fast-equals 5.3.3 → 5.3.4

package/dist/cjs/index.cjs

@@ -1,7 +1,8 @@
 'use strict';
 
-var getOwnPropertyNames = Object.getOwnPropertyNames, getOwnPropertySymbols = Object.getOwnPropertySymbols;
-var hasOwnProperty = Object.prototype.hasOwnProperty;
+const { getOwnPropertyNames, getOwnPropertySymbols } = Object;
+// eslint-disable-next-line @typescript-eslint/unbound-method
+const { hasOwnProperty } = Object.prototype;
 /**
  * Combine two comparators into a single comparators.
  */
@@ -20,15 +21,15 @@ function createIsCircular(areItemsEqual) {
         if (!a || !b || typeof a !== 'object' || typeof b !== 'object') {
             return areItemsEqual(a, b, state);
         }
-        var cache = state.cache;
-        var cachedA = cache.get(a);
-        var cachedB = cache.get(b);
+        const { cache } = state;
+        const cachedA = cache.get(a);
+        const cachedB = cache.get(b);
         if (cachedA && cachedB) {
             return cachedA === b && cachedB === a;
         }
         cache.set(a, b);
         cache.set(b, a);
-        var result = areItemsEqual(a, b, state);
+        const result = areItemsEqual(a, b, state);
         cache.delete(a);
         cache.delete(b);
         return result;
@@ -50,12 +51,9 @@ function getStrictProperties(object) {
 /**
  * Whether the object contains the property passed as an own property.
  */
-var hasOwn = 
+const hasOwn = 
 // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-Object.hasOwn ||
-    (function (object, property) {
-        return hasOwnProperty.call(object, property);
-    });
+Object.hasOwn || ((object, property) => hasOwnProperty.call(object, property));
 /**
  * Whether the values passed are strictly equal or both NaN.
  */
@@ -63,15 +61,15 @@ function sameValueZeroEqual(a, b) {
     return a === b || (!a && !b && a !== a && b !== b);
 }
 
-var PREACT_VNODE = '__v';
-var PREACT_OWNER = '__o';
-var REACT_OWNER = '_owner';
-var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor, keys = Object.keys;
+const PREACT_VNODE = '__v';
+const PREACT_OWNER = '__o';
+const REACT_OWNER = '_owner';
+const { getOwnPropertyDescriptor, keys } = Object;
 /**
  * Whether the arrays are equal in value.
  */
 function areArraysEqual(a, b, state) {
-    var index = a.length;
+    let index = a.length;
     if (b.length !== index) {
         return false;
     }
@@ -92,10 +90,7 @@ function areDatesEqual(a, b) {
  * Whether the errors passed are equal in value.
  */
 function areErrorsEqual(a, b) {
-    return (a.name === b.name &&
-        a.message === b.message &&
-        a.cause === b.cause &&
-        a.stack === b.stack);
+    return a.name === b.name && a.message === b.message && a.cause === b.cause && a.stack === b.stack;
 }
 /**
  * Whether the functions passed are equal in value.
@@ -107,26 +102,26 @@ function areFunctionsEqual(a, b) {
  * Whether the `Map`s are equal in value.
  */
 function areMapsEqual(a, b, state) {
-    var size = a.size;
+    const size = a.size;
     if (size !== b.size) {
         return false;
     }
     if (!size) {
         return true;
     }
-    var matchedIndices = new Array(size);
-    var aIterable = a.entries();
-    var aResult;
-    var bResult;
-    var index = 0;
+    const matchedIndices = new Array(size);
+    const aIterable = a.entries();
+    let aResult;
+    let bResult;
+    let index = 0;
     // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
     while ((aResult = aIterable.next())) {
         if (aResult.done) {
             break;
         }
-        var bIterable = b.entries();
-        var hasMatch = false;
-        var matchIndex = 0;
+        const bIterable = b.entries();
+        let hasMatch = false;
+        let matchIndex = 0;
         // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
         while ((bResult = bIterable.next())) {
             if (bResult.done) {
@@ -136,10 +131,10 @@ function areMapsEqual(a, b, state) {
                 matchIndex++;
                 continue;
             }
-            var aEntry = aResult.value;
-            var bEntry = bResult.value;
-            if (state.equals(aEntry[0], bEntry[0], index, matchIndex, a, b, state) &&
-                state.equals(aEntry[1], bEntry[1], aEntry[0], bEntry[0], a, b, state)) {
+            const aEntry = aResult.value;
+            const bEntry = bResult.value;
+            if (state.equals(aEntry[0], bEntry[0], index, matchIndex, a, b, state)
+                && state.equals(aEntry[1], bEntry[1], aEntry[0], bEntry[0], a, b, state)) {
                 hasMatch = matchedIndices[matchIndex] = true;
                 break;
             }
@@ -155,13 +150,13 @@ function areMapsEqual(a, b, state) {
 /**
  * Whether the numbers are equal in value.
  */
-var areNumbersEqual = sameValueZeroEqual;
+const areNumbersEqual = sameValueZeroEqual;
 /**
  * Whether the objects are equal in value.
  */
 function areObjectsEqual(a, b, state) {
-    var properties = keys(a);
-    var index = properties.length;
+    const properties = keys(a);
+    let index = properties.length;
     if (keys(b).length !== index) {
         return false;
     }
@@ -180,14 +175,14 @@ function areObjectsEqual(a, b, state) {
  * Whether the objects are equal in value with strict property checking.
  */
 function areObjectsEqualStrict(a, b, state) {
-    var properties = getStrictProperties(a);
-    var index = properties.length;
+    const properties = getStrictProperties(a);
+    let index = properties.length;
     if (getStrictProperties(b).length !== index) {
         return false;
     }
-    var property;
-    var descriptorA;
-    var descriptorB;
+    let property;
+    let descriptorA;
+    let descriptorB;
     // Decrementing `while` showed faster results than either incrementing or
     // decrementing `for` loop and than an incrementing `while` loop. Declarative
     // methods like `some` / `every` were not used to avoid incurring the garbage
@@ -199,12 +194,12 @@ function areObjectsEqualStrict(a, b, state) {
         }
         descriptorA = getOwnPropertyDescriptor(a, property);
         descriptorB = getOwnPropertyDescriptor(b, property);
-        if ((descriptorA || descriptorB) &&
-            (!descriptorA ||
-                !descriptorB ||
-                descriptorA.configurable !== descriptorB.configurable ||
-                descriptorA.enumerable !== descriptorB.enumerable ||
-                descriptorA.writable !== descriptorB.writable)) {
+        if ((descriptorA || descriptorB)
+            && (!descriptorA
+                || !descriptorB
+                || descriptorA.configurable !== descriptorB.configurable
+                || descriptorA.enumerable !== descriptorB.enumerable
+                || descriptorA.writable !== descriptorB.writable)) {
             return false;
         }
     }
@@ -226,32 +221,32 @@ function areRegExpsEqual(a, b) {
  * Whether the `Set`s are equal in value.
  */
 function areSetsEqual(a, b, state) {
-    var size = a.size;
+    const size = a.size;
     if (size !== b.size) {
         return false;
     }
     if (!size) {
         return true;
     }
-    var matchedIndices = new Array(size);
-    var aIterable = a.values();
-    var aResult;
-    var bResult;
+    const matchedIndices = new Array(size);
+    const aIterable = a.values();
+    let aResult;
+    let bResult;
     // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
     while ((aResult = aIterable.next())) {
         if (aResult.done) {
             break;
         }
-        var bIterable = b.values();
-        var hasMatch = false;
-        var matchIndex = 0;
+        const bIterable = b.values();
+        let hasMatch = false;
+        let matchIndex = 0;
         // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
         while ((bResult = bIterable.next())) {
             if (bResult.done) {
                 break;
             }
-            if (!matchedIndices[matchIndex] &&
-                state.equals(aResult.value, bResult.value, aResult.value, bResult.value, a, b, state)) {
+            if (!matchedIndices[matchIndex]
+                && state.equals(aResult.value, bResult.value, aResult.value, bResult.value, a, b, state)) {
                 hasMatch = matchedIndices[matchIndex] = true;
                 break;
             }
@@ -267,7 +262,7 @@ function areSetsEqual(a, b, state) {
  * Whether the TypedArray instances are equal in value.
  */
 function areTypedArraysEqual(a, b) {
-    var index = a.length;
+    let index = a.length;
     if (b.length !== index) {
         return false;
     }
@@ -282,47 +277,44 @@ function areTypedArraysEqual(a, b) {
  * Whether the URL instances are equal in value.
  */
 function areUrlsEqual(a, b) {
-    return (a.hostname === b.hostname &&
-        a.pathname === b.pathname &&
-        a.protocol === b.protocol &&
-        a.port === b.port &&
-        a.hash === b.hash &&
-        a.username === b.username &&
-        a.password === b.password);
+    return (a.hostname === b.hostname
+        && a.pathname === b.pathname
+        && a.protocol === b.protocol
+        && a.port === b.port
+        && a.hash === b.hash
+        && a.username === b.username
+        && a.password === b.password);
 }
 function isPropertyEqual(a, b, state, property) {
-    if ((property === REACT_OWNER ||
-        property === PREACT_OWNER ||
-        property === PREACT_VNODE) &&
-        (a.$$typeof || b.$$typeof)) {
+    if ((property === REACT_OWNER || property === PREACT_OWNER || property === PREACT_VNODE)
+        && (a.$$typeof || b.$$typeof)) {
         return true;
     }
-    return (hasOwn(b, property) &&
-        state.equals(a[property], b[property], property, property, a, b, state));
+    return hasOwn(b, property) && state.equals(a[property], b[property], property, property, a, b, state);
 }
 
-var ARGUMENTS_TAG = '[object Arguments]';
-var BOOLEAN_TAG = '[object Boolean]';
-var DATE_TAG = '[object Date]';
-var ERROR_TAG = '[object Error]';
-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 URL_TAG = '[object URL]';
-var isArray = Array.isArray;
-var isTypedArray = typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function'
-    ? ArrayBuffer.isView
-    : null;
-var assign = Object.assign;
-var getTag = Object.prototype.toString.call.bind(Object.prototype.toString);
+const ARGUMENTS_TAG = '[object Arguments]';
+const BOOLEAN_TAG = '[object Boolean]';
+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 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);
 /**
  * Create a comparator method based on the type-specific equality comparators passed.
  */
-function createEqualityComparator(_a) {
-    var areArraysEqual = _a.areArraysEqual, areDatesEqual = _a.areDatesEqual, areErrorsEqual = _a.areErrorsEqual, areFunctionsEqual = _a.areFunctionsEqual, areMapsEqual = _a.areMapsEqual, areNumbersEqual = _a.areNumbersEqual, areObjectsEqual = _a.areObjectsEqual, arePrimitiveWrappersEqual = _a.arePrimitiveWrappersEqual, areRegExpsEqual = _a.areRegExpsEqual, areSetsEqual = _a.areSetsEqual, areTypedArraysEqual = _a.areTypedArraysEqual, areUrlsEqual = _a.areUrlsEqual, unknownTagComparators = _a.unknownTagComparators;
+function createEqualityComparator({ areArraysEqual, 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
      */
@@ -336,7 +328,7 @@ function createEqualityComparator(_a) {
         if (a == null || b == null) {
             return false;
         }
-        var type = typeof a;
+        const type = typeof a;
         if (type !== typeof b) {
             return false;
         }
@@ -350,7 +342,7 @@ function createEqualityComparator(_a) {
             // If a primitive value that is not strictly equal, it must be unequal.
             return false;
         }
-        var constructor = a.constructor;
+        const constructor = a.constructor;
         // Checks are listed in order of commonality of use-case:
         //   1. Common complex object types (plain object, array)
         //   2. Common data values (date, regexp)
@@ -399,7 +391,7 @@ function createEqualityComparator(_a) {
         }
         // 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.
-        var tag = getTag(a);
+        const tag = getTag(a);
         if (tag === DATE_TAG) {
             return areDatesEqual(a, b, state);
         }
@@ -418,9 +410,7 @@ function createEqualityComparator(_a) {
             // 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));
+            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.
@@ -443,9 +433,9 @@ function createEqualityComparator(_a) {
             return arePrimitiveWrappersEqual(a, b, state);
         }
         if (unknownTagComparators) {
-            var unknownTagComparator = unknownTagComparators[tag];
+            let unknownTagComparator = unknownTagComparators[tag];
             if (!unknownTagComparator) {
-                var shortTag = getShortTag(a);
+                const shortTag = getShortTag(a);
                 if (shortTag) {
                     unknownTagComparator = unknownTagComparators[shortTag];
                 }
@@ -473,30 +463,19 @@ function createEqualityComparator(_a) {
 /**
  * Create the configuration object used for building comparators.
  */
-function createEqualityComparatorConfig(_a) {
-    var circular = _a.circular, createCustomConfig = _a.createCustomConfig, strict = _a.strict;
-    var config = {
-        areArraysEqual: strict
-            ? areObjectsEqualStrict
-            : areArraysEqual,
+function createEqualityComparatorConfig({ circular, createCustomConfig, strict, }) {
+    let config = {
+        areArraysEqual: strict ? areObjectsEqualStrict : areArraysEqual,
         areDatesEqual: areDatesEqual,
         areErrorsEqual: areErrorsEqual,
         areFunctionsEqual: areFunctionsEqual,
-        areMapsEqual: strict
-            ? combineComparators(areMapsEqual, areObjectsEqualStrict)
-            : areMapsEqual,
+        areMapsEqual: strict ? combineComparators(areMapsEqual, areObjectsEqualStrict) : areMapsEqual,
         areNumbersEqual: areNumbersEqual,
-        areObjectsEqual: strict
-            ? areObjectsEqualStrict
-            : areObjectsEqual,
+        areObjectsEqual: strict ? areObjectsEqualStrict : areObjectsEqual,
         arePrimitiveWrappersEqual: arePrimitiveWrappersEqual,
         areRegExpsEqual: areRegExpsEqual,
-        areSetsEqual: strict
-            ? combineComparators(areSetsEqual, areObjectsEqualStrict)
-            : areSetsEqual,
-        areTypedArraysEqual: strict
-            ? areObjectsEqualStrict
-            : areTypedArraysEqual,
+        areSetsEqual: strict ? combineComparators(areSetsEqual, areObjectsEqualStrict) : areSetsEqual,
+        areTypedArraysEqual: strict ? areObjectsEqualStrict : areTypedArraysEqual,
         areUrlsEqual: areUrlsEqual,
         unknownTagComparators: undefined,
     };
@@ -504,15 +483,15 @@ function createEqualityComparatorConfig(_a) {
         config = assign({}, config, createCustomConfig(config));
     }
     if (circular) {
-        var areArraysEqual$1 = createIsCircular(config.areArraysEqual);
-        var areMapsEqual$1 = createIsCircular(config.areMapsEqual);
-        var areObjectsEqual$1 = createIsCircular(config.areObjectsEqual);
-        var areSetsEqual$1 = createIsCircular(config.areSetsEqual);
+        const areArraysEqual = createIsCircular(config.areArraysEqual);
+        const areMapsEqual = createIsCircular(config.areMapsEqual);
+        const areObjectsEqual = createIsCircular(config.areObjectsEqual);
+        const areSetsEqual = createIsCircular(config.areSetsEqual);
         config = assign({}, config, {
-            areArraysEqual: areArraysEqual$1,
-            areMapsEqual: areMapsEqual$1,
-            areObjectsEqual: areObjectsEqual$1,
-            areSetsEqual: areSetsEqual$1,
+            areArraysEqual,
+            areMapsEqual,
+            areObjectsEqual,
+            areSetsEqual,
         });
     }
     return config;
@@ -529,16 +508,15 @@ function createInternalEqualityComparator(compare) {
 /**
  * Create the `isEqual` function used by the consuming application.
  */
-function createIsEqual(_a) {
-    var circular = _a.circular, comparator = _a.comparator, createState = _a.createState, equals = _a.equals, strict = _a.strict;
+function createIsEqual({ circular, comparator, createState, equals, strict }) {
     if (createState) {
         return function isEqual(a, b) {
-            var _a = createState(), _b = _a.cache, cache = _b === void 0 ? circular ? new WeakMap() : undefined : _b, meta = _a.meta;
+            const { cache = circular ? new WeakMap() : undefined, meta } = createState();
             return comparator(a, b, {
-                cache: cache,
-                equals: equals,
-                meta: meta,
-                strict: strict,
+                cache,
+                equals,
+                meta,
+                strict,
             });
         };
     }
@@ -546,17 +524,17 @@ function createIsEqual(_a) {
         return function isEqual(a, b) {
             return comparator(a, b, {
                 cache: new WeakMap(),
-                equals: equals,
+                equals,
                 meta: undefined,
-                strict: strict,
+                strict,
             });
         };
     }
-    var state = {
+    const state = {
         cache: undefined,
-        equals: equals,
+        equals,
         meta: undefined,
-        strict: strict,
+        strict,
     };
     return function isEqual(a, b) {
         return comparator(a, b, state);
@@ -566,50 +544,50 @@ function createIsEqual(_a) {
 /**
  * Whether the items passed are deeply-equal in value.
  */
-var deepEqual = createCustomEqual();
+const deepEqual = createCustomEqual();
 /**
  * Whether the items passed are deeply-equal in value based on strict comparison.
  */
-var strictDeepEqual = createCustomEqual({ strict: true });
+const strictDeepEqual = createCustomEqual({ strict: true });
 /**
  * Whether the items passed are deeply-equal in value, including circular references.
  */
-var circularDeepEqual = createCustomEqual({ circular: true });
+const circularDeepEqual = createCustomEqual({ circular: true });
 /**
  * Whether the items passed are deeply-equal in value, including circular references,
  * based on strict comparison.
  */
-var strictCircularDeepEqual = createCustomEqual({
+const strictCircularDeepEqual = createCustomEqual({
     circular: true,
     strict: true,
 });
 /**
  * Whether the items passed are shallowly-equal in value.
  */
-var shallowEqual = createCustomEqual({
-    createInternalComparator: function () { return sameValueZeroEqual; },
+const shallowEqual = createCustomEqual({
+    createInternalComparator: () => sameValueZeroEqual,
 });
 /**
  * Whether the items passed are shallowly-equal in value based on strict comparison
  */
-var strictShallowEqual = createCustomEqual({
+const strictShallowEqual = createCustomEqual({
     strict: true,
-    createInternalComparator: function () { return sameValueZeroEqual; },
+    createInternalComparator: () => sameValueZeroEqual,
 });
 /**
  * Whether the items passed are shallowly-equal in value, including circular references.
  */
-var circularShallowEqual = createCustomEqual({
+const circularShallowEqual = createCustomEqual({
     circular: true,
-    createInternalComparator: function () { return sameValueZeroEqual; },
+    createInternalComparator: () => sameValueZeroEqual,
 });
 /**
  * Whether the items passed are shallowly-equal in value, including circular references,
  * based on strict comparison.
  */
-var strictCircularShallowEqual = createCustomEqual({
+const strictCircularShallowEqual = createCustomEqual({
     circular: true,
-    createInternalComparator: function () { return sameValueZeroEqual; },
+    createInternalComparator: () => sameValueZeroEqual,
     strict: true,
 });
 /**
@@ -620,15 +598,14 @@ var strictCircularShallowEqual = createCustomEqual({
  * support for legacy environments that do not support expected features like
  * `RegExp.prototype.flags` out of the box.
  */
-function createCustomEqual(options) {
-    if (options === void 0) { options = {}; }
-    var _a = options.circular, circular = _a === void 0 ? false : _a, createCustomInternalComparator = options.createInternalComparator, createState = options.createState, _b = options.strict, strict = _b === void 0 ? false : _b;
-    var config = createEqualityComparatorConfig(options);
-    var comparator = createEqualityComparator(config);
-    var equals = createCustomInternalComparator
+function createCustomEqual(options = {}) {
+    const { circular = false, createInternalComparator: createCustomInternalComparator, createState, strict = false, } = options;
+    const config = createEqualityComparatorConfig(options);
+    const comparator = createEqualityComparator(config);
+    const equals = createCustomInternalComparator
         ? createCustomInternalComparator(comparator)
         : createInternalEqualityComparator(comparator);
-    return createIsEqual({ circular: circular, comparator: comparator, createState: createState, equals: equals, strict: strict });
+    return createIsEqual({ circular, comparator, createState, equals, strict });
 }
 
 exports.circularDeepEqual = circularDeepEqual;