fast-equals 3.0.1 → 4.0.0-beta.0

package/dist/fast-equals.cjs.js

@@ -2,119 +2,193 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-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
+ * Default equality comparator pass-through, used as the standard `isEqual` creator for
+ * use inside the built comparator.
  */
-function sameValueZeroEqual(a, b) {
-    return a === b || (a !== a && b !== b);
+function createDefaultIsNestedEqual(comparator) {
+    return function isEqual(a, b, indexOrKeyA, indexOrKeyB, parentA, parentB, meta) {
+        return comparator(a, b, meta);
+    };
 }
 /**
- * is the value a plain object
- *
- * @param value the value to test
- * @returns is the value a plain object
+ * Wrap the provided `areItemsEqual` method to manage the circular cache, allowing
+ * for circular references to be safely included in the comparison without creating
+ * stack overflows.
  */
-function isPlainObject(value) {
-    return value.constructor === Object || value.constructor == null;
+function createIsCircular(areItemsEqual) {
+    return function isCircular(a, b, isEqual, cache) {
+        if (!a || !b || typeof a !== 'object' || typeof b !== 'object') {
+            return areItemsEqual(a, b, isEqual, cache);
+        }
+        var cachedA = cache.get(a);
+        var cachedB = cache.get(b);
+        if (cachedA && cachedB) {
+            return cachedA === b && cachedB === a;
+        }
+        cache.set(a, b);
+        cache.set(b, a);
+        var result = areItemsEqual(a, b, isEqual, cache);
+        cache.delete(a);
+        cache.delete(b);
+        return result;
+    };
 }
 /**
- * is the value promise-like (meaning it is thenable)
+ * Targeted shallow merge of two objects.
  *
- * @param value the value to test
- * @returns is the value promise-like
+ * @NOTE
+ * This exists as a tinier compiled version of the `__assign` helper that
+ * `tsc` injects in case of `Object.assign` not being present.
  */
-function isPromiseLike(value) {
-    return !!value && typeof value.then === 'function';
+function merge(a, b) {
+    var merged = {};
+    for (var key in a) {
+        merged[key] = a[key];
+    }
+    for (var key in b) {
+        merged[key] = b[key];
+    }
+    return merged;
 }
 /**
- * is the value passed a react element
+ * Whether the value is a plain object.
  *
- * @param value the value to test
- * @returns is the value a react element
+ * @NOTE
+ * This is a same-realm compariosn only.
  */
-function isReactElement(value) {
-    return !!(value && value.$$typeof);
+function isPlainObject(value) {
+    return value.constructor === Object || value.constructor == null;
 }
 /**
- * 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
+ * When the value is `Promise`-like, aka "then-able".
  */
-function getNewCacheFallback() {
-    var values = [];
-    return {
-        add: function (value) {
-            values.push(value);
-        },
-        has: function (value) {
-            return values.indexOf(value) !== -1;
-        },
-    };
+function isPromiseLike(value) {
+    return typeof value.then === 'function';
 }
 /**
- * get a new cache object to prevent circular references
- *
- * @returns the new cache object
+ * Whether the values passed are strictly equal or both NaN.
  */
-var getNewCache = (function (canUseWeakMap) {
-    if (canUseWeakMap) {
-        return function _getNewCache() {
-            return new WeakSet();
-        };
+function sameValueZeroEqual(a, b) {
+    return a === b || (a !== a && b !== b);
+}
+
+var ARGUMENTS_TAG = '[object Arguments]';
+var BOOLEAN_TAG = '[object Boolean]';
+var DATE_TAG = '[object Date]';
+var REG_EXP_TAG = '[object RegExp]';
+var MAP_TAG = '[object Map]';
+var NUMBER_TAG = '[object Number]';
+var OBJECT_TAG = '[object Object]';
+var SET_TAG = '[object Set]';
+var STRING_TAG = '[object String]';
+var toString = Object.prototype.toString;
+function createComparator(_a) {
+    var areArraysEqual = _a.areArraysEqual, areDatesEqual = _a.areDatesEqual, areMapsEqual = _a.areMapsEqual, areObjectsEqual = _a.areObjectsEqual, areRegExpsEqual = _a.areRegExpsEqual, areSetsEqual = _a.areSetsEqual, createIsNestedEqual = _a.createIsNestedEqual;
+    var isEqual = createIsNestedEqual(comparator);
+    /**
+     * compare the value of the two objects and return true if they are equivalent in values
+     */
+    function comparator(a, b, meta) {
+        // If the items are strictly equal, no need to do a value comparison.
+        if (a === b) {
+            return true;
+        }
+        // If the items are not non-nullish objects, then the only possibility
+        // of them being equal but not strictly is if they are both `NaN`. Since
+        // `NaN` is uniquely not equal to itself, we can use self-comparison of
+        // both objects, which is faster than `isNaN()`.
+        if (!a || !b || typeof a !== 'object' || typeof b !== 'object') {
+            return a !== a && b !== b;
+        }
+        // Checks are listed in order of commonality of use-case:
+        //   1. Common complex object types (plain object, array)
+        //   2. Common data values (date, regexp)
+        //   3. Less-common complex object types (map, set)
+        //   4. Less-common data values (promise, primitive wrappers)
+        // Inherently this is both subjective and assumptive, however
+        // when reviewing comparable libraries in the wild this order
+        // appears to be generally consistent.
+        // `isPlainObject` only checks against the object's own realm. Cross-realm
+        // comparisons are rare, and will be handled in the ultimate fallback, so
+        // we can avoid the `toString.call()` cost unless necessary.
+        if (isPlainObject(a) && isPlainObject(b)) {
+            return areObjectsEqual(a, b, isEqual, meta);
+        }
+        // `isArray()` works on subclasses and is cross-realm, so we can again avoid
+        // the `toString.call()` cost unless necessary by just checking if either
+        // and then both are arrays.
+        var aArray = Array.isArray(a);
+        var bArray = Array.isArray(b);
+        if (aArray || bArray) {
+            return aArray === bArray && areArraysEqual(a, b, isEqual, meta);
+        }
+        // Since this is a custom object, use the classic `toString.call()` to get its
+        // type. This is reasonably performant in modern environments like v8 and
+        // SpiderMonkey, and allows for cross-realm comparison when other checks like
+        // `instanceof` do not.
+        var aTag = toString.call(a);
+        if (aTag !== toString.call(b)) {
+            return false;
+        }
+        if (aTag === DATE_TAG) {
+            // `getTime()` showed better results compared to alternatives like `valueOf()`
+            // or the unary `+` operator.
+            return areDatesEqual(a, b, isEqual, meta);
+        }
+        if (aTag === REG_EXP_TAG) {
+            return areRegExpsEqual(a, b, isEqual, meta);
+        }
+        if (aTag === MAP_TAG) {
+            return areMapsEqual(a, b, isEqual, meta);
+        }
+        if (aTag === SET_TAG) {
+            return areSetsEqual(a, b, isEqual, meta);
+        }
+        // If a simple object tag, then we can prioritize a simple object comparison because
+        // it is likely a custom class. If an arguments tag, it should be treated as a standard
+        // object.
+        if (aTag === OBJECT_TAG || aTag === ARGUMENTS_TAG) {
+            // The exception for value comparison is `Promise`-like contracts. These should be
+            // treated the same as standard `Promise` objects, which means strict equality.
+            return isPromiseLike(a) || isPromiseLike(b)
+                ? a === b
+                : areObjectsEqual(a, b, isEqual, meta);
+        }
+        // As the penultimate fallback, check if the values passed are primitive wrappers. This
+        // is very rare in modern JS, which is why it is deprioritized compared to all other object
+        // types.
+        if (aTag === BOOLEAN_TAG || aTag === NUMBER_TAG || aTag === STRING_TAG) {
+            return sameValueZeroEqual(a.valueOf(), b.valueOf());
+        }
+        // If not matching any tags that require a specific type of comparison, then use strict
+        // equality. This is for a few reasons:
+        //   - For types that cannot be introspected (`Promise`, `WeakMap`, etc.), this is the only
+        //     comparison that can be made.
+        //   - For types that can be introspected, but rarely have requirements to be compared
+        //     (`ArrayBuffer`, `DataView`, etc.), the cost is avoided to prioritize the common
+        //     use-cases.
+        //   - For types that can be introspected, but do not have an objective definition of what
+        //     equality is (`Error`, etc.), the subjective decision was to be conservative.
+        // In all cases, these decisions should be reevaluated based on changes to the language and
+        // common development practices.
+        return a === b;
     }
-    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, indexOrKeyA, indexOrKeyB, parentA, parentB, 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);
-        };
-    };
-}
+    return comparator;
+}
+
 /**
- * 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
+ * Whether the arrays are equal in value.
  */
 function areArraysEqual(a, b, isEqual, meta) {
     var index = a.length;
     if (b.length !== index) {
         return false;
     }
+    // Decrementing `while` showed faster results than either incrementing or
+    // decrementing `for` loop and than an incrementing `while` loop. Declarative
+    // methods like `some` / `every` were not used to avoid incurring the garbage
+    // cost of anonymous callbacks.
     while (index-- > 0) {
         if (!isEqual(a[index], b[index], index, index, a, b, meta)) {
             return false;
@@ -123,199 +197,228 @@ function areArraysEqual(a, b, isEqual, meta) {
     return true;
 }
 /**
- * are the maps equal in value
+ * Whether the arrays are equal in value, including circular references.
+ */
+var areArraysEqualCircular = createIsCircular(areArraysEqual);
+
+/**
+ * Whether the dates passed are 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
+ * @NOTE
+ * This is a standalone function instead of done inline in the comparator
+ * to allow for overrides.
+ */
+function areDatesEqual(a, b) {
+    return sameValueZeroEqual(a.valueOf(), b.valueOf());
+}
+
+/**
+ * Whether the `Map`s are equal in value.
  */
 function areMapsEqual(a, b, isEqual, meta) {
     var isValueEqual = a.size === b.size;
-    if (isValueEqual && a.size) {
-        var matchedIndices_1 = {};
-        var indexA_1 = 0;
-        a.forEach(function (aValue, aKey) {
-            if (isValueEqual) {
-                var hasMatch_1 = false;
-                var matchIndexB_1 = 0;
-                b.forEach(function (bValue, bKey) {
-                    if (!hasMatch_1 && !matchedIndices_1[matchIndexB_1]) {
-                        hasMatch_1 =
-                            isEqual(aKey, bKey, indexA_1, matchIndexB_1, a, b, meta) &&
-                                isEqual(aValue, bValue, aKey, bKey, a, b, meta);
-                        if (hasMatch_1) {
-                            matchedIndices_1[matchIndexB_1] = true;
-                        }
-                    }
-                    matchIndexB_1++;
-                });
-                indexA_1++;
-                isValueEqual = hasMatch_1;
+    if (!isValueEqual) {
+        return false;
+    }
+    if (!a.size) {
+        return true;
+    }
+    // The use of `forEach()` is to avoid the transpilation cost of `for...of` comparisons, and
+    // the inability to control the performance of the resulting code. It also avoids excessive
+    // iteration compared to doing comparisons of `keys()` and `values()`. As a result, though,
+    // we cannot short-circuit the iterations; bookkeeping must be done to short-circuit the
+    // equality checks themselves.
+    var matchedIndices = {};
+    var indexA = 0;
+    a.forEach(function (aValue, aKey) {
+        if (!isValueEqual) {
+            return;
+        }
+        var hasMatch = false;
+        var matchIndexB = 0;
+        b.forEach(function (bValue, bKey) {
+            if (!hasMatch &&
+                !matchedIndices[matchIndexB] &&
+                (hasMatch =
+                    isEqual(aKey, bKey, indexA, matchIndexB, a, b, meta) &&
+                        isEqual(aValue, bValue, aKey, bKey, a, b, meta))) {
+                matchedIndices[matchIndexB] = true;
             }
+            matchIndexB++;
         });
-    }
+        indexA++;
+        isValueEqual = hasMatch;
+    });
     return isValueEqual;
 }
+/**
+ * Whether the `Map`s are equal in value, including circular references.
+ */
+var areMapsEqualCircular = createIsCircular(areMapsEqual);
+
 var OWNER = '_owner';
-var hasOwnProperty = Function.prototype.bind.call(Function.prototype.call, Object.prototype.hasOwnProperty);
+var hasOwnProperty = 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
+ * Whether the objects are equal in value.
  */
 function areObjectsEqual(a, b, isEqual, meta) {
-    var keysA = keys(a);
+    var keysA = Object.keys(a);
     var index = keysA.length;
-    if (keys(b).length !== index) {
+    if (Object.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], key, key, a, b, meta)) {
+    var key;
+    // Decrementing `while` showed faster results than either incrementing or
+    // decrementing `for` loop and than an incrementing `while` loop. Declarative
+    // methods like `some` / `every` were not used to avoid incurring the garbage
+    // cost of anonymous callbacks.
+    while (index-- > 0) {
+        key = keysA[index];
+        if (key === OWNER) {
+            var reactElementA = !!a.$$typeof;
+            var reactElementB = !!b.$$typeof;
+            if ((reactElementA || reactElementB) && reactElementA !== reactElementB) {
                 return false;
             }
         }
+        if (!hasOwnProperty.call(b, key) ||
+            !isEqual(a[key], b[key], key, key, a, b, meta)) {
+            return false;
+        }
     }
     return true;
 }
 /**
- * are the regExps equal in value
+ * Whether the objects are equal in value, including circular references.
+ */
+var areObjectsEqualCircular = createIsCircular(areObjectsEqual);
+
+/**
+ * Whether the regexps passed are equal in value.
  *
- * @param a the regExp to test
- * @param b the regExp to test agains
- * @returns are the regExps equal
+ * @NOTE
+ * This is a standalone function instead of done inline in the comparator
+ * to allow for overrides. An example of this would be supporting a
+ * pre-ES2015 environment where the `flags` property is not available.
  */
 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);
-}
+    return a.source === b.source && a.flags === b.flags;
+}
+
 /**
- * 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
+ * Whether the `Set`s are equal in value.
  */
 function areSetsEqual(a, b, isEqual, meta) {
     var isValueEqual = a.size === b.size;
-    if (isValueEqual && a.size) {
-        var matchedIndices_2 = {};
-        a.forEach(function (aValue, aKey) {
-            if (isValueEqual) {
-                var hasMatch_2 = false;
-                var matchIndex_1 = 0;
-                b.forEach(function (bValue, bKey) {
-                    if (!hasMatch_2 && !matchedIndices_2[matchIndex_1]) {
-                        hasMatch_2 = isEqual(aValue, bValue, aKey, bKey, a, b, meta);
-                        if (hasMatch_2) {
-                            matchedIndices_2[matchIndex_1] = true;
-                        }
-                    }
-                    matchIndex_1++;
-                });
-                isValueEqual = hasMatch_2;
+    if (!isValueEqual) {
+        return false;
+    }
+    if (!a.size) {
+        return true;
+    }
+    // The use of `forEach()` is to avoid the transpilation cost of `for...of` comparisons, and
+    // the inability to control the performance of the resulting code. It also avoids excessive
+    // iteration compared to doing comparisons of `keys()` and `values()`. As a result, though,
+    // we cannot short-circuit the iterations; bookkeeping must be done to short-circuit the
+    // equality checks themselves.
+    var matchedIndices = {};
+    a.forEach(function (aValue, aKey) {
+        if (!isValueEqual) {
+            return;
+        }
+        var hasMatch = false;
+        var matchIndex = 0;
+        b.forEach(function (bValue, bKey) {
+            if (!hasMatch &&
+                !matchedIndices[matchIndex] &&
+                (hasMatch = isEqual(aValue, bValue, aKey, bKey, a, b, meta))) {
+                matchedIndices[matchIndex] = true;
             }
+            matchIndex++;
         });
-    }
+        isValueEqual = hasMatch;
+    });
     return isValueEqual;
-}
+}
+/**
+ * Whether the `Set`s are equal in value, including circular references.
+ */
+var areSetsEqualCircular = createIsCircular(areSetsEqual);
 
-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)
-        : function (a, b, indexOrKeyA, indexOrKeyB, parentA, parentB, meta) { return comparator(a, b, meta); };
-    /* 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 DEFAULT_CONFIG = Object.freeze({
+    areArraysEqual: areArraysEqual,
+    areDatesEqual: areDatesEqual,
+    areMapsEqual: areMapsEqual,
+    areObjectsEqual: areObjectsEqual,
+    areRegExpsEqual: areRegExpsEqual,
+    areSetsEqual: areSetsEqual,
+    createIsNestedEqual: createDefaultIsNestedEqual,
+});
+var DEFAULT_CIRCULAR_CONFIG = Object.freeze(merge(DEFAULT_CONFIG, {
+    areArraysEqual: areArraysEqualCircular,
+    areMapsEqual: areMapsEqualCircular,
+    areObjectsEqual: areObjectsEqualCircular,
+    areSetsEqual: areSetsEqualCircular,
+}));
+var isDeepEqual = createComparator(DEFAULT_CONFIG);
+/**
+ * Whether the items passed are deeply-equal in value.
+ */
+function deepEqual(a, b) {
+    return isDeepEqual(a, b, undefined);
+}
+var isShallowEqual = createComparator(merge(DEFAULT_CONFIG, { createIsNestedEqual: function () { return sameValueZeroEqual; } }));
+/**
+ * Whether the items passed are shallowly-equal in value.
+ */
+function shallowEqual(a, b) {
+    return isShallowEqual(a, b, undefined);
+}
+var isCircularDeepEqual = createComparator(DEFAULT_CIRCULAR_CONFIG);
+/**
+ * Whether the items passed are deeply-equal in value, including circular references.
+ */
+function circularDeepEqual(a, b) {
+    return isCircularDeepEqual(a, b, new WeakMap());
+}
+var isCircularShallowEqual = createComparator(merge(DEFAULT_CIRCULAR_CONFIG, {
+    createIsNestedEqual: function () { return sameValueZeroEqual; },
+}));
+/**
+ * Whether the items passed are shallowly-equal in value, including circular references.
+ */
+function circularShallowEqual(a, b) {
+    return isCircularShallowEqual(a, b, new WeakMap());
+}
+/**
+ * Create a custom equality comparison method.
+ *
+ * This can be done to create very targeted comparisons in extreme hot-path scenarios
+ * where the standard methods are not performant enough, but can also be used to provide
+ * support for legacy environments that do not support expected features like
+ * `RegExp.prototype.flags` out of the box.
+ */
+function createCustomEqual(getComparatorOptions) {
+    return createComparator(merge(DEFAULT_CONFIG, getComparatorOptions(DEFAULT_CONFIG)));
+}
+/**
+ * Create a custom equality comparison method that handles circular references. This is very
+ * similar to `createCustomEqual`, with the only difference being that `meta` expects to be
+ * populated with a `WeakMap`-like contract.
+ *
+ * This can be done to create very targeted comparisons in extreme hot-path scenarios
+ * where the standard methods are not performant enough, but can also be used to provide
+ * support for legacy environments that do not support expected features like
+ * `WeakMap` out of the box.
+ */
+function createCustomCircularEqual(getComparatorOptions) {
+    return createComparator(merge(DEFAULT_CIRCULAR_CONFIG, getComparatorOptions(DEFAULT_CIRCULAR_CONFIG)));
 }
 
-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.createCustomCircularEqual = createCustomCircularEqual;
+exports.createCustomEqual = createCustomEqual;
 exports.deepEqual = deepEqual;
 exports.sameValueZeroEqual = sameValueZeroEqual;
 exports.shallowEqual = shallowEqual;