fast-equals 5.3.3 → 5.4.0

package/dist/umd/index.js

@@ -4,8 +4,9 @@
     (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["fast-equals"] = {}));
 })(this, (function (exports) { '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.
      */
@@ -24,15 +25,15 @@
             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;
@@ -54,12 +55,9 @@
     /**
      * 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.
      */
@@ -67,15 +65,21 @@
         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 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.
      */
     function areArraysEqual(a, b, state) {
-        var index = a.length;
+        let index = a.length;
         if (b.length !== index) {
             return false;
         }
@@ -86,6 +90,13 @@
         }
         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.
      */
@@ -96,10 +107,7 @@
      * 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.
@@ -111,26 +119,26 @@
      * 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) {
@@ -140,10 +148,10 @@
                     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;
                 }
@@ -159,13 +167,13 @@
     /**
      * 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;
         }
@@ -184,14 +192,14 @@
      * 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
@@ -203,12 +211,12 @@
             }
             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;
             }
         }
@@ -230,32 +238,32 @@
      * 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;
                 }
@@ -271,8 +279,8 @@
      * Whether the TypedArray instances are equal in value.
      */
     function areTypedArraysEqual(a, b) {
-        var index = a.length;
-        if (b.length !== index) {
+        let index = a.byteLength;
+        if (b.byteLength !== index || a.byteOffset !== b.byteOffset) {
             return false;
         }
         while (index-- > 0) {
@@ -286,47 +294,55 @@
      * 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 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(_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({ 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
          */
@@ -340,7 +356,7 @@
             if (a == null || b == null) {
                 return false;
             }
-            var type = typeof a;
+            const type = typeof a;
             if (type !== typeof b) {
                 return false;
             }
@@ -354,7 +370,7 @@
                 // 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)
@@ -376,14 +392,9 @@
             }
             // `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
@@ -403,7 +414,7 @@
             }
             // 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 = toString.call(a);
             if (tag === DATE_TAG) {
                 return areDatesEqual(a, b, state);
             }
@@ -422,9 +433,7 @@
                 // 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.
@@ -440,6 +449,15 @@
             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.
@@ -447,9 +465,9 @@
                 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];
                     }
@@ -477,46 +495,39 @@
     /**
      * 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 = {
+            areArrayBuffersEqual,
+            areArraysEqual: strict ? areObjectsEqualStrict : areArraysEqual,
+            areDataViewsEqual,
             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,
+            areSetsEqual: strict ? combineComparators(areSetsEqual, areObjectsEqualStrict) : areSetsEqual,
             areTypedArraysEqual: strict
-                ? areObjectsEqualStrict
+                ? combineComparators(areTypedArraysEqual, areObjectsEqualStrict)
                 : areTypedArraysEqual,
             areUrlsEqual: areUrlsEqual,
             unknownTagComparators: undefined,
         };
         if (createCustomConfig) {
-            config = assign({}, config, createCustomConfig(config));
+            config = Object.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);
-            config = assign({}, config, {
-                areArraysEqual: areArraysEqual$1,
-                areMapsEqual: areMapsEqual$1,
-                areObjectsEqual: areObjectsEqual$1,
-                areSetsEqual: areSetsEqual$1,
+            const areArraysEqual = createIsCircular(config.areArraysEqual);
+            const areMapsEqual = createIsCircular(config.areMapsEqual);
+            const areObjectsEqual = createIsCircular(config.areObjectsEqual);
+            const areSetsEqual = createIsCircular(config.areSetsEqual);
+            config = Object.assign({}, config, {
+                areArraysEqual,
+                areMapsEqual,
+                areObjectsEqual,
+                areSetsEqual,
             });
         }
         return config;
@@ -533,16 +544,15 @@
     /**
      * 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,
                 });
             };
         }
@@ -550,17 +560,17 @@
             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);
@@ -570,50 +580,50 @@
     /**
      * 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,
     });
     /**
@@ -624,15 +634,14 @@
      * 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;