@btst/stack 5.2.0 → 6.0.0-beta.0

package/dist/node_modules/.pnpm/fast-equals@5.4.5/node_modules/fast-equals/dist/es/index.mjs

@@ -1,784 +0,0 @@
-const { getOwnPropertyNames, getOwnPropertySymbols } = Object;
-// eslint-disable-next-line @typescript-eslint/unbound-method
-const { hasOwnProperty } = Object.prototype;
-/**
- * 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);
-    };
-}
-/**
- * Wrap the provided `areItemsEqual` method to manage the circular state, allowing
- * for circular references to be safely included in the comparison without creating
- * stack overflows.
- */
-function createIsCircular(areItemsEqual) {
-    return function isCircular(a, b, state) {
-        if (!a || !b || typeof a !== 'object' || typeof b !== 'object') {
-            return areItemsEqual(a, b, state);
-        }
-        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);
-        const result = areItemsEqual(a, b, state);
-        cache.delete(a);
-        cache.delete(b);
-        return result;
-    };
-}
-/**
- * Get the `@@toStringTag` of the value, if it exists.
- */
-function getShortTag(value) {
-    return value != null ? value[Symbol.toStringTag] : undefined;
-}
-/**
- * Get the properties to strictly examine, which include both own properties that are
- * not enumerable and symbol properties.
- */
-function getStrictProperties(object) {
-    return getOwnPropertyNames(object).concat(getOwnPropertySymbols(object));
-}
-/**
- * Whether the object contains the property passed as an own property.
- */
-const hasOwn = 
-// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-Object.hasOwn || ((object, property) => hasOwnProperty.call(object, property));
-/**
- * Whether the values passed are strictly equal or both NaN.
- */
-function sameValueZeroEqual(a, b) {
-    return a === b || (!a && !b && a !== a && b !== b);
-}
-
-const PREACT_VNODE = '__v';
-const PREACT_OWNER = '__o';
-const REACT_OWNER = '_owner';
-/**
- * Above this many keys, out-of-position keys are checked with `propertyIsEnumerable` rather than by
- * scanning the other object's keys. Measured in V8: scanning wins up to 50 keys and loses from 100.
- */
-const MAX_SCANNED_PROPERTIES = 64;
-const { getOwnPropertyDescriptor, keys } = Object;
-// eslint-disable-next-line @typescript-eslint/unbound-method
-const { propertyIsEnumerable } = Object.prototype;
-/**
- * Identify the element type of TypedArrays across realms and subclasses.
- */
-// eslint-disable-next-line @typescript-eslint/unbound-method
-const getTypedArrayTag = getOwnPropertyDescriptor(Object.getPrototypeOf(Int8Array.prototype), Symbol.toStringTag).get;
-/**
- * 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) {
-    let index = a.length;
-    if (b.length !== index) {
-        return false;
-    }
-    while (index-- > 0) {
-        if (!state.equals(a[index], b[index], index, index, a, b, state)) {
-            return false;
-        }
-    }
-    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.
- */
-function areDatesEqual(a, b) {
-    return sameValueZeroEqual(a.getTime(), b.getTime());
-}
-/**
- * Whether the errors passed are equal in value.
- *
- * @note
- * `name`, `message` and `stack` are own properties but are not enumerable, so they are compared
- * explicitly. `cause` and `errors` are compared by value rather than by reference, matching how
- * every other nested value in the comparison is treated. They are compared exactly once, regardless
- * of whether they were assigned (enumerable) or set by the constructor (non-enumerable). Other own
- * enumerable properties (which custom `Error` subclasses commonly add) are compared afterward.
- *
- * The own property comparison is inlined rather than extracted, which measured faster in V8 when
- * recursing through `cause`. Keep the bytecode under V8's 460-byte TurboFan inlining limit (383 bytes
- * at time of writing; check with `node --print-bytecode --print-bytecode-filter=areErrorsEqual`), or
- * this stops being inlined into its callers.
- */
-function areErrorsEqual(a, b, state) {
-    if (a.name !== b.name || a.message !== b.message || a.stack !== b.stack) {
-        return false;
-    }
-    const causeA = a.cause;
-    const causeB = b.cause;
-    if (causeA !== causeB && !state.equals(causeA, causeB, 'cause', 'cause', a, b, state)) {
-        return false;
-    }
-    const errorsA = a.errors;
-    const errorsB = b.errors;
-    if (errorsA !== errorsB && !state.equals(errorsA, errorsB, 'errors', 'errors', a, b, state)) {
-        return false;
-    }
-    const propertiesA = keys(a);
-    const propertiesB = keys(b);
-    let index = propertiesA.length;
-    // Constructed errors rarely have enumerable own properties.
-    if (!index && !propertiesB.length) {
-        return true;
-    }
-    let compared = 0;
-    let property;
-    while (index-- > 0) {
-        property = propertiesA[index];
-        // Already compared above regardless of enumerability, so we can ignore them.
-        if (property === 'cause' || property === 'errors') {
-            continue;
-        }
-        // `propertyIsEnumerable` rather than `hasOwn`, so that a non-enumerable own property on `b` cannot
-        // stand in for an enumerable one. Keys in the same position are trivially enumerable on `b`.
-        if ((property !== propertiesB[index] && !propertyIsEnumerable.call(b, property))
-            || !state.equals(a[property], b[property], property, property, a, b, state)) {
-            return false;
-        }
-        ++compared;
-    }
-    // Every compared key is enumerable on `b`, so any of `b`'s keys left over must be `cause` / `errors`.
-    const remaining = propertiesB.length - compared;
-    return (!remaining
-        || remaining === (propertyIsEnumerable.call(b, 'cause') ? 1 : 0) + (propertyIsEnumerable.call(b, 'errors') ? 1 : 0));
-}
-/**
- * Whether the functions passed are equal in value.
- */
-function areFunctionsEqual(a, b) {
-    return a === b;
-}
-/**
- * Whether the errors passed are equal in value.
- *
- * @note
- * `name`, `message` and `stack` are own properties but are not enumerable, so they are compared
- * explicitly. `cause` and `errors` are own properties, so `areObjectsEqualStrict` compares them along
- * with every other own property; they are not compared explicitly to avoid comparing them twice.
- */
-function areErrorsEqualStrict(a, b, state) {
-    return a.name === b.name && a.message === b.message && a.stack === b.stack && areObjectsEqualStrict(a, b, state);
-}
-/**
- * Whether the `Map`s are equal in value.
- */
-function areMapsEqual(a, b, state) {
-    const size = a.size;
-    if (size !== b.size) {
-        return false;
-    }
-    if (!size) {
-        return true;
-    }
-    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;
-        }
-        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) {
-                break;
-            }
-            if (matchedIndices[matchIndex]) {
-                matchIndex++;
-                continue;
-            }
-            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;
-            }
-            matchIndex++;
-        }
-        if (!hasMatch) {
-            return false;
-        }
-        index++;
-    }
-    return true;
-}
-/**
- * Whether the numbers are equal in value.
- */
-const areNumbersEqual = sameValueZeroEqual;
-/**
- * Whether the objects are equal in value.
- */
-function areObjectsEqual(a, b, state) {
-    const properties = keys(a);
-    const propertiesB = keys(b);
-    let index = properties.length;
-    if (propertiesB.length !== index) {
-        return false;
-    }
-    const isScannable = index <= MAX_SCANNED_PROPERTIES;
-    let property;
-    // 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
-    // cost of anonymous callbacks.
-    while (index-- > 0) {
-        property = properties[index];
-        if (isReactProperty(a, b, property)) {
-            continue;
-        }
-        // Objects built the same way list their keys in the same order, in which case the key is
-        // already known to be an own enumerable property of `b` and the lookup can be skipped.
-        // Otherwise, `propertiesB` is exactly `b`'s own enumerable keys. Scanning it is faster than
-        // `propertyIsEnumerable` for smaller objects, but it is linear per key, so larger objects
-        // (where reordering would make it quadratic) use the lookup instead.
-        if ((property !== propertiesB[index]
-            && !(isScannable ? propertiesB.includes(property) : propertyIsEnumerable.call(b, property)))
-            || !state.equals(a[property], b[property], property, property, a, b, state)) {
-            return false;
-        }
-    }
-    return true;
-}
-/**
- * Whether the objects are equal in value with strict property checking.
- */
-function areObjectsEqualStrict(a, b, state) {
-    const properties = getStrictProperties(a);
-    let index = properties.length;
-    if (getStrictProperties(b).length !== index) {
-        return false;
-    }
-    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
-    // cost of anonymous callbacks.
-    while (index-- > 0) {
-        property = properties[index];
-        if (!isReactProperty(a, b, property)
-            && (!hasOwn(b, property) || !state.equals(a[property], b[property], property, property, a, b, state))) {
-            return false;
-        }
-        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)) {
-            return false;
-        }
-    }
-    return true;
-}
-/**
- * Whether the primitive wrappers passed are equal in value.
- */
-function arePrimitiveWrappersEqual(a, b) {
-    return sameValueZeroEqual(a.valueOf(), b.valueOf());
-}
-/**
- * Whether the regexps passed are equal in value.
- */
-function areRegExpsEqual(a, b) {
-    return a.source === b.source && a.flags === b.flags;
-}
-/**
- * Whether the `Set`s are equal in value.
- */
-function areSetsEqual(a, b, state) {
-    const size = a.size;
-    if (size !== b.size) {
-        return false;
-    }
-    if (!size) {
-        return true;
-    }
-    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;
-        }
-        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)) {
-                hasMatch = matchedIndices[matchIndex] = true;
-                break;
-            }
-            matchIndex++;
-        }
-        if (!hasMatch) {
-            return false;
-        }
-    }
-    return true;
-}
-/**
- * Whether the TypedArray instances are equal in value.
- */
-function areTypedArraysEqual(a, b) {
-    let index = a.length;
-    if (b.length !== index || a.byteOffset !== b.byteOffset) {
-        return false;
-    }
-    // Only float-backed views can hold `NaN`, and the additional check needed to treat it as equal
-    // to itself measurably slows the loop, so integer views keep the plain comparison. This is
-    // hoisted out of the loop so the cost is paid once per call rather than once per element.
-    const tag = getTypedArrayTag.call(a);
-    if (tag === 'Float64Array' || tag === 'Float32Array' || tag === 'Float16Array') {
-        while (index-- > 0) {
-            // `NaN` is the only value not equal to itself, and it is treated as equal here to match
-            // the SameValueZero semantics used for every other numeric comparison in the library.
-            if (a[index] !== b[index] && (a[index] === a[index] || b[index] === b[index])) {
-                return false;
-            }
-        }
-        return true;
-    }
-    while (index-- > 0) {
-        if (a[index] !== b[index]) {
-            return false;
-        }
-    }
-    return true;
-}
-/**
- * Whether the URL instances are equal in value.
- */
-function areUrlsEqual(a, b) {
-    // `href` is the normalized serialization of every component, so matching hrefs are equal without
-    // any further work. Only a difference in query parameter ordering can survive a mismatch here.
-    if (a.href === b.href) {
-        return true;
-    }
-    return (a.protocol === b.protocol
-        && a.username === b.username
-        && a.password === b.password
-        // `host` covers both the hostname and the port.
-        && a.host === b.host
-        && a.pathname === b.pathname
-        && a.hash === b.hash
-        && areSearchParamsEqual(a.searchParams, b.searchParams));
-}
-/**
- * Whether the search params passed are equal in value.
- *
- * @note
- * Order is not significant, matching how the other unordered collections in the library are
- * compared. Repeated keys are, so this is a comparison of multisets rather than of sets:
- * `a=1&a=2` is equal to `a=2&a=1`, but not to `a=1&a=1`.
- */
-function areSearchParamsEqual(a, b) {
-    const serializedA = a.toString();
-    const serializedB = b.toString();
-    // Identical serializations are equal under any ordering, and this is by far the common case, so
-    // it is worth checking before sorting anything.
-    return serializedA === serializedB || sortSearchParams(serializedA) === sortSearchParams(serializedB);
-}
-/**
- * Reorder a serialized query string so that params holding the same pairs compare as equal
- * regardless of the order they appear in.
- *
- * @note
- * The serializer percent-encodes `&` and `=` wherever they appear inside a name or a value, so
- * splitting on `&` recovers exactly the pairs and nothing else.
- */
-function sortSearchParams(serialized) {
-    return serialized.split('&').sort().join('&');
-}
-function isReactProperty(a, b, property) {
-    return ((property === REACT_OWNER || property === PREACT_OWNER || property === PREACT_VNODE) && !!(a.$$typeof || b.$$typeof));
-}
-
-const ARRAY_BUFFER_TAG = '[object ArrayBuffer]';
-const ARGUMENTS_TAG = '[object Arguments]';
-const BOOLEAN_TAG = '[object Boolean]';
-const DATA_VIEW_TAG = '[object DataView]';
-const DATE_TAG = '[object Date]';
-const ERROR_TAG = '[object Error]';
-const MAP_TAG = '[object Map]';
-const NUMBER_TAG = '[object Number]';
-const OBJECT_TAG = '[object Object]';
-const REG_EXP_TAG = '[object RegExp]';
-const SET_TAG = '[object Set]';
-const STRING_TAG = '[object String]';
-const TYPED_ARRAY_TAGS = {
-    '[object Int8Array]': true,
-    '[object Uint8Array]': true,
-    '[object Uint8ClampedArray]': true,
-    '[object Int16Array]': true,
-    '[object Uint16Array]': true,
-    '[object Int32Array]': true,
-    '[object Uint32Array]': true,
-    '[object Float16Array]': true,
-    '[object Float32Array]': true,
-    '[object Float64Array]': true,
-    '[object BigInt64Array]': true,
-    '[object BigUint64Array]': true,
-};
-const URL_TAG = '[object URL]';
-// eslint-disable-next-line @typescript-eslint/unbound-method
-const toString = Object.prototype.toString;
-/**
- * Create a comparator method based on the type-specific equality comparators passed.
- */
-function createEqualityComparator({ areArrayBuffersEqual, areArraysEqual, areDataViewsEqual, areDatesEqual, areErrorsEqual, areFunctionsEqual, areMapsEqual, areNumbersEqual, areObjectsEqual, arePrimitiveWrappersEqual, areRegExpsEqual, areSetsEqual, areTypedArraysEqual, areUrlsEqual, unknownTagComparators, }) {
-    /**
-     * 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 either of the items are nullish and fail the strictly equal check
-        // above, then they must be unequal.
-        if (a == null || b == null) {
-            return false;
-        }
-        const type = typeof a;
-        if (type !== typeof b) {
-            return false;
-        }
-        if (type !== 'object') {
-            if (type === 'number') {
-                return areNumbersEqual(a, b, state);
-            }
-            if (type === 'function') {
-                return areFunctionsEqual(a, b, state);
-            }
-            // If a primitive value that is not strictly equal, it must be unequal.
-            return false;
-        }
-        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)
-        //   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.
-        // Constructors should match, otherwise there is potential for false positives
-        // between class and subclass or custom object and POJO.
-        if (constructor !== b.constructor) {
-            return false;
-        }
-        // `isPlainObject` only checks against the object's own realm. Cross-realm
-        // comparisons are rare, and will be handled in the ultimate fallback, so
-        // we can avoid capturing the string tag.
-        if (constructor === Object) {
-            return areObjectsEqual(a, b, state);
-        }
-        // `isArray()` works on subclasses and is cross-realm, so we can avoid capturing
-        // the string tag or doing an `instanceof` check.
-        if (Array.isArray(a)) {
-            return areArraysEqual(a, b, state);
-        }
-        // Try to fast-path equality checks for other complex object types in the
-        // same realm to avoid capturing the string tag. Strict equality is used
-        // instead of `instanceof` because it is more performant for the common
-        // use-case. If someone is subclassing a native class, it will be handled
-        // with the string tag comparison.
-        if (constructor === Date) {
-            return areDatesEqual(a, b, state);
-        }
-        if (constructor === RegExp) {
-            return areRegExpsEqual(a, b, state);
-        }
-        if (constructor === Map) {
-            return areMapsEqual(a, b, state);
-        }
-        if (constructor === Set) {
-            return areSetsEqual(a, b, state);
-        }
-        if (constructor == null) {
-            // Objects with a prototype of `null` are plain objects.
-            return areObjectsEqual(a, b, state);
-        }
-        // Since this is a custom object, capture the string tag to determing its type.
-        // This is reasonably performant in modern environments like v8 and SpiderMonkey.
-        const tag = toString.call(a);
-        if (tag === DATE_TAG) {
-            return areDatesEqual(a, b, state);
-        }
-        // For RegExp, the properties are not enumerable, and therefore will give false positives if
-        // tested like a standard object.
-        if (tag === REG_EXP_TAG) {
-            return areRegExpsEqual(a, b, state);
-        }
-        if (tag === MAP_TAG) {
-            return areMapsEqual(a, b, state);
-        }
-        if (tag === SET_TAG) {
-            return areSetsEqual(a, b, state);
-        }
-        if (tag === OBJECT_TAG) {
-            // The exception for value comparison is custom `Promise`-like class instances. These should
-            // be treated the same as standard `Promise` objects, which means strict equality, and if
-            // it reaches this point then that strict equality comparison has already failed.
-            return typeof a.then !== 'function' && typeof b.then !== 'function' && areObjectsEqual(a, b, state);
-        }
-        // If a URL tag, it should be tested explicitly. Like RegExp, the properties are not
-        // enumerable, and therefore will give false positives if tested like a standard object.
-        if (tag === URL_TAG) {
-            return areUrlsEqual(a, b, state);
-        }
-        // If an error tag, it should be tested explicitly. Like RegExp, the properties are not
-        // enumerable, and therefore will give false positives if tested like a standard object.
-        if (tag === ERROR_TAG) {
-            return areErrorsEqual(a, b, state);
-        }
-        // If an arguments tag, it should be treated as a standard object.
-        if (tag === ARGUMENTS_TAG) {
-            return areObjectsEqual(a, b, state);
-        }
-        if (TYPED_ARRAY_TAGS[tag]) {
-            return areTypedArraysEqual(a, b, state);
-        }
-        if (tag === ARRAY_BUFFER_TAG) {
-            return areArrayBuffersEqual(a, b, state);
-        }
-        if (tag === DATA_VIEW_TAG) {
-            return areDataViewsEqual(a, b, state);
-        }
-        // As the penultimate fallback, check if the values passed are primitive wrappers. This
-        // is very rare in modern JS, which is why it is deprioritized compared to all other object
-        // types.
-        if (tag === BOOLEAN_TAG || tag === NUMBER_TAG || tag === STRING_TAG) {
-            return arePrimitiveWrappersEqual(a, b, state);
-        }
-        if (unknownTagComparators) {
-            let unknownTagComparator = unknownTagComparators[tag];
-            if (!unknownTagComparator) {
-                const shortTag = getShortTag(a);
-                if (shortTag) {
-                    unknownTagComparator = unknownTagComparators[shortTag];
-                }
-            }
-            // If the custom config has an unknown tag comparator that matches the captured tag or the
-            // @@toStringTag, it is the source of truth for whether the values are equal.
-            if (unknownTagComparator) {
-                return unknownTagComparator(a, b, state);
-            }
-        }
-        // 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 createEqualityComparatorConfig({ circular, createCustomConfig, strict, }) {
-    let config = {
-        areArrayBuffersEqual,
-        areArraysEqual: strict ? areObjectsEqualStrict : areArraysEqual,
-        areDataViewsEqual,
-        areDatesEqual: areDatesEqual,
-        // `name` / `message` / `stack` / `cause` / `errors` are not enumerable (unless assigned), which is why
-        // errors need a comparator of their own rather than being treated as plain objects. Each variant also
-        // compares the own properties that `Error` subclasses routinely carry (`status`, `code`, ...):
-        // enumerable ones in loose mode, and all of them (via `areObjectsEqualStrict`) in strict mode.
-        areErrorsEqual: strict ? areErrorsEqualStrict : areErrorsEqual,
-        areFunctionsEqual: areFunctionsEqual,
-        areMapsEqual: strict ? combineComparators(areMapsEqual, areObjectsEqualStrict) : areMapsEqual,
-        areNumbersEqual: areNumbersEqual,
-        areObjectsEqual: strict ? areObjectsEqualStrict : areObjectsEqual,
-        arePrimitiveWrappersEqual: arePrimitiveWrappersEqual,
-        areRegExpsEqual: areRegExpsEqual,
-        areSetsEqual: strict ? combineComparators(areSetsEqual, areObjectsEqualStrict) : areSetsEqual,
-        areTypedArraysEqual: strict
-            ? combineComparators(areTypedArraysEqual, areObjectsEqualStrict)
-            : areTypedArraysEqual,
-        areUrlsEqual: areUrlsEqual,
-        unknownTagComparators: undefined,
-    };
-    if (createCustomConfig) {
-        config = Object.assign({}, config, createCustomConfig(config));
-    }
-    if (circular) {
-        const areArraysEqual = createIsCircular(config.areArraysEqual);
-        // Errors are included because comparing `cause` and own properties by value means an error
-        // that references itself would otherwise recurse without bound.
-        const areErrorsEqual = createIsCircular(config.areErrorsEqual);
-        const areMapsEqual = createIsCircular(config.areMapsEqual);
-        const areObjectsEqual = createIsCircular(config.areObjectsEqual);
-        const areSetsEqual = createIsCircular(config.areSetsEqual);
-        config = Object.assign({}, config, {
-            areArraysEqual,
-            areErrorsEqual,
-            areMapsEqual,
-            areObjectsEqual,
-            areSetsEqual,
-        });
-    }
-    return config;
-}
-/**
- * Default equality comparator pass-through, used as the standard `isEqual` creator for
- * use inside the built comparator.
- */
-function createInternalEqualityComparator(compare) {
-    return function (a, b, _indexOrKeyA, _indexOrKeyB, _parentA, _parentB, state) {
-        return compare(a, b, state);
-    };
-}
-/**
- * Create the `isEqual` function used by the consuming application.
- */
-function createIsEqual({ circular, comparator, createState, equals, strict }) {
-    if (createState) {
-        return function isEqual(a, b) {
-            const { cache = circular ? new WeakMap() : undefined, meta } = createState();
-            return comparator(a, b, {
-                cache,
-                equals,
-                meta,
-                strict,
-            });
-        };
-    }
-    if (circular) {
-        return function isEqual(a, b) {
-            return comparator(a, b, {
-                cache: new WeakMap(),
-                equals,
-                meta: undefined,
-                strict,
-            });
-        };
-    }
-    const state = {
-        cache: undefined,
-        equals,
-        meta: undefined,
-        strict,
-    };
-    return function isEqual(a, b) {
-        return comparator(a, b, state);
-    };
-}
-
-/**
- * Whether the items passed are deeply-equal in value.
- */
-createCustomEqual();
-/**
- * Whether the items passed are deeply-equal in value based on strict comparison.
- */
-createCustomEqual({ strict: true });
-/**
- * Whether the items passed are deeply-equal in value, including circular references.
- */
-const circularDeepEqual = createCustomEqual({ circular: true });
-/**
- * Whether the items passed are deeply-equal in value, including circular references,
- * based on strict comparison.
- */
-createCustomEqual({
-    circular: true,
-    strict: true,
-});
-/**
- * Whether the items passed are shallowly-equal in value.
- */
-createCustomEqual({
-    createInternalComparator: () => sameValueZeroEqual,
-});
-/**
- * Whether the items passed are shallowly-equal in value based on strict comparison
- */
-createCustomEqual({
-    strict: true,
-    createInternalComparator: () => sameValueZeroEqual,
-});
-/**
- * Whether the items passed are shallowly-equal in value, including circular references.
- */
-createCustomEqual({
-    circular: true,
-    createInternalComparator: () => sameValueZeroEqual,
-});
-/**
- * Whether the items passed are shallowly-equal in value, including circular references,
- * based on strict comparison.
- */
-createCustomEqual({
-    circular: true,
-    createInternalComparator: () => sameValueZeroEqual,
-    strict: true,
-});
-/**
- * Create a custom equality comparison method.
- *
- * This can be done to create very targeted comparisons in extreme hot-path scenarios
- * where the standard methods are not performant enough, but can also be used to provide
- * support for legacy environments that do not support expected features like
- * `RegExp.prototype.flags` out of the box.
- */
-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, comparator, createState, equals, strict });
-}
-
-export { circularDeepEqual, createCustomEqual, sameValueZeroEqual };