fast-equals 5.0.0-beta.2 → 5.0.0-beta.3

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

@@ -1,2 +1,9 @@
-import type { ComparatorConfig, EqualityComparator } from './internalTypes';
+import type { ComparatorConfig, CustomEqualCreatorOptions, EqualityComparator } from './internalTypes';
+/**
+ * Create a comparator method based on the type-specific equality comparators passed.
+ */
 export declare function createComparator<Meta>({ areArraysEqual, areDatesEqual, areMapsEqual, areObjectsEqual, arePrimitiveWrappersEqual, areRegExpsEqual, areSetsEqual, }: ComparatorConfig<Meta>): EqualityComparator<Meta>;
+/**
+ * Create the configuration object used for building comparators.
+ */
+export declare function createComparatorConfig<Meta>({ circular, createCustomConfig, strict, }: CustomEqualCreatorOptions<Meta>): ComparatorConfig<Meta>;

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

@@ -5,10 +5,6 @@ import type { Dictionary, State } from './internalTypes';
 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;
 /**
@@ -25,19 +21,10 @@ export declare function areObjectsEqual(a: Dictionary, b: Dictionary, state: Sta
 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;
 /**

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

@@ -1,51 +1,41 @@
-import type { CreateCustomComparatorConfig, CreateState, EqualityComparator } from './internalTypes';
-import { createInternalComparator, sameValueZeroEqual } from './utils';
+import type { CustomEqualCreatorOptions } from './internalTypes';
+import { sameValueZeroEqual } from './utils';
 export { sameValueZeroEqual };
 export * from './internalTypes';
-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;
+export declare const deepEqual: <A, B>(a: A, b: B, metaOverride?: unknown) => 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;
+export declare const strictDeepEqual: <A, B>(a: A, b: B, metaOverride?: unknown) => boolean;
 /**
  * Whether the items passed are deeply-equal in value, including circular references.
  */
-export declare const circularDeepEqual: <A, B>(a: A, b: B) => boolean;
+export declare const circularDeepEqual: <A, B>(a: A, b: B, metaOverride?: unknown) => 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;
+export declare const strictCircularDeepEqual: <A, B>(a: A, b: B, metaOverride?: unknown) => boolean;
 /**
  * Whether the items passed are shallowly-equal in value.
  */
-export declare const shallowEqual: <A, B>(a: A, b: B) => boolean;
+export declare const shallowEqual: <A, B>(a: A, b: B, metaOverride?: unknown) => 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;
+export declare const strictShallowEqual: <A, B>(a: A, b: B, metaOverride?: unknown) => boolean;
 /**
  * Whether the items passed are shallowly-equal in value, including circular references.
  */
-export declare const circularShallowEqual: <A, B>(a: A, b: B) => boolean;
+export declare const circularShallowEqual: <A, B>(a: A, b: B, metaOverride?: unknown) => 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;
+export declare const strictCircularShallowEqual: <A, B>(a: A, b: B, metaOverride?: unknown) => boolean;
 /**
  * Create a custom equality comparison method.
  *
@@ -54,4 +44,4 @@ export declare const strictCircularShallowEqual: <A, B>(a: A, b: B) => boolean;
  * 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;
+export declare function createCustomEqual<Meta>(options?: CustomEqualCreatorOptions<Meta>): <A, B>(a: A, b: B, metaOverride?: Meta | undefined) => boolean;

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

@@ -34,3 +34,11 @@ export type AnyEqualityComparator<Meta> = (a: any, b: any, state: State<Meta>) =
 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;
+export interface CustomEqualCreatorOptions<Meta> {
+    circular?: boolean;
+    comparator?: EqualityComparator<Meta>;
+    createCustomConfig?: CreateCustomComparatorConfig<Meta>;
+    createInternalComparator?: <Meta>(compare: EqualityComparator<Meta>) => InternalEqualityComparator<Meta>;
+    createState?: CreateState<Meta>;
+    strict?: boolean;
+}

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

@@ -1,4 +1,7 @@
 import { AnyEqualityComparator, Dictionary, EqualityComparator, InternalEqualityComparator, State, TypeEqualityComparator } from './internalTypes';
+/**
+ * Combine two comparators into a single comparators.
+ */
 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
@@ -11,7 +14,14 @@ export declare function createInternalComparator<Meta>(compare: EqualityComparat
  * stack overflows.
  */
 export declare function createIsCircular<AreItemsEqual extends TypeEqualityComparator<any, any>>(areItemsEqual: AreItemsEqual): AreItemsEqual;
+/**
+ * Get the properties to strictly examine, which include both own properties that are
+ * not enumerable and symbol properties.
+ */
 export declare function getStrictProperties(object: Dictionary): Array<string | symbol>;
+/**
+ * Whether the object contains the property passed as an own property.
+ */
 export declare const hasOwn: (o: object, v: PropertyKey) => boolean;
 /**
  * Whether the values passed are strictly equal or both NaN.

package/dist/esm/index.mjs

@@ -1,110 +1,8 @@
-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;
+/**
+ * Combine two comparators into a single comparators.
+ */
 function combineComparators(comparatorA, comparatorB) {
     return function isEqual(a, b, state) {
         return comparatorA(a, b, state) && comparatorB(a, b, state);
@@ -143,9 +41,16 @@ function createIsCircular(areItemsEqual) {
         return result;
     };
 }
+/**
+ * Get the properties to strictly examine, which include both own properties that are
+ * not enumerable and symbol properties.
+ */
 function getStrictProperties(object) {
     return getOwnPropertyNames(object).concat(getOwnPropertySymbols(object));
 }
+/**
+ * Whether the object contains the property passed as an own property.
+ */
 var hasOwn = Object.hasOwn ||
     (function (object, property) {
         return hasOwnProperty.call(object, property);
@@ -176,10 +81,6 @@ function areArraysEqual(a, b, state) {
 }
 /**
  * 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());
@@ -291,21 +192,12 @@ function areObjectsEqualStrict(a, b, state) {
 }
 /**
  * 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;
@@ -342,94 +234,191 @@ function areSetsEqual(a, b, state) {
     return isValueEqual;
 }
 
+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 assign = Object.assign;
+var getTag = Object.prototype.toString.call.bind(Object.prototype.toString);
+/**
+ * Create a comparator method based on the type-specific equality comparators passed.
+ */
+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;
+    };
+}
+/**
+ * Create the configuration object used for building comparators.
+ */
 function createComparatorConfig(_a) {
-    var circular = _a.circular, strict = _a.strict;
+    var circular = _a.circular, createCustomConfig = _a.createCustomConfig, strict = _a.strict;
     var config = {
-        areArraysEqual: areArraysEqual,
+        areArraysEqual: strict
+            ? areObjectsEqualStrict
+            : areArraysEqual,
         areDatesEqual: areDatesEqual,
-        areMapsEqual: areMapsEqual,
-        areObjectsEqual: areObjectsEqual,
+        areMapsEqual: strict
+            ? combineComparators(areMapsEqual, areObjectsEqualStrict)
+            : areMapsEqual,
+        areObjectsEqual: strict
+            ? areObjectsEqualStrict
+            : areObjectsEqual,
         arePrimitiveWrappersEqual: arePrimitiveWrappersEqual,
         areRegExpsEqual: areRegExpsEqual,
-        areSetsEqual: areSetsEqual,
+        areSetsEqual: strict
+            ? combineComparators(areSetsEqual, areObjectsEqualStrict)
+            : areSetsEqual,
     };
-    if (strict) {
-        config.areArraysEqual = areObjectsEqual;
-        config.areMapsEqual = combineComparators(areMapsEqual, areObjectsEqual);
-        config.areObjectsEqual = areObjectsEqualStrict;
-        config.areSetsEqual = combineComparators(areSetsEqual, areObjectsEqual);
+    if (createCustomConfig) {
+        config = assign({}, config, createCustomConfig(config));
     }
     if (circular) {
-        config.areArraysEqual = createIsCircular(config.areArraysEqual);
-        config.areMapsEqual = createIsCircular(config.areMapsEqual);
-        config.areObjectsEqual = createIsCircular(config.areObjectsEqual);
-        config.areSetsEqual = createIsCircular(config.areSetsEqual);
+        var areArraysEqual$1 = createIsCircular(config.areArraysEqual);
+        var areMapsEqual$1 = createIsCircular(config.areMapsEqual);
+        var areObjectsEqual$1 = createIsCircular(config.areObjectsEqual);
+        var areSetsEqual$1 = createIsCircular(config.areSetsEqual);
+        config = assign({}, config, {
+            areArraysEqual: areArraysEqual$1,
+            areMapsEqual: areMapsEqual$1,
+            areObjectsEqual: areObjectsEqual$1,
+            areSetsEqual: areSetsEqual$1,
+        });
     }
     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();
+var deepEqual = createCustomEqual();
 /**
  * Whether the items passed are deeply-equal in value based on strict comparison.
  */
-var strictDeepEqual = createDefaultEqualCreator({ strict: true });
+var strictDeepEqual = createCustomEqual({ strict: true });
 /**
  * Whether the items passed are deeply-equal in value, including circular references.
  */
-var circularDeepEqual = createDefaultEqualCreator({ circular: true });
+var circularDeepEqual = createCustomEqual({ circular: true });
 /**
  * Whether the items passed are deeply-equal in value, including circular references,
  * based on strict comparison.
  */
-var strictCircularDeepEqual = createDefaultEqualCreator({
+var strictCircularDeepEqual = createCustomEqual({
     circular: true,
     strict: true,
 });
 /**
  * Whether the items passed are shallowly-equal in value.
  */
-var shallowEqual = createDefaultEqualCreator({
+var shallowEqual = createCustomEqual({
     comparator: sameValueZeroEqual,
 });
 /**
  * Whether the items passed are shallowly-equal in value based on strict comparison
  */
-var strictShallowEqual = createDefaultEqualCreator({
+var strictShallowEqual = createCustomEqual({
     comparator: sameValueZeroEqual,
     strict: true,
 });
 /**
  * Whether the items passed are shallowly-equal in value, including circular references.
  */
-var circularShallowEqual = createDefaultEqualCreator({
+var circularShallowEqual = createCustomEqual({
     comparator: sameValueZeroEqual,
     circular: true,
 });
@@ -437,7 +426,7 @@ var circularShallowEqual = createDefaultEqualCreator({
  * Whether the items passed are shallowly-equal in value, including circular references,
  * based on strict comparison.
  */
-var strictCircularShallowEqual = createDefaultEqualCreator({
+var strictCircularShallowEqual = createCustomEqual({
     comparator: sameValueZeroEqual,
     circular: true,
     strict: true,
@@ -452,35 +441,31 @@ var strictCircularShallowEqual = createDefaultEqualCreator({
  */
 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;
+    var circular = options.circular, comparator = options.comparator, createCustomInternalComparator = options.createInternalComparator, createState = options.createState, _a = options.strict, baseStrict = _a === void 0 ? false : _a;
+    var config = createComparatorConfig(options);
+    var isEqualCustom = createComparator(config);
+    var isEqualCustomComparator = comparator ||
+        (createCustomInternalComparator
+            ? createCustomInternalComparator(isEqualCustom)
+            : createInternalComparator(isEqualCustom));
     if (createState) {
         return function isEqual(a, b, metaOverride) {
-            var customState = createState(isEqualCustom);
+            var _a = createState(isEqualCustom), _b = _a.cache, cache = _b === void 0 ? circular ? new WeakMap() : undefined : _b, _c = _a.equals, equals = _c === void 0 ? isEqualCustomComparator : _c, meta = _a.meta, _d = _a.strict, strict = _d === void 0 ? baseStrict : _d;
             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,
+                cache: cache,
+                equals: equals,
+                meta: metaOverride !== undefined ? metaOverride : meta,
+                strict: strict,
             });
         };
     }
-    if (options.circular) {
+    if (circular) {
         return function equals(a, b) {
             return isEqualCustom(a, b, {
                 cache: new WeakMap(),
                 equals: isEqualCustomComparator,
                 meta: undefined,
-                strict: strict,
+                strict: baseStrict,
             });
         };
     }
@@ -488,7 +473,7 @@ function createCustomEqual(options) {
         cache: undefined,
         equals: isEqualCustomComparator,
         meta: undefined,
-        strict: strict,
+        strict: baseStrict,
     });
     return function equals(a, b) {
         return isEqualCustom(a, b, state);