text: // This is (almost) directly from Node.js assert
  // https://github.com/joyent/node/blob/f8c335d0caf47f16d31413f89aa28eda3878e3aa/lib/assert.js
  
  module.exports = _deepEqual;
  
  var getEnumerableProperties = require('./getEnumerableProperties');
  
  // for the browser
  var Buffer;
  try {
    Buffer = require('buffer').Buffer;
  } catch (ex) {
    Buffer = {
      isBuffer: function () { return false; }
    };
  }
  
  function _deepEqual(actual, expected, memos) {
  
    // 7.1. All identical values are equivalent, as determined by ===.
    if (actual === expected) {
      return true;
  
    } else if (Buffer.isBuffer(actual) && Buffer.isBuffer(expected)) {
      if (actual.length != expected.length) return false;
  
      for (var i = 0; i < actual.length; i++) {
        if (actual[i] !== expected[i]) return false;
      }
  
      return true;
  
    // 7.2. If the expected value is a Date object, the actual value is
    // equivalent if it is also a Date object that refers to the same time.
    } else if (expected instanceof Date) {
      if (!(actual instanceof Date)) return false;
      return actual.getTime() === expected.getTime();
  
    // 7.3. Other pairs that do not both pass typeof value == 'object',
    // equivalence is determined by ==.
    } else if (typeof actual != 'object' && typeof expected != 'object') {
      return actual === expected;
  
    } else if (expected instanceof RegExp) {
      if (!(actual instanceof RegExp)) return false;
      return actual.toString() === expected.toString();
  
    // 7.4. For all other Object pairs, including Array objects, equivalence is
    // determined by having the same number of owned properties (as verified
    // with Object.prototype.hasOwnProperty.call), the same set of keys
    // (although not necessarily the same order), equivalent values for every
    // corresponding key, and an identical 'prototype' property. Note: this
    // accounts for both named and indexed properties on Arrays.
    } else {
      return objEquiv(actual, expected, memos);
    }
  }
  
  function isUndefinedOrNull(value) {
    return value === null || value === undefined;
  }
  
  function isArguments(object) {
    return Object.prototype.toString.call(object) == '[object Arguments]';
  }
  
  function objEquiv(a, b, memos) {
    if (isUndefinedOrNull(a) || isUndefinedOrNull(b))
      return false;
  
    // an identical 'prototype' property.
    if (a.prototype !== b.prototype) return false;
  
    // check if we have already compared a and b
    var i;
    if (memos) {
      for(i = 0; i < memos.length; i++) {
        if ((memos[i][0] === a && memos[i][1] === b) ||
            (memos[i][0] === b && memos[i][1] === a))
          return true;
      }
    } else {
      memos = [];
    }
  
    //~~~I've managed to break Object.keys through screwy arguments passing.
    //   Converting to array solves the problem.
    if (isArguments(a)) {
      if (!isArguments(b)) {
        return false;
      }
      a = pSlice.call(a);
      b = pSlice.call(b);
      return _deepEqual(a, b, memos);
    }
    try {
      var ka = getEnumerableProperties(a),
          kb = getEnumerableProperties(b),
          key;
    } catch (e) {//happens when one is a string literal and the other isn't
      return false;
    }
  
    // having the same number of owned properties (keys incorporates
    // hasOwnProperty)
    if (ka.length != kb.length)
      return false;
  
    //the same set of keys (although not necessarily the same order),
    ka.sort();
    kb.sort();
    //~~~cheap key test
    for (i = ka.length - 1; i >= 0; i--) {
      if (ka[i] != kb[i])
        return false;
    }
  
    // remember objects we have compared to guard against circular references
    memos.push([ a, b ]);
  
    //equivalent values for every corresponding key, and
    //~~~possibly expensive deep test
    for (i = ka.length - 1; i >= 0; i--) {
      key = ka[i];
      if (!_deepEqual(a[key], b[key], memos)) return false;
    }
  
    return true;
  }
  