freewind-ts-utils 0.18.2

package/common/index.d.ts

@@ -0,0 +1,49 @@
+export * from './anyToString/index.js';
+export * from './assertsType.js';
+export * from './buildSequence.js';
+export * from './tree/buildTree.js';
+export * from './deepClone.js';
+export * from './deepEqual.js';
+export * from './deepParseJsonStrings.js';
+export * from './dependsOn.js';
+export * from './doExpr.js';
+export * from './jsonRecord/filterJsonRecord.js';
+export * from './flatChildren.js';
+export * from './fuzzy/fuzzyMatch.js';
+export * from './fuzzy/fuzzyMatchPath.js';
+export * from './tree/flatTree.js';
+export * from './formatDecimal.js';
+export * from './formatFriendlyTime.js';
+export * from './formatSize.js';
+export * from './isEmptyRecord.js';
+export * from './isNil.js';
+export * from './isNonNil.js';
+export * from './jsonRecord/isJsonRecord.js';
+export * from './isRecord.js';
+export * from './simpleInt/isSimpleInt.js';
+export * from './simpleInt/isSimpleIntInputing.js';
+export * from './simpleInt/isSimpleNumber.js';
+export * from './simpleInt/isSimpleNumberInputing.js';
+export * from './jsonRecord/mapJsonRecord.js';
+export * from './tree/mapTree.js';
+export * from './jsonRecord/modifyJsonRecord.js';
+export * from './onlyUnique.js';
+export * from './simpleInt/parseSimpleInt.js';
+export * from './simpleInt/parseSimpleIntOrNil.js';
+export * from './simpleInt/parseSimpleNumber.js';
+export * from './simpleInt/parseSimpleNumberOrNil.js';
+export * from './pipe.js';
+export * from './pipeNonNil.js';
+export * from './jsonRecord/jsonRecordDiff.js';
+export * from './tree/pruneTree.js';
+export * from './tree/sortTree.js';
+export * from './SimpleType.js';
+export * from './tap.js';
+export * from './tree/treeToArray.js';
+export * from './tree/treeToRows.js';
+export * from './tree/treeTypes.js';
+export * from './truncateJsonStrings.js';
+export * from './truncateString.js';
+export * from './tryParsePartialJson.js';
+export * from './jsonRecord/walkJsonRecord.js';
+export * from './tree/walkTree.js';

package/common/index.js

@@ -0,0 +1,48 @@
+import { fuzzyMatchPath as e } from "./fuzzy/fuzzyMatchPath.js";
+import { fuzzyMatch as t } from "./fuzzy/fuzzyMatch.js";
+import { formatSize as n } from "./formatSize.js";
+import { truncateString as r } from "./truncateString.js";
+import { anyToString as i } from "./anyToString/anyToString.js";
+import { assertsType as a } from "./assertsType.js";
+import { buildSequence as o } from "./buildSequence.js";
+import { deepClone as s } from "./deepClone.js";
+import { deepEqual as c } from "./deepEqual.js";
+import { deepParseJsonStrings as l } from "./deepParseJsonStrings.js";
+import { dependsOn as u } from "./dependsOn.js";
+import { doExpr as d } from "./doExpr.js";
+import { flatChildren as f } from "./flatChildren.js";
+import { formatDecimal as p } from "./formatDecimal.js";
+import { formatFriendlyTime as m } from "./formatFriendlyTime.js";
+import { isNonNil as h } from "./isNonNil.js";
+import { buildTree as g } from "./tree/buildTree.js";
+import { isRecord as _ } from "./isRecord.js";
+import { isJsonRecord as v } from "./jsonRecord/isJsonRecord.js";
+import { filterJsonRecord as y } from "./jsonRecord/filterJsonRecord.js";
+import { flatTree as b } from "./tree/flatTree.js";
+import { isEmptyRecord as x } from "./isEmptyRecord.js";
+import { isNil as S } from "./isNil.js";
+import { isSimpleInt as C } from "./simpleInt/isSimpleInt.js";
+import { isSimpleIntInputing as w } from "./simpleInt/isSimpleIntInputing.js";
+import { isSimpleNumber as T } from "./simpleInt/isSimpleNumber.js";
+import { isSimpleNumberInputing as E } from "./simpleInt/isSimpleNumberInputing.js";
+import { mapJsonRecord as D } from "./jsonRecord/mapJsonRecord.js";
+import { mapTree as O } from "./tree/mapTree.js";
+import { modifyJsonRecord as k } from "./jsonRecord/modifyJsonRecord.js";
+import { onlyUnique as A } from "./onlyUnique.js";
+import { parseSimpleIntOrNil as j } from "./simpleInt/parseSimpleIntOrNil.js";
+import { parseSimpleInt as M } from "./simpleInt/parseSimpleInt.js";
+import { parseSimpleNumberOrNil as N } from "./simpleInt/parseSimpleNumberOrNil.js";
+import { parseSimpleNumber as P } from "./simpleInt/parseSimpleNumber.js";
+import { pipe as F } from "./pipe.js";
+import { pipeNonNil as I } from "./pipeNonNil.js";
+import { jsonRecordDiff as L } from "./jsonRecord/jsonRecordDiff.js";
+import { pruneTree as R } from "./tree/pruneTree.js";
+import { sortTree as z } from "./tree/sortTree.js";
+import { tap as B } from "./tap.js";
+import { treeToArray as V } from "./tree/treeToArray.js";
+import { treeToRows as H } from "./tree/treeToRows.js";
+import { truncateJsonStrings as U } from "./truncateJsonStrings.js";
+import { tryParsePartialJson as W } from "./tryParsePartialJson.js";
+import { walkJsonRecord as G } from "./jsonRecord/walkJsonRecord.js";
+import { walkTree as K } from "./tree/walkTree.js";
+export { i as anyToString, a as assertsType, o as buildSequence, g as buildTree, s as deepClone, c as deepEqual, l as deepParseJsonStrings, u as dependsOn, d as doExpr, y as filterJsonRecord, f as flatChildren, b as flatTree, p as formatDecimal, m as formatFriendlyTime, n as formatSize, t as fuzzyMatch, e as fuzzyMatchPath, x as isEmptyRecord, v as isJsonRecord, S as isNil, h as isNonNil, _ as isRecord, C as isSimpleInt, w as isSimpleIntInputing, T as isSimpleNumber, E as isSimpleNumberInputing, L as jsonRecordDiff, D as mapJsonRecord, O as mapTree, k as modifyJsonRecord, A as onlyUnique, M as parseSimpleInt, j as parseSimpleIntOrNil, P as parseSimpleNumber, N as parseSimpleNumberOrNil, F as pipe, I as pipeNonNil, R as pruneTree, z as sortTree, B as tap, V as treeToArray, H as treeToRows, U as truncateJsonStrings, r as truncateString, W as tryParsePartialJson, G as walkJsonRecord, K as walkTree };

package/common/isEmptyRecord.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Returns `true` when the value is `null`, `undefined`, or a record with no own keys.
+ *
+ * @example
+ * ```ts
+ * isEmptyRecord({}) // true
+ * isEmptyRecord({ a: 1 }) // false
+ * ```
+ */
+export declare function isEmptyRecord(value: unknown): boolean;

package/common/isEmptyRecord.js

@@ -0,0 +1,7 @@
+import { isRecord as e } from "./isRecord.js";
+//#region src/common/isEmptyRecord.ts
+function t(t) {
+	return t == null || e(t) && Object.keys(t).length === 0;
+}
+//#endregion
+export { t as isEmptyRecord };

package/common/isNil.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Returns `true` when the value is `null` or `undefined`.
+ *
+ * @example
+ * ```ts
+ * isNil(undefined) // true
+ * isNil(null) // true
+ * isNil('hello') // false
+ * ```
+ */
+export declare function isNil(arg: undefined): arg is undefined;
+export declare function isNil(arg: null): arg is null;
+export declare function isNil<T>(arg: T | undefined | null): arg is undefined | null;

package/common/isNil.js

@@ -0,0 +1,6 @@
+//#region src/common/isNil.ts
+function e(e) {
+	return e == null;
+}
+//#endregion
+export { e as isNil };

package/common/isNonNil.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Returns `true` when the value is neither `null` nor `undefined`.
+ *
+ * @example
+ * ```ts
+ * isNonNil(1) // true
+ * isNonNil(undefined) // false
+ * isNonNil(null) // false
+ * ```
+ */
+export declare function isNonNil<T>(arg: T | undefined | null): arg is T;

package/common/isNonNil.js

@@ -0,0 +1,6 @@
+//#region src/common/isNonNil.ts
+function e(e) {
+	return e != null;
+}
+//#endregion
+export { e as isNonNil };

package/common/isRecord.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Returns `true` when the value is a key-value record with `Object.prototype`
+ * or a `null` prototype.
+ *
+ * @example
+ * ```ts
+ * isRecord({ a: 1 }) // true
+ * isRecord(Object.create(null)) // true
+ * isRecord([]) // false
+ * ```
+ */
+export declare function isRecord(value: unknown): value is Record<string, unknown>;

package/common/isRecord.js

@@ -0,0 +1,8 @@
+//#region src/common/isRecord.ts
+function e(e) {
+	if (typeof e != "object" || !e || Array.isArray(e)) return !1;
+	let t = Object.getPrototypeOf(e);
+	return t === Object.prototype || t === null;
+}
+//#endregion
+export { e as isRecord };

package/common/jsonRecord/filterJsonRecord.d.ts

@@ -0,0 +1,16 @@
+export type FilterJsonRecordFn = (key: string, value: unknown) => boolean;
+/**
+ * Filters keys from a JSON-like record, with optional deep traversal into nested
+ * records and arrays.
+ *
+ * @example
+ * ```ts
+ * filterJsonRecord({ a: 1, b: 'x' }, (key, value) => typeof value === 'number')
+ * ```
+ */
+export declare function filterJsonRecord<T extends Record<string, unknown>>(obj: T, filterFn: FilterJsonRecordFn, options?: {
+    deep?: boolean;
+}): T;
+export declare function filterJsonRecord<T>(obj: T, filterFn: FilterJsonRecordFn, options?: {
+    deep?: boolean;
+}): T | undefined;

package/common/jsonRecord/filterJsonRecord.js

@@ -0,0 +1,19 @@
+import { isNonNil as e } from "../isNonNil.js";
+import { isJsonRecord as t } from "./isJsonRecord.js";
+//#region src/common/jsonRecord/filterJsonRecord.ts
+function n(e) {
+	return t(e) && Object.keys(e).length === 0;
+}
+function r(i, a, o = {}) {
+	let { deep: s } = o;
+	if (s && Array.isArray(i)) return i.map((e) => r(e, a, o)).filter((t) => e(t) && !n(t));
+	if (t(i)) {
+		let t = Object.entries(i).map(([e, t]) => {
+			let n = s ? r(t, a, o) : void 0;
+			return n ? [e, n] : a(e, t) ? [e, t] : void 0;
+		}).filter((t) => e(t));
+		return Object.fromEntries(t);
+	}
+}
+//#endregion
+export { r as filterJsonRecord };

package/common/jsonRecord/isJsonRecord.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Returns `true` when the value is a JSON-like record tree:
+ * - top-level value is a record with `Object.prototype` or a `null` prototype
+ * - nested values contain only JSON-compatible primitives, arrays, and records
+ * - nested objects and arrays are unique and acyclic
+ *
+ * This is the structural entry check used by json-record helpers that assume
+ * a tree-shaped JSON object instead of shared references or circular graphs.
+ *
+ * @example
+ * ```ts
+ * isJsonRecord({ a: 1, items: [true, null] }) // true
+ * isJsonRecord([]) // false
+ * ```
+ */
+export declare function isJsonRecord(value: unknown): value is Record<string, unknown>;

package/common/jsonRecord/isJsonRecord.js

@@ -0,0 +1,16 @@
+import { isRecord as e } from "../isRecord.js";
+//#region src/common/jsonRecord/isJsonRecord.ts
+function t(e) {
+	return typeof e == "number" && Number.isFinite(e);
+}
+function n(e) {
+	return e === null || typeof e == "boolean" || typeof e == "string" || t(e);
+}
+function r(t, i) {
+	return n(t) ? !0 : typeof t != "object" || t === void 0 || i.has(t) ? !1 : (i.add(t), Array.isArray(t) ? t.every((e) => r(e, i)) : e(t) ? Object.values(t).every((e) => r(e, i)) : !1);
+}
+function i(t) {
+	return e(t) && r(t, /* @__PURE__ */ new WeakSet());
+}
+//#endregion
+export { i as isJsonRecord };

package/common/jsonRecord/jsonRecordDiff.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Diffs two JSON-like records and keeps only the current shape while marking unchanged,
+ * removed, and array-prefix portions in a compact readable form.
+ *
+ * @example
+ * ```ts
+ * jsonRecordDiff(
+ *   { name: 'next', items: [1, 2, 4] },
+ *   { name: 'prev', items: [1, 2, 3] },
+ * )
+ * ```
+ */
+export declare function jsonRecordDiff(current: Record<string, unknown>, previous: Record<string, unknown>): Record<string, unknown>;

package/common/jsonRecord/jsonRecordDiff.js

@@ -0,0 +1,26 @@
+import { deepEqual as e } from "../deepEqual.js";
+import { isJsonRecord as t } from "./isJsonRecord.js";
+//#region src/common/jsonRecord/jsonRecordDiff.ts
+var n = "...", r = "... removed";
+function i(e) {
+	return `... removed ${e} items`;
+}
+function a(t, n) {
+	let r = 0;
+	for (; r < t.length && r < n.length && e(t[r], n[r]);) r += 1;
+	let a = [];
+	r > 0 && a.push(`... common ${r} items`);
+	let o = n.slice(r);
+	return o.length > 0 && a.push({ [i(o.length)]: o }), a.push(...t.slice(r)), a;
+}
+function o(r, i) {
+	return e(r, i) ? n : Array.isArray(r) && Array.isArray(i) ? a(r, i) : t(r) && t(i) ? s(r, i) : r;
+}
+function s(e, t) {
+	let n = [], i = /* @__PURE__ */ new Set();
+	for (let [r, a] of Object.entries(e)) i.add(r), n.push([r, r in t ? o(a, t[r]) : a]);
+	for (let e of Object.keys(t)) i.has(e) || n.push([e, r]);
+	return Object.fromEntries(n);
+}
+//#endregion
+export { s as jsonRecordDiff };

package/common/jsonRecord/mapJsonRecord.d.ts

@@ -0,0 +1,13 @@
+export type MapJsonRecordFn = (key: string, value: unknown) => [string, unknown] | undefined;
+/**
+ * Maps keys and values in a JSON-like record, with optional deep traversal into
+ * nested records and arrays.
+ *
+ * @example
+ * ```ts
+ * mapJsonRecord({ a: 1 }, (key, value) => [`${key}!`, value])
+ * ```
+ */
+export declare function mapJsonRecord<T, U = T>(obj: T, mapFn: MapJsonRecordFn, options?: {
+    deep?: boolean;
+}): U;

package/common/jsonRecord/mapJsonRecord.js

@@ -0,0 +1,14 @@
+import { isNonNil as e } from "../isNonNil.js";
+import { isJsonRecord as t } from "./isJsonRecord.js";
+//#region src/common/jsonRecord/mapJsonRecord.ts
+function n(r, i, a = {}) {
+	let { deep: o } = a;
+	if (o && Array.isArray(r)) return r.map((e) => n(e, i, a));
+	if (t(r)) {
+		let t = Object.entries(r).map(([e, t]) => i(e, o ? n(t, i, a) : t)).filter((t) => e(t));
+		return Object.fromEntries(t);
+	}
+	return r;
+}
+//#endregion
+export { n as mapJsonRecord };

package/common/jsonRecord/modifyJsonRecord.d.ts

@@ -0,0 +1,14 @@
+export type ModifyJsonRecordFn = (key: string, value: unknown) => [string, unknown] | undefined;
+/**
+ * Mutates a JSON-like record in place, with optional deep traversal into nested
+ * records and arrays.
+ *
+ * @example
+ * ```ts
+ * const data = { a: 1 }
+ * modifyJsonRecord(data, (key, value) => [key, Number(value) + 1])
+ * ```
+ */
+export declare function modifyJsonRecord(obj: unknown, modifyFn: ModifyJsonRecordFn, options?: {
+    deep?: boolean;
+}): void;

package/common/jsonRecord/modifyJsonRecord.js

@@ -0,0 +1,24 @@
+import { isJsonRecord as e } from "./isJsonRecord.js";
+//#region src/common/jsonRecord/modifyJsonRecord.ts
+function t(n, r, i = {}) {
+	let { deep: a } = i;
+	if (a && Array.isArray(n)) {
+		n.forEach((e) => {
+			t(e, r, i);
+		});
+		return;
+	}
+	if (e(n)) for (let e of Object.keys(n)) {
+		let o = n[e];
+		a && t(o, r, i);
+		let s = r(e, o);
+		if (s === void 0) {
+			delete n[e];
+			continue;
+		}
+		let [c, l] = s;
+		delete n[e], n[c] = l;
+	}
+}
+//#endregion
+export { t as modifyJsonRecord };

package/common/jsonRecord/walkJsonRecord.d.ts

@@ -0,0 +1,15 @@
+export type WalkJsonRecordFn = (key: string | number, value: unknown) => void;
+/**
+ * Walks through keys in a JSON-like record, with optional deep traversal into nested
+ * records and arrays.
+ *
+ * @example
+ * ```ts
+ * walkJsonRecord({ a: 1 }, (key, value) => {
+ *   console.log(key, value)
+ * })
+ * ```
+ */
+export declare function walkJsonRecord<T>(obj: T, walkFn: WalkJsonRecordFn, options?: {
+    deep?: boolean;
+}): void;

package/common/jsonRecord/walkJsonRecord.js

@@ -0,0 +1,16 @@
+import { isJsonRecord as e } from "./isJsonRecord.js";
+//#region src/common/jsonRecord/walkJsonRecord.ts
+function t(n, r, i = {}) {
+	let { deep: a } = i;
+	if (a && Array.isArray(n)) {
+		n.forEach((e, n) => {
+			r(n, e), t(e, r, i);
+		});
+		return;
+	}
+	e(n) && Object.entries(n).forEach(([e, n]) => {
+		r(e, n), a && t(n, r, i);
+	});
+}
+//#endregion
+export { t as walkJsonRecord };

package/common/onlyUnique.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Predicate for `Array.prototype.filter` that keeps only the first occurrence.
+ *
+ * @example
+ * ```ts
+ * const values = [1, 1, 2, 3, 2]
+ * const uniqueValues = values.filter(onlyUnique)
+ * ```
+ */
+export declare function onlyUnique<T>(item: T, index: number, items: T[]): boolean;

package/common/onlyUnique.js

@@ -0,0 +1,6 @@
+//#region src/common/onlyUnique.ts
+function e(e, t, n) {
+	return n.indexOf(e) === t;
+}
+//#endregion
+export { e as onlyUnique };

package/common/pipe.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Passes a value into a function and returns the function result.
+ *
+ * @example
+ * ```ts
+ * const size = pipe('hello', (text) => text.length)
+ * ```
+ */
+export declare function pipe<T, K>(data: T, fn: (t: T) => K): K;

package/common/pipe.js

@@ -0,0 +1,6 @@
+//#region src/common/pipe.ts
+function e(e, t) {
+	return t(e);
+}
+//#endregion
+export { e as pipe };

package/common/pipeNonNil.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Passes a value into a function only when the value is not `null` or `undefined`.
+ *
+ * When the input is nil, it is returned as-is.
+ *
+ * @example
+ * ```ts
+ * pipeNonNil('hello', (text) => text.length) // 5
+ * pipeNonNil(undefined, (text) => text.length) // undefined
+ * pipeNonNil(null, (text) => text.length) // null
+ * ```
+ */
+export declare function pipeNonNil<T, K>(data: T, fn: (it: T) => K): K;
+export declare function pipeNonNil<T, K>(data: T | undefined, fn: (it: T) => K): K | undefined;
+export declare function pipeNonNil<T, K>(data: T | null, fn: (it: T) => K): K | null;
+export declare function pipeNonNil<T, K>(data: T | undefined | null, fn: (it: T) => K): K | undefined | null;

package/common/pipeNonNil.js

@@ -0,0 +1,7 @@
+import { isNonNil as e } from "./isNonNil.js";
+//#region src/common/pipeNonNil.ts
+function t(t, n) {
+	return e(t) ? n(t) : t;
+}
+//#endregion
+export { t as pipeNonNil };

package/common/safeJsonStringify.d.ts

@@ -0,0 +1,28 @@
+export interface SafeJsonStringifyOptions {
+    spaces?: number;
+}
+export interface SafeJsonCircularRef {
+    $ref: string;
+    $type: "circular";
+}
+/**
+ * Safely stringifies any value to JSON.
+ *
+ * The first occurrence of an object is serialized normally. Later references to the
+ * same object are replaced with a circular marker object so the output stays valid JSON.
+ *
+ * @example
+ * ```ts
+ * const shared = { id: 1 }
+ *
+ * safeJsonStringify({
+ *   first: shared,
+ *   second: shared,
+ * })
+ * // {
+ * //   "first": { "id": 1 },
+ * //   "second": { "$type": "circular", "$ref": "$.first" }
+ * // }
+ * ```
+ */
+export declare function safeJsonStringify(value: unknown, options?: SafeJsonStringifyOptions): string;

package/common/safeJsonStringify.js

@@ -0,0 +1,105 @@
+import { createObjectReferenceTracker as e } from "./_internal/createObjectReferenceTracker.js";
+import { getEnumerableOwnDescriptors as t } from "./getEnumerableOwnDescriptors.js";
+import { anyToString as n } from "./anyToString/anyToString.js";
+import { isJsonRecord as r } from "./jsonRecord/isJsonRecord.js";
+//#region src/common/safeJsonStringify.ts
+function i(t, n = {}) {
+	return JSON.stringify(o(t, "$", { referenceTracker: e() }), null, a(n.spaces));
+}
+function a(e) {
+	return typeof e != "number" || !Number.isFinite(e) ? 0 : Math.max(0, Math.floor(e));
+}
+function o(e, t, n) {
+	if (e === null) return null;
+	if (e === void 0) return "[undefined]";
+	switch (typeof e) {
+		case "string": return e;
+		case "boolean": return e;
+		case "number": return Number.isFinite(e) ? e : String(e);
+		case "bigint": return `${e}n`;
+		case "symbol": return String(e);
+		case "function": return `[Function ${e.name || "anonymous"}]`;
+		case "object": return s(e, t, n);
+		default: return String(e);
+	}
+}
+function s(e, t, r) {
+	let i = r.referenceTracker.remember(e, t);
+	return i ? {
+		$ref: i,
+		$type: "circular"
+	} : e instanceof Date ? Number.isNaN(e.getTime()) ? "Invalid Date" : e.toISOString() : e instanceof RegExp ? String(e) : e instanceof Error ? c(e, t, r) : typeof URL < "u" && e instanceof URL ? e.href : p(e) ? "[Promise]" : m(e) ? n(e) : Array.isArray(e) ? e.map((e, n) => o(e, `${t}[${n}]`, r)) : e instanceof Map ? {
+		$type: "Map",
+		entries: Array.from(e.entries()).map(([e, n], i) => [o(e, `${t}.entries[${i}][0]`, r), o(n, `${t}.entries[${i}][1]`, r)])
+	} : e instanceof Set ? {
+		$type: "Set",
+		values: Array.from(e.values()).map((e, n) => o(e, `${t}.values[${n}]`, r))
+	} : ArrayBuffer.isView(e) ? l(e, t, r) : e instanceof ArrayBuffer ? {
+		$type: "ArrayBuffer",
+		byteLength: e.byteLength
+	} : u(e, t, r);
+}
+function c(e, t, n) {
+	let r = {
+		$type: e.name || "Error",
+		message: e.message
+	};
+	e.stack && (r.stack = e.stack.split("\n")[0] || e.stack), "cause" in e && e.cause !== void 0 && (r.cause = o(e.cause, `${t}.cause`, n));
+	for (let i of Object.keys(e)) i in r || (r[i] = o(e[i], d(t, i), n));
+	return r;
+}
+function l(e, t, n) {
+	return e instanceof DataView ? {
+		$type: "DataView",
+		byteLength: e.byteLength
+	} : {
+		$type: e.constructor.name || "TypedArray",
+		values: Array.from(e).map((e, r) => o(e, `${t}.values[${r}]`, n))
+	};
+}
+function u(e, n, i) {
+	let a = {}, s = e.constructor?.name;
+	s && s !== "Object" && !r(e) && (a.$type = s);
+	for (let [r, s] of t(e)) {
+		let e = f(r);
+		if ("value" in s) {
+			a[e] = o(s.value, d(n, e), i);
+			continue;
+		}
+		if (s.get && s.set) {
+			a[e] = "[Getter/Setter]";
+			continue;
+		}
+		if (s.get) {
+			a[e] = "[Getter]";
+			continue;
+		}
+		a[e] = "[Setter]";
+	}
+	return a;
+}
+function d(e, t) {
+	return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(t) ? `${e}.${t}` : `${e}[${JSON.stringify(t)}]`;
+}
+function f(e) {
+	return typeof e == "symbol" ? `[${String(e)}]` : String(e);
+}
+function p(e) {
+	return "then" in e && typeof e.then == "function";
+}
+function m(e) {
+	return h(e) || g(e) || _(e);
+}
+function h(e) {
+	let t = Object.prototype.toString.call(e);
+	return t === "[object Window]" || t === "[object global]" && "window" in e && e.window === e && "document" in e;
+}
+function g(e) {
+	let t = Object.prototype.toString.call(e);
+	return t === "[object Document]" || t === "[object HTMLDocument]" || "nodeType" in e && e.nodeType === 9;
+}
+function _(e) {
+	return "nodeType" in e && e.nodeType === 1 && "tagName" in e;
+}
+//#endregion
+export { i as safeJsonStringify };

package/common/simpleInt/isSimpleInt.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Returns `true` when the string is a simple integer: `0` or a signed non-zero integer without leading zeros.
+ *
+ * This intentionally rejects `+1`, `01`, `-0`, and scientific notation.
+ */
+export declare function isSimpleInt(str: string | null | undefined): boolean;

package/common/simpleInt/isSimpleInt.js

@@ -0,0 +1,6 @@
+//#region src/common/simpleInt/isSimpleInt.ts
+function e(e) {
+	return e == null ? !1 : e === "0" || /^-?[1-9]\d*$/.test(e);
+}
+//#endregion
+export { e as isSimpleInt };

package/common/simpleInt/isSimpleIntInputing.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Returns `true` when the string is a still-editing integer input.
+ *
+ * Accepts partial states such as `''` or `'-'`.
+ */
+export declare function isSimpleIntInputing(str: string): boolean;

package/common/simpleInt/isSimpleIntInputing.js

@@ -0,0 +1,7 @@
+import { isSimpleInt as e } from "./isSimpleInt.js";
+//#region src/common/simpleInt/isSimpleIntInputing.ts
+function t(t) {
+	return e(`${t}1`);
+}
+//#endregion
+export { t as isSimpleIntInputing };

package/common/simpleInt/isSimpleNumber.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Returns `true` when the string is a plain decimal number without exponent notation.
+ *
+ * @example
+ * ```ts
+ * isSimpleNumber('12.3') // true
+ * isSimpleNumber('1e2') // false
+ * ```
+ */
+export declare function isSimpleNumber(str: string): boolean;

package/common/simpleInt/isSimpleNumber.js

@@ -0,0 +1,6 @@
+//#region src/common/simpleInt/isSimpleNumber.ts
+function e(e) {
+	return /^[+-]?\d+(\.\d+)?$/.test(e);
+}
+//#endregion
+export { e as isSimpleNumber };