@shirudo/ddd-kit 2.0.0 → 3.0.0-rc.3

package/dist/chunks/deep-equal-except.js

@@ -0,0 +1,639 @@
+//#region src/utils/array/is-built-in.ts
+/**
+* Set of `Object.prototype.toString.call(x)` tags that the library treats
+* as built-in atomic types. Members of this set are compared/cloned by
+* reference (or with type-specific logic) rather than walked structurally.
+*
+* Detection is tag-based, since `Object.prototype.toString` gives the same
+* answer across realms (an iframe's `Date` has the same tag as the main
+* window's `Date`), and then brand-verified via internal-slot probes,
+* because `Symbol.toStringTag` lets any plain object claim a built-in tag.
+* The previous strategy also checked `globalThis[name] === constructor`
+* and a `proto !== Object.prototype` heuristic; both broke for cross-realm
+* objects and the latter additionally misclassified ordinary user classes
+* as built-ins.
+*/
+const BUILT_IN_TAGS = /* @__PURE__ */ new Set([
+	"[object Date]",
+	"[object RegExp]",
+	"[object Map]",
+	"[object Set]",
+	"[object WeakMap]",
+	"[object WeakSet]",
+	"[object Promise]",
+	"[object Error]",
+	"[object Boolean]",
+	"[object Number]",
+	"[object String]",
+	"[object BigInt]",
+	"[object ArrayBuffer]",
+	"[object SharedArrayBuffer]",
+	"[object DataView]"
+]);
+function intrinsicGetter(proto, prop) {
+	const get = Object.getOwnPropertyDescriptor(proto, prop)?.get;
+	if (!get) throw new Error(`missing intrinsic getter for ${prop}`);
+	return get;
+}
+const dateGetTime = Date.prototype.getTime;
+const mapSizeGet = intrinsicGetter(Map.prototype, "size");
+const setSizeGet = intrinsicGetter(Set.prototype, "size");
+const weakMapHas = WeakMap.prototype.has;
+const weakSetHas = WeakSet.prototype.has;
+const dataViewByteLengthGet = intrinsicGetter(DataView.prototype, "byteLength");
+const arrayBufferByteLengthGet = intrinsicGetter(ArrayBuffer.prototype, "byteLength");
+const sharedArrayBufferByteLengthGet = typeof SharedArrayBuffer === "undefined" ? void 0 : intrinsicGetter(SharedArrayBuffer.prototype, "byteLength");
+const regExpSourceGet = intrinsicGetter(RegExp.prototype, "source");
+const booleanValueOf = Boolean.prototype.valueOf;
+const numberValueOf = Number.prototype.valueOf;
+const stringValueOf = String.prototype.valueOf;
+const bigIntValueOf = BigInt.prototype.valueOf;
+const functionToString = Function.prototype.toString;
+const PROBE_KEY = {};
+const intrinsicConstructorSources = new Map([
+	"Object",
+	"Array",
+	"Date",
+	"RegExp",
+	"Map",
+	"Set",
+	"WeakMap",
+	"WeakSet",
+	"Promise",
+	"Error",
+	"EvalError",
+	"RangeError",
+	"ReferenceError",
+	"SyntaxError",
+	"TypeError",
+	"URIError",
+	"AggregateError",
+	"Boolean",
+	"Number",
+	"String",
+	"BigInt",
+	"ArrayBuffer",
+	"SharedArrayBuffer",
+	"DataView",
+	"Int8Array",
+	"Uint8Array",
+	"Uint8ClampedArray",
+	"Int16Array",
+	"Uint16Array",
+	"Int32Array",
+	"Uint32Array",
+	"Float32Array",
+	"Float64Array",
+	"BigInt64Array",
+	"BigUint64Array"
+].flatMap((name) => {
+	const intrinsic = Object.getOwnPropertyDescriptor(globalThis, name)?.value;
+	return typeof intrinsic === "function" ? [[name, functionToString.call(intrinsic)]] : [];
+}));
+const intrinsicConstructorSourceSet = new Set(intrinsicConstructorSources.values());
+const ERROR_INTRINSIC_NAMES = [
+	"Error",
+	"EvalError",
+	"RangeError",
+	"ReferenceError",
+	"SyntaxError",
+	"TypeError",
+	"URIError",
+	"AggregateError"
+];
+function isIntrinsicConstructorPrototype(prototype, expectedName) {
+	const constructorDescriptor = Object.getOwnPropertyDescriptor(prototype, "constructor");
+	const candidateConstructor = constructorDescriptor?.value;
+	if (constructorDescriptor === void 0 || !("value" in constructorDescriptor) || typeof candidateConstructor !== "function") return false;
+	let candidateSource;
+	try {
+		candidateSource = functionToString.call(candidateConstructor);
+	} catch {
+		return false;
+	}
+	const expectedSource = expectedName === void 0 ? void 0 : intrinsicConstructorSources.get(expectedName);
+	if (expectedSource !== void 0 && candidateSource !== expectedSource || expectedSource === void 0 && !intrinsicConstructorSourceSet.has(candidateSource)) return false;
+	const nameDescriptor = Object.getOwnPropertyDescriptor(candidateConstructor, "name");
+	const candidateName = nameDescriptor !== void 0 && "value" in nameDescriptor && typeof nameDescriptor.value === "string" ? nameDescriptor.value : void 0;
+	const intrinsicName = expectedName ?? candidateName;
+	const intrinsicSource = intrinsicName === void 0 ? void 0 : intrinsicConstructorSources.get(intrinsicName);
+	return candidateName === intrinsicName && intrinsicSource !== void 0 && candidateSource === intrinsicSource && Object.getOwnPropertyDescriptor(candidateConstructor, "prototype")?.value === prototype;
+}
+/**
+* Accepts an intrinsic prototype, optionally behind transparent
+* `Symbol.toStringTag` override layers. A user-defined subclass has its own
+* non-native constructor and is therefore rejected before reaching the
+* intrinsic prototype.
+*/
+function hasIntrinsicPrototypeChain(value, expectedName) {
+	const visited = /* @__PURE__ */ new WeakSet();
+	let prototype = Object.getPrototypeOf(value);
+	while (prototype !== null && !visited.has(prototype)) {
+		visited.add(prototype);
+		if (Object.hasOwn(prototype, "constructor")) return isIntrinsicConstructorPrototype(prototype, expectedName);
+		const ownKeys = Reflect.ownKeys(prototype);
+		if (ownKeys.length !== 1 || ownKeys[0] !== Symbol.toStringTag) return false;
+		prototype = Object.getPrototypeOf(prototype);
+	}
+	return false;
+}
+/**
+* Tags that `deepEqual` compares BY REFERENCE (its unhandled-built-in
+* fallback) and that `deepOmit` must therefore ALIAS rather than clone:
+* a clone would break `deepEqualExcept(x, x)` reflexivity. Single source
+* of truth so the two modules cannot drift: if `deepEqual` ever learns a
+* by-value comparison for one of these, remove it here and add a clone
+* case in `deepOmit`'s `cloneBuiltIn` in the same change.
+*/
+const REFERENCE_COMPARED_TAGS = /* @__PURE__ */ new Set([
+	"[object Error]",
+	"[object ArrayBuffer]",
+	"[object SharedArrayBuffer]",
+	"[object Promise]",
+	"[object WeakMap]",
+	"[object WeakSet]"
+]);
+/**
+* Intrinsic tags of OPAQUE exotics: objects whose internal state no
+* structural walk can observe (boxed Symbols, generator objects,
+* WeakRefs, FinalizationRegistry handles). `deepEqual` compares them by
+* identity and `deepOmit` passes them through by reference; treating
+* them as (empty) plain objects would make ALL such exotics equal to
+* each other. Deliberately a curated INTRINSIC list, not "every unknown
+* tag": a user class exposing its own `Symbol.toStringTag` (e.g.
+* "Money") keeps structural comparison, and a plain object spoofing one
+* of these intrinsic tags gets the identity semantics of the thing it
+* claims to be.
+*/
+const OPAQUE_EXOTIC_TAGS = /* @__PURE__ */ new Set([
+	"[object Symbol]",
+	"[object Generator]",
+	"[object AsyncGenerator]",
+	"[object WeakRef]",
+	"[object FinalizationRegistry]"
+]);
+/** True when `tag` names an opaque intrinsic; see {@link OPAQUE_EXOTIC_TAGS}. */
+function isOpaqueExoticTag(tag) {
+	return OPAQUE_EXOTIC_TAGS.has(tag);
+}
+function findPropertyDescriptor(value, key) {
+	const visited = /* @__PURE__ */ new WeakSet();
+	let current = value;
+	while (current !== null && !visited.has(current)) {
+		visited.add(current);
+		const descriptor = Object.getOwnPropertyDescriptor(current, key);
+		if (descriptor !== void 0) return descriptor;
+		current = Object.getPrototypeOf(current);
+	}
+}
+function builtInTagWithoutInvokingAccessors(value) {
+	if (ArrayBuffer.isView(value)) return hasBrand(value, "[object DataView]") ? "[object DataView]" : "[object TypedArray]";
+	const descriptor = findPropertyDescriptor(value, Symbol.toStringTag);
+	if (descriptor !== void 0 && !("value" in descriptor)) return builtInTagFromBrand(value);
+	const tag = Object.prototype.toString.call(value);
+	if (BUILT_IN_TAGS.has(tag) && hasBrand(value, tag)) return tag;
+	return descriptor === void 0 ? void 0 : builtInTagFromBrand(value);
+}
+function mutableBuiltInTagWithoutInvokingAccessors(value) {
+	const tag = builtInTagWithoutInvokingAccessors(value);
+	return tag === "[object Date]" || tag === "[object Map]" || tag === "[object Set]" ? tag : void 0;
+}
+function builtInTagFromBrand(value) {
+	if (hasBrand(value, "[object Date]")) return "[object Date]";
+	if (hasBrand(value, "[object RegExp]")) return "[object RegExp]";
+	if (hasBrand(value, "[object Map]")) return "[object Map]";
+	if (hasBrand(value, "[object Set]")) return "[object Set]";
+	if (hasBrand(value, "[object WeakMap]")) return "[object WeakMap]";
+	if (hasBrand(value, "[object WeakSet]")) return "[object WeakSet]";
+	if (hasBrand(value, "[object DataView]")) return "[object DataView]";
+	if (hasBrand(value, "[object ArrayBuffer]")) return "[object ArrayBuffer]";
+	if (hasBrand(value, "[object SharedArrayBuffer]")) return "[object SharedArrayBuffer]";
+	if (hasBrand(value, "[object Boolean]")) return "[object Boolean]";
+	if (hasBrand(value, "[object Number]")) return "[object Number]";
+	if (hasBrand(value, "[object String]")) return "[object String]";
+	if (hasBrand(value, "[object BigInt]")) return "[object BigInt]";
+	if (hasNativePrototype(value, "Promise")) return "[object Promise]";
+	if (hasNativePrototype(value, "Error")) return "[object Error]";
+}
+function hasNativePrototype(value, expectedName) {
+	const visited = /* @__PURE__ */ new WeakSet();
+	let prototype = Object.getPrototypeOf(value);
+	while (prototype !== null && !visited.has(prototype)) {
+		visited.add(prototype);
+		if (isIntrinsicConstructorPrototype(prototype, expectedName)) return true;
+		prototype = Object.getPrototypeOf(prototype);
+	}
+	return false;
+}
+/**
+* Verifies that `obj` genuinely is the type its tag claims, via an
+* internal-slot probe. Promise and Error have no side-effect-free standard
+* probe, so their visible tags remain conservative; masked instances are
+* identified separately through their native prototype chain.
+*/
+function hasBrand(obj, tag) {
+	try {
+		switch (tag) {
+			case "[object Date]":
+				dateGetTime.call(obj);
+				return true;
+			case "[object RegExp]":
+				regExpSourceGet.call(obj);
+				return true;
+			case "[object Map]":
+				mapSizeGet.call(obj);
+				return true;
+			case "[object Set]":
+				setSizeGet.call(obj);
+				return true;
+			case "[object WeakMap]":
+				weakMapHas.call(obj, PROBE_KEY);
+				return true;
+			case "[object WeakSet]":
+				weakSetHas.call(obj, PROBE_KEY);
+				return true;
+			case "[object DataView]":
+				dataViewByteLengthGet.call(obj);
+				return true;
+			case "[object ArrayBuffer]":
+				arrayBufferByteLengthGet.call(obj);
+				return true;
+			case "[object SharedArrayBuffer]":
+				if (!sharedArrayBufferByteLengthGet) return false;
+				sharedArrayBufferByteLengthGet.call(obj);
+				return true;
+			case "[object Boolean]":
+				booleanValueOf.call(obj);
+				return true;
+			case "[object Number]":
+				numberValueOf.call(obj);
+				return true;
+			case "[object String]":
+				stringValueOf.call(obj);
+				return true;
+			case "[object BigInt]":
+				bigIntValueOf.call(obj);
+				return true;
+			case "[object Promise]": return hasNativePrototype(obj, "Promise");
+			case "[object Error]": return ERROR_INTRINSIC_NAMES.some((name) => hasNativePrototype(obj, name));
+			default: return false;
+		}
+	} catch {
+		return false;
+	}
+}
+/**
+* Returns `true` when `obj` is a built-in JavaScript type that should be
+* treated atomically (compared/cloned as a unit, not walked structurally).
+* Cross-realm safe, and brand-verified: a plain object spoofing a built-in
+* tag via `Symbol.toStringTag` returns `false` and is walked structurally
+* like any other plain object instead of crashing type-specific code.
+*
+* @param obj - The object to classify
+* @param tag - The result of `Object.prototype.toString.call(obj)`, passed
+*              in so callers that already computed it don't pay twice
+*/
+function isBuiltInObject(obj, tag) {
+	if (ArrayBuffer.isView(obj)) return true;
+	if (tag.endsWith("Array]")) return false;
+	return BUILT_IN_TAGS.has(tag) && hasBrand(obj, tag);
+}
+
+//#endregion
+//#region src/utils/array/deep-equal.ts
+const objProto = Object.prototype;
+const objToString = objProto.toString;
+const objHasOwn = objProto.hasOwnProperty;
+/**
+* SameValueZero: `===` plus NaN-equals-NaN (and `+0 === -0`, unlike
+* `Object.is`). The numeric semantics `deepEqual` documents for primitives,
+* applied consistently inside TypedArrays, Dates and Number wrappers.
+*/
+function sameValueZero(a, b) {
+	return a === b || Number.isNaN(a) && Number.isNaN(b);
+}
+/**
+* Performs a deep equality check between two values.
+*
+* This function compares values recursively, handling:
+* - Primitives (with special handling for NaN)
+* - Arrays (nested arrays supported)
+* - Objects (plain objects and class instances)
+* - TypedArrays (Uint8Array, Int32Array, etc.)
+* - DataView
+* - Maps and Sets
+* - Dates and RegExp
+* - Wrapper objects (Boolean, Number, String)
+* - Circular references (detected and handled)
+*
+* @param a - The first value to compare
+* @param b - The second value to compare
+* @returns `true` if the values are deeply equal, `false` otherwise
+*
+* @example
+* ```ts
+* deepEqual([1, 2, 3], [1, 2, 3]); // true
+* deepEqual({ a: 1, b: [2, 3] }, { a: 1, b: [2, 3] }); // true
+* deepEqual(NaN, NaN); // true
+* deepEqual([1, 2], [1, 2, 3]); // false
+* ```
+*/
+function deepEqual(a, b) {
+	return deepEqualInner(a, b, /* @__PURE__ */ new WeakMap());
+}
+/**
+* Internal recursive function for deep equality comparison.
+*
+* @internal
+*/
+function deepEqualInner(a, b, visited) {
+	if (a === b) return true;
+	const typeA = typeof a;
+	const typeB = typeof b;
+	if (typeA !== "object" || a === null || typeB !== "object" || b === null) {
+		if (typeA === "number" && typeB === "number") return Number.isNaN(a) && Number.isNaN(b);
+		return false;
+	}
+	const objA = a;
+	const objB = b;
+	let cachedBs = visited.get(objA);
+	if (cachedBs?.has(objB)) return true;
+	if (!cachedBs) {
+		cachedBs = /* @__PURE__ */ new WeakSet();
+		visited.set(objA, cachedBs);
+	}
+	cachedBs.add(objB);
+	if (ArrayBuffer.isView(objA) || ArrayBuffer.isView(objB)) {
+		if (!ArrayBuffer.isView(objA) || !ArrayBuffer.isView(objB)) return false;
+		const tagA = objToString.call(objA);
+		if (tagA !== objToString.call(objB)) return false;
+		if (tagA === "[object DataView]") {
+			const viewA = objA;
+			const viewB = objB;
+			if (viewA.byteLength !== viewB.byteLength) return false;
+			const len = viewA.byteLength;
+			for (let i = 0; i < len; i++) if (viewA.getUint8(i) !== viewB.getUint8(i)) return false;
+			return true;
+		}
+		const arrA = objA;
+		const arrB = objB;
+		const len = arrA.length;
+		if (len !== arrB.length) return false;
+		for (let i = 0; i < len; i++) if (!sameValueZero(arrA[i], arrB[i])) return false;
+		return true;
+	}
+	if (Array.isArray(objA) || Array.isArray(objB)) {
+		if (!Array.isArray(objA) || !Array.isArray(objB)) return false;
+		if (objA.length !== objB.length) return false;
+		const keysA = Reflect.ownKeys(objA).filter((key) => key !== "length");
+		const keysB = Reflect.ownKeys(objB).filter((key) => key !== "length");
+		if (keysA.length !== keysB.length) return false;
+		const arrA = objA;
+		const arrB = objB;
+		for (const key of keysA) {
+			if (!objHasOwn.call(objB, key)) return false;
+			if (!deepEqualInner(arrA[key], arrB[key], visited)) return false;
+		}
+		return true;
+	}
+	const tagA = objToString.call(objA);
+	const tagB = objToString.call(objB);
+	if (tagA !== tagB) return false;
+	const builtInA = isBuiltInObject(objA, tagA);
+	if (builtInA !== isBuiltInObject(objB, tagB)) return false;
+	if (!builtInA) {
+		if (isOpaqueExoticTag(tagA)) return objA === objB;
+		return comparePlainObjects(objA, objB, visited);
+	}
+	switch (tagA) {
+		case "[object Map]": {
+			const mapA = objA;
+			const mapB = objB;
+			if (mapA.size !== mapB.size) return false;
+			for (const [key, valA] of mapA) {
+				if (!mapB.has(key)) return false;
+				if (!deepEqualInner(valA, mapB.get(key), visited)) return false;
+			}
+			return true;
+		}
+		case "[object Set]": {
+			const setA = objA;
+			const setB = objB;
+			if (setA.size !== setB.size) return false;
+			for (const value of setA) if (!setB.has(value)) return false;
+			return true;
+		}
+		case "[object Date]": return sameValueZero(objA.getTime(), objB.getTime());
+		case "[object RegExp]": {
+			const regA = objA;
+			const regB = objB;
+			return regA.source === regB.source && regA.flags === regB.flags;
+		}
+		case "[object Boolean]":
+		case "[object Number]":
+		case "[object String]":
+		case "[object BigInt]": return sameValueZero(objA.valueOf(), objB.valueOf());
+		default: return objA === objB;
+	}
+}
+/**
+* Plain / custom objects: compare own enumerable string keys + own symbol
+* keys and their values. Used both as the final fallback and for objects
+* whose built-in-looking tag failed brand verification.
+*/
+function comparePlainObjects(objA, objB, visited) {
+	const recA = objA;
+	const recB = objB;
+	const stringKeysA = Object.getOwnPropertyNames(objA);
+	const stringKeysB = Object.getOwnPropertyNames(objB);
+	if (stringKeysA.length !== stringKeysB.length) return false;
+	const symbolKeysA = Object.getOwnPropertySymbols(objA);
+	const symbolKeysB = Object.getOwnPropertySymbols(objB);
+	if (symbolKeysA.length !== symbolKeysB.length) return false;
+	const symbolKeysBSet = new Set(symbolKeysB);
+	for (const key of stringKeysA) if (!objHasOwn.call(objB, key)) return false;
+	for (const key of symbolKeysA) if (!symbolKeysBSet.has(key)) return false;
+	for (const key of stringKeysA) if (!deepEqualInner(recA[key], recB[key], visited)) return false;
+	for (const key of symbolKeysA) if (!deepEqualInner(recA[key], recB[key], visited)) return false;
+	return true;
+}
+
+//#endregion
+//#region src/utils/array/deep-omit.ts
+/**
+* Creates a deep copy of `value` with certain keys removed according to the
+* provided rules.
+*
+* Walks the object tree and skips keys that match `ignoreKeys` /
+* `ignoreKeyPredicate`. Built-in atomic types that `deepEqual` compares by
+* value (Date, RegExp, Map, Set, TypedArrays, DataView) are cloned by type
+* rather than walked, since their internal structure has no key filtering to
+* apply. Types that `deepEqual` compares by reference (Error, ArrayBuffer,
+* SharedArrayBuffer, Promise, WeakMap, WeakSet) are passed through by
+* reference, so `deepEqualExcept(x, x)` stays reflexive. Cycles are
+* preserved: a cycle `a → a` clones to `a' → a'`. Arrays retain sparse
+* holes and all non-ignored own properties, including symbol keys.
+*
+* **Shared references.** Without `ignoreKeyPredicate`, an object reached
+* via several paths dedupes to a single clone. With a predicate, each
+* path gets its own clone, because the predicate may decide differently per
+* path, so memoising the first path's result would be wrong. This is
+* inherently exponential for diamond-shaped sharing (a node reachable
+* via 2^n paths is cloned 2^n times); the walk aborts with a descriptive
+* error after {@link PATH_SENSITIVE_VISIT_BUDGET} node visits instead of
+* hanging the process.
+*
+* **Prototype-pollution safety.** `__proto__` and `constructor` keys
+* encountered as *own* properties of the input (typical of `JSON.parse`
+* output) are copied as inert data properties via `Object.defineProperty`
+* so the clone graph cannot bleed into `Object.prototype`.
+*
+* **Class instances.** When the input is a class instance, the clone is
+* built via `Object.create(proto)` so the prototype is preserved, but the
+* constructor is NOT re-invoked, so class invariants enforced by the
+* constructor are not re-checked. `deepOmit` is therefore best used for
+* comparison/serialisation (`voEqualsExcept`, `deepEqualExcept`), not as
+* a general-purpose clone for behaviour-carrying objects.
+*
+* @param value - The value to create a deep copy from
+* @param options - Options specifying which keys to ignore
+* @returns A deep copy of `value` with specified keys removed
+*/
+function deepOmit(value, options) {
+	const visited = /* @__PURE__ */ new WeakMap();
+	return omitInternal(value, options, options.ignoreKeys ? new Set(options.ignoreKeys) : void 0, [], visited, options.ignoreKeyPredicate ? { visits: 0 } : void 0);
+}
+/**
+* Maximum object-node visits for a single path-sensitive `deepOmit` walk.
+* Per-path cloning expands exponentially on diamond-shaped sharing; past
+* this bound the walk throws instead of hanging the process. One million
+* visits covers any realistically tree-shaped input.
+*/
+const PATH_SENSITIVE_VISIT_BUDGET = 1e6;
+function omitInternal(value, options, ignoreKeys, path, visited, budget) {
+	if (value === null) return value;
+	if (typeof value !== "object") return value;
+	const obj = value;
+	if (visited.has(obj)) return visited.get(obj);
+	if (budget && ++budget.visits > PATH_SENSITIVE_VISIT_BUDGET) throw new Error(`deepOmit: exceeded ${PATH_SENSITIVE_VISIT_BUDGET} node visits. With ignoreKeyPredicate, objects reached via shared references are cloned once per path (the predicate may decide differently per path), which expands exponentially on diamond-shaped sharing. Restructure the input to a tree, or use ignoreKeys for path-independent filtering.`);
+	if (Array.isArray(obj)) {
+		const arr = obj;
+		const clone = new Array(arr.length);
+		const lengthDescriptor = Object.getOwnPropertyDescriptor(arr, "length");
+		visited.set(obj, clone);
+		for (const key of Reflect.ownKeys(arr)) {
+			if (key === "length") continue;
+			const segment = arrayPathSegment(key);
+			if (typeof segment !== "number" && shouldIgnoreKey(key, path, ignoreKeys, options)) continue;
+			const descriptor = Object.getOwnPropertyDescriptor(arr, key);
+			if (descriptor === void 0) continue;
+			path.push(segment);
+			if ("value" in descriptor) descriptor.value = omitInternal(descriptor.value, options, ignoreKeys, path, visited, budget);
+			Object.defineProperty(clone, key, descriptor);
+			path.pop();
+		}
+		if (lengthDescriptor !== void 0) Object.defineProperty(clone, "length", lengthDescriptor);
+		if (budget) visited.delete(obj);
+		return clone;
+	}
+	const tag = Object.prototype.toString.call(obj);
+	if (isBuiltInObject(obj, tag)) {
+		const builtInClone = cloneBuiltIn(obj, tag);
+		visited.set(obj, builtInClone);
+		return builtInClone;
+	}
+	if (isOpaqueExoticTag(tag)) {
+		visited.set(obj, obj);
+		return obj;
+	}
+	const clone = Object.create(Object.getPrototypeOf(obj));
+	visited.set(obj, clone);
+	const stringKeys = Object.getOwnPropertyNames(obj);
+	const symbolKeys = Object.getOwnPropertySymbols(obj);
+	for (const key of [...stringKeys, ...symbolKeys]) {
+		if (shouldIgnoreKey(key, path, ignoreKeys, options)) continue;
+		path.push(key);
+		assignOwn(clone, key, omitInternal(obj[key], options, ignoreKeys, path, visited, budget), Object.getOwnPropertyDescriptor(obj, key)?.enumerable ?? true);
+		path.pop();
+	}
+	if (budget) visited.delete(obj);
+	return clone;
+}
+function arrayPathSegment(key) {
+	if (typeof key === "symbol") return key;
+	const index = Number(key);
+	return Number.isInteger(index) && index >= 0 && index < 4294967295 && String(index) === key ? index : key;
+}
+/**
+* Assigns `value` as an OWN data property on `target` without going through
+* any inherited setter; critically, it never invokes the `__proto__` setter
+* even when `key === "__proto__"`. Required to defeat prototype-pollution
+* payloads that ship `__proto__` as a parsed-JSON own key.
+*/
+function assignOwn(target, key, value, enumerable = true) {
+	Object.defineProperty(target, key, {
+		value,
+		writable: true,
+		enumerable,
+		configurable: true
+	});
+}
+/**
+* Clones a built-in atomic type by case. Falls back to `structuredClone`
+* for anything not explicitly enumerated (e.g. DataView, TypedArrays,
+* Boolean/Number/String wrappers, all of which `deepEqual` compares by
+* value). Types that `deepEqual` compares BY REFERENCE (the shared
+* {@link REFERENCE_COMPARED_TAGS} set) are passed through by reference
+* instead; cloning them would make `deepEqualExcept(x, x)` false.
+* Promise/WeakMap/WeakSet additionally cannot be cloned at all
+* (`structuredClone` rejects them).
+*/
+function cloneBuiltIn(obj, tag) {
+	if (REFERENCE_COMPARED_TAGS.has(tag)) return obj;
+	switch (tag) {
+		case "[object Date]": return new Date(obj.getTime());
+		case "[object RegExp]": {
+			const re = obj;
+			const copy = new RegExp(re.source, re.flags);
+			copy.lastIndex = re.lastIndex;
+			return copy;
+		}
+		case "[object Map]": return new Map(obj);
+		case "[object Set]": return new Set(obj);
+		default: return structuredClone(obj);
+	}
+}
+function shouldIgnoreKey(key, path, ignoreKeys, options) {
+	if (ignoreKeys?.has(key)) return true;
+	if (options.ignoreKeyPredicate?.(key, path.slice())) return true;
+	return false;
+}
+
+//#endregion
+//#region src/utils/array/deep-equal-except.ts
+/**
+* Performs a deep equality comparison between two values after omitting specified keys.
+*
+* This function first removes the specified keys from both values using `deepOmit`,
+* then performs a deep equality check using `deepEqual`.
+*
+* @param a - The first value to compare
+* @param b - The second value to compare
+* @param options - Options specifying which keys to omit before comparison
+* @returns `true` if the values are deeply equal after omitting specified keys, `false` otherwise
+*
+* @example
+* ```ts
+* const obj1 = { id: 1, name: "Alice", updatedAt: "2024-01-01" };
+* const obj2 = { id: 2, name: "Alice", updatedAt: "2024-01-02" };
+*
+* deepEqualExcept(obj1, obj2, { ignoreKeys: ["id", "updatedAt"] }); // true
+* ```
+*/
+function deepEqualExcept(a, b, options) {
+	return deepEqual(deepOmit(a, options), deepOmit(b, options));
+}
+
+//#endregion
+export { findPropertyDescriptor as a, isIntrinsicConstructorPrototype as c, builtInTagWithoutInvokingAccessors as i, mutableBuiltInTagWithoutInvokingAccessors as l, deepOmit as n, hasIntrinsicPrototypeChain as o, deepEqual as r, isBuiltInObject as s, deepEqualExcept as t };
+//# sourceMappingURL=deep-equal-except.js.map