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

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,44 @@ console.log(shallowEqual(objectA, objectB)); // true
 console.log(shallowEqual(objectA, objectC)); // false
 ```
 
+### sameValueEqual
+
+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 { sameValueEqual } from 'fast-equals';
+
+const mainObject = { foo: NaN, bar: 'baz' };
+
+const objectA = 'baz';
+const objectB = NaN;
+const objectC = { foo: NaN, bar: 'baz' };
+
+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),
+`sameValueEqual` is just a re-export of that method.
+
 ### sameValueZeroEqual
 
 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`.
+objects passed and returns a boolean representing the value equivalency of the objects. In simple terms, this means:
+
+- `+0` and `-0` are 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,9 +165,9 @@ 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
 ```
 
 ### circularDeepEqual
@@ -298,18 +328,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 +365,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 +382,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 +399,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 +475,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.
@@ -54,17 +48,33 @@ function getStrictProperties(object) {
 const hasOwn = 
 // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
 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 PREACT_VNODE = '__v';
 const PREACT_OWNER = '__o';
 const REACT_OWNER = '_owner';
 const { getOwnPropertyDescriptor, keys } = Object;
+/**
+ * Whether the values passed are equal based on a [SameValue](https://262.ecma-international.org/7.0/#sec-samevalue) basis.
+ * Simplified, this maps to if the two values are referentially equal to one another (`a === b`) or both are `NaN`.
+ *
+ * @note
+ * When available in the environment, this is just a re-export of the global
+ * [`Object.is`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is) method.
+ */
+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;
+    };
+/**
+ * Whether the values passed are equal based on a [SameValue](https://262.ecma-international.org/7.0/#sec-samevaluezero) basis.
+ * Simplified, this maps to if the two values are referentially equal to one another (`a === b`), both are `NaN`, or both
+ * are either positive or negative zero.
+ */
+function sameValueZeroEqual(a, b) {
+    return a === b || (a !== a && b !== b);
+}
 /**
  * Whether the array buffers are equal in value.
  */
@@ -97,7 +107,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 +173,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 +232,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 +316,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 +342,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 +365,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,79 +388,31 @@ 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);
-        }
-        if (TYPED_ARRAY_TAGS[tag]) {
-            return areTypedArraysEqual(a, b, state);
+        const supportedComparator = supportedComparatorMap[tag];
+        if (supportedComparator) {
+            return supportedComparator(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:
         //   - 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
@@ -509,7 +441,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 +504,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 +573,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 +595,7 @@ const circularShallowEqual = createCustomEqual({
  */
 const strictCircularShallowEqual = createCustomEqual({
     circular: true,
-    createInternalComparator: () => sameValueZeroEqual,
+    createInternalComparator: () => sameValueEqual,
     strict: true,
 });
 /**
@@ -644,6 +620,7 @@ exports.circularDeepEqual = circularDeepEqual;
 exports.circularShallowEqual = circularShallowEqual;
 exports.createCustomEqual = createCustomEqual;
 exports.deepEqual = deepEqual;
+exports.sameValueEqual = sameValueEqual;
 exports.sameValueZeroEqual = sameValueZeroEqual;
 exports.shallowEqual = shallowEqual;
 exports.strictCircularDeepEqual = strictCircularDeepEqual;

package/dist/cjs/index.d.cts

@@ -101,12 +101,9 @@ interface ComparatorConfig<Meta> {
      */
     areUrlsEqual: TypeEqualityComparator<any, Meta>;
     /**
-     * Whether two values with unknown `@@toStringTag` are equal in value. This comparator is
-     * called when no other comparator applies.
-     *
-     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/toStringTag
+     * Get a custom comparator based on the objects passed.
      */
-    unknownTagComparators: Record<string, TypeEqualityComparator<any, Meta>> | undefined;
+    getUnsupportedCustomComparator: ((a: any, b: any, tag: string) => TypeEqualityComparator<any, Meta> | undefined) | undefined;
 }
 type CreateCustomComparatorConfig<Meta> = (config: ComparatorConfig<Meta>) => Partial<ComparatorConfig<Meta>>;
 type CreateState<Meta> = () => {
@@ -159,7 +156,18 @@ interface CustomEqualCreatorOptions<Meta> {
 }
 
 /**
- * Whether the values passed are strictly equal or both NaN.
+ * Whether the values passed are equal based on a [SameValue](https://262.ecma-international.org/7.0/#sec-samevalue) basis.
+ * Simplified, this maps to if the two values are referentially equal to one another (`a === b`) or both are `NaN`.
+ *
+ * @note
+ * When available in the environment, this is just a re-export of the global
+ * [`Object.is`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is) method.
+ */
+declare const sameValueEqual: (value1: any, value2: any) => boolean;
+/**
+ * Whether the values passed are equal based on a [SameValue](https://262.ecma-international.org/7.0/#sec-samevaluezero) basis.
+ * Simplified, this maps to if the two values are referentially equal to one another (`a === b`), both are `NaN`, or both
+ * are either positive or negative zero.
  */
 declare function sameValueZeroEqual(a: any, b: any): boolean;
 
@@ -207,5 +215,5 @@ declare const strictCircularShallowEqual: <A, B>(a: A, b: B) => boolean;
  */
 declare function createCustomEqual<Meta = undefined>(options?: CustomEqualCreatorOptions<Meta>): <A, B>(a: A, b: B) => boolean;
 
-export { circularDeepEqual, circularShallowEqual, createCustomEqual, deepEqual, sameValueZeroEqual, shallowEqual, strictCircularDeepEqual, strictCircularShallowEqual, strictDeepEqual, strictShallowEqual };
+export { circularDeepEqual, circularShallowEqual, createCustomEqual, deepEqual, sameValueEqual, sameValueZeroEqual, shallowEqual, strictCircularDeepEqual, strictCircularShallowEqual, strictDeepEqual, strictShallowEqual };
 export type { AnyEqualityComparator, Cache, CircularState, ComparatorConfig, CreateCustomComparatorConfig, CreateState, CustomEqualCreatorOptions, DefaultState, Dictionary, EqualityComparator, EqualityComparatorCreator, InternalEqualityComparator, PrimitiveWrapper, State, TypeEqualityComparator, TypedArray };

package/dist/es/index.d.mts

@@ -101,12 +101,9 @@ interface ComparatorConfig<Meta> {
      */
     areUrlsEqual: TypeEqualityComparator<any, Meta>;
     /**
-     * Whether two values with unknown `@@toStringTag` are equal in value. This comparator is
-     * called when no other comparator applies.
-     *
-     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/toStringTag
+     * Get a custom comparator based on the objects passed.
      */
-    unknownTagComparators: Record<string, TypeEqualityComparator<any, Meta>> | undefined;
+    getUnsupportedCustomComparator: ((a: any, b: any, tag: string) => TypeEqualityComparator<any, Meta> | undefined) | undefined;
 }
 type CreateCustomComparatorConfig<Meta> = (config: ComparatorConfig<Meta>) => Partial<ComparatorConfig<Meta>>;
 type CreateState<Meta> = () => {
@@ -159,7 +156,18 @@ interface CustomEqualCreatorOptions<Meta> {
 }
 
 /**
- * Whether the values passed are strictly equal or both NaN.
+ * Whether the values passed are equal based on a [SameValue](https://262.ecma-international.org/7.0/#sec-samevalue) basis.
+ * Simplified, this maps to if the two values are referentially equal to one another (`a === b`) or both are `NaN`.
+ *
+ * @note
+ * When available in the environment, this is just a re-export of the global
+ * [`Object.is`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is) method.
+ */
+declare const sameValueEqual: (value1: any, value2: any) => boolean;
+/**
+ * Whether the values passed are equal based on a [SameValue](https://262.ecma-international.org/7.0/#sec-samevaluezero) basis.
+ * Simplified, this maps to if the two values are referentially equal to one another (`a === b`), both are `NaN`, or both
+ * are either positive or negative zero.
  */
 declare function sameValueZeroEqual(a: any, b: any): boolean;
 
@@ -207,5 +215,5 @@ declare const strictCircularShallowEqual: <A, B>(a: A, b: B) => boolean;
  */
 declare function createCustomEqual<Meta = undefined>(options?: CustomEqualCreatorOptions<Meta>): <A, B>(a: A, b: B) => boolean;
 
-export { circularDeepEqual, circularShallowEqual, createCustomEqual, deepEqual, sameValueZeroEqual, shallowEqual, strictCircularDeepEqual, strictCircularShallowEqual, strictDeepEqual, strictShallowEqual };
+export { circularDeepEqual, circularShallowEqual, createCustomEqual, deepEqual, sameValueEqual, sameValueZeroEqual, shallowEqual, strictCircularDeepEqual, strictCircularShallowEqual, strictDeepEqual, strictShallowEqual };
 export type { AnyEqualityComparator, Cache, CircularState, ComparatorConfig, CreateCustomComparatorConfig, CreateState, CustomEqualCreatorOptions, DefaultState, Dictionary, EqualityComparator, EqualityComparatorCreator, InternalEqualityComparator, PrimitiveWrapper, State, TypeEqualityComparator, TypedArray };

package/dist/es/index.mjs

@@ -33,12 +33,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.
@@ -52,17 +46,33 @@ function getStrictProperties(object) {
 const hasOwn = 
 // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
 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 PREACT_VNODE = '__v';
 const PREACT_OWNER = '__o';
 const REACT_OWNER = '_owner';
 const { getOwnPropertyDescriptor, keys } = Object;
+/**
+ * Whether the values passed are equal based on a [SameValue](https://262.ecma-international.org/7.0/#sec-samevalue) basis.
+ * Simplified, this maps to if the two values are referentially equal to one another (`a === b`) or both are `NaN`.
+ *
+ * @note
+ * When available in the environment, this is just a re-export of the global
+ * [`Object.is`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is) method.
+ */
+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;
+    };
+/**
+ * Whether the values passed are equal based on a [SameValue](https://262.ecma-international.org/7.0/#sec-samevaluezero) basis.
+ * Simplified, this maps to if the two values are referentially equal to one another (`a === b`), both are `NaN`, or both
+ * are either positive or negative zero.
+ */
+function sameValueZeroEqual(a, b) {
+    return a === b || (a !== a && b !== b);
+}
 /**
  * Whether the array buffers are equal in value.
  */
@@ -95,7 +105,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.
@@ -161,7 +171,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.
  */
@@ -220,7 +230,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.
@@ -304,39 +314,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
      */
@@ -355,7 +340,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') {
@@ -378,22 +363,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);
         }
@@ -406,79 +386,31 @@ 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);
-        }
-        if (TYPED_ARRAY_TAGS[tag]) {
-            return areTypedArraysEqual(a, b, state);
+        const supportedComparator = supportedComparatorMap[tag];
+        if (supportedComparator) {
+            return supportedComparator(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:
         //   - 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
@@ -507,7 +439,7 @@ function createEqualityComparatorConfig({ circular, createCustomConfig, strict,
             ? combineComparators(areTypedArraysEqual, areObjectsEqualStrict)
             : areTypedArraysEqual,
         areUrlsEqual: areUrlsEqual,
-        unknownTagComparators: undefined,
+        getUnsupportedCustomComparator: undefined,
     };
     if (createCustomConfig) {
         config = Object.assign({}, config, createCustomConfig(config));
@@ -570,6 +502,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.
@@ -595,21 +571,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,
@@ -617,7 +593,7 @@ const circularShallowEqual = createCustomEqual({
  */
 const strictCircularShallowEqual = createCustomEqual({
     circular: true,
-    createInternalComparator: () => sameValueZeroEqual,
+    createInternalComparator: () => sameValueEqual,
     strict: true,
 });
 /**
@@ -638,4 +614,4 @@ function createCustomEqual(options = {}) {
     return createIsEqual({ circular, comparator, createState, equals, strict });
 }
 
-export { circularDeepEqual, circularShallowEqual, createCustomEqual, deepEqual, sameValueZeroEqual, shallowEqual, strictCircularDeepEqual, strictCircularShallowEqual, strictDeepEqual, strictShallowEqual };
+export { circularDeepEqual, circularShallowEqual, createCustomEqual, deepEqual, sameValueEqual, sameValueZeroEqual, shallowEqual, strictCircularDeepEqual, strictCircularShallowEqual, strictDeepEqual, strictShallowEqual };

package/index.d.ts

@@ -101,12 +101,9 @@ interface ComparatorConfig<Meta> {
      */
     areUrlsEqual: TypeEqualityComparator<any, Meta>;
     /**
-     * Whether two values with unknown `@@toStringTag` are equal in value. This comparator is
-     * called when no other comparator applies.
-     *
-     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/toStringTag
+     * Get a custom comparator based on the objects passed.
      */
-    unknownTagComparators: Record<string, TypeEqualityComparator<any, Meta>> | undefined;
+    getUnsupportedCustomComparator: ((a: any, b: any, tag: string) => TypeEqualityComparator<any, Meta> | undefined) | undefined;
 }
 type CreateCustomComparatorConfig<Meta> = (config: ComparatorConfig<Meta>) => Partial<ComparatorConfig<Meta>>;
 type CreateState<Meta> = () => {
@@ -159,7 +156,18 @@ interface CustomEqualCreatorOptions<Meta> {
 }
 
 /**
- * Whether the values passed are strictly equal or both NaN.
+ * Whether the values passed are equal based on a [SameValue](https://262.ecma-international.org/7.0/#sec-samevalue) basis.
+ * Simplified, this maps to if the two values are referentially equal to one another (`a === b`) or both are `NaN`.
+ *
+ * @note
+ * When available in the environment, this is just a re-export of the global
+ * [`Object.is`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is) method.
+ */
+declare const sameValueEqual: (value1: any, value2: any) => boolean;
+/**
+ * Whether the values passed are equal based on a [SameValue](https://262.ecma-international.org/7.0/#sec-samevaluezero) basis.
+ * Simplified, this maps to if the two values are referentially equal to one another (`a === b`), both are `NaN`, or both
+ * are either positive or negative zero.
  */
 declare function sameValueZeroEqual(a: any, b: any): boolean;
 
@@ -207,5 +215,5 @@ declare const strictCircularShallowEqual: <A, B>(a: A, b: B) => boolean;
  */
 declare function createCustomEqual<Meta = undefined>(options?: CustomEqualCreatorOptions<Meta>): <A, B>(a: A, b: B) => boolean;
 
-export { circularDeepEqual, circularShallowEqual, createCustomEqual, deepEqual, sameValueZeroEqual, shallowEqual, strictCircularDeepEqual, strictCircularShallowEqual, strictDeepEqual, strictShallowEqual };
+export { circularDeepEqual, circularShallowEqual, createCustomEqual, deepEqual, sameValueEqual, sameValueZeroEqual, shallowEqual, strictCircularDeepEqual, strictCircularShallowEqual, strictDeepEqual, strictShallowEqual };
 export type { AnyEqualityComparator, Cache, CircularState, ComparatorConfig, CreateCustomComparatorConfig, CreateState, CustomEqualCreatorOptions, DefaultState, Dictionary, EqualityComparator, EqualityComparatorCreator, InternalEqualityComparator, PrimitiveWrapper, State, TypeEqualityComparator, TypedArray };

package/package.json

@@ -9,14 +9,14 @@
   },
   "description": "A blazing fast equality comparison, either shallow or deep",
   "devDependencies": {
-    "@planttheidea/build-tools": "^2.0.0-beta.5",
+    "@planttheidea/build-tools": "^2.0.0",
     "@types/lodash": "^4.17.21",
-    "@types/node": "^24.10.3",
+    "@types/node": "^24.10.4",
     "@types/ramda": "^0.31.1",
     "@types/react": "^19.2.7",
     "@types/react-dom": "^19.2.3",
-    "@typescript-eslint/eslint-plugin": "^8.49.0",
-    "@typescript-eslint/parser": "^8.49.0",
+    "@typescript-eslint/eslint-plugin": "^8.50.0",
+    "@typescript-eslint/parser": "^8.50.0",
     "@vitest/coverage-v8": "^4.0.15",
     "cli-table3": "^0.6.5",
     "decircularize": "^1.0.0",
@@ -35,13 +35,13 @@
     "react-dom": "^19.2.3",
     "react-fast-compare": "^3.2.2",
     "release-it": "^19.1.0",
-    "rollup": "^4.53.3",
+    "rollup": "^4.53.5",
     "shallow-equal-fuzzy": "^0.0.2",
     "tinybench": "^6.0.0",
     "typescript": "^5.9.3",
-    "typescript-eslint": "^8.49.0",
+    "typescript-eslint": "^8.50.0",
     "underscore": "^1.13.7",
-    "vite": "^7.2.7",
+    "vite": "^7.3.0",
     "vitest": "^4.0.15"
   },
   "engines": {
@@ -109,5 +109,5 @@
   "sideEffects": false,
   "type": "module",
   "types": "./index.d.ts",
-  "version": "6.0.0-beta.1"
+  "version": "6.0.0-rc.1"
 }