@sentropic/h2a 0.97.0 → 0.97.2

package/focus-app/server/chunks/chunks/{utils.js-h3jETFNR.js → utils.js-Bzpr6vQU.js}

@@ -493,17 +493,25 @@ function is_valid_array_index_string(s) {
 }
 
 /**
- * Finds the populated indices of an array.
- * @param {unknown[]} array
+ * Returns the length of the leading run of valid array indices in `keys`.
+ * @param {readonly string[]} keys
  */
-function valid_array_indices(array) {
-	const keys = Object.keys(array);
+function array_index_cut(keys) {
 	for (var i = keys.length - 1; i >= 0; i--) {
 		if (is_valid_array_index_string(keys[i])) {
 			break;
 		}
 	}
-	keys.length = i + 1;
+	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;
 }
 
@@ -576,6 +584,7 @@ function uneval(value, replacer) {
 				case 'Map':
 					for (const [key, value] of thing) {
 						keys.push(`.get(${is_primitive(key) ? stringify_primitive$1(key) : '...'})`);
+						walk(key);
 						walk(value);
 						keys.pop();
 					}
@@ -757,9 +766,7 @@ function uneval(value, replacer) {
 							return `Object.assign(Array(${thing.length}),{${entries}})`;
 						}
 
-						// Re-process this index as a hole in the array literal
 						has_holes = true;
-						i -= 1;
 					}
 					// else: already decided on array literal, hole is just an empty slot
 					// (the comma separator is all we need — no content for this position)
@@ -788,8 +795,7 @@ function uneval(value, replacer) {
 				let str = `new ${type}`;
 
 				if (!names.has(thing.buffer)) {
-					const array = new thing.constructor(thing.buffer);
-					str += `([${array}])`;
+					str += `([${stringify_typed_array_elements(type, thing.buffer)}])`;
 				} else {
 					str += `(${stringify(thing.buffer)})`;
 				}
@@ -815,7 +821,7 @@ function uneval(value, replacer) {
 
 				// handle subviews
 				if (thing.byteLength !== thing.buffer.byteLength) {
-					str += `,${thing.startOffset},${thing.byteLength}`;
+					str += `,${thing.byteOffset},${thing.byteLength}`;
 				}
 
 				return str + ')';
@@ -860,6 +866,13 @@ function uneval(value, replacer) {
 		/** @type {string[]} */
 		const values = [];
 
+		// Reconstructions (e.g. `b = new Uint8Array(...)`) reassign a placeholder
+		// parameter. They must run before the `statements` that reference them,
+		// otherwise those statements capture the placeholder. They only depend on
+		// IIFE arguments (never on each other), so emitting them first is safe.
+		/** @type {string[]} */
+		const reconstructions = [];
+
 		names.forEach((name, thing) => {
 			params.push(name);
 
@@ -910,23 +923,23 @@ function uneval(value, replacer) {
 					});
 					break;
 
-				case 'Set':
+				case 'Set': {
 					values.push(`new Set`);
-					statements.push(
-						`${name}.${Array.from(thing)
-							.map((v) => `add(${stringify(v)})`)
-							.join('.')}`
-					);
+					const adds = Array.from(thing).map((v) => `.add(${stringify(v)})`);
+					// An empty Set is fully built by `new Set`; a chained statement would
+					// otherwise be a dangling `name.`.
+					if (adds.length > 0) statements.push(name + adds.join(''));
 					break;
+				}
 
-				case 'Map':
+				case 'Map': {
 					values.push(`new Map`);
-					statements.push(
-						`${name}.${Array.from(thing)
-							.map(([k, v]) => `set(${stringify(k)}, ${stringify(v)})`)
-							.join('.')}`
+					const sets = Array.from(thing).map(
+						([k, v]) => `.set(${stringify(k)}, ${stringify(v)})`
 					);
+					if (sets.length > 0) statements.push(name + sets.join(''));
 					break;
+				}
 
 				case 'Int8Array':
 				case 'Uint8Array':
@@ -943,8 +956,7 @@ function uneval(value, replacer) {
 					let str = `new ${type}`;
 
 					if (!names.has(thing.buffer)) {
-						const array = new thing.constructor(thing.buffer);
-						str += `([${array}])`;
+						str += `([${stringify_typed_array_elements(type, thing.buffer)}])`;
 					} else {
 						str += `(${stringify(thing.buffer)})`;
 					}
@@ -957,7 +969,7 @@ function uneval(value, replacer) {
 					}
 
 					values.push(`{}`);
-					statements.push(`${name}=${str}`);
+					reconstructions.push(`${name}=${str}`);
 					break;
 				}
 
@@ -978,7 +990,7 @@ function uneval(value, replacer) {
 					str += ')';
 
 					values.push(`{}`);
-					statements.push(`${name}=${str}`);
+					reconstructions.push(`${name}=${str}`);
 					break;
 				}
 
@@ -986,6 +998,17 @@ function uneval(value, replacer) {
 					values.push(`new Uint8Array([${new Uint8Array(thing)}]).buffer`);
 					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':
+					values.push(`${type}.from(${stringify_string(thing.toString())})`);
+					break;
+
 				default:
 					values.push(Object.getPrototypeOf(thing) === null ? 'Object.create(null)' : '{}');
 					Object.keys(thing).forEach((key) => {
@@ -996,12 +1019,51 @@ function uneval(value, replacer) {
 
 		statements.push(`return ${str}`);
 
-		return `(function(${params.join(',')}){${statements.join(';')}}(${values.join(',')}))`;
+		const body = [...reconstructions, ...statements].join(';');
+		// A function may have at most 65535 parameters (and a call at most that
+		// many arguments). For very large graphs, pass the hoisted values as a
+		// single array argument and destructure them into the placeholder names,
+		// so the emitted code stays within the engine limit (#93).
+		if (params.length > 65534) {
+			return `(function(){var[${params.join(',')}]=arguments[0];${body}}([${values.join(',')}]))`;
+		}
+
+		return `(function(${params.join(',')}){${body}}(${values.join(',')}))`;
 	} else {
 		return str;
 	}
 }
 
+/**
+ * Serialize the elements of `buffer`, read as `type`, as a comma-separated list.
+ * The view is created from `type` rather than from the serialized value's own
+ * constructor, which may be a subclass like Node's `Buffer` whose `toString`
+ * decodes the bytes instead of listing them.
+ * `BigInt64Array`/`BigUint64Array` elements are bigints and must be written
+ * with an `n` suffix, otherwise the emitted `new BigInt64Array([...])` throws.
+ * @param {string} type
+ * @param {ArrayBufferLike} buffer
+ */
+function stringify_typed_array_elements(type, buffer) {
+	const array = new (/** @type {any} */ (globalThis)[type])(buffer);
+
+	if (type === 'BigInt64Array' || type === 'BigUint64Array') {
+		return Array.from(array, (element) => `${element}n`).join(',');
+	}
+
+	// Float arrays can hold `-0`, which `toString()` collapses to `"0"`, silently
+	// losing the sign on round-trip. Emit `-0` explicitly for those elements.
+	if (
+		array instanceof Float32Array ||
+		array instanceof Float64Array ||
+		(typeof Float16Array !== 'undefined' && array instanceof Float16Array)
+	) {
+		return Array.from(array, (element) => (Object.is(element, -0) ? '-0' : `${element}`)).join(',');
+	}
+
+	return array.toString();
+}
+
 /** @param {number} num */
 function get_name(num) {
 	let name = '';
@@ -1109,12 +1171,191 @@ const buffer = typeof process === 'object' && process.versions?.node !== undefin
 const encode64 = native ? encode_native : buffer ? encode_buffer : encode_legacy;
 const decode64 = native ? decode_native : buffer ? decode_buffer : decode_legacy;
 
+/**
+ * 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) {
+	return defaults;
+}
+
+/** @type {{ kind: 'not-plain' }} */
+const NOT_PLAIN = Object.freeze({ kind: 'not-plain' });
+
+/** @type {{ kind: 'symbol-keys' }} */
+const SYMBOL_KEYS = Object.freeze({ kind: 'symbol-keys' });
+
+/**
+ * The default implementations of every introspection/extraction operation
+ * `stringify` performs on the value being serialized. Each one uses native
+ * JavaScript semantics (property access, iteration, prototype methods, etc).
+ *
+ * Pass overrides via the `operations` option of `stringify`/`stringifyAsync`
+ * to customize how values are inspected — e.g. to serialize values without
+ * triggering getters, proxy traps, or patched prototype methods, or to
+ * serialize values that live in a different JavaScript runtime (a `node:vm`
+ * context, a WASM-hosted engine, a remote process) through handle objects.
+ *
+ * The object is frozen — it is shared by every `stringify` call that does
+ * not override a given operation.
+ *
+ */
+/** @type {import('./types.js').DefaultStringifyOperations} */
+const stringify_operations = {
+	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) => ({
+		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 default_stringify_operations = Object.freeze(stringify_operations);
+
+/**
+ * The default implementations of every construction operation `parse` and
+ * `unflatten` perform while reviving a value. Each one uses native
+ * JavaScript semantics (built-in constructors, property assignment, etc).
+ *
+ * Pass overrides via the `operations` option of `parse`/`unflatten` to
+ * customize how values are built — e.g. to construct them from the
+ * intrinsics of a different realm (a `node:vm` context), or to build up
+ * values inside another JavaScript runtime (a WASM-hosted engine, a remote
+ * process) through handle objects.
+ *
+ * The object is frozen — it is shared by every `parse` call that does not
+ * override a given operation.
+ *
+ */
+/** @type {import('./types.js').DefaultParseOperations} */
+const parse_operations = {
+	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);
+		// 'Temporal.Instant', 'Temporal.PlainDate', ...
+		// @ts-expect-error TS doesn't know about Temporal yet
+		return Temporal[tag.slice(9)].from(text);
+	},
+
+	fromArrayBuffer: (buffer) => buffer,
+
+	fromRegExpInfo: (source, flags) => new RegExp(source, flags),
+
+	fromViewInfo: (tag, buffer, byteOffset, length) => {
+		const Constructor = /** @type {any} */ (globalThis)[tag];
+		return byteOffset !== undefined
+			? new Constructor(buffer, byteOffset, length)
+			: new Constructor(buffer);
+	},
+
+	box: (value) => Object(value),
+
+	createArray: (length) => new Array(length),
+
+	createSparseArray: (length) => {
+		/** @type {any[]} */
+		const array = [];
+
+		// Setting `array.length = length` (or equivalently calling
+		// `new Array(length)`) on an untrusted length is a DoS vector: V8
+		// eagerly allocates a contiguous backing store for array lengths below
+		// ~10^8, so a small payload with a huge declared length can force
+		// arbitrary memory allocation. Touching the largest-possible index
+		// first forces V8 into dictionary-elements mode, where `length` is
+		// just a number and no contiguous allocation occurs.
+		array[MAX_ARRAY_INDEX] = undefined;
+		delete array[MAX_ARRAY_INDEX];
+		array.length = length;
+
+		return array;
+	},
+
+	createObject: () => ({}),
+
+	createNullPrototypeObject: () => Object.create(null),
+
+	createSet: () => new Set(),
+
+	createMap: () => new Map(),
+
+	set: (target, key, value) => {
+		target[key] = value;
+	},
+
+	addValue: (set, value) => {
+		set.add(value);
+	},
+
+	addEntry: (map, key, value) => {
+		map.set(key, value);
+	}
+};
+
+const default_parse_operations = Object.freeze(parse_operations);
+
 /**
  * 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) {
+function parse(serialized, revivers, options) {
 	return unflatten(JSON.parse(serialized), revivers);
 }
 
@@ -1122,8 +1363,12 @@ function parse(serialized, revivers) {
  * 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) {
+function unflatten(parsed, revivers, options) {
+	/** @type {import('./types.js').ParseOperations} */
+	const ops = merge_operations(default_parse_operations);
+
 	if (typeof parsed === 'number') return hydrate(parsed, true);
 
 	if (!Array.isArray(parsed) || parsed.length === 0) {
@@ -1146,11 +1391,11 @@ function unflatten(parsed, revivers) {
 	 * @returns {any}
 	 */
 	function hydrate(index, standalone = false) {
-		if (index === UNDEFINED) return undefined;
-		if (index === NAN) return NaN;
-		if (index === POSITIVE_INFINITY) return Infinity;
-		if (index === NEGATIVE_INFINITY) return -Infinity;
-		if (index === NEGATIVE_ZERO) return -0;
+		if (index === UNDEFINED) return ops.fromPrimitive(undefined);
+		if (index === NAN) return ops.fromPrimitive(NaN);
+		if (index === POSITIVE_INFINITY) return ops.fromPrimitive(Infinity);
+		if (index === NEGATIVE_INFINITY) return ops.fromPrimitive(-Infinity);
+		if (index === NEGATIVE_ZERO) return ops.fromPrimitive(-0);
 
 		if (standalone || typeof index !== 'number') {
 			throw new Error(`Invalid input`);
@@ -1158,10 +1403,14 @@ function unflatten(parsed, revivers) {
 
 		if (index in hydrated) return hydrated[index];
 
+		if (index >= values.length) {
+			throw new Error(`Invalid input`);
+		}
+
 		const value = values[index];
 
 		if (!value || typeof value !== 'object') {
-			hydrated[index] = value;
+			hydrated[index] = ops.fromPrimitive(value);
 		} else if (Array.isArray(value)) {
 			if (typeof value[0] === 'string') {
 				const type = value[0];
@@ -1176,6 +1425,16 @@ function unflatten(parsed, revivers) {
 						i = values.push(value[1]) - 1;
 					}
 
+					// If the payload is already hydrated, its recursion has already
+					// terminated (e.g. a self-referential object cached itself before
+					// following its own back-reference), so revive it directly. Falling
+					// through to the `hydrating` guard here would wrongly reject a valid
+					// cycle. An actually infinite payload (e.g. `[["Custom", 0]]`) is never
+					// cached, so it still hits the guard below.
+					if (Object.hasOwn(hydrated, i)) {
+						return (hydrated[index] = reviver(hydrated[i]));
+					}
+
 					hydrating ??= new Set();
 
 					if (hydrating.has(i)) {
@@ -1191,27 +1450,27 @@ function unflatten(parsed, revivers) {
 
 				switch (type) {
 					case 'Date':
-						hydrated[index] = new Date(value[1]);
+						hydrated[index] = ops.fromISOString(value[1]);
 						break;
 
 					case 'Set':
-						const set = new Set();
+						const set = ops.createSet();
 						hydrated[index] = set;
 						for (let i = 1; i < value.length; i += 1) {
-							set.add(hydrate(value[i]));
+							ops.addValue(set, hydrate(value[i]));
 						}
 						break;
 
 					case 'Map':
-						const map = new Map();
+						const map = ops.createMap();
 						hydrated[index] = map;
 						for (let i = 1; i < value.length; i += 2) {
-							map.set(hydrate(value[i]), hydrate(value[i + 1]));
+							ops.addEntry(map, hydrate(value[i]), hydrate(value[i + 1]));
 						}
 						break;
 
 					case 'RegExp':
-						hydrated[index] = new RegExp(value[1], value[2]);
+						hydrated[index] = ops.fromRegExpInfo(value[1], value[2]);
 						break;
 
 					case 'Object': {
@@ -1225,23 +1484,23 @@ function unflatten(parsed, revivers) {
 							throw new Error('Invalid input');
 						}
 
-						hydrated[index] = Object(hydrate(wrapped_index));
+						hydrated[index] = ops.box(hydrate(wrapped_index));
 						break;
 					}
 
 					case 'BigInt':
-						hydrated[index] = BigInt(value[1]);
+						hydrated[index] = ops.fromPrimitive(BigInt(value[1]));
 						break;
 
 					case 'null':
-						const obj = Object.create(null);
+						const obj = ops.createNullPrototypeObject();
 						hydrated[index] = obj;
 						for (let i = 1; i < value.length; i += 2) {
 							if (value[i] === '__proto__') {
 								throw new Error('Cannot parse an object with a `__proto__` property');
 							}
 
-							obj[value[i]] = hydrate(value[i + 1]);
+							ops.set(obj, value[i], hydrate(value[i + 1]));
 						}
 						break;
 
@@ -1265,13 +1524,9 @@ function unflatten(parsed, revivers) {
 							throw new Error('Invalid data');
 						}
 
-						const TypedArrayConstructor = globalThis[type];
 						const buffer = hydrate(value[1]);
 
-						hydrated[index] =
-							value[2] !== undefined
-								? new TypedArrayConstructor(buffer, value[2], value[3])
-								: new TypedArrayConstructor(buffer);
+						hydrated[index] = ops.fromViewInfo(type, buffer, value[2], value[3]);
 
 						break;
 					}
@@ -1281,11 +1536,12 @@ function unflatten(parsed, revivers) {
 						if (typeof base64 !== 'string') {
 							throw new Error('Invalid ArrayBuffer encoding');
 						}
-						const arraybuffer = decode64(base64);
-						hydrated[index] = arraybuffer;
+						hydrated[index] = ops.fromArrayBuffer(decode64(base64));
 						break;
 					}
 
+					case 'URL':
+					case 'URLSearchParams':
 					case 'Temporal.Duration':
 					case 'Temporal.Instant':
 					case 'Temporal.PlainDate':
@@ -1294,21 +1550,8 @@ function unflatten(parsed, revivers) {
 					case 'Temporal.PlainMonthDay':
 					case 'Temporal.PlainYearMonth':
 					case 'Temporal.ZonedDateTime': {
-						const temporalName = type.slice(9);
-						// @ts-expect-error TS doesn't know about Temporal yet
-						hydrated[index] = Temporal[temporalName].from(value[1]);
-						break;
-					}
-
-					case 'URL': {
-						const url = new URL(value[1]);
-						hydrated[index] = url;
-						break;
-					}
-
-					case 'URLSearchParams': {
-						const url = new URLSearchParams(value[1]);
-						hydrated[index] = url;
+						// the same tags `toStringValue` serializes on the stringify side
+						hydrated[index] = ops.fromStringValue(type, value[1]);
 						break;
 					}
 
@@ -1323,20 +1566,12 @@ function unflatten(parsed, revivers) {
 					throw new Error('Invalid input');
 				}
 
-				/** @type {any[]} */
-				const array = [];
+				// `len` comes from the input rather than being bounded by it, so
+				// `createSparseArray` is responsible for not allocating storage
+				// proportional to it.
+				const array = ops.createSparseArray(len);
 				hydrated[index] = array;
 
-				// Setting `array.length = len` (or equivalently calling `new Array(len)`)
-				// on an untrusted `len` is a DoS vector: V8 eagerly allocates a
-				// contiguous backing store for array lengths below ~10^8, so a
-				// small payload with a huge declared length can force arbitrary
-				// memory allocation. Touching the largest-possible index first
-				// forces V8 into dictionary-elements mode, where `length` is
-				// just a number and no contiguous allocation occurs.
-				array[MAX_ARRAY_INDEX] = undefined;
-				delete array[MAX_ARRAY_INDEX];
-
 				for (let i = 2; i < value.length; i += 2) {
 					const idx = value[i];
 
@@ -1344,24 +1579,21 @@ function unflatten(parsed, revivers) {
 						throw new Error('Invalid input');
 					}
 
-					array[idx] = hydrate(value[i + 1]);
+					ops.set(array, idx, hydrate(value[i + 1]));
 				}
-
-				array.length = len;
 			} else {
-				const array = new Array(value.length);
+				const array = ops.createArray(value.length);
 				hydrated[index] = array;
 
 				for (let i = 0; i < value.length; i += 1) {
 					const n = value[i];
 					if (n === HOLE) continue;
 
-					array[i] = hydrate(n);
+					ops.set(array, i, hydrate(n));
 				}
 			}
 		} else {
-			/** @type {Record<string, any>} */
-			const object = {};
+			const object = ops.createObject();
 			hydrated[index] = object;
 
 			for (const key of Object.keys(value)) {
@@ -1369,8 +1601,7 @@ function unflatten(parsed, revivers) {
 					throw new Error('Cannot parse an object with a `__proto__` property');
 				}
 
-				const n = value[key];
-				object[key] = hydrate(n);
+				ops.set(object, key, hydrate(value[key]));
 			}
 		}
 
@@ -1384,8 +1615,9 @@ function unflatten(parsed, revivers) {
  * 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$1(value, reducers) {
+function stringify$1(value, reducers, options) {
 	const stringified = run(false, value, reducers);
 	return typeof stringified === 'string' ? stringified : `[${stringified.join(',')}]`;
 }
@@ -1394,8 +1626,11 @@ function stringify$1(value, reducers) {
  * @param {boolean} async
  * @param {any} value
  * @param {Record<string, (value: any) => any>} [reducers]
+ * @param {import('./types.js').StringifyOptions} [options]
  */
-function run(async, value, reducers) {
+function run(async, value, reducers, options) {
+	const ops = merge_operations(default_stringify_operations);
+
 	/** @type {any[]} */
 	const stringified = [];
 
@@ -1420,16 +1655,30 @@ function run(async, value, reducers) {
 	 * @param {number} [index]
 	 */
 	function flatten(thing, index) {
-		if (thing === undefined) return UNDEFINED;
-		if (Number.isNaN(thing)) return NAN;
-		if (thing === Infinity) return POSITIVE_INFINITY;
-		if (thing === -Infinity) return NEGATIVE_INFINITY;
-		if (thing === 0 && 1 / thing < 0) return NEGATIVE_ZERO;
+		const type = ops.typeOf(thing);
+
+		if (type === 'undefined') return UNDEFINED;
+
+		/** @type {number | undefined} */
+		let number;
+
+		// `ops.toPrimitive` is the boundary between the value being serialized and
+		// plain host JavaScript: everything below operates on the extracted host
+		// primitive, so native comparisons and arithmetic are correct there.
+		if (type === 'number') {
+			number = /** @type {number} */ (ops.toPrimitive(thing));
+			if (Number.isNaN(number)) return NAN;
+			if (number === Infinity) return POSITIVE_INFINITY;
+			if (number === -Infinity) return NEGATIVE_INFINITY;
+			if (number === 0 && 1 / number < 0) return NEGATIVE_ZERO;
+		}
 
-		if (indexes.has(thing)) return /** @type {number} */ (indexes.get(thing));
+		const id = ops.identify(thing);
+
+		if (indexes.has(id)) return /** @type {number} */ (indexes.get(id));
 
 		index ??= p++;
-		indexes.set(thing, index);
+		indexes.set(id, index);
 
 		for (const { key, fn } of custom) {
 			const value = fn(thing);
@@ -1439,18 +1688,18 @@ function run(async, value, reducers) {
 			}
 		}
 
-		if (typeof thing === 'function') {
+		if (type === 'function') {
 			throw new DevalueError(`Cannot stringify a function`, keys, thing, value);
-		} else if (typeof thing === 'symbol') {
+		} else if (type === 'symbol') {
 			throw new DevalueError(`Cannot stringify a Symbol primitive`, keys, thing, value);
 		}
 
 		/** @type {string | Promise<any>} */
 		let str = '';
 
-		if (is_primitive(thing)) {
-			str = stringify_primitive(thing);
-		} else if (typeof thing.then === 'function') {
+		if (type !== 'object') {
+			str = stringify_primitive(type === 'number' ? number : ops.toPrimitive(thing));
+		} else if (ops.isThenable(thing)) {
 			{
 				throw new DevalueError(
 					`Cannot stringify a Promise or thenable — use stringifyAsync instead`,
@@ -1460,31 +1709,30 @@ function run(async, value, reducers) {
 				);
 			}
 		} else {
-			const type = get_type(thing);
+			const tag = ops.tagOf(thing);
 
-			switch (type) {
+			switch (tag) {
 				case 'Number':
 				case 'String':
 				case 'Boolean':
 				case 'BigInt':
-					str = `["Object",${flatten(thing.valueOf())}]`;
+					str = `["Object",${flatten(ops.unbox(thing))}]`;
 					break;
 
 				case 'Date':
-					const valid = !isNaN(thing.getDate());
-					str = `["Date","${valid ? thing.toISOString() : ''}"]`;
+					str = `["Date","${ops.toISOString(thing)}"]`;
 					break;
 
 				case 'URL':
-					str = `["URL",${stringify_string(thing.toString())}]`;
+					str = `["URL",${stringify_string(ops.toStringValue(thing))}]`;
 					break;
 
 				case 'URLSearchParams':
-					str = `["URLSearchParams",${stringify_string(thing.toString())}]`;
+					str = `["URLSearchParams",${stringify_string(ops.toStringValue(thing))}]`;
 					break;
 
 				case 'RegExp':
-					const { source, flags } = thing;
+					const { source, flags } = ops.regExpInfo(thing);
 					str = flags
 						? `["RegExp",${stringify_string(source)},"${flags}"]`
 						: `["RegExp",${stringify_string(source)}]`;
@@ -1500,14 +1748,16 @@ function run(async, value, reducers) {
 					// is what protects against the DoS of e.g. `arr[1000000] = 1`.
 					let mostly_dense = false;
 
+					const length = ops.lengthOf(thing);
+
 					str = '[';
 
-					for (let i = 0; i < thing.length; i += 1) {
+					for (let i = 0; i < length; i += 1) {
 						if (i > 0) str += ',';
 
-						if (Object.hasOwn(thing, i)) {
+						if (ops.hasOwn(thing, i)) {
 							keys.push(`[${i}]`);
-							str += flatten(thing[i]);
+							str += flatten(ops.get(thing, i));
 							keys.pop();
 						} else if (mostly_dense) {
 							// Use dense encoding. The heuristic guarantees the
@@ -1546,19 +1796,19 @@ function run(async, value, reducers) {
 							//
 							// Sparse encoding is cheaper when:
 							//   (4 + d) + P * (d + 1) < (L - P) * 3
-							const populated_keys = valid_array_indices(/** @type {any[]} */ (thing));
+							const populated_keys = ops.indicesOf(thing);
 							const population = populated_keys.length;
-							const d = String(thing.length).length;
+							const d = String(length).length;
 
-							const hole_cost = (thing.length - population) * 3;
+							const hole_cost = (length - population) * 3;
 							const sparse_cost = 4 + d + population * (d + 1);
 
 							if (hole_cost > sparse_cost) {
-								str = '[' + SPARSE + ',' + thing.length;
+								str = '[' + SPARSE + ',' + length;
 								for (let j = 0; j < populated_keys.length; j++) {
 									const key = populated_keys[j];
 									keys.push(`[${key}]`);
-									str += ',' + key + ',' + flatten(thing[key]);
+									str += ',' + key + ',' + flatten(ops.get(thing, key));
 									keys.pop();
 								}
 								break;
@@ -1577,7 +1827,7 @@ function run(async, value, reducers) {
 				case 'Set':
 					str = '["Set"';
 
-					for (const value of thing) {
+					for (const value of ops.valuesOf(thing)) {
 						str += `,${flatten(value)}`;
 					}
 
@@ -1587,8 +1837,13 @@ function run(async, value, reducers) {
 				case 'Map':
 					str = '["Map"';
 
-					for (const [key, value] of thing) {
-						keys.push(`.get(${is_primitive(key) ? stringify_primitive(key) : '...'})`);
+					for (const [key, value] of ops.entriesOf(thing)) {
+						const key_type = ops.typeOf(key);
+						const key_is_primitive =
+							key_type !== 'object' && key_type !== 'function' && key_type !== 'symbol';
+						keys.push(
+							`.get(${key_is_primitive ? stringify_primitive(ops.toPrimitive(key)) : '...'})`
+						);
 						str += `,${flatten(key)},${flatten(value)}`;
 						keys.pop();
 					}
@@ -1607,16 +1862,25 @@ function run(async, value, reducers) {
 				case 'Float32Array':
 				case 'Float64Array':
 				case 'BigInt64Array':
-				case 'BigUint64Array':
-				case 'DataView': {
-					/** @type {import("./types.js").TypedArray} */
-					const typedArray = thing;
-					str = '["' + type + '",' + flatten(typedArray.buffer);
+				case 'BigUint64Array': {
+					const info = ops.viewInfo(thing);
+					str = '["' + tag + '",' + flatten(info.buffer);
 
 					// handle subarrays
-					if (typedArray.byteLength !== typedArray.buffer.byteLength) {
-						// to be used with `new TypedArray(buffer, byteOffset, length)`
-						str += `,${typedArray.byteOffset},${typedArray.length}`;
+					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 += ']';
@@ -1624,9 +1888,7 @@ function run(async, value, reducers) {
 				}
 
 				case 'ArrayBuffer': {
-					/** @type {ArrayBuffer} */
-					const arraybuffer = thing;
-					const base64 = encode64(arraybuffer);
+					const base64 = encode64(ops.toArrayBuffer(thing));
 
 					str = `["ArrayBuffer","${base64}"]`;
 					break;
@@ -1640,21 +1902,23 @@ function run(async, value, reducers) {
 				case 'Temporal.PlainMonthDay':
 				case 'Temporal.PlainYearMonth':
 				case 'Temporal.ZonedDateTime':
-					str = `["${type}",${stringify_string(thing.toString())}]`;
+					str = `["${tag}",${stringify_string(ops.toStringValue(thing))}]`;
 					break;
 
-				default:
-					if (!is_plain_object(thing)) {
+				default: {
+					const shape = ops.shapeOf(thing);
+
+					if (shape.kind === 'not-plain') {
 						throw new DevalueError(`Cannot stringify arbitrary non-POJOs`, keys, thing, value);
 					}
 
-					if (enumerable_symbols(thing).length > 0) {
+					if (shape.kind === 'symbol-keys') {
 						throw new DevalueError(`Cannot stringify POJOs with symbolic keys`, keys, thing, value);
 					}
 
-					if (Object.getPrototypeOf(thing) === null) {
+					if (shape.kind === 'null-proto') {
 						str = '["null"';
-						for (const key of Object.keys(thing)) {
+						for (const key of shape.keys) {
 							if (key === '__proto__') {
 								throw new DevalueError(
 									`Cannot stringify objects with __proto__ keys`,
@@ -1665,14 +1929,14 @@ function run(async, value, reducers) {
 							}
 
 							keys.push(stringify_key(key));
-							str += `,${stringify_string(key)},${flatten(thing[key])}`;
+							str += `,${stringify_string(key)},${flatten(ops.get(thing, key))}`;
 							keys.pop();
 						}
 						str += ']';
 					} else {
 						str = '{';
 						let started = false;
-						for (const key of Object.keys(thing)) {
+						for (const key of shape.keys) {
 							if (key === '__proto__') {
 								throw new DevalueError(
 									`Cannot stringify objects with __proto__ keys`,
@@ -1685,11 +1949,12 @@ function run(async, value, reducers) {
 							if (started) str += ',';
 							started = true;
 							keys.push(stringify_key(key));
-							str += `${stringify_string(key)}:${flatten(thing[key])}`;
+							str += `${stringify_string(key)}:${flatten(ops.get(thing, key))}`;
 							keys.pop();
 						}
 						str += '}';
 					}
+				}
 			}
 		}
 
@@ -2542,4 +2807,4 @@ function create_replacer(transport) {
 }
 
 export { escape_html as A, create_remote_key as B, error as C, parse_remote_arg as D, ENDPOINT_METHODS as E, deserialize_binary_form as F, stringify as G, HttpError as H, INVALIDATED_PARAM as I, stringify$1 as J, ActionFailure as K, split_remote_key as L, SVELTE_KIT_ASSETS as M, splitCookiesString as N, PAGE_METHODS as P, Redirect as R, SvelteKitError as S, TRAILING_SLASH_PARAM as T, handle_fatal_error as a, negotiate as b, method_not_allowed as c, handle_error_and_jsonify as d, get_status as e, format_server_error as f, get_set_cookies as g, has_prerendered_path as h, is_form_content_type as i, json as j, get_global_name as k, create_replacer as l, merge_tracing as m, noop as n, serialize_uses as o, parseString as p, clarify_devalue_error as q, redirect_response as r, static_error_page as s, text as t, uneval as u, once as v, with_request_store as w, normalize_error as x, get_node_type as y, isRedirect as z };
-//# sourceMappingURL=utils.js-h3jETFNR.js.map
+//# sourceMappingURL=utils.js-Bzpr6vQU.js.map