@aopslabs/aops-server 0.2.3 → 0.2.5

package/build/server/chunks/{index.js-CWgll4BT.js → index.js-Ciyn4OZi.js}

@@ -75,6 +75,42 @@ class ActionFailure {
 
 const text_encoder$2 = new TextEncoder();
 
+const text_encoder$1 = new TextEncoder();
+function get_relative_path(from, to) {
+  const from_parts = from.split(/[/\\]/);
+  const to_parts = to.split(/[/\\]/);
+  from_parts.pop();
+  while (from_parts[0] === to_parts[0]) {
+    from_parts.shift();
+    to_parts.shift();
+  }
+  let i = from_parts.length;
+  while (i--) from_parts[i] = "..";
+  return from_parts.concat(to_parts).join("/");
+}
+function base64_encode$1(bytes) {
+  if (globalThis.Buffer) {
+    return globalThis.Buffer.from(bytes).toString("base64");
+  }
+  let binary = "";
+  for (let i = 0; i < bytes.length; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  return btoa(binary);
+}
+function base64_decode(encoded) {
+  if (globalThis.Buffer) {
+    const buffer = globalThis.Buffer.from(encoded, "base64");
+    return new Uint8Array(buffer);
+  }
+  const binary = atob(encoded);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+
 const UNDEFINED = -1;
 const HOLE = -2;
 const NAN = -3;
@@ -82,1653 +118,496 @@ const POSITIVE_INFINITY = -4;
 const NEGATIVE_INFINITY = -5;
 const NEGATIVE_ZERO = -6;
 const SPARSE = -7;
-
-// The largest valid value for a JavaScript array's `length` property,
-// and the largest valid array index (one less than the max length).
 const MAX_ARRAY_LEN = 2 ** 32 - 1;
 const MAX_ARRAY_INDEX = MAX_ARRAY_LEN - 1;
-
-/** @type {Record<string, string>} */
 const escaped = {
-	'<': '\\u003C',
-	'\\': '\\\\',
-	'\b': '\\b',
-	'\f': '\\f',
-	'\n': '\\n',
-	'\r': '\\r',
-	'\t': '\\t',
-	'\u2028': '\\u2028',
-	'\u2029': '\\u2029'
+  "<": "\\u003C",
+  "\\": "\\\\",
+  "\b": "\\b",
+  "\f": "\\f",
+  "\n": "\\n",
+  "\r": "\\r",
+  "	": "\\t",
+  "\u2028": "\\u2028",
+  "\u2029": "\\u2029"
 };
-
 class DevalueError 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;
-	}
+  /**
+   * @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;
+  }
 }
-
-/** @param {any} thing */
 function is_primitive(thing) {
-	return thing === null || (typeof thing !== 'object' && typeof thing !== 'function');
+  return thing === null || typeof thing !== "object" && typeof thing !== "function";
 }
-
-const object_proto_names = /* @__PURE__ */ Object.getOwnPropertyNames(Object.prototype)
-	.sort()
-	.join('\0');
-
-/** @param {any} thing */
+const object_proto_names = /* @__PURE__ */ Object.getOwnPropertyNames(Object.prototype).sort().join("\0");
 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
-	);
+  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);
+  return Object.prototype.toString.call(thing).slice(8, -1);
 }
-
-/** @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 '\t':
-			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')}` : '';
-	}
+  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")}` : "";
+  }
 }
-
-/** @param {string} str */
 function stringify_string(str) {
-	let result = '';
-	let last_pos = 0;
-	const len = str.length;
-
-	for (let i = 0; i < len; i += 1) {
-		const char = str[i];
-		const replacement = get_escaped_char(char);
-		if (replacement) {
-			result += str.slice(last_pos, i) + replacement;
-			last_pos = i + 1;
-		}
-	}
-
-	return `"${last_pos === 0 ? str : result + str.slice(last_pos)}"`;
+  let result = "";
+  let last_pos = 0;
+  const len = str.length;
+  for (let i = 0; i < len; i += 1) {
+    const char = str[i];
+    const replacement = get_escaped_char(char);
+    if (replacement) {
+      result += str.slice(last_pos, i) + replacement;
+      last_pos = i + 1;
+    }
+  }
+  return `"${last_pos === 0 ? str : result + str.slice(last_pos)}"`;
 }
-
-/** @param {Record<string | symbol, any>} object */
 function enumerable_symbols(object) {
-	return Object.getOwnPropertySymbols(object).filter(
-		(symbol) => Object.getOwnPropertyDescriptor(object, symbol).enumerable
-	);
+  return Object.getOwnPropertySymbols(object).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) + ']';
+  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;
+  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;
+  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; // leading zero
-	for (let i = 0; i < s.length; i++) {
-		const c = s.charCodeAt(i);
-		if (c < 48 || c > 57) return false;
-	}
-	// by this point we know it's a string of digits, but it has to be within
-	// the range of valid array indices
-	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;
+  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);
 }
-
-/**
- * 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;
+  const keys = Object.keys(array);
+  for (var i = keys.length - 1; i >= 0; i--) {
+    if (is_valid_array_index_string(keys[i])) {
+      break;
+    }
+  }
+  keys.length = i + 1;
+  return keys;
 }
-
-const chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_$';
+const chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_$";
 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)$/;
-
-/**
- * Turn a value into the JavaScript that creates an equivalent value
- * @param {any} value
- * @param {(value: any, uneval: (value: any) => string) => string | void} [replacer]
- */
+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)$/;
 function uneval(value, replacer) {
-	const counts = new Map();
-
-	/** @type {string[]} */
-	const keys = [];
-
-	const custom = new Map();
-
-	/** @param {any} thing */
-	function walk(thing) {
-		if (!is_primitive(thing)) {
-			if (counts.has(thing)) {
-				counts.set(thing, counts.get(thing) + 1);
-				return;
-			}
-
-			counts.set(thing, 1);
-
-			if (replacer) {
-				const str = replacer(thing, (value) => uneval(value, replacer));
-
-				if (typeof str === 'string') {
-					custom.set(thing, str);
-					return;
-				}
-			}
-
-			if (typeof thing === 'function') {
-				throw new DevalueError(`Cannot stringify a function`, keys, thing, value);
-			}
-
-			const type = get_type(thing);
-
-			switch (type) {
-				case 'Number':
-				case 'BigInt':
-				case 'String':
-				case 'Boolean':
-				case 'Date':
-				case 'RegExp':
-				case 'URL':
-				case 'URLSearchParams':
-					return;
-
-				case 'Array':
-					/** @type {any[]} */ (thing).forEach((value, i) => {
-						keys.push(`[${i}]`);
-						walk(value);
-						keys.pop();
-					});
-					break;
-
-				case 'Set':
-					Array.from(thing).forEach(walk);
-					break;
-
-				case 'Map':
-					for (const [key, value] of thing) {
-						keys.push(`.get(${is_primitive(key) ? stringify_primitive$1(key) : '...'})`);
-						walk(key);
-						walk(value);
-						keys.pop();
-					}
-					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':
-					walk(thing.buffer);
-					return;
-
-				case 'ArrayBuffer':
-					return;
-
-				case 'Temporal.Duration':
-				case 'Temporal.Instant':
-				case 'Temporal.PlainDate':
-				case 'Temporal.PlainTime':
-				case 'Temporal.PlainDateTime':
-				case 'Temporal.PlainMonthDay':
-				case 'Temporal.PlainYearMonth':
-				case 'Temporal.ZonedDateTime':
-					return;
-
-				default:
-					if (!is_plain_object(thing)) {
-						throw new DevalueError(`Cannot stringify arbitrary non-POJOs`, keys, thing, value);
-					}
-
-					if (enumerable_symbols(thing).length > 0) {
-						throw new DevalueError(`Cannot stringify POJOs with symbolic keys`, keys, thing, value);
-					}
-
-					for (const key of Object.keys(thing)) {
-						if (key === '__proto__') {
-							throw new DevalueError(
-								`Cannot stringify objects with __proto__ keys`,
-								keys,
-								thing,
-								value
-							);
-						}
-
-						keys.push(stringify_key(key));
-						walk(thing[key]);
-						keys.pop();
-					}
-			}
-		} else if (typeof thing === 'symbol') {
-			throw new DevalueError(`Cannot stringify a Symbol primitive`, keys, thing, value);
-		}
-	}
-
-	walk(value);
-
-	const names = new Map();
-
-	Array.from(counts)
-		.filter((entry) => entry[1] > 1)
-		.sort((a, b) => b[1] - a[1])
-		.forEach((entry, i) => {
-			names.set(entry[0], get_name(i));
-		});
-
-	/**
-	 * @param {any} thing
-	 * @returns {string}
-	 */
-	function stringify(thing) {
-		if (names.has(thing)) {
-			return names.get(thing);
-		}
-
-		if (is_primitive(thing)) {
-			return stringify_primitive$1(thing);
-		}
-
-		if (custom.has(thing)) {
-			return custom.get(thing);
-		}
-
-		const type = get_type(thing);
-
-		switch (type) {
-			case 'Number':
-			case 'String':
-			case 'Boolean':
-			case 'BigInt':
-				return `Object(${stringify(thing.valueOf())})`;
-
-			case 'RegExp':
-				const { source, flags } = thing;
-				return flags
-					? `new RegExp(${stringify_string(source)},"${flags}")`
-					: `new RegExp(${stringify_string(source)})`;
-
-			case 'Date':
-				return `new Date(${thing.getTime()})`;
-
-			case 'URL':
-				return `new URL(${stringify_string(thing.toString())})`;
-
-			case 'URLSearchParams':
-				return `new URLSearchParams(${stringify_string(thing.toString())})`;
-
-			case 'Array': {
-				// For dense arrays (no holes), we iterate normally.
-				// When we encounter the first hole, we call Object.keys
-				// to determine the sparseness, then decide between:
-				//   - Array literal with holes: [,"a",,] (default)
-				//   - Object.assign: Object.assign(Array(n),{...}) (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;
-
-				let result = '[';
-
-				for (let i = 0; i < thing.length; i += 1) {
-					if (i > 0) result += ',';
-
-					if (Object.hasOwn(thing, i)) {
-						result += stringify(thing[i]);
-					} else if (!has_holes) {
-						// Decide between array literal and Object.assign.
-						//
-						// Array literal: holes are consecutive commas.
-						// For example, [, "a", ,] is written as [,"a",,].
-						// Each hole costs 1 char (a comma).
-						//
-						// 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.
-						//
-						// The serialized values are the same size either way, so
-						// the choice comes down to the structural overhead:
-						//
-						//   Array literal overhead:
-						//     1 char per element or hole (comma separators)
-						//     + 2 chars for "[" and "]"
-						//     = L + 2
-						//
-						//   Object.assign overhead:
-						//     "Object.assign(Array(" — 20 chars
-						//     + length              — d chars
-						//     + "),{"               — 3 chars
-						//     + for each populated element:
-						//       index + ":" + ","   — (d + 2) chars
-						//     + "})"                — 2 chars
-						//     = (25 + d) + 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).
-						//
-						// Object.assign is cheaper when:
-						//   (25 + d) + P * (d + 2) < L + 2
-						const populated_keys = valid_array_indices(/** @type {any[]} */ (thing));
-						const population = populated_keys.length;
-						const d = String(thing.length).length;
-
-						const hole_cost = thing.length + 2;
-						const sparse_cost = 25 + d + 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}})`;
-						}
-
-						has_holes = true;
-					}
-					// else: already decided on array literal, hole is just an empty slot
-					// (the comma separator is all we need — no content for this position)
-				}
-
-				const tail = thing.length === 0 || thing.length - 1 in thing ? '' : ',';
-				return result + tail + ']';
-			}
-
-			case 'Set':
-			case 'Map':
-				return `new ${type}([${Array.from(thing).map(stringify).join(',')}])`;
-
-			case 'Int8Array':
-			case 'Uint8Array':
-			case 'Uint8ClampedArray':
-			case 'Int16Array':
-			case 'Uint16Array':
-			case 'Float16Array':
-			case 'Int32Array':
-			case 'Uint32Array':
-			case 'Float32Array':
-			case 'Float64Array':
-			case 'BigInt64Array':
-			case 'BigUint64Array': {
-				let str = `new ${type}`;
-
-				if (!names.has(thing.buffer)) {
-					str += `([${stringify_typed_array_elements(new thing.constructor(thing.buffer))}])`;
-				} else {
-					str += `(${stringify(thing.buffer)})`;
-				}
-
-				// handle subarrays
-				if (thing.byteLength !== thing.buffer.byteLength) {
-					const start = thing.byteOffset / thing.BYTES_PER_ELEMENT;
-					const end = start + thing.length;
-					str += `.subarray(${start},${end})`;
-				}
-
-				return str;
-			}
-
-			case 'DataView': {
-				let str = `new DataView`;
-
-				if (!names.has(thing.buffer)) {
-					str += `(new Uint8Array([${new Uint8Array(thing.buffer)}]).buffer`;
-				} else {
-					str += `(${stringify(thing.buffer)}`;
-				}
-
-				// handle subviews
-				if (thing.byteLength !== thing.buffer.byteLength) {
-					str += `,${thing.byteOffset},${thing.byteLength}`;
-				}
-
-				return str + ')';
-			}
-
-			case 'ArrayBuffer': {
-				const ui8 = new Uint8Array(thing);
-				return `new Uint8Array([${ui8.toString()}]).buffer`;
-			}
-
-			case 'Temporal.Duration':
-			case 'Temporal.Instant':
-			case 'Temporal.PlainDate':
-			case 'Temporal.PlainTime':
-			case 'Temporal.PlainDateTime':
-			case 'Temporal.PlainMonthDay':
-			case 'Temporal.PlainYearMonth':
-			case 'Temporal.ZonedDateTime':
-				return `${type}.from(${stringify_string(thing.toString())})`;
-
-			default:
-				const keys = Object.keys(thing);
-				const obj = keys.map((key) => `${safe_key(key)}:${stringify(thing[key])}`).join(',');
-				const proto = Object.getPrototypeOf(thing);
-				if (proto === null) {
-					return keys.length > 0 ? `{${obj},__proto__:null}` : `{__proto__:null}`;
-				}
-
-				return `{${obj}}`;
-		}
-	}
-
-	const str = stringify(value);
-
-	if (names.size) {
-		/** @type {string[]} */
-		const params = [];
-
-		/** @type {string[]} */
-		const statements = [];
-
-		/** @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);
-
-			if (custom.has(thing)) {
-				values.push(/** @type {string} */ (custom.get(thing)));
-				return;
-			}
-
-			if (is_primitive(thing)) {
-				values.push(stringify_primitive$1(thing));
-				return;
-			}
-
-			const type = get_type(thing);
-
-			switch (type) {
-				case 'Number':
-				case 'String':
-				case 'Boolean':
-				case 'BigInt':
-					values.push(`Object(${stringify(thing.valueOf())})`);
-					break;
-
-				case 'RegExp':
-					const { source, flags } = thing;
-					const regexp = flags
-						? `new RegExp(${stringify_string(source)},"${flags}")`
-						: `new RegExp(${stringify_string(source)})`;
-					values.push(regexp);
-					break;
-
-				case 'Date':
-					values.push(`new Date(${thing.getTime()})`);
-					break;
-
-				case 'URL':
-					values.push(`new URL(${stringify_string(thing.toString())})`);
-					break;
-
-				case 'URLSearchParams':
-					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)}`);
-					});
-					break;
-
-				case 'Set': {
-					values.push(`new Set`);
-					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': {
-					values.push(`new Map`);
-					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':
-				case 'Uint8ClampedArray':
-				case 'Int16Array':
-				case 'Uint16Array':
-				case 'Float16Array':
-				case 'Int32Array':
-				case 'Uint32Array':
-				case 'Float32Array':
-				case 'Float64Array':
-				case 'BigInt64Array':
-				case 'BigUint64Array': {
-					let str = `new ${type}`;
-
-					if (!names.has(thing.buffer)) {
-						str += `([${stringify_typed_array_elements(new thing.constructor(thing.buffer))}])`;
-					} else {
-						str += `(${stringify(thing.buffer)})`;
-					}
-
-					// handle subarrays
-					if (thing.byteLength !== thing.buffer.byteLength) {
-						const start = thing.byteOffset / thing.BYTES_PER_ELEMENT;
-						const end = start + thing.length;
-						str += `.subarray(${start},${end})`;
-					}
-
-					values.push(`{}`);
-					reconstructions.push(`${name}=${str}`);
-					break;
-				}
-
-				case 'DataView': {
-					let str = `new DataView`;
-
-					if (!names.has(thing.buffer)) {
-						str += `(new Uint8Array([${new Uint8Array(thing.buffer)}]).buffer`;
-					} else {
-						str += `(${stringify(thing.buffer)}`;
-					}
-
-					// handle subviews
-					if (thing.byteLength !== thing.buffer.byteLength) {
-						str += `,${thing.byteOffset},${thing.byteLength}`;
-					}
-
-					str += ')';
-
-					values.push(`{}`);
-					reconstructions.push(`${name}=${str}`);
-					break;
-				}
-
-				case 'ArrayBuffer':
-					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) => {
-						statements.push(`${name}${safe_prop(key)}=${stringify(thing[key])}`);
-					});
-			}
-		});
-
-		statements.push(`return ${str}`);
-
-		const body = [...reconstructions, ...statements].join(';');
-		return `(function(${params.join(',')}){${body}}(${values.join(',')}))`;
-	} else {
-		return str;
-	}
-}
-
-/**
- * Serialize the elements of a typed array as a comma-separated list.
- * `BigInt64Array`/`BigUint64Array` elements are bigints and must be written
- * with an `n` suffix, otherwise the emitted `new BigInt64Array([...])` throws.
- * @param {import('./types.js').TypedArray} array
- */
-function stringify_typed_array_elements(array) {
-	if (array instanceof BigInt64Array || array instanceof BigUint64Array) {
-		return Array.from(array, (element) => `${element}n`).join(',');
-	}
-
-	return array.toString();
-}
-
-/** @param {number} num */
-function get_name(num) {
-	let name = '';
-
-	do {
-		name = chars[num % chars.length] + name;
-		num = ~~(num / chars.length) - 1;
-	} while (num >= 0);
-
-	return reserved.test(name) ? `${name}0` : name;
-}
-
-/** @param {string} c */
-function escape_unsafe_char(c) {
-	return escaped[c] || c;
-}
-
-/** @param {string} str */
-function escape_unsafe_chars(str) {
-	return str.replace(unsafe_chars, escape_unsafe_char);
-}
-
-/** @param {string} key */
-function safe_key(key) {
-	return /^[_$a-zA-Z][_$a-zA-Z0-9]*$/.test(key) ? key : escape_unsafe_chars(JSON.stringify(key));
-}
-
-/** @param {string} key */
-function safe_prop(key) {
-	return /^[_$a-zA-Z][_$a-zA-Z0-9]*$/.test(key)
-		? `.${key}`
-		: `[${escape_unsafe_chars(JSON.stringify(key))}]`;
-}
-
-/** @param {any} thing */
-function stringify_primitive$1(thing) {
-	const type = typeof thing;
-	if (type === 'string') return stringify_string(thing);
-	if (thing === void 0) return 'void 0';
-	if (thing === 0 && 1 / thing < 0) return '-0';
-	const str = String(thing);
-	if (type === 'number') return str.replace(/^(-)?0\./, '$1.');
-	if (type === 'bigint') return thing + 'n';
-	return str;
-}
-
-/* Baseline 2025 runtimes */
-
-/**	@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;
-}
-
-/* Node-compatible runtimes */
-
-/** @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;
-}
-
-/* Legacy runtimes */
-
-/** @type {(array_buffer: ArrayBuffer) => string} */
-function encode_legacy(array_buffer) {
-	const array = new Uint8Array(array_buffer);
-	let binary = '';
-
-	// the maximum number of arguments to String.fromCharCode.apply
-	// should be around 0xFFFF in modern engines
-	const chunk_size = 0x8000;
-	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 !== undefined;
-
-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, options) {
-	return unflatten(JSON.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, 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) {
-		throw new Error('Invalid input');
-	}
-
-	const values = /** @type {any[]} */ (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 hydrate(index, standalone = false) {
-		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`);
-		}
-
-		if (index in hydrated) return hydrated[index];
-
-		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] : undefined;
-
-				if (reviver) {
-					let i = value[1];
-					if (typeof i !== 'number') {
-						// if it's not a number, it was serialized by a builtin reviver
-						// so we need to munge it into the format expected by a custom reviver
-						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)) {
-						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 (
-							typeof values[wrapped_index] === 'object' &&
-							values[wrapped_index][0] !== 'BigInt'
-						) {
-							// avoid infinite recusion in case of malformed input
-							throw new Error('Invalid input');
-						}
-
-						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) {
-							if (value[i] === '__proto__') {
-								throw new Error('Cannot parse an object with a `__proto__` property');
-							}
-
-							ops.set(obj, value[i], 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': {
-						if (values[value[1]][0] !== 'ArrayBuffer') {
-							// without this, if we receive malformed input we could
-							// end up trying to hydrate in a circle or allocate
-							// huge amounts of memory when we call `new TypedArrayConstructor(buffer)`
-							throw new Error('Invalid data');
-						}
-
-						const buffer = hydrate(value[1]);
-
-						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': {
-						// the same tags `toStringValue` serializes on the stringify side
-						hydrated[index] = ops.fromStringValue(type, value[1]);
-						break;
-					}
-
-					default:
-						throw new Error(`Unknown type ${type}`);
-				}
-			} else if (value[0] === SPARSE) {
-				// Sparse array encoding: [SPARSE, length, idx, val, idx, val, ...]
-				const len = value[1];
-
-				if (!is_valid_array_len(len)) {
-					throw new Error('Invalid input');
-				}
-
-				// `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;
-
-				for (let i = 2; i < value.length; i += 2) {
-					const idx = value[i];
-
-					if (!is_valid_array_index(idx) || idx >= len) {
-						throw new Error('Invalid input');
-					}
-
-					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 === HOLE) 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);
-}
-
-/**
- * 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, options) {
-	const stringified = run(false, value, reducers);
-	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);
-
-	/** @type {any[]} */
-	const stringified = [];
-
-	/** @type {Map<any, number>} */
-	const indexes = 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 {string[]} */
-	const keys = [];
-
-	let p = 0;
-
-	/**
-	 * @param {any} thing
-	 * @param {number} [index]
-	 */
-	function flatten(thing, index) {
-		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;
-		}
-
-		const id = ops.identify(thing);
-
-		if (indexes.has(id)) return /** @type {number} */ (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') {
-			throw new DevalueError(`Cannot stringify a function`, keys, thing, value);
-		} else if (type === 'symbol') {
-			throw new DevalueError(`Cannot stringify a Symbol primitive`, keys, thing, value);
-		}
-
-		/** @type {string | Promise<any>} */
-		let str = '';
-
-		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`,
-					keys,
-					thing,
-					value
-				);
-			}
-		} 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': {
-					// For dense arrays (no holes), we iterate normally.
-					// When we encounter the first hole, we call Object.keys
-					// to determine the sparseness, then decide between:
-					//   - HOLE encoding: [-2, val, -2, ...] (default)
-					//   - Sparse encoding: [-7, length, idx, val, ...] (for very sparse arrays)
-					// Only the sparse path avoids iterating every slot, which
-					// 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 < 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) {
-							// Use dense encoding. The heuristic guarantees the
-							// array is only mildly sparse, so iterating over every
-							// slot is fine.
-							str += HOLE;
-						} else {
-							// Decide between HOLE encoding and sparse encoding.
-							//
-							// HOLE encoding: each hole is serialized as the HOLE
-							// sentinel (-2). For example, [, "a", ,] becomes
-							// [-2, 0, -2]. Each hole costs 3 chars ("-2" + comma).
-							//
-							// Sparse encoding: lists only populated indices.
-							// For example, [, "a", ,] becomes [-7, 3, 1, 0] — the
-							// -7 sentinel, the array length (3), then index-value
-							// pairs. This avoids paying per-hole, but each element
-							// costs extra chars to write its index.
-							//
-							// The values are the same size either way, so the
-							// choice comes down to structural overhead:
-							//
-							//   HOLE overhead:
-							//     3 chars per hole ("-2" + comma)
-							//     = (L - P) * 3
-							//
-							//   Sparse overhead:
-							//     "-7,"          — 3 chars (sparse sentinel + comma)
-							//     + length + "," — (d + 1) chars (array length + comma)
-							//     + per element: index + "," — (d + 1) chars
-							//     = (4 + d) + P * (d + 1)
-							//
-							// 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).
-							//
-							// Sparse encoding is cheaper when:
-							//   (4 + d) + P * (d + 1) < (L - P) * 3
-							const populated_keys = ops.indicesOf(thing);
-							const population = populated_keys.length;
-							const d = String(length).length;
-
-							const hole_cost = (length - population) * 3;
-							const sparse_cost = 4 + d + population * (d + 1);
-
-							if (hole_cost > sparse_cost) {
-								str = '[' + SPARSE + ',' + 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 += HOLE;
-							}
-						}
-					}
-
-					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)) {
-						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();
-					}
-
-					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);
-
-					// handle subarrays
-					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': {
-					const base64 = encode64(ops.toArrayBuffer(thing));
-
-					str = `["ArrayBuffer","${base64}"]`;
-					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') {
-						throw new DevalueError(`Cannot stringify arbitrary non-POJOs`, keys, thing, value);
-					}
-
-					if (shape.kind === 'symbol-keys') {
-						throw new DevalueError(`Cannot stringify POJOs with symbolic keys`, keys, thing, value);
-					}
-
-					if (shape.kind === 'null-proto') {
-						str = '["null"';
-						for (const key of shape.keys) {
-							if (key === '__proto__') {
-								throw new DevalueError(
-									`Cannot stringify objects with __proto__ keys`,
-									keys,
-									thing,
-									value
-								);
-							}
-
-							keys.push(stringify_key(key));
-							str += `,${stringify_string(key)},${flatten(ops.get(thing, key))}`;
-							keys.pop();
-						}
-						str += ']';
-					} else {
-						str = '{';
-						let started = false;
-						for (const key of shape.keys) {
-							if (key === '__proto__') {
-								throw new DevalueError(
-									`Cannot stringify objects with __proto__ keys`,
-									keys,
-									thing,
-									value
-								);
-							}
-
-							if (started) str += ',';
-							started = true;
-							keys.push(stringify_key(key));
-							str += `${stringify_string(key)}:${flatten(ops.get(thing, key))}`;
-							keys.pop();
-						}
-						str += '}';
-					}
-				}
-			}
-		}
-
-		stringified[index] = str;
-		return index;
-	}
-
-	const index = flatten(value);
-
-	// special case — value is represented as a negative index
-	if (index < 0) return `${index}`;
-
-	return stringified;
+  const counts = /* @__PURE__ */ new Map();
+  const keys = [];
+  const custom = /* @__PURE__ */ new Map();
+  function walk(thing) {
+    if (!is_primitive(thing)) {
+      if (counts.has(thing)) {
+        counts.set(thing, counts.get(thing) + 1);
+        return;
+      }
+      counts.set(thing, 1);
+      if (replacer) {
+        const str2 = replacer(thing, (value2) => uneval(value2, replacer));
+        if (typeof str2 === "string") {
+          custom.set(thing, str2);
+          return;
+        }
+      }
+      if (typeof thing === "function") {
+        throw new DevalueError(`Cannot stringify a function`, keys, thing, value);
+      }
+      const type = get_type(thing);
+      switch (type) {
+        case "Number":
+        case "BigInt":
+        case "String":
+        case "Boolean":
+        case "Date":
+        case "RegExp":
+        case "URL":
+        case "URLSearchParams":
+          return;
+        case "Array":
+          thing.forEach((value2, i) => {
+            keys.push(`[${i}]`);
+            walk(value2);
+            keys.pop();
+          });
+          break;
+        case "Set":
+          Array.from(thing).forEach(walk);
+          break;
+        case "Map":
+          for (const [key, value2] of thing) {
+            keys.push(`.get(${is_primitive(key) ? stringify_primitive$1(key) : "..."})`);
+            walk(value2);
+            keys.pop();
+          }
+          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":
+          walk(thing.buffer);
+          return;
+        case "ArrayBuffer":
+          return;
+        case "Temporal.Duration":
+        case "Temporal.Instant":
+        case "Temporal.PlainDate":
+        case "Temporal.PlainTime":
+        case "Temporal.PlainDateTime":
+        case "Temporal.PlainMonthDay":
+        case "Temporal.PlainYearMonth":
+        case "Temporal.ZonedDateTime":
+          return;
+        default:
+          if (!is_plain_object(thing)) {
+            throw new DevalueError(`Cannot stringify arbitrary non-POJOs`, keys, thing, value);
+          }
+          if (enumerable_symbols(thing).length > 0) {
+            throw new DevalueError(`Cannot stringify POJOs with symbolic keys`, keys, thing, value);
+          }
+          for (const key of Object.keys(thing)) {
+            if (key === "__proto__") {
+              throw new DevalueError(
+                `Cannot stringify objects with __proto__ keys`,
+                keys,
+                thing,
+                value
+              );
+            }
+            keys.push(stringify_key(key));
+            walk(thing[key]);
+            keys.pop();
+          }
+      }
+    } else if (typeof thing === "symbol") {
+      throw new DevalueError(`Cannot stringify a Symbol primitive`, keys, thing, value);
+    }
+  }
+  walk(value);
+  const names = /* @__PURE__ */ new Map();
+  Array.from(counts).filter((entry) => entry[1] > 1).sort((a, b) => b[1] - a[1]).forEach((entry, i) => {
+    names.set(entry[0], get_name(i));
+  });
+  function stringify(thing) {
+    if (names.has(thing)) {
+      return names.get(thing);
+    }
+    if (is_primitive(thing)) {
+      return stringify_primitive$1(thing);
+    }
+    if (custom.has(thing)) {
+      return custom.get(thing);
+    }
+    const type = get_type(thing);
+    switch (type) {
+      case "Number":
+      case "String":
+      case "Boolean":
+      case "BigInt":
+        return `Object(${stringify(thing.valueOf())})`;
+      case "RegExp":
+        const { source, flags } = thing;
+        return flags ? `new RegExp(${stringify_string(source)},"${flags}")` : `new RegExp(${stringify_string(source)})`;
+      case "Date":
+        return `new Date(${thing.getTime()})`;
+      case "URL":
+        return `new URL(${stringify_string(thing.toString())})`;
+      case "URLSearchParams":
+        return `new URLSearchParams(${stringify_string(thing.toString())})`;
+      case "Array": {
+        let has_holes = false;
+        let result = "[";
+        for (let i = 0; i < thing.length; i += 1) {
+          if (i > 0) result += ",";
+          if (Object.hasOwn(thing, i)) {
+            result += stringify(thing[i]);
+          } else if (!has_holes) {
+            const populated_keys = valid_array_indices(
+              /** @type {any[]} */
+              thing
+            );
+            const population = populated_keys.length;
+            const d = String(thing.length).length;
+            const hole_cost = thing.length + 2;
+            const sparse_cost = 25 + d + 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}})`;
+            }
+            has_holes = true;
+            i -= 1;
+          }
+        }
+        const tail = thing.length === 0 || thing.length - 1 in thing ? "" : ",";
+        return result + tail + "]";
+      }
+      case "Set":
+      case "Map":
+        return `new ${type}([${Array.from(thing).map(stringify).join(",")}])`;
+      case "Int8Array":
+      case "Uint8Array":
+      case "Uint8ClampedArray":
+      case "Int16Array":
+      case "Uint16Array":
+      case "Float16Array":
+      case "Int32Array":
+      case "Uint32Array":
+      case "Float32Array":
+      case "Float64Array":
+      case "BigInt64Array":
+      case "BigUint64Array": {
+        let str2 = `new ${type}`;
+        if (!names.has(thing.buffer)) {
+          const array = new thing.constructor(thing.buffer);
+          str2 += `([${array}])`;
+        } else {
+          str2 += `(${stringify(thing.buffer)})`;
+        }
+        if (thing.byteLength !== thing.buffer.byteLength) {
+          const start = thing.byteOffset / thing.BYTES_PER_ELEMENT;
+          const end = start + thing.length;
+          str2 += `.subarray(${start},${end})`;
+        }
+        return str2;
+      }
+      case "DataView": {
+        let str2 = `new DataView`;
+        if (!names.has(thing.buffer)) {
+          str2 += `(new Uint8Array([${new Uint8Array(thing.buffer)}]).buffer`;
+        } else {
+          str2 += `(${stringify(thing.buffer)}`;
+        }
+        if (thing.byteLength !== thing.buffer.byteLength) {
+          str2 += `,${thing.startOffset},${thing.byteLength}`;
+        }
+        return str2 + ")";
+      }
+      case "ArrayBuffer": {
+        const ui8 = new Uint8Array(thing);
+        return `new Uint8Array([${ui8.toString()}]).buffer`;
+      }
+      case "Temporal.Duration":
+      case "Temporal.Instant":
+      case "Temporal.PlainDate":
+      case "Temporal.PlainTime":
+      case "Temporal.PlainDateTime":
+      case "Temporal.PlainMonthDay":
+      case "Temporal.PlainYearMonth":
+      case "Temporal.ZonedDateTime":
+        return `${type}.from(${stringify_string(thing.toString())})`;
+      default:
+        const keys2 = Object.keys(thing);
+        const obj = keys2.map((key) => `${safe_key(key)}:${stringify(thing[key])}`).join(",");
+        const proto = Object.getPrototypeOf(thing);
+        if (proto === null) {
+          return keys2.length > 0 ? `{${obj},__proto__:null}` : `{__proto__:null}`;
+        }
+        return `{${obj}}`;
+    }
+  }
+  const str = stringify(value);
+  if (names.size) {
+    const params = [];
+    const statements = [];
+    const values = [];
+    names.forEach((name, thing) => {
+      params.push(name);
+      if (custom.has(thing)) {
+        values.push(
+          /** @type {string} */
+          custom.get(thing)
+        );
+        return;
+      }
+      if (is_primitive(thing)) {
+        values.push(stringify_primitive$1(thing));
+        return;
+      }
+      const type = get_type(thing);
+      switch (type) {
+        case "Number":
+        case "String":
+        case "Boolean":
+        case "BigInt":
+          values.push(`Object(${stringify(thing.valueOf())})`);
+          break;
+        case "RegExp":
+          const { source, flags } = thing;
+          const regexp = flags ? `new RegExp(${stringify_string(source)},"${flags}")` : `new RegExp(${stringify_string(source)})`;
+          values.push(regexp);
+          break;
+        case "Date":
+          values.push(`new Date(${thing.getTime()})`);
+          break;
+        case "URL":
+          values.push(`new URL(${stringify_string(thing.toString())})`);
+          break;
+        case "URLSearchParams":
+          values.push(`new URLSearchParams(${stringify_string(thing.toString())})`);
+          break;
+        case "Array":
+          values.push(`Array(${thing.length})`);
+          thing.forEach((v, i) => {
+            statements.push(`${name}[${i}]=${stringify(v)}`);
+          });
+          break;
+        case "Set":
+          values.push(`new Set`);
+          statements.push(
+            `${name}.${Array.from(thing).map((v) => `add(${stringify(v)})`).join(".")}`
+          );
+          break;
+        case "Map":
+          values.push(`new Map`);
+          statements.push(
+            `${name}.${Array.from(thing).map(([k, v]) => `set(${stringify(k)}, ${stringify(v)})`).join(".")}`
+          );
+          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": {
+          let str2 = `new ${type}`;
+          if (!names.has(thing.buffer)) {
+            const array = new thing.constructor(thing.buffer);
+            str2 += `([${array}])`;
+          } else {
+            str2 += `(${stringify(thing.buffer)})`;
+          }
+          if (thing.byteLength !== thing.buffer.byteLength) {
+            const start = thing.byteOffset / thing.BYTES_PER_ELEMENT;
+            const end = start + thing.length;
+            str2 += `.subarray(${start},${end})`;
+          }
+          values.push(`{}`);
+          statements.push(`${name}=${str2}`);
+          break;
+        }
+        case "DataView": {
+          let str2 = `new DataView`;
+          if (!names.has(thing.buffer)) {
+            str2 += `(new Uint8Array([${new Uint8Array(thing.buffer)}]).buffer`;
+          } else {
+            str2 += `(${stringify(thing.buffer)}`;
+          }
+          if (thing.byteLength !== thing.buffer.byteLength) {
+            str2 += `,${thing.byteOffset},${thing.byteLength}`;
+          }
+          str2 += ")";
+          values.push(`{}`);
+          statements.push(`${name}=${str2}`);
+          break;
+        }
+        case "ArrayBuffer":
+          values.push(`new Uint8Array([${new Uint8Array(thing)}]).buffer`);
+          break;
+        default:
+          values.push(Object.getPrototypeOf(thing) === null ? "Object.create(null)" : "{}");
+          Object.keys(thing).forEach((key) => {
+            statements.push(`${name}${safe_prop(key)}=${stringify(thing[key])}`);
+          });
+      }
+    });
+    statements.push(`return ${str}`);
+    return `(function(${params.join(",")}){${statements.join(";")}}(${values.join(",")}))`;
+  } else {
+    return str;
+  }
 }
-
-/**
- * @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 UNDEFINED.toString();
-	if (thing === 0 && 1 / thing < 0) return NEGATIVE_ZERO.toString();
-	if (type === 'bigint') return `["BigInt","${thing}"]`;
-	return String(thing);
+function get_name(num) {
+  let name = "";
+  do {
+    name = chars[num % chars.length] + name;
+    num = ~~(num / chars.length) - 1;
+  } while (num >= 0);
+  return reserved.test(name) ? `${name}0` : name;
 }
-
-const text_encoder$1 = new TextEncoder();
-function get_relative_path(from, to) {
-  const from_parts = from.split(/[/\\]/);
-  const to_parts = to.split(/[/\\]/);
-  from_parts.pop();
-  while (from_parts[0] === to_parts[0]) {
-    from_parts.shift();
-    to_parts.shift();
-  }
-  let i = from_parts.length;
-  while (i--) from_parts[i] = "..";
-  return from_parts.concat(to_parts).join("/");
+function escape_unsafe_char(c) {
+  return escaped[c] || c;
 }
-function base64_encode$1(bytes) {
-  if (globalThis.Buffer) {
-    return globalThis.Buffer.from(bytes).toString("base64");
-  }
-  let binary = "";
-  for (let i = 0; i < bytes.length; i++) {
-    binary += String.fromCharCode(bytes[i]);
-  }
-  return btoa(binary);
+function escape_unsafe_chars(str) {
+  return str.replace(unsafe_chars, escape_unsafe_char);
 }
-function base64_decode(encoded) {
-  if (globalThis.Buffer) {
-    const buffer = globalThis.Buffer.from(encoded, "base64");
-    return new Uint8Array(buffer);
-  }
-  const binary = atob(encoded);
-  const bytes = new Uint8Array(binary.length);
-  for (let i = 0; i < binary.length; i++) {
-    bytes[i] = binary.charCodeAt(i);
-  }
-  return bytes;
+function safe_key(key) {
+  return /^[_$a-zA-Z][_$a-zA-Z0-9]*$/.test(key) ? key : escape_unsafe_chars(JSON.stringify(key));
+}
+function safe_prop(key) {
+  return /^[_$a-zA-Z][_$a-zA-Z0-9]*$/.test(key) ? `.${key}` : `[${escape_unsafe_chars(JSON.stringify(key))}]`;
+}
+function stringify_primitive$1(thing) {
+  const type = typeof thing;
+  if (type === "string") return stringify_string(thing);
+  if (thing === void 0) return "void 0";
+  if (thing === 0 && 1 / thing < 0) return "-0";
+  const str = String(thing);
+  if (type === "number") return str.replace(/^(-)?0\./, "$1.");
+  if (type === "bigint") return thing + "n";
+  return str;
 }
 
 /** @import { StandardSchemaV1 } from '@standard-schema/spec' */
@@ -1915,266 +794,449 @@ function merge_tracing(event_like, current) {
 	};
 }
 
-var defaultParseOptions = {
-  decodeValues: true,
-  map: false,
-  silent: false,
-  split: "auto", // auto = split strings but not arrays
-};
-
-function isForbiddenKey(key) {
-  return typeof key !== "string" || key in {};
+function encode_native(array_buffer) {
+  return new Uint8Array(array_buffer).toBase64();
 }
-
-function createNullObj() {
-  return Object.create(null);
+function decode_native(base64) {
+  return Uint8Array.fromBase64(base64).buffer;
 }
-
-function isNonEmptyString(str) {
-  return typeof str === "string" && !!str.trim();
+function encode_buffer(array_buffer) {
+  return Buffer.from(array_buffer).toString("base64");
 }
-
-function parseString(setCookieValue, options) {
-  var parts = setCookieValue.split(";").filter(isNonEmptyString);
-
-  var nameValuePairStr = parts.shift();
-  if (!nameValuePairStr) {
-    return null;
-  }
-  var parsed = parseNameValuePair(nameValuePairStr);
-  var name = parsed.name;
-  var value = parsed.value;
-
-  options = options
-    ? Object.assign({}, defaultParseOptions, options)
-    : defaultParseOptions;
-
-  if (isForbiddenKey(name)) {
-    return null;
-  }
-
-  try {
-    value = options.decodeValues ? decodeURIComponent(value) : value; // decode cookie value
-  } catch (e) {
-    console.error(
-      "set-cookie-parser: failed to decode cookie value. Set options.decodeValues=false to disable decoding.",
-      e
-    );
-  }
-
-  var cookie = createNullObj();
-  cookie.name = name;
-  cookie.value = value;
-
-  parts.forEach(function (part) {
-    var sides = part.split("=");
-    var key = sides.shift().trim().toLowerCase();
-    if (isForbiddenKey(key)) {
-      return;
-    }
-    var value = sides.join("=").trim();
-    if (key === "expires") {
-      cookie.expires = new Date(value);
-    } else if (key === "max-age") {
-      var n = parseInt(value, 10);
-      if (!Number.isNaN(n)) cookie.maxAge = n;
-    } else if (key === "secure") {
-      cookie.secure = true;
-    } else if (key === "httponly") {
-      cookie.httpOnly = true;
-    } else if (key === "samesite") {
-      cookie.sameSite = value;
-    } else if (key === "partitioned") {
-      cookie.partitioned = true;
-    } else if (key) {
-      cookie[key] = value;
-    }
-  });
-
-  return cookie;
+function decode_buffer(base64) {
+  return Uint8Array.from(Buffer.from(base64, "base64")).buffer;
 }
-
-function parseNameValuePair(nameValuePairStr) {
-  // Parses name-value-pair according to rfc6265bis draft
-
-  var name = "";
-  var value = "";
-  var nameValueArr = nameValuePairStr.split("=");
-  if (nameValueArr.length > 1) {
-    name = nameValueArr.shift();
-    value = nameValueArr.join("="); // everything after the first =, joined by a "=" if there was more than one part
-  } else {
-    value = nameValuePairStr;
+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 { name: name, value: value };
+  return btoa(binary);
 }
-
-function parseSetCookie(input, options) {
-  options = options
-    ? Object.assign({}, defaultParseOptions, options)
-    : defaultParseOptions;
-
-  if (!input) {
-    if (!options.map) {
-      return [];
-    } else {
-      return createNullObj();
-    }
-  }
-
-  if (input.headers) {
-    if (typeof input.headers.getSetCookie === "function") {
-      // for fetch responses - they combine headers of the same type in the headers array,
-      // but getSetCookie returns an uncombined array
-      input = input.headers.getSetCookie();
-    } else if (input.headers["set-cookie"]) {
-      // fast-path for node.js (which automatically normalizes header names to lower-case)
-      input = input.headers["set-cookie"];
-    } else {
-      // slow-path for other environments - see #25
-      var sch =
-        input.headers[
-          Object.keys(input.headers).find(function (key) {
-            return key.toLowerCase() === "set-cookie";
-          })
-        ];
-      // warn if called on a request-like object with a cookie header rather than a set-cookie header - see #34, 36
-      if (!sch && input.headers.cookie && !options.silent) {
-        console.warn(
-          "Warning: set-cookie-parser appears to have been called on a request object. It is designed to parse Set-Cookie headers from responses, not Cookie headers from requests. Set the option {silent: true} to suppress this warning."
-        );
-      }
-      input = sch;
-    }
-  }
-
-  var split = options.split;
-  var isArray = Array.isArray(input);
-
-  if (split === "auto") {
-    split = !isArray;
-  }
-
-  if (!isArray) {
-    input = [input];
-  }
-
-  input = input.filter(isNonEmptyString);
-
-  if (split) {
-    input = input.map(splitCookiesString).flat();
-  }
-
-  if (!options.map) {
-    return input
-      .map(function (str) {
-        return parseString(str, options);
-      })
-      .filter(Boolean);
-  } else {
-    var cookies = createNullObj();
-    return input.reduce(function (cookies, str) {
-      var cookie = parseString(str, options);
-      if (cookie && !isForbiddenKey(cookie.name)) {
-        cookies[cookie.name] = cookie;
-      }
-      return cookies;
-    }, cookies);
+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;
 }
-
-/*
-  Set-Cookie header field-values are sometimes comma joined in one string. This splits them without choking on commas
-  that are within a single set-cookie field-value, such as in the Expires portion.
-
-  This is uncommon, but explicitly allowed - see https://tools.ietf.org/html/rfc2616#section-4.2
-  Node.js does this for every header *except* set-cookie - see https://github.com/nodejs/node/blob/d5e363b77ebaf1caf67cd7528224b651c86815c1/lib/_http_incoming.js#L128
-  React Native's fetch does this for *every* header, including set-cookie.
-
-  Based on: https://github.com/google/j2objc/commit/16820fdbc8f76ca0c33472810ce0cb03d20efe25
-  Credits to: https://github.com/tomball for original and https://github.com/chrusart for JavaScript implementation
-*/
-function splitCookiesString(cookiesString) {
-  if (Array.isArray(cookiesString)) {
-    return cookiesString;
-  }
-  if (typeof cookiesString !== "string") {
-    return [];
-  }
-
-  var cookiesStrings = [];
-  var pos = 0;
-  var start;
-  var ch;
-  var lastComma;
-  var nextStart;
-  var cookiesSeparatorFound;
-
-  function skipWhitespace() {
-    while (pos < cookiesString.length && /\s/.test(cookiesString.charAt(pos))) {
-      pos += 1;
-    }
-    return pos < cookiesString.length;
-  }
-
-  function notSpecialChar() {
-    ch = cookiesString.charAt(pos);
-
-    return ch !== "=" && ch !== ";" && ch !== ",";
-  }
-
-  while (pos < cookiesString.length) {
-    start = pos;
-    cookiesSeparatorFound = false;
-
-    while (skipWhitespace()) {
-      ch = cookiesString.charAt(pos);
-      if (ch === ",") {
-        // ',' is a cookie separator if we have later first '=', not ';' or ','
-        lastComma = pos;
-        pos += 1;
-
-        skipWhitespace();
-        nextStart = pos;
-
-        while (pos < cookiesString.length && notSpecialChar()) {
-          pos += 1;
-        }
-
-        // currently special character
-        if (pos < cookiesString.length && cookiesString.charAt(pos) === "=") {
-          // we found cookies separator
-          cookiesSeparatorFound = true;
-          // pos is inside the next cookie, so back up and return it.
-          pos = nextStart;
-          cookiesStrings.push(cookiesString.substring(start, lastComma));
-          start = pos;
-        } else {
-          // in param ',' or param separator ';',
-          // we continue from that comma
-          pos = lastComma + 1;
+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;
+function parse(serialized, revivers) {
+  return unflatten(JSON.parse(serialized), revivers);
+}
+function unflatten(parsed, revivers) {
+  if (typeof parsed === "number") return hydrate(parsed, true);
+  if (!Array.isArray(parsed) || parsed.length === 0) {
+    throw new Error("Invalid input");
+  }
+  const values = (
+    /** @type {any[]} */
+    parsed
+  );
+  const hydrated = Array(values.length);
+  let hydrating = null;
+  function hydrate(index, standalone = false) {
+    if (index === UNDEFINED) return void 0;
+    if (index === NAN) return NaN;
+    if (index === POSITIVE_INFINITY) return Infinity;
+    if (index === NEGATIVE_INFINITY) return -Infinity;
+    if (index === NEGATIVE_ZERO) return -0;
+    if (standalone || typeof index !== "number") {
+      throw new Error(`Invalid input`);
+    }
+    if (index in hydrated) return hydrated[index];
+    const value = values[index];
+    if (!value || typeof value !== "object") {
+      hydrated[index] = 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;
+          }
+          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] = new Date(value[1]);
+            break;
+          case "Set":
+            const set = /* @__PURE__ */ new Set();
+            hydrated[index] = set;
+            for (let i = 1; i < value.length; i += 1) {
+              set.add(hydrate(value[i]));
+            }
+            break;
+          case "Map":
+            const map = /* @__PURE__ */ new Map();
+            hydrated[index] = map;
+            for (let i = 1; i < value.length; i += 2) {
+              map.set(hydrate(value[i]), hydrate(value[i + 1]));
+            }
+            break;
+          case "RegExp":
+            hydrated[index] = new RegExp(value[1], value[2]);
+            break;
+          case "Object": {
+            const wrapped_index = value[1];
+            if (typeof values[wrapped_index] === "object" && values[wrapped_index][0] !== "BigInt") {
+              throw new Error("Invalid input");
+            }
+            hydrated[index] = Object(hydrate(wrapped_index));
+            break;
+          }
+          case "BigInt":
+            hydrated[index] = BigInt(value[1]);
+            break;
+          case "null":
+            const obj = /* @__PURE__ */ Object.create(null);
+            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]);
+            }
+            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": {
+            if (values[value[1]][0] !== "ArrayBuffer") {
+              throw new Error("Invalid data");
+            }
+            const TypedArrayConstructor = globalThis[type];
+            const buffer2 = hydrate(value[1]);
+            hydrated[index] = value[2] !== void 0 ? new TypedArrayConstructor(buffer2, value[2], value[3]) : new TypedArrayConstructor(buffer2);
+            break;
+          }
+          case "ArrayBuffer": {
+            const base64 = value[1];
+            if (typeof base64 !== "string") {
+              throw new Error("Invalid ArrayBuffer encoding");
+            }
+            const arraybuffer = decode64(base64);
+            hydrated[index] = arraybuffer;
+            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": {
+            const temporalName = type.slice(9);
+            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;
+            break;
+          }
+          default:
+            throw new Error(`Unknown type ${type}`);
+        }
+      } else if (value[0] === SPARSE) {
+        const len = value[1];
+        if (!is_valid_array_len(len)) {
+          throw new Error("Invalid input");
+        }
+        const array = [];
+        hydrated[index] = array;
+        array[MAX_ARRAY_INDEX] = void 0;
+        delete array[MAX_ARRAY_INDEX];
+        for (let i = 2; i < value.length; i += 2) {
+          const idx = value[i];
+          if (!is_valid_array_index(idx) || idx >= len) {
+            throw new Error("Invalid input");
+          }
+          array[idx] = hydrate(value[i + 1]);
         }
+        array.length = len;
       } else {
-        pos += 1;
+        const array = new Array(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);
+        }
+      }
+    } else {
+      const object = {};
+      hydrated[index] = object;
+      for (const key of Object.keys(value)) {
+        if (key === "__proto__") {
+          throw new Error("Cannot parse an object with a `__proto__` property");
+        }
+        const n = value[key];
+        object[key] = hydrate(n);
+      }
+    }
+    return hydrated[index];
+  }
+  return hydrate(0);
+}
+function stringify$1(value, reducers) {
+  const stringified = run(false, value, reducers);
+  return typeof stringified === "string" ? stringified : `[${stringified.join(",")}]`;
+}
+function run(async, value, reducers) {
+  const stringified = [];
+  const indexes = /* @__PURE__ */ new Map();
+  const custom = [];
+  if (reducers) {
+    for (const key of Object.getOwnPropertyNames(reducers)) {
+      custom.push({ key, fn: reducers[key] });
+    }
+  }
+  const keys = [];
+  let p = 0;
+  function flatten(thing, index2) {
+    if (thing === void 0) 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;
+    if (indexes.has(thing)) return (
+      /** @type {number} */
+      indexes.get(thing)
+    );
+    index2 ??= p++;
+    indexes.set(thing, index2);
+    for (const { key, fn } of custom) {
+      const value2 = fn(thing);
+      if (value2) {
+        stringified[index2] = `["${key}",${flatten(value2)}]`;
+        return index2;
+      }
+    }
+    if (typeof thing === "function") {
+      throw new DevalueError(`Cannot stringify a function`, keys, thing, value);
+    } else if (typeof thing === "symbol") {
+      throw new DevalueError(`Cannot stringify a Symbol primitive`, keys, thing, value);
+    }
+    let str = "";
+    if (is_primitive(thing)) {
+      str = stringify_primitive(thing);
+    } else if (typeof thing.then === "function") {
+      {
+        throw new DevalueError(
+          `Cannot stringify a Promise or thenable — use stringifyAsync instead`,
+          keys,
+          thing,
+          value
+        );
+      }
+    } else {
+      const type = get_type(thing);
+      switch (type) {
+        case "Number":
+        case "String":
+        case "Boolean":
+        case "BigInt":
+          str = `["Object",${flatten(thing.valueOf())}]`;
+          break;
+        case "Date":
+          const valid = !isNaN(thing.getDate());
+          str = `["Date","${valid ? thing.toISOString() : ""}"]`;
+          break;
+        case "URL":
+          str = `["URL",${stringify_string(thing.toString())}]`;
+          break;
+        case "URLSearchParams":
+          str = `["URLSearchParams",${stringify_string(thing.toString())}]`;
+          break;
+        case "RegExp":
+          const { source, flags } = thing;
+          str = flags ? `["RegExp",${stringify_string(source)},"${flags}"]` : `["RegExp",${stringify_string(source)}]`;
+          break;
+        case "Array": {
+          let mostly_dense = false;
+          str = "[";
+          for (let i = 0; i < thing.length; i += 1) {
+            if (i > 0) str += ",";
+            if (Object.hasOwn(thing, i)) {
+              keys.push(`[${i}]`);
+              str += flatten(thing[i]);
+              keys.pop();
+            } else if (mostly_dense) {
+              str += HOLE;
+            } else {
+              const populated_keys = valid_array_indices(
+                /** @type {any[]} */
+                thing
+              );
+              const population = populated_keys.length;
+              const d = String(thing.length).length;
+              const hole_cost = (thing.length - population) * 3;
+              const sparse_cost = 4 + d + population * (d + 1);
+              if (hole_cost > sparse_cost) {
+                str = "[" + SPARSE + "," + thing.length;
+                for (let j = 0; j < populated_keys.length; j++) {
+                  const key = populated_keys[j];
+                  keys.push(`[${key}]`);
+                  str += "," + key + "," + flatten(thing[key]);
+                  keys.pop();
+                }
+                break;
+              } else {
+                mostly_dense = true;
+                str += HOLE;
+              }
+            }
+          }
+          str += "]";
+          break;
+        }
+        case "Set":
+          str = '["Set"';
+          for (const value2 of thing) {
+            str += `,${flatten(value2)}`;
+          }
+          str += "]";
+          break;
+        case "Map":
+          str = '["Map"';
+          for (const [key, value2] of thing) {
+            keys.push(`.get(${is_primitive(key) ? stringify_primitive(key) : "..."})`);
+            str += `,${flatten(key)},${flatten(value2)}`;
+            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":
+        case "DataView": {
+          const typedArray = thing;
+          str = '["' + type + '",' + flatten(typedArray.buffer);
+          if (typedArray.byteLength !== typedArray.buffer.byteLength) {
+            str += `,${typedArray.byteOffset},${typedArray.length}`;
+          }
+          str += "]";
+          break;
+        }
+        case "ArrayBuffer": {
+          const arraybuffer = thing;
+          const base64 = encode64(arraybuffer);
+          str = `["ArrayBuffer","${base64}"]`;
+          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 = `["${type}",${stringify_string(thing.toString())}]`;
+          break;
+        default:
+          if (!is_plain_object(thing)) {
+            throw new DevalueError(`Cannot stringify arbitrary non-POJOs`, keys, thing, value);
+          }
+          if (enumerable_symbols(thing).length > 0) {
+            throw new DevalueError(`Cannot stringify POJOs with symbolic keys`, keys, thing, value);
+          }
+          if (Object.getPrototypeOf(thing) === null) {
+            str = '["null"';
+            for (const key of Object.keys(thing)) {
+              if (key === "__proto__") {
+                throw new DevalueError(
+                  `Cannot stringify objects with __proto__ keys`,
+                  keys,
+                  thing,
+                  value
+                );
+              }
+              keys.push(stringify_key(key));
+              str += `,${stringify_string(key)},${flatten(thing[key])}`;
+              keys.pop();
+            }
+            str += "]";
+          } else {
+            str = "{";
+            let started = false;
+            for (const key of Object.keys(thing)) {
+              if (key === "__proto__") {
+                throw new DevalueError(
+                  `Cannot stringify objects with __proto__ keys`,
+                  keys,
+                  thing,
+                  value
+                );
+              }
+              if (started) str += ",";
+              started = true;
+              keys.push(stringify_key(key));
+              str += `${stringify_string(key)}:${flatten(thing[key])}`;
+              keys.pop();
+            }
+            str += "}";
+          }
       }
     }
-
-    if (!cookiesSeparatorFound || pos >= cookiesString.length) {
-      cookiesStrings.push(cookiesString.substring(start, cookiesString.length));
-    }
+    stringified[index2] = str;
+    return index2;
   }
-
-  return cookiesStrings;
+  const index = flatten(value);
+  if (index < 0) return `${index}`;
+  return stringified;
+}
+function stringify_primitive(thing) {
+  const type = typeof thing;
+  if (type === "string") return stringify_string(thing);
+  if (thing === void 0) return UNDEFINED.toString();
+  if (thing === 0 && 1 / thing < 0) return NEGATIVE_ZERO.toString();
+  if (type === "bigint") return `["BigInt","${thing}"]`;
+  return String(thing);
 }
-
-// named export for CJS
-parseSetCookie.parseSetCookie = parseSetCookie;
-// for backwards compatibility
-parseSetCookie.parse = parseSetCookie;
-parseSetCookie.parseString = parseString;
-parseSetCookie.splitCookiesString = splitCookiesString;
-
 const SVELTE_KIT_ASSETS = "/_svelte_kit_assets";
 const ENDPOINT_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD"];
 const PAGE_METHODS = ["GET", "POST", "HEAD"];
@@ -2279,13 +1341,13 @@ async function deserialize_binary_form(request) {
       chunks2.push(chunk);
       cursor += chunk.byteLength;
     }
-    const buffer = new Uint8Array(length);
+    const buffer2 = new Uint8Array(length);
     cursor = 0;
     for (const chunk of chunks2) {
-      buffer.set(chunk, cursor);
+      buffer2.set(chunk, cursor);
       cursor += chunk.byteLength;
     }
-    return buffer;
+    return buffer2;
   }
   const header = await get_buffer(0, HEADER_BYTES);
   if (!header) throw deserialize_error("too short");
@@ -2542,76 +1604,266 @@ function create_remote_arg_revivers(transport) {
       if (!Array.isArray(value)) {
         throw new Error("Invalid data for Set reviver");
       }
-      const set = /* @__PURE__ */ new Set();
-      for (const item of value) {
-        if (typeof item !== "string") {
-          throw new Error("Invalid data for Set reviver");
+      const set = /* @__PURE__ */ new Set();
+      for (const item of value) {
+        if (typeof item !== "string") {
+          throw new Error("Invalid data for Set reviver");
+        }
+        set.add(parse$1(item));
+      }
+      return set;
+    },
+    /** @type {(value: any) => File} */
+    [remote_file]: (value) => {
+      if (!value || typeof value !== "object" || typeof value.name !== "string" || typeof value.type !== "string" || typeof value.size !== "number" || typeof value.lastModified !== "number" || !(value.data instanceof ArrayBuffer)) {
+        throw new Error("Invalid data for File reviver");
+      }
+      const { data, name, ...meta } = value;
+      return new File([data], name, meta);
+    }
+  };
+  const user_revivers = Object.fromEntries(
+    Object.entries(transport).map(([k, v]) => [k, v.decode])
+  );
+  const all_revivers = { ...user_revivers, ...remote_fns_revivers };
+  const parse$1 = (data) => parse(data, all_revivers);
+  return all_revivers;
+}
+function parse_remote_arg(string, transport) {
+  if (!string) return void 0;
+  const json_string = new TextDecoder().decode(
+    // no need to add back `=` characters, atob can handle it
+    base64_decode(string.replaceAll("-", "+").replaceAll("_", "/"))
+  );
+  return parse(json_string, create_remote_arg_revivers(transport));
+}
+function create_remote_key(id, payload) {
+  return id + "/" + payload;
+}
+function split_remote_key(key) {
+  const i = key.lastIndexOf("/");
+  if (i === -1) {
+    throw new Error(`Invalid remote key: ${key}`);
+  }
+  return {
+    id: key.slice(0, i),
+    payload: key.slice(i + 1)
+  };
+}
+function coalesce_to_error(err) {
+  return err instanceof Error || err && /** @type {any} */
+  err.name && /** @type {any} */
+  err.message ? (
+    /** @type {Error} */
+    err
+  ) : new Error(JSON.stringify(err));
+}
+function normalize_error(error) {
+  return (
+    /** @type {import('../exports/internal/index.js').Redirect | HttpError | SvelteKitError | Error} */
+    error
+  );
+}
+function get_status(error) {
+  return error instanceof HttpError || error instanceof SvelteKitError ? error.status : 500;
+}
+function get_message(error) {
+  return error instanceof SvelteKitError ? error.text : "Internal Error";
+}
+var defaultParseOptions = {
+  decodeValues: true,
+  map: false,
+  silent: false,
+  split: "auto"
+  // auto = split strings but not arrays
+};
+function isForbiddenKey(key) {
+  return typeof key !== "string" || key in {};
+}
+function createNullObj() {
+  return /* @__PURE__ */ Object.create(null);
+}
+function isNonEmptyString(str) {
+  return typeof str === "string" && !!str.trim();
+}
+function parseString(setCookieValue, options) {
+  var parts = setCookieValue.split(";").filter(isNonEmptyString);
+  var nameValuePairStr = parts.shift();
+  if (!nameValuePairStr) {
+    return null;
+  }
+  var parsed = parseNameValuePair(nameValuePairStr);
+  var name = parsed.name;
+  var value = parsed.value;
+  options = options ? Object.assign({}, defaultParseOptions, options) : defaultParseOptions;
+  if (isForbiddenKey(name)) {
+    return null;
+  }
+  try {
+    value = options.decodeValues ? decodeURIComponent(value) : value;
+  } catch (e) {
+    console.error(
+      "set-cookie-parser: failed to decode cookie value. Set options.decodeValues=false to disable decoding.",
+      e
+    );
+  }
+  var cookie = createNullObj();
+  cookie.name = name;
+  cookie.value = value;
+  parts.forEach(function(part) {
+    var sides = part.split("=");
+    var key = sides.shift().trim().toLowerCase();
+    if (isForbiddenKey(key)) {
+      return;
+    }
+    var value2 = sides.join("=").trim();
+    if (key === "expires") {
+      cookie.expires = new Date(value2);
+    } else if (key === "max-age") {
+      var n = parseInt(value2, 10);
+      if (!Number.isNaN(n)) cookie.maxAge = n;
+    } else if (key === "secure") {
+      cookie.secure = true;
+    } else if (key === "httponly") {
+      cookie.httpOnly = true;
+    } else if (key === "samesite") {
+      cookie.sameSite = value2;
+    } else if (key === "partitioned") {
+      cookie.partitioned = true;
+    } else if (key) {
+      cookie[key] = value2;
+    }
+  });
+  return cookie;
+}
+function parseNameValuePair(nameValuePairStr) {
+  var name = "";
+  var value = "";
+  var nameValueArr = nameValuePairStr.split("=");
+  if (nameValueArr.length > 1) {
+    name = nameValueArr.shift();
+    value = nameValueArr.join("=");
+  } else {
+    value = nameValuePairStr;
+  }
+  return { name, value };
+}
+function parseSetCookie(input, options) {
+  options = options ? Object.assign({}, defaultParseOptions, options) : defaultParseOptions;
+  if (!input) {
+    if (!options.map) {
+      return [];
+    } else {
+      return createNullObj();
+    }
+  }
+  if (input.headers) {
+    if (typeof input.headers.getSetCookie === "function") {
+      input = input.headers.getSetCookie();
+    } else if (input.headers["set-cookie"]) {
+      input = input.headers["set-cookie"];
+    } else {
+      var sch = input.headers[Object.keys(input.headers).find(function(key) {
+        return key.toLowerCase() === "set-cookie";
+      })];
+      if (!sch && input.headers.cookie && !options.silent) {
+        console.warn(
+          "Warning: set-cookie-parser appears to have been called on a request object. It is designed to parse Set-Cookie headers from responses, not Cookie headers from requests. Set the option {silent: true} to suppress this warning."
+        );
+      }
+      input = sch;
+    }
+  }
+  var split = options.split;
+  var isArray = Array.isArray(input);
+  if (split === "auto") {
+    split = !isArray;
+  }
+  if (!isArray) {
+    input = [input];
+  }
+  input = input.filter(isNonEmptyString);
+  if (split) {
+    input = input.map(splitCookiesString).flat();
+  }
+  if (!options.map) {
+    return input.map(function(str) {
+      return parseString(str, options);
+    }).filter(Boolean);
+  } else {
+    var cookies = createNullObj();
+    return input.reduce(function(cookies2, str) {
+      var cookie = parseString(str, options);
+      if (cookie && !isForbiddenKey(cookie.name)) {
+        cookies2[cookie.name] = cookie;
+      }
+      return cookies2;
+    }, cookies);
+  }
+}
+function splitCookiesString(cookiesString) {
+  if (Array.isArray(cookiesString)) {
+    return cookiesString;
+  }
+  if (typeof cookiesString !== "string") {
+    return [];
+  }
+  var cookiesStrings = [];
+  var pos = 0;
+  var start;
+  var ch;
+  var lastComma;
+  var nextStart;
+  var cookiesSeparatorFound;
+  function skipWhitespace() {
+    while (pos < cookiesString.length && /\s/.test(cookiesString.charAt(pos))) {
+      pos += 1;
+    }
+    return pos < cookiesString.length;
+  }
+  function notSpecialChar() {
+    ch = cookiesString.charAt(pos);
+    return ch !== "=" && ch !== ";" && ch !== ",";
+  }
+  while (pos < cookiesString.length) {
+    start = pos;
+    cookiesSeparatorFound = false;
+    while (skipWhitespace()) {
+      ch = cookiesString.charAt(pos);
+      if (ch === ",") {
+        lastComma = pos;
+        pos += 1;
+        skipWhitespace();
+        nextStart = pos;
+        while (pos < cookiesString.length && notSpecialChar()) {
+          pos += 1;
         }
-        set.add(parse$1(item));
-      }
-      return set;
-    },
-    /** @type {(value: any) => File} */
-    [remote_file]: (value) => {
-      if (!value || typeof value !== "object" || typeof value.name !== "string" || typeof value.type !== "string" || typeof value.size !== "number" || typeof value.lastModified !== "number" || !(value.data instanceof ArrayBuffer)) {
-        throw new Error("Invalid data for File reviver");
+        if (pos < cookiesString.length && cookiesString.charAt(pos) === "=") {
+          cookiesSeparatorFound = true;
+          pos = nextStart;
+          cookiesStrings.push(cookiesString.substring(start, lastComma));
+          start = pos;
+        } else {
+          pos = lastComma + 1;
+        }
+      } else {
+        pos += 1;
       }
-      const { data, name, ...meta } = value;
-      return new File([data], name, meta);
     }
-  };
-  const user_revivers = Object.fromEntries(
-    Object.entries(transport).map(([k, v]) => [k, v.decode])
-  );
-  const all_revivers = { ...user_revivers, ...remote_fns_revivers };
-  const parse$1 = (data) => parse(data, all_revivers);
-  return all_revivers;
-}
-function parse_remote_arg(string, transport) {
-  if (!string) return void 0;
-  const json_string = new TextDecoder().decode(
-    // no need to add back `=` characters, atob can handle it
-    base64_decode(string.replaceAll("-", "+").replaceAll("_", "/"))
-  );
-  return parse(json_string, create_remote_arg_revivers(transport));
-}
-function create_remote_key(id, payload) {
-  return id + "/" + payload;
-}
-function split_remote_key(key) {
-  const i = key.lastIndexOf("/");
-  if (i === -1) {
-    throw new Error(`Invalid remote key: ${key}`);
+    if (!cookiesSeparatorFound || pos >= cookiesString.length) {
+      cookiesStrings.push(cookiesString.substring(start, cookiesString.length));
+    }
   }
-  return {
-    id: key.slice(0, i),
-    payload: key.slice(i + 1)
-  };
-}
-function coalesce_to_error(err) {
-  return err instanceof Error || err && /** @type {any} */
-  err.name && /** @type {any} */
-  err.message ? (
-    /** @type {Error} */
-    err
-  ) : new Error(JSON.stringify(err));
-}
-function normalize_error(error) {
-  return (
-    /** @type {import('../exports/internal/index.js').Redirect | HttpError | SvelteKitError | Error} */
-    error
-  );
-}
-function get_status(error) {
-  return error instanceof HttpError || error instanceof SvelteKitError ? error.status : 500;
-}
-function get_message(error) {
-  return error instanceof SvelteKitError ? error.text : "Internal Error";
+  return cookiesStrings;
 }
+parseSetCookie.parseSetCookie = parseSetCookie;
+parseSetCookie.parse = parseSetCookie;
+parseSetCookie.parseString = parseString;
+parseSetCookie.splitCookiesString = splitCookiesString;
 function negotiate(accept, types) {
   const parts = [];
   accept.split(",").forEach((str, i) => {
-    const match = /([^/ \t]+)\/([^; \t]+)[ \t]*(?:;[ \t]*q=([0-9.]+))?/.exec(str);
+    const match = /^[ \t]*([^/ \t]+)\/([^; \t]+)[ \t]*(?:;[ \t]*q=([0-9.]+))?/.exec(str);
     if (match) {
       const [, type, subtype, q = "1"] = match;
       parts.push({ type, subtype, q: +q, i });
@@ -2812,8 +2064,6 @@ function create_replacer(transport) {
   return replacer;
 }
 
-function r(e){var t,f,n="";if("string"==typeof e||"number"==typeof e)n+=e;else if("object"==typeof e)if(Array.isArray(e)){var o=e.length;for(t=0;t<o;t++)e[t]&&(f=r(e[t]))&&(n&&(n+=" "),n+=f);}else for(f in e)e[f]&&(n&&(n+=" "),n+=f);return n}function clsx$1(){for(var e,t,f=0,n="",o=arguments.length;f<o;f++)(e=arguments[f])&&(t=r(e))&&(n&&(n+=" "),n+=t);return n}
-
 const DERIVED = 1 << 1;
 const EFFECT = 1 << 2;
 const RENDER_EFFECT = 1 << 3;
@@ -4108,7 +3358,7 @@ class Batch {
     if (this.#roots.length > 0) {
       if (next_batch !== null) {
         const batch2 = next_batch;
-        batch2.#roots.push(...this.#roots.filter((r) => !batch2.#roots.includes(r)));
+        batch2.#roots.push(...this.#roots.filter((r2) => !batch2.#roots.includes(r2)));
       } else {
         next_batch = this;
       }
@@ -5812,6 +5062,19 @@ function escape_html(value, is_attr) {
   }
   return escaped + str.substring(last);
 }
+function r(e) {
+  var t, f, n = "";
+  if ("string" == typeof e || "number" == typeof e) n += e;
+  else if ("object" == typeof e) if (Array.isArray(e)) {
+    var o = e.length;
+    for (t = 0; t < o; t++) e[t] && (f = r(e[t])) && (n && (n += " "), n += f);
+  } else for (f in e) e[f] && (n && (n += " "), n += f);
+  return n;
+}
+function clsx$1() {
+  for (var e, t, f = 0, n = "", o = arguments.length; f < o; f++) (e = arguments[f]) && (t = r(e)) && (n && (n += " "), n += t);
+  return n;
+}
 const replacements$1 = {
   translate: /* @__PURE__ */ new Map([
     [true, "yes"],
@@ -6345,14 +5608,14 @@ class Renderer {
     };
     if (typeof body === "function") {
       this.child((renderer) => {
-        const r = new Renderer(this.global, this);
-        body(r);
+        const r2 = new Renderer(this.global, this);
+        body(r2);
         if (this.global.mode === "async") {
-          return r.#collect_content_async().then((content) => {
+          return r2.#collect_content_async().then((content) => {
             close(renderer, content.body.replaceAll("<!---->", ""), content);
           });
         } else {
-          const content = r.#collect_content();
+          const content = r2.#collect_content();
           close(renderer, content.body.replaceAll("<!---->", ""), content);
         }
       });
@@ -6369,14 +5632,14 @@ class Renderer {
       this.global.set_title(head, path);
     };
     this.child((renderer) => {
-      const r = new Renderer(renderer.global, renderer);
-      fn(r);
+      const r2 = new Renderer(renderer.global, renderer);
+      fn(r2);
       if (renderer.global.mode === "async") {
-        return r.#collect_content_async().then((content) => {
+        return r2.#collect_content_async().then((content) => {
           close(content.head);
         });
       } else {
-        const content = r.#collect_content();
+        const content = r2.#collect_content();
         close(content.head);
       }
     });
@@ -7312,7 +6575,7 @@ const options = {
     app: ({ head, body, assets, nonce, env }) => '<!doctype html>\n<html lang="en">\n  <head>\n    <meta charset="utf-8" />\n    <link rel="icon" href="' + assets + '/favicon.png" />\n    <meta name="viewport" content="width=device-width, initial-scale=1" />\n    ' + head + '\n  </head>\n  <body data-sveltekit-preload-data="hover">\n    <div style="display: contents">' + body + "</div>\n  </body>\n</html>\n",
     error
   },
-  version_hash: "141pzln"
+  version_hash: "cmtin0"
 };
 async function get_hooks() {
   let handle;
@@ -7320,7 +6583,7 @@ async function get_hooks() {
   let handleError;
   let handleValidationError;
   let init;
-  ({ handle, handleFetch, handleError, handleValidationError, init } = await import('./hooks.server-Zx-k_ERd.js'));
+  ({ handle, handleFetch, handleError, handleValidationError, init } = await import('./hooks.server-BGc6cSdu.js'));
   let reroute;
   let transport;
   return {
@@ -7334,291 +6597,6 @@ async function get_hooks() {
   };
 }
 
-var cookie = {};
-
-/*!
- * cookie
- * Copyright(c) 2012-2014 Roman Shtylman
- * Copyright(c) 2015 Douglas Christopher Wilson
- * MIT Licensed
- */
-
-var hasRequiredCookie;
-
-function requireCookie () {
-	if (hasRequiredCookie) return cookie;
-	hasRequiredCookie = 1;
-
-	/**
-	 * Module exports.
-	 * @public
-	 */
-
-	cookie.parse = parse;
-	cookie.serialize = serialize;
-
-	/**
-	 * Module variables.
-	 * @private
-	 */
-
-	var __toString = Object.prototype.toString;
-
-	/**
-	 * RegExp to match field-content in RFC 7230 sec 3.2
-	 *
-	 * field-content = field-vchar [ 1*( SP / HTAB ) field-vchar ]
-	 * field-vchar   = VCHAR / obs-text
-	 * obs-text      = %x80-FF
-	 */
-
-	var fieldContentRegExp = /^[\u0009\u0020-\u007e\u0080-\u00ff]+$/;
-
-	/**
-	 * Parse a cookie header.
-	 *
-	 * Parse the given cookie header string into an object
-	 * The object has the various cookies as keys(names) => values
-	 *
-	 * @param {string} str
-	 * @param {object} [options]
-	 * @return {object}
-	 * @public
-	 */
-
-	function parse(str, options) {
-	  if (typeof str !== 'string') {
-	    throw new TypeError('argument str must be a string');
-	  }
-
-	  var obj = {};
-	  var opt = options || {};
-	  var dec = opt.decode || decode;
-
-	  var index = 0;
-	  while (index < str.length) {
-	    var eqIdx = str.indexOf('=', index);
-
-	    // no more cookie pairs
-	    if (eqIdx === -1) {
-	      break
-	    }
-
-	    var endIdx = str.indexOf(';', index);
-
-	    if (endIdx === -1) {
-	      endIdx = str.length;
-	    } else if (endIdx < eqIdx) {
-	      // backtrack on prior semicolon
-	      index = str.lastIndexOf(';', eqIdx - 1) + 1;
-	      continue
-	    }
-
-	    var key = str.slice(index, eqIdx).trim();
-
-	    // only assign once
-	    if (undefined === obj[key]) {
-	      var val = str.slice(eqIdx + 1, endIdx).trim();
-
-	      // quoted values
-	      if (val.charCodeAt(0) === 0x22) {
-	        val = val.slice(1, -1);
-	      }
-
-	      obj[key] = tryDecode(val, dec);
-	    }
-
-	    index = endIdx + 1;
-	  }
-
-	  return obj;
-	}
-
-	/**
-	 * Serialize data into a cookie header.
-	 *
-	 * Serialize the a name value pair into a cookie string suitable for
-	 * http headers. An optional options object specified cookie parameters.
-	 *
-	 * serialize('foo', 'bar', { httpOnly: true })
-	 *   => "foo=bar; httpOnly"
-	 *
-	 * @param {string} name
-	 * @param {string} val
-	 * @param {object} [options]
-	 * @return {string}
-	 * @public
-	 */
-
-	function serialize(name, val, options) {
-	  var opt = options || {};
-	  var enc = opt.encode || encode;
-
-	  if (typeof enc !== 'function') {
-	    throw new TypeError('option encode is invalid');
-	  }
-
-	  if (!fieldContentRegExp.test(name)) {
-	    throw new TypeError('argument name is invalid');
-	  }
-
-	  var value = enc(val);
-
-	  if (value && !fieldContentRegExp.test(value)) {
-	    throw new TypeError('argument val is invalid');
-	  }
-
-	  var str = name + '=' + value;
-
-	  if (null != opt.maxAge) {
-	    var maxAge = opt.maxAge - 0;
-
-	    if (isNaN(maxAge) || !isFinite(maxAge)) {
-	      throw new TypeError('option maxAge is invalid')
-	    }
-
-	    str += '; Max-Age=' + Math.floor(maxAge);
-	  }
-
-	  if (opt.domain) {
-	    if (!fieldContentRegExp.test(opt.domain)) {
-	      throw new TypeError('option domain is invalid');
-	    }
-
-	    str += '; Domain=' + opt.domain;
-	  }
-
-	  if (opt.path) {
-	    if (!fieldContentRegExp.test(opt.path)) {
-	      throw new TypeError('option path is invalid');
-	    }
-
-	    str += '; Path=' + opt.path;
-	  }
-
-	  if (opt.expires) {
-	    var expires = opt.expires;
-
-	    if (!isDate(expires) || isNaN(expires.valueOf())) {
-	      throw new TypeError('option expires is invalid');
-	    }
-
-	    str += '; Expires=' + expires.toUTCString();
-	  }
-
-	  if (opt.httpOnly) {
-	    str += '; HttpOnly';
-	  }
-
-	  if (opt.secure) {
-	    str += '; Secure';
-	  }
-
-	  if (opt.partitioned) {
-	    str += '; Partitioned';
-	  }
-
-	  if (opt.priority) {
-	    var priority = typeof opt.priority === 'string'
-	      ? opt.priority.toLowerCase()
-	      : opt.priority;
-
-	    switch (priority) {
-	      case 'low':
-	        str += '; Priority=Low';
-	        break
-	      case 'medium':
-	        str += '; Priority=Medium';
-	        break
-	      case 'high':
-	        str += '; Priority=High';
-	        break
-	      default:
-	        throw new TypeError('option priority is invalid')
-	    }
-	  }
-
-	  if (opt.sameSite) {
-	    var sameSite = typeof opt.sameSite === 'string'
-	      ? opt.sameSite.toLowerCase() : opt.sameSite;
-
-	    switch (sameSite) {
-	      case true:
-	        str += '; SameSite=Strict';
-	        break;
-	      case 'lax':
-	        str += '; SameSite=Lax';
-	        break;
-	      case 'strict':
-	        str += '; SameSite=Strict';
-	        break;
-	      case 'none':
-	        str += '; SameSite=None';
-	        break;
-	      default:
-	        throw new TypeError('option sameSite is invalid');
-	    }
-	  }
-
-	  return str;
-	}
-
-	/**
-	 * URL-decode string value. Optimized to skip native call when no %.
-	 *
-	 * @param {string} str
-	 * @returns {string}
-	 */
-
-	function decode (str) {
-	  return str.indexOf('%') !== -1
-	    ? decodeURIComponent(str)
-	    : str
-	}
-
-	/**
-	 * URL-encode value.
-	 *
-	 * @param {string} val
-	 * @returns {string}
-	 */
-
-	function encode (val) {
-	  return encodeURIComponent(val)
-	}
-
-	/**
-	 * Determine if value is a Date.
-	 *
-	 * @param {*} val
-	 * @private
-	 */
-
-	function isDate (val) {
-	  return __toString.call(val) === '[object Date]' ||
-	    val instanceof Date
-	}
-
-	/**
-	 * Try decoding a string using a decoding function.
-	 *
-	 * @param {string} str
-	 * @param {function} decode
-	 * @private
-	 */
-
-	function tryDecode(str, decode) {
-	  try {
-	    return decode(str);
-	  } catch (e) {
-	    return str;
-	  }
-	}
-	return cookie;
-}
-
-var cookieExports = requireCookie();
-
 const s = JSON.stringify;
 function exec(match, params, matchers) {
   const result = {};
@@ -10588,6 +9566,152 @@ function redirect_json_response(redirect) {
     }
   );
 }
+var cookie = {};
+var hasRequiredCookie;
+function requireCookie() {
+  if (hasRequiredCookie) return cookie;
+  hasRequiredCookie = 1;
+  cookie.parse = parse;
+  cookie.serialize = serialize;
+  var __toString = Object.prototype.toString;
+  var fieldContentRegExp = /^[\u0009\u0020-\u007e\u0080-\u00ff]+$/;
+  function parse(str, options2) {
+    if (typeof str !== "string") {
+      throw new TypeError("argument str must be a string");
+    }
+    var obj = {};
+    var opt = options2 || {};
+    var dec = opt.decode || decode;
+    var index = 0;
+    while (index < str.length) {
+      var eqIdx = str.indexOf("=", index);
+      if (eqIdx === -1) {
+        break;
+      }
+      var endIdx = str.indexOf(";", index);
+      if (endIdx === -1) {
+        endIdx = str.length;
+      } else if (endIdx < eqIdx) {
+        index = str.lastIndexOf(";", eqIdx - 1) + 1;
+        continue;
+      }
+      var key2 = str.slice(index, eqIdx).trim();
+      if (void 0 === obj[key2]) {
+        var val = str.slice(eqIdx + 1, endIdx).trim();
+        if (val.charCodeAt(0) === 34) {
+          val = val.slice(1, -1);
+        }
+        obj[key2] = tryDecode(val, dec);
+      }
+      index = endIdx + 1;
+    }
+    return obj;
+  }
+  function serialize(name, val, options2) {
+    var opt = options2 || {};
+    var enc = opt.encode || encode2;
+    if (typeof enc !== "function") {
+      throw new TypeError("option encode is invalid");
+    }
+    if (!fieldContentRegExp.test(name)) {
+      throw new TypeError("argument name is invalid");
+    }
+    var value = enc(val);
+    if (value && !fieldContentRegExp.test(value)) {
+      throw new TypeError("argument val is invalid");
+    }
+    var str = name + "=" + value;
+    if (null != opt.maxAge) {
+      var maxAge = opt.maxAge - 0;
+      if (isNaN(maxAge) || !isFinite(maxAge)) {
+        throw new TypeError("option maxAge is invalid");
+      }
+      str += "; Max-Age=" + Math.floor(maxAge);
+    }
+    if (opt.domain) {
+      if (!fieldContentRegExp.test(opt.domain)) {
+        throw new TypeError("option domain is invalid");
+      }
+      str += "; Domain=" + opt.domain;
+    }
+    if (opt.path) {
+      if (!fieldContentRegExp.test(opt.path)) {
+        throw new TypeError("option path is invalid");
+      }
+      str += "; Path=" + opt.path;
+    }
+    if (opt.expires) {
+      var expires = opt.expires;
+      if (!isDate(expires) || isNaN(expires.valueOf())) {
+        throw new TypeError("option expires is invalid");
+      }
+      str += "; Expires=" + expires.toUTCString();
+    }
+    if (opt.httpOnly) {
+      str += "; HttpOnly";
+    }
+    if (opt.secure) {
+      str += "; Secure";
+    }
+    if (opt.partitioned) {
+      str += "; Partitioned";
+    }
+    if (opt.priority) {
+      var priority = typeof opt.priority === "string" ? opt.priority.toLowerCase() : opt.priority;
+      switch (priority) {
+        case "low":
+          str += "; Priority=Low";
+          break;
+        case "medium":
+          str += "; Priority=Medium";
+          break;
+        case "high":
+          str += "; Priority=High";
+          break;
+        default:
+          throw new TypeError("option priority is invalid");
+      }
+    }
+    if (opt.sameSite) {
+      var sameSite = typeof opt.sameSite === "string" ? opt.sameSite.toLowerCase() : opt.sameSite;
+      switch (sameSite) {
+        case true:
+          str += "; SameSite=Strict";
+          break;
+        case "lax":
+          str += "; SameSite=Lax";
+          break;
+        case "strict":
+          str += "; SameSite=Strict";
+          break;
+        case "none":
+          str += "; SameSite=None";
+          break;
+        default:
+          throw new TypeError("option sameSite is invalid");
+      }
+    }
+    return str;
+  }
+  function decode(str) {
+    return str.indexOf("%") !== -1 ? decodeURIComponent(str) : str;
+  }
+  function encode2(val) {
+    return encodeURIComponent(val);
+  }
+  function isDate(val) {
+    return __toString.call(val) === "[object Date]" || val instanceof Date;
+  }
+  function tryDecode(str, decode2) {
+    try {
+      return decode2(str);
+    } catch (e) {
+      return str;
+    }
+  }
+  return cookie;
+}
+var cookieExports = requireCookie();
 const INVALID_COOKIE_CHARACTER_REGEX = /[\x00-\x1F\x7F()<>@,;:"/[\]?={} \t]/;
 function validate_options(options2) {
   if (options2?.path === void 0) {
@@ -10624,8 +9748,8 @@ function get_cookies(request, url) {
         return best_match.options.maxAge === 0 ? void 0 : best_match.value;
       }
       const req_cookies = cookieExports.parse(header, { decode: opts?.decode });
-      const cookie = req_cookies[name];
-      return cookie;
+      const cookie2 = req_cookies[name];
+      return cookie2;
     },
     /**
      * @param {import('cookie').CookieParseOptions} [opts]
@@ -10693,11 +9817,11 @@ function get_cookies(request, url) {
       // cookies sent by the user agent have lowest precedence
       ...initial_cookies
     };
-    for (const cookie of new_cookies.values()) {
-      if (!domain_matches(destination.hostname, cookie.options.domain)) continue;
-      if (!path_matches(destination.pathname, cookie.options.path)) continue;
-      const encoder = cookie.options.encode || encodeURIComponent;
-      combined_cookies[cookie.name] = encoder(cookie.value);
+    for (const cookie2 of new_cookies.values()) {
+      if (!domain_matches(destination.hostname, cookie2.options.domain)) continue;
+      if (!path_matches(destination.pathname, cookie2.options.path)) continue;
+      const encoder = cookie2.options.encode || encodeURIComponent;
+      combined_cookies[cookie2.name] = encoder(cookie2.value);
     }
     if (header2) {
       const parsed = cookieExports.parse(header2, { decode: (value) => value });
@@ -10718,8 +9842,8 @@ function get_cookies(request, url) {
       path = resolve(normalized_url, path);
     }
     const cookie_key = generate_cookie_key(options2.domain, path, name);
-    const cookie = { name, value, options: { ...options2, path } };
-    new_cookies.set(cookie_key, cookie);
+    const cookie2 = { name, value, options: { ...options2, path } };
+    new_cookies.set(cookie_key, cookie2);
   }
   function set_trailing_slash(trailing_slash) {
     normalized_url = normalize_path(url.pathname, trailing_slash);
@@ -10773,8 +9897,8 @@ function create_fetch({ event, options: options2, manifest, state, get_cookie_he
         const decoded = decodeURIComponent(url.pathname);
         if (url.origin !== event.url.origin || base && decoded !== base && !decoded.startsWith(`${base}/`)) {
           if (`.${url.hostname}`.endsWith(`.${event.url.hostname}`) && credentials !== "omit") {
-            const cookie = get_cookie_header(url, request.headers.get("cookie"));
-            if (cookie) request.headers.set("cookie", cookie);
+            const cookie2 = get_cookie_header(url, request.headers.get("cookie"));
+            if (cookie2) request.headers.set("cookie", cookie2);
           }
           return fetch(request);
         }
@@ -10806,9 +9930,9 @@ function create_fetch({ event, options: options2, manifest, state, get_cookie_he
           return await fetch(request);
         }
         if (credentials !== "omit") {
-          const cookie = get_cookie_header(url, request.headers.get("cookie"));
-          if (cookie) {
-            request.headers.set("cookie", cookie);
+          const cookie2 = get_cookie_header(url, request.headers.get("cookie"));
+          if (cookie2) {
+            request.headers.set("cookie", cookie2);
           }
           const authorization = event.request.headers.get("authorization");
           if (authorization && !request.headers.has("authorization")) {
@@ -11246,8 +10370,8 @@ async function internal_respond(request, options2, manifest, state) {
           const value = response.headers.get(key2);
           if (value) headers22.set(key2, value);
         }
-        for (const cookie of get_set_cookies(response.headers)) {
-          headers22.append("set-cookie", cookie);
+        for (const cookie2 of get_set_cookies(response.headers)) {
+          headers22.append("set-cookie", cookie2);
         }
         return new Response(void 0, {
           status: 304,