@sentropic/h2a 0.97.11 → 0.97.12

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

@@ -403,6 +403,11 @@ 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) {
@@ -516,6 +521,10 @@ function valid_array_indices(array) {
 }
 
 const chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_$';
+// Short strings have bounded escaping/output costs per reference, so they cannot
+// cause quadratic expansion. Keep them on the original fast path rather than
+// paying for deduplication on common values such as names, IDs and status fields.
+const MIN_STRING_LENGTH = 128;
 const unsafe_chars = /[<\b\f\n\r\t\0\u2028\u2029]/g;
 const reserved =
 	/^(?:do|if|in|for|int|let|new|try|var|byte|case|char|else|enum|goto|long|this|void|with|await|break|catch|class|const|final|float|short|super|throw|while|yield|delete|double|export|import|native|return|switch|throws|typeof|boolean|default|extends|finally|package|private|abstract|continue|debugger|function|volatile|interface|protected|transient|implements|instanceof|synchronized)$/;
@@ -533,6 +542,28 @@ function uneval(value, replacer) {
 
 	const custom = new Map();
 
+	// Only allocate a literal cache when we need to reuse an expensive primitive,
+	// including long Map keys rendered in error paths during the walk.
+	/** @type {Map<string | bigint, string> | undefined} */
+	let primitives;
+
+	/** @param {any} thing */
+	function stringify_cached_primitive(thing) {
+		if (
+			(typeof thing === 'string' && thing.length >= MIN_STRING_LENGTH) ||
+			typeof thing === 'bigint'
+		) {
+			primitives ??= new Map();
+			let literal = primitives.get(thing);
+			if (literal === undefined) {
+				literal = stringify_primitive$1(thing);
+				primitives.set(thing, literal);
+			}
+			return literal;
+		}
+		return stringify_primitive$1(thing);
+	}
+
 	/** @param {any} thing */
 	function walk(thing) {
 		if (!is_primitive(thing)) {
@@ -559,9 +590,12 @@ function uneval(value, replacer) {
 			const type = get_type(thing);
 
 			switch (type) {
-				case 'Number':
 				case 'BigInt':
 				case 'String':
+					walk(thing.valueOf());
+					return;
+
+				case 'Number':
 				case 'Boolean':
 				case 'Date':
 				case 'RegExp':
@@ -570,11 +604,14 @@ function uneval(value, replacer) {
 					return;
 
 				case 'Array':
-					/** @type {any[]} */ (thing).forEach((value, i) => {
+					// forEach scans the logical length of dictionary-backed sparse
+					// arrays. Visit own enumerable indices without doing work for
+					// every hole.
+					for (const i of valid_array_indices(thing)) {
 						keys.push(`[${i}]`);
-						walk(value);
+						walk(thing[i]);
 						keys.pop();
-					});
+					}
 					break;
 
 				case 'Set':
@@ -583,7 +620,7 @@ function uneval(value, replacer) {
 
 				case 'Map':
 					for (const [key, value] of thing) {
-						keys.push(`.get(${is_primitive(key) ? stringify_primitive$1(key) : '...'})`);
+						keys.push(`.get(${is_primitive(key) ? stringify_cached_primitive(key) : '...'})`);
 						walk(key);
 						walk(value);
 						keys.pop();
@@ -603,7 +640,9 @@ function uneval(value, replacer) {
 				case 'BigInt64Array':
 				case 'BigUint64Array':
 				case 'DataView':
-					walk(thing.buffer);
+					// A Node Buffer's backing store may be a shared pool. It must
+					// never be visited or hoisted just because a Buffer uses it.
+					if (!is_buffer(thing)) walk(thing.buffer);
 					return;
 
 				case 'ArrayBuffer':
@@ -645,6 +684,11 @@ function uneval(value, replacer) {
 			}
 		} else if (typeof thing === 'symbol') {
 			throw new DevalueError(`Cannot stringify a Symbol primitive`, keys, thing, value);
+		} else if (
+			(typeof thing === 'string' && thing.length >= MIN_STRING_LENGTH) ||
+			typeof thing === 'bigint'
+		) {
+			counts.set(thing, (counts.get(thing) || 0) + 1);
 		}
 	}
 
@@ -652,11 +696,27 @@ function uneval(value, replacer) {
 
 	const names = new Map();
 
-	Array.from(counts)
-		.filter((entry) => entry[1] > 1)
+	/** @type {Array<[any, number]>} */
+	const repeated = [];
+	// Avoid allocating entries for all the values that will never be hoisted.
+	counts.forEach((count, thing) => {
+		if (count > 1) repeated.push([thing, count]);
+	});
+
+	repeated
 		.sort((a, b) => b[1] - a[1])
-		.forEach((entry, i) => {
-			names.set(entry[0], get_name(i));
+		.forEach(([thing, count]) => {
+			const name = get_name(names.size);
+
+			if (is_primitive(thing)) {
+				const length = stringify_cached_primitive(thing).length;
+				// Hoisting costs one literal, a parameter and a reference per occurrence.
+				// Allow for the IIFE wrapper and separators even if one already exists,
+				// so inexpensive repetitions stay inline.
+				if (length * count <= length + (count + 1) * name.length + 25) return;
+			}
+
+			names.set(thing, name);
 		});
 
 	/**
@@ -702,10 +762,10 @@ function uneval(value, replacer) {
 
 			case 'Array': {
 				// For dense arrays (no holes), we iterate normally.
-				// When we encounter the first hole, we call Object.keys
+				// When we encounter the first hole, we collect own indices
 				// to determine the sparseness, then decide between:
 				//   - Array literal with holes: [,"a",,] (default)
-				//   - Object.assign: Object.assign(Array(n),{...}) (for very sparse arrays)
+				//   - Object.assign with a sparse-safe allocator (for very sparse arrays)
 				// Only the Object.assign path avoids iterating every slot, which
 				// is what protects against the DoS of e.g. `arr[1000000] = 1`.
 				let has_holes = false;
@@ -726,10 +786,11 @@ function uneval(value, replacer) {
 						//
 						// Object.assign: populated indices are listed explicitly.
 						// For example, [, "a", ,] would be written as
-						// Object.assign(Array(3),{1:"a"}). This avoids paying
-						// per-hole, but has a large fixed overhead for the
-						// "Object.assign(Array(n),{...})" wrapper, and each
-						// element costs extra chars for its index and colon.
+						// Object.assign(sparse(3),{1:"a"}), where sparse(n) stands
+						// for the expression emitted by stringify_sparse_array(n).
+						// This avoids paying per-hole, but has a large fixed
+						// overhead for the allocator and Object.assign wrapper,
+						// and each element costs extra chars for its index and colon.
 						//
 						// The serialized values are the same size either way, so
 						// the choice comes down to the structural overhead:
@@ -740,30 +801,32 @@ function uneval(value, replacer) {
 						//     = L + 2
 						//
 						//   Object.assign overhead:
-						//     "Object.assign(Array(" — 20 chars
-						//     + length              — d chars
-						//     + "),{"               — 3 chars
+						//     "Object.assign("      — 14 chars
+						//     + allocator expression — A chars
+						//     + ",{"                 — 2 chars
 						//     + for each populated element:
-						//       index + ":" + ","   — (d + 2) chars
-						//     + "})"                — 2 chars
-						//     = (25 + d) + P * (d + 2)
+						//       index + ":" + ","     — (d + 2) chars
+						//     + "})"                 — 2 chars
+						//     = (18 + A) + P * (d + 2)
 						//
 						// where L is the array length, P is the number of
-						// populated elements, and d is the number of digits
-						// in L (an upper bound on the digits in any index).
+						// populated elements, A is the allocator expression's
+						// length, and d is the number of digits in L (an upper
+						// bound on the digits in any index).
 						//
 						// Object.assign is cheaper when:
-						//   (25 + d) + P * (d + 2) < L + 2
-						const populated_keys = valid_array_indices(/** @type {any[]} */ (thing));
+						//   (18 + A) + P * (d + 2) < L + 2
+						const populated_keys = valid_array_indices(thing);
 						const population = populated_keys.length;
 						const d = String(thing.length).length;
+						const array = stringify_sparse_array(thing.length);
 
 						const hole_cost = thing.length + 2;
-						const sparse_cost = 25 + d + population * (d + 2);
+						const sparse_cost = array.length + 18 + population * (d + 2);
 
 						if (hole_cost > sparse_cost) {
 							const entries = populated_keys.map((k) => `${k}:${stringify(thing[k])}`).join(',');
-							return `Object.assign(Array(${thing.length}),{${entries}})`;
+							return `Object.assign(${array},{${entries}})`;
 						}
 
 						has_holes = true;
@@ -772,7 +835,7 @@ function uneval(value, replacer) {
 					// (the comma separator is all we need — no content for this position)
 				}
 
-				const tail = thing.length === 0 || thing.length - 1 in thing ? '' : ',';
+				const tail = thing.length === 0 || Object.hasOwn(thing, thing.length - 1) ? '' : ',';
 				return result + tail + ']';
 			}
 
@@ -792,6 +855,8 @@ function uneval(value, replacer) {
 			case 'Float64Array':
 			case 'BigInt64Array':
 			case 'BigUint64Array': {
+				if (is_buffer(thing)) thing = new Uint8Array(thing);
+
 				let str = `new ${type}`;
 
 				if (!names.has(thing.buffer)) {
@@ -882,7 +947,7 @@ function uneval(value, replacer) {
 			}
 
 			if (is_primitive(thing)) {
-				values.push(stringify_primitive$1(thing));
+				values.push(stringify_cached_primitive(thing));
 				return;
 			}
 
@@ -892,9 +957,18 @@ function uneval(value, replacer) {
 				case 'Number':
 				case 'String':
 				case 'Boolean':
-				case 'BigInt':
-					values.push(`Object(${stringify(thing.valueOf())})`);
+				case 'BigInt': {
+					const primitive = thing.valueOf();
+					if (names.has(primitive)) {
+						// A hoisted primitive is only in scope inside the IIFE, not in
+						// its arguments. Reconstruct the box before assigning references.
+						values.push('{}');
+						reconstructions.push(`${name}=Object(${stringify(primitive)})`);
+					} else {
+						values.push(`Object(${stringify(primitive)})`);
+					}
 					break;
+				}
 
 				case 'RegExp':
 					const { source, flags } = thing;
@@ -916,12 +990,20 @@ function uneval(value, replacer) {
 					values.push(`new URLSearchParams(${stringify_string(thing.toString())})`);
 					break;
 
-				case 'Array':
-					values.push(`Array(${thing.length})`);
-					/** @type {any[]} */ (thing).forEach((v, i) => {
-						statements.push(`${name}[${i}]=${stringify(v)}`);
-					});
+				case 'Array': {
+					const populated_keys = valid_array_indices(thing);
+					// Only preallocate when the length is bounded by the number
+					// of populated elements, plus a small constant for short arrays.
+					values.push(
+						thing.length > 32 + 2 * populated_keys.length
+							? stringify_sparse_array(thing.length)
+							: `Array(${thing.length})`
+					);
+					for (const i of populated_keys) {
+						statements.push(`${name}[${i}]=${stringify(thing[i])}`);
+					}
 					break;
+				}
 
 				case 'Set': {
 					values.push(`new Set`);
@@ -953,6 +1035,8 @@ function uneval(value, replacer) {
 				case 'Float64Array':
 				case 'BigInt64Array':
 				case 'BigUint64Array': {
+					if (is_buffer(thing)) thing = new Uint8Array(thing);
+
 					let str = `new ${type}`;
 
 					if (!names.has(thing.buffer)) {
@@ -1034,6 +1118,17 @@ function uneval(value, replacer) {
 	}
 }
 
+/**
+ * Emit an array whose storage is not proportional to its declared length.
+ * As in the default parse operations, touching and deleting the largest valid
+ * index forces V8 into dictionary-elements mode before setting the length.
+ * Merely starting with [] and assigning .length still eagerly allocates.
+ * @param {number} length
+ */
+function stringify_sparse_array(length) {
+	return `(function(a){a[${MAX_ARRAY_INDEX}]=0;delete a[${MAX_ARRAY_INDEX}];a.length=${length};return a}([]))`;
+}
+
 /**
  * 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
@@ -1187,10 +1282,10 @@ function merge_operations(defaults, overrides) {
 }
 
 /** @type {{ kind: 'not-plain' }} */
-const NOT_PLAIN = Object.freeze({ kind: 'not-plain' });
+const NOT_PLAIN = /* @__PURE__ */ Object.freeze({ kind: 'not-plain' });
 
 /** @type {{ kind: 'symbol-keys' }} */
-const SYMBOL_KEYS = Object.freeze({ kind: 'symbol-keys' });
+const SYMBOL_KEYS = /* @__PURE__ */ Object.freeze({ kind: 'symbol-keys' });
 
 /**
  * The default implementations of every introspection/extraction operation
@@ -1233,13 +1328,19 @@ const stringify_operations = {
 
 	entriesOf: (map) => map,
 
-	viewInfo: (view) => ({
-		buffer: view.buffer,
-		byteOffset: view.byteOffset,
-		byteLength: view.byteLength,
-		length: view.length,
-		bufferByteLength: view.buffer.byteLength
-	}),
+	viewInfo: (view) => {
+		// Node Buffers may share a pool containing unrelated, sensitive data.
+		// Copy only the visible bytes, without using Buffer's pooling or slice.
+		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,
 
@@ -1262,7 +1363,17 @@ const stringify_operations = {
 	get: (value, key) => value[key]
 };
 
-const default_stringify_operations = Object.freeze(stringify_operations);
+const default_stringify_operations = /* @__PURE__ */ Object.freeze(stringify_operations);
+
+const array_buffer_byte_length = Object.getOwnPropertyDescriptor(
+	ArrayBuffer.prototype,
+	'byteLength'
+).get;
+
+const shared_array_buffer_byte_length =
+	typeof SharedArrayBuffer === 'undefined'
+		? undefined
+		: Object.getOwnPropertyDescriptor(SharedArrayBuffer.prototype, 'byteLength').get;
 
 /**
  * The default implementations of every construction operation `parse` and
@@ -1298,6 +1409,17 @@ const parse_operations = {
 	fromRegExpInfo: (source, flags) => new RegExp(source, flags),
 
 	fromViewInfo: (tag, buffer, byteOffset, length) => {
+		// A reviver can replace an ArrayBuffer with a length or array-like value,
+		// which a typed array constructor would use to allocate a new buffer.
+		// The native getters check internal slots, so they work across realms
+		// and cannot be fooled by a forged prototype or Symbol.toStringTag.
+		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 = /** @type {any} */ (globalThis)[tag];
 		return byteOffset !== undefined
 			? new Constructor(buffer, byteOffset, length)
@@ -1347,7 +1469,7 @@ const parse_operations = {
 	}
 };
 
-const default_parse_operations = Object.freeze(parse_operations);
+const default_parse_operations = /* @__PURE__ */ Object.freeze(parse_operations);
 
 /**
  * Revive a value serialized with `devalue.stringify`
@@ -1496,11 +1618,16 @@ function unflatten(parsed, revivers, options) {
 						const obj = ops.createNullPrototypeObject();
 						hydrated[index] = obj;
 						for (let i = 1; i < value.length; i += 2) {
-							if (value[i] === '__proto__') {
+							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, value[i], hydrate(value[i + 1]));
+							ops.set(obj, key, hydrate(value[i + 1]));
 						}
 						break;
 
@@ -2807,4 +2934,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-Bzpr6vQU.js.map
+//# sourceMappingURL=utils.js-DBwpgn00.js.map