freewind-ts-utils 0.18.2

package/antd/_internal/HighlightParts.d.ts

@@ -0,0 +1,6 @@
+import { FC } from 'react';
+import { FuzzyMatchPart } from '../../common/fuzzy/fuzzyMatch.js';
+export type HighlightPartsProps = {
+    parts: FuzzyMatchPart[];
+};
+export declare const HighlightParts: FC<HighlightPartsProps>;

package/antd/_internal/HighlightParts.js

@@ -0,0 +1,12 @@
+import { Typography as e } from "antd";
+import { jsx as t } from "react/jsx-runtime";
+//#region src/antd/_internal/HighlightParts.tsx
+var n = ({ parts: e }) => /* @__PURE__ */ t("span", { children: e.map((e, t) => r(e, t)) });
+function r(n, r) {
+	return n.matched ? /* @__PURE__ */ t(e.Text, {
+		mark: !0,
+		children: n.text
+	}, r) : /* @__PURE__ */ t("span", { children: n.text }, r);
+}
+//#endregion
+export { n as HighlightParts };

package/antd/index.d.ts

@@ -0,0 +1,8 @@
+export * from './CopyButton/index.js';
+export * from './FloatLabel/index.js';
+export * from './FuzzyAutoComplete/index.js';
+export * from './FuzzyPathSelect/index.js';
+export * from './FuzzyStringSelect/index.js';
+export * from './HoverSwap/index.js';
+export * from './InputLabel/index.js';
+export * from './JsonPreviewer/index.js';

package/antd/index.js

@@ -0,0 +1,17 @@
+import { CopyButton as e } from "./CopyButton/CopyButton.js";
+import "./CopyButton/index.js";
+import { FloatLabel as t } from "./FloatLabel/FloatLabel.js";
+import "./FloatLabel/index.js";
+import { FuzzyAutoComplete as n } from "./FuzzyAutoComplete/FuzzyAutoComplete.js";
+import "./FuzzyAutoComplete/index.js";
+import { FuzzyPathSelect as r } from "./FuzzyPathSelect/FuzzyPathSelect.js";
+import "./FuzzyPathSelect/index.js";
+import { FuzzyStringSelect as i } from "./FuzzyStringSelect/FuzzyStringSelect.js";
+import "./FuzzyStringSelect/index.js";
+import { HoverSwap as a } from "./HoverSwap/HoverSwap.js";
+import "./HoverSwap/index.js";
+import { InputLabel as o } from "./InputLabel/InputLabel.js";
+import "./InputLabel/index.js";
+import { JsonPreviewer as s } from "./JsonPreviewer/JsonPreviewer.js";
+import "./JsonPreviewer/index.js";
+export { e as CopyButton, t as FloatLabel, n as FuzzyAutoComplete, r as FuzzyPathSelect, i as FuzzyStringSelect, a as HoverSwap, o as InputLabel, s as JsonPreviewer };

package/common/SimpleType.d.ts

@@ -0,0 +1,2 @@
+export type SimpleType = string | boolean | number | bigint | symbol | undefined | null;
+export type SimpleTypeName = "string" | "boolean" | "number" | "bigint" | "symbol" | "undefined" | "null";

package/common/_internal/createObjectReferenceTracker.d.ts

@@ -0,0 +1,5 @@
+type ObjectReferenceTracker = {
+    remember: (value: object, path: string) => string | undefined;
+};
+export declare function createObjectReferenceTracker(): ObjectReferenceTracker;
+export {};

package/common/_internal/createObjectReferenceTracker.js

@@ -0,0 +1,11 @@
+//#region src/common/_internal/createObjectReferenceTracker.ts
+function e() {
+	let e = /* @__PURE__ */ new Map();
+	return { remember(t, n) {
+		let r = e.get(t);
+		if (r) return r;
+		e.set(t, n);
+	} };
+}
+//#endregion
+export { e as createObjectReferenceTracker };

package/common/anyToString/anyToString.d.ts

@@ -0,0 +1,27 @@
+type AnyToStringOptions = {
+    maxDepth?: number;
+    maxEntries?: number;
+    maxStringLength?: number;
+    spaces?: number;
+};
+/**
+ * Converts any value into a readable string and safely handles special objects such as
+ * `Error`, `Date`, `Map`, `Set`, DOM nodes, `window`, and circular references.
+ *
+ * It avoids invoking enumerable getters, keeps custom instance names visible, and can
+ * shorten deep or wide structures to keep logs readable.
+ *
+ * @example
+ * ```ts
+ * anyToString({
+ *   user: 'alice',
+ *   error: new Error('request failed'),
+ * })
+ * // {
+ * //   user: "alice",
+ * //   error: Error: request failed
+ * // }
+ * ```
+ */
+export declare function anyToString(value: unknown, options?: AnyToStringOptions): string;
+export {};

package/common/anyToString/anyToString.js

@@ -0,0 +1,23 @@
+import { createCircularStackTracker as e } from "./createCircularStackTracker.js";
+import { formatValue as t } from "./formatters/formatValue.js";
+//#region src/common/anyToString/anyToString.ts
+var n = 4, r = 20, i = 2;
+function a(n, r = {}) {
+	return t(n, {
+		options: o(r),
+		circularTracker: e()
+	}, 0, !1);
+}
+function o(e) {
+	return {
+		maxDepth: s(e.maxDepth, n),
+		maxEntries: s(e.maxEntries, r),
+		maxStringLength: e.maxStringLength === void 0 ? void 0 : s(e.maxStringLength, 0),
+		spaces: s(e.spaces, i)
+	};
+}
+function s(e, t) {
+	return typeof e != "number" || !Number.isFinite(e) ? t : Math.max(0, Math.floor(e));
+}
+//#endregion
+export { a as anyToString };

package/common/anyToString/createCircularStackTracker.d.ts

@@ -0,0 +1,5 @@
+export type CircularStackTracker = {
+    enter: (value: object) => boolean;
+    leave: (value: object) => void;
+};
+export declare function createCircularStackTracker(): CircularStackTracker;

package/common/anyToString/createCircularStackTracker.js

@@ -0,0 +1,14 @@
+//#region src/common/anyToString/createCircularStackTracker.ts
+function e() {
+	let e = /* @__PURE__ */ new WeakSet();
+	return {
+		enter(t) {
+			return e.has(t) ? !0 : (e.add(t), !1);
+		},
+		leave(t) {
+			e.delete(t);
+		}
+	};
+}
+//#endregion
+export { e as createCircularStackTracker };

package/common/anyToString/formatters/formatArray.d.ts

@@ -0,0 +1,2 @@
+import { FormatContext } from './formatValue.js';
+export declare function formatArray(value: unknown[], context: FormatContext, depth: number): string;

package/common/anyToString/formatters/formatArray.js

@@ -0,0 +1,11 @@
+import { joinBlock as e } from "./joinBlock.js";
+import { formatValue as t } from "./formatValue.js";
+//#region src/common/anyToString/formatters/formatArray.ts
+function n(n, r, i) {
+	if (i >= r.options.maxDepth) return `[Array(${n.length})]`;
+	let a = [], o = Math.min(n.length, r.options.maxEntries);
+	for (let e = 0; e < o; e += 1) a.push(e in n ? t(n[e], r, i + 1, !0) : "<empty>");
+	return n.length > o && a.push(`...(${n.length - o} more)`), e("[", "]", a, r.options.spaces, i);
+}
+//#endregion
+export { n as formatArray };

package/common/anyToString/formatters/formatArrayBufferView.d.ts

@@ -0,0 +1,2 @@
+import { FormatContext } from './formatValue.js';
+export declare function formatArrayBufferView(value: ArrayBufferView, context: FormatContext, depth: number): string;

package/common/anyToString/formatters/formatArrayBufferView.js

@@ -0,0 +1,14 @@
+import { joinBlock as e } from "./joinBlock.js";
+import { getConstructorName as t } from "./getConstructorName.js";
+import { formatValue as n } from "./formatValue.js";
+//#region src/common/anyToString/formatters/formatArrayBufferView.ts
+function r(r, i, a) {
+	let o = t(r) || "ArrayBufferView";
+	if (r instanceof DataView) return `${o}(${r.byteLength})`;
+	let s = Array.from(r);
+	if (a >= i.options.maxDepth) return `${o}(${s.length})`;
+	let c = Math.min(s.length, i.options.maxEntries), l = s.slice(0, c).map((e) => n(e, i, a + 1, !0));
+	return s.length > c && l.push(`...(${s.length - c} more)`), e(`${o}(${s.length}) [`, "]", l, i.options.spaces, a);
+}
+//#endregion
+export { r as formatArrayBufferView };

package/common/anyToString/formatters/formatDocumentObject.d.ts

@@ -0,0 +1 @@
+export declare function formatDocumentObject(value: object): string;

package/common/anyToString/formatters/formatDocumentObject.js

@@ -0,0 +1,7 @@
+//#region src/common/anyToString/formatters/formatDocumentObject.ts
+function e(e) {
+	let t = "title" in e && typeof e.title == "string" ? e.title : "";
+	return `Document(${JSON.stringify(t)})`;
+}
+//#endregion
+export { e as formatDocumentObject };

package/common/anyToString/formatters/formatElementObject.d.ts

@@ -0,0 +1 @@
+export declare function formatElementObject(value: object): string;

package/common/anyToString/formatters/formatElementObject.js

@@ -0,0 +1,15 @@
+//#region src/common/anyToString/formatters/formatElementObject.ts
+function e(e) {
+	let n = "tagName" in e && typeof e.tagName == "string" ? e.tagName.toLowerCase() : "element", r = "id" in e && typeof e.id == "string" && e.id ? `#${e.id}` : "", i = t(e);
+	return `${n}${r}${i ? "." + i.trim().split(/\s+/).filter(Boolean).join(".") : ""}`;
+}
+function t(e) {
+	if ("className" in e && typeof e.className == "string") return e.className;
+	if ("getAttribute" in e && typeof e.getAttribute == "function") {
+		let t = e.getAttribute("class");
+		return typeof t == "string" ? t : "";
+	}
+	return "";
+}
+//#endregion
+export { e as formatElementObject };

package/common/anyToString/formatters/formatError.d.ts

@@ -0,0 +1 @@
+export declare function formatError(value: Error): string;

package/common/anyToString/formatters/formatError.js

@@ -0,0 +1,7 @@
+//#region src/common/anyToString/formatters/formatError.ts
+function e(e) {
+	let t = e.name || "Error";
+	return e.message ? `${t}: ${e.message}` : t;
+}
+//#endregion
+export { e as formatError };

package/common/anyToString/formatters/formatFunction.d.ts

@@ -0,0 +1 @@
+export declare function formatFunction(value: Function): string;

package/common/anyToString/formatters/formatFunction.js

@@ -0,0 +1,6 @@
+//#region src/common/anyToString/formatters/formatFunction.ts
+function e(e) {
+	return `[Function ${e.name || "anonymous"}]`;
+}
+//#endregion
+export { e as formatFunction };

package/common/anyToString/formatters/formatMap.d.ts

@@ -0,0 +1,2 @@
+import { FormatContext } from './formatValue.js';
+export declare function formatMap(value: Map<unknown, unknown>, context: FormatContext, depth: number): string;

package/common/anyToString/formatters/formatMap.js

@@ -0,0 +1,17 @@
+import { joinBlock as e } from "./joinBlock.js";
+import { formatValue as t } from "./formatValue.js";
+//#region src/common/anyToString/formatters/formatMap.ts
+function n(n, r, i) {
+	if (i >= r.options.maxDepth) return `Map(${n.size})`;
+	let a = [], o = 0;
+	for (let [e, s] of n) {
+		if (o >= r.options.maxEntries) {
+			a.push(`...(${n.size - o} more)`);
+			break;
+		}
+		a.push(`${t(e, r, i + 1, !0)} => ${t(s, r, i + 1, !0)}`), o += 1;
+	}
+	return e("Map(" + String(n.size) + ") {", "}", a, r.options.spaces, i);
+}
+//#endregion
+export { n as formatMap };

package/common/anyToString/formatters/formatObject.d.ts

@@ -0,0 +1,2 @@
+import { FormatContext } from './formatValue.js';
+export declare function formatObject(value: object, context: FormatContext, depth: number): string;

package/common/anyToString/formatters/formatObject.js

@@ -0,0 +1,44 @@
+import { formatArray as e } from "./formatArray.js";
+import { formatArrayBufferView as t } from "./formatArrayBufferView.js";
+import { formatDocumentObject as n } from "./formatDocumentObject.js";
+import { formatElementObject as r } from "./formatElementObject.js";
+import { formatError as i } from "./formatError.js";
+import { formatMap as a } from "./formatMap.js";
+import { formatRecordLike as o } from "./formatRecordLike.js";
+import { formatSet as s } from "./formatSet.js";
+import { formatWindowObject as c } from "./formatWindowObject.js";
+import { withCircularGuard as l } from "./withCircularGuard.js";
+import { formatValue as u } from "./formatValue.js";
+//#region src/common/anyToString/formatters/formatObject.ts
+function d(d, _, v) {
+	let y = f(d);
+	return y !== void 0 && y !== d ? u(y, _, v, !1) : d instanceof Date ? Number.isNaN(d.getTime()) ? "Invalid Date" : d.toISOString() : d instanceof Error ? i(d) : d instanceof RegExp ? String(d) : typeof URL < "u" && d instanceof URL ? `URL(${d.href})` : p(d) ? "Promise" : m(d) ? c(d) : h(d) ? n(d) : g(d) ? r(d) : Array.isArray(d) ? l(d, _, () => e(d, _, v)) : d instanceof Map ? l(d, _, () => a(d, _, v)) : d instanceof Set ? l(d, _, () => s(d, _, v)) : ArrayBuffer.isView(d) ? t(d, _, v) : d instanceof ArrayBuffer ? `ArrayBuffer(${d.byteLength})` : l(d, _, () => o(d, _, v));
+}
+function f(e) {
+	if (!("toQuickValue" in e)) return;
+	let t = e.toQuickValue;
+	if (typeof t == "function") try {
+		return t.call(e);
+	} catch {
+		return;
+	}
+}
+function p(e) {
+	return _(e) === "[object Promise]" || "then" in e && typeof e.then == "function";
+}
+function m(e) {
+	let t = _(e);
+	return t === "[object Window]" || t === "[object global]" && "window" in e && e.window === e && "document" in e;
+}
+function h(e) {
+	let t = _(e);
+	return t === "[object Document]" || t === "[object HTMLDocument]" || "nodeType" in e && e.nodeType === 9 && "title" in e;
+}
+function g(e) {
+	return "nodeType" in e && e.nodeType === 1 && "tagName" in e;
+}
+function _(e) {
+	return Object.prototype.toString.call(e);
+}
+//#endregion
+export { d as formatObject };

package/common/anyToString/formatters/formatObjectKey.d.ts

@@ -0,0 +1 @@
+export declare function formatObjectKey(key: PropertyKey): string;

package/common/anyToString/formatters/formatObjectKey.js

@@ -0,0 +1,8 @@
+//#region src/common/anyToString/formatters/formatObjectKey.ts
+function e(e) {
+	if (typeof e == "symbol") return `[${String(e)}]`;
+	let t = String(e);
+	return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(t) ? t : JSON.stringify(t);
+}
+//#endregion
+export { e as formatObjectKey };

package/common/anyToString/formatters/formatRecordLike.d.ts

@@ -0,0 +1,2 @@
+import { FormatContext } from './formatValue.js';
+export declare function formatRecordLike(value: object, context: FormatContext, depth: number): string;

package/common/anyToString/formatters/formatRecordLike.js

@@ -0,0 +1,39 @@
+import { joinBlock as e } from "./joinBlock.js";
+import { getConstructorName as t } from "./getConstructorName.js";
+import { getEnumerableOwnDescriptors as n } from "../../getEnumerableOwnDescriptors.js";
+import { formatObjectKey as r } from "./formatObjectKey.js";
+import { formatValue as i } from "./formatValue.js";
+//#region src/common/anyToString/formatters/formatRecordLike.ts
+function a(n, i, a) {
+	let l = t(n);
+	if (a >= i.options.maxDepth) return l ? `${l} { ... }` : "{ ... }";
+	let u = s(n).map(([e, t]) => `${r(e)}: ${c(t, i, a + 1)}`);
+	return (l ? `${l} ` : "") + e("{", "}", o(u, i.options.maxEntries), i.options.spaces, a);
+}
+function o(e, t) {
+	return e.length <= t ? e : [...e.slice(0, t), `...(${e.length - t} more)`];
+}
+function s(e) {
+	let t = [];
+	for (let [r, i] of n(e)) {
+		if ("value" in i) {
+			t.push([r, i.value]);
+			continue;
+		}
+		if (i.get && i.set) {
+			t.push([r, "[Getter/Setter]"]);
+			continue;
+		}
+		if (i.get) {
+			t.push([r, "[Getter]"]);
+			continue;
+		}
+		t.push([r, "[Setter]"]);
+	}
+	return t;
+}
+function c(e, t, n) {
+	return e === "[Getter]" || e === "[Getter/Setter]" || e === "[Setter]" ? e : i(e, t, n, !0);
+}
+//#endregion
+export { a as formatRecordLike };

package/common/anyToString/formatters/formatSet.d.ts

@@ -0,0 +1,2 @@
+import { FormatContext } from './formatValue.js';
+export declare function formatSet(value: Set<unknown>, context: FormatContext, depth: number): string;

package/common/anyToString/formatters/formatSet.js

@@ -0,0 +1,17 @@
+import { joinBlock as e } from "./joinBlock.js";
+import { formatValue as t } from "./formatValue.js";
+//#region src/common/anyToString/formatters/formatSet.ts
+function n(n, r, i) {
+	if (i >= r.options.maxDepth) return `Set(${n.size})`;
+	let a = [], o = 0;
+	for (let e of n) {
+		if (o >= r.options.maxEntries) {
+			a.push(`...(${n.size - o} more)`);
+			break;
+		}
+		a.push(t(e, r, i + 1, !0)), o += 1;
+	}
+	return e("Set(" + String(n.size) + ") {", "}", a, r.options.spaces, i);
+}
+//#endregion
+export { n as formatSet };

package/common/anyToString/formatters/formatString.d.ts

@@ -0,0 +1 @@
+export declare function formatString(value: string, maxStringLength: number | undefined, nested: boolean): string;

package/common/anyToString/formatters/formatString.js

@@ -0,0 +1,8 @@
+import { truncateString as e } from "../../truncateString.js";
+//#region src/common/anyToString/formatters/formatString.ts
+function t(t, n, r) {
+	let i = n === void 0 ? t : e(t, n);
+	return r ? JSON.stringify(i) : i;
+}
+//#endregion
+export { t as formatString };

package/common/anyToString/formatters/formatValue.d.ts

@@ -0,0 +1,11 @@
+import { CircularStackTracker } from '../createCircularStackTracker.js';
+export type FormatContext = {
+    options: {
+        maxDepth: number;
+        maxEntries: number;
+        maxStringLength: number | undefined;
+        spaces: number;
+    };
+    circularTracker: CircularStackTracker;
+};
+export declare function formatValue(value: unknown, context: FormatContext, depth: number, nested: boolean): string;

package/common/anyToString/formatters/formatValue.js

@@ -0,0 +1,20 @@
+import { formatFunction as e } from "./formatFunction.js";
+import { formatObject as t } from "./formatObject.js";
+import { formatString as n } from "./formatString.js";
+//#region src/common/anyToString/formatters/formatValue.ts
+function r(r, i, a, o) {
+	if (r === null) return "null";
+	if (r === void 0) return "undefined";
+	switch (typeof r) {
+		case "string": return n(r, i.options.maxStringLength, o);
+		case "number": return Number.isNaN(r) ? "NaN" : String(r);
+		case "boolean": return String(r);
+		case "bigint": return `${r}n`;
+		case "symbol": return String(r);
+		case "function": return e(r);
+		case "object": return t(r, i, a);
+		default: return String(r);
+	}
+}
+//#endregion
+export { r as formatValue };

package/common/anyToString/formatters/formatWindowObject.d.ts

@@ -0,0 +1 @@
+export declare function formatWindowObject(value: object): string;

package/common/anyToString/formatters/formatWindowObject.js

@@ -0,0 +1,6 @@
+//#region src/common/anyToString/formatters/formatWindowObject.ts
+function e(e) {
+	return `Window(${"location" in e && e.location && typeof e.location == "object" && "href" in e.location && typeof e.location.href == "string" ? e.location.href : ""})`;
+}
+//#endregion
+export { e as formatWindowObject };

package/common/anyToString/formatters/getConstructorName.d.ts

@@ -0,0 +1 @@
+export declare function getConstructorName(value: object): string | undefined;

package/common/anyToString/formatters/getConstructorName.js

@@ -0,0 +1,7 @@
+//#region src/common/anyToString/formatters/getConstructorName.ts
+function e(e) {
+	let t = e.constructor, n = typeof t?.name == "string" ? t.name : "";
+	if (!(!n || n === "Object")) return n;
+}
+//#endregion
+export { e as getConstructorName };

package/common/anyToString/formatters/joinBlock.d.ts

@@ -0,0 +1 @@
+export declare function joinBlock(open: string, close: string, items: string[], spaces: number, depth: number): string;

package/common/anyToString/formatters/joinBlock.js

@@ -0,0 +1,9 @@
+//#region src/common/anyToString/formatters/joinBlock.ts
+function e(e, t, n, r, i) {
+	if (n.length === 0) return `${e}${t}`;
+	if (r === 0) return `${e}${n.join(", ")}${t}`;
+	let a = " ".repeat(i * r), o = " ".repeat((i + 1) * r);
+	return `${e}\n${n.map((e) => `${o}${e}`).join(",\n")}\n${a}${t}`;
+}
+//#endregion
+export { e as joinBlock };

package/common/anyToString/formatters/withCircularGuard.d.ts

@@ -0,0 +1,2 @@
+import { FormatContext } from './formatValue.js';
+export declare function withCircularGuard<T extends object>(value: T, context: FormatContext, formatter: () => string): string;

package/common/anyToString/formatters/withCircularGuard.js

@@ -0,0 +1,11 @@
+//#region src/common/anyToString/formatters/withCircularGuard.ts
+function e(e, t, n) {
+	if (t.circularTracker.enter(e)) return "[Circular]";
+	try {
+		return n();
+	} finally {
+		t.circularTracker.leave(e);
+	}
+}
+//#endregion
+export { e as withCircularGuard };

package/common/anyToString/index.d.ts

@@ -0,0 +1 @@
+export * from './anyToString.js';

package/common/anyToString/index.js

@@ -0,0 +1,2 @@
+import { anyToString as e } from "./anyToString.js";
+export { e as anyToString };

package/common/assertsType.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Provides a compile-time assertion hook for narrowing a value to a target type.
+ *
+ * This function does nothing at runtime.
+ *
+ * @example
+ * ```ts
+ * const value: unknown = 'hello'
+ * assertsType<string>(value)
+ * ```
+ */
+export declare function assertsType<T>(value: unknown): asserts value is T;

package/common/assertsType.js

@@ -0,0 +1,4 @@
+//#region src/common/assertsType.ts
+function e(e) {}
+//#endregion
+export { e as assertsType };

package/common/buildSequence.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Builds an inclusive ascending integer sequence from `from` to `to`.
+ *
+ * Returns an empty array when `from` is greater than `to`.
+ */
+export declare function buildSequence(from: number, to: number): number[];

package/common/buildSequence.js

@@ -0,0 +1,8 @@
+//#region src/common/buildSequence.ts
+function e(e, t) {
+	let n = [];
+	for (let r = e; r <= t; r += 1) n.push(r);
+	return n;
+}
+//#endregion
+export { e as buildSequence };

package/common/deepClone.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Deeply clones arrays, objects, maps, sets, dates, regexes, array buffers,
+ * and typed arrays.
+ *
+ * Circular references are supported. `null` prototypes are preserved.
+ *
+ * @example
+ * ```ts
+ * const copy = deepClone({ a: [1, 2] })
+ * ```
+ */
+export declare function deepClone<T>(value: T): T;

package/common/deepClone.js

@@ -0,0 +1,55 @@
+import { getEnumerableOwnDescriptors as e } from "./getEnumerableOwnDescriptors.js";
+//#region src/common/deepClone.ts
+function t(e, t) {
+	if (e instanceof DataView) {
+		let r = n(e.buffer.slice(e.byteOffset, e.byteOffset + e.byteLength), t);
+		return new DataView(r, 0, e.byteLength);
+	}
+	let r = e.constructor;
+	return new r(e);
+}
+function n(r, i) {
+	if (typeof r != "object" || !r) return r;
+	let a = i.get(r);
+	if (a !== void 0) return a;
+	if (r instanceof Date) return new Date(r.getTime());
+	if (r instanceof RegExp) {
+		let e = new RegExp(r.source, r.flags);
+		return e.lastIndex = r.lastIndex, e;
+	}
+	if (r instanceof Map) {
+		let e = /* @__PURE__ */ new Map();
+		return i.set(r, e), r.forEach((t, r) => {
+			e.set(n(r, i), n(t, i));
+		}), e;
+	}
+	if (r instanceof Set) {
+		let e = /* @__PURE__ */ new Set();
+		return i.set(r, e), r.forEach((t) => {
+			e.add(n(t, i));
+		}), e;
+	}
+	if (r instanceof ArrayBuffer) return r.slice(0);
+	if (ArrayBuffer.isView(r)) return t(r, i);
+	if (Array.isArray(r)) {
+		let e = [];
+		return i.set(r, e), r.forEach((t, r) => {
+			e[r] = n(t, i);
+		}), e;
+	}
+	let o = Object.create(Object.getPrototypeOf(r));
+	i.set(r, o);
+	for (let [t, a] of e(r)) {
+		if ("value" in a) {
+			o[t] = n(a.value, i);
+			continue;
+		}
+		Object.defineProperty(o, t, a);
+	}
+	return o;
+}
+function r(e) {
+	return n(e, /* @__PURE__ */ new Map());
+}
+//#endregion
+export { r as deepClone };

package/common/deepEqual.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Compares two values deeply, including arrays, objects, maps, sets, dates,
+ * regexes, array buffers, and typed arrays.
+ *
+ * Circular references are supported.
+ *
+ * @example
+ * ```ts
+ * deepEqual({ a: [1, 2] }, { a: [1, 2] }) // true
+ * ```
+ */
+export declare function deepEqual(left: unknown, right: unknown): boolean;