fast-equals 5.3.4 → 6.0.0-beta.0

package/README.md

@@ -12,7 +12,7 @@ The following types are handled out-of-the-box:
 
 - Plain objects (including `react` elements and `Arguments`)
 - Arrays
-- Typed Arrays
+- `ArrayBuffer` / `TypedArray` / `DataView` instances
 - `Date` objects
 - `RegExp` objects
 - `Map` / `Set` iterables
@@ -369,70 +369,70 @@ Testing mixed objects equal...
 ┌────────────────────────────────────────┬────────────────┐
 │ Name                                   │ Ops / sec      │
 ├────────────────────────────────────────┼────────────────┤
-│ fast-equals (passed)                   │ 1407749.173253 │
+│ fast-equals (passed)                   │ 1416193.769468 │
 ├────────────────────────────────────────┼────────────────┤
-│ fast-deep-equal (passed)               │ 1280048.665876 │
+│ fast-deep-equal (passed)               │ 1284824.583215 │
 ├────────────────────────────────────────┼────────────────┤
-│ react-fast-compare (passed)            │ 1246487.311854 │
+│ react-fast-compare (passed)            │ 1246947.505444 │
 ├────────────────────────────────────────┼────────────────┤
-│ shallow-equal-fuzzy (passed)           │ 1214706.618885 │
+│ shallow-equal-fuzzy (passed)           │ 1238082.379207 │
 ├────────────────────────────────────────┼────────────────┤
-│ nano-equal (failed)                    │ 940867.156604  │
+│ nano-equal (failed)                    │ 946782.33704   │
 ├────────────────────────────────────────┼────────────────┤
-│ dequal/lite (passed)                   │ 761363.455047  │
+│ dequal/lite (passed)                   │ 758213.632866  │
 ├────────────────────────────────────────┼────────────────┤
-│ dequal (passed)                        │ 750171.073217  │
+│ dequal (passed)                        │ 756789.655029  │
 ├────────────────────────────────────────┼────────────────┤
-│ fast-equals (circular) (passed)        │ 737965.55573   │
+│ fast-equals (circular) (passed)        │ 726093.253185  │
 ├────────────────────────────────────────┼────────────────┤
-│ underscore.isEqual (passed)            │ 483891.274261  │
+│ underscore.isEqual (passed)            │ 489748.701783  │
 ├────────────────────────────────────────┼────────────────┤
-│ assert.deepStrictEqual (passed)        │ 453773.568213  │
+│ assert.deepStrictEqual (passed)        │ 453761.890107  │
 ├────────────────────────────────────────┼────────────────┤
-│ lodash.isEqual (passed)                │ 286143.874795  │
+│ lodash.isEqual (passed)                │ 288264.867811  │
 ├────────────────────────────────────────┼────────────────┤
-│ fast-equals (strict) (passed)          │ 210515.955319  │
+│ fast-equals (strict) (passed)          │ 217221.619705  │
 ├────────────────────────────────────────┼────────────────┤
-│ fast-equals (strict circular) (passed) │ 182784.610131  │
+│ fast-equals (strict circular) (passed) │ 186916.942934  │
 ├────────────────────────────────────────┼────────────────┤
-│ deep-eql (passed)                      │ 158366.491816  │
+│ deep-eql (passed)                      │ 162487.877883  │
 ├────────────────────────────────────────┼────────────────┤
-│ deep-equal (passed)                    │ 918.529727     │
-└────────────────────────────────────────┴───────────────
+│ deep-equal (passed)                    │ 916.680714     │
+└────────────────────────────────────────┴────────────────┘
 
 Testing mixed objects not equal...
 ┌────────────────────────────────────────┬────────────────┐
 │ Name                                   │ Ops / sec      │
 ├────────────────────────────────────────┼────────────────┤
-│ fast-equals (passed)                   │ 4608308.851367 │
+│ fast-equals (passed)                   │ 4687012.640614 │
 ├────────────────────────────────────────┼────────────────┤
-│ fast-deep-equal (passed)               │ 3407711.655124 │
+│ fast-deep-equal (passed)               │ 3418170.156109 │
 ├────────────────────────────────────────┼────────────────┤
-│ react-fast-compare (passed)            │ 3272226.526599 │
+│ react-fast-compare (passed)            │ 3283516.669966 │
 ├────────────────────────────────────────┼────────────────┤
-│ fast-equals (circular) (passed)        │ 3259611.548677 │
+│ fast-equals (circular) (passed)        │ 3268062.099602 │
 ├────────────────────────────────────────┼────────────────┤
-│ fast-equals (strict) (passed)          │ 1642777.096261 │
+│ fast-equals (strict) (passed)          │ 1747578.66456  │
 ├────────────────────────────────────────┼────────────────┤
-│ fast-equals (strict circular) (passed) │ 1416054.558291 │
+│ fast-equals (strict circular) (passed) │ 1477873.624956 │
 ├────────────────────────────────────────┼────────────────┤
-│ dequal/lite (passed)                   │ 1331215.970586 │
+│ dequal/lite (passed)                   │ 1335397.839502 │
 ├────────────────────────────────────────┼────────────────┤
-│ dequal (passed)                        │ 1301010.914786 │
+│ dequal (passed)                        │ 1319426.71146  │
 ├────────────────────────────────────────┼────────────────┤
-│ shallow-equal-fuzzy (failed)           │ 1205019.5157   │
+│ shallow-equal-fuzzy (failed)           │ 1237432.986615 │
 ├────────────────────────────────────────┼────────────────┤
-│ nano-equal (passed)                    │ 1057016.193582 │
+│ nano-equal (passed)                    │ 1064383.319776 │
 ├────────────────────────────────────────┼────────────────┤
-│ underscore.isEqual (passed)            │ 917363.620713  │
+│ underscore.isEqual (passed)            │ 920462.516736  │
 ├────────────────────────────────────────┼────────────────┤
-│ lodash.isEqual (passed)                │ 381357.861375  │
+│ lodash.isEqual (passed)                │ 379370.998021  │
 ├────────────────────────────────────────┼────────────────┤
-│ deep-eql (passed)                      │ 184651.960191  │
+│ deep-eql (passed)                      │ 184111.383127  │
 ├────────────────────────────────────────┼────────────────┤
-│ assert.deepStrictEqual (passed)        │ 20607.926681   │
+│ assert.deepStrictEqual (passed)        │ 20775.59065    │
 ├────────────────────────────────────────┼────────────────┤
-│ deep-equal (passed)                    │ 3687.588699    │
+│ deep-equal (passed)                    │ 3678.51009     │
 └────────────────────────────────────────┴────────────────┘
 ```
 

package/dist/cjs/comparator.d.cts

@@ -16,7 +16,9 @@ interface CreateIsEqualOptions<Meta> {
  * Create a comparator method based on the type-specific equality comparators passed.
  */
 export declare function createEqualityComparator<Meta>({
+  areArrayBuffersEqual,
   areArraysEqual,
+  areDataViewsEqual,
   areDatesEqual,
   areErrorsEqual,
   areFunctionsEqual,

package/dist/cjs/equals.d.cts

@@ -1,9 +1,17 @@
 import type { Dictionary, PrimitiveWrapper, State, TypedArray } from './internalTypes.d.cts';
 import type { sameValueZeroEqual } from './utils.d.cts';
+/**
+ * Whether the array buffers are equal in value.
+ */
+export declare function areArrayBuffersEqual(a: ArrayBuffer, b: ArrayBuffer): boolean;
 /**
  * Whether the arrays are equal in value.
  */
 export declare function areArraysEqual(a: any[], b: any[], state: State<any>): boolean;
+/**
+ * Whether the dataviews are equal in value.
+ */
+export declare function areDataViewsEqual(a: DataView, b: DataView): boolean;
 /**
  * Whether the dates passed are equal in value.
  */

package/dist/cjs/index.cjs

@@ -65,6 +65,12 @@ const PREACT_VNODE = '__v';
 const PREACT_OWNER = '__o';
 const REACT_OWNER = '_owner';
 const { getOwnPropertyDescriptor, keys } = Object;
+/**
+ * Whether the array buffers are equal in value.
+ */
+function areArrayBuffersEqual(a, b) {
+    return a.byteLength === b.byteLength && areTypedArraysEqual(new Uint8Array(a), new Uint8Array(b));
+}
 /**
  * Whether the arrays are equal in value.
  */
@@ -80,6 +86,13 @@ function areArraysEqual(a, b, state) {
     }
     return true;
 }
+/**
+ * Whether the dataviews are equal in value.
+ */
+function areDataViewsEqual(a, b) {
+    return (a.byteLength === b.byteLength
+        && areTypedArraysEqual(new Uint8Array(a.buffer, a.byteOffset, a.byteLength), new Uint8Array(b.buffer, b.byteOffset, b.byteLength)));
+}
 /**
  * Whether the dates passed are equal in value.
  */
@@ -262,8 +275,8 @@ function areSetsEqual(a, b, state) {
  * Whether the TypedArray instances are equal in value.
  */
 function areTypedArraysEqual(a, b) {
-    let index = a.length;
-    if (b.length !== index) {
+    let index = a.byteLength;
+    if (b.byteLength !== index || a.byteOffset !== b.byteOffset) {
         return false;
     }
     while (index-- > 0) {
@@ -293,8 +306,10 @@ 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]';
@@ -303,18 +318,27 @@ 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]';
-const { isArray } = Array;
-const isTypedArray = 
 // eslint-disable-next-line @typescript-eslint/unbound-method
-typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' ? ArrayBuffer.isView : null;
-const { assign } = Object;
-// eslint-disable-next-line @typescript-eslint/unbound-method
-const getTag = Object.prototype.toString.call.bind(Object.prototype.toString);
+const toString = Object.prototype.toString;
 /**
  * Create a comparator method based on the type-specific equality comparators passed.
  */
-function createEqualityComparator({ areArraysEqual, areDatesEqual, areErrorsEqual, areFunctionsEqual, areMapsEqual, areNumbersEqual, areObjectsEqual, arePrimitiveWrappersEqual, areRegExpsEqual, areSetsEqual, areTypedArraysEqual, areUrlsEqual, unknownTagComparators, }) {
+function createEqualityComparator({ areArrayBuffersEqual, areArraysEqual, areDataViewsEqual, areDatesEqual, areErrorsEqual, areFunctionsEqual, areMapsEqual, areNumbersEqual, areObjectsEqual, arePrimitiveWrappersEqual, areRegExpsEqual, areSetsEqual, areTypedArraysEqual, areUrlsEqual, unknownTagComparators, }) {
     /**
      * compare the value of the two objects and return true if they are equivalent in values
      */
@@ -364,14 +388,9 @@ function createEqualityComparator({ areArraysEqual, areDatesEqual, areErrorsEqua
         }
         // `isArray()` works on subclasses and is cross-realm, so we can avoid capturing
         // the string tag or doing an `instanceof` check.
-        if (isArray(a)) {
+        if (Array.isArray(a)) {
             return areArraysEqual(a, b, state);
         }
-        // `isTypedArray()` works on all possible TypedArray classes, so we can avoid
-        // capturing the string tag or comparing against all possible constructors.
-        if (isTypedArray != null && isTypedArray(a)) {
-            return areTypedArraysEqual(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
@@ -391,7 +410,7 @@ function createEqualityComparator({ areArraysEqual, areDatesEqual, areErrorsEqua
         }
         // 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 = getTag(a);
+        const tag = toString.call(a);
         if (tag === DATE_TAG) {
             return areDatesEqual(a, b, state);
         }
@@ -426,6 +445,15 @@ function createEqualityComparator({ areArraysEqual, areDatesEqual, areErrorsEqua
         if (tag === ARGUMENTS_TAG) {
             return areObjectsEqual(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.
@@ -465,7 +493,9 @@ function createEqualityComparator({ areArraysEqual, areDatesEqual, areErrorsEqua
  */
 function createEqualityComparatorConfig({ circular, createCustomConfig, strict, }) {
     let config = {
+        areArrayBuffersEqual,
         areArraysEqual: strict ? areObjectsEqualStrict : areArraysEqual,
+        areDataViewsEqual,
         areDatesEqual: areDatesEqual,
         areErrorsEqual: areErrorsEqual,
         areFunctionsEqual: areFunctionsEqual,
@@ -475,19 +505,21 @@ function createEqualityComparatorConfig({ circular, createCustomConfig, strict,
         arePrimitiveWrappersEqual: arePrimitiveWrappersEqual,
         areRegExpsEqual: areRegExpsEqual,
         areSetsEqual: strict ? combineComparators(areSetsEqual, areObjectsEqualStrict) : areSetsEqual,
-        areTypedArraysEqual: strict ? areObjectsEqualStrict : areTypedArraysEqual,
+        areTypedArraysEqual: strict
+            ? combineComparators(areTypedArraysEqual, areObjectsEqualStrict)
+            : areTypedArraysEqual,
         areUrlsEqual: areUrlsEqual,
         unknownTagComparators: undefined,
     };
     if (createCustomConfig) {
-        config = assign({}, config, createCustomConfig(config));
+        config = Object.assign({}, config, createCustomConfig(config));
     }
     if (circular) {
         const areArraysEqual = createIsCircular(config.areArraysEqual);
         const areMapsEqual = createIsCircular(config.areMapsEqual);
         const areObjectsEqual = createIsCircular(config.areObjectsEqual);
         const areSetsEqual = createIsCircular(config.areSetsEqual);
-        config = assign({}, config, {
+        config = Object.assign({}, config, {
             areArraysEqual,
             areMapsEqual,
             areObjectsEqual,
@@ -618,4 +650,3 @@ exports.strictCircularDeepEqual = strictCircularDeepEqual;
 exports.strictCircularShallowEqual = strictCircularShallowEqual;
 exports.strictDeepEqual = strictDeepEqual;
 exports.strictShallowEqual = strictShallowEqual;
-//# sourceMappingURL=index.cjs.map

package/dist/cjs/internalTypes.d.cts

@@ -38,11 +38,20 @@ export interface Dictionary<Value = any> {
   $$typeof?: any;
 }
 export interface ComparatorConfig<Meta> {
+  /**
+   * Whether the array buffers passed are equal in value. In strict mode, this includes
+   * additional properties added to the array.
+   */
+  areArrayBuffersEqual: TypeEqualityComparator<any, Meta>;
   /**
    * Whether the arrays passed are equal in value. In strict mode, this includes
    * additional properties added to the array.
    */
   areArraysEqual: TypeEqualityComparator<any, Meta>;
+  /**
+   * Whether the data views passed are equal in value.
+   */
+  areDataViewsEqual: TypeEqualityComparator<any, Meta>;
   /**
    * Whether the dates passed are equal in value.
    */
@@ -120,15 +129,10 @@ export type PrimitiveWrapper = Boolean | Number | String;
 /**
  * Type which encompasses possible instances of TypedArray
  * classes.
- *
- * **NOTE**: This does not include `BigInt64Array` and
- * `BitUint64Array` because those are part of ES2020 and
- * not supported by certain TS configurations. If using
- * either in `areTypedArraysEqual`, you can cast the
- * instance as `TypedArray` and it will work as expected,
- * because runtime checks will still work for those classes.
  */
 export type TypedArray =
+  | BigInt64Array
+  | BigUint64Array
   | Float32Array
   | Float64Array
   | Int8Array

package/dist/es/comparator.d.mts

@@ -16,7 +16,9 @@ interface CreateIsEqualOptions<Meta> {
  * Create a comparator method based on the type-specific equality comparators passed.
  */
 export declare function createEqualityComparator<Meta>({
+  areArrayBuffersEqual,
   areArraysEqual,
+  areDataViewsEqual,
   areDatesEqual,
   areErrorsEqual,
   areFunctionsEqual,

package/dist/es/equals.d.mts

@@ -1,9 +1,17 @@
 import type { Dictionary, PrimitiveWrapper, State, TypedArray } from './internalTypes.d.mts';
 import type { sameValueZeroEqual } from './utils.d.mts';
+/**
+ * Whether the array buffers are equal in value.
+ */
+export declare function areArrayBuffersEqual(a: ArrayBuffer, b: ArrayBuffer): boolean;
 /**
  * Whether the arrays are equal in value.
  */
 export declare function areArraysEqual(a: any[], b: any[], state: State<any>): boolean;
+/**
+ * Whether the dataviews are equal in value.
+ */
+export declare function areDataViewsEqual(a: DataView, b: DataView): boolean;
 /**
  * Whether the dates passed are equal in value.
  */

package/dist/es/index.mjs

@@ -63,6 +63,12 @@ const PREACT_VNODE = '__v';
 const PREACT_OWNER = '__o';
 const REACT_OWNER = '_owner';
 const { getOwnPropertyDescriptor, keys } = Object;
+/**
+ * Whether the array buffers are equal in value.
+ */
+function areArrayBuffersEqual(a, b) {
+    return a.byteLength === b.byteLength && areTypedArraysEqual(new Uint8Array(a), new Uint8Array(b));
+}
 /**
  * Whether the arrays are equal in value.
  */
@@ -78,6 +84,13 @@ function areArraysEqual(a, b, state) {
     }
     return true;
 }
+/**
+ * Whether the dataviews are equal in value.
+ */
+function areDataViewsEqual(a, b) {
+    return (a.byteLength === b.byteLength
+        && areTypedArraysEqual(new Uint8Array(a.buffer, a.byteOffset, a.byteLength), new Uint8Array(b.buffer, b.byteOffset, b.byteLength)));
+}
 /**
  * Whether the dates passed are equal in value.
  */
@@ -260,8 +273,8 @@ function areSetsEqual(a, b, state) {
  * Whether the TypedArray instances are equal in value.
  */
 function areTypedArraysEqual(a, b) {
-    let index = a.length;
-    if (b.length !== index) {
+    let index = a.byteLength;
+    if (b.byteLength !== index || a.byteOffset !== b.byteOffset) {
         return false;
     }
     while (index-- > 0) {
@@ -291,8 +304,10 @@ 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]';
@@ -301,18 +316,27 @@ 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]';
-const { isArray } = Array;
-const isTypedArray = 
 // eslint-disable-next-line @typescript-eslint/unbound-method
-typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' ? ArrayBuffer.isView : null;
-const { assign } = Object;
-// eslint-disable-next-line @typescript-eslint/unbound-method
-const getTag = Object.prototype.toString.call.bind(Object.prototype.toString);
+const toString = Object.prototype.toString;
 /**
  * Create a comparator method based on the type-specific equality comparators passed.
  */
-function createEqualityComparator({ areArraysEqual, areDatesEqual, areErrorsEqual, areFunctionsEqual, areMapsEqual, areNumbersEqual, areObjectsEqual, arePrimitiveWrappersEqual, areRegExpsEqual, areSetsEqual, areTypedArraysEqual, areUrlsEqual, unknownTagComparators, }) {
+function createEqualityComparator({ areArrayBuffersEqual, areArraysEqual, areDataViewsEqual, areDatesEqual, areErrorsEqual, areFunctionsEqual, areMapsEqual, areNumbersEqual, areObjectsEqual, arePrimitiveWrappersEqual, areRegExpsEqual, areSetsEqual, areTypedArraysEqual, areUrlsEqual, unknownTagComparators, }) {
     /**
      * compare the value of the two objects and return true if they are equivalent in values
      */
@@ -362,14 +386,9 @@ function createEqualityComparator({ areArraysEqual, areDatesEqual, areErrorsEqua
         }
         // `isArray()` works on subclasses and is cross-realm, so we can avoid capturing
         // the string tag or doing an `instanceof` check.
-        if (isArray(a)) {
+        if (Array.isArray(a)) {
             return areArraysEqual(a, b, state);
         }
-        // `isTypedArray()` works on all possible TypedArray classes, so we can avoid
-        // capturing the string tag or comparing against all possible constructors.
-        if (isTypedArray != null && isTypedArray(a)) {
-            return areTypedArraysEqual(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
@@ -389,7 +408,7 @@ function createEqualityComparator({ areArraysEqual, areDatesEqual, areErrorsEqua
         }
         // 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 = getTag(a);
+        const tag = toString.call(a);
         if (tag === DATE_TAG) {
             return areDatesEqual(a, b, state);
         }
@@ -424,6 +443,15 @@ function createEqualityComparator({ areArraysEqual, areDatesEqual, areErrorsEqua
         if (tag === ARGUMENTS_TAG) {
             return areObjectsEqual(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.
@@ -463,7 +491,9 @@ function createEqualityComparator({ areArraysEqual, areDatesEqual, areErrorsEqua
  */
 function createEqualityComparatorConfig({ circular, createCustomConfig, strict, }) {
     let config = {
+        areArrayBuffersEqual,
         areArraysEqual: strict ? areObjectsEqualStrict : areArraysEqual,
+        areDataViewsEqual,
         areDatesEqual: areDatesEqual,
         areErrorsEqual: areErrorsEqual,
         areFunctionsEqual: areFunctionsEqual,
@@ -473,19 +503,21 @@ function createEqualityComparatorConfig({ circular, createCustomConfig, strict,
         arePrimitiveWrappersEqual: arePrimitiveWrappersEqual,
         areRegExpsEqual: areRegExpsEqual,
         areSetsEqual: strict ? combineComparators(areSetsEqual, areObjectsEqualStrict) : areSetsEqual,
-        areTypedArraysEqual: strict ? areObjectsEqualStrict : areTypedArraysEqual,
+        areTypedArraysEqual: strict
+            ? combineComparators(areTypedArraysEqual, areObjectsEqualStrict)
+            : areTypedArraysEqual,
         areUrlsEqual: areUrlsEqual,
         unknownTagComparators: undefined,
     };
     if (createCustomConfig) {
-        config = assign({}, config, createCustomConfig(config));
+        config = Object.assign({}, config, createCustomConfig(config));
     }
     if (circular) {
         const areArraysEqual = createIsCircular(config.areArraysEqual);
         const areMapsEqual = createIsCircular(config.areMapsEqual);
         const areObjectsEqual = createIsCircular(config.areObjectsEqual);
         const areSetsEqual = createIsCircular(config.areSetsEqual);
-        config = assign({}, config, {
+        config = Object.assign({}, config, {
             areArraysEqual,
             areMapsEqual,
             areObjectsEqual,
@@ -607,4 +639,3 @@ function createCustomEqual(options = {}) {
 }
 
 export { circularDeepEqual, circularShallowEqual, createCustomEqual, deepEqual, sameValueZeroEqual, shallowEqual, strictCircularDeepEqual, strictCircularShallowEqual, strictDeepEqual, strictShallowEqual };
-//# sourceMappingURL=index.mjs.map

package/dist/es/internalTypes.d.mts

@@ -38,11 +38,20 @@ export interface Dictionary<Value = any> {
   $$typeof?: any;
 }
 export interface ComparatorConfig<Meta> {
+  /**
+   * Whether the array buffers passed are equal in value. In strict mode, this includes
+   * additional properties added to the array.
+   */
+  areArrayBuffersEqual: TypeEqualityComparator<any, Meta>;
   /**
    * Whether the arrays passed are equal in value. In strict mode, this includes
    * additional properties added to the array.
    */
   areArraysEqual: TypeEqualityComparator<any, Meta>;
+  /**
+   * Whether the data views passed are equal in value.
+   */
+  areDataViewsEqual: TypeEqualityComparator<any, Meta>;
   /**
    * Whether the dates passed are equal in value.
    */
@@ -120,15 +129,10 @@ export type PrimitiveWrapper = Boolean | Number | String;
 /**
  * Type which encompasses possible instances of TypedArray
  * classes.
- *
- * **NOTE**: This does not include `BigInt64Array` and
- * `BitUint64Array` because those are part of ES2020 and
- * not supported by certain TS configurations. If using
- * either in `areTypedArraysEqual`, you can cast the
- * instance as `TypedArray` and it will work as expected,
- * because runtime checks will still work for those classes.
  */
 export type TypedArray =
+  | BigInt64Array
+  | BigUint64Array
   | Float32Array
   | Float64Array
   | Int8Array

package/index.d.ts

@@ -38,11 +38,20 @@ interface Dictionary<Value = any> {
   $$typeof?: any;
 }
 interface ComparatorConfig<Meta> {
+  /**
+   * Whether the array buffers passed are equal in value. In strict mode, this includes
+   * additional properties added to the array.
+   */
+  areArrayBuffersEqual: TypeEqualityComparator<any, Meta>;
   /**
    * Whether the arrays passed are equal in value. In strict mode, this includes
    * additional properties added to the array.
    */
   areArraysEqual: TypeEqualityComparator<any, Meta>;
+  /**
+   * Whether the data views passed are equal in value.
+   */
+  areDataViewsEqual: TypeEqualityComparator<any, Meta>;
   /**
    * Whether the dates passed are equal in value.
    */
@@ -120,15 +129,10 @@ type PrimitiveWrapper = Boolean | Number | String;
 /**
  * Type which encompasses possible instances of TypedArray
  * classes.
- *
- * **NOTE**: This does not include `BigInt64Array` and
- * `BitUint64Array` because those are part of ES2020 and
- * not supported by certain TS configurations. If using
- * either in `areTypedArraysEqual`, you can cast the
- * instance as `TypedArray` and it will work as expected,
- * because runtime checks will still work for those classes.
  */
 type TypedArray =
+  | BigInt64Array
+  | BigUint64Array
   | Float32Array
   | Float64Array
   | Int8Array