content-query 0.0.1 → 0.1.0

package/dist/values-B7lo_2_x.mjs

@@ -0,0 +1,900 @@
+//#region ../../node_modules/.pnpm/devalue@6.0.2/node_modules/devalue/src/constants.js
+const MAX_ARRAY_LEN = 2 ** 32 - 1;
+const MAX_ARRAY_INDEX = MAX_ARRAY_LEN - 1;
+//#endregion
+//#region ../../node_modules/.pnpm/devalue@6.0.2/node_modules/devalue/src/utils.js
+var DevalueError = class extends Error {
+	/**
+	* @param {string} message
+	* @param {string[]} keys
+	* @param {any} [value] - The value that failed to be serialized
+	* @param {any} [root] - The root value being serialized
+	*/
+	constructor(message, keys, value, root) {
+		super(message);
+		this.name = "DevalueError";
+		this.path = keys.join("");
+		this.value = value;
+		this.root = root;
+	}
+};
+/**
+* Marks a Map key on the path being serialized. The key itself is recorded
+* right after the marker, so nothing is formatted or allocated per entry.
+*/
+const MAP_KEY = Symbol();
+/**
+* Formats the path recorded on the way to the value being serialized — a
+* property key, an array index, or `MAP_KEY` followed by a Map key — into
+* the segments a `DevalueError` joins. Only runs when an error is raised.
+* @param {any[]} keys
+* @param {(key: any) => string} format_map_key
+* @returns {string[]}
+*/
+function format_path(keys, format_map_key) {
+	/** @type {string[]} */
+	const path = [];
+	for (let i = 0; i < keys.length; i += 1) {
+		const segment = keys[i];
+		if (segment === MAP_KEY) path.push(`.get(${format_map_key(keys[++i])})`);
+		else if (typeof segment === "number") path.push(`[${segment}]`);
+		else path.push(stringify_key(segment));
+	}
+	return path;
+}
+const object_proto_names = /* @__PURE__ */ Object.getOwnPropertyNames(Object.prototype).sort().join("\0");
+/** @param {any} thing */
+function is_plain_object(thing) {
+	const proto = Object.getPrototypeOf(thing);
+	return proto === Object.prototype || proto === null || Object.getPrototypeOf(proto) === null || Object.getOwnPropertyNames(proto).sort().join("\0") === object_proto_names;
+}
+/** @param {any} thing */
+function get_type(thing) {
+	return Object.prototype.toString.call(thing).slice(8, -1);
+}
+/** @param {any} thing */
+function is_buffer(thing) {
+	return typeof Buffer !== "undefined" && Buffer.isBuffer(thing);
+}
+/** @param {string} char */
+function get_escaped_char(char) {
+	switch (char) {
+		case "\"": return "\\\"";
+		case "<": return "\\u003C";
+		case "\\": return "\\\\";
+		case "\n": return "\\n";
+		case "\r": return "\\r";
+		case "	": return "\\t";
+		case "\b": return "\\b";
+		case "\f": return "\\f";
+		case "\u2028": return "\\u2028";
+		case "\u2029": return "\\u2029";
+		default: return char < " " ? `\\u${char.charCodeAt(0).toString(16).padStart(4, "0")}` : "";
+	}
+}
+const needs_escape = /["<\\\u0000-\u001f\u2028\u2029]/;
+/** @param {string} str */
+function stringify_string(str) {
+	if (!needs_escape.test(str) && str.isWellFormed()) return `"${str}"`;
+	let result = "";
+	let last_pos = 0;
+	const len = str.length;
+	for (let i = 0; i < len; i += 1) {
+		const code = str.charCodeAt(i);
+		if (code >= 55296 && code <= 57343) {
+			if (code <= 56319 && i + 1 < len && (str.charCodeAt(i + 1) & 64512) === 56320) {
+				i += 1;
+				continue;
+			}
+			result += str.slice(last_pos, i) + `\\u${code.toString(16)}`;
+			last_pos = i + 1;
+			continue;
+		}
+		const replacement = get_escaped_char(str[i]);
+		if (replacement) {
+			result += str.slice(last_pos, i) + replacement;
+			last_pos = i + 1;
+		}
+	}
+	return `"${last_pos === 0 ? str : result + str.slice(last_pos)}"`;
+}
+const MAX_CACHED_KEY_LENGTH = 64;
+/** @type {Map<string, string>} */
+const quoted_keys = /* @__PURE__ */ new Map();
+/** @param {string} key */
+function quote_key(key) {
+	if (key.length > MAX_CACHED_KEY_LENGTH) return stringify_string(key);
+	let quoted = quoted_keys.get(key);
+	if (quoted === void 0) {
+		if (quoted_keys.size >= 1024) quoted_keys.clear();
+		quoted = stringify_string(key);
+		quoted_keys.set(key, quoted);
+	}
+	return quoted;
+}
+/** @param {Record<string | symbol, any>} object */
+function enumerable_symbols(object) {
+	const symbols = Object.getOwnPropertySymbols(object);
+	return symbols.length === 0 ? symbols : symbols.filter((symbol) => Object.getOwnPropertyDescriptor(object, symbol)?.enumerable);
+}
+const is_identifier = /^[a-zA-Z_$][a-zA-Z_$0-9]*$/;
+/** @param {string} key */
+function stringify_key(key) {
+	return is_identifier.test(key) ? "." + key : "[" + JSON.stringify(key) + "]";
+}
+/** @param {number} n */
+function is_valid_array_index(n) {
+	if (!Number.isInteger(n)) return false;
+	if (n < 0) return false;
+	if (n > MAX_ARRAY_INDEX) return false;
+	return true;
+}
+/** @param {number} n */
+function is_valid_array_len(n) {
+	if (!Number.isInteger(n)) return false;
+	if (n < 0) return false;
+	if (n > MAX_ARRAY_LEN) return false;
+	return true;
+}
+/** @param {string} s */
+function is_valid_array_index_string(s) {
+	if (s.length === 0) return false;
+	if (s.length > 1 && s.charCodeAt(0) === 48) return false;
+	for (let i = 0; i < s.length; i++) {
+		const c = s.charCodeAt(i);
+		if (c < 48 || c > 57) return false;
+	}
+	return is_valid_array_index(+s);
+}
+/**
+* Returns the length of the leading run of valid array indices in `keys`.
+* @param {readonly string[]} keys
+*/
+function array_index_cut(keys) {
+	for (var i = keys.length - 1; i >= 0; i--) if (is_valid_array_index_string(keys[i])) break;
+	return i + 1;
+}
+/**
+* Finds the populated indices of an array.
+* @param {unknown[]} array
+*/
+function valid_array_indices(array) {
+	const keys = Object.keys(array);
+	keys.length = array_index_cut(keys);
+	return keys;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/devalue@6.0.2/node_modules/devalue/src/base64.js
+/**	@type {(array_buffer: ArrayBuffer) => string} */
+function encode_native(array_buffer) {
+	return new Uint8Array(array_buffer).toBase64();
+}
+/**	@type {(base64: string) => ArrayBuffer} */
+function decode_native(base64) {
+	return Uint8Array.fromBase64(base64).buffer;
+}
+/** @type {(array_buffer: ArrayBuffer) => string} */
+function encode_buffer(array_buffer) {
+	return Buffer.from(array_buffer).toString("base64");
+}
+/**	@type {(base64: string) => ArrayBuffer} */
+function decode_buffer(base64) {
+	return Uint8Array.from(Buffer.from(base64, "base64")).buffer;
+}
+/** @type {(array_buffer: ArrayBuffer) => string} */
+function encode_legacy(array_buffer) {
+	const array = new Uint8Array(array_buffer);
+	let binary = "";
+	const chunk_size = 32768;
+	for (let i = 0; i < array.length; i += chunk_size) {
+		const chunk = array.subarray(i, i + chunk_size);
+		binary += String.fromCharCode.apply(null, chunk);
+	}
+	return btoa(binary);
+}
+/**	@type {(base64: string) => ArrayBuffer} */
+function decode_legacy(base64) {
+	const binary_string = atob(base64);
+	const len = binary_string.length;
+	const array = new Uint8Array(len);
+	for (let i = 0; i < len; i++) array[i] = binary_string.charCodeAt(i);
+	return array.buffer;
+}
+const native = typeof Uint8Array.fromBase64 === "function";
+const buffer = typeof process === "object" && process.versions?.node !== void 0;
+const encode64 = native ? encode_native : buffer ? encode_buffer : encode_legacy;
+const decode64 = native ? decode_native : buffer ? decode_buffer : decode_legacy;
+//#endregion
+//#region ../../node_modules/.pnpm/devalue@6.0.2/node_modules/devalue/src/operations.js
+/**
+* Merges caller-provided operation overrides over the defaults. Iterating the
+* default keys (rather than the override's own keys) means nullish members
+* fall back to the default, and inherited members — e.g. from a class
+* instance — are picked up.
+*
+* @template {Record<string, any>} T
+* @param {T} defaults
+* @param {Partial<T> | undefined} overrides
+* @returns {T}
+*/
+function merge_operations(defaults, overrides) {
+	if (!overrides) return defaults;
+	const merged = {};
+	for (const key of Object.keys(defaults)) merged[key] = overrides[key] ?? defaults[key];
+	return merged;
+}
+/** @type {{ kind: 'not-plain' }} */
+const NOT_PLAIN = /* @__PURE__ */ Object.freeze({ kind: "not-plain" });
+/** @type {{ kind: 'symbol-keys' }} */
+const SYMBOL_KEYS = /* @__PURE__ */ Object.freeze({ kind: "symbol-keys" });
+const default_stringify_operations = /* @__PURE__ */ Object.freeze({
+	identify: (value) => value,
+	typeOf: (value) => value === null ? "null" : typeof value,
+	toPrimitive: (value) => value,
+	tagOf: (value) => get_type(value),
+	isThenable: (value) => typeof value.then === "function",
+	toPromise: (thenable) => Promise.resolve(thenable),
+	unbox: (boxed) => boxed.valueOf(),
+	toISOString: (date) => isNaN(date.getDate()) ? "" : date.toISOString(),
+	toStringValue: (value) => value.toString(),
+	regExpInfo: (regexp) => ({
+		source: regexp.source,
+		flags: regexp.flags
+	}),
+	valuesOf: (set) => set,
+	entriesOf: (map) => map,
+	viewInfo: (view) => {
+		if (is_buffer(view)) view = new Uint8Array(view);
+		return {
+			buffer: view.buffer,
+			byteOffset: view.byteOffset,
+			byteLength: view.byteLength,
+			length: view.length,
+			bufferByteLength: view.buffer.byteLength
+		};
+	},
+	toArrayBuffer: (buffer) => buffer,
+	lengthOf: (array) => array.length,
+	hasOwn: (value, key) => Object.hasOwn(value, key),
+	indicesOf: (array) => valid_array_indices(array),
+	shapeOf: (value) => {
+		if (!is_plain_object(value)) return NOT_PLAIN;
+		if (enumerable_symbols(value).length > 0) return SYMBOL_KEYS;
+		return {
+			kind: Object.getPrototypeOf(value) === null ? "null-proto" : "plain",
+			keys: Object.keys(value)
+		};
+	},
+	get: (value, key) => value[key]
+});
+const array_buffer_byte_length = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "byteLength")?.get;
+const shared_array_buffer_byte_length = typeof SharedArrayBuffer === "undefined" ? void 0 : Object.getOwnPropertyDescriptor(SharedArrayBuffer.prototype, "byteLength")?.get;
+const default_parse_operations = /* @__PURE__ */ Object.freeze({
+	fromPrimitive: (primitive) => primitive,
+	fromISOString: (iso) => new Date(iso),
+	fromStringValue: (tag, text) => {
+		if (tag === "URL") return new URL(text);
+		if (tag === "URLSearchParams") return new URLSearchParams(text);
+		return Temporal[tag.slice(9)].from(text);
+	},
+	fromArrayBuffer: (buffer) => buffer,
+	fromRegExpInfo: (source, flags) => new RegExp(source, flags),
+	fromViewInfo: (tag, buffer, byteOffset, length) => {
+		try {
+			array_buffer_byte_length.call(buffer);
+		} catch (error) {
+			if (!shared_array_buffer_byte_length) throw error;
+			shared_array_buffer_byte_length.call(buffer);
+		}
+		const Constructor = globalThis[tag];
+		return byteOffset !== void 0 ? new Constructor(buffer, byteOffset, length) : new Constructor(buffer);
+	},
+	box: (value) => Object(value),
+	createArray: (length) => new Array(length),
+	createSparseArray: (length) => {
+		/** @type {any[]} */
+		const array = [];
+		array[MAX_ARRAY_INDEX] = void 0;
+		delete array[MAX_ARRAY_INDEX];
+		array.length = length;
+		return array;
+	},
+	createObject: () => ({}),
+	createNullPrototypeObject: () => Object.create(null),
+	createSet: () => /* @__PURE__ */ new Set(),
+	createMap: () => /* @__PURE__ */ new Map(),
+	set: (target, key, value) => {
+		target[key] = value;
+	},
+	addValue: (set, value) => {
+		set.add(value);
+	},
+	addEntry: (map, key, value) => {
+		map.set(key, value);
+	}
+});
+//#endregion
+//#region ../../node_modules/.pnpm/devalue@6.0.2/node_modules/devalue/src/parse.js
+function invalid() {
+	throw new Error("Invalid input");
+}
+/**
+* Revive a value serialized with `devalue.stringify`
+* @param {string} serialized
+* @param {Record<string, (value: any) => any>} [revivers]
+* @param {import('./types.js').ParseOptions} [options]
+*/
+function parse(serialized, revivers, options) {
+	return unflatten(JSON.parse(serialized), revivers, options);
+}
+/**
+* Revive a value flattened with `devalue.stringify`
+* @param {number | any[]} parsed
+* @param {Record<string, (value: any) => any>} [revivers]
+* @param {import('./types.js').ParseOptions} [options]
+*/
+function unflatten(parsed, revivers, options) {
+	/** @type {import('./types.js').ParseOperations} */
+	const ops = merge_operations(default_parse_operations, options?.operations);
+	if (typeof parsed === "number") return hydrate(parsed, true);
+	if (!Array.isArray(parsed) || parsed.length === 0) invalid();
+	const values = parsed;
+	const hydrated = Array(values.length);
+	/**
+	* A set of values currently being hydrated with custom revivers,
+	* used to detect invalid cyclical dependencies
+	* @type {Set<number> | null}
+	*/
+	let hydrating = null;
+	/**
+	* @param {number} index
+	* @returns {any}
+	*/
+	function get_raw(index) {
+		if (!is_valid_array_index(index) || index >= values.length) invalid();
+		return values[index];
+	}
+	/**
+	* @param {number} index
+	* @returns {any}
+	*/
+	function hydrate(index, standalone = false) {
+		if (index === -1) return ops.fromPrimitive(void 0);
+		if (index === -3) return ops.fromPrimitive(NaN);
+		if (index === -4) return ops.fromPrimitive(Infinity);
+		if (index === -5) return ops.fromPrimitive(-Infinity);
+		if (index === -6) return ops.fromPrimitive(-0);
+		if (standalone || typeof index !== "number") invalid();
+		if (index in hydrated) return hydrated[index];
+		if (index >= values.length) invalid();
+		const value = values[index];
+		if (!value || typeof value !== "object") hydrated[index] = ops.fromPrimitive(value);
+		else if (Array.isArray(value)) if (typeof value[0] === "string") {
+			const type = value[0];
+			const reviver = revivers && Object.hasOwn(revivers, type) ? revivers[type] : void 0;
+			if (reviver) {
+				let i = value[1];
+				if (typeof i !== "number") i = values.push(value[1]) - 1;
+				if (Object.hasOwn(hydrated, i)) return hydrated[index] = reviver(hydrated[i]);
+				hydrating ??= /* @__PURE__ */ new Set();
+				if (hydrating.has(i)) throw new Error("Invalid circular reference");
+				hydrating.add(i);
+				hydrated[index] = reviver(hydrate(i));
+				hydrating.delete(i);
+				return hydrated[index];
+			}
+			switch (type) {
+				case "Date":
+					hydrated[index] = ops.fromISOString(value[1]);
+					break;
+				case "Set":
+					const set = ops.createSet();
+					hydrated[index] = set;
+					for (let i = 1; i < value.length; i += 1) ops.addValue(set, hydrate(value[i]));
+					break;
+				case "Map":
+					const map = ops.createMap();
+					hydrated[index] = map;
+					for (let i = 1; i < value.length; i += 2) ops.addEntry(map, hydrate(value[i]), hydrate(value[i + 1]));
+					break;
+				case "RegExp":
+					hydrated[index] = ops.fromRegExpInfo(value[1], value[2]);
+					break;
+				case "Object": {
+					const wrapped_index = value[1];
+					if (!(wrapped_index === -3 || wrapped_index === -4 || wrapped_index === -5 || wrapped_index === -6)) {
+						const wrapped = get_raw(wrapped_index);
+						const is_bigint = Array.isArray(wrapped) && wrapped[0] === "BigInt";
+						if ((wrapped === void 0 || typeof wrapped === "object") && !is_bigint) invalid();
+					}
+					hydrated[index] = ops.box(hydrate(wrapped_index));
+					break;
+				}
+				case "BigInt":
+					hydrated[index] = ops.fromPrimitive(BigInt(value[1]));
+					break;
+				case "null":
+					const obj = ops.createNullPrototypeObject();
+					hydrated[index] = obj;
+					for (let i = 1; i < value.length; i += 2) {
+						const key = value[i];
+						if (typeof key !== "string") throw new Error("Cannot parse an object with a non-string key");
+						if (key === "__proto__") throw new Error("Cannot parse an object with a `__proto__` property");
+						ops.set(obj, key, hydrate(value[i + 1]));
+					}
+					break;
+				case "Int8Array":
+				case "Uint8Array":
+				case "Uint8ClampedArray":
+				case "Int16Array":
+				case "Uint16Array":
+				case "Float16Array":
+				case "Int32Array":
+				case "Uint32Array":
+				case "Float32Array":
+				case "Float64Array":
+				case "BigInt64Array":
+				case "BigUint64Array":
+				case "DataView": {
+					const buffer_index = value[1];
+					const raw = get_raw(buffer_index);
+					if (!Array.isArray(raw) || raw[0] !== "ArrayBuffer") invalid();
+					const buffer = hydrate(buffer_index);
+					hydrated[index] = ops.fromViewInfo(type, buffer, value[2], value[3]);
+					break;
+				}
+				case "ArrayBuffer": {
+					const base64 = value[1];
+					if (typeof base64 !== "string") throw new Error("Invalid ArrayBuffer encoding");
+					hydrated[index] = ops.fromArrayBuffer(decode64(base64));
+					break;
+				}
+				case "URL":
+				case "URLSearchParams":
+				case "Temporal.Duration":
+				case "Temporal.Instant":
+				case "Temporal.PlainDate":
+				case "Temporal.PlainTime":
+				case "Temporal.PlainDateTime":
+				case "Temporal.PlainMonthDay":
+				case "Temporal.PlainYearMonth":
+				case "Temporal.ZonedDateTime":
+					hydrated[index] = ops.fromStringValue(type, value[1]);
+					break;
+				default: throw new Error(`Unknown type ${type}`);
+			}
+		} else if (value[0] === -7) {
+			const len = value[1];
+			if (!is_valid_array_len(len)) invalid();
+			const array = ops.createSparseArray(len);
+			hydrated[index] = array;
+			for (let i = 2; i < value.length; i += 2) {
+				const idx = value[i];
+				if (!is_valid_array_index(idx) || idx >= len) invalid();
+				ops.set(array, idx, hydrate(value[i + 1]));
+			}
+		} else {
+			const array = ops.createArray(value.length);
+			hydrated[index] = array;
+			for (let i = 0; i < value.length; i += 1) {
+				const n = value[i];
+				if (n === -2) continue;
+				ops.set(array, i, hydrate(n));
+			}
+		}
+		else {
+			const object = ops.createObject();
+			hydrated[index] = object;
+			for (const key of Object.keys(value)) {
+				if (key === "__proto__") throw new Error("Cannot parse an object with a `__proto__` property");
+				ops.set(object, key, hydrate(value[key]));
+			}
+		}
+		return hydrated[index];
+	}
+	return hydrate(0);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/devalue@6.0.2/node_modules/devalue/src/stringify.js
+/**
+* Turn a value into a JSON string that can be parsed with `devalue.parse`
+* @param {any} value
+* @param {Record<string, (value: any) => any>} [reducers]
+* @param {import('./types.js').StringifyOptions} [options]
+*/
+function stringify(value, reducers, options) {
+	const stringified = run(false, value, reducers, options);
+	return typeof stringified === "string" ? stringified : `[${stringified.join(",")}]`;
+}
+/**
+* @param {boolean} async
+* @param {any} value
+* @param {Record<string, (value: any) => any>} [reducers]
+* @param {import('./types.js').StringifyOptions} [options]
+*/
+function run(async, value, reducers, options) {
+	const ops = merge_operations(default_stringify_operations, options?.operations);
+	/** @type {any[]} */
+	const stringified = [];
+	/** @type {Map<any, number>} */
+	const indexes = /* @__PURE__ */ new Map();
+	/** @type {Array<{ key: string, fn: (value: any) => any }>} */
+	const custom = [];
+	if (reducers) for (const key of Object.getOwnPropertyNames(reducers)) custom.push({
+		key,
+		fn: reducers[key]
+	});
+	/** @type {any[]} */
+	let keys = [];
+	let p = 0;
+	/**
+	* @param {string} message
+	* @param {any} thing
+	* @returns {never}
+	*/
+	function error(message, thing) {
+		throw new DevalueError(message, format_path(keys, (key) => {
+			const key_type = ops.typeOf(key);
+			return key_type !== "object" && key_type !== "function" && key_type !== "symbol" ? stringify_primitive(ops.toPrimitive(key)) : "...";
+		}), thing, value);
+	}
+	/**
+	* @param {any} thing
+	* @param {number} [index]
+	*/
+	function flatten(thing, index) {
+		const type = ops.typeOf(thing);
+		if (type === "undefined") return -1;
+		/** @type {number | undefined} */
+		let number;
+		if (type === "number") {
+			number = ops.toPrimitive(thing);
+			if (Number.isNaN(number)) return -3;
+			if (number === Infinity) return -4;
+			if (number === -Infinity) return -5;
+			if (number === 0 && 1 / number < 0) return -6;
+		}
+		const id = ops.identify(thing);
+		if (indexes.has(id)) return indexes.get(id);
+		index ??= p++;
+		indexes.set(id, index);
+		for (const { key, fn } of custom) {
+			const value = fn(thing);
+			if (value) {
+				stringified[index] = `["${key}",${flatten(value)}]`;
+				return index;
+			}
+		}
+		if (type === "function") error(`Cannot stringify a function`, thing);
+		else if (type === "symbol") error(`Cannot stringify a Symbol primitive`, thing);
+		/** @type {string | Promise<any>} */
+		let str = "";
+		if (type !== "object") str = stringify_primitive(type === "number" ? number : ops.toPrimitive(thing));
+		else if (ops.isThenable(thing)) {
+			if (!async) error(`Cannot stringify a Promise or thenable — use stringifyAsync instead`, thing);
+			const prev_keys = keys.slice();
+			str = ops.toPromise(thing).then((value) => {
+				keys = prev_keys;
+				const i = flatten(value, index);
+				if (i < 0) stringified[index] = i;
+			});
+			str.catch(() => {});
+		} else {
+			const tag = ops.tagOf(thing);
+			switch (tag) {
+				case "Number":
+				case "String":
+				case "Boolean":
+				case "BigInt":
+					str = `["Object",${flatten(ops.unbox(thing))}]`;
+					break;
+				case "Date":
+					str = `["Date","${ops.toISOString(thing)}"]`;
+					break;
+				case "URL":
+					str = `["URL",${stringify_string(ops.toStringValue(thing))}]`;
+					break;
+				case "URLSearchParams":
+					str = `["URLSearchParams",${stringify_string(ops.toStringValue(thing))}]`;
+					break;
+				case "RegExp":
+					const { source, flags } = ops.regExpInfo(thing);
+					str = flags ? `["RegExp",${stringify_string(source)},"${flags}"]` : `["RegExp",${stringify_string(source)}]`;
+					break;
+				case "Array": {
+					let mostly_dense = false;
+					const length = ops.lengthOf(thing);
+					str = "[";
+					for (let i = 0; i < length; i += 1) {
+						if (i > 0) str += ",";
+						if (ops.hasOwn(thing, i)) {
+							keys.push(i);
+							str += flatten(ops.get(thing, i));
+							keys.pop();
+						} else if (mostly_dense) str += -2;
+						else {
+							const populated_keys = ops.indicesOf(thing);
+							const population = populated_keys.length;
+							const d = String(length).length;
+							if ((length - population) * 3 > 4 + d + population * (d + 1)) {
+								str = "[-7," + length;
+								for (let j = 0; j < populated_keys.length; j++) {
+									const key = populated_keys[j];
+									keys.push(+key);
+									str += "," + key + "," + flatten(ops.get(thing, key));
+									keys.pop();
+								}
+								break;
+							} else {
+								mostly_dense = true;
+								str += -2;
+							}
+						}
+					}
+					str += "]";
+					break;
+				}
+				case "Set":
+					str = "[\"Set\"";
+					for (const value of ops.valuesOf(thing)) str += `,${flatten(value)}`;
+					str += "]";
+					break;
+				case "Map":
+					str = "[\"Map\"";
+					for (const [key, value] of ops.entriesOf(thing)) {
+						keys.push(MAP_KEY, key);
+						str += `,${flatten(key)},${flatten(value)}`;
+						keys.pop();
+						keys.pop();
+					}
+					str += "]";
+					break;
+				case "Int8Array":
+				case "Uint8Array":
+				case "Uint8ClampedArray":
+				case "Int16Array":
+				case "Uint16Array":
+				case "Float16Array":
+				case "Int32Array":
+				case "Uint32Array":
+				case "Float32Array":
+				case "Float64Array":
+				case "BigInt64Array":
+				case "BigUint64Array": {
+					const info = ops.viewInfo(thing);
+					str = "[\"" + tag + "\"," + flatten(info.buffer);
+					if (info.byteLength !== info.bufferByteLength) str += `,${info.byteOffset},${info.length}`;
+					str += "]";
+					break;
+				}
+				case "DataView": {
+					const info = ops.viewInfo(thing);
+					str = "[\"" + tag + "\"," + flatten(info.buffer);
+					if (info.byteLength !== info.bufferByteLength) str += `,${info.byteOffset},${info.byteLength}`;
+					str += "]";
+					break;
+				}
+				case "ArrayBuffer":
+					str = `["ArrayBuffer","${encode64(ops.toArrayBuffer(thing))}"]`;
+					break;
+				case "Temporal.Duration":
+				case "Temporal.Instant":
+				case "Temporal.PlainDate":
+				case "Temporal.PlainTime":
+				case "Temporal.PlainDateTime":
+				case "Temporal.PlainMonthDay":
+				case "Temporal.PlainYearMonth":
+				case "Temporal.ZonedDateTime":
+					str = `["${tag}",${stringify_string(ops.toStringValue(thing))}]`;
+					break;
+				default: {
+					const shape = ops.shapeOf(thing);
+					if (shape.kind === "not-plain") error(`Cannot stringify arbitrary non-POJOs`, thing);
+					if (shape.kind === "symbol-keys") error(`Cannot stringify POJOs with symbolic keys`, thing);
+					if (shape.kind === "null-proto") {
+						str = "[\"null\"";
+						for (const key of shape.keys) {
+							if (key === "__proto__") error(`Cannot stringify objects with __proto__ keys`, thing);
+							keys.push(key);
+							str += `,${quote_key(key)},${flatten(ops.get(thing, key))}`;
+							keys.pop();
+						}
+						str += "]";
+					} else {
+						str = "{";
+						let started = false;
+						for (const key of shape.keys) {
+							if (key === "__proto__") error(`Cannot stringify objects with __proto__ keys`, thing);
+							if (started) str += ",";
+							started = true;
+							keys.push(key);
+							str += `${quote_key(key)}:${flatten(ops.get(thing, key))}`;
+							keys.pop();
+						}
+						str += "}";
+					}
+				}
+			}
+		}
+		stringified[index] = str;
+		return index;
+	}
+	const index = flatten(value);
+	if (index < 0) return `${index}`;
+	return stringified;
+}
+/**
+* @param {any} thing
+* @returns {string}
+*/
+function stringify_primitive(thing) {
+	const type = typeof thing;
+	if (type === "string") return stringify_string(thing);
+	if (thing === void 0) return (-1).toString();
+	if (thing === 0 && 1 / thing < 0) return (-6).toString();
+	if (type === "bigint") return `["BigInt","${thing}"]`;
+	return String(thing);
+}
+//#endregion
+//#region src/shared/values.ts
+/** Encodes supported values without reducers, preserving presence and graph references. */
+function encode(value) {
+	return stringify(value);
+}
+const pathSegment = /^(?:\.get\(("(?:[^"\\]|\\.)*"|[^)]*)\)|\.([A-Za-z_$][\w$]*)|\[(\d+)\]|\[("(?:[^"\\]|\\.)*")\])/;
+/**
+* Converts devalue's formatted error path, such as `.tags[0]` or `.map.get("key")`, into
+* property segments. Map entries are identified by their key; unparsable text is kept whole.
+*/
+function valuePath(formatted) {
+	const segments = [];
+	let rest = formatted;
+	while (rest) {
+		const match = pathSegment.exec(rest);
+		if (!match) return [formatted];
+		const [text, mapKey, identifier, index, quoted] = match;
+		if (identifier !== void 0) segments.push(identifier);
+		else if (index !== void 0) segments.push(Number(index));
+		else if (quoted !== void 0) segments.push(JSON.parse(quoted));
+		else {
+			const key = mapKey;
+			segments.push(key.startsWith("\"") ? JSON.parse(key) : /^-?\d+(?:\.\d+)?$/.test(key) ? Number(key) : key);
+		}
+		rest = rest.slice(text.length);
+	}
+	return segments;
+}
+/** Restores supported values without invoking application schemas or transforms. */
+function decode(encoded) {
+	return parse(encoded);
+}
+/** Reads the built-in tag that the encoder uses to choose a value's encoding. */
+function tagOf(value) {
+	return Object.prototype.toString.call(value);
+}
+/** Marks a graph that only the general encode/decode round trip can detach faithfully. */
+const general = Symbol("general");
+/**
+* Copies a graph of primitives, plain or null-prototype objects, dense arrays, and dates
+* directly. Each object must pass the same tag, thenable, symbol-key, and `__proto__` checks
+* that the encoder applies; objects and dates also need their standard prototype. The encoder
+* reads any array-tagged value by index, so array subclasses and arrays from other realms
+* copy into ordinary arrays either way. Anything else returns `general` so the caller detaches
+* the whole graph through devalue, which keeps aliases consistent across rich values and
+* reports unsupported values with their paths.
+*/
+function copyDirect(value, copies) {
+	if (typeof value !== "object" || value === null) return typeof value === "function" || typeof value === "symbol" ? general : value;
+	const existing = copies.get(value);
+	if (existing !== void 0) return existing;
+	if (typeof value.then === "function") return general;
+	const tag = tagOf(value);
+	if (tag === "[object Array]") {
+		const source = value;
+		const copy = [];
+		copies.set(value, copy);
+		for (let index = 0; index < source.length; index++) {
+			const item = source[index];
+			if (item === void 0 && !Object.hasOwn(source, index)) return general;
+			const copied = copyDirect(item, copies);
+			if (copied === general) return general;
+			copy.push(copied);
+		}
+		return copy;
+	}
+	const prototype = Object.getPrototypeOf(value);
+	if (tag === "[object Object]" && (prototype === Object.prototype || prototype === null)) {
+		if (Object.getOwnPropertySymbols(value).length) return general;
+		const source = value;
+		const copy = prototype === null ? Object.create(null) : {};
+		copies.set(value, copy);
+		for (const key of Object.keys(source)) {
+			if (key === "__proto__") return general;
+			const copied = copyDirect(source[key], copies);
+			if (copied === general) return general;
+			copy[key] = copied;
+		}
+		return copy;
+	}
+	if (tag === "[object Date]" && prototype === Date.prototype) {
+		const copy = new Date(value.getTime());
+		copies.set(value, copy);
+		return copy;
+	}
+	return general;
+}
+/**
+* Detaches an entire value graph with the supported-value semantics, preserving cycles and
+* repeated references. Graphs of primitives, plain objects, dense arrays, and dates are copied
+* directly; any other graph, including one containing a `Map`, an array hole, or an unsupported
+* value, takes the devalue encode/decode round trip as a whole, which throws for unsupported
+* values. Getters on a graph that falls back can therefore be read twice.
+*
+* @param value - The value to copy; it is never modified.
+* @returns An independent copy that callers can mutate without affecting `value`.
+*/
+function detach(value) {
+	const copied = copyDirect(value, /* @__PURE__ */ new Map());
+	return copied === general ? decode(encode(value)) : copied;
+}
+/**
+* Detaches the named fields of one record together, so references shared between selected
+* fields remain shared in the result. Every name becomes an own enumerable property, including
+* `__proto__`, and missing fields become own `undefined` values. Each field is read once.
+*
+* @param record - The stored record to read; it is never modified.
+* @param fields - The selected field names, in result order.
+* @returns A new object containing detached copies of the selected values.
+*/
+function detachSelection(record, fields) {
+	const values = fields.map((field) => Object.hasOwn(record, field) ? record[field] : void 0);
+	const copies = /* @__PURE__ */ new Map();
+	const selection = {};
+	for (let index = 0; index < fields.length; index++) {
+		const copied = copyDirect(values[index], copies);
+		if (copied === general) return Object.fromEntries(decode(encode(new Map(fields.map((field, position) => [field, values[position]])))));
+		const field = fields[index];
+		if (field === "__proto__") Object.defineProperty(selection, field, {
+			value: copied,
+			enumerable: true,
+			configurable: true,
+			writable: true
+		});
+		else selection[field] = copied;
+	}
+	return selection;
+}
+/** Compares strings by Unicode code point rather than locale or UTF-16 code unit. */
+function compareStrings(left, right) {
+	const leftPoints = Array.from(left, (character) => character.codePointAt(0));
+	const rightPoints = Array.from(right, (character) => character.codePointAt(0));
+	for (let index = 0; index < Math.min(leftPoints.length, rightPoints.length); index++) if (leftPoints[index] !== rightPoints[index]) return leftPoints[index] < rightPoints[index] ? -1 : 1;
+	return Math.sign(leftPoints.length - rightPoints.length);
+}
+/** Tests the scalar categories accepted by equality and relationship matching. */
+function isScalar(value) {
+	return value == null || [
+		"string",
+		"number",
+		"bigint",
+		"boolean"
+	].includes(typeof value) || value instanceof Date;
+}
+/** Applies scalar equality with date timestamps and SameValueZero numeric behavior. */
+function equal(left, right) {
+	if (left instanceof Date || right instanceof Date) return left instanceof Date && right instanceof Date && equal(left.getTime(), right.getTime());
+	return left === right || typeof left === "number" && typeof right === "number" && Number.isNaN(left) && Number.isNaN(right);
+}
+/** Orders comparable scalar values; undefined denotes incomparable values. */
+function compare(left, right) {
+	if (left == null || right == null) return;
+	if (left instanceof Date || right instanceof Date) return left instanceof Date && right instanceof Date ? compare(left.getTime(), right.getTime()) : void 0;
+	if (typeof left !== typeof right) return;
+	if (typeof left === "string" && typeof right === "string") return compareStrings(left, right);
+	if (typeof left === "number" && typeof right === "number" || typeof left === "bigint" && typeof right === "bigint" || typeof left === "boolean" && typeof right === "boolean") {
+		if (typeof left === "number" && (Number.isNaN(left) || Number.isNaN(right))) return;
+		return left < right ? -1 : left > right ? 1 : 0;
+	}
+}
+//#endregion
+export { detachSelection as a, isScalar as c, detach as i, valuePath as l, compareStrings as n, encode as o, decode as r, equal as s, compare as t };