fast-equals 4.0.3 → 5.0.0-beta.0

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

@@ -0,0 +1,56 @@
+import type { CreateCustomComparatorConfig, CreateState, EqualityComparator } from './internalTypes';
+import { createInternalComparator, sameValueZeroEqual } from './utils';
+export { sameValueZeroEqual };
+interface DefaultEqualCreatorOptions<Meta> {
+    comparator?: EqualityComparator<Meta>;
+    circular?: boolean;
+    strict?: boolean;
+}
+interface CustomEqualCreatorOptions<Meta> extends DefaultEqualCreatorOptions<Meta> {
+    createCustomConfig?: CreateCustomComparatorConfig<Meta>;
+    createInternalComparator?: typeof createInternalComparator;
+    createState?: CreateState<Meta>;
+}
+/**
+ * Whether the items passed are deeply-equal in value.
+ */
+export declare const deepEqual: <A, B>(a: A, b: B) => boolean;
+/**
+ * Whether the items passed are deeply-equal in value based on strict comparison.
+ */
+export declare const strictDeepEqual: <A, B>(a: A, b: B) => boolean;
+/**
+ * Whether the items passed are deeply-equal in value, including circular references.
+ */
+export declare const circularDeepEqual: <A, B>(a: A, b: B) => boolean;
+/**
+ * Whether the items passed are deeply-equal in value, including circular references,
+ * based on strict comparison.
+ */
+export declare const strictCircularDeepEqual: <A, B>(a: A, b: B) => boolean;
+/**
+ * Whether the items passed are shallowly-equal in value.
+ */
+export declare const shallowEqual: <A, B>(a: A, b: B) => boolean;
+/**
+ * Whether the items passed are shallowly-equal in value based on strict comparison
+ */
+export declare const strictShallowEqual: <A, B>(a: A, b: B) => boolean;
+/**
+ * Whether the items passed are shallowly-equal in value, including circular references.
+ */
+export declare const circularShallowEqual: <A, B>(a: A, b: B) => boolean;
+/**
+ * Whether the items passed are shallowly-equal in value, including circular references,
+ * based on strict comparison.
+ */
+export declare const strictCircularShallowEqual: <A, B>(a: A, b: B) => boolean;
+/**
+ * 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.
+ */
+export declare function createCustomEqual<Meta>(options?: CustomEqualCreatorOptions<Meta>): <A, B>(a: A, b: B, metaOverride?: Meta) => boolean;

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

@@ -0,0 +1,36 @@
+export interface BaseCircular extends Pick<WeakMap<any, any>, 'delete' | 'get'> {
+    set(key: object, value: any): any;
+}
+export type State<Meta> = CircularState<Meta> | DefaultState<Meta>;
+export interface CircularState<Meta> {
+    readonly cache: BaseCircular;
+    readonly equals: InternalEqualityComparator<Meta>;
+    meta: Meta;
+    readonly strict: boolean;
+}
+export interface DefaultState<Meta> {
+    readonly cache: undefined;
+    readonly equals: InternalEqualityComparator<Meta>;
+    meta: Meta;
+    readonly strict: boolean;
+}
+export interface Dictionary<Value = any> {
+    [key: string | symbol]: Value;
+    $$typeof?: any;
+}
+export interface ComparatorConfig<Meta> {
+    areArraysEqual: TypeEqualityComparator<any, Meta>;
+    areDatesEqual: TypeEqualityComparator<any, Meta>;
+    areMapsEqual: TypeEqualityComparator<any, Meta>;
+    areObjectsEqual: TypeEqualityComparator<any, Meta>;
+    arePrimitiveWrappersEqual: TypeEqualityComparator<any, Meta>;
+    areRegExpsEqual: TypeEqualityComparator<any, Meta>;
+    areSetsEqual: TypeEqualityComparator<any, Meta>;
+}
+export type CreateCustomComparatorConfig<Meta> = (config: ComparatorConfig<Meta>) => Partial<ComparatorConfig<Meta>>;
+export type CreateState<Meta> = (comparator: EqualityComparator<Meta>) => Partial<State<Meta>>;
+export type EqualityComparator<Meta> = <A, B>(a: A, b: B, state: State<Meta>) => boolean;
+export type AnyEqualityComparator<Meta> = (a: any, b: any, state: State<Meta>) => boolean;
+export type EqualityComparatorCreator<Meta> = (fn: EqualityComparator<Meta>) => InternalEqualityComparator<Meta>;
+export type InternalEqualityComparator<Meta> = (a: any, b: any, indexOrKeyA: any, indexOrKeyB: any, parentA: any, parentB: any, state: State<Meta>) => boolean;
+export type TypeEqualityComparator<Type, Meta = undefined> = (a: Type, b: Type, state: State<Meta>) => boolean;

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

@@ -0,0 +1,19 @@
+import { AnyEqualityComparator, Dictionary, EqualityComparator, InternalEqualityComparator, State, TypeEqualityComparator } from './internalTypes';
+export declare function combineComparators<Meta>(comparatorA: AnyEqualityComparator<Meta>, comparatorB: AnyEqualityComparator<Meta>): <A, B>(a: A, b: B, state: State<Meta>) => boolean;
+/**
+ * Default equality comparator pass-through, used as the standard `isEqual` creator for
+ * use inside the built comparator.
+ */
+export declare function createInternalComparator<Meta>(compare: EqualityComparator<Meta>): InternalEqualityComparator<Meta>;
+/**
+ * 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.
+ */
+export declare function createIsCircular<AreItemsEqual extends TypeEqualityComparator<any, any>>(areItemsEqual: AreItemsEqual): AreItemsEqual;
+export declare function getStrictProperties(object: Dictionary): Array<string | symbol>;
+export declare const hasOwn: (o: object, v: PropertyKey) => boolean;
+/**
+ * Whether the values passed are strictly equal or both NaN.
+ */
+export declare function sameValueZeroEqual(a: any, b: any): boolean;

package/dist/esm/index.mjs

@@ -0,0 +1,499 @@
+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);
+    };
+}
+
+export { circularDeepEqual, circularShallowEqual, createCustomEqual, deepEqual, sameValueZeroEqual, shallowEqual, strictCircularDeepEqual, strictCircularShallowEqual, strictDeepEqual, strictShallowEqual };
+//# sourceMappingURL=index.mjs.map