fast-equals 4.0.3 → 5.0.0-beta.0

package/dist/cjs/index.cjs

@@ -0,0 +1,510 @@
+'use strict';
+
+var ARGUMENTS_TAG = '[object Arguments]';
+var BOOLEAN_TAG = '[object Boolean]';
+var DATE_TAG = '[object Date]';
+var MAP_TAG = '[object Map]';
+var NUMBER_TAG = '[object Number]';
+var OBJECT_TAG = '[object Object]';
+var REG_EXP_TAG = '[object RegExp]';
+var SET_TAG = '[object Set]';
+var STRING_TAG = '[object String]';
+var isArray = Array.isArray;
+var getTag = Object.prototype.toString.call.bind(Object.prototype.toString);
+function createComparator(_a) {
+    var areArraysEqual = _a.areArraysEqual, areDatesEqual = _a.areDatesEqual, areMapsEqual = _a.areMapsEqual, areObjectsEqual = _a.areObjectsEqual, arePrimitiveWrappersEqual = _a.arePrimitiveWrappersEqual, areRegExpsEqual = _a.areRegExpsEqual, areSetsEqual = _a.areSetsEqual;
+    /**
+     * compare the value of the two objects and return true if they are equivalent in values
+     */
+    return function comparator(a, b, state) {
+        // 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 (a.constructor === Object && b.constructor === Object) {
+            return areObjectsEqual(a, b, state);
+        }
+        // `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 = isArray(a);
+        var bArray = isArray(b);
+        if (aArray || bArray) {
+            return aArray === bArray && areArraysEqual(a, b, state);
+        }
+        // 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 tag = getTag(a);
+        if (tag !== getTag(b)) {
+            return false;
+        }
+        if (tag === DATE_TAG) {
+            return areDatesEqual(a, b, state);
+        }
+        if (tag === REG_EXP_TAG) {
+            return areRegExpsEqual(a, b, state);
+        }
+        if (tag === MAP_TAG) {
+            return areMapsEqual(a, b, state);
+        }
+        if (tag === SET_TAG) {
+            return areSetsEqual(a, b, state);
+        }
+        // If a simple object tag, then we can prioritize a simple object comparison because
+        // it is likely a custom class.
+        if (tag === OBJECT_TAG) {
+            // The exception for value comparison is `Promise`-like contracts. These should be
+            // treated the same as standard `Promise` objects, which means strict equality, and if
+            // it reaches this point then that strict equality comparison has already failed.
+            return (typeof a.then !== 'function' &&
+                typeof b.then !== 'function' &&
+                areObjectsEqual(a, b, state));
+        }
+        // If an arguments tag, it should be treated as a standard object.
+        if (tag === ARGUMENTS_TAG) {
+            return areObjectsEqual(a, b, state);
+        }
+        // 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 (tag === BOOLEAN_TAG || tag === NUMBER_TAG || tag === STRING_TAG) {
+            return arePrimitiveWrappersEqual(a, b, state);
+        }
+        // If not matching any tags that require a specific type of comparison, then we hard-code false because
+        // the only thing remaining is strict equality, which has already been compared. This is for a few reasons:
+        //   - Certain types that cannot be introspected (e.g., `WeakMap`). For these types, 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 (may be included in a future release, if requested enough).
+        //   - For types that can be introspected but do not have an objective definition of what
+        //     equality is (`Error`, etc.), the subjective decision is to be conservative and strictly compare.
+        // In all cases, these decisions should be reevaluated based on changes to the language and
+        // common development practices.
+        return false;
+    };
+}
+
+var getOwnPropertyNames = Object.getOwnPropertyNames, getOwnPropertySymbols = Object.getOwnPropertySymbols;
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+function combineComparators(comparatorA, comparatorB) {
+    return function isEqual(a, b, state) {
+        return comparatorA(a, b, state) && comparatorB(a, b, state);
+    };
+}
+/**
+ * Default equality comparator pass-through, used as the standard `isEqual` creator for
+ * use inside the built comparator.
+ */
+function createInternalComparator(compare) {
+    return function (a, b, _indexOrKeyA, _indexOrKeyB, _parentA, _parentB, state) {
+        return compare(a, b, state);
+    };
+}
+/**
+ * Wrap the provided `areItemsEqual` method to manage the circular state, allowing
+ * for circular references to be safely included in the comparison without creating
+ * stack overflows.
+ */
+function createIsCircular(areItemsEqual) {
+    return function isCircular(a, b, state) {
+        if (!a || !b || typeof a !== 'object' || typeof b !== 'object') {
+            return areItemsEqual(a, b, state);
+        }
+        var cache = state.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, state);
+        cache.delete(a);
+        cache.delete(b);
+        return result;
+    };
+}
+function getStrictProperties(object) {
+    return getOwnPropertyNames(object).concat(getOwnPropertySymbols(object));
+}
+var hasOwn = Object.hasOwn ||
+    (function (object, property) {
+        return hasOwnProperty.call(object, property);
+    });
+/**
+ * Whether the values passed are strictly equal or both NaN.
+ */
+function sameValueZeroEqual(a, b) {
+    return a || b ? a === b : a === b || (a !== a && b !== b);
+}
+
+var OWNER = '_owner';
+var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor, keys = Object.keys;
+/**
+ * Whether the arrays are equal in value.
+ */
+function areArraysEqual(a, b, state) {
+    var index = a.length;
+    if (b.length !== index) {
+        return false;
+    }
+    while (index-- > 0) {
+        if (!state.equals(a[index], b[index], index, index, a, b, state)) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Whether the dates passed are equal in value.
+ *
+ * @NOTE
+ * This is a standalone function instead of done inline in the comparator
+ * to allow for overrides.
+ */
+function areDatesEqual(a, b) {
+    return sameValueZeroEqual(a.getTime(), b.getTime());
+}
+/**
+ * Whether the `Map`s are equal in value.
+ */
+function areMapsEqual(a, b, state) {
+    var isValueEqual = a.size === b.size;
+    if (isValueEqual && a.size) {
+        // 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_1 = {};
+        var indexA_1 = 0;
+        a.forEach(function (aValue, aKey) {
+            if (!isValueEqual) {
+                return;
+            }
+            var hasMatch = false;
+            var matchIndexB = 0;
+            b.forEach(function (bValue, bKey) {
+                if (!hasMatch &&
+                    !matchedIndices_1[matchIndexB] &&
+                    (hasMatch =
+                        state.equals(aKey, bKey, indexA_1, matchIndexB, a, b, state) &&
+                            state.equals(aValue, bValue, aKey, bKey, a, b, state))) {
+                    matchedIndices_1[matchIndexB] = true;
+                }
+                matchIndexB++;
+            });
+            indexA_1++;
+            isValueEqual = hasMatch;
+        });
+    }
+    return isValueEqual;
+}
+/**
+ * Whether the objects are equal in value.
+ */
+function areObjectsEqual(a, b, state) {
+    var properties = keys(a);
+    var index = properties.length;
+    if (keys(b).length !== index) {
+        return false;
+    }
+    var property;
+    // 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) {
+        property = properties[index];
+        if (property === OWNER &&
+            (a.$$typeof || b.$$typeof) &&
+            a.$$typeof !== b.$$typeof) {
+            return false;
+        }
+        if (!hasOwn(b, property) ||
+            !state.equals(a[property], b[property], property, property, a, b, state)) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Whether the objects are equal in value with strict property checking.
+ */
+function areObjectsEqualStrict(a, b, state) {
+    var properties = getStrictProperties(a);
+    var index = properties.length;
+    if (getStrictProperties(b).length !== index) {
+        return false;
+    }
+    var property;
+    var descriptorA;
+    var descriptorB;
+    // 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) {
+        property = properties[index];
+        if (property === OWNER &&
+            (a.$$typeof || b.$$typeof) &&
+            a.$$typeof !== b.$$typeof) {
+            return false;
+        }
+        if (!hasOwn(b, property)) {
+            return false;
+        }
+        if (!state.equals(a[property], b[property], property, property, a, b, state)) {
+            return false;
+        }
+        descriptorA = getOwnPropertyDescriptor(a, property);
+        descriptorB = getOwnPropertyDescriptor(b, property);
+        if ((descriptorA || descriptorB) &&
+            (!descriptorA ||
+                !descriptorB ||
+                descriptorA.configurable !== descriptorB.configurable ||
+                descriptorA.enumerable !== descriptorB.enumerable ||
+                descriptorA.writable !== descriptorB.writable)) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Whether the primitive wrappers passed are equal in value.
+ *
+ * @NOTE
+ * This is a standalone function instead of done inline in the comparator
+ * to allow for overrides.
+ */
+function arePrimitiveWrappersEqual(a, b) {
+    return sameValueZeroEqual(a.valueOf(), b.valueOf());
+}
+/**
+ * Whether the regexps passed are equal in value.
+ *
+ * @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.flags === b.flags;
+}
+/**
+ * Whether the `Set`s are equal in value.
+ */
+function areSetsEqual(a, b, state) {
+    var isValueEqual = a.size === b.size;
+    if (isValueEqual && a.size) {
+        // 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_2 = {};
+        a.forEach(function (aValue, aKey) {
+            if (!isValueEqual) {
+                return;
+            }
+            var hasMatch = false;
+            var matchIndex = 0;
+            b.forEach(function (bValue, bKey) {
+                if (!hasMatch &&
+                    !matchedIndices_2[matchIndex] &&
+                    (hasMatch = state.equals(aValue, bValue, aKey, bKey, a, b, state))) {
+                    matchedIndices_2[matchIndex] = true;
+                }
+                matchIndex++;
+            });
+            isValueEqual = hasMatch;
+        });
+    }
+    return isValueEqual;
+}
+
+function createComparatorConfig(_a) {
+    var circular = _a.circular, strict = _a.strict;
+    var config = {
+        areArraysEqual: areArraysEqual,
+        areDatesEqual: areDatesEqual,
+        areMapsEqual: areMapsEqual,
+        areObjectsEqual: areObjectsEqual,
+        arePrimitiveWrappersEqual: arePrimitiveWrappersEqual,
+        areRegExpsEqual: areRegExpsEqual,
+        areSetsEqual: areSetsEqual,
+    };
+    if (strict) {
+        config.areArraysEqual = areObjectsEqual;
+        config.areMapsEqual = combineComparators(areMapsEqual, areObjectsEqual);
+        config.areObjectsEqual = areObjectsEqualStrict;
+        config.areSetsEqual = combineComparators(areSetsEqual, areObjectsEqual);
+    }
+    if (circular) {
+        config.areArraysEqual = createIsCircular(config.areArraysEqual);
+        config.areMapsEqual = createIsCircular(config.areMapsEqual);
+        config.areObjectsEqual = createIsCircular(config.areObjectsEqual);
+        config.areSetsEqual = createIsCircular(config.areSetsEqual);
+    }
+    return config;
+}
+function createDefaultEqualCreator(options) {
+    if (options === void 0) { options = {}; }
+    var config = createComparatorConfig(options);
+    var isEqual = createComparator(config);
+    var isEqualComparator = options.comparator || createInternalComparator(isEqual);
+    var strict = !!options.strict;
+    if (options.circular) {
+        return function equals(a, b) {
+            return isEqual(a, b, {
+                cache: new WeakMap(),
+                equals: isEqualComparator,
+                meta: undefined,
+                strict: strict,
+            });
+        };
+    }
+    var state = Object.freeze({
+        cache: undefined,
+        equals: isEqualComparator,
+        meta: undefined,
+        strict: strict,
+    });
+    return function equals(a, b) {
+        return isEqual(a, b, state);
+    };
+}
+/**
+ * Whether the items passed are deeply-equal in value.
+ */
+var deepEqual = createDefaultEqualCreator();
+/**
+ * Whether the items passed are deeply-equal in value based on strict comparison.
+ */
+var strictDeepEqual = createDefaultEqualCreator({ strict: true });
+/**
+ * Whether the items passed are deeply-equal in value, including circular references.
+ */
+var circularDeepEqual = createDefaultEqualCreator({ circular: true });
+/**
+ * Whether the items passed are deeply-equal in value, including circular references,
+ * based on strict comparison.
+ */
+var strictCircularDeepEqual = createDefaultEqualCreator({
+    circular: true,
+    strict: true,
+});
+/**
+ * Whether the items passed are shallowly-equal in value.
+ */
+var shallowEqual = createDefaultEqualCreator({
+    comparator: sameValueZeroEqual,
+});
+/**
+ * Whether the items passed are shallowly-equal in value based on strict comparison
+ */
+var strictShallowEqual = createDefaultEqualCreator({
+    comparator: sameValueZeroEqual,
+    strict: true,
+});
+/**
+ * Whether the items passed are shallowly-equal in value, including circular references.
+ */
+var circularShallowEqual = createDefaultEqualCreator({
+    comparator: sameValueZeroEqual,
+    circular: true,
+});
+/**
+ * Whether the items passed are shallowly-equal in value, including circular references,
+ * based on strict comparison.
+ */
+var strictCircularShallowEqual = createDefaultEqualCreator({
+    comparator: sameValueZeroEqual,
+    circular: true,
+    strict: true,
+});
+/**
+ * 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(options) {
+    if (options === void 0) { options = {}; }
+    var comparator = options.comparator, createCustomInternalComparator = options.createInternalComparator, createCustomConfig = options.createCustomConfig, createState = options.createState;
+    var baseConfig = createComparatorConfig(options);
+    var config = createCustomConfig
+        ? Object.assign({}, baseConfig, createCustomConfig(baseConfig))
+        : baseConfig;
+    var isEqualCustom = comparator || createComparator(config);
+    var isEqualCustomComparator = createCustomInternalComparator
+        ? createCustomInternalComparator(isEqualCustom)
+        : createInternalComparator(isEqualCustom);
+    var strict = !!options.strict;
+    if (createState) {
+        return function isEqual(a, b, metaOverride) {
+            var customState = createState(isEqualCustom);
+            return isEqualCustom(a, b, {
+                cache: customState.cache || new WeakMap(),
+                equals: customState.equals || isEqualCustomComparator,
+                // @ts-expect-error - inferred `Meta` may be undefined, which is okay
+                meta: metaOverride !== undefined ? metaOverride : customState.meta,
+                strict: customState.strict !== undefined ? customState.strict : strict,
+            });
+        };
+    }
+    if (options.circular) {
+        return function equals(a, b) {
+            return isEqualCustom(a, b, {
+                cache: new WeakMap(),
+                equals: isEqualCustomComparator,
+                meta: undefined,
+                strict: strict,
+            });
+        };
+    }
+    var state = Object.freeze({
+        cache: undefined,
+        equals: isEqualCustomComparator,
+        meta: undefined,
+        strict: strict,
+    });
+    return function equals(a, b) {
+        return isEqualCustom(a, b, state);
+    };
+}
+
+exports.circularDeepEqual = circularDeepEqual;
+exports.circularShallowEqual = circularShallowEqual;
+exports.createCustomEqual = createCustomEqual;
+exports.deepEqual = deepEqual;
+exports.sameValueZeroEqual = sameValueZeroEqual;
+exports.shallowEqual = shallowEqual;
+exports.strictCircularDeepEqual = strictCircularDeepEqual;
+exports.strictCircularShallowEqual = strictCircularShallowEqual;
+exports.strictDeepEqual = strictDeepEqual;
+exports.strictShallowEqual = strictShallowEqual;
+//# sourceMappingURL=index.cjs.map

package/dist/cjs/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","sources":["../../src/comparator.ts","../../src/utils.ts","../../src/equals.ts","../../src/index.ts"],"sourcesContent":["import type {\n  ComparatorConfig,\n  EqualityComparator,\n  State,\n} from './internalTypes';\n\nconst ARGUMENTS_TAG = '[object Arguments]';\nconst BOOLEAN_TAG = '[object Boolean]';\nconst DATE_TAG = '[object Date]';\nconst MAP_TAG = '[object Map]';\nconst NUMBER_TAG = '[object Number]';\nconst OBJECT_TAG = '[object Object]';\nconst REG_EXP_TAG = '[object RegExp]';\nconst SET_TAG = '[object Set]';\nconst STRING_TAG = '[object String]';\n\nconst { isArray } = Array;\nconst getTag = Object.prototype.toString.call.bind(\n  Object.prototype.toString,\n) as (a: object) => string;\n\nexport function createComparator<Meta>({\n  areArraysEqual,\n  areDatesEqual,\n  areMapsEqual,\n  areObjectsEqual,\n  arePrimitiveWrappersEqual,\n  areRegExpsEqual,\n  areSetsEqual,\n}: ComparatorConfig<Meta>): EqualityComparator<Meta> {\n  /**\n   * compare the value of the two objects and return true if they are equivalent in values\n   */\n  return function comparator(a: any, b: any, state: State<Meta>): boolean {\n    // If the items are strictly equal, no need to do a value comparison.\n    if (a === b) {\n      return true;\n    }\n\n    // If the items are not non-nullish objects, then the only possibility\n    // of them being equal but not strictly is if they are both `NaN`. Since\n    // `NaN` is uniquely not equal to itself, we can use self-comparison of\n    // both objects, which is faster than `isNaN()`.\n    if (!a || !b || typeof a !== 'object' || typeof b !== 'object') {\n      return a !== a && b !== b;\n    }\n\n    // Checks are listed in order of commonality of use-case:\n    //   1. Common complex object types (plain object, array)\n    //   2. Common data values (date, regexp)\n    //   3. Less-common complex object types (map, set)\n    //   4. Less-common data values (promise, primitive wrappers)\n    // Inherently this is both subjective and assumptive, however\n    // when reviewing comparable libraries in the wild this order\n    // appears to be generally consistent.\n\n    // `isPlainObject` only checks against the object's own realm. Cross-realm\n    // comparisons are rare, and will be handled in the ultimate fallback, so\n    // we can avoid the `toString.call()` cost unless necessary.\n    if (a.constructor === Object && b.constructor === Object) {\n      return areObjectsEqual(a, b, state);\n    }\n\n    // `isArray()` works on subclasses and is cross-realm, so we can again avoid\n    // the `toString.call()` cost unless necessary by just checking if either\n    // and then both are arrays.\n    const aArray = isArray(a);\n    const bArray = isArray(b);\n\n    if (aArray || bArray) {\n      return aArray === bArray && areArraysEqual(a, b, state);\n    }\n\n    // Since this is a custom object, use the classic `toString.call()` to get its\n    // type. This is reasonably performant in modern environments like v8 and\n    // SpiderMonkey, and allows for cross-realm comparison when other checks like\n    // `instanceof` do not.\n    const tag = getTag(a);\n\n    if (tag !== getTag(b)) {\n      return false;\n    }\n\n    if (tag === DATE_TAG) {\n      return areDatesEqual(a, b, state);\n    }\n\n    if (tag === REG_EXP_TAG) {\n      return areRegExpsEqual(a, b, state);\n    }\n\n    if (tag === MAP_TAG) {\n      return areMapsEqual(a, b, state);\n    }\n\n    if (tag === SET_TAG) {\n      return areSetsEqual(a, b, state);\n    }\n\n    // If a simple object tag, then we can prioritize a simple object comparison because\n    // it is likely a custom class.\n    if (tag === OBJECT_TAG) {\n      // The exception for value comparison is `Promise`-like contracts. These should be\n      // treated the same as standard `Promise` objects, which means strict equality, and if\n      // it reaches this point then that strict equality comparison has already failed.\n      return (\n        typeof a.then !== 'function' &&\n        typeof b.then !== 'function' &&\n        areObjectsEqual(a, b, state)\n      );\n    }\n\n    // If an arguments tag, it should be treated as a standard object.\n    if (tag === ARGUMENTS_TAG) {\n      return areObjectsEqual(a, b, state);\n    }\n\n    // As the penultimate fallback, check if the values passed are primitive wrappers. This\n    // is very rare in modern JS, which is why it is deprioritized compared to all other object\n    // types.\n    if (tag === BOOLEAN_TAG || tag === NUMBER_TAG || tag === STRING_TAG) {\n      return arePrimitiveWrappersEqual(a, b, state);\n    }\n\n    // If not matching any tags that require a specific type of comparison, then we hard-code false because\n    // the only thing remaining is strict equality, which has already been compared. This is for a few reasons:\n    //   - Certain types that cannot be introspected (e.g., `WeakMap`). For these types, this is the only\n    //     comparison that can be made.\n    //   - For types that can be introspected, but rarely have requirements to be compared\n    //     (`ArrayBuffer`, `DataView`, etc.), the cost is avoided to prioritize the common\n    //     use-cases (may be included in a future release, if requested enough).\n    //   - For types that can be introspected but do not have an objective definition of what\n    //     equality is (`Error`, etc.), the subjective decision is to be conservative and strictly compare.\n    // In all cases, these decisions should be reevaluated based on changes to the language and\n    // common development practices.\n    return false;\n  };\n}\n","import {\n  AnyEqualityComparator,\n  BaseCircular,\n  CircularState,\n  Dictionary,\n  EqualityComparator,\n  InternalEqualityComparator,\n  State,\n  TypeEqualityComparator,\n} from './internalTypes';\n\nconst { getOwnPropertyNames, getOwnPropertySymbols } = Object;\nconst { hasOwnProperty } = Object.prototype;\n\nexport function combineComparators<Meta>(\n  comparatorA: AnyEqualityComparator<Meta>,\n  comparatorB: AnyEqualityComparator<Meta>,\n) {\n  return function isEqual<A, B>(a: A, b: B, state: State<Meta>) {\n    return comparatorA(a, b, state) && comparatorB(a, b, state);\n  };\n}\n\n/**\n * Default equality comparator pass-through, used as the standard `isEqual` creator for\n * use inside the built comparator.\n */\nexport function createInternalComparator<Meta>(\n  compare: EqualityComparator<Meta>,\n): InternalEqualityComparator<Meta> {\n  return function (\n    a: any,\n    b: any,\n    _indexOrKeyA: any,\n    _indexOrKeyB: any,\n    _parentA: any,\n    _parentB: any,\n    state: State<Meta>,\n  ) {\n    return compare(a, b, state);\n  };\n}\n\n/**\n * Wrap the provided `areItemsEqual` method to manage the circular state, allowing\n * for circular references to be safely included in the comparison without creating\n * stack overflows.\n */\nexport function createIsCircular<\n  AreItemsEqual extends TypeEqualityComparator<any, any>,\n>(areItemsEqual: AreItemsEqual): AreItemsEqual {\n  return function isCircular(\n    a: any,\n    b: any,\n    state: CircularState<BaseCircular>,\n  ) {\n    if (!a || !b || typeof a !== 'object' || typeof b !== 'object') {\n      return areItemsEqual(a, b, state);\n    }\n\n    const { cache } = state;\n\n    const cachedA = cache.get(a);\n    const cachedB = cache.get(b);\n\n    if (cachedA && cachedB) {\n      return cachedA === b && cachedB === a;\n    }\n\n    cache.set(a, b);\n    cache.set(b, a);\n\n    const result = areItemsEqual(a, b, state);\n\n    cache.delete(a);\n    cache.delete(b);\n\n    return result;\n  } as AreItemsEqual;\n}\n\nexport function getStrictProperties(\n  object: Dictionary,\n): Array<string | symbol> {\n  return (getOwnPropertyNames(object) as Array<string | symbol>).concat(\n    getOwnPropertySymbols(object),\n  );\n}\n\nexport const hasOwn =\n  Object.hasOwn ||\n  ((object: Dictionary, property: number | string | symbol) =>\n    hasOwnProperty.call(object, property));\n\n/**\n * Whether the values passed are strictly equal or both NaN.\n */\nexport function sameValueZeroEqual(a: any, b: any): boolean {\n  return a || b ? a === b : a === b || (a !== a && b !== b);\n}\n","import { getStrictProperties, hasOwn, sameValueZeroEqual } from './utils';\nimport type { Dictionary, State } from './internalTypes';\n\nconst OWNER = '_owner';\n\nconst { getOwnPropertyDescriptor, keys } = Object;\n\n/**\n * Whether the arrays are equal in value.\n */\nexport function areArraysEqual(a: any[], b: any[], state: State<any>) {\n  let index = a.length;\n\n  if (b.length !== index) {\n    return false;\n  }\n\n  while (index-- > 0) {\n    if (!state.equals(a[index], b[index], index, index, a, b, state)) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\n/**\n * Whether the dates passed are equal in value.\n *\n * @NOTE\n * This is a standalone function instead of done inline in the comparator\n * to allow for overrides.\n */\nexport function areDatesEqual(a: Date, b: Date): boolean {\n  return sameValueZeroEqual(a.getTime(), b.getTime());\n}\n\n/**\n * Whether the `Map`s are equal in value.\n */\nexport function areMapsEqual(\n  a: Map<any, any>,\n  b: Map<any, any>,\n  state: State<any>,\n): boolean {\n  let isValueEqual = a.size === b.size;\n\n  if (isValueEqual && a.size) {\n    // The use of `forEach()` is to avoid the transpilation cost of `for...of` comparisons, and\n    // the inability to control the performance of the resulting code. It also avoids excessive\n    // iteration compared to doing comparisons of `keys()` and `values()`. As a result, though,\n    // we cannot short-circuit the iterations; bookkeeping must be done to short-circuit the\n    // equality checks themselves.\n\n    const matchedIndices: Record<number, true> = {};\n\n    let indexA = 0;\n\n    a.forEach((aValue, aKey) => {\n      if (!isValueEqual) {\n        return;\n      }\n\n      let hasMatch = false;\n      let matchIndexB = 0;\n\n      b.forEach((bValue, bKey) => {\n        if (\n          !hasMatch &&\n          !matchedIndices[matchIndexB] &&\n          (hasMatch =\n            state.equals(aKey, bKey, indexA, matchIndexB, a, b, state) &&\n            state.equals(aValue, bValue, aKey, bKey, a, b, state))\n        ) {\n          matchedIndices[matchIndexB] = true;\n        }\n\n        matchIndexB++;\n      });\n\n      indexA++;\n      isValueEqual = hasMatch;\n    });\n  }\n\n  return isValueEqual;\n}\n\n/**\n * Whether the objects are equal in value.\n */\nexport function areObjectsEqual(\n  a: Dictionary,\n  b: Dictionary,\n  state: State<any>,\n): boolean {\n  const properties = keys(a);\n\n  let index = properties.length;\n\n  if (keys(b).length !== index) {\n    return false;\n  }\n\n  let property: string | symbol;\n\n  // Decrementing `while` showed faster results than either incrementing or\n  // decrementing `for` loop and than an incrementing `while` loop. Declarative\n  // methods like `some` / `every` were not used to avoid incurring the garbage\n  // cost of anonymous callbacks.\n  while (index-- > 0) {\n    property = properties[index]!;\n\n    if (\n      property === OWNER &&\n      (a.$$typeof || b.$$typeof) &&\n      a.$$typeof !== b.$$typeof\n    ) {\n      return false;\n    }\n\n    if (\n      !hasOwn(b, property) ||\n      !state.equals(a[property], b[property], property, property, a, b, state)\n    ) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\n/**\n * Whether the objects are equal in value with strict property checking.\n */\nexport function areObjectsEqualStrict(\n  a: Dictionary,\n  b: Dictionary,\n  state: State<any>,\n): boolean {\n  const properties = getStrictProperties(a);\n\n  let index = properties.length;\n\n  if (getStrictProperties(b).length !== index) {\n    return false;\n  }\n\n  let property: string | symbol;\n  let descriptorA: ReturnType<typeof getOwnPropertyDescriptor>;\n  let descriptorB: ReturnType<typeof getOwnPropertyDescriptor>;\n\n  // Decrementing `while` showed faster results than either incrementing or\n  // decrementing `for` loop and than an incrementing `while` loop. Declarative\n  // methods like `some` / `every` were not used to avoid incurring the garbage\n  // cost of anonymous callbacks.\n  while (index-- > 0) {\n    property = properties[index]!;\n\n    if (\n      property === OWNER &&\n      (a.$$typeof || b.$$typeof) &&\n      a.$$typeof !== b.$$typeof\n    ) {\n      return false;\n    }\n\n    if (!hasOwn(b, property)) {\n      return false;\n    }\n\n    if (\n      !state.equals(a[property], b[property], property, property, a, b, state)\n    ) {\n      return false;\n    }\n\n    descriptorA = getOwnPropertyDescriptor(a, property);\n    descriptorB = getOwnPropertyDescriptor(b, property);\n\n    if (\n      (descriptorA || descriptorB) &&\n      (!descriptorA ||\n        !descriptorB ||\n        descriptorA.configurable !== descriptorB.configurable ||\n        descriptorA.enumerable !== descriptorB.enumerable ||\n        descriptorA.writable !== descriptorB.writable)\n    ) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\n/**\n * Whether the primitive wrappers passed are equal in value.\n *\n * @NOTE\n * This is a standalone function instead of done inline in the comparator\n * to allow for overrides.\n */\nexport function arePrimitiveWrappersEqual(a: Date, b: Date): boolean {\n  return sameValueZeroEqual(a.valueOf(), b.valueOf());\n}\n\n/**\n * Whether the regexps passed are equal in value.\n *\n * @NOTE\n * This is a standalone function instead of done inline in the comparator\n * to allow for overrides. An example of this would be supporting a\n * pre-ES2015 environment where the `flags` property is not available.\n */\nexport function areRegExpsEqual(a: RegExp, b: RegExp): boolean {\n  return a.source === b.source && a.flags === b.flags;\n}\n\n/**\n * Whether the `Set`s are equal in value.\n */\nexport function areSetsEqual(\n  a: Set<any>,\n  b: Set<any>,\n  state: State<any>,\n): boolean {\n  let isValueEqual = a.size === b.size;\n\n  if (isValueEqual && a.size) {\n    // The use of `forEach()` is to avoid the transpilation cost of `for...of` comparisons, and\n    // the inability to control the performance of the resulting code. It also avoids excessive\n    // iteration compared to doing comparisons of `keys()` and `values()`. As a result, though,\n    // we cannot short-circuit the iterations; bookkeeping must be done to short-circuit the\n    // equality checks themselves.\n\n    const matchedIndices: Record<number, true> = {};\n\n    a.forEach((aValue, aKey) => {\n      if (!isValueEqual) {\n        return;\n      }\n\n      let hasMatch = false;\n      let matchIndex = 0;\n\n      b.forEach((bValue, bKey) => {\n        if (\n          !hasMatch &&\n          !matchedIndices[matchIndex] &&\n          (hasMatch = state.equals(aValue, bValue, aKey, bKey, a, b, state))\n        ) {\n          matchedIndices[matchIndex] = true;\n        }\n\n        matchIndex++;\n      });\n\n      isValueEqual = hasMatch;\n    });\n  }\n\n  return isValueEqual;\n}\n","import { createComparator } from './comparator';\nimport {\n  areArraysEqual,\n  areDatesEqual,\n  areMapsEqual,\n  areObjectsEqual,\n  areObjectsEqualStrict,\n  arePrimitiveWrappersEqual,\n  areRegExpsEqual,\n  areSetsEqual,\n} from './equals';\nimport type {\n  CircularState,\n  ComparatorConfig,\n  CreateCustomComparatorConfig,\n  CreateState,\n  DefaultState,\n  EqualityComparator,\n} from './internalTypes';\nimport {\n  combineComparators,\n  createInternalComparator,\n  createIsCircular,\n  sameValueZeroEqual,\n} from './utils';\n\nexport { sameValueZeroEqual };\n\ninterface DefaultEqualCreatorOptions<Meta> {\n  comparator?: EqualityComparator<Meta>;\n  circular?: boolean;\n  strict?: boolean;\n}\n\ninterface CustomEqualCreatorOptions<Meta>\n  extends DefaultEqualCreatorOptions<Meta> {\n  createCustomConfig?: CreateCustomComparatorConfig<Meta>;\n  createInternalComparator?: typeof createInternalComparator;\n  createState?: CreateState<Meta>;\n}\n\nfunction createComparatorConfig<Meta>({\n  circular,\n  strict,\n}: DefaultEqualCreatorOptions<Meta>) {\n  const config: ComparatorConfig<Meta> = {\n    areArraysEqual,\n    areDatesEqual,\n    areMapsEqual,\n    areObjectsEqual,\n    arePrimitiveWrappersEqual,\n    areRegExpsEqual,\n    areSetsEqual,\n  };\n\n  if (strict) {\n    config.areArraysEqual = areObjectsEqual;\n    config.areMapsEqual = combineComparators(areMapsEqual, areObjectsEqual);\n    config.areObjectsEqual = areObjectsEqualStrict;\n    config.areSetsEqual = combineComparators(areSetsEqual, areObjectsEqual);\n  }\n\n  if (circular) {\n    config.areArraysEqual = createIsCircular(config.areArraysEqual);\n    config.areMapsEqual = createIsCircular(config.areMapsEqual);\n    config.areObjectsEqual = createIsCircular(config.areObjectsEqual);\n    config.areSetsEqual = createIsCircular(config.areSetsEqual);\n  }\n\n  return config;\n}\n\nfunction createDefaultEqualCreator(\n  options: DefaultEqualCreatorOptions<undefined> = {},\n) {\n  const config = createComparatorConfig(options);\n  const isEqual = createComparator(config);\n  const isEqualComparator =\n    options.comparator || createInternalComparator(isEqual);\n  const strict = !!options.strict;\n\n  if (options.circular) {\n    return function equals<A, B>(a: A, b: B): boolean {\n      return isEqual(a, b, {\n        cache: new WeakMap(),\n        equals: isEqualComparator,\n        meta: undefined,\n        strict,\n      });\n    };\n  }\n\n  const state = Object.freeze({\n    cache: undefined,\n    equals: isEqualComparator,\n    meta: undefined,\n    strict,\n  });\n\n  return function equals<A, B>(a: A, b: B): boolean {\n    return isEqual(a, b, state);\n  };\n}\n\n/**\n * Whether the items passed are deeply-equal in value.\n */\nexport const deepEqual = createDefaultEqualCreator();\n\n/**\n * Whether the items passed are deeply-equal in value based on strict comparison.\n */\nexport const strictDeepEqual = createDefaultEqualCreator({ strict: true });\n\n/**\n * Whether the items passed are deeply-equal in value, including circular references.\n */\nexport const circularDeepEqual = createDefaultEqualCreator({ circular: true });\n\n/**\n * Whether the items passed are deeply-equal in value, including circular references,\n * based on strict comparison.\n */\nexport const strictCircularDeepEqual = createDefaultEqualCreator({\n  circular: true,\n  strict: true,\n});\n\n/**\n * Whether the items passed are shallowly-equal in value.\n */\nexport const shallowEqual = createDefaultEqualCreator({\n  comparator: sameValueZeroEqual,\n});\n\n/**\n * Whether the items passed are shallowly-equal in value based on strict comparison\n */\nexport const strictShallowEqual = createDefaultEqualCreator({\n  comparator: sameValueZeroEqual,\n  strict: true,\n});\n\n/**\n * Whether the items passed are shallowly-equal in value, including circular references.\n */\nexport const circularShallowEqual = createDefaultEqualCreator({\n  comparator: sameValueZeroEqual,\n  circular: true,\n});\n\n/**\n * Whether the items passed are shallowly-equal in value, including circular references,\n * based on strict comparison.\n */\nexport const strictCircularShallowEqual = createDefaultEqualCreator({\n  comparator: sameValueZeroEqual,\n  circular: true,\n  strict: true,\n});\n\n/**\n * Create a custom equality comparison method.\n *\n * This can be done to create very targeted comparisons in extreme hot-path scenarios\n * where the standard methods are not performant enough, but can also be used to provide\n * support for legacy environments that do not support expected features like\n * `RegExp.prototype.flags` out of the box.\n */\nexport function createCustomEqual<Meta>(\n  options: CustomEqualCreatorOptions<Meta> = {},\n) {\n  const {\n    comparator,\n    createInternalComparator: createCustomInternalComparator,\n    createCustomConfig,\n    createState,\n  } = options;\n\n  const baseConfig = createComparatorConfig(options);\n  const config = createCustomConfig\n    ? Object.assign({}, baseConfig, createCustomConfig(baseConfig))\n    : baseConfig;\n  const isEqualCustom = comparator || createComparator(config);\n  const isEqualCustomComparator = createCustomInternalComparator\n    ? createCustomInternalComparator(isEqualCustom)\n    : createInternalComparator(isEqualCustom);\n  const strict = !!options.strict;\n\n  if (createState) {\n    return function isEqual<A, B>(a: A, b: B, metaOverride?: Meta): boolean {\n      const customState = createState(isEqualCustom);\n\n      return isEqualCustom(a, b, {\n        cache: customState.cache || new WeakMap(),\n        equals: customState.equals || isEqualCustomComparator,\n        // @ts-expect-error - inferred `Meta` may be undefined, which is okay\n        meta: metaOverride !== undefined ? metaOverride : customState.meta,\n        strict: customState.strict !== undefined ? customState.strict : strict,\n      });\n    };\n  }\n\n  if (options.circular) {\n    return function equals<A, B>(a: A, b: B): boolean {\n      return isEqualCustom(a, b, {\n        cache: new WeakMap(),\n        equals: isEqualCustomComparator,\n        meta: undefined as Meta,\n        strict,\n      } as CircularState<Meta>);\n    };\n  }\n\n  const state = Object.freeze({\n    cache: undefined,\n    equals: isEqualCustomComparator,\n    meta: undefined,\n    strict,\n  });\n\n  return function equals<A, B>(a: A, b: B): boolean {\n    return isEqualCustom(a, b, state as DefaultState<Meta>);\n  };\n}\n"],"names":[],"mappings":"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"}

package/dist/cjs/types/comparator.d.ts

@@ -0,0 +1,2 @@
+import type { ComparatorConfig, EqualityComparator } from './internalTypes';
+export declare function createComparator<Meta>({ areArraysEqual, areDatesEqual, areMapsEqual, areObjectsEqual, arePrimitiveWrappersEqual, areRegExpsEqual, areSetsEqual, }: ComparatorConfig<Meta>): EqualityComparator<Meta>;

package/dist/cjs/types/equals.d.ts

@@ -0,0 +1,46 @@
+import type { Dictionary, State } from './internalTypes';
+/**
+ * Whether the arrays are equal in value.
+ */
+export declare function areArraysEqual(a: any[], b: any[], state: State<any>): boolean;
+/**
+ * Whether the dates passed are equal in value.
+ *
+ * @NOTE
+ * This is a standalone function instead of done inline in the comparator
+ * to allow for overrides.
+ */
+export declare function areDatesEqual(a: Date, b: Date): boolean;
+/**
+ * Whether the `Map`s are equal in value.
+ */
+export declare function areMapsEqual(a: Map<any, any>, b: Map<any, any>, state: State<any>): boolean;
+/**
+ * Whether the objects are equal in value.
+ */
+export declare function areObjectsEqual(a: Dictionary, b: Dictionary, state: State<any>): boolean;
+/**
+ * Whether the objects are equal in value with strict property checking.
+ */
+export declare function areObjectsEqualStrict(a: Dictionary, b: Dictionary, state: State<any>): boolean;
+/**
+ * Whether the primitive wrappers passed are equal in value.
+ *
+ * @NOTE
+ * This is a standalone function instead of done inline in the comparator
+ * to allow for overrides.
+ */
+export declare function arePrimitiveWrappersEqual(a: Date, b: Date): boolean;
+/**
+ * Whether the regexps passed are equal in value.
+ *
+ * @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.
+ */
+export declare function areRegExpsEqual(a: RegExp, b: RegExp): boolean;
+/**
+ * Whether the `Set`s are equal in value.
+ */
+export declare function areSetsEqual(a: Set<any>, b: Set<any>, state: State<any>): boolean;