fast-equals 1.6.3 → 2.0.0

package/dist/fast-equals.cjs.js

@@ -2,457 +2,426 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-/**
- * @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
-};
+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 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;
+}
+
+// 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;
 //# sourceMappingURL=fast-equals.cjs.js.map