fast-equals 6.0.0-beta.0 → 6.0.0-rc.0

package/README.md

@@ -34,7 +34,7 @@ customize any specific type comparison based on your application's use-cases.
     - [deepEqual](#deepequal)
       - [Comparing `Map`s](#comparing-maps)
     - [shallowEqual](#shallowequal)
-    - [sameValueZeroEqual](#samevaluezeroequal)
+    - [sameValueEqual](#samevalueequal)
     - [circularDeepEqual](#circulardeepequal)
     - [circularShallowEqual](#circularshallowequal)
     - [strictDeepEqual](#strictdeepequal)
@@ -42,7 +42,7 @@ customize any specific type comparison based on your application's use-cases.
     - [strictCircularDeepEqual](#strictcirculardeepequal)
     - [strictCircularShallowEqual](#strictcircularshallowequal)
     - [createCustomEqual](#createcustomequal)
-      - [unknownTagComparators](#unknowntagcomparators)
+      - [getUnsupportedCustomComparator](#getunsupportedcustomcomparator)
       - [Recipes](#recipes)
   - [Benchmarks](#benchmarks)
   - [Development](#development)
@@ -120,14 +120,17 @@ console.log(shallowEqual(objectA, objectB)); // true
 console.log(shallowEqual(objectA, objectC)); // false
 ```
 
-### sameValueZeroEqual
+### sameValueEqual
 
-Performs a [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) comparison on the two
-objects passed and returns a boolean representing the value equivalency of the objects. In simple terms, this means
-either strictly equal or both `NaN`.
+Performs a [`SameValue`](http://ecma-international.org/ecma-262/7.0/#sec-samevalue) comparison on the two objects passed
+and returns a boolean representing the value equivalency of the objects. In simple terms, this means:
+
+- `+0` and `-0` are not equal
+- `NaN` is equal to `NaN`
+- All other items are based on referential equality (`a === b`)
 
 ```ts
-import { sameValueZeroEqual } from 'fast-equals';
+import { sameValueEqual } from 'fast-equals';
 
 const mainObject = { foo: NaN, bar: 'baz' };
 
@@ -135,11 +138,15 @@ const objectA = 'baz';
 const objectB = NaN;
 const objectC = { foo: NaN, bar: 'baz' };
 
-console.log(sameValueZeroEqual(mainObject.bar, objectA)); // true
-console.log(sameValueZeroEqual(mainObject.foo, objectB)); // true
-console.log(sameValueZeroEqual(mainObject, objectC)); // false
+console.log(sameValueEqual(mainObject.bar, objectA)); // true
+console.log(sameValueEqual(mainObject.foo, objectB)); // true
+console.log(sameValueEqual(mainObject, objectC)); // false
 ```
 
+**NOTE**: In environments that support
+[`Object.is`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is), this is just
+a re-export of that method.
+
 ### circularDeepEqual
 
 Performs the same comparison as `deepEqual` but supports circular objects. It is slower than `deepEqual`, so only use if
@@ -298,18 +305,21 @@ interface Cache<Key extends object, Value> {
 }
 
 interface ComparatorConfig<Meta> {
-  areArraysEqual: TypeEqualityComparator<any[], Meta>;
+  areArrayBuffersEcqual: TypeEqualityComparator<ArrayBuffer, Meta>;
+  areArraysEcqual: TypeEqualityComparator<any[], Meta>;
+  areDataViewsEqual: TypeEqualityComparator<DataView, Meta>;
   areDatesEqual: TypeEqualityComparator<Date, Meta>;
   areErrorsEqual: TypeEqualityComparator<Error, Meta>;
   areFunctionsEqual: TypeEqualityComparator<(...args: any[]) => any, Meta>;
   areMapsEqual: TypeEqualityComparator<Map<any, any>, Meta>;
+  areNumbersEqual: TypeEqualityComparator<number, Meta>;
   areObjectsEqual: TypeEqualityComparator<Record<string, any>, Meta>;
-  arePrimitiveWrappersEqual: TypeEqualityComparator<boolean | string | number, Meta>;
+  arePrimitiveWrappersEqual: TypeEqualityComparator<Boolean | Number | String, Meta>;
   areRegExpsEqual: TypeEqualityComparator<RegExp, Meta>;
   areSetsEqual: TypeEqualityComparator<Set<any>, Meta>;
   areTypedArraysEqual: TypeEqualityComparator<TypedArray, Meta>;
   areUrlsEqual: TypeEqualityComparator<URL, Meta>;
-  unknownTagComparators: Record<string, TypeEqualityComparator<string, any>>;
+  getUnsupportedCustomComparator: <Type>(a: Type, b: Type, tag: string) => TypeEqualityComparator<Type, Meta>;
 }
 
 function createCustomEqual<Meta>(options: {
@@ -332,10 +342,11 @@ _**NOTE**: `Map` implementations compare equality for both keys and value. When
 equality of the keys, the iteration index is provided as both `indexOrKeyA` and `indexOrKeyB` to help use-cases where
 ordering of keys matters to equality._
 
-#### unknownTagComparators
+#### getUnsupportedCustomComparator
 
 If you want to compare objects that have a custom `@@toStringTag`, you can provide a map of the custom tags you want to
-support via the `unknownTagComparators` option. See [this recipe]('./recipes/special-objects.md) for an example.
+support via the `getUnsupportedCustomComparator` option. See [this recipe]('./recipes/special-objects.md) for an
+example.
 
 #### Recipes
 
@@ -348,12 +359,12 @@ to the problem you are solving, they can offer guidance of how to structure your
 - [Comparing non-standard properties](./recipes/non-standard-properties.md)
 - [Strict property descriptor comparison](./recipes/strict-property-descriptor-check.md)
 - [Legacy environment support for circualr equal comparators](./recipes/legacy-circular-equal-support.md)
-- [Custom `@@toStringTag` support](./recipes/special-objects.md)
+- [Custom comparator support](./recipes/special-objects.md)
 
 ## Benchmarks
 
 All benchmarks were performed on an i9-11900H Ubuntu Linux 24.04 laptop with 64GB of memory using NodeJS version
-`20.17.0`, and are based on averages of running comparisons based deep equality on the following object types:
+`24.11.1`, and are based on averages of running comparisons based deep equality on the following object types:
 
 - Primitives (`String`, `Number`, `null`, `undefined`)
 - `Function`
@@ -365,74 +376,73 @@ All benchmarks were performed on an i9-11900H Ubuntu Linux 24.04 laptop with 64G
 - A mixed object with a combination of all the above types
 
 ```bash
-Testing mixed objects equal...
 ┌────────────────────────────────────────┬────────────────┐
 │ Name                                   │ Ops / sec      │
 ├────────────────────────────────────────┼────────────────┤
-│ fast-equals (passed)                   │ 1416193.769468 │
+│ fast-equals (passed)                   │ 1544237.29413  │
 ├────────────────────────────────────────┼────────────────┤
-│ fast-deep-equal (passed)               │ 1284824.583215 │
+│ fast-deep-equal (passed)               │ 1328583.767745 │
 ├────────────────────────────────────────┼────────────────┤
-│ react-fast-compare (passed)            │ 1246947.505444 │
+│ react-fast-compare (passed)            │ 1301727.296375 │
 ├────────────────────────────────────────┼────────────────┤
-│ shallow-equal-fuzzy (passed)           │ 1238082.379207 │
+│ shallow-equal-fuzzy (passed)           │ 1225981.400919 │
 ├────────────────────────────────────────┼────────────────┤
-│ nano-equal (failed)                    │ 946782.33704   │
+│ nano-equal (failed)                    │ 969495.538753  │
 ├────────────────────────────────────────┼────────────────┤
-│ dequal/lite (passed)                   │ 758213.632866  │
+│ fast-equals (circular) (passed)        │ 813716.49516   │
 ├────────────────────────────────────────┼────────────────┤
-│ dequal (passed)                        │ 756789.655029  │
+│ dequal/lite (passed)                   │ 780805.627339  │
 ├────────────────────────────────────────┼────────────────┤
-│ fast-equals (circular) (passed)        │ 726093.253185  │
+│ dequal (passed)                        │ 767208.995048  │
 ├────────────────────────────────────────┼────────────────┤
-│ underscore.isEqual (passed)            │ 489748.701783  │
+│ underscore.isEqual (passed)            │ 490695.830468  │
 ├────────────────────────────────────────┼────────────────┤
-│ assert.deepStrictEqual (passed)        │ 453761.890107  │
+│ assert.deepStrictEqual (passed)        │ 471011.425391  │
 ├────────────────────────────────────────┼────────────────┤
-│ lodash.isEqual (passed)                │ 288264.867811  │
+│ lodash.isEqual (passed)                │ 296064.057382  │
 ├────────────────────────────────────────┼────────────────┤
-│ fast-equals (strict) (passed)          │ 217221.619705  │
+│ fast-equals (strict) (passed)          │ 225894.800964  │
 ├────────────────────────────────────────┼────────────────┤
-│ fast-equals (strict circular) (passed) │ 186916.942934  │
+│ fast-equals (strict circular) (passed) │ 195657.732354  │
 ├────────────────────────────────────────┼────────────────┤
-│ deep-eql (passed)                      │ 162487.877883  │
+│ deep-eql (passed)                      │ 162718.102328  │
 ├────────────────────────────────────────┼────────────────┤
-│ deep-equal (passed)                    │ 916.680714     │
+│ deep-equal (passed)                    │ 954.172311     │
 └────────────────────────────────────────┴────────────────┘
 
 Testing mixed objects not equal...
 ┌────────────────────────────────────────┬────────────────┐
 │ Name                                   │ Ops / sec      │
 ├────────────────────────────────────────┼────────────────┤
-│ fast-equals (passed)                   │ 4687012.640614 │
+│ fast-equals (passed)                   │ 5112341.000979 │
 ├────────────────────────────────────────┼────────────────┤
-│ fast-deep-equal (passed)               │ 3418170.156109 │
+│ fast-equals (circular) (passed)        │ 3501225.300307 │
 ├────────────────────────────────────────┼────────────────┤
-│ react-fast-compare (passed)            │ 3283516.669966 │
+│ fast-deep-equal (passed)               │ 3471838.735181 │
 ├────────────────────────────────────────┼────────────────┤
-│ fast-equals (circular) (passed)        │ 3268062.099602 │
+│ react-fast-compare (passed)            │ 3439612.908273 │
 ├────────────────────────────────────────┼────────────────┤
-│ fast-equals (strict) (passed)          │ 1747578.66456  │
+│ fast-equals (strict) (passed)          │ 1797319.423491 │
 ├────────────────────────────────────────┼────────────────┤
-│ fast-equals (strict circular) (passed) │ 1477873.624956 │
+│ fast-equals (strict circular) (passed) │ 1534168.229167 │
 ├────────────────────────────────────────┼────────────────┤
-│ dequal/lite (passed)                   │ 1335397.839502 │
+│ dequal/lite (passed)                   │ 1357981.758571 │
 ├────────────────────────────────────────┼────────────────┤
-│ dequal (passed)                        │ 1319426.71146  │
+│ dequal (passed)                        │ 1328078.173967 │
 ├────────────────────────────────────────┼────────────────┤
-│ shallow-equal-fuzzy (failed)           │ 1237432.986615 │
+│ shallow-equal-fuzzy (failed)           │ 1224747.272118 │
 ├────────────────────────────────────────┼────────────────┤
-│ nano-equal (passed)                    │ 1064383.319776 │
+│ nano-equal (passed)                    │ 1087373.99615  │
 ├────────────────────────────────────────┼────────────────┤
-│ underscore.isEqual (passed)            │ 920462.516736  │
+│ underscore.isEqual (passed)            │ 927298.592729  │
 ├────────────────────────────────────────┼────────────────┤
-│ lodash.isEqual (passed)                │ 379370.998021  │
+│ lodash.isEqual (passed)                │ 387294.235476  │
 ├────────────────────────────────────────┼────────────────┤
-│ deep-eql (passed)                      │ 184111.383127  │
+│ deep-eql (passed)                      │ 186028.168827  │
 ├────────────────────────────────────────┼────────────────┤
-│ assert.deepStrictEqual (passed)        │ 20775.59065    │
+│ assert.deepStrictEqual (passed)        │ 21261.312424   │
 ├────────────────────────────────────────┼────────────────┤
-│ deep-equal (passed)                    │ 3678.51009     │
+│ deep-equal (passed)                    │ 3782.329948    │
 └────────────────────────────────────────┴────────────────┘
 ```
 
@@ -442,17 +452,17 @@ Caveats that impact the benchmark (and accuracy of comparison):
   fully supported their comparison
 - `fast-deep-equal`, `react-fast-compare` and `nano-equal` throw on objects with `null` as prototype
   (`Object.create(null)`)
-- `assert.deepStrictEqual` does not support `NaN` or `SameValueZero` equality for dates
-- `deep-eql` does not support `SameValueZero` equality for zero equality (positive and negative zero are not equal)
+- `assert.deepStrictEqual` does not support `NaN` or `SameValue` equality for dates
+- `deep-eql` does not support `SameValue` equality for zero equality (positive and negative zero are not equal)
 - `deep-equal` does not support `NaN` and does not strictly compare object type, or date / regexp values, nor uses
-  `SameValueZero` equality for dates
-- `fast-deep-equal` does not support `NaN` or `SameValueZero` equality for dates
-- `nano-equal` does not strictly compare object property structure, array length, or object type, nor `SameValueZero`
+  `SameValue` equality for dates
+- `fast-deep-equal` does not support `NaN` or `SameValue` equality for dates
+- `nano-equal` does not strictly compare object property structure, array length, or object type, nor `SameValue`
   equality for dates
-- `react-fast-compare` does not support `NaN` or `SameValueZero` equality for dates, and does not compare `function`
+- `react-fast-compare` does not support `NaN` or `SameValue` equality for dates, and does not compare `function`
   equality
-- `shallow-equal-fuzzy` does not strictly compare object type or regexp values, nor `SameValueZero` equality for dates
-- `underscore.isEqual` does not support `SameValueZero` equality for primitives or dates
+- `shallow-equal-fuzzy` does not strictly compare object type or regexp values, nor `SameValue` equality for dates
+- `underscore.isEqual` does not support `SameValue` equality for primitives or dates
 
 All of these have the potential of inflating the respective library's numbers in comparison to `fast-equals`, but it was
 the closest apples-to-apples comparison I could create of a reasonable sample size. It should be noted that `react`

package/dist/cjs/index.cjs

@@ -35,12 +35,6 @@ function createIsCircular(areItemsEqual) {
         return result;
     };
 }
-/**
- * Get the `@@toStringTag` of the value, if it exists.
- */
-function getShortTag(value) {
-    return value != null ? value[Symbol.toStringTag] : undefined;
-}
 /**
  * Get the properties to strictly examine, which include both own properties that are
  * not enumerable and symbol properties.
@@ -57,9 +51,12 @@ Object.hasOwn || ((object, property) => hasOwnProperty.call(object, property));
 /**
  * Whether the values passed are strictly equal or both NaN.
  */
-function sameValueZeroEqual(a, b) {
-    return a === b || (!a && !b && a !== a && b !== b);
-}
+const sameValueEqual = 
+// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+Object.is
+    || function sameValueEqual(a, b) {
+        return a === b ? a !== 0 || 1 / a === 1 / b : a !== a && b !== b;
+    };
 
 const PREACT_VNODE = '__v';
 const PREACT_OWNER = '__o';
@@ -97,7 +94,7 @@ function areDataViewsEqual(a, b) {
  * Whether the dates passed are equal in value.
  */
 function areDatesEqual(a, b) {
-    return sameValueZeroEqual(a.getTime(), b.getTime());
+    return sameValueEqual(a.getTime(), b.getTime());
 }
 /**
  * Whether the errors passed are equal in value.
@@ -163,7 +160,7 @@ function areMapsEqual(a, b, state) {
 /**
  * Whether the numbers are equal in value.
  */
-const areNumbersEqual = sameValueZeroEqual;
+const areNumbersEqual = sameValueEqual;
 /**
  * Whether the objects are equal in value.
  */
@@ -222,7 +219,7 @@ function areObjectsEqualStrict(a, b, state) {
  * Whether the primitive wrappers passed are equal in value.
  */
 function arePrimitiveWrappersEqual(a, b) {
-    return sameValueZeroEqual(a.valueOf(), b.valueOf());
+    return sameValueEqual(a.valueOf(), b.valueOf());
 }
 /**
  * Whether the regexps passed are equal in value.
@@ -306,39 +303,14 @@ function isPropertyEqual(a, b, state, property) {
     return hasOwn(b, property) && state.equals(a[property], b[property], property, property, a, b, state);
 }
 
-const ARRAY_BUFFER_TAG = '[object ArrayBuffer]';
-const ARGUMENTS_TAG = '[object Arguments]';
-const BOOLEAN_TAG = '[object Boolean]';
-const DATA_VIEW_TAG = '[object DataView]';
-const DATE_TAG = '[object Date]';
-const ERROR_TAG = '[object Error]';
-const MAP_TAG = '[object Map]';
-const NUMBER_TAG = '[object Number]';
-const OBJECT_TAG = '[object Object]';
-const REG_EXP_TAG = '[object RegExp]';
-const SET_TAG = '[object Set]';
-const STRING_TAG = '[object String]';
-const TYPED_ARRAY_TAGS = {
-    '[object Int8Array]': true,
-    '[object Uint8Array]': true,
-    '[object Uint8ClampedArray]': true,
-    '[object Int16Array]': true,
-    '[object Uint16Array]': true,
-    '[object Int32Array]': true,
-    '[object Uint32Array]': true,
-    '[object Float16Array]': true,
-    '[object Float32Array]': true,
-    '[object Float64Array]': true,
-    '[object BigInt64Array]': true,
-    '[object BigUint64Array]': true,
-};
-const URL_TAG = '[object URL]';
 // eslint-disable-next-line @typescript-eslint/unbound-method
 const toString = Object.prototype.toString;
 /**
  * Create a comparator method based on the type-specific equality comparators passed.
  */
-function createEqualityComparator({ areArrayBuffersEqual, areArraysEqual, areDataViewsEqual, areDatesEqual, areErrorsEqual, areFunctionsEqual, areMapsEqual, areNumbersEqual, areObjectsEqual, arePrimitiveWrappersEqual, areRegExpsEqual, areSetsEqual, areTypedArraysEqual, areUrlsEqual, unknownTagComparators, }) {
+function createEqualityComparator(config) {
+    const supportedComparatorMap = createSupportedComparatorMap(config);
+    const { areArraysEqual, areDatesEqual, areFunctionsEqual, areMapsEqual, areNumbersEqual, areObjectsEqual, areRegExpsEqual, areSetsEqual, getUnsupportedCustomComparator, } = config;
     /**
      * compare the value of the two objects and return true if they are equivalent in values
      */
@@ -357,7 +329,7 @@ function createEqualityComparator({ areArrayBuffersEqual, areArraysEqual, areDat
             return false;
         }
         if (type !== 'object') {
-            if (type === 'number') {
+            if (type === 'number' || type === 'bigint') {
                 return areNumbersEqual(a, b, state);
             }
             if (type === 'function') {
@@ -380,22 +352,17 @@ function createEqualityComparator({ areArrayBuffersEqual, areArraysEqual, areDat
         if (constructor !== b.constructor) {
             return false;
         }
-        // `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 capturing the string tag.
-        if (constructor === Object) {
-            return areObjectsEqual(a, b, state);
-        }
-        // `isArray()` works on subclasses and is cross-realm, so we can avoid capturing
-        // the string tag or doing an `instanceof` check.
-        if (Array.isArray(a)) {
-            return areArraysEqual(a, b, state);
-        }
         // Try to fast-path equality checks for other complex object types in the
         // same realm to avoid capturing the string tag. Strict equality is used
         // instead of `instanceof` because it is more performant for the common
         // use-case. If someone is subclassing a native class, it will be handled
         // with the string tag comparison.
+        if (constructor === Object) {
+            return areObjectsEqual(a, b, state);
+        }
+        if (constructor === Array) {
+            return areArraysEqual(a, b, state);
+        }
         if (constructor === Date) {
             return areDatesEqual(a, b, state);
         }
@@ -408,71 +375,26 @@ function createEqualityComparator({ areArrayBuffersEqual, areArraysEqual, areDat
         if (constructor === Set) {
             return areSetsEqual(a, b, state);
         }
+        if (constructor === Promise) {
+            // Avoid tag checks for promise values, since we know if they are not referentially equal
+            // then they are not equal.
+            return false;
+        }
+        // `isArray()` works on subclasses and is cross-realm, so we can avoid capturing
+        // the string tag or doing an `instanceof` in edge cases.
+        if (Array.isArray(a)) {
+            return areArraysEqual(a, b, state);
+        }
         // Since this is a custom object, capture the string tag to determing its type.
         // This is reasonably performant in modern environments like v8 and SpiderMonkey.
         const tag = toString.call(a);
-        if (tag === DATE_TAG) {
-            return areDatesEqual(a, b, state);
-        }
-        // For RegExp, the properties are not enumerable, and therefore will give false positives if
-        // tested like a standard object.
-        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 (tag === OBJECT_TAG) {
-            // The exception for value comparison is custom `Promise`-like class instances. 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 a URL tag, it should be tested explicitly. Like RegExp, the properties are not
-        // enumerable, and therefore will give false positives if tested like a standard object.
-        if (tag === URL_TAG) {
-            return areUrlsEqual(a, b, state);
-        }
-        // If an error tag, it should be tested explicitly. Like RegExp, the properties are not
-        // enumerable, and therefore will give false positives if tested like a standard object.
-        if (tag === ERROR_TAG) {
-            return areErrorsEqual(a, b, state);
-        }
-        // If an arguments tag, it should be treated as a standard object.
-        if (tag === ARGUMENTS_TAG) {
-            return areObjectsEqual(a, b, state);
+        const supportedComparator = supportedComparatorMap[tag];
+        if (supportedComparator) {
+            return supportedComparator(a, b, state);
         }
-        if (TYPED_ARRAY_TAGS[tag]) {
-            return areTypedArraysEqual(a, b, state);
-        }
-        if (tag === ARRAY_BUFFER_TAG) {
-            return areArrayBuffersEqual(a, b, state);
-        }
-        if (tag === DATA_VIEW_TAG) {
-            return areDataViewsEqual(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 (unknownTagComparators) {
-            let unknownTagComparator = unknownTagComparators[tag];
-            if (!unknownTagComparator) {
-                const shortTag = getShortTag(a);
-                if (shortTag) {
-                    unknownTagComparator = unknownTagComparators[shortTag];
-                }
-            }
-            // If the custom config has an unknown tag comparator that matches the captured tag or the
-            // @@toStringTag, it is the source of truth for whether the values are equal.
-            if (unknownTagComparator) {
-                return unknownTagComparator(a, b, state);
-            }
+        const unsupportedCustomComparator = getUnsupportedCustomComparator && getUnsupportedCustomComparator(a, b, tag);
+        if (unsupportedCustomComparator) {
+            return unsupportedCustomComparator(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:
@@ -509,7 +431,7 @@ function createEqualityComparatorConfig({ circular, createCustomConfig, strict,
             ? combineComparators(areTypedArraysEqual, areObjectsEqualStrict)
             : areTypedArraysEqual,
         areUrlsEqual: areUrlsEqual,
-        unknownTagComparators: undefined,
+        getUnsupportedCustomComparator: undefined,
     };
     if (createCustomConfig) {
         config = Object.assign({}, config, createCustomConfig(config));
@@ -572,6 +494,50 @@ function createIsEqual({ circular, comparator, createState, equals, strict }) {
         return comparator(a, b, state);
     };
 }
+/**
+ * Create a map of `toString()` values to their respective handlers for `tag`-based lookups.
+ */
+function createSupportedComparatorMap({ areArrayBuffersEqual, areArraysEqual, areDataViewsEqual, areDatesEqual, areErrorsEqual, areFunctionsEqual, areMapsEqual, areNumbersEqual, areObjectsEqual, arePrimitiveWrappersEqual, areRegExpsEqual, areSetsEqual, areTypedArraysEqual, areUrlsEqual, }) {
+    return {
+        '[object Arguments]': areObjectsEqual,
+        '[object Array]': areArraysEqual,
+        '[object ArrayBuffer]': areArrayBuffersEqual,
+        '[object BigInt]': areNumbersEqual,
+        '[object BigInt64Array]': areTypedArraysEqual,
+        '[object BigUint64Array]': areTypedArraysEqual,
+        '[object Boolean]': arePrimitiveWrappersEqual,
+        '[object DataView]': areDataViewsEqual,
+        '[object Date]': areDatesEqual,
+        // If an error tag, it should be tested explicitly. Like RegExp, the properties are not
+        // enumerable, and therefore will give false positives if tested like a standard object.
+        '[object Error]': areErrorsEqual,
+        '[object Float16Array]': areTypedArraysEqual,
+        '[object Float32Array]': areTypedArraysEqual,
+        '[object Float64Array]': areTypedArraysEqual,
+        '[object Function]': areFunctionsEqual,
+        '[object GeneratorFunction]': areFunctionsEqual,
+        '[object Int8Array]': areTypedArraysEqual,
+        '[object Int16Array]': areTypedArraysEqual,
+        '[object Int32Array]': areTypedArraysEqual,
+        '[object Map]': areMapsEqual,
+        '[object Number]': arePrimitiveWrappersEqual,
+        '[object Object]': (a, b, state) => 
+        // The exception for value comparison is custom `Promise`-like class instances. 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.
+        typeof a.then !== 'function' && typeof b.then !== 'function' && areObjectsEqual(a, b, state),
+        // For RegExp, the properties are not enumerable, and therefore will give false positives if
+        // tested like a standard object.
+        '[object RegExp]': areRegExpsEqual,
+        '[object Set]': areSetsEqual,
+        '[object String]': arePrimitiveWrappersEqual,
+        '[object URL]': areUrlsEqual,
+        '[object Uint8Array]': areTypedArraysEqual,
+        '[object Uint8ClampedArray]': areTypedArraysEqual,
+        '[object Uint16Array]': areTypedArraysEqual,
+        '[object Uint32Array]': areTypedArraysEqual,
+    };
+}
 
 /**
  * Whether the items passed are deeply-equal in value.
@@ -597,21 +563,21 @@ const strictCircularDeepEqual = createCustomEqual({
  * Whether the items passed are shallowly-equal in value.
  */
 const shallowEqual = createCustomEqual({
-    createInternalComparator: () => sameValueZeroEqual,
+    createInternalComparator: () => sameValueEqual,
 });
 /**
  * Whether the items passed are shallowly-equal in value based on strict comparison
  */
 const strictShallowEqual = createCustomEqual({
     strict: true,
-    createInternalComparator: () => sameValueZeroEqual,
+    createInternalComparator: () => sameValueEqual,
 });
 /**
  * Whether the items passed are shallowly-equal in value, including circular references.
  */
 const circularShallowEqual = createCustomEqual({
     circular: true,
-    createInternalComparator: () => sameValueZeroEqual,
+    createInternalComparator: () => sameValueEqual,
 });
 /**
  * Whether the items passed are shallowly-equal in value, including circular references,
@@ -619,7 +585,7 @@ const circularShallowEqual = createCustomEqual({
  */
 const strictCircularShallowEqual = createCustomEqual({
     circular: true,
-    createInternalComparator: () => sameValueZeroEqual,
+    createInternalComparator: () => sameValueEqual,
     strict: true,
 });
 /**
@@ -644,7 +610,7 @@ exports.circularDeepEqual = circularDeepEqual;
 exports.circularShallowEqual = circularShallowEqual;
 exports.createCustomEqual = createCustomEqual;
 exports.deepEqual = deepEqual;
-exports.sameValueZeroEqual = sameValueZeroEqual;
+exports.sameValueEqual = sameValueEqual;
 exports.shallowEqual = shallowEqual;
 exports.strictCircularDeepEqual = strictCircularDeepEqual;
 exports.strictCircularShallowEqual = strictCircularShallowEqual;