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

package/CHANGELOG.md

@@ -31,11 +31,15 @@ The following new comparators are available:
 
 This will perform the same comparisons as their non-strict counterparts, but will verify additional properties (non-enumerable properties on objects, keyed objects on `Array` / `Map` / `Set`) and that the descriptors for the properties align.
 
+#### `TypedArray` support
+
+Support for comparing all typed array values is now supported, and you can provide a custom comparator via the new `areTypedArraysEqual` option in the `createCustomEqual` configuration.
+
 #### Better build system resolution
 
 The library now leverages the `exports` property in the `package.json` to provide builds specific to your method of consumption (ESM / CommonJS / UMD). There is still a minified UMD version available if you want to use it instead.
 
-#### `arePrimitiveWrappersEqual` added to `createCustomEqual` configuration
+#### `arePrimitiveWrappersEqual` option added to `createCustomEqual` configuration
 
 If you want a custom comparator for primitive wrappers (`new Boolean()` / `new Number()` / `new String()`) it is now available.
 

package/README.md

@@ -4,7 +4,7 @@
 <img src="https://img.shields.io/badge/coverage-100%25-brightgreen.svg"/>
 <img src="https://img.shields.io/badge/license-MIT-blue.svg"/>
 
-Perform [blazing fast](#benchmarks) equality comparisons (either deep or shallow) on two objects passed. It has no dependencies, and is ~1.27kB when minified and gzipped.
+Perform [blazing fast](#benchmarks) equality comparisons (either deep or shallow) on two objects passed. It has no dependencies, and is ~1.75kB when minified and gzipped.
 
 Unlike most equality validation libraries, the following types are handled out-of-the-box:
 
@@ -162,6 +162,7 @@ console.log(circularShallowEqual(array, [array])); // false
 
 Performs the same comparison as `deepEqual` but performs a strict comparison of the objects. In this includes:
 
+- Checking constructors match
 - Checking non-enumerable properties in object comparisons
 - Checking full descriptor of properties on the object to match
 - Checking non-index properties on arrays
@@ -296,6 +297,7 @@ interface CreateComparatorCreatorOptions<Meta> {
   >;
   areRegExpsEqual: TypeEqualityComparator<RegExp, Meta>;
   areSetsEqual: TypeEqualityComparator<Set<any>, Meta>;
+  areTypedArraysEqual: TypeEqualityComparatory<TypedArray, Meta>;
 }
 
 interface CustomEqualCreatorOptions<Meta> {

package/dist/cjs/index.cjs

@@ -1,112 +1,11 @@
 'use strict';
 
-var ARGUMENTS_TAG = '[object Arguments]';
-var BOOLEAN_TAG = '[object Boolean]';
-var DATE_TAG = '[object Date]';
-var MAP_TAG = '[object Map]';
-var NUMBER_TAG = '[object Number]';
-var OBJECT_TAG = '[object Object]';
-var REG_EXP_TAG = '[object RegExp]';
-var SET_TAG = '[object Set]';
-var STRING_TAG = '[object String]';
-var isArray = Array.isArray;
-var getTag = Object.prototype.toString.call.bind(Object.prototype.toString);
-function createComparator(_a) {
-    var areArraysEqual = _a.areArraysEqual, areDatesEqual = _a.areDatesEqual, areMapsEqual = _a.areMapsEqual, areObjectsEqual = _a.areObjectsEqual, arePrimitiveWrappersEqual = _a.arePrimitiveWrappersEqual, areRegExpsEqual = _a.areRegExpsEqual, areSetsEqual = _a.areSetsEqual;
-    /**
-     * compare the value of the two objects and return true if they are equivalent in values
-     */
-    return function comparator(a, b, state) {
-        // If the items are strictly equal, no need to do a value comparison.
-        if (a === b) {
-            return true;
-        }
-        // If the items are not non-nullish objects, then the only possibility
-        // of them being equal but not strictly is if they are both `NaN`. Since
-        // `NaN` is uniquely not equal to itself, we can use self-comparison of
-        // both objects, which is faster than `isNaN()`.
-        if (!a || !b || typeof a !== 'object' || typeof b !== 'object') {
-            return a !== a && b !== b;
-        }
-        // Checks are listed in order of commonality of use-case:
-        //   1. Common complex object types (plain object, array)
-        //   2. Common data values (date, regexp)
-        //   3. Less-common complex object types (map, set)
-        //   4. Less-common data values (promise, primitive wrappers)
-        // Inherently this is both subjective and assumptive, however
-        // when reviewing comparable libraries in the wild this order
-        // appears to be generally consistent.
-        // `isPlainObject` only checks against the object's own realm. Cross-realm
-        // comparisons are rare, and will be handled in the ultimate fallback, so
-        // we can avoid the `toString.call()` cost unless necessary.
-        if (a.constructor === Object && b.constructor === Object) {
-            return areObjectsEqual(a, b, state);
-        }
-        // `isArray()` works on subclasses and is cross-realm, so we can again avoid
-        // the `toString.call()` cost unless necessary by just checking if either
-        // and then both are arrays.
-        var aArray = isArray(a);
-        var bArray = isArray(b);
-        if (aArray || bArray) {
-            return aArray === bArray && areArraysEqual(a, b, state);
-        }
-        // Since this is a custom object, use the classic `toString.call()` to get its
-        // type. This is reasonably performant in modern environments like v8 and
-        // SpiderMonkey, and allows for cross-realm comparison when other checks like
-        // `instanceof` do not.
-        var tag = getTag(a);
-        if (tag !== getTag(b)) {
-            return false;
-        }
-        if (tag === DATE_TAG) {
-            return areDatesEqual(a, b, state);
-        }
-        if (tag === REG_EXP_TAG) {
-            return areRegExpsEqual(a, b, state);
-        }
-        if (tag === MAP_TAG) {
-            return areMapsEqual(a, b, state);
-        }
-        if (tag === SET_TAG) {
-            return areSetsEqual(a, b, state);
-        }
-        // If a simple object tag, then we can prioritize a simple object comparison because
-        // it is likely a custom class.
-        if (tag === OBJECT_TAG) {
-            // The exception for value comparison is `Promise`-like contracts. These should be
-            // treated the same as standard `Promise` objects, which means strict equality, and if
-            // it reaches this point then that strict equality comparison has already failed.
-            return (typeof a.then !== 'function' &&
-                typeof b.then !== 'function' &&
-                areObjectsEqual(a, b, state));
-        }
-        // If an arguments tag, it should be treated as a standard object.
-        if (tag === ARGUMENTS_TAG) {
-            return areObjectsEqual(a, b, state);
-        }
-        // As the penultimate fallback, check if the values passed are primitive wrappers. This
-        // is very rare in modern JS, which is why it is deprioritized compared to all other object
-        // types.
-        if (tag === BOOLEAN_TAG || tag === NUMBER_TAG || tag === STRING_TAG) {
-            return arePrimitiveWrappersEqual(a, b, state);
-        }
-        // If not matching any tags that require a specific type of comparison, then we hard-code false because
-        // the only thing remaining is strict equality, which has already been compared. This is for a few reasons:
-        //   - Certain types that cannot be introspected (e.g., `WeakMap`). For these types, this is the only
-        //     comparison that can be made.
-        //   - For types that can be introspected, but rarely have requirements to be compared
-        //     (`ArrayBuffer`, `DataView`, etc.), the cost is avoided to prioritize the common
-        //     use-cases (may be included in a future release, if requested enough).
-        //   - For types that can be introspected but do not have an objective definition of what
-        //     equality is (`Error`, etc.), the subjective decision is to be conservative and strictly compare.
-        // In all cases, these decisions should be reevaluated based on changes to the language and
-        // common development practices.
-        return false;
-    };
-}
-
 var getOwnPropertyNames = Object.getOwnPropertyNames, getOwnPropertySymbols = Object.getOwnPropertySymbols;
 var hasOwnProperty = Object.prototype.hasOwnProperty;
+var SUPPORTS_ARRAY_BUFFER = typeof ArrayBuffer === 'function' && Boolean(ArrayBuffer.isView);
+/**
+ * Combine two comparators into a single comparators.
+ */
 function combineComparators(comparatorA, comparatorB) {
     return function isEqual(a, b, state) {
         return comparatorA(a, b, state) && comparatorB(a, b, state);
@@ -145,13 +44,23 @@ function createIsCircular(areItemsEqual) {
         return result;
     };
 }
+/**
+ * Get the properties to strictly examine, which include both own properties that are
+ * not enumerable and symbol properties.
+ */
 function getStrictProperties(object) {
     return getOwnPropertyNames(object).concat(getOwnPropertySymbols(object));
 }
+/**
+ * Whether the object contains the property passed as an own property.
+ */
 var hasOwn = Object.hasOwn ||
     (function (object, property) {
         return hasOwnProperty.call(object, property);
     });
+function isArrayBuffer(value) {
+    return SUPPORTS_ARRAY_BUFFER && ArrayBuffer.isView(value);
+}
 /**
  * Whether the values passed are strictly equal or both NaN.
  */
@@ -178,10 +87,6 @@ function areArraysEqual(a, b, state) {
 }
 /**
  * Whether the dates passed are equal in value.
- *
- * @NOTE
- * This is a standalone function instead of done inline in the comparator
- * to allow for overrides.
  */
 function areDatesEqual(a, b) {
     return sameValueZeroEqual(a.getTime(), b.getTime());
@@ -293,21 +198,12 @@ function areObjectsEqualStrict(a, b, state) {
 }
 /**
  * Whether the primitive wrappers passed are equal in value.
- *
- * @NOTE
- * This is a standalone function instead of done inline in the comparator
- * to allow for overrides.
  */
 function arePrimitiveWrappersEqual(a, b) {
     return sameValueZeroEqual(a.valueOf(), b.valueOf());
 }
 /**
  * Whether the regexps passed are equal in value.
- *
- * @NOTE
- * This is a standalone function instead of done inline in the comparator
- * to allow for overrides. An example of this would be supporting a
- * pre-ES2015 environment where the `flags` property is not available.
  */
 function areRegExpsEqual(a, b) {
     return a.source === b.source && a.flags === b.flags;
@@ -343,95 +239,218 @@ function areSetsEqual(a, b, state) {
     }
     return isValueEqual;
 }
+function areTypedArraysEqual(a, b) {
+    var index = a.length;
+    if (b.length !== index) {
+        return false;
+    }
+    while (index-- > 0) {
+        if (a[index] !== b[index]) {
+            return false;
+        }
+    }
+    return true;
+}
 
+var ARGUMENTS_TAG = '[object Arguments]';
+var BOOLEAN_TAG = '[object Boolean]';
+var DATE_TAG = '[object Date]';
+var MAP_TAG = '[object Map]';
+var NUMBER_TAG = '[object Number]';
+var OBJECT_TAG = '[object Object]';
+var REG_EXP_TAG = '[object RegExp]';
+var SET_TAG = '[object Set]';
+var STRING_TAG = '[object String]';
+var isArray = Array.isArray;
+var assign = Object.assign;
+var getTag = Object.prototype.toString.call.bind(Object.prototype.toString);
+/**
+ * Create a comparator method based on the type-specific equality comparators passed.
+ */
+function createComparator(_a) {
+    var areArraysEqual = _a.areArraysEqual, areDatesEqual = _a.areDatesEqual, areMapsEqual = _a.areMapsEqual, areObjectsEqual = _a.areObjectsEqual, arePrimitiveWrappersEqual = _a.arePrimitiveWrappersEqual, areRegExpsEqual = _a.areRegExpsEqual, areSetsEqual = _a.areSetsEqual, areTypedArraysEqual = _a.areTypedArraysEqual;
+    /**
+     * compare the value of the two objects and return true if they are equivalent in values
+     */
+    return function comparator(a, b, state) {
+        // If the items are strictly equal, no need to do a value comparison.
+        if (a === b) {
+            return true;
+        }
+        // If the items are not non-nullish objects, then the only possibility
+        // of them being equal but not strictly is if they are both `NaN`. Since
+        // `NaN` is uniquely not equal to itself, we can use self-comparison of
+        // both objects, which is faster than `isNaN()`.
+        if (!a || !b || typeof a !== 'object' || typeof b !== 'object') {
+            return a !== a && b !== b;
+        }
+        // Checks are listed in order of commonality of use-case:
+        //   1. Common complex object types (plain object, array)
+        //   2. Common data values (date, regexp)
+        //   3. Less-common complex object types (map, set)
+        //   4. Less-common data values (promise, primitive wrappers)
+        // Inherently this is both subjective and assumptive, however
+        // when reviewing comparable libraries in the wild this order
+        // appears to be generally consistent.
+        // `isPlainObject` only checks against the object's own realm. Cross-realm
+        // comparisons are rare, and will be handled in the ultimate fallback, so
+        // we can avoid the `toString.call()` cost unless necessary.
+        if (a.constructor === Object && b.constructor === Object) {
+            return areObjectsEqual(a, b, state);
+        }
+        // In strict mode, constructors should match. We placed this after the plain object check
+        // because the constructors must match to meet plain object requirements (must both be `Object`
+        // in the given Realm), so it slightly improves performance on a very common use-case.
+        if (state.strict && a.constructor !== b.constructor) {
+            return false;
+        }
+        // `isArray()` works on subclasses and is cross-realm, so we can again avoid
+        // the `toString.call()` cost unless necessary by just checking if either
+        // and then both are arrays.
+        var aArray = isArray(a);
+        var bArray = isArray(b);
+        if (aArray || bArray) {
+            return aArray === bArray && areArraysEqual(a, b, state);
+        }
+        aArray = isArrayBuffer(a);
+        bArray = isArrayBuffer(b);
+        if (aArray || bArray) {
+            return aArray === bArray && areTypedArraysEqual(a, b, state);
+        }
+        // Since this is a custom object, use the classic `toString.call()` to get its
+        // type. This is reasonably performant in modern environments like v8 and
+        // SpiderMonkey, and allows for cross-realm comparison when other checks like
+        // `instanceof` do not.
+        var tag = getTag(a);
+        if (tag !== getTag(b)) {
+            return false;
+        }
+        if (tag === DATE_TAG) {
+            return areDatesEqual(a, b, state);
+        }
+        if (tag === REG_EXP_TAG) {
+            return areRegExpsEqual(a, b, state);
+        }
+        if (tag === MAP_TAG) {
+            return areMapsEqual(a, b, state);
+        }
+        if (tag === SET_TAG) {
+            return areSetsEqual(a, b, state);
+        }
+        // If a simple object tag, then we can prioritize a simple object comparison because
+        // it is likely a custom class.
+        if (tag === OBJECT_TAG) {
+            // The exception for value comparison is `Promise`-like contracts. These should be
+            // treated the same as standard `Promise` objects, which means strict equality, and if
+            // it reaches this point then that strict equality comparison has already failed.
+            return (typeof a.then !== 'function' &&
+                typeof b.then !== 'function' &&
+                areObjectsEqual(a, b, state));
+        }
+        // If an arguments tag, it should be treated as a standard object.
+        if (tag === ARGUMENTS_TAG) {
+            return areObjectsEqual(a, b, state);
+        }
+        // As the penultimate fallback, check if the values passed are primitive wrappers. This
+        // is very rare in modern JS, which is why it is deprioritized compared to all other object
+        // types.
+        if (tag === BOOLEAN_TAG || tag === NUMBER_TAG || tag === STRING_TAG) {
+            return arePrimitiveWrappersEqual(a, b, state);
+        }
+        // If not matching any tags that require a specific type of comparison, then we hard-code false because
+        // the only thing remaining is strict equality, which has already been compared. This is for a few reasons:
+        //   - Certain types that cannot be introspected (e.g., `WeakMap`). For these types, this is the only
+        //     comparison that can be made.
+        //   - For types that can be introspected, but rarely have requirements to be compared
+        //     (`ArrayBuffer`, `DataView`, etc.), the cost is avoided to prioritize the common
+        //     use-cases (may be included in a future release, if requested enough).
+        //   - For types that can be introspected but do not have an objective definition of what
+        //     equality is (`Error`, etc.), the subjective decision is to be conservative and strictly compare.
+        // In all cases, these decisions should be reevaluated based on changes to the language and
+        // common development practices.
+        return false;
+    };
+}
+/**
+ * Create the configuration object used for building comparators.
+ */
 function createComparatorConfig(_a) {
-    var circular = _a.circular, strict = _a.strict;
+    var circular = _a.circular, createCustomConfig = _a.createCustomConfig, strict = _a.strict;
     var config = {
-        areArraysEqual: areArraysEqual,
+        areArraysEqual: strict
+            ? areObjectsEqualStrict
+            : areArraysEqual,
         areDatesEqual: areDatesEqual,
-        areMapsEqual: areMapsEqual,
-        areObjectsEqual: areObjectsEqual,
+        areMapsEqual: strict
+            ? combineComparators(areMapsEqual, areObjectsEqualStrict)
+            : areMapsEqual,
+        areObjectsEqual: strict
+            ? areObjectsEqualStrict
+            : areObjectsEqual,
         arePrimitiveWrappersEqual: arePrimitiveWrappersEqual,
         areRegExpsEqual: areRegExpsEqual,
-        areSetsEqual: areSetsEqual,
+        areSetsEqual: strict
+            ? combineComparators(areSetsEqual, areObjectsEqualStrict)
+            : areSetsEqual,
+        areTypedArraysEqual: strict
+            ? combineComparators(areTypedArraysEqual, areObjectsEqualStrict)
+            : areTypedArraysEqual,
     };
-    if (strict) {
-        config.areArraysEqual = areObjectsEqual;
-        config.areMapsEqual = combineComparators(areMapsEqual, areObjectsEqual);
-        config.areObjectsEqual = areObjectsEqualStrict;
-        config.areSetsEqual = combineComparators(areSetsEqual, areObjectsEqual);
+    if (createCustomConfig) {
+        config = assign({}, config, createCustomConfig(config));
     }
     if (circular) {
-        config.areArraysEqual = createIsCircular(config.areArraysEqual);
-        config.areMapsEqual = createIsCircular(config.areMapsEqual);
-        config.areObjectsEqual = createIsCircular(config.areObjectsEqual);
-        config.areSetsEqual = createIsCircular(config.areSetsEqual);
+        var areArraysEqual$1 = createIsCircular(config.areArraysEqual);
+        var areMapsEqual$1 = createIsCircular(config.areMapsEqual);
+        var areObjectsEqual$1 = createIsCircular(config.areObjectsEqual);
+        var areSetsEqual$1 = createIsCircular(config.areSetsEqual);
+        config = assign({}, config, {
+            areArraysEqual: areArraysEqual$1,
+            areMapsEqual: areMapsEqual$1,
+            areObjectsEqual: areObjectsEqual$1,
+            areSetsEqual: areSetsEqual$1,
+        });
     }
     return config;
 }
-function createDefaultEqualCreator(options) {
-    if (options === void 0) { options = {}; }
-    var config = createComparatorConfig(options);
-    var isEqual = createComparator(config);
-    var isEqualComparator = options.comparator || createInternalComparator(isEqual);
-    var strict = !!options.strict;
-    if (options.circular) {
-        return function equals(a, b) {
-            return isEqual(a, b, {
-                cache: new WeakMap(),
-                equals: isEqualComparator,
-                meta: undefined,
-                strict: strict,
-            });
-        };
-    }
-    var state = Object.freeze({
-        cache: undefined,
-        equals: isEqualComparator,
-        meta: undefined,
-        strict: strict,
-    });
-    return function equals(a, b) {
-        return isEqual(a, b, state);
-    };
-}
+
 /**
  * Whether the items passed are deeply-equal in value.
  */
-var deepEqual = createDefaultEqualCreator();
+var deepEqual = createCustomEqual();
 /**
  * Whether the items passed are deeply-equal in value based on strict comparison.
  */
-var strictDeepEqual = createDefaultEqualCreator({ strict: true });
+var strictDeepEqual = createCustomEqual({ strict: true });
 /**
  * Whether the items passed are deeply-equal in value, including circular references.
  */
-var circularDeepEqual = createDefaultEqualCreator({ circular: true });
+var circularDeepEqual = createCustomEqual({ circular: true });
 /**
  * Whether the items passed are deeply-equal in value, including circular references,
  * based on strict comparison.
  */
-var strictCircularDeepEqual = createDefaultEqualCreator({
+var strictCircularDeepEqual = createCustomEqual({
     circular: true,
     strict: true,
 });
 /**
  * Whether the items passed are shallowly-equal in value.
  */
-var shallowEqual = createDefaultEqualCreator({
+var shallowEqual = createCustomEqual({
     comparator: sameValueZeroEqual,
 });
 /**
  * Whether the items passed are shallowly-equal in value based on strict comparison
  */
-var strictShallowEqual = createDefaultEqualCreator({
+var strictShallowEqual = createCustomEqual({
     comparator: sameValueZeroEqual,
     strict: true,
 });
 /**
  * Whether the items passed are shallowly-equal in value, including circular references.
  */
-var circularShallowEqual = createDefaultEqualCreator({
+var circularShallowEqual = createCustomEqual({
     comparator: sameValueZeroEqual,
     circular: true,
 });
@@ -439,7 +458,7 @@ var circularShallowEqual = createDefaultEqualCreator({
  * Whether the items passed are shallowly-equal in value, including circular references,
  * based on strict comparison.
  */
-var strictCircularShallowEqual = createDefaultEqualCreator({
+var strictCircularShallowEqual = createCustomEqual({
     comparator: sameValueZeroEqual,
     circular: true,
     strict: true,
@@ -454,35 +473,31 @@ var strictCircularShallowEqual = createDefaultEqualCreator({
  */
 function createCustomEqual(options) {
     if (options === void 0) { options = {}; }
-    var comparator = options.comparator, createCustomInternalComparator = options.createInternalComparator, createCustomConfig = options.createCustomConfig, createState = options.createState;
-    var baseConfig = createComparatorConfig(options);
-    var config = createCustomConfig
-        ? Object.assign({}, baseConfig, createCustomConfig(baseConfig))
-        : baseConfig;
-    var isEqualCustom = comparator || createComparator(config);
-    var isEqualCustomComparator = createCustomInternalComparator
-        ? createCustomInternalComparator(isEqualCustom)
-        : createInternalComparator(isEqualCustom);
-    var strict = !!options.strict;
+    var circular = options.circular, comparator = options.comparator, createCustomInternalComparator = options.createInternalComparator, createState = options.createState, _a = options.strict, baseStrict = _a === void 0 ? false : _a;
+    var config = createComparatorConfig(options);
+    var isEqualCustom = createComparator(config);
+    var isEqualCustomComparator = comparator ||
+        (createCustomInternalComparator
+            ? createCustomInternalComparator(isEqualCustom)
+            : createInternalComparator(isEqualCustom));
     if (createState) {
         return function isEqual(a, b, metaOverride) {
-            var customState = createState(isEqualCustom);
+            var _a = createState(isEqualCustom), _b = _a.cache, cache = _b === void 0 ? circular ? new WeakMap() : undefined : _b, _c = _a.equals, equals = _c === void 0 ? isEqualCustomComparator : _c, meta = _a.meta, _d = _a.strict, strict = _d === void 0 ? baseStrict : _d;
             return isEqualCustom(a, b, {
-                cache: customState.cache || new WeakMap(),
-                equals: customState.equals || isEqualCustomComparator,
-                // @ts-expect-error - inferred `Meta` may be undefined, which is okay
-                meta: metaOverride !== undefined ? metaOverride : customState.meta,
-                strict: customState.strict !== undefined ? customState.strict : strict,
+                cache: cache,
+                equals: equals,
+                meta: metaOverride !== undefined ? metaOverride : meta,
+                strict: strict,
             });
         };
     }
-    if (options.circular) {
+    if (circular) {
         return function equals(a, b) {
             return isEqualCustom(a, b, {
                 cache: new WeakMap(),
                 equals: isEqualCustomComparator,
                 meta: undefined,
-                strict: strict,
+                strict: baseStrict,
             });
         };
     }
@@ -490,7 +505,7 @@ function createCustomEqual(options) {
         cache: undefined,
         equals: isEqualCustomComparator,
         meta: undefined,
-        strict: strict,
+        strict: baseStrict,
     });
     return function equals(a, b) {
         return isEqualCustom(a, b, state);