fast-equals 1.6.3 → 2.0.3

package/dist/fast-equals.js

@@ -1,464 +1,309 @@
 (function (global, factory) {
   typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
   typeof define === 'function' && define.amd ? define(['exports'], factory) :
-  (global = global || self, factory(global['fast-equals'] = {}));
-}(this, function (exports) { 'use strict';
-
-  /**
-   * @constant {boolean} HAS_MAP_SUPPORT
-   */
-  var HAS_MAP_SUPPORT = typeof Map === 'function';
-  /**
-   * @constant {boolean} HAS_SET_SUPPORT
-   */
-
-  var HAS_SET_SUPPORT = typeof Set === 'function';
-  /**
-   * @constant {boolean} HAS_WEAKSET_SUPPORT
-   */
-
-  var HAS_WEAKSET_SUPPORT = typeof WeakSet === 'function';
-
-  // constants
-  var keys = Object.keys;
-  /**
-   * @function addObjectToCache
-   *
-   * @description
-   * add object to cache if it is indeed an object
-   *
-   * @param {any} object the object to potentially add to the cache
-   * @param {Object|WeakSet} cache the cache to add to
-   * @returns {void}
-   */
-
-  var addObjectToCache = function addObjectToCache(object, cache) {
-    return object && typeof object === 'object' && cache.add(object);
-  };
-  /**
-   *
-   * @param {Array<Array<any>>} pairs the pairs to check in
-   * @param {Array<any>} pairToMatch the pair to check if exists
-   * @param {function} isEqual the equality comparator
-   * @param {any} meta the meta item to pass through
-   * @returns {boolean} does the pair exist in the pairs
-   */
-
-  var hasPair = function hasPair(pairs, pairToMatch, isEqual, meta) {
-    var pair;
-
-    for (var index = 0; index < pairs.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 values include the vakye passed
-   *
-   * @param {Array<any>} values the values to check in
-   * @param {any} item the value to locate
-   * @param {function} isEqual the equality comparator
-   * @param {any} meta the meta item to pass through
-   * @returns {boolean} does the value exist in the values
-   */
-
-  var hasValue = function hasValue(values, item, isEqual, meta) {
-    for (var index = 0; index < values.length; index++) {
-      if (isEqual(values[index], item, meta)) {
-        return true;
-      }
-    }
-
-    return false;
-  };
-  /**
-   * @function sameValueZeroEqual
-   *
-   * @description
-   * are the objects passed strictly equal or both NaN
-   *
-   * @param {any} objectA the object to compare against
-   * @param {any} objectB the object to test
-   * @returns {boolean} are the objects equal by the SameValueZero principle
-   */
-
-  var sameValueZeroEqual = function sameValueZeroEqual(objectA, objectB) {
-    return objectA === objectB || objectA !== objectA && objectB !== objectB;
-  };
-  /**
-   * @function isPlainObject
-   *
-   * @description
-   * is the object a plain object
-   *
-   * @param {any} object the object to test
-   * @returns {boolean} is the object a plain object
-   */
-
-  var isPlainObject = function isPlainObject(object) {
-    return object.constructor === Object;
-  };
-  /**
-   * @function isPromiseLike
-   *
-   * @description
-   * is the object promise-like (thenable)
-   *
-   * @param {any} object the object to test
-   * @returns {boolean} is the object promise-like
-   */
-
-  var isPromiseLike = function isPromiseLike(object) {
-    return typeof object.then === 'function';
-  };
-  /**
-   * @function isReactElement
-   *
-   * @description
-   * is the object passed a react element
-   *
-   * @param {any} object the object to test
-   * @returns {boolean} is the object a react element
-   */
-
-  var isReactElement = function isReactElement(object) {
-    return !!(object.$$typeof && object._store);
-  };
-  /**
-   * @function getNewCache
-   *
-   * @description
-   * get a new cache object to prevent circular references
-   *
-   * @returns {Object|Weakset} the new cache object
-   */
-
-  var getNewCache = function getNewCache() {
-    return HAS_WEAKSET_SUPPORT ? new WeakSet() : Object.create({
-      _values: [],
-      add: function add(value) {
-        this._values.push(value);
-      },
-      has: function has(value) {
-        return !!~this._values.indexOf(value);
-      }
-    });
-  };
-  /**
-   * @function createCircularEqual
-   *
-   * @description
-   * create a custom isEqual handler specific to circular objects
-   *
-   * @param {funtion} [isEqual] the isEqual comparator to use instead of isDeepEqual
-   * @returns {function(any, any): boolean}
-   */
-
-  var createCircularEqual = function createCircularEqual(isEqual) {
-    return function (isDeepEqual) {
-      var comparator = isEqual || isDeepEqual;
-      return function (objectA, objectB, cache) {
-        if (cache === void 0) {
-          cache = getNewCache();
-        }
-
-        var cacheHasA = cache.has(objectA);
-        var cacheHasB = cache.has(objectB);
-
-        if (cacheHasA || cacheHasB) {
-          return cacheHasA && cacheHasB;
-        }
-
-        addObjectToCache(objectA, cache);
-        addObjectToCache(objectB, cache);
-        return comparator(objectA, objectB, cache);
-      };
-    };
-  };
-  /**
-   * @function toPairs
-   *
-   * @param {Map} map the map to convert to [key, value] pairs (entries)
-   * @returns {Array<Array<*>>} the [key, value] pairs
-   */
-
-  var toPairs = function toPairs(map) {
-    var pairs = [];
-    map.forEach(function (value, key) {
-      return pairs.push([key, value]);
-    });
-    return pairs;
-  };
-  /**
-   * @function toValues
-   *
-   * @param {Set} set the set to convert to values
-   * @returns {Array<*>} the values
-   */
-
-  var toValues = function toValues(set) {
-    var values = [];
-    set.forEach(function (value) {
-      return values.push(value);
-    });
-    return values;
-  };
-  /**
-   * @function areArraysEqual
-   *
-   * @description
-   * are the arrays equal in value
-   *
-   * @param {Array<any>} arrayA the array to test
-   * @param {Array<any>} arrayB the array to test against
-   * @param {function} isEqual the comparator to determine equality
-   * @param {any} meta the meta object to pass through
-   * @returns {boolean} are the arrays equal
-   */
-
-  var areArraysEqual = function areArraysEqual(arrayA, arrayB, isEqual, meta) {
-    if (arrayA.length !== arrayB.length) {
-      return false;
-    }
-
-    for (var index = 0; index < arrayA.length; index++) {
-      if (!isEqual(arrayA[index], arrayB[index], meta)) {
-        return false;
-      }
-    }
-
-    return true;
-  };
-  /**
-   * @function areMapsEqual
-   *
-   * @description
-   * are the maps equal in value
-   *
-   * @param {Map} mapA the map to test
-   * @param {Map} mapB the map to test against
-   * @param {function} isEqual the comparator to determine equality
-   * @param {any} meta the meta map to pass through
-   * @returns {boolean} are the maps equal
-   */
-
-  var areMapsEqual = function areMapsEqual(mapA, mapB, isEqual, meta) {
-    if (mapA.size !== mapB.size) {
-      return false;
-    }
-
-    var pairsA = toPairs(mapA);
-    var pairsB = toPairs(mapB);
-
-    for (var index = 0; index < pairsA.length; index++) {
-      if (!hasPair(pairsB, pairsA[index], isEqual, meta) || !hasPair(pairsA, pairsB[index], isEqual, meta)) {
-        return false;
-      }
-    }
-
-    return true;
-  };
-  /**
-   * @function areObjectsEqual
-   *
-   * @description
-   * are the objects equal in value
-   *
-   * @param {Object} objectA the object to test
-   * @param {Object} objectB the object to test against
-   * @param {function} isEqual the comparator to determine equality
-   * @param {any} meta the meta object to pass through
-   * @returns {boolean} are the objects equal
-   */
-
-  var areObjectsEqual = function areObjectsEqual(objectA, objectB, isEqual, meta) {
-    var keysA = keys(objectA);
-    var keysB = keys(objectB);
-
-    if (keysA.length !== keysB.length) {
-      return false;
-    }
-
-    var key;
-
-    for (var index = 0; index < keysA.length; index++) {
-      key = keysA[index];
-
-      if (!hasValue(keysB, key, sameValueZeroEqual)) {
-        return false;
-      } // if a react element, ignore the "_owner" key because its not necessary for equality comparisons
-
-
-      if (key === '_owner' && isReactElement(objectA) && isReactElement(objectB)) {
-        continue;
-      }
-
-      if (!isEqual(objectA[key], objectB[key], meta)) {
-        return false;
-      }
-    }
-
-    return true;
-  };
-  /**
-   * @function areRegExpsEqual
-   *
-   * @description
-   * are the regExps equal in value
-   *
-   * @param {RegExp} regExpA the regExp to test
-   * @param {RegExp} regExpB the regExp to test agains
-   * @returns {boolean} are the regExps equal
-   */
-
-  var areRegExpsEqual = function areRegExpsEqual(regExpA, regExpB) {
-    return regExpA.source === regExpB.source && regExpA.global === regExpB.global && regExpA.ignoreCase === regExpB.ignoreCase && regExpA.multiline === regExpB.multiline && regExpA.unicode === regExpB.unicode && regExpA.sticky === regExpB.sticky && regExpA.lastIndex === regExpB.lastIndex;
-  };
-  /**
-   * @function areSetsEqual
-   *
-   * @description
-   * are the sets equal in value
-   *
-   * @param {Set} setA the set to test
-   * @param {Set} setB the set to test against
-   * @param {function} isEqual the comparator to determine equality
-   * @param {any} meta the meta set to pass through
-   * @returns {boolean} are the sets equal
-   */
-
-  var areSetsEqual = function areSetsEqual(setA, setB, isEqual, meta) {
-    if (setA.size !== setB.size) {
-      return false;
-    }
-
-    var valuesA = toValues(setA);
-    var valuesB = toValues(setB);
-
-    for (var index = 0; index < valuesA.length; index++) {
-      if (!hasValue(valuesB, valuesA[index], isEqual, meta) || !hasValue(valuesA, valuesB[index], isEqual, meta)) {
-        return false;
-      }
-    }
-
-    return true;
-  };
-
-  // constants
-  var isArray = Array.isArray;
-
-  var createComparator = function createComparator(createIsEqual) {
-    // eslint-disable-next-line no-use-before-define
-    var isEqual = typeof createIsEqual === 'function' ? createIsEqual(comparator) : comparator;
-    /**
-     * @function comparator
-     *
-     * @description
-     * compare the value of the two objects and return true if they are equivalent in values
-     *
-     * @param {any} objectA the object to test against
-     * @param {any} objectB the object to test
-     * @param {any} [meta] an optional meta object that is passed through to all equality test calls
-     * @returns {boolean} are objectA and objectB equivalent in value
-     */
-
-    function comparator(objectA, objectB, meta) {
-      if (sameValueZeroEqual(objectA, objectB)) {
-        return true;
-      }
-
-      var typeOfA = typeof objectA;
-
-      if (typeOfA !== typeof objectB || typeOfA !== 'object' || !objectA || !objectB) {
-        return false;
-      }
-
-      if (isPlainObject(objectA) && isPlainObject(objectB)) {
-        return areObjectsEqual(objectA, objectB, isEqual, meta);
-      }
-
-      var arrayA = isArray(objectA);
-      var arrayB = isArray(objectB);
-
-      if (arrayA || arrayB) {
-        return arrayA === arrayB && areArraysEqual(objectA, objectB, isEqual, meta);
-      }
-
-      var dateA = objectA instanceof Date;
-      var dateB = objectB instanceof Date;
-
-      if (dateA || dateB) {
-        return dateA === dateB && sameValueZeroEqual(objectA.getTime(), objectB.getTime());
-      }
-
-      var regexpA = objectA instanceof RegExp;
-      var regexpB = objectB instanceof RegExp;
-
-      if (regexpA || regexpB) {
-        return regexpA === regexpB && areRegExpsEqual(objectA, objectB);
-      }
-
-      if (isPromiseLike(objectA) || isPromiseLike(objectB)) {
-        return objectA === objectB;
-      }
-
-      if (HAS_MAP_SUPPORT) {
-        var mapA = objectA instanceof Map;
-        var mapB = objectB instanceof Map;
-
-        if (mapA || mapB) {
-          return mapA === mapB && areMapsEqual(objectA, objectB, isEqual, meta);
-        }
-      }
-
-      if (HAS_SET_SUPPORT) {
-        var setA = objectA instanceof Set;
-        var setB = objectB instanceof Set;
-
-        if (setA || setB) {
-          return setA === setB && areSetsEqual(objectA, objectB, isEqual, meta);
-        }
-      }
-
-      return areObjectsEqual(objectA, objectB, isEqual, meta);
-    }
-
-    return comparator;
-  };
-
-  // comparator
-  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
-  };
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global['fast-equals'] = {}));
+}(this, (function (exports) { 'use strict';
+
+  var HAS_WEAKSET_SUPPORT = typeof WeakSet === 'function';
+  var keys = Object.keys;
+  /**
+   * 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);
+  }
+  /**
+   * 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;
+  }
+  /**
+   * 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';
+  }
+  /**
+   * 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);
+  }
+  /**
+   * 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() {
+      var values = [];
+      return {
+          add: function (value) {
+              values.push(value);
+          },
+          has: function (value) {
+              return values.indexOf(value) !== -1;
+          },
+      };
+  }
+  /**
+   * 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);
+  /**
+   * 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 isCacheableA = !!a && typeof a === 'object';
+              var isCacheableB = !!b && typeof b === 'object';
+              if (isCacheableA || isCacheableB) {
+                  var hasA = isCacheableA && cache.has(a);
+                  var hasB = isCacheableB && cache.has(b);
+                  if (hasA || hasB) {
+                      return hasA && hasB;
+                  }
+                  if (isCacheableA) {
+                      cache.add(a);
+                  }
+                  if (isCacheableB) {
+                      cache.add(b);
+                  }
+              }
+              return _comparator(a, b, cache);
+          };
+      };
+  }
+  /**
+   * 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 index = a.length;
+      if (b.length !== index) {
+          return false;
+      }
+      while (index-- > 0) {
+          if (!isEqual(a[index], b[index], meta)) {
+              return false;
+          }
+      }
+      return true;
+  }
+  /**
+   * 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) {
+      var isValueEqual = a.size === b.size;
+      if (isValueEqual && a.size) {
+          a.forEach(function (aValue, aKey) {
+              if (isValueEqual) {
+                  isValueEqual = false;
+                  b.forEach(function (bValue, bKey) {
+                      if (!isValueEqual && isEqual(aKey, bKey, meta)) {
+                          isValueEqual = isEqual(aValue, bValue, meta);
+                      }
+                  });
+              }
+          });
+      }
+      return isValueEqual;
+  }
+  var OWNER = '_owner';
+  var hasOwnProperty = Function.prototype.bind.call(Function.prototype.call, Object.prototype.hasOwnProperty);
+  /**
+   * 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 index = keysA.length;
+      if (keys(b).length !== index) {
+          return false;
+      }
+      if (index) {
+          var key = void 0;
+          while (index-- > 0) {
+              key = keysA[index];
+              if (key === OWNER) {
+                  var reactElementA = isReactElement(a);
+                  var reactElementB = isReactElement(b);
+                  if ((reactElementA || reactElementB) &&
+                      reactElementA !== reactElementB) {
+                      return false;
+                  }
+              }
+              if (!hasOwnProperty(b, key) || !isEqual(a[key], b[key], meta)) {
+                  return false;
+              }
+          }
+      }
+      return true;
+  }
+  /**
+   * 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);
+  }
+  /**
+   * 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) {
+      var isValueEqual = a.size === b.size;
+      if (isValueEqual && a.size) {
+          a.forEach(function (aValue) {
+              if (isValueEqual) {
+                  isValueEqual = false;
+                  b.forEach(function (bValue) {
+                      if (!isValueEqual) {
+                          isValueEqual = isEqual(aValue, bValue, meta);
+                      }
+                  });
+              }
+          });
+      }
+      return isValueEqual;
+  }
+
+  var HAS_MAP_SUPPORT = typeof Map === 'function';
+  var HAS_SET_SUPPORT = typeof Set === 'function';
+  function createComparator(createIsEqual) {
+      var isEqual = 
+      /* eslint-disable no-use-before-define */
+      typeof createIsEqual === 'function'
+          ? createIsEqual(comparator)
+          : comparator;
+      /* eslint-enable */
+      /**
+       * 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 (a === b) {
+              return true;
+          }
+          if (a && b && typeof a === 'object' && typeof b === 'object') {
+              if (isPlainObject(a) && isPlainObject(b)) {
+                  return areObjectsEqual(a, b, isEqual, meta);
+              }
+              var aShape = Array.isArray(a);
+              var bShape = Array.isArray(b);
+              if (aShape || bShape) {
+                  return aShape === bShape && areArraysEqual(a, b, isEqual, meta);
+              }
+              aShape = a instanceof Date;
+              bShape = b instanceof Date;
+              if (aShape || bShape) {
+                  return (aShape === bShape && sameValueZeroEqual(a.getTime(), b.getTime()));
+              }
+              aShape = a instanceof RegExp;
+              bShape = b instanceof RegExp;
+              if (aShape || bShape) {
+                  return aShape === bShape && areRegExpsEqual(a, b);
+              }
+              if (isPromiseLike(a) || isPromiseLike(b)) {
+                  return a === b;
+              }
+              if (HAS_MAP_SUPPORT) {
+                  aShape = a instanceof Map;
+                  bShape = b instanceof Map;
+                  if (aShape || bShape) {
+                      return aShape === bShape && areMapsEqual(a, b, isEqual, meta);
+                  }
+              }
+              if (HAS_SET_SUPPORT) {
+                  aShape = a instanceof Set;
+                  bShape = b instanceof Set;
+                  if (aShape || bShape) {
+                      return aShape === bShape && areSetsEqual(a, b, isEqual, meta);
+                  }
+              }
+              return areObjectsEqual(a, b, isEqual, meta);
+          }
+          return a !== a && b !== b;
+      }
+      return comparator;
+  }
+
+  var deepEqual = createComparator();
+  var shallowEqual = createComparator(function () { return sameValueZeroEqual; });
+  var circularDeepEqual = createComparator(createCircularEqualCreator());
+  var circularShallowEqual = createComparator(createCircularEqualCreator(sameValueZeroEqual));
 
   exports.circularDeepEqual = circularDeepEqual;
   exports.circularShallowEqual = circularShallowEqual;
   exports.createCustomEqual = createComparator;
   exports.deepEqual = deepEqual;
-  exports.default = index;
   exports.sameValueZeroEqual = sameValueZeroEqual;
   exports.shallowEqual = shallowEqual;
 
   Object.defineProperty(exports, '__esModule', { value: true });
 
-}));
+})));
 //# sourceMappingURL=fast-equals.js.map