likec4 1.59.4 → 1.61.0

package/__app__/src/chunks/libs/fast-equals.mjs

@@ -1,281 +1,574 @@
 import "../rolldown-runtime.mjs";
-//#region ../../node_modules/.pnpm/fast-equals@6.0.3/node_modules/fast-equals/dist/es/index.mjs
-var { getOwnPropertyNames: e, getOwnPropertySymbols: t } = Object, { hasOwnProperty: n } = Object.prototype;
-function combineComparators(e, t) {
-	return function isEqual(n, r, i) {
-		return e(n, r, i) && t(n, r, i);
+// ../../node_modules/.pnpm/fast-equals@6.2.2/node_modules/fast-equals/dist/es/index.mjs
+var { getOwnPropertyDescriptor, getOwnPropertyNames, getOwnPropertySymbols } = Object;
+var { hasOwnProperty, toString: toString$1 } = Object.prototype;
+var OBJECT_TAG = "[object Object]";
+/**
+* Whether the own properties from `end` onward are equal with strict property checking, where the
+* caller has already verified that both objects have the same number of own properties.
+*/
+function areStrictPropertiesEqual(a, b, state, properties, end) {
+	let index = properties.length;
+	let property;
+	let descriptorA;
+	let descriptorB;
+	while (index-- > end) {
+		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;
+}
+/**
+* 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);
 	};
 }
-function createIsCircular(e) {
-	return function isCircular(t, n, r) {
-		if (!t || !n || typeof t != "object" || typeof n != "object") return e(t, n, r);
-		let { cache: i } = r, a = i.get(t), o = i.get(n);
-		if (a && o) return a === n && o === t;
-		i.set(t, n), i.set(n, t);
-		let s = e(t, n, r);
-		return i.delete(t), i.delete(n), s;
+/**
+* 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;
 	};
 }
-function getStrictProperties(n) {
-	let r = t(n);
-	return r.length ? e(n).concat(r) : e(n);
+/**
+* Get the properties to strictly examine, which include both own properties that are
+* not enumerable and symbol properties.
+*/
+function getStrictProperties(object) {
+	const symbols = getOwnPropertySymbols(object);
+	return symbols.length ? getOwnPropertyNames(object).concat(symbols) : getOwnPropertyNames(object);
+}
+/**
+* Identify the element type of TypedArrays across realms and subclasses.
+*/
+var getTypedArrayTag = getOwnPropertyDescriptor(Object.getPrototypeOf(Int8Array.prototype), Symbol.toStringTag).get;
+/**
+* Whether the object contains the property passed as an own property.
+*/
+var hasOwn = Object.hasOwn || ((object, property) => hasOwnProperty.call(object, property));
+/**
+* Whether a null-prototype object is being compared with a plain object. Only one side can be
+* null-prototype when the constructors differ. The other side must be a plain object by
+* constructor, or by tag when it comes from another realm.
+*/
+function isNullPrototypeComparable(a, b) {
+	const aConstructor = a.constructor;
+	const bConstructor = b.constructor;
+	if (aConstructor == null) return bConstructor === Object || toString$1.call(b) === OBJECT_TAG;
+	if (bConstructor == null) return aConstructor === Object || toString$1.call(a) === OBJECT_TAG;
+	return false;
+}
+/**
+* Whether the property passed is a property specific to React/Preact elements. These are ignored in comparison, as they
+* are deeply circular and will return frequent false negatives for the comparison that matters, which is often the
+* React element's aspects (`props`, `type`, etc.).
+*/
+function isReactProperty(a, b, property) {
+	return (property === "_owner" || property === "__o" || property === "__v") && !!(a.$$typeof || b.$$typeof);
+}
+/**
+* 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("&");
 }
-var r = Object.hasOwn || ((e, t) => n.call(e, t)), i = "__v", a = "__o", o = "_owner", s = typeof Float16Array < "u", { getOwnPropertyDescriptor: c, keys: l } = Object, u = Object.is || function sameValueEqual(e, t) {
-	return e === t ? e !== 0 || 1 / e == 1 / t : e !== e && t !== t;
+/**
+* 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.
+*/
+var MAX_SCANNED_PROPERTIES = 64;
+var { keys } = Object;
+var { propertyIsEnumerable } = Object.prototype;
+/**
+* Whether the values passed are equal based on a [SameValue](https://262.ecma-international.org/7.0/#sec-samevalue) basis.
+* Simplified, this maps to if the two values are referentially equal to one another (`a === b`) or both are `NaN`.
+*
+* @note
+* When available in the environment, this is just a re-export of the global
+* [`Object.is`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is) method.
+*/
+var sameValueEqual = Object.is || function sameValueEqual(a, b) {
+	return a === b ? a !== 0 || 1 / a === 1 / b : a !== a && b !== b;
 };
-function strictEqual(e, t) {
-	return e === t;
+/**
+* Whether the values passed are equal based on a
+* [Strict Equality Comparison](https://262.ecma-international.org/7.0/#sec-strict-equality-comparison) basis.
+* Simplified, this maps to if the two values are referentially equal to one another (`a === b`).
+*
+* @note
+* This is mainly available as a convenience function, such as being a default when a function to determine equality between
+* two objects is used.
+*/
+function strictEqual(a, b) {
+	return a === b;
 }
-function areArrayBuffersEqual(e, t) {
-	return e.byteLength === t.byteLength && areTypedArraysEqual(new Uint8Array(e), new Uint8Array(t));
+/**
+* Whether the array buffers are equal in value.
+*/
+function areArrayBuffersEqual(a, b) {
+	return a.byteLength === b.byteLength && areTypedArraysEqual(new Uint8Array(a), new Uint8Array(b));
 }
-function areArraysEqual(e, t, n) {
-	let r = e.length;
-	if (t.length !== r) return !1;
-	for (; r-- > 0;) if (!n.equals(e[r], t[r], r, r, e, t, n)) return !1;
-	return !0;
+/**
+* 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;
 }
-function areDataViewsEqual(e, t) {
-	return e.byteLength === t.byteLength && areTypedArraysEqual(new Uint8Array(e.buffer, e.byteOffset, e.byteLength), new Uint8Array(t.buffer, t.byteOffset, t.byteLength));
+/**
+* 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));
 }
-function areDatesEqual(e, t) {
-	return u(e.getTime(), t.getTime());
+/**
+* Whether the dates passed are equal in value.
+*/
+function areDatesEqual(a, b) {
+	return sameValueEqual(a.getTime(), b.getTime());
 }
-function areErrorsEqual(e, t, n) {
-	return e.name === t.name && e.message === t.message && e.stack === t.stack && n.equals(e.cause, t.cause, "cause", "cause", e, t, n);
+/**
+* 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;
+	if (!index && !propertiesB.length) return true;
+	let compared = 0;
+	let property;
+	while (index-- > 0) {
+		property = propertiesA[index];
+		if (property === "cause" || property === "errors") continue;
+		if (property !== propertiesB[index] && !propertyIsEnumerable.call(b, property) || !state.equals(a[property], b[property], property, property, a, b, state)) return false;
+		++compared;
+	}
+	const remaining = propertiesB.length - compared;
+	return !remaining || remaining === (propertyIsEnumerable.call(b, "cause") ? 1 : 0) + (propertyIsEnumerable.call(b, "errors") ? 1 : 0);
+}
+/**
+* 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);
 }
-function areMapsEqual(e, t, n) {
-	let r = e.size;
-	if (r !== t.size) return !1;
-	if (!r) return !0;
-	let i = new Uint8Array(r), a = e.entries(), o, s, c = 0;
-	for (; (o = a.next()) && !o.done;) {
-		let r = t.entries(), a = 0, l = 0;
-		for (; (s = r.next()) && !s.done;) {
-			if (i[l]) {
-				l++;
+/**
+* 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;
+	while (aResult = aIterable.next()) {
+		if (aResult.done) break;
+		const bIterable = b.entries();
+		let hasMatch = false;
+		let matchIndex = 0;
+		while (bResult = bIterable.next()) {
+			if (bResult.done) break;
+			if (matchedIndices[matchIndex]) {
+				matchIndex++;
 				continue;
 			}
-			let r = o.value, u = s.value;
-			if (n.equals(r[0], u[0], c, l, e, t, n) && n.equals(r[1], u[1], r[0], u[0], e, t, n)) {
-				a = i[l] = 1;
+			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;
 			}
-			l++;
+			matchIndex++;
 		}
-		if (!a) return !1;
-		c++;
+		if (!hasMatch) return false;
+		index++;
+	}
+	return true;
+}
+/**
+* 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;
+	while (index-- > 0) {
+		property = properties[index];
+		if (isReactProperty(a, b, property)) continue;
+		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 !0;
+	return true;
 }
-function areObjectsEqual(e, t, n) {
-	let r = l(e), i = r.length;
-	if (l(t).length !== i) return !1;
-	for (; i-- > 0;) if (!isPropertyEqual(e, t, n, r[i])) return !1;
-	return !0;
+/**
+* Whether the objects are equal in value with strict property checking.
+*/
+function areObjectsEqualStrict(a, b, state) {
+	const properties = getStrictProperties(a);
+	return getStrictProperties(b).length === properties.length && areStrictPropertiesEqual(a, b, state, properties, 0);
 }
-function areObjectsEqualStrict(e, t, n) {
-	let r = getStrictProperties(e), i = r.length;
-	if (getStrictProperties(t).length !== i) return !1;
-	let a, o, s;
-	for (; i-- > 0;) if (a = r[i], !isPropertyEqual(e, t, n, a) || (o = c(e, a), s = c(t, a), (o || s) && (!o || !s || o.configurable !== s.configurable || o.enumerable !== s.enumerable || o.writable !== s.writable))) return !1;
-	return !0;
+/**
+* Whether the primitive wrappers passed are equal in value.
+*/
+function arePrimitiveWrappersEqual(a, b) {
+	return sameValueEqual(a.valueOf(), b.valueOf());
 }
-function arePrimitiveWrappersEqual(e, t) {
-	return u(e.valueOf(), t.valueOf());
+/**
+* Whether the regexps passed are equal in value.
+*/
+function areRegExpsEqual(a, b) {
+	return a.source === b.source && a.flags === b.flags;
 }
-function areRegExpsEqual(e, t) {
-	return e.source === t.source && e.flags === t.flags;
+/**
+* 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();
+	return serializedA === serializedB || sortSearchParams(serializedA) === sortSearchParams(serializedB);
 }
-function areSetsEqual(e, t, n) {
-	let r = e.size;
-	if (r !== t.size) return !1;
-	if (!r) return !0;
-	let i = new Uint8Array(r), a = e.values(), o, s;
-	for (; (o = a.next()) && !o.done;) {
-		let r = t.values(), a = 0, c = 0;
-		for (; (s = r.next()) && !s.done;) {
-			if (!i[c] && n.equals(o.value, s.value, o.value, s.value, e, t, n)) {
-				a = i[c] = 1;
+/**
+* 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;
+	while (aResult = aIterable.next()) {
+		if (aResult.done) break;
+		const bIterable = b.values();
+		let hasMatch = false;
+		let matchIndex = 0;
+		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;
 			}
-			c++;
+			matchIndex++;
 		}
-		if (!a) return !1;
+		if (!hasMatch) return false;
 	}
-	return !0;
+	return true;
 }
-function areTypedArraysEqual(e, t) {
-	let n = e.length;
-	if (t.length !== n || e.byteOffset !== t.byteOffset) return !1;
-	if (e instanceof Float64Array || e instanceof Float32Array || s && e instanceof Float16Array) {
-		for (; n-- > 0;) if (e[n] !== t[n] && (e[n] === e[n] || t[n] === t[n])) return !1;
-		return !0;
+/**
+* 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;
+	const tag = getTypedArrayTag.call(a);
+	if (tag === "Float64Array" || tag === "Float32Array" || tag === "Float16Array") {
+		while (index-- > 0) if (a[index] !== b[index] && (a[index] === a[index] || b[index] === b[index])) return false;
+		return true;
 	}
-	for (; n-- > 0;) if (e[n] !== t[n]) return !1;
-	return !0;
+	while (index-- > 0) if (a[index] !== b[index]) return false;
+	return true;
 }
-function areUrlsEqual(e, t) {
-	return e.href === t.href || e.protocol === t.protocol && e.username === t.username && e.password === t.password && e.host === t.host && e.pathname === t.pathname && e.hash === t.hash && areSearchParamsEqual(e.searchParams, t.searchParams);
+/**
+* Whether the TypedArray instances are equal in value with strict property checking.
+*
+* @note
+* Indexed elements are also own properties, listed first and in order, with descriptors fixed by the
+* spec. They are compared once by `areTypedArraysEqual`, so only the own properties after them
+* (including symbols) are compared with strict property checking.
+*/
+function areTypedArraysEqualStrict(a, b, state) {
+	if (!areTypedArraysEqual(a, b)) return false;
+	const properties = getStrictProperties(a);
+	return getStrictProperties(b).length === properties.length && areStrictPropertiesEqual(a, b, state, properties, a.length);
 }
-function areSearchParamsEqual(e, t) {
-	let n = e.toString(), r = t.toString();
-	return n === r || sortSearchParams(n) === sortSearchParams(r);
+/**
+* Whether the URL instances are equal in value.
+*/
+function areUrlsEqual(a, b) {
+	if (a.href === b.href) return true;
+	return a.protocol === b.protocol && a.username === b.username && a.password === b.password && a.host === b.host && a.pathname === b.pathname && a.hash === b.hash && areSearchParamsEqual(a.searchParams, b.searchParams);
 }
-function sortSearchParams(e) {
-	return e.split("&").sort().join("&");
-}
-function isPropertyEqual(e, t, n, s) {
-	return (s === o || s === a || s === i) && (e.$$typeof || t.$$typeof) ? !0 : r(t, s) && n.equals(e[s], t[s], s, s, e, t, n);
-}
-var d = Object.prototype.toString;
-function createEqualityComparator(e) {
-	let t = createSupportedComparatorMap(e), { areArraysEqual: n, areDatesEqual: r, areFunctionsEqual: i, areMapsEqual: a, areNumbersEqual: o, areObjectsEqual: s, areRegExpsEqual: c, areSetsEqual: l, getUnsupportedCustomComparator: u } = e;
-	return function comparator(e, f, p) {
-		if (e === f) return !0;
-		if (e == null || f == null) return !1;
-		let m = typeof e;
-		if (m !== typeof f) return !1;
-		if (m !== "object") return m === "number" || m === "bigint" ? o(e, f, p) : m === "function" && i(e, f, p);
-		let h = e.constructor;
-		if (h !== f.constructor) return !1;
-		if (h === Object) return s(e, f, p);
-		if (h === Array) return n(e, f, p);
-		if (h === Date) return r(e, f, p);
-		if (h === RegExp) return c(e, f, p);
-		if (h === Map) return a(e, f, p);
-		if (h === Set) return l(e, f, p);
-		if (h === Promise) return !1;
-		if (Array.isArray(e)) return n(e, f, p);
-		let g = d.call(e), _ = t[g];
-		if (_) return _(e, f, p);
-		let v = u && u(e, f, p, g);
-		return v ? v(e, f, p) : !1;
+var { toString } = Object.prototype;
+/**
+* Create a comparator method based on the type-specific equality comparators passed.
+*/
+function createEqualityComparator(config) {
+	const supportedComparatorMap = createSupportedComparatorMap(config);
+	const { areArraysEqual, areDatesEqual, areFunctionsEqual, areMapsEqual, areNumbersEqual, areObjectsEqual, areRegExpsEqual, areSetsEqual, getUnsupportedCustomComparator, strictNullPrototypeComparison } = config;
+	/**
+	* Whether the custom objects are equal in value, based on their string tag. 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 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.
+	*
+	* Capturing the tag is reasonably performant in modern environments like v8 and SpiderMonkey. This is
+	* kept out of the main comparator so that it stays within the engine's bytecode budget for inlining.
+	* See [#207](https://github.com/planttheidea/fast-equals/pull/207) for more details.
+	*/
+	const areTaggedObjectsEqual = getUnsupportedCustomComparator ? function areTaggedObjectsEqual(a, b, state) {
+		const tag = toString.call(a);
+		const supportedComparator = supportedComparatorMap[tag];
+		if (supportedComparator) return supportedComparator(a, b, state);
+		const unsupportedCustomComparator = getUnsupportedCustomComparator(a, b, state, tag);
+		return unsupportedCustomComparator ? unsupportedCustomComparator(a, b, state) : false;
+	} : function areTaggedObjectsEqual(a, b, state) {
+		const supportedComparator = supportedComparatorMap[toString.call(a)];
+		return supportedComparator ? supportedComparator(a, b, state) : false;
+	};
+	/**
+	* compare the value of the two objects and return true if they are equivalent in values
+	*/
+	return function comparator(a, b, state) {
+		if (a === b) return true;
+		if (a == null || b == null) return false;
+		const type = typeof a;
+		if (type !== typeof b) return false;
+		if (type !== "object") {
+			if (type === "number" || type === "bigint") return areNumbersEqual(a, b, state);
+			if (type === "function") return areFunctionsEqual(a, b, state);
+			return false;
+		}
+		const constructor = a.constructor;
+		if (constructor !== b.constructor) return strictNullPrototypeComparison ? false : isNullPrototypeComparable(a, b) && areObjectsEqual(a, b, state);
+		if (constructor === Object) return areObjectsEqual(a, b, state);
+		if (constructor === Array) return areArraysEqual(a, b, state);
+		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) return areObjectsEqual(a, b, state);
+		if (constructor === Promise) return false;
+		if (Array.isArray(a)) return areArraysEqual(a, b, state);
+		return areTaggedObjectsEqual(a, b, state);
 	};
 }
-function createEqualityComparatorConfig({ circular: e, createCustomConfig: t, strict: n }) {
-	let r = {
+/**
+* Create the configuration object used for building comparators.
+*/
+function createEqualityComparatorConfig({ circular, createCustomConfig, strict, strictNullPrototypeComparison = true }) {
+	let config = {
 		areArrayBuffersEqual,
-		areArraysEqual: n ? areObjectsEqualStrict : areArraysEqual,
+		areArraysEqual: strict ? areObjectsEqualStrict : areArraysEqual,
 		areDataViewsEqual,
-		areDatesEqual,
-		areErrorsEqual: n ? combineComparators(areErrorsEqual, areObjectsEqualStrict) : combineComparators(areErrorsEqual, areObjectsEqual),
+		areDatesEqual: strict ? combineComparators(areDatesEqual, areObjectsEqualStrict) : areDatesEqual,
+		areErrorsEqual: strict ? areErrorsEqualStrict : areErrorsEqual,
 		areFunctionsEqual: strictEqual,
-		areMapsEqual: n ? combineComparators(areMapsEqual, areObjectsEqualStrict) : areMapsEqual,
-		areNumbersEqual: u,
-		areObjectsEqual: n ? areObjectsEqualStrict : areObjectsEqual,
+		areMapsEqual: strict ? combineComparators(areMapsEqual, areObjectsEqualStrict) : areMapsEqual,
+		areNumbersEqual: sameValueEqual,
+		areObjectsEqual: strict ? areObjectsEqualStrict : areObjectsEqual,
 		arePrimitiveWrappersEqual,
 		areRegExpsEqual,
-		areSetsEqual: n ? combineComparators(areSetsEqual, areObjectsEqualStrict) : areSetsEqual,
-		areTypedArraysEqual: n ? combineComparators(areTypedArraysEqual, areObjectsEqualStrict) : areTypedArraysEqual,
+		areSetsEqual: strict ? combineComparators(areSetsEqual, areObjectsEqualStrict) : areSetsEqual,
+		areTypedArraysEqual: strict ? areTypedArraysEqualStrict : areTypedArraysEqual,
 		areUrlsEqual,
-		getUnsupportedCustomComparator: void 0
+		getUnsupportedCustomComparator: void 0,
+		strictNullPrototypeComparison
 	};
-	if (t && (r = Object.assign({}, r, t(r))), e) {
-		let e = createIsCircular(r.areArraysEqual), t = createIsCircular(r.areErrorsEqual), n = createIsCircular(r.areMapsEqual), i = createIsCircular(r.areObjectsEqual), a = createIsCircular(r.areSetsEqual);
-		r = Object.assign({}, r, {
-			areArraysEqual: e,
-			areErrorsEqual: t,
-			areMapsEqual: n,
-			areObjectsEqual: i,
-			areSetsEqual: a
+	if (createCustomConfig) config = Object.assign({}, config, createCustomConfig(config));
+	if (circular) {
+		const areArraysEqual = createIsCircular(config.areArraysEqual);
+		const areDatesEqual = strict ? createIsCircular(config.areDatesEqual) : config.areDatesEqual;
+		const areErrorsEqual = createIsCircular(config.areErrorsEqual);
+		const areMapsEqual = createIsCircular(config.areMapsEqual);
+		const areObjectsEqual = createIsCircular(config.areObjectsEqual);
+		const areSetsEqual = createIsCircular(config.areSetsEqual);
+		const areTypedArraysEqual = strict ? createIsCircular(config.areTypedArraysEqual) : config.areTypedArraysEqual;
+		config = Object.assign({}, config, {
+			areArraysEqual,
+			areDatesEqual,
+			areErrorsEqual,
+			areMapsEqual,
+			areObjectsEqual,
+			areSetsEqual,
+			areTypedArraysEqual
 		});
 	}
-	return r;
+	return config;
 }
-function createInternalEqualityComparator(e) {
-	return function(t, n, r, i, a, o, s) {
-		return e(t, n, s);
+/**
+* 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);
 	};
 }
-function createIsEqual({ circular: e, comparator: t, createState: n, equals: r, strict: i }) {
-	if (n) return function isEqual(a, o) {
-		let { cache: s = e ? /* @__PURE__ */ new WeakMap() : void 0, meta: c } = n();
-		return t(a, o, {
-			cache: s,
-			equals: r,
-			meta: c,
-			strict: i
+/**
+* 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 ? /* @__PURE__ */ new WeakMap() : void 0, meta } = createState();
+		return comparator(a, b, {
+			cache,
+			equals,
+			meta,
+			strict
 		});
 	};
-	if (e) return function isEqual(e, n) {
-		return t(e, n, {
+	if (circular) return function isEqual(a, b) {
+		return comparator(a, b, {
 			cache: /* @__PURE__ */ new WeakMap(),
-			equals: r,
+			equals,
 			meta: void 0,
-			strict: i
+			strict
 		});
 	};
-	let a = {
+	const state = {
 		cache: void 0,
-		equals: r,
+		equals,
 		meta: void 0,
-		strict: i
+		strict
 	};
-	return function isEqual(e, n) {
-		return t(e, n, a);
+	return function isEqual(a, b) {
+		return comparator(a, b, state);
 	};
 }
-function createSupportedComparatorMap({ areArrayBuffersEqual: e, areArraysEqual: t, areDataViewsEqual: n, areDatesEqual: r, areErrorsEqual: i, areFunctionsEqual: a, areMapsEqual: o, areObjectsEqual: s, arePrimitiveWrappersEqual: c, areRegExpsEqual: l, areSetsEqual: u, areTypedArraysEqual: d, areUrlsEqual: f }) {
+/**
+* Create a map of `toString()` values to their respective handlers for `tag`-based lookups.
+*/
+function createSupportedComparatorMap({ areArrayBuffersEqual, areArraysEqual, areDataViewsEqual, areDatesEqual, areErrorsEqual, areFunctionsEqual, areMapsEqual, areObjectsEqual, arePrimitiveWrappersEqual, areRegExpsEqual, areSetsEqual, areTypedArraysEqual, areUrlsEqual }) {
 	return {
-		"[object Arguments]": s,
-		"[object Array]": t,
-		"[object ArrayBuffer]": e,
-		"[object AsyncGeneratorFunction]": a,
-		"[object BigInt]": c,
-		"[object BigInt64Array]": d,
-		"[object BigUint64Array]": d,
-		"[object Boolean]": c,
-		"[object DataView]": n,
-		"[object Date]": r,
-		"[object Error]": i,
-		"[object Float16Array]": d,
-		"[object Float32Array]": d,
-		"[object Float64Array]": d,
-		"[object Function]": a,
-		"[object GeneratorFunction]": a,
-		"[object Int8Array]": d,
-		"[object Int16Array]": d,
-		"[object Int32Array]": d,
-		"[object Map]": o,
-		"[object Number]": c,
-		"[object Object]": (e, t, n) => typeof e.then != "function" && typeof t.then != "function" && s(e, t, n),
-		"[object RegExp]": l,
-		"[object Set]": u,
-		"[object String]": c,
-		"[object URL]": f,
-		"[object Uint8Array]": d,
-		"[object Uint8ClampedArray]": d,
-		"[object Uint16Array]": d,
-		"[object Uint32Array]": d
+		"[object Arguments]": areObjectsEqual,
+		"[object Array]": areArraysEqual,
+		"[object ArrayBuffer]": areArrayBuffersEqual,
+		"[object AsyncGeneratorFunction]": areFunctionsEqual,
+		"[object BigInt]": arePrimitiveWrappersEqual,
+		"[object BigInt64Array]": areTypedArraysEqual,
+		"[object BigUint64Array]": areTypedArraysEqual,
+		"[object Boolean]": arePrimitiveWrappersEqual,
+		"[object DataView]": areDataViewsEqual,
+		"[object Date]": areDatesEqual,
+		"[object Error]": areErrorsEqual,
+		"[object Float16Array]": areTypedArraysEqual,
+		"[object Float32Array]": areTypedArraysEqual,
+		"[object Float64Array]": areTypedArraysEqual,
+		"[object Function]": areFunctionsEqual,
+		"[object GeneratorFunction]": areFunctionsEqual,
+		"[object Int8Array]": areTypedArraysEqual,
+		"[object Int16Array]": areTypedArraysEqual,
+		"[object Int32Array]": areTypedArraysEqual,
+		"[object Map]": areMapsEqual,
+		"[object Number]": arePrimitiveWrappersEqual,
+		"[object Object]": (a, b, state) => typeof a.then !== "function" && typeof b.then !== "function" && areObjectsEqual(a, b, state),
+		"[object RegExp]": areRegExpsEqual,
+		"[object Set]": areSetsEqual,
+		"[object String]": arePrimitiveWrappersEqual,
+		"[object URL]": areUrlsEqual,
+		"[object Uint8Array]": areTypedArraysEqual,
+		"[object Uint8ClampedArray]": areTypedArraysEqual,
+		"[object Uint16Array]": areTypedArraysEqual,
+		"[object Uint32Array]": areTypedArraysEqual
 	};
 }
-var f = createCustomEqual();
-createCustomEqual({ strict: !0 }), createCustomEqual({ circular: !0 }), createCustomEqual({
-	circular: !0,
-	strict: !0
+/**
+* Whether the items passed are deeply-equal in value.
+*/
+var deepEqual = createCustomEqual();
+createCustomEqual({ strict: true });
+createCustomEqual({ circular: true });
+createCustomEqual({
+	circular: true,
+	strict: true
+});
+createCustomEqual({ createInternalComparator: () => sameValueEqual });
+createCustomEqual({
+	strict: true,
+	createInternalComparator: () => sameValueEqual
+});
+createCustomEqual({
+	circular: true,
+	createInternalComparator: () => sameValueEqual
 });
-var p = createCustomEqual({ createInternalComparator: () => u });
 createCustomEqual({
-	strict: !0,
-	createInternalComparator: () => u
-}), createCustomEqual({
-	circular: !0,
-	createInternalComparator: () => u
-}), createCustomEqual({
-	circular: !0,
-	createInternalComparator: () => u,
-	strict: !0
+	circular: true,
+	createInternalComparator: () => sameValueEqual,
+	strict: true
 });
-function createCustomEqual(e = {}) {
-	let { circular: t = !1, createInternalComparator: n, createState: r, strict: i = !1 } = e, a = createEqualityComparator(createEqualityComparatorConfig(e));
+/**
+* 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 comparator = createEqualityComparator(createEqualityComparatorConfig(options));
 	return createIsEqual({
-		circular: t,
-		comparator: a,
-		createState: r,
-		equals: n ? n(a) : createInternalEqualityComparator(a),
-		strict: i
+		circular,
+		comparator,
+		createState,
+		equals: createCustomInternalComparator ? createCustomInternalComparator(comparator) : createInternalEqualityComparator(comparator),
+		strict
 	});
 }
-//#endregion
-export { p as n, f as t };
+export { deepEqual as t };