@sprawlify/primitives 0.0.1

package/dist/json-tree-utils.cjs

@@ -0,0 +1,1512 @@
+
+//#region src/shared/json-tree-utils/json-to-tree.ts
+const MAX_DEPTH = 20;
+const jsonToTree = (data, props = {}) => {
+	const { visited = /* @__PURE__ */ new WeakSet(), keyPath = [ROOT_KEY], depth = 0 } = props;
+	const options = getPreviewOptions(props.options);
+	if (depth > MAX_DEPTH) return {
+		value: "[Max Depth Reached]",
+		type: "string",
+		keyPath
+	};
+	if (data && typeof data === "object") {
+		if (visited.has(data)) return {
+			value: "[Circular Reference]",
+			type: "circular",
+			keyPath
+		};
+		visited.add(data);
+	}
+	return (dataTypes.find((dataType$1) => dataType$1.check(data)) || PrimitiveType).node({
+		value: data,
+		createNode: (nestedKeyPath, value) => jsonToTree(value, {
+			visited,
+			keyPath: [...keyPath, ...nestedKeyPath],
+			options,
+			depth: depth + 1
+		}),
+		keyPath,
+		options
+	});
+};
+
+//#endregion
+//#region src/shared/json-tree-utils/shared.ts
+const regexReturnCharacters = /\r/g;
+function hash(str) {
+	const v = str.replace(regexReturnCharacters, "");
+	let hash$1 = 5381;
+	let i = v.length;
+	while (i--) hash$1 = (hash$1 << 5) - hash$1 ^ v.charCodeAt(i);
+	return (hash$1 >>> 0).toString(36);
+}
+function getProp(value, key) {
+	return value[key];
+}
+function defu(a, b) {
+	const res = { ...a };
+	for (const key in b) if (b[key] !== void 0) res[key] = b[key];
+	return res;
+}
+const isObj = (v) => v != null && typeof v === "object" && !Array.isArray(v);
+const typeOf = (value) => Object.prototype.toString.call(value);
+
+//#endregion
+//#region src/shared/json-tree-utils/node-conversion.ts
+const ROOT_KEY = "$";
+const PATH_SEP = ".";
+function isRootKeyPath(keyPath) {
+	return keyPath.length === 1 && keyPath[0] === ROOT_KEY;
+}
+function keyPathToId(keyPath) {
+	return keyPath.join(PATH_SEP);
+}
+function keyPathToKey(keyPath, opts) {
+	if (keyPath.length === 0) return "";
+	if (opts?.excludeRoot && isRootKeyPath(keyPath)) return "";
+	return String(keyPath[keyPath.length - 1]);
+}
+function nodeToValue(node) {
+	return hash(keyPathToId(node.keyPath));
+}
+function jsonPathToValue(path) {
+	return hash(path);
+}
+function nodeToString(node) {
+	return keyPathToKey(node.keyPath) || "root";
+}
+function getRootNode(data, opts) {
+	return {
+		value: "",
+		type: "object",
+		keyPath: [],
+		children: [jsonToTree(data, {
+			visited: /* @__PURE__ */ new WeakSet(),
+			keyPath: [ROOT_KEY],
+			options: getPreviewOptions(opts)
+		})]
+	};
+}
+const DEFAULT_PREVIEW_OPTIONS = {
+	maxPreviewItems: 3,
+	collapseStringsAfterLength: 30,
+	groupArraysAfterLength: 100,
+	showNonenumerable: true
+};
+const getPreviewOptions = (opts) => {
+	if (!opts) return DEFAULT_PREVIEW_OPTIONS;
+	return defu(DEFAULT_PREVIEW_OPTIONS, opts);
+};
+
+//#endregion
+//#region src/shared/json-tree-utils/data-type.ts
+const generatePreviewText = (items, hasMore) => {
+	return ` ${items.join(", ")}${hasMore ? ", … " : " "}`;
+};
+const ENTRIES_KEY = "[[Entries]]";
+const txt = (value) => ({
+	type: "text",
+	value
+});
+const jsx = (tagName, properties = {}, children = []) => ({
+	type: "element",
+	tagName,
+	properties,
+	children
+});
+const formatValueMini = (child) => {
+	if (child.type === "string") return `"${child.value}"`;
+	if (child.type === "null") return "null";
+	if (child.type === "undefined" || child.type === "symbol") return "undefined";
+	if (child.type === "object") return "{…}";
+	if (child.type === "array") return "[…]";
+	if (child.type === "set") return "Set(…)";
+	if (child.type === "map") return "Map(…)";
+	if (child.type === "iterable") return "Iterable(…)";
+	if (child.type === "function") return "ƒ(…)";
+	return String(child.value);
+};
+const formatValue = (value) => {
+	if (value === null) return "null";
+	if (value === void 0) return "undefined";
+	if (typeof value === "string") return `"${value}"`;
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+	if (value instanceof Date) return value.toISOString();
+	if (value instanceof Set) return `Set(${value.size})`;
+	if (value instanceof Map) return `Map(${value.size})`;
+	if (Array.isArray(value)) return `Array(${value.length})`;
+	if (typeof value === "object") return "Object";
+	return String(value);
+};
+function dataType(opts) {
+	return opts;
+}
+const NullType = dataType({
+	type: "null",
+	description: "null",
+	check(value) {
+		return value === null;
+	},
+	previewElement() {
+		return jsx("span", {}, [txt("null")]);
+	},
+	node({ value, keyPath }) {
+		return {
+			value,
+			type: "null",
+			keyPath
+		};
+	}
+});
+const UndefinedType = dataType({
+	type: "undefined",
+	description: "undefined",
+	check(value) {
+		return value === void 0;
+	},
+	previewElement() {
+		return jsx("span", {}, [txt("undefined")]);
+	},
+	node({ value, keyPath }) {
+		return {
+			type: "undefined",
+			value,
+			keyPath
+		};
+	}
+});
+const SymbolType = dataType({
+	type: "symbol",
+	description(node) {
+		return String(node.value);
+	},
+	check(value) {
+		return typeof value === "symbol";
+	},
+	previewElement(node) {
+		return jsx("span", {}, [txt(node.value.toString())]);
+	},
+	node({ value, keyPath }) {
+		return {
+			type: "symbol",
+			value,
+			keyPath
+		};
+	}
+});
+const BigIntType = dataType({
+	type: "bigint",
+	description(node) {
+		return `${node.value}n`;
+	},
+	check(value) {
+		return typeof value === "bigint";
+	},
+	previewElement(node) {
+		return jsx("span", {}, [txt(`${node.value}n`)]);
+	},
+	node({ value, keyPath }) {
+		return {
+			type: "bigint",
+			value,
+			keyPath
+		};
+	}
+});
+const SetType = dataType({
+	type: "set",
+	description(node) {
+		return `Set(${node.value.size})`;
+	},
+	check(value) {
+		return value instanceof Set;
+	},
+	previewText(node, opts) {
+		const maxItems = opts.maxPreviewItems;
+		const entries = Array.from(node.value);
+		return generatePreviewText(entries.slice(0, maxItems).map(formatValue), entries.length > maxItems);
+	},
+	previewElement(node, opts) {
+		const preview = this.previewText?.(node, opts) ?? "";
+		const size = node.value.size;
+		const children = [jsx("span", { kind: "constructor" }, [txt(`Set(${size})`)]), jsx("span", { kind: "brace" }, [txt(" {")])];
+		if (preview) children.push(jsx("span", { kind: "preview-text" }, [txt(preview)]));
+		children.push(jsx("span", { kind: "brace" }, [txt("}")]));
+		return jsx("span", {}, children);
+	},
+	node({ value, keyPath, createNode }) {
+		const entriesChildren = Array.from(value).map((item, index) => createNode([ENTRIES_KEY, index.toString()], item));
+		return {
+			type: "set",
+			value,
+			keyPath,
+			children: [{
+				value: Array.from(value),
+				keyPath: [...keyPath, ENTRIES_KEY],
+				type: "array",
+				children: entriesChildren,
+				isNonEnumerable: true
+			}, createNode(["size"], value.size)]
+		};
+	}
+});
+const WeakSetType = dataType({
+	type: "weakset",
+	description: "WeakSet",
+	check(value) {
+		return value instanceof WeakSet;
+	},
+	previewElement() {
+		return jsx("span", {}, [
+			jsx("span", { kind: "constructor" }, [txt("WeakSet")]),
+			jsx("span", { kind: "brace" }, [txt(" {")]),
+			jsx("span", { kind: "preview" }, [txt(" [[Entries]]: not enumerable ")]),
+			jsx("span", { kind: "brace" }, [txt("}")])
+		]);
+	},
+	node({ value, keyPath }) {
+		return {
+			type: "weakset",
+			value,
+			keyPath
+		};
+	}
+});
+const WeakMapType = dataType({
+	type: "weakmap",
+	description: "WeakMap",
+	check(value) {
+		return value instanceof WeakMap;
+	},
+	previewElement() {
+		return jsx("span", {}, [
+			jsx("span", { kind: "constructor" }, [txt("WeakMap")]),
+			jsx("span", { kind: "brace" }, [txt(" {")]),
+			jsx("span", { kind: "preview" }, [txt(" [[Entries]]: not enumerable ")]),
+			jsx("span", { kind: "brace" }, [txt("}")])
+		]);
+	},
+	node({ value, keyPath }) {
+		return {
+			type: "weakmap",
+			value,
+			keyPath
+		};
+	}
+});
+const REGEX_KEYS = [
+	"lastIndex",
+	"dotAll",
+	"flags",
+	"global",
+	"hasIndices",
+	"ignoreCase",
+	"multiline",
+	"source",
+	"sticky",
+	"unicode"
+];
+const RegexType = dataType({
+	type: "regex",
+	description(node) {
+		return String(node.value);
+	},
+	check(value) {
+		return value instanceof RegExp;
+	},
+	previewElement(node) {
+		return jsx("span", {}, [txt(String(node.value))]);
+	},
+	node({ value, keyPath, createNode }) {
+		return {
+			value,
+			type: "regex",
+			keyPath,
+			children: REGEX_KEYS.map((key) => createNode([key], getProp(value, key)))
+		};
+	}
+});
+const DATA_VIEW_KEYS = [
+	"byteLength",
+	"byteOffset",
+	"buffer"
+];
+const DataViewType = dataType({
+	type: "dataview",
+	description(node) {
+		return `DataView(${node.value.byteLength})`;
+	},
+	check(value) {
+		return value instanceof DataView;
+	},
+	previewElement(node) {
+		const dataView = node.value;
+		return jsx("span", {}, [
+			jsx("span", { kind: "constructor" }, [txt(`DataView(${dataView.byteLength})`)]),
+			jsx("span", { kind: "brace" }, [txt(" { ")]),
+			jsx("span", { kind: "preview" }, [txt(` buffer: ArrayBuffer(${dataView.buffer.byteLength}), byteOffset: ${dataView.byteOffset} `)]),
+			jsx("span", { kind: "brace" }, [txt(" }")])
+		]);
+	},
+	node({ value, keyPath, createNode }) {
+		return {
+			value,
+			keyPath,
+			type: "dataview",
+			children: DATA_VIEW_KEYS.map((key) => createNode([key], getProp(value, key)))
+		};
+	}
+});
+const URL_KEYS = [
+	"href",
+	"origin",
+	"protocol",
+	"username",
+	"password",
+	"host",
+	"hostname",
+	"port",
+	"pathname",
+	"search",
+	"searchParams",
+	"hash"
+];
+const UrlType = dataType({
+	type: "url",
+	description: "URL",
+	check(value) {
+		return typeOf(value) === "[object URL]";
+	},
+	previewElement(node, opts) {
+		const url = node.value;
+		const maxItems = opts.maxPreviewItems;
+		const preview = URL_KEYS.slice(0, maxItems).map((key) => `${key}: '${url[key]}'`).join(", ");
+		const hasMore = URL_KEYS.length > maxItems;
+		return jsx("span", {}, [
+			jsx("span", { kind: "constructor" }, [txt("URL")]),
+			jsx("span", { kind: "brace" }, [txt(" { ")]),
+			jsx("span", { kind: "preview-text" }, [txt(` ${preview}${hasMore ? ", …" : ""} `)]),
+			jsx("span", { kind: "brace" }, [txt(" }")])
+		]);
+	},
+	node({ value, keyPath, createNode }) {
+		return {
+			value,
+			keyPath,
+			type: "url",
+			children: URL_KEYS.map((key) => createNode([key], Reflect.get(value, key)))
+		};
+	}
+});
+const URLSearchParamsType = dataType({
+	type: "urlsearchparams",
+	description: "URLSearchParams",
+	check(value) {
+		return typeOf(value) === "[object URLSearchParams]";
+	},
+	previewElement(node) {
+		const params = node.value;
+		const paramsArray = Array.from(params.entries());
+		return jsx("span", {}, [
+			jsx("span", { kind: "constructor" }, [txt("URLSearchParams")]),
+			jsx("span", { kind: "brace" }, [txt(" { ")]),
+			jsx("span", { kind: "preview" }, [txt(`size: ${paramsArray.length}`)]),
+			jsx("span", { kind: "brace" }, [txt(" }")])
+		]);
+	},
+	node({ value, keyPath, createNode }) {
+		const entriesChildren = Array.from(value.entries()).map(([key, value$1], index) => {
+			const keyStr = String(key);
+			const keyNode = createNode([
+				ENTRIES_KEY,
+				keyStr,
+				"key"
+			], key);
+			const valueNode = createNode([
+				ENTRIES_KEY,
+				keyStr,
+				"value"
+			], value$1);
+			return {
+				keyPath: [
+					...keyPath,
+					ENTRIES_KEY,
+					index
+				],
+				value: { [key]: value$1 },
+				type: "object",
+				children: [keyNode, valueNode]
+			};
+		});
+		return {
+			value,
+			keyPath,
+			type: "urlsearchparams",
+			children: [{
+				keyPath: [...keyPath, "[[Entries]]"],
+				value: Array.from(value.entries()),
+				type: "array",
+				children: entriesChildren,
+				isNonEnumerable: true
+			}, createNode(["size"], Array.from(value.entries()).length)]
+		};
+	}
+});
+const BLOB_KEYS = ["size", "type"];
+const BlobType = dataType({
+	type: "blob",
+	description(node) {
+		return `Blob(${node.value.size})`;
+	},
+	check(value) {
+		return typeOf(value) === "[object Blob]";
+	},
+	previewElement(node) {
+		const blob = node.value;
+		return jsx("span", {}, [
+			jsx("span", { kind: "constructor" }, [txt("Blob")]),
+			jsx("span", { kind: "brace" }, [txt(" { ")]),
+			jsx("span", { kind: "preview" }, [txt(`size: ${blob.size}, type: '${blob.type || "application/octet-stream"}'`)]),
+			jsx("span", { kind: "brace" }, [txt(" }")])
+		]);
+	},
+	node({ value, keyPath, createNode }) {
+		return {
+			value,
+			keyPath,
+			type: "blob",
+			children: BLOB_KEYS.map((key) => ({
+				key,
+				value: Reflect.get(value, key)
+			})).map(({ key, value: value$1 }) => createNode([key], value$1))
+		};
+	}
+});
+const FILE_KEYS = [
+	"name",
+	"size",
+	"type",
+	"lastModified",
+	"webkitRelativePath"
+];
+const FileType = dataType({
+	type: "file",
+	description(node) {
+		return `File(${node.value.size})`;
+	},
+	check(value) {
+		return typeOf(value) === "[object File]";
+	},
+	previewElement(node) {
+		const file = node.value;
+		const hasMore = FILE_KEYS.length > 2;
+		return jsx("span", {}, [
+			jsx("span", { kind: "constructor" }, [txt("File")]),
+			jsx("span", { kind: "brace" }, [txt(" { ")]),
+			jsx("span", { kind: "preview" }, [txt(`name: '${file.name}', lastModified: ${file.lastModified}${hasMore ? ", …" : ""}`)]),
+			jsx("span", { kind: "brace" }, [txt(" }")])
+		]);
+	},
+	node({ value, keyPath, createNode }) {
+		return {
+			value,
+			keyPath,
+			type: "file",
+			children: FILE_KEYS.map((key) => ({
+				key,
+				value: getProp(value, key) || ""
+			})).map(({ key, value: value$1 }) => createNode([key], value$1))
+		};
+	}
+});
+const getFunctionString = (func) => {
+	try {
+		return func.toString();
+	} catch {
+		switch (func.constructor.name) {
+			case "AsyncFunction": return "async function () {}";
+			case "AsyncGeneratorFunction": return "async function * () {}";
+			case "GeneratorFunction": return "function * () {}";
+			default: return "function () {}";
+		}
+	}
+};
+const FUNCTION_SIGNATURE_REGEX = /(?:async\s+)?(?:function\s*\*?\s*)?([^(]*\([^)]*\))/;
+const getFunctionSignature = (func) => {
+	const signatureMatch = getFunctionString(func).match(FUNCTION_SIGNATURE_REGEX);
+	return signatureMatch ? signatureMatch[1] : `${func.name || "anonymous"}()`;
+};
+const FUNC_KEYS = [
+	"name",
+	"length",
+	"prototype",
+	"caller",
+	"arguments"
+];
+const FunctionType = dataType({
+	type: "function",
+	description(node) {
+		const func = node.value;
+		const name = func.name || "anonymous";
+		switch (func.constructor.name) {
+			case "AsyncFunction": return `async ƒ ${name}()`;
+			case "AsyncGeneratorFunction": return `async ƒ* ${name}()`;
+			case "GeneratorFunction": return `ƒ* ${name}()`;
+			default: return `ƒ ${name}()`;
+		}
+	},
+	check(value) {
+		return typeof value === "function";
+	},
+	previewElement(node) {
+		const func = node.value;
+		const signature = getFunctionSignature(func);
+		const constructorName = func.constructor.name;
+		const preview = signature.length > 50 ? `${signature.substring(0, 47)}...` : signature;
+		let functionTypePrefix = "";
+		if (constructorName === "AsyncFunction") functionTypePrefix += "async ";
+		if (constructorName === "AsyncGeneratorFunction") functionTypePrefix += "async ";
+		if (constructorName === "GeneratorFunction" || constructorName === "AsyncGeneratorFunction") functionTypePrefix += "ƒ* ";
+		if (!constructorName.includes("Generator")) functionTypePrefix += "ƒ ";
+		return jsx("span", {}, [jsx("span", { kind: "function-type" }, [txt(functionTypePrefix)]), jsx("span", { kind: "function-body" }, [txt(preview)])]);
+	},
+	node({ value, keyPath, createNode, options }) {
+		const funcName = value.name || "anonymous";
+		const constructorName = value.constructor.name;
+		const enumerableProperties = [];
+		const nonEnumerableProperties = [];
+		const funcString = getFunctionString(value);
+		nonEnumerableProperties.push({
+			key: "[[Function]]",
+			value: funcString
+		});
+		enumerableProperties.push({
+			key: "name",
+			value: funcName
+		});
+		enumerableProperties.push({
+			key: "length",
+			value: value.length
+		});
+		enumerableProperties.push({
+			key: "constructor",
+			value: constructorName
+		});
+		const additionalProps = Object.getOwnPropertyNames(value).filter((key) => !FUNC_KEYS.includes(key)).map((key) => ({
+			key,
+			value: Reflect.get(value, key)
+		}));
+		enumerableProperties.push(...additionalProps);
+		const enumerableChildren = enumerableProperties.map(({ key, value: value$1 }) => createNode([key], value$1));
+		const nonEnumerableChildren = options?.showNonenumerable ? nonEnumerableProperties.map(({ key, value: value$1 }) => {
+			const node = createNode([key], value$1);
+			node.isNonEnumerable = true;
+			return node;
+		}) : [];
+		return {
+			value,
+			type: "function",
+			keyPath,
+			children: [...enumerableChildren, ...nonEnumerableChildren]
+		};
+	}
+});
+const ArrayBufferType = dataType({
+	type: "arraybuffer",
+	description(node) {
+		return `ArrayBuffer(${node.value.byteLength})`;
+	},
+	check(value) {
+		return value instanceof ArrayBuffer;
+	},
+	previewElement(node) {
+		return jsx("span", { nodeType: "arraybuffer" }, [txt(node.value.toString())]);
+	},
+	node({ value, keyPath }) {
+		return {
+			value,
+			keyPath,
+			type: "arraybuffer"
+		};
+	}
+});
+const SharedArrayBufferType = dataType({
+	type: "sharedarraybuffer",
+	description(node) {
+		return `SharedArrayBuffer(${node.value.byteLength})`;
+	},
+	check(value) {
+		return typeof SharedArrayBuffer !== "undefined" && value instanceof SharedArrayBuffer;
+	},
+	previewElement() {
+		return jsx("span", { nodeType: "sharedarraybuffer" }, [txt("sharedarraybuffer")]);
+	},
+	node({ value, keyPath }) {
+		return {
+			value,
+			keyPath,
+			type: "sharedarraybuffer"
+		};
+	}
+});
+const BufferType = dataType({
+	type: "buffer",
+	description(node) {
+		return `Buffer(${node.value.length})`;
+	},
+	check(value) {
+		return typeof Buffer !== "undefined" && value instanceof Buffer;
+	},
+	previewElement(node) {
+		const buffer = node.value;
+		const preview = Array.from(new Uint8Array(buffer).slice(0, 8)).map((byte) => byte.toString(16).padStart(2, "0")).join(" ");
+		const hasMore = buffer.length > 8;
+		return jsx("span", {}, [
+			jsx("span", { kind: "constructor" }, [txt(`Buffer(${buffer.length})`)]),
+			jsx("span", { kind: "brace" }, [txt(" ['")]),
+			jsx("span", { kind: "preview-text" }, [txt(preview + (hasMore ? " …" : ""))]),
+			jsx("span", { kind: "brace" }, [txt("']")])
+		]);
+	},
+	node({ value, keyPath }) {
+		return {
+			value,
+			keyPath,
+			type: "buffer"
+		};
+	}
+});
+const DateType = dataType({
+	type: "date",
+	description(node) {
+		return String(node.value);
+	},
+	check(value) {
+		return value instanceof Date;
+	},
+	previewElement(node) {
+		return jsx("span", {}, [txt(node.value.toISOString())]);
+	},
+	node({ value, keyPath }) {
+		return {
+			value,
+			keyPath,
+			type: "date"
+		};
+	}
+});
+const MapType = dataType({
+	type: "map",
+	description(node) {
+		return `Map(${node.value.size})`;
+	},
+	check(value) {
+		return value instanceof Map;
+	},
+	previewText(node, opts) {
+		const maxItems = opts.maxPreviewItems;
+		const entries = Array.from(node.value.entries());
+		return generatePreviewText(entries.slice(0, maxItems).map(([key, value]) => {
+			const valueDesc = formatValue(value);
+			return `${typeof key === "string" ? `"${key}"` : String(key)} => ${valueDesc}`;
+		}), entries.length > maxItems);
+	},
+	previewElement(node, opts) {
+		const preview = this.previewText?.(node, opts) || "";
+		const size = node.value.size;
+		const children = [jsx("span", { kind: "constructor" }, [txt(`Map(${size})`)]), jsx("span", { kind: "brace" }, [txt(" {")])];
+		if (preview) children.push(jsx("span", { kind: "preview-text" }, [txt(preview)]));
+		children.push(jsx("span", { kind: "brace" }, [txt("}")]));
+		return jsx("span", {}, children);
+	},
+	node({ value, keyPath, createNode }) {
+		const entriesChildren = Array.from(value.entries()).map(([key, value$1], index) => {
+			const keyStr = String(key);
+			const keyNode = createNode([
+				ENTRIES_KEY,
+				keyStr,
+				"key"
+			], key);
+			const valueNode = createNode([
+				ENTRIES_KEY,
+				keyStr,
+				"value"
+			], value$1);
+			return {
+				keyPath: [
+					...keyPath,
+					ENTRIES_KEY,
+					index
+				],
+				value: { [keyStr]: value$1 },
+				type: "object",
+				children: [keyNode, valueNode]
+			};
+		});
+		return {
+			value,
+			keyPath,
+			type: "map",
+			children: [{
+				keyPath: [...keyPath, ENTRIES_KEY],
+				value: Array.from(value.entries()),
+				type: "array",
+				children: entriesChildren,
+				isNonEnumerable: true
+			}, createNode(["size"], value.size)]
+		};
+	}
+});
+const ERROR_KEYS = [
+	"name",
+	"message",
+	"stack"
+];
+const ErrorType = dataType({
+	type: "error",
+	description(node) {
+		const err = node.value;
+		return `${err.name}: ${err.message}`;
+	},
+	check(value) {
+		return value instanceof Error;
+	},
+	previewElement(node) {
+		const err = node.value;
+		return jsx("span", {}, [
+			jsx("span", { kind: "constructor" }, [txt(err.name)]),
+			jsx("span", { kind: "colon" }, [txt(": ")]),
+			jsx("span", {}, [txt(err.message)])
+		]);
+	},
+	node({ value, keyPath, createNode }) {
+		const errorProperties = ERROR_KEYS.map((key) => ({
+			key,
+			value: Reflect.get(value, key)
+		}));
+		const additionalProps = Object.getOwnPropertyNames(value).filter((key) => !ERROR_KEYS.includes(key)).map((key) => ({
+			key,
+			value: getProp(value, key)
+		}));
+		return {
+			value,
+			keyPath,
+			type: "error",
+			children: [...errorProperties, ...additionalProps].map(({ key, value: value$1 }) => createNode([key], value$1))
+		};
+	}
+});
+function errorStackToElement(stack) {
+	const stackLines = stack?.split("\n").filter((line) => line.trim()) || [];
+	return jsx("span", {}, stackLines.map((line, index) => {
+		const appendNewLine = index < stackLines.length - 1;
+		return jsx("span", {
+			nodeType: "string",
+			kind: "error-stack"
+		}, [jsx("span", {}, [txt(line + (appendNewLine ? "\\n" : ""))]), jsx("span", { kind: "operator" }, [txt(appendNewLine ? " +" : "")])]);
+	}));
+}
+const HeadersType = dataType({
+	type: "headers",
+	description: "Headers",
+	check(value) {
+		return typeOf(value) === "[object Headers]";
+	},
+	previewElement(node) {
+		const headers = node.value;
+		const entriesArray = Array.from(headers.entries());
+		const preview = entriesArray.slice(0, 2).map(([key, value]) => `${key}: ${value}`).join(", ");
+		const hasMore = entriesArray.length > 2;
+		return jsx("span", {}, [
+			jsx("span", { kind: "constructor" }, [txt(`Headers(${entriesArray.length})`)]),
+			jsx("span", { kind: "brace" }, [txt(" {")]),
+			jsx("span", { kind: "preview-text" }, [txt(` ${preview}${hasMore ? ", …" : ""} `)]),
+			jsx("span", { kind: "brace" }, [txt("}")])
+		]);
+	},
+	node({ value, keyPath, createNode }) {
+		const entriesChildren = Array.from(value.entries()).map(([key, value$1], index) => {
+			const keyStr = String(key);
+			const keyNode = createNode([
+				ENTRIES_KEY,
+				keyStr,
+				"key"
+			], key);
+			const valueNode = createNode([
+				ENTRIES_KEY,
+				keyStr,
+				"value"
+			], value$1);
+			return {
+				keyPath: [
+					...keyPath,
+					ENTRIES_KEY,
+					index
+				],
+				value: { [key]: value$1 },
+				type: "object",
+				children: [keyNode, valueNode]
+			};
+		});
+		return {
+			value,
+			keyPath,
+			type: "headers",
+			children: [{
+				keyPath: [...keyPath, ENTRIES_KEY],
+				value: Array.from(value.entries()),
+				type: "array",
+				children: entriesChildren,
+				isNonEnumerable: true
+			}]
+		};
+	}
+});
+const FormDataType = dataType({
+	type: "formdata",
+	description: "FormData",
+	check(value) {
+		return typeOf(value) === "[object FormData]";
+	},
+	previewElement(node) {
+		const formData = node.value;
+		const entriesArray = Array.from(formData.entries());
+		const preview = entriesArray.slice(0, 2).map(([key, value]) => {
+			return `${key}: ${FileType.check(value) ? `File(${value.size})` : String(value)}`;
+		}).join(", ");
+		const hasMore = entriesArray.length > 2;
+		return jsx("span", {}, [
+			jsx("span", { kind: "constructor" }, [txt(`FormData(${entriesArray.length})`)]),
+			jsx("span", { kind: "brace" }, [txt(" {")]),
+			jsx("span", { kind: "preview-text" }, [txt(` ${preview}${hasMore ? ", …" : ""} `)]),
+			jsx("span", { kind: "brace" }, [txt("}")])
+		]);
+	},
+	node({ value, keyPath, createNode }) {
+		const entriesChildren = Array.from(value.entries()).map(([key, value$1], index) => {
+			const keyNode = createNode([
+				ENTRIES_KEY,
+				index,
+				"key"
+			], key);
+			const valueNode = createNode([
+				ENTRIES_KEY,
+				index,
+				"value"
+			], value$1);
+			return {
+				keyPath: [
+					...keyPath,
+					ENTRIES_KEY,
+					index
+				],
+				value: { [key]: value$1 },
+				type: "object",
+				children: [keyNode, valueNode]
+			};
+		});
+		return {
+			value,
+			keyPath,
+			type: "formdata",
+			children: [{
+				keyPath: [...keyPath, ENTRIES_KEY],
+				value: Array.from(value.entries()),
+				type: "array",
+				children: entriesChildren,
+				isNonEnumerable: true
+			}]
+		};
+	}
+});
+const ArrayType = dataType({
+	type: "array",
+	description(node) {
+		return `Array(${node.value.length})`;
+	},
+	check(value) {
+		return Array.isArray(value);
+	},
+	previewText(node, opts) {
+		const maxItems = opts.maxPreviewItems;
+		const enumerableChildren = (node.children || []).filter((child) => !child.isNonEnumerable && keyPathToKey(child.keyPath) !== "length");
+		return generatePreviewText(enumerableChildren.slice(0, maxItems).map(formatValueMini), enumerableChildren.length > maxItems);
+	},
+	previewElement(node, opts) {
+		const preview = this.previewText?.(node, opts) || "";
+		const count = node.value.length;
+		const children = [];
+		if (count > 0) children.push(jsx("span", { kind: "constructor" }, [txt(`(${count}) `)]));
+		children.push(jsx("span", { kind: "brace" }, [txt("[")]));
+		if (preview) children.push(jsx("span", { kind: "preview-text" }, [txt(preview)]));
+		children.push(jsx("span", { kind: "brace" }, [txt("]")]));
+		return jsx("span", {}, children);
+	},
+	node({ value, keyPath, createNode, options }) {
+		const arrayChildren = [];
+		const definedIndices = Object.keys(value).filter((key) => !Number.isNaN(Number(key))).map(Number).sort((a, b) => a - b);
+		const chunkSize = options?.groupArraysAfterLength;
+		if (chunkSize && definedIndices.length > chunkSize) {
+			const chunks = [];
+			for (let i = 0; i < definedIndices.length; i += chunkSize) chunks.push(definedIndices.slice(i, i + chunkSize));
+			for (let chunkIndex = 0; chunkIndex < chunks.length; chunkIndex++) {
+				const chunk = chunks[chunkIndex];
+				const groupKey = `[${chunk[0]}…${chunk[chunk.length - 1]}]`;
+				const groupChildren = chunk.map((index) => createNode([index.toString()], value[index]));
+				const groupNode = {
+					keyPath: [...keyPath, groupKey],
+					value: chunk.map((index) => value[index]),
+					type: "array",
+					children: groupChildren,
+					isNonEnumerable: false
+				};
+				arrayChildren.push(groupNode);
+			}
+		} else for (const index of definedIndices) arrayChildren.push(createNode([index.toString()], value[index]));
+		const lengthChild = createNode(["length"], value.length);
+		const propertyNames = Object.getOwnPropertyNames(value);
+		const enumerableKeys = Object.keys(value).filter((key) => !Number.isNaN(Number(key)));
+		const nonEnumerableKeys = propertyNames.filter((key) => !enumerableKeys.includes(key) && key !== "length" && Number.isNaN(Number(key)));
+		const nonEnumerableChildren = options?.showNonenumerable ? nonEnumerableKeys.map((key) => {
+			const descriptor = Object.getOwnPropertyDescriptor(value, key);
+			const node = createNode([key], Reflect.get(value, key));
+			node.isNonEnumerable = true;
+			node.propertyDescriptor = descriptor;
+			return node;
+		}) : [];
+		return {
+			value,
+			type: "array",
+			children: [
+				...arrayChildren,
+				lengthChild,
+				...nonEnumerableChildren
+			],
+			keyPath
+		};
+	}
+});
+const typedArrayConstructors = {
+	Int8Array: "int8array",
+	Uint8Array: "uint8array",
+	Uint8ClampedArray: "uint8clampedarray",
+	Int16Array: "int16array",
+	Uint16Array: "uint16array",
+	Int32Array: "int32array",
+	Uint32Array: "uint32array",
+	Float32Array: "float32array",
+	Float64Array: "float64array",
+	BigInt64Array: "bigint64array",
+	BigUint64Array: "biguint64array"
+};
+const revertTypedArrayConstructors = Object.fromEntries(Object.entries(typedArrayConstructors).map(([key, value]) => [value, key]));
+const TYPED_ARRAY_KEYS = [
+	"length",
+	"byteLength",
+	"byteOffset",
+	"buffer"
+];
+const TypedArrayType = dataType({
+	type: (value) => Reflect.get(typedArrayConstructors, value.constructor.name),
+	description(node) {
+		const typedArray = node.value;
+		return `${revertTypedArrayConstructors[typedArray.constructor.name]}(${typedArray.length})`;
+	},
+	check(value) {
+		return isObj(value) && value.constructor.name in typedArrayConstructors;
+	},
+	previewElement(node) {
+		const typedArray = node.value;
+		const constructorName = typedArray.constructor.name;
+		const preview = Array.from(typedArray).slice(0, 5).join(", ");
+		const hasMore = typedArray.length > 5;
+		return jsx("span", {}, [
+			jsx("span", { kind: "constructor" }, [txt(`${constructorName}(${typedArray.length})`)]),
+			jsx("span", { kind: "brace" }, [txt(" [ ")]),
+			jsx("span", { kind: "preview-text" }, [txt(preview + (hasMore ? ", …" : ""))]),
+			jsx("span", { kind: "brace" }, [txt(" ]")])
+		]);
+	},
+	node({ value, keyPath, createNode, options }) {
+		const typedArray = value;
+		const enumerableChildren = TYPED_ARRAY_KEYS.map((key) => ({
+			key,
+			value: Reflect.get(typedArray, key)
+		})).map(({ key, value: value$1 }) => createNode([key], value$1));
+		const nonEnumerableChildren = options?.showNonenumerable ? (() => {
+			const node = createNode(["[[Values]]"], Array.from(typedArray).slice(0, 100));
+			node.isNonEnumerable = true;
+			return [node];
+		})() : [];
+		const children = [...enumerableChildren, ...nonEnumerableChildren];
+		return {
+			value,
+			keyPath,
+			type: Reflect.get(typedArrayConstructors, value.constructor.name),
+			children
+		};
+	}
+});
+const IterableType = dataType({
+	type: "iterable",
+	description: "Iterable",
+	check(value) {
+		return Boolean(value && typeof value === "object" && typeof value[Symbol.iterator] === "function" && !(value instanceof Set) && !(value instanceof Map) && !Array.isArray(value) && !(value instanceof Date) && !(value instanceof RegExp) && !(value instanceof ArrayBuffer));
+	},
+	previewElement(node, opts) {
+		const preview = SetType.previewText?.(node, opts) ?? "";
+		const entriesArray = Array.from(node.value);
+		const children = [jsx("span", { kind: "constructor" }, [txt(`Iterable(${node.value.size ?? node.value.length ?? entriesArray.length})`)]), jsx("span", { kind: "brace" }, [txt(" {")])];
+		if (preview) children.push(jsx("span", { kind: "preview-text" }, [txt(preview)]));
+		children.push(jsx("span", { kind: "brace" }, [txt("}")]));
+		return jsx("span", {}, children);
+	},
+	node({ value, keyPath, createNode }) {
+		const entriesArray = Array.from(value);
+		const entriesChildren = entriesArray.map((item, index) => createNode([ENTRIES_KEY, index], item));
+		return {
+			value,
+			type: "iterable",
+			children: [{
+				keyPath: [...keyPath, ENTRIES_KEY],
+				value: entriesArray,
+				type: "array",
+				children: entriesChildren,
+				isNonEnumerable: true
+			}, createNode(["size"], value.size ?? value.length ?? entriesArray.length)],
+			keyPath
+		};
+	}
+});
+const ClassType = dataType({
+	type: "object",
+	description(node) {
+		return node.constructorName || "Object";
+	},
+	check(value) {
+		return typeof value === "object" && value !== null && value.constructor !== Object;
+	},
+	previewText(node, opts) {
+		return ObjectType.previewText?.(node, opts) || "";
+	},
+	previewElement(node, opts) {
+		return ObjectType.previewElement(node, opts);
+	},
+	node({ value, keyPath, createNode, options }) {
+		const constructorName = value.constructor.name;
+		const allPropertyNames = Object.getOwnPropertyNames(value);
+		const enumerableKeys = Object.keys(value);
+		const nonEnumerableKeys = allPropertyNames.filter((key) => !enumerableKeys.includes(key));
+		const enumerableChildren = enumerableKeys.map((key) => createNode([key], Reflect.get(value, key)));
+		const nonEnumerableChildren = options?.showNonenumerable ? nonEnumerableKeys.map((key) => {
+			const descriptor = Object.getOwnPropertyDescriptor(value, key);
+			const node = createNode([`[[${key}]]`], getProp(value, key));
+			node.isNonEnumerable = true;
+			node.propertyDescriptor = descriptor;
+			return node;
+		}) : [];
+		return {
+			value,
+			keyPath,
+			type: "object",
+			constructorName,
+			children: [...enumerableChildren, ...nonEnumerableChildren]
+		};
+	}
+});
+const ObjectType = dataType({
+	type: "object",
+	description: "Object",
+	check(value) {
+		return typeof value === "object" && value !== null;
+	},
+	previewText(node, opts) {
+		const maxItems = opts.maxPreviewItems;
+		const children = node.children || [];
+		return generatePreviewText(children.slice(0, maxItems).map((child) => {
+			const valueDesc = getNodeTypeDescription(child);
+			return `${keyPathToKey(child.keyPath)}: ${valueDesc}`;
+		}), children.length > maxItems);
+	},
+	previewElement(node, opts) {
+		const preview = this.previewText?.(node, opts) ?? "";
+		const children = [];
+		if (node.constructorName) children.push(jsx("span", { kind: "constructor" }, [txt(`${node.constructorName} `)]));
+		children.push(jsx("span", { kind: "brace" }, [txt("{")]));
+		if (preview) children.push(jsx("span", { kind: "preview-text" }, [txt(preview)]));
+		children.push(jsx("span", { kind: "brace" }, [txt("}")]));
+		return jsx("span", {}, children);
+	},
+	node({ value, keyPath, createNode, options }) {
+		const allPropertyNames = Object.getOwnPropertyNames(value);
+		const enumerableKeys = Object.keys(value);
+		const nonEnumerableKeys = allPropertyNames.filter((key) => !enumerableKeys.includes(key));
+		const enumerableChildren = enumerableKeys.map((key) => createNode([key], getProp(value, key)));
+		const nonEnumerableChildren = options?.showNonenumerable ? nonEnumerableKeys.map((key) => {
+			const descriptor = Object.getOwnPropertyDescriptor(value, key);
+			const node = createNode([`[[${key}]]`], getProp(value, key));
+			node.isNonEnumerable = true;
+			node.propertyDescriptor = descriptor;
+			return node;
+		}) : [];
+		return {
+			value,
+			type: "object",
+			children: [...enumerableChildren, ...nonEnumerableChildren],
+			keyPath
+		};
+	}
+});
+const ELEMENT_KEYS = [
+	"attributes",
+	"childElementCount",
+	"className",
+	"dataset",
+	"hidden",
+	"id",
+	"inert",
+	"isConnected",
+	"isContentEditable",
+	"nodeType",
+	"style",
+	"tabIndex",
+	"tagName"
+];
+const isSvg = (el) => typeof el === "object" && el.tagName === "svg" && el.namespaceURI === "http://www.w3.org/2000/svg";
+const isHTML = (el) => typeof el === "object" && el.namespaceURI === "http://www.w3.org/1999/xhtml";
+const ElementType = dataType({
+	type: "element",
+	description(node) {
+		return typeOf(node.value);
+	},
+	check(value) {
+		return isSvg(value) || isHTML(value);
+	},
+	previewElement(node) {
+		const el = node.value;
+		const classList = Array.from(el.classList).slice(0, 3);
+		return jsx("span", {}, [
+			jsx("span", { kind: "constructor" }, [txt(el.constructor.name)]),
+			jsx("span", {}, [txt(" ")]),
+			jsx("span", { kind: "preview-text" }, [txt(`<${el.localName}${el.id ? `#${el.id}` : ""}${classList.length > 0 ? "." + classList.join(".") : ""}>`)])
+		]);
+	},
+	node({ value, keyPath, createNode }) {
+		return {
+			value,
+			keyPath,
+			type: "element",
+			children: ELEMENT_KEYS.reduce((acc, key) => {
+				let childValue = Reflect.get(value, key);
+				if (key === "attributes") {
+					const attrs = Array.from(value.attributes);
+					childValue = attrs.length ? Object.fromEntries(attrs.map((attr) => [attr.name, attr.value])) : void 0;
+				}
+				if (key === "style") {
+					const style = Array.from(value.style);
+					childValue = style.length ? Object.fromEntries(style.map((key$1) => [key$1, value.style.getPropertyValue(key$1)])) : void 0;
+				}
+				acc.push(createNode([key], childValue));
+				return acc;
+			}, [])
+		};
+	}
+});
+const DOCUMENT_KEYS = [
+	"title",
+	"URL",
+	"documentElement",
+	"head",
+	"body",
+	"contentType",
+	"readyState"
+];
+const DocumentType = dataType({
+	type: "document",
+	description: "Document",
+	check(value) {
+		return typeOf(value) === "[object HTMLDocument]";
+	},
+	previewElement(node) {
+		const url = node.value.URL || "unknown";
+		return jsx("span", {}, [jsx("span", { kind: "constructor" }, [txt("#document")]), jsx("span", { kind: "preview-text" }, [txt(` (${url})`)])]);
+	},
+	node({ value, keyPath, createNode }) {
+		return {
+			value,
+			keyPath,
+			type: "document",
+			children: DOCUMENT_KEYS.map((key) => createNode([key], Reflect.get(value, key)))
+		};
+	}
+});
+const WINDOW_KEYS = [
+	"location",
+	"navigator",
+	"document",
+	"innerWidth",
+	"innerHeight",
+	"devicePixelRatio",
+	"origin"
+];
+const WindowType = dataType({
+	type: "window",
+	description: "Window",
+	check(value) {
+		return typeOf(value) === "[object Window]";
+	},
+	previewElement() {
+		return jsx("span", {}, [jsx("span", { kind: "constructor" }, [txt("Window")]), jsx("span", { kind: "preview-text" }, [txt(" { … }")])]);
+	},
+	node({ value, keyPath, createNode }) {
+		return {
+			value,
+			keyPath,
+			type: "window",
+			children: WINDOW_KEYS.map((key) => {
+				const childValue = Reflect.get(value, key);
+				return createNode([key], childValue);
+			})
+		};
+	}
+});
+const REACT_ELEMENT_KEYS = [
+	"$$typeof",
+	"type",
+	"key",
+	"ref",
+	"props"
+];
+const getElementTypeName = (type) => {
+	if (typeof type === "string") return type;
+	if (typeof type === "function") return type.displayName || type.name || "Component";
+	return type?.toString() || "Component";
+};
+const ReactElementType = dataType({
+	type: "react-element",
+	description(node) {
+		const el = node.value;
+		return getElementTypeName(el.type);
+	},
+	check(value) {
+		return isObj(value) && "$$typeof" in value && "props" in value;
+	},
+	previewElement(node, opts) {
+		const el = node.value;
+		const elName = getElementTypeName(el.type);
+		const props = Object.entries(el.props);
+		const hasMore = props.length > opts.maxPreviewItems;
+		return jsx("span", {}, [
+			txt(`<${elName} `),
+			...props.slice(0, opts.maxPreviewItems).reduce((acc, [key, value]) => {
+				if (key === "children") return acc;
+				acc.push(jsx("span", {}, [txt(` ${key}=${typeof value === "string" ? `"${value}"` : `{${value}}`}`)]));
+				return acc;
+			}, []),
+			...hasMore ? [txt(" …")] : [],
+			txt(el.children ? `> {…} </${elName}>` : ` />`)
+		]);
+	},
+	node({ value, keyPath, createNode }) {
+		return {
+			value,
+			type: "react-element",
+			keyPath,
+			children: REACT_ELEMENT_KEYS.reduce((acc, key) => {
+				let childValue = Reflect.get(value, key);
+				if (key === "type") childValue = getElementTypeName(childValue);
+				acc.push(createNode([key], childValue));
+				return acc;
+			}, [])
+		};
+	}
+});
+const map = {
+	"\n": "\\n",
+	"	": "\\t",
+	"\r": "\\r"
+};
+const STRING_ESCAPE_REGEXP = /[\n\t\r]/g;
+const StringType = dataType({
+	type: "string",
+	description(node, opts) {
+		return `"${this.previewText?.(node, opts) ?? node.value}"`;
+	},
+	check(value) {
+		return typeof value === "string";
+	},
+	previewText(node, opts) {
+		const serialised = node.value.replace(STRING_ESCAPE_REGEXP, (_) => map[_]);
+		return serialised.slice(0, opts.collapseStringsAfterLength) + (serialised.length > opts.collapseStringsAfterLength ? "…" : "");
+	},
+	previewElement(node) {
+		return jsx("span", {}, [txt(`"${node.value.replace(STRING_ESCAPE_REGEXP, (_) => map[_])}"`)]);
+	},
+	node({ value, keyPath }) {
+		return {
+			value,
+			type: "string",
+			keyPath
+		};
+	}
+});
+const PrimitiveType = dataType({
+	type(value) {
+		return typeof value;
+	},
+	description(node) {
+		return String(node.value);
+	},
+	check(value) {
+		return value !== null && value !== void 0;
+	},
+	previewElement(node) {
+		return jsx("span", {}, [txt(String(node.value))]);
+	},
+	node({ value, keyPath }) {
+		return {
+			value,
+			type: typeof value,
+			keyPath
+		};
+	}
+});
+const dataTypes = [
+	NullType,
+	UndefinedType,
+	SymbolType,
+	BigIntType,
+	FunctionType,
+	ArrayBufferType,
+	SharedArrayBufferType,
+	BufferType,
+	DataViewType,
+	ErrorType,
+	DateType,
+	RegexType,
+	SetType,
+	MapType,
+	WeakMapType,
+	WeakSetType,
+	FileType,
+	BlobType,
+	ReactElementType,
+	WindowType,
+	DocumentType,
+	ElementType,
+	UrlType,
+	URLSearchParamsType,
+	HeadersType,
+	FormDataType,
+	ArrayType,
+	TypedArrayType,
+	IterableType,
+	ClassType,
+	ObjectType,
+	StringType,
+	PrimitiveType
+];
+const jsonNodeToElement = (node, opts) => {
+	const options = getPreviewOptions(opts);
+	const key = keyPathToKey(node.keyPath, { excludeRoot: true });
+	if (key === "stack" && typeof node.value === "string") return errorStackToElement(node.value);
+	const dataType$1 = dataTypes.find((dataType$2) => dataType$2.check(node.value));
+	if (!dataType$1) return jsx("span", {}, [txt(String(node.value))]);
+	const element = dataType$1.previewElement(node, options);
+	if (!key) element.properties.root = true;
+	element.properties.kind = "preview";
+	element.properties.nodeType = typeof dataType$1.type === "function" ? dataType$1.type(node.value) : dataType$1.type;
+	return element;
+};
+const getNodeTypeDescription = (node, opts) => {
+	const options = getPreviewOptions(opts);
+	const dataType$1 = dataTypes.find((dataType$2) => dataType$2.check(node.value));
+	if (dataType$1) return typeof dataType$1.description === "function" ? dataType$1.description(node, options) : dataType$1.description;
+	return String(node.value);
+};
+
+//#endregion
+//#region src/shared/json-tree-utils/accessibility.ts
+const propertyWord = (count) => count === 1 ? "property" : "properties";
+const isPrimitive = (node) => {
+	return node.type === "string" || node.type === "number" || node.type === "boolean";
+};
+const getAccessibleDescription = (node, opts) => {
+	const typeDescription = getNodeTypeDescription(node, opts);
+	const key = keyPathToKey(node.keyPath, { excludeRoot: true });
+	const nonEnumerablePrefix = node.isNonEnumerable ? "non-enumerable " : "";
+	const format = (text) => {
+		return [key, `${nonEnumerablePrefix}${text}`].filter(Boolean).join(": ");
+	};
+	if (node.children && node.children.length > 0) {
+		const childCount = node.children.length;
+		if (key === "[[Entries]]") return format(`${childCount} ${propertyWord(childCount)}`);
+		return format(`${typeDescription}, expandable with ${childCount} ${propertyWord(childCount)}`);
+	}
+	if (isPrimitive(node)) {
+		if (key === "stack") return format(node.value.split("\n")[1]?.trim() || "trace");
+		if (key === "[[Function]]") return format("function implementation");
+		return format(`${typeof node.value === "string" ? `"${node.value}"` : String(node.value)}${node.isNonEnumerable && node.propertyDescriptor ? `, ${getDescriptorInfo(node.propertyDescriptor)}` : ""}`);
+	}
+	if (node.type === "null") return format("null");
+	if (node.type === "undefined") return format("undefined");
+	if (node.type === "circular") return format("circular reference");
+	return format(`${nonEnumerablePrefix}${typeDescription}${node.isNonEnumerable && node.propertyDescriptor ? `, ${getDescriptorInfo(node.propertyDescriptor)}` : ""}`);
+};
+const getDescriptorInfo = (descriptor) => {
+	const parts = [];
+	if (!descriptor.writable) parts.push("read-only");
+	if (!descriptor.configurable) parts.push("non-configurable");
+	return parts.length > 0 ? parts.join(", ") : "non-enumerable";
+};
+
+//#endregion
+exports.ArrayBufferType = ArrayBufferType;
+exports.ArrayType = ArrayType;
+exports.BigIntType = BigIntType;
+exports.BlobType = BlobType;
+exports.BufferType = BufferType;
+exports.ClassType = ClassType;
+exports.DEFAULT_PREVIEW_OPTIONS = DEFAULT_PREVIEW_OPTIONS;
+exports.DataViewType = DataViewType;
+exports.DateType = DateType;
+exports.DocumentType = DocumentType;
+exports.ElementType = ElementType;
+exports.ErrorType = ErrorType;
+exports.FileType = FileType;
+exports.FormDataType = FormDataType;
+exports.FunctionType = FunctionType;
+exports.HeadersType = HeadersType;
+exports.IterableType = IterableType;
+exports.MapType = MapType;
+exports.NullType = NullType;
+exports.ObjectType = ObjectType;
+exports.PATH_SEP = PATH_SEP;
+exports.PrimitiveType = PrimitiveType;
+exports.ROOT_KEY = ROOT_KEY;
+exports.ReactElementType = ReactElementType;
+exports.RegexType = RegexType;
+exports.SetType = SetType;
+exports.SharedArrayBufferType = SharedArrayBufferType;
+exports.StringType = StringType;
+exports.SymbolType = SymbolType;
+exports.TypedArrayType = TypedArrayType;
+exports.URLSearchParamsType = URLSearchParamsType;
+exports.UndefinedType = UndefinedType;
+exports.UrlType = UrlType;
+exports.WeakMapType = WeakMapType;
+exports.WeakSetType = WeakSetType;
+exports.WindowType = WindowType;
+exports.dataTypes = dataTypes;
+exports.getAccessibleDescription = getAccessibleDescription;
+exports.getNodeTypeDescription = getNodeTypeDescription;
+exports.getPreviewOptions = getPreviewOptions;
+exports.getRootNode = getRootNode;
+exports.isRootKeyPath = isRootKeyPath;
+exports.jsonNodeToElement = jsonNodeToElement;
+exports.jsonPathToValue = jsonPathToValue;
+exports.jsonToTree = jsonToTree;
+exports.keyPathToId = keyPathToId;
+exports.keyPathToKey = keyPathToKey;
+exports.nodeToString = nodeToString;
+exports.nodeToValue = nodeToValue;