fast-equals 1.6.0 → 2.0.0

package/dist/fast-equals.js

@@ -1,26 +1,433 @@
 (function (global, factory) {
   typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
   typeof define === 'function' && define.amd ? define(['exports'], factory) :
-  (factory((global.fe = {})));
-}(this, (function (exports) { 'use strict';
+  (global = global || self, factory(global['fast-equals'] = {}));
+}(this, function (exports) { 'use strict';
 
-  var HAS_MAP_SUPPORT='function'==typeof Map;var HAS_SET_SUPPORT='function'==typeof Set;var HAS_WEAKSET_SUPPORT='function'==typeof WeakSet;
+  var HAS_WEAKSET_SUPPORT = typeof WeakSet === 'function';
+  var keys = Object.keys;
+  /**
+   * @function addToCache
+   *
+   * add object to cache if an object
+   *
+   * @param value the value to potentially add to cache
+   * @param cache the cache to add to
+   */
+  function addToCache(value, cache) {
+      if (value && typeof value === 'object') {
+          cache.add(value);
+      }
+  }
+  /**
+   * @function hasPair
+   *
+   * @description
+   * does the `pairToMatch` exist in the list of `pairs` provided based on the
+   * `isEqual` check
+   *
+   * @param pairs the pairs to compare against
+   * @param pairToMatch the pair to match
+   * @param isEqual the equality comparator used
+   * @param meta the meta provided
+   * @returns does the pair exist in the pairs provided
+   */
+  function hasPair(pairs, pairToMatch, isEqual, meta) {
+      var length = pairs.length;
+      var pair;
+      for (var index = 0; index < length; index++) {
+          pair = pairs[index];
+          if (isEqual(pair[0], pairToMatch[0], meta) &&
+              isEqual(pair[1], pairToMatch[1], meta)) {
+              return true;
+          }
+      }
+      return false;
+  }
+  /**
+   * @function hasValue
+   *
+   * @description
+   * does the `valueToMatch` exist in the list of `values` provided based on the
+   * `isEqual` check
+   *
+   * @param values the values to compare against
+   * @param valueToMatch the value to match
+   * @param isEqual the equality comparator used
+   * @param meta the meta provided
+   * @returns does the value exist in the values provided
+   */
+  function hasValue(values, valueToMatch, isEqual, meta) {
+      var length = values.length;
+      for (var index = 0; index < length; index++) {
+          if (isEqual(values[index], valueToMatch, meta)) {
+              return true;
+          }
+      }
+      return false;
+  }
+  /**
+   * @function sameValueZeroEqual
+   *
+   * @description
+   * are the values passed strictly equal or both NaN
+   *
+   * @param a the value to compare against
+   * @param b the value to test
+   * @returns are the values equal by the SameValueZero principle
+   */
+  function sameValueZeroEqual(a, b) {
+      return a === b || (a !== a && b !== b);
+  }
+  /**
+   * @function isPlainObject
+   *
+   * @description
+   * is the value a plain object
+   *
+   * @param value the value to test
+   * @returns is the value a plain object
+   */
+  function isPlainObject(value) {
+      return value.constructor === Object || value.constructor == null;
+  }
+  /**
+   * @function isPromiseLike
+   *
+   * @description
+   * is the value promise-like (meaning it is thenable)
+   *
+   * @param value the value to test
+   * @returns is the value promise-like
+   */
+  function isPromiseLike(value) {
+      return !!value && typeof value.then === 'function';
+  }
+  /**
+   * @function isReactElement
+   *
+   * @description
+   * is the value passed a react element
+   *
+   * @param value the value to test
+   * @returns is the value a react element
+   */
+  function isReactElement(value) {
+      return !!(value && value.$$typeof);
+  }
+  /**
+   * @function getNewCacheFallback
+   *
+   * @description
+   * in cases where WeakSet is not supported, creates a new custom
+   * object that mimics the necessary API aspects for cache purposes
+   *
+   * @returns the new cache object
+   */
+  function getNewCacheFallback() {
+      return Object.create({
+          _values: [],
+          add: function (value) {
+              this._values.push(value);
+          },
+          has: function (value) {
+              return this._values.indexOf(value) !== -1;
+          },
+      });
+  }
+  /**
+   * @function getNewCache
+   *
+   * @description
+   * get a new cache object to prevent circular references
+   *
+   * @returns the new cache object
+   */
+  var getNewCache = (function (canUseWeakMap) {
+      if (canUseWeakMap) {
+          return function _getNewCache() {
+              return new WeakSet();
+          };
+      }
+      return getNewCacheFallback;
+  })(HAS_WEAKSET_SUPPORT);
+  /**
+   * @function createCircularEqualCreator
+   *
+   * @description
+   * create a custom isEqual handler specific to circular objects
+   *
+   * @param [isEqual] the isEqual comparator to use instead of isDeepEqual
+   * @returns the method to create the `isEqual` function
+   */
+  function createCircularEqualCreator(isEqual) {
+      return function createCircularEqual(comparator) {
+          var _comparator = isEqual || comparator;
+          return function circularEqual(a, b, cache) {
+              if (cache === void 0) { cache = getNewCache(); }
+              var hasA = cache.has(a);
+              var hasB = cache.has(b);
+              if (hasA || hasB) {
+                  return hasA && hasB;
+              }
+              addToCache(a, cache);
+              addToCache(b, cache);
+              return _comparator(a, b, cache);
+          };
+      };
+  }
+  /**
+   * @function toPairs
+   *
+   * @description
+   * convert the map passed into pairs (meaning an array of [key, value] tuples)
+   *
+   * @param map the map to convert to [key, value] pairs (entries)
+   * @returns the [key, value] pairs
+   */
+  function toPairs(map) {
+      var pairs = new Array(map.size);
+      var index = 0;
+      map.forEach(function (value, key) {
+          pairs[index++] = [key, value];
+      });
+      return pairs;
+  }
+  /**
+   * @function toValues
+   *
+   * @description
+   * convert the set passed into values
+   *
+   * @param set the set to convert to values
+   * @returns the values
+   */
+  function toValues(set) {
+      var values = new Array(set.size);
+      var index = 0;
+      set.forEach(function (value) {
+          values[index++] = value;
+      });
+      return values;
+  }
+  /**
+   * @function areArraysEqual
+   *
+   * @description
+   * are the arrays equal in value
+   *
+   * @param a the array to test
+   * @param b the array to test against
+   * @param isEqual the comparator to determine equality
+   * @param meta the meta object to pass through
+   * @returns are the arrays equal
+   */
+  function areArraysEqual(a, b, isEqual, meta) {
+      var length = a.length;
+      if (b.length !== length) {
+          return false;
+      }
+      for (var index = 0; index < length; index++) {
+          if (!isEqual(a[index], b[index], meta)) {
+              return false;
+          }
+      }
+      return true;
+  }
+  /**
+   * @function areMapsEqual
+   *
+   * @description
+   * are the maps equal in value
+   *
+   * @param a the map to test
+   * @param b the map to test against
+   * @param isEqual the comparator to determine equality
+   * @param meta the meta map to pass through
+   * @returns are the maps equal
+   */
+  function areMapsEqual(a, b, isEqual, meta) {
+      if (a.size !== b.size) {
+          return false;
+      }
+      var pairsA = toPairs(a);
+      var pairsB = toPairs(b);
+      var length = pairsA.length;
+      for (var index = 0; index < length; index++) {
+          if (!hasPair(pairsB, pairsA[index], isEqual, meta) ||
+              !hasPair(pairsA, pairsB[index], isEqual, meta)) {
+              return false;
+          }
+      }
+      return true;
+  }
+  var OWNER = '_owner';
+  var hasOwnProperty = Function.prototype.bind.call(Function.prototype.call, Object.prototype.hasOwnProperty);
+  /**
+   * @function areObjectsEqual
+   *
+   * @description
+   * are the objects equal in value
+   *
+   * @param a the object to test
+   * @param b the object to test against
+   * @param isEqual the comparator to determine equality
+   * @param meta the meta object to pass through
+   * @returns are the objects equal
+   */
+  function areObjectsEqual(a, b, isEqual, meta) {
+      var keysA = keys(a);
+      var length = keysA.length;
+      if (keys(b).length !== length) {
+          return false;
+      }
+      var key;
+      for (var index = 0; index < length; index++) {
+          key = keysA[index];
+          if (!hasOwnProperty(b, key)) {
+              return false;
+          }
+          if (key === OWNER && isReactElement(a)) {
+              if (!isReactElement(b)) {
+                  return false;
+              }
+          }
+          else if (!isEqual(a[key], b[key], meta)) {
+              return false;
+          }
+      }
+      return true;
+  }
+  /**
+   * @function areRegExpsEqual
+   *
+   * @description
+   * are the regExps equal in value
+   *
+   * @param a the regExp to test
+   * @param b the regExp to test agains
+   * @returns are the regExps equal
+   */
+  function areRegExpsEqual(a, b) {
+      return (a.source === b.source &&
+          a.global === b.global &&
+          a.ignoreCase === b.ignoreCase &&
+          a.multiline === b.multiline &&
+          a.unicode === b.unicode &&
+          a.sticky === b.sticky &&
+          a.lastIndex === b.lastIndex);
+  }
+  /**
+   * @function areSetsEqual
+   *
+   * @description
+   * are the sets equal in value
+   *
+   * @param a the set to test
+   * @param b the set to test against
+   * @param isEqual the comparator to determine equality
+   * @param meta the meta set to pass through
+   * @returns are the sets equal
+   */
+  function areSetsEqual(a, b, isEqual, meta) {
+      if (a.size !== b.size) {
+          return false;
+      }
+      var valuesA = toValues(a);
+      var valuesB = toValues(b);
+      var length = valuesA.length;
+      for (var index = 0; index < length; index++) {
+          if (!hasValue(valuesB, valuesA[index], isEqual, meta) ||
+              !hasValue(valuesA, valuesB[index], isEqual, meta)) {
+              return false;
+          }
+      }
+      return true;
+  }
 
-  var keys=Object.keys;var addObjectToCache=function(a,b){return a&&'object'==typeof a&&b.add(a)};var hasItem=function(a,b,c,d){for(var e=0;e<a.length;e++)if(c(a[e],b,d))return !0;return !1};var hasItems=function(a,b,c,d){if(a.length!==b.length)return !1;for(var e=0;e<a.length;e++)if(!hasItem(b,a[e],c,d))return !1;return !0};var sameValueZeroEqual=function(a,b){return a===b||a!==a&&b!==b};var isPlainObject=function(a){return a.constructor===Object};var isPromiseLike=function(a){return 'function'==typeof a.then};var isReactElement=function(a){return !!(a.$$typeof&&a._store)};var getNewCache=function(){return HAS_WEAKSET_SUPPORT?new WeakSet:Object.create({_values:[],add:function b(a){this._values.push(a);},has:function b(a){return !!~this._values.indexOf(a)}})};var createCircularEqual=function(a){return function(b){return function(c,d){var e=2<arguments.length&&void 0!==arguments[2]?arguments[2]:getNewCache(),f=e.has(c),g=e.has(d);return f||g?f&&g:(addObjectToCache(c,e),addObjectToCache(d,e),(a||b)(c,d,e))}}};var toPairs=function(a){var b={keys:[],values:[]};return a.forEach(function(a,c){return b.keys.push(c)&&b.values.push(a)}),b};var areArraysEqual=function(a,b,c,d){if(a.length!==b.length)return !1;for(var e=0;e<a.length;e++)if(!c(a[e],b[e],d))return !1;return !0};var createAreIterablesEqual=function(a){var b=a?function(a,b,c,d){return hasItems(a.keys,b.keys,c,d)&&hasItems(a.values,b.values,c,d)}:function(a,b,c,d){return hasItems(a.values,b.values,c,d)};return function(a,c,d,e){return b(toPairs(a),toPairs(c),d,e)}};var areObjectsEqual=function(a,b,c,d){var e=keys(a),f=keys(b);if(e.length!==f.length)return !1;for(var g=void 0,h=0;h<e.length;h++){if(g=e[h],!hasItem(f,g,sameValueZeroEqual))return !1;if(!('_owner'===g&&isReactElement(a)&&isReactElement(b))&&!c(a[g],b[g],d))return !1}return !0};var areRegExpsEqual=function(a,b){return a.source===b.source&&a.global===b.global&&a.ignoreCase===b.ignoreCase&&a.multiline===b.multiline&&a.unicode===b.unicode&&a.sticky===b.sticky&&a.lastIndex===b.lastIndex};
+  var isArray = Array.isArray;
+  var HAS_MAP_SUPPORT = typeof Map === 'function';
+  var HAS_SET_SUPPORT = typeof Set === 'function';
+  var OBJECT_TYPEOF = 'object';
+  function createComparator(createIsEqual) {
+      var isEqual = 
+      /* eslint-disable no-use-before-define */
+      typeof createIsEqual === 'function'
+          ? createIsEqual(comparator)
+          : comparator;
+      /* eslint-enable */
+      /**
+       * @function comparator
+       *
+       * @description
+       * compare the value of the two objects and return true if they are equivalent in values
+       *
+       * @param a the value to test against
+       * @param b the value to test
+       * @param [meta] an optional meta object that is passed through to all equality test calls
+       * @returns are a and b equivalent in value
+       */
+      function comparator(a, b, meta) {
+          if (sameValueZeroEqual(a, b)) {
+              return true;
+          }
+          if (a && b && typeof a === OBJECT_TYPEOF && typeof b === OBJECT_TYPEOF) {
+              if (isPlainObject(a) && isPlainObject(b)) {
+                  return areObjectsEqual(a, b, isEqual, meta);
+              }
+              var arrayA = isArray(a);
+              var arrayB = isArray(b);
+              if (arrayA || arrayB) {
+                  return arrayA === arrayB && areArraysEqual(a, b, isEqual, meta);
+              }
+              var aDate = a instanceof Date;
+              var bDate = b instanceof Date;
+              if (aDate || bDate) {
+                  return aDate === bDate && sameValueZeroEqual(a.getTime(), b.getTime());
+              }
+              var aRegExp = a instanceof RegExp;
+              var bRegExp = b instanceof RegExp;
+              if (aRegExp || bRegExp) {
+                  return aRegExp === bRegExp && areRegExpsEqual(a, b);
+              }
+              if (isPromiseLike(a) || isPromiseLike(b)) {
+                  return a === b;
+              }
+              if (HAS_MAP_SUPPORT) {
+                  var aMap = a instanceof Map;
+                  var bMap = b instanceof Map;
+                  if (aMap || bMap) {
+                      return aMap === bMap && areMapsEqual(a, b, isEqual, meta);
+                  }
+              }
+              if (HAS_SET_SUPPORT) {
+                  var aSet = a instanceof Set;
+                  var bSet = b instanceof Set;
+                  if (aSet || bSet) {
+                      return aSet === bSet && areSetsEqual(a, b, isEqual, meta);
+                  }
+              }
+              return areObjectsEqual(a, b, isEqual, meta);
+          }
+          return false;
+      }
+      return comparator;
+  }
 
-  var isArray=Array.isArray,areMapsEqual=createAreIterablesEqual(!0),areSetsEqual=createAreIterablesEqual(!1),createComparator=function(a){function b(a,b,d){if(sameValueZeroEqual(a,b))return !0;var e=typeof a;if(e!=typeof b||'object'!=e||!a||!b)return !1;if(isPlainObject(a)&&isPlainObject(b))return areObjectsEqual(a,b,c,d);var f=isArray(a),g=isArray(b);if(f||g)return f===g&&areArraysEqual(a,b,c,d);var h=a instanceof Date,i=b instanceof Date;if(h||i)return h==i&&sameValueZeroEqual(a.getTime(),b.getTime());var j=a instanceof RegExp,k=b instanceof RegExp;if(j||k)return j==k&&areRegExpsEqual(a,b);if(isPromiseLike(a)||isPromiseLike(b))return a===b;if(HAS_MAP_SUPPORT){var l=a instanceof Map,m=b instanceof Map;if(l||m)return l==m&&areMapsEqual(a,b,c,d)}if(HAS_SET_SUPPORT){var n=a instanceof Set,o=b instanceof Set;if(n||o)return n==o&&areSetsEqual(a,b,c,d)}return areObjectsEqual(a,b,c,d)}var c='function'==typeof a?a(b):b;return b};
+  // comparator
+  var deepEqual = createComparator();
+  var shallowEqual = createComparator(function () { return sameValueZeroEqual; });
+  var circularDeepEqual = createComparator(createCircularEqualCreator());
+  var circularShallowEqual = createComparator(createCircularEqualCreator(sameValueZeroEqual));
 
-  var circularDeepEqual=createComparator(createCircularEqual());var circularShallowEqual=createComparator(createCircularEqual(sameValueZeroEqual));var deepEqual=createComparator();var shallowEqual=createComparator(function(){return sameValueZeroEqual});var index = {circularDeep:circularDeepEqual,circularShallow:circularShallowEqual,createCustom:createComparator,deep:deepEqual,sameValueZero:sameValueZeroEqual,shallow:shallowEqual};
-
-  exports.createCustomEqual = createComparator;
-  exports.sameValueZeroEqual = sameValueZeroEqual;
   exports.circularDeepEqual = circularDeepEqual;
   exports.circularShallowEqual = circularShallowEqual;
+  exports.createCustomEqual = createComparator;
   exports.deepEqual = deepEqual;
+  exports.sameValueZeroEqual = sameValueZeroEqual;
   exports.shallowEqual = shallowEqual;
-  exports.default = index;
 
   Object.defineProperty(exports, '__esModule', { value: true });
 
-})));
+}));
 //# sourceMappingURL=fast-equals.js.map

package/dist/fast-equals.js.map

@@ -1 +1 @@
-{"version":3,"file":"fast-equals.js","sources":["../src/constants.js","../src/utils.js","../src/comparator.js","../src/index.js"],"sourcesContent":["/**\n * @constant {boolean} HAS_MAP_SUPPORT\n */\nexport const HAS_MAP_SUPPORT = typeof Map === 'function';\n\n/**\n * @constant {boolean} HAS_SET_SUPPORT\n */\nexport const HAS_SET_SUPPORT = typeof Set === 'function';\n\n/**\n * @constant {boolean} HAS_WEAKSET_SUPPORT\n */\nexport const HAS_WEAKSET_SUPPORT = typeof WeakSet === 'function';\n","// constants\nimport {HAS_WEAKSET_SUPPORT} from './constants';\n\nconst keys = Object.keys;\n\n/**\n * @function addObjectToCache\n *\n * @description\n * add object to cache if it is indeed an object\n *\n * @param {any} object the object to potentially add to the cache\n * @param {Object|WeakSet} cache the cache to add to\n * @returns {void}\n */\nexport const addObjectToCache = (object, cache) => object && typeof object === 'object' && cache.add(object);\n\n/**\n * @function hasItem\n *\n * @description\n * does the array include the item passed\n *\n * @param {Array<any>} array the array to check in\n * @param {any} item the item to locate\n * @param {function} isEqual the equality comparator\n * @param {any} meta the meta item to pass through\n * @returns {boolean} does the item exist in the array\n */\nexport const hasItem = (array, item, isEqual, meta) => {\n  for (let index = 0; index < array.length; index++) {\n    if (isEqual(array[index], item, meta)) {\n      return true;\n    }\n  }\n\n  return false;\n};\n\n/**\n * @function hasItems\n *\n * @description\n * are the arrays equal in value, despite being in different order\n *\n * @param {Array<any>} arrayA the first array to test\n * @param {Array<any>} arrayB the second array to test\n * @param {function} isEqual the equality comparator\n * @param {any} meta the meta item to pass through\n * @returns {boolean} are the arrays equal absent order\n */\nexport const hasItems = (arrayA, arrayB, isEqual, meta) => {\n  if (arrayA.length !== arrayB.length) {\n    return false;\n  }\n\n  for (let index = 0; index < arrayA.length; index++) {\n    if (!hasItem(arrayB, arrayA[index], isEqual, meta)) {\n      return false;\n    }\n  }\n\n  return true;\n};\n\n/**\n * @function sameValueZeroEqual\n *\n * @description\n * are the objects passed strictly equal or both NaN\n *\n * @param {any} objectA the object to compare against\n * @param {any} objectB the object to test\n * @returns {boolean} are the objects equal by the SameValueZero principle\n */\nexport const sameValueZeroEqual = (objectA, objectB) =>\n  objectA === objectB || (objectA !== objectA && objectB !== objectB);\n\n/**\n * @function isPlainObject\n *\n * @description\n * is the object a plain object\n *\n * @param {any} object the object to test\n * @returns {boolean} is the object a plain object\n */\nexport const isPlainObject = (object) => object.constructor === Object;\n\n/**\n * @function isPromiseLike\n *\n * @description\n * is the object promise-like (thenable)\n *\n * @param {any} object the object to test\n * @returns {boolean} is the object promise-like\n */\nexport const isPromiseLike = (object) => typeof object.then === 'function';\n\n/**\n * @function isReactElement\n *\n * @description\n * is the object passed a react element\n *\n * @param {any} object the object to test\n * @returns {boolean} is the object a react element\n */\nexport const isReactElement = (object) => !!(object.$$typeof && object._store);\n\n/**\n * @function getNewCache\n *\n * @description\n * get a new cache object to prevent circular references\n *\n * @returns {Object|Weakset} the new cache object\n */\nexport const getNewCache = () =>\n  HAS_WEAKSET_SUPPORT\n    ? new WeakSet()\n    : Object.create({\n      _values: [],\n      add(value) {\n        this._values.push(value);\n      },\n      has(value) {\n        return !!~this._values.indexOf(value);\n      },\n    });\n\n/**\n * @function createCircularEqual\n *\n * @description\n * create a custom isEqual handler specific to circular objects\n *\n * @param {funtion} [isEqual] the isEqual comparator to use instead of isDeepEqual\n * @returns {function(any, any): boolean}\n */\nexport const createCircularEqual = (isEqual) => (isDeepEqual) => {\n  const comparator = isEqual || isDeepEqual;\n\n  return (objectA, objectB, cache = getNewCache()) => {\n    const cacheHasA = cache.has(objectA);\n    const cacheHasB = cache.has(objectB);\n\n    if (cacheHasA || cacheHasB) {\n      return cacheHasA && cacheHasB;\n    }\n\n    addObjectToCache(objectA, cache);\n    addObjectToCache(objectB, cache);\n\n    return comparator(objectA, objectB, cache);\n  };\n};\n\n/**\n * @function toPairs\n *\n * @param {Map|Set} iterable the iterable to convert to [key, value] pairs (entries)\n * @returns {{keys: Array<*>, values: Array<*>}} the [key, value] pairs\n */\nexport const toPairs = (iterable) => {\n  const pairs = {\n    keys: [],\n    values: [],\n  };\n\n  iterable.forEach((value, key) => pairs.keys.push(key) && pairs.values.push(value));\n\n  return pairs;\n};\n\n/**\n * @function areArraysEqual\n *\n * @description\n * are the arrays equal in value\n *\n * @param {Array<any>} arrayA the array to test\n * @param {Array<any>} arrayB the array to test against\n * @param {function} isEqual the comparator to determine equality\n * @param {any} meta the meta object to pass through\n * @returns {boolean} are the arrays equal\n */\nexport const areArraysEqual = (arrayA, arrayB, isEqual, meta) => {\n  if (arrayA.length !== arrayB.length) {\n    return false;\n  }\n\n  for (let index = 0; index < arrayA.length; index++) {\n    if (!isEqual(arrayA[index], arrayB[index], meta)) {\n      return false;\n    }\n  }\n\n  return true;\n};\n\nexport const createAreIterablesEqual = (shouldCompareKeys) => {\n  /**\n   * @function areIterablesEqual\n   *\n   * @description\n   * determine if the iterables are equivalent in value\n   *\n   * @param {Array<Array<any>>} pairsA the pairs to test\n   * @param {Array<Array<any>>} pairsB the pairs to test against\n   * @param {function} isEqual the comparator to determine equality\n   * @param {any} meta the cache possibly being used\n   * @returns {boolean} are the objects equal in value\n   */\n  const areIterablesEqual = shouldCompareKeys\n    ? (pairsA, pairsB, isEqual, meta) =>\n      hasItems(pairsA.keys, pairsB.keys, isEqual, meta) && hasItems(pairsA.values, pairsB.values, isEqual, meta)\n    : (pairsA, pairsB, isEqual, meta) => hasItems(pairsA.values, pairsB.values, isEqual, meta);\n\n  return (iterableA, iterableB, isEqual, meta) =>\n    areIterablesEqual(toPairs(iterableA), toPairs(iterableB), isEqual, meta);\n};\n\n/**\n * @function areArraysEqual\n *\n * @description\n * are the objects equal in value\n *\n * @param {Array<any>} objectA the object to test\n * @param {Array<any>} objectB the object to test against\n * @param {function} isEqual the comparator to determine equality\n * @param {any} meta the meta object to pass through\n * @returns {boolean} are the objects equal\n */\nexport const areObjectsEqual = (objectA, objectB, isEqual, meta) => {\n  const keysA = keys(objectA);\n  const keysB = keys(objectB);\n\n  if (keysA.length !== keysB.length) {\n    return false;\n  }\n\n  let key;\n\n  for (let index = 0; index < keysA.length; index++) {\n    key = keysA[index];\n\n    if (!hasItem(keysB, key, sameValueZeroEqual)) {\n      return false;\n    }\n\n    // if a react element, ignore the \"_owner\" key because its not necessary for equality comparisons\n    if (key === '_owner' && isReactElement(objectA) && isReactElement(objectB)) {\n      continue;\n    }\n\n    if (!isEqual(objectA[key], objectB[key], meta)) {\n      return false;\n    }\n  }\n\n  return true;\n};\n\n/**\n * @function areRegExpsEqual\n *\n * @description\n * are the regExps equal in value\n *\n * @param {RegExp} regExpA the regExp to test\n * @param {RegExp} regExpB the regExp to test agains\n * @returns {boolean} are the regExps equal\n */\nexport const areRegExpsEqual = (regExpA, regExpB) =>\n  regExpA.source === regExpB.source\n  && regExpA.global === regExpB.global\n  && regExpA.ignoreCase === regExpB.ignoreCase\n  && regExpA.multiline === regExpB.multiline\n  && regExpA.unicode === regExpB.unicode\n  && regExpA.sticky === regExpB.sticky\n  && regExpA.lastIndex === regExpB.lastIndex;\n","// constants\nimport {\n  HAS_MAP_SUPPORT,\n  HAS_SET_SUPPORT\n} from './constants';\n\n// utils\nimport {\n  areArraysEqual,\n  areObjectsEqual,\n  areRegExpsEqual,\n  createAreIterablesEqual,\n  isPlainObject,\n  isPromiseLike,\n  isReactElement,\n  sameValueZeroEqual\n} from './utils';\n\nconst isArray = Array.isArray;\n\nconst areMapsEqual = createAreIterablesEqual(true);\nconst areSetsEqual = createAreIterablesEqual(false);\n\nconst createComparator = (createIsEqual) => {\n  // eslint-disable-next-line no-use-before-define\n  const isEqual = typeof createIsEqual === 'function' ? createIsEqual(comparator) : comparator;\n\n  /**\n   * @function comparator\n   *\n   * @description\n   * compare the value of the two objects and return true if they are equivalent in values\n   *\n   * @param {any} objectA the object to test against\n   * @param {any} objectB the object to test\n   * @param {any} [meta] an optional meta object that is passed through to all equality test calls\n   * @returns {boolean} are objectA and objectB equivalent in value\n   */\n  function comparator(objectA, objectB, meta) {\n    if (sameValueZeroEqual(objectA, objectB)) {\n      return true;\n    }\n\n    const typeOfA = typeof objectA;\n\n    if (typeOfA !== typeof objectB || typeOfA !== 'object' || !objectA || !objectB) {\n      return false;\n    }\n\n    if (isPlainObject(objectA) && isPlainObject(objectB)) {\n      return areObjectsEqual(objectA, objectB, isEqual, meta);\n    }\n\n    const arrayA = isArray(objectA);\n    const arrayB = isArray(objectB);\n\n    if (arrayA || arrayB) {\n      return arrayA === arrayB && areArraysEqual(objectA, objectB, isEqual, meta);\n    }\n\n    const dateA = objectA instanceof Date;\n    const dateB = objectB instanceof Date;\n\n    if (dateA || dateB) {\n      return dateA === dateB && sameValueZeroEqual(objectA.getTime(), objectB.getTime());\n    }\n\n    const regexpA = objectA instanceof RegExp;\n    const regexpB = objectB instanceof RegExp;\n\n    if (regexpA || regexpB) {\n      return regexpA === regexpB && areRegExpsEqual(objectA, objectB);\n    }\n\n    if (isPromiseLike(objectA) || isPromiseLike(objectB)) {\n      return objectA === objectB;\n    }\n\n    if (HAS_MAP_SUPPORT) {\n      const mapA = objectA instanceof Map;\n      const mapB = objectB instanceof Map;\n\n      if (mapA || mapB) {\n        return mapA === mapB && areMapsEqual(objectA, objectB, isEqual, meta);\n      }\n    }\n\n    if (HAS_SET_SUPPORT) {\n      const setA = objectA instanceof Set;\n      const setB = objectB instanceof Set;\n\n      if (setA || setB) {\n        return setA === setB && areSetsEqual(objectA, objectB, isEqual, meta);\n      }\n    }\n\n    return areObjectsEqual(objectA, objectB, isEqual, meta);\n  }\n\n  return comparator;\n};\n\nexport default createComparator;\n","// comparator\nimport createCustomEqual from './comparator';\n\n// utils\nimport {\n  createCircularEqual,\n  sameValueZeroEqual\n} from './utils';\n\nexport {\n  createCustomEqual, sameValueZeroEqual\n};\n\nexport const circularDeepEqual = createCustomEqual(createCircularEqual());\nexport const circularShallowEqual = createCustomEqual(createCircularEqual(sameValueZeroEqual));\nexport const deepEqual = createCustomEqual();\nexport const shallowEqual = createCustomEqual(() => sameValueZeroEqual);\n\nexport default {\n  circularDeep: circularDeepEqual,\n  circularShallow: circularShallowEqual,\n  createCustom: createCustomEqual,\n  deep: deepEqual,\n  sameValueZero: sameValueZeroEqual,\n  shallow: shallowEqual,\n};\n"],"names":["Object","keys","object","cache","add","array","item","isEqual","meta","index","length","arrayA","arrayB","hasItem","sameValueZeroEqual","objectA","objectB","constructor","then","$$typeof","_store","create","_values","value","push","has","indexOf","isDeepEqual","getNewCache","cacheHasA","cacheHasB","addObjectToCache","iterable","values","forEach","key","pairs","shouldCompareKeys","pairsA","pairsB","hasItems","iterableA","iterableB","toPairs","keysB","keysA","isReactElement","regExpA","regExpB","source","global","ignoreCase","multiline","unicode","sticky","lastIndex","Array","isArray","areMapsEqual","createAreIterablesEqual","areSetsEqual","createComparator","createIsEqual","typeOfA","isPlainObject","areArraysEqual","dateB","dateA","getTime","regexpB","regexpA","areRegExpsEqual","isPromiseLike","HAS_MAP_SUPPORT","mapB","mapA","HAS_SET_SUPPORT","setB","setA","comparator","circularDeepEqual","createCustomEqual","createCircularEqual","circularShallowEqual","deepEqual","shallowEqual","circularDeep","circularShallow","createCustom","deep","sameValueZero","shallow"],"mappings":"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"}
+{"version":3,"file":"fast-equals.js","sources":["../src/utils.ts","../src/comparator.ts","../src/index.ts"],"sourcesContent":["const HAS_WEAKSET_SUPPORT = typeof WeakSet === 'function';\n\nconst { keys } = Object;\n\ntype Cache = {\n  add: (value: any) => void;\n  has: (value: any) => boolean;\n};\n\n/**\n * @function addToCache\n *\n * add object to cache if an object\n *\n * @param value the value to potentially add to cache\n * @param cache the cache to add to\n */\nexport function addToCache(value: any, cache: Cache) {\n  if (value && typeof value === 'object') {\n    cache.add(value);\n  }\n}\n\nexport type EqualityComparator = (a: any, b: any, meta?: any) => boolean;\n\n/**\n * @function hasPair\n *\n * @description\n * does the `pairToMatch` exist in the list of `pairs` provided based on the\n * `isEqual` check\n *\n * @param pairs the pairs to compare against\n * @param pairToMatch the pair to match\n * @param isEqual the equality comparator used\n * @param meta the meta provided\n * @returns does the pair exist in the pairs provided\n */\nexport function hasPair(\n  pairs: [any, any][],\n  pairToMatch: [any, any],\n  isEqual: EqualityComparator,\n  meta: any,\n) {\n  const { length } = pairs;\n\n  let pair: [any, any];\n\n  for (let index = 0; index < length; index++) {\n    pair = pairs[index];\n\n    if (\n      isEqual(pair[0], pairToMatch[0], meta) &&\n      isEqual(pair[1], pairToMatch[1], meta)\n    ) {\n      return true;\n    }\n  }\n\n  return false;\n}\n\n/**\n * @function hasValue\n *\n * @description\n * does the `valueToMatch` exist in the list of `values` provided based on the\n * `isEqual` check\n *\n * @param values the values to compare against\n * @param valueToMatch the value to match\n * @param isEqual the equality comparator used\n * @param meta the meta provided\n * @returns does the value exist in the values provided\n */\nexport function hasValue(\n  values: any[],\n  valueToMatch: any,\n  isEqual: EqualityComparator,\n  meta: any,\n) {\n  const { length } = values;\n\n  for (let index = 0; index < length; index++) {\n    if (isEqual(values[index], valueToMatch, meta)) {\n      return true;\n    }\n  }\n\n  return false;\n}\n\n/**\n * @function sameValueZeroEqual\n *\n * @description\n * are the values passed strictly equal or both NaN\n *\n * @param a the value to compare against\n * @param b the value to test\n * @returns are the values equal by the SameValueZero principle\n */\nexport function sameValueZeroEqual(a: any, b: any) {\n  return a === b || (a !== a && b !== b);\n}\n\n/**\n * @function isPlainObject\n *\n * @description\n * is the value a plain object\n *\n * @param value the value to test\n * @returns is the value a plain object\n */\nexport function isPlainObject(value: any) {\n  return value.constructor === Object || value.constructor == null;\n}\n\n/**\n * @function isPromiseLike\n *\n * @description\n * is the value promise-like (meaning it is thenable)\n *\n * @param value the value to test\n * @returns is the value promise-like\n */\nexport function isPromiseLike(value: any) {\n  return !!value && typeof value.then === 'function';\n}\n\n/**\n * @function isReactElement\n *\n * @description\n * is the value passed a react element\n *\n * @param value the value to test\n * @returns is the value a react element\n */\nexport function isReactElement(value: any) {\n  return !!(value && value.$$typeof);\n}\n\n/**\n * @function getNewCacheFallback\n *\n * @description\n * in cases where WeakSet is not supported, creates a new custom\n * object that mimics the necessary API aspects for cache purposes\n *\n * @returns the new cache object\n */\nexport function getNewCacheFallback(): Cache {\n  return Object.create({\n    _values: [],\n\n    add(value: any) {\n      this._values.push(value);\n    },\n\n    has(value: any) {\n      return this._values.indexOf(value) !== -1;\n    },\n  });\n}\n\n/**\n * @function getNewCache\n *\n * @description\n * get a new cache object to prevent circular references\n *\n * @returns the new cache object\n */\nexport const getNewCache = ((canUseWeakMap: boolean) => {\n  if (canUseWeakMap) {\n    return function _getNewCache(): Cache {\n      return new WeakSet();\n    };\n  }\n\n  return getNewCacheFallback;\n})(HAS_WEAKSET_SUPPORT);\n\n/**\n * @function createCircularEqualCreator\n *\n * @description\n * create a custom isEqual handler specific to circular objects\n *\n * @param [isEqual] the isEqual comparator to use instead of isDeepEqual\n * @returns the method to create the `isEqual` function\n */\nexport function createCircularEqualCreator(isEqual?: EqualityComparator) {\n  return function createCircularEqual(comparator: EqualityComparator) {\n    const _comparator = isEqual || comparator;\n\n    return function circularEqual(\n      a: any,\n      b: any,\n      cache: Cache = getNewCache(),\n    ) {\n      const hasA = cache.has(a);\n      const hasB = cache.has(b);\n\n      if (hasA || hasB) {\n        return hasA && hasB;\n      }\n\n      addToCache(a, cache);\n      addToCache(b, cache);\n\n      return _comparator(a, b, cache);\n    };\n  };\n}\n\n/**\n * @function toPairs\n *\n * @description\n * convert the map passed into pairs (meaning an array of [key, value] tuples)\n *\n * @param map the map to convert to [key, value] pairs (entries)\n * @returns the [key, value] pairs\n */\nexport function toPairs(map: Map<any, any>): [any, any][] {\n  const pairs = new Array(map.size);\n\n  let index = 0;\n\n  map.forEach((value, key) => {\n    pairs[index++] = [key, value];\n  });\n\n  return pairs;\n}\n\n/**\n * @function toValues\n *\n * @description\n * convert the set passed into values\n *\n * @param set the set to convert to values\n * @returns the values\n */\nexport function toValues(set: Set<any>) {\n  const values = new Array(set.size);\n\n  let index = 0;\n\n  set.forEach((value) => {\n    values[index++] = value;\n  });\n\n  return values;\n}\n\n/**\n * @function areArraysEqual\n *\n * @description\n * are the arrays equal in value\n *\n * @param a the array to test\n * @param b the array to test against\n * @param isEqual the comparator to determine equality\n * @param meta the meta object to pass through\n * @returns are the arrays equal\n */\nexport function areArraysEqual(\n  a: any[],\n  b: any[],\n  isEqual: EqualityComparator,\n  meta: any,\n) {\n  const { length } = a;\n\n  if (b.length !== length) {\n    return false;\n  }\n\n  for (let index = 0; index < length; index++) {\n    if (!isEqual(a[index], b[index], meta)) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\n/**\n * @function areMapsEqual\n *\n * @description\n * are the maps equal in value\n *\n * @param a the map to test\n * @param b the map to test against\n * @param isEqual the comparator to determine equality\n * @param meta the meta map to pass through\n * @returns are the maps equal\n */\nexport function areMapsEqual(\n  a: Map<any, any>,\n  b: Map<any, any>,\n  isEqual: EqualityComparator,\n  meta: any,\n) {\n  if (a.size !== b.size) {\n    return false;\n  }\n\n  const pairsA = toPairs(a);\n  const pairsB = toPairs(b);\n\n  const { length } = pairsA;\n\n  for (let index = 0; index < length; index++) {\n    if (\n      !hasPair(pairsB, pairsA[index], isEqual, meta) ||\n      !hasPair(pairsA, pairsB[index], isEqual, meta)\n    ) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\ntype Dictionary<Type> = {\n  [key: string]: Type;\n  [index: number]: Type;\n};\n\nconst OWNER = '_owner';\n\nconst hasOwnProperty = Function.prototype.bind.call(\n  Function.prototype.call,\n  Object.prototype.hasOwnProperty,\n);\n\n/**\n * @function areObjectsEqual\n *\n * @description\n * are the objects equal in value\n *\n * @param a the object to test\n * @param b the object to test against\n * @param isEqual the comparator to determine equality\n * @param meta the meta object to pass through\n * @returns are the objects equal\n */\nexport function areObjectsEqual(\n  a: Dictionary<any>,\n  b: Dictionary<any>,\n  isEqual: EqualityComparator,\n  meta: any,\n) {\n  const keysA = keys(a);\n\n  const { length } = keysA;\n\n  if (keys(b).length !== length) {\n    return false;\n  }\n\n  let key: string;\n\n  for (let index = 0; index < length; index++) {\n    key = keysA[index];\n\n    if (!hasOwnProperty(b, key)) {\n      return false;\n    }\n\n    if (key === OWNER && isReactElement(a)) {\n      if (!isReactElement(b)) {\n        return false;\n      }\n    } else if (!isEqual(a[key], b[key], meta)) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\n/**\n * @function areRegExpsEqual\n *\n * @description\n * are the regExps equal in value\n *\n * @param a the regExp to test\n * @param b the regExp to test agains\n * @returns are the regExps equal\n */\nexport function areRegExpsEqual(a: RegExp, b: RegExp) {\n  return (\n    a.source === b.source &&\n    a.global === b.global &&\n    a.ignoreCase === b.ignoreCase &&\n    a.multiline === b.multiline &&\n    a.unicode === b.unicode &&\n    a.sticky === b.sticky &&\n    a.lastIndex === b.lastIndex\n  );\n}\n\n/**\n * @function areSetsEqual\n *\n * @description\n * are the sets equal in value\n *\n * @param a the set to test\n * @param b the set to test against\n * @param isEqual the comparator to determine equality\n * @param meta the meta set to pass through\n * @returns are the sets equal\n */\nexport function areSetsEqual(\n  a: Set<any>,\n  b: Set<any>,\n  isEqual: EqualityComparator,\n  meta: any,\n) {\n  if (a.size !== b.size) {\n    return false;\n  }\n\n  const valuesA = toValues(a);\n  const valuesB = toValues(b);\n\n  const { length } = valuesA;\n\n  for (let index = 0; index < length; index++) {\n    if (\n      !hasValue(valuesB, valuesA[index], isEqual, meta) ||\n      !hasValue(valuesA, valuesB[index], isEqual, meta)\n    ) {\n      return false;\n    }\n  }\n\n  return true;\n}\n","import {\n  EqualityComparator,\n  areArraysEqual,\n  areMapsEqual,\n  areObjectsEqual,\n  areRegExpsEqual,\n  areSetsEqual,\n  isPlainObject,\n  isPromiseLike,\n  sameValueZeroEqual,\n} from './utils';\n\nconst { isArray } = Array;\n\nconst HAS_MAP_SUPPORT = typeof Map === 'function';\nconst HAS_SET_SUPPORT = typeof Set === 'function';\n\nconst OBJECT_TYPEOF = 'object';\n\ntype EqualityComparatorCreator = (fn: EqualityComparator) => EqualityComparator;\n\nexport function createComparator(createIsEqual?: EqualityComparatorCreator) {\n  const isEqual: EqualityComparator =\n    /* eslint-disable no-use-before-define */\n    typeof createIsEqual === 'function'\n      ? createIsEqual(comparator)\n      : comparator;\n  /* eslint-enable */\n\n  /**\n   * @function comparator\n   *\n   * @description\n   * compare the value of the two objects and return true if they are equivalent in values\n   *\n   * @param a the value to test against\n   * @param b the value to test\n   * @param [meta] an optional meta object that is passed through to all equality test calls\n   * @returns are a and b equivalent in value\n   */\n  function comparator(a: any, b: any, meta?: any) {\n    if (sameValueZeroEqual(a, b)) {\n      return true;\n    }\n\n    if (a && b && typeof a === OBJECT_TYPEOF && typeof b === OBJECT_TYPEOF) {\n      if (isPlainObject(a) && isPlainObject(b)) {\n        return areObjectsEqual(a, b, isEqual, meta);\n      }\n\n      const arrayA = isArray(a);\n      const arrayB = isArray(b);\n\n      if (arrayA || arrayB) {\n        return arrayA === arrayB && areArraysEqual(a, b, isEqual, meta);\n      }\n\n      const aDate = a instanceof Date;\n      const bDate = b instanceof Date;\n\n      if (aDate || bDate) {\n        return aDate === bDate && sameValueZeroEqual(a.getTime(), b.getTime());\n      }\n\n      const aRegExp = a instanceof RegExp;\n      const bRegExp = b instanceof RegExp;\n\n      if (aRegExp || bRegExp) {\n        return aRegExp === bRegExp && areRegExpsEqual(a, b);\n      }\n\n      if (isPromiseLike(a) || isPromiseLike(b)) {\n        return a === b;\n      }\n\n      if (HAS_MAP_SUPPORT) {\n        const aMap = a instanceof Map;\n        const bMap = b instanceof Map;\n\n        if (aMap || bMap) {\n          return aMap === bMap && areMapsEqual(a, b, isEqual, meta);\n        }\n      }\n\n      if (HAS_SET_SUPPORT) {\n        const aSet = a instanceof Set;\n        const bSet = b instanceof Set;\n\n        if (aSet || bSet) {\n          return aSet === bSet && areSetsEqual(a, b, isEqual, meta);\n        }\n      }\n\n      return areObjectsEqual(a, b, isEqual, meta);\n    }\n\n    return false;\n  }\n\n  return comparator;\n}\n","// comparator\nimport { createComparator } from './comparator';\n\n// utils\nimport { createCircularEqualCreator, sameValueZeroEqual } from './utils';\n\nexport { createComparator as createCustomEqual, sameValueZeroEqual };\n\nexport const deepEqual = createComparator();\nexport const shallowEqual = createComparator(() => sameValueZeroEqual);\n\nexport const circularDeepEqual = createComparator(createCircularEqualCreator());\nexport const circularShallowEqual = createComparator(\n  createCircularEqualCreator(sameValueZeroEqual),\n);\n"],"names":[],"mappings":"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"}

package/dist/fast-equals.min.js

@@ -1 +1 @@
-!function(e,n){"object"==typeof exports&&"undefined"!=typeof module?n(exports):"function"==typeof define&&define.amd?define(["exports"],n):n(e.fe={})}(this,function(e){"use strict";var g="function"==typeof Map,m="function"==typeof Set,f="function"==typeof WeakSet,a=Object.keys,c=function(e,n){return e&&"object"==typeof e&&n.add(e)},l=function(e,n,t,r){for(var u=0;u<e.length;u++)if(t(e[u],n,r))return!0;return!1},i=function(e,n,t,r){if(e.length!==n.length)return!1;for(var u=0;u<e.length;u++)if(!l(n,e[u],t,r))return!1;return!0},b=function(e,n){return e===n||e!=e&&n!=n},k=function(e){return e.constructor===Object},E=function(e){return"function"==typeof e.then},s=function(e){return!(!e.$$typeof||!e._store)},n=function(o){return function(i){return function(e,n){var t=2<arguments.length&&void 0!==arguments[2]?arguments[2]:f?new WeakSet:Object.create({_values:[],add:function(e){this._values.push(e)},has:function(e){return!!~this._values.indexOf(e)}}),r=t.has(e),u=t.has(n);return r||u?r&&u:(c(e,t),c(n,t),(o||i)(e,n,t))}}},o=function(e){var t={keys:[],values:[]};return e.forEach(function(e,n){return t.keys.push(n)&&t.values.push(e)}),t},t=function(e){var u=e?function(e,n,t,r){return i(e.keys,n.keys,t,r)&&i(e.values,n.values,t,r)}:function(e,n,t,r){return i(e.values,n.values,t,r)};return function(e,n,t,r){return u(o(e),o(n),t,r)}},x=function(e,n,t,r){var u=a(e),i=a(n);if(u.length!==i.length)return!1;for(var o=void 0,f=0;f<u.length;f++){if(o=u[f],!l(i,o,b))return!1;if(!("_owner"===o&&s(e)&&s(n)||t(e[o],n[o],r)))return!1}return!0},j=Array.isArray,S=t(!0),_=t(!1),r=function(e){function n(e,n,t){if(b(e,n))return!0;var r=typeof e;if(r!=typeof n||"object"!=r||!e||!n)return!1;if(k(e)&&k(n))return x(e,n,y,t);var u=j(e),i=j(n);if(u||i)return u===i&&function(e,n,t,r){if(e.length!==n.length)return!1;for(var u=0;u<e.length;u++)if(!t(e[u],n[u],r))return!1;return!0}(e,n,y,t);var o=e instanceof Date,f=n instanceof Date;if(o||f)return o==f&&b(e.getTime(),n.getTime());var a,c,l=e instanceof RegExp,s=n instanceof RegExp;if(l||s)return l==s&&(c=n,(a=e).source===c.source&&a.global===c.global&&a.ignoreCase===c.ignoreCase&&a.multiline===c.multiline&&a.unicode===c.unicode&&a.sticky===c.sticky&&a.lastIndex===c.lastIndex);if(E(e)||E(n))return e===n;if(g){var p=e instanceof Map,v=n instanceof Map;if(p||v)return p==v&&S(e,n,y,t)}if(m){var h=e instanceof Set,d=n instanceof Set;if(h||d)return h==d&&_(e,n,y,t)}return x(e,n,y,t)}var y="function"==typeof e?e(n):n;return n},u=r(n()),p=r(n(b)),v=r(),h=r(function(){return b}),d={circularDeep:u,circularShallow:p,createCustom:r,deep:v,sameValueZero:b,shallow:h};e.createCustomEqual=r,e.sameValueZeroEqual=b,e.circularDeepEqual=u,e.circularShallowEqual=p,e.deepEqual=v,e.shallowEqual=h,e.default=d,Object.defineProperty(e,"__esModule",{value:!0})});
+!function(n,e){"object"==typeof exports&&"undefined"!=typeof module?e(exports):"function"==typeof define&&define.amd?define(["exports"],e):e((n=n||self)["fast-equals"]={})}(this,function(n){"use strict";var e="function"==typeof WeakSet,t=Object.keys;function r(n,e){n&&"object"==typeof n&&e.add(n)}function u(n,e,t,r){for(var u,i=n.length,o=0;o<i;o++)if(t((u=n[o])[0],e[0],r)&&t(u[1],e[1],r))return!0;return!1}function i(n,e,t,r){for(var u=n.length,i=0;i<u;i++)if(t(n[i],e,r))return!0;return!1}function o(n,e){return n===e||n!=n&&e!=e}function f(n){return n.constructor===Object||null==n.constructor}function a(n){return!!n&&"function"==typeof n.then}function c(n){return!(!n||!n.$$typeof)}function s(){return Object.create({_values:[],add:function(n){this._values.push(n)},has:function(n){return-1!==this._values.indexOf(n)}})}var l=e?function(){return new WeakSet}:s;function p(n){return function(e){var t=n||e;return function(n,e,u){void 0===u&&(u=l());var i=u.has(n),o=u.has(e);return i||o?i&&o:(r(n,u),r(e,u),t(n,e,u))}}}function v(n){var e=new Array(n.size),t=0;return n.forEach(function(n,r){e[t++]=[r,n]}),e}function y(n){var e=new Array(n.size),t=0;return n.forEach(function(n){e[t++]=n}),e}var d="_owner",h=Function.prototype.bind.call(Function.prototype.call,Object.prototype.hasOwnProperty);function g(n,e,r,u){var i,o=t(n),f=o.length;if(t(e).length!==f)return!1;for(var a=0;a<f;a++){if(i=o[a],!h(e,i))return!1;if(i===d&&c(n)){if(!c(e))return!1}else if(!r(n[i],e[i],u))return!1}return!0}var b=Array.isArray,E="function"==typeof Map,j="function"==typeof Set,m="object";function x(n){var e="function"==typeof n?n(t):t;function t(n,t,r){if(o(n,t))return!0;if(n&&t&&typeof n===m&&typeof t===m){if(f(n)&&f(t))return g(n,t,e,r);var c=b(n),s=b(t);if(c||s)return c===s&&function(n,e,t,r){var u=n.length;if(e.length!==u)return!1;for(var i=0;i<u;i++)if(!t(n[i],e[i],r))return!1;return!0}(n,t,e,r);var l=n instanceof Date,p=t instanceof Date;if(l||p)return l===p&&o(n.getTime(),t.getTime());var d=n instanceof RegExp,h=t instanceof RegExp;if(d||h)return d===h&&function(n,e){return n.source===e.source&&n.global===e.global&&n.ignoreCase===e.ignoreCase&&n.multiline===e.multiline&&n.unicode===e.unicode&&n.sticky===e.sticky&&n.lastIndex===e.lastIndex}(n,t);if(a(n)||a(t))return n===t;if(E){var x=n instanceof Map,q=t instanceof Map;if(x||q)return x===q&&function(n,e,t,r){if(n.size!==e.size)return!1;for(var i=v(n),o=v(e),f=i.length,a=0;a<f;a++)if(!u(o,i[a],t,r)||!u(i,o[a],t,r))return!1;return!0}(n,t,e,r)}if(j){var w=n instanceof Set,O=t instanceof Set;if(w||O)return w===O&&function(n,e,t,r){if(n.size!==e.size)return!1;for(var u=y(n),o=y(e),f=u.length,a=0;a<f;a++)if(!i(o,u[a],t,r)||!i(u,o[a],t,r))return!1;return!0}(n,t,e,r)}return g(n,t,e,r)}return!1}return t}var q=x(),w=x(function(){return o}),O=x(p()),z=x(p(o));n.circularDeepEqual=O,n.circularShallowEqual=z,n.createCustomEqual=x,n.deepEqual=q,n.sameValueZeroEqual=o,n.shallowEqual=w,Object.defineProperty(n,"__esModule",{value:!0})});