@celsoft/coordinator 0.0.0 → 0.1.0

package/build/chunk-NVNLDPUJ.js

@@ -0,0 +1,2122 @@
+import { createRequire as __cr } from 'node:module'; const require = __cr(import.meta.url);
+import {
+  ActionFailure,
+  HandledHttpError,
+  HttpError,
+  Redirect,
+  SvelteKitError,
+  ValidationError,
+  error,
+  merge_tracing,
+  record_span,
+  text,
+  with_request_store
+} from "./chunk-SU26PJVX.js";
+import {
+  action_data_not_serializable,
+  action_default_with_named,
+  action_name_reserved,
+  action_response_not_serializable,
+  action_throw_fail,
+  capture_error,
+  handle_error_hook_failed,
+  load_not_plain_object,
+  load_not_serializable,
+  server_api_unavailable,
+  url_search_unavailable_prerender
+} from "./chunk-WWJ3F4QS.js";
+import {
+  DevalueError,
+  MAX_ARRAY_INDEX,
+  enumerable_symbols,
+  get_type,
+  is_buffer,
+  is_plain_object,
+  is_valid_array_index,
+  is_valid_array_len,
+  stringify_key,
+  stringify_string,
+  uneval,
+  valid_array_indices
+} from "./chunk-U5BSBG4R.js";
+
+// build/server/chunks/internal.js
+var verbose = false;
+function enable_verbose_errors() {
+  verbose = true;
+}
+function throw_error(code, message, caller) {
+  const error2 = /* @__PURE__ */ new Error(`${code}
+${message}
+https://svelte.dev/e/kit/${code}`);
+  error2.name = "SvelteKit error";
+  Error.captureStackTrace?.(error2, caller);
+  throw error2;
+}
+var assets = "";
+var app_dir = "_app";
+function set_assets(path2) {
+  assets = path2;
+}
+var symbol = Symbol.for("sveltekit.global_state");
+var state = globalThis[symbol] ??= {};
+var text_encoder = new TextEncoder();
+function stream_from_iterable(iterable) {
+  if (ReadableStream.from) return ReadableStream.from(iterable);
+  const iterator = iterable[Symbol.asyncIterator]();
+  return new ReadableStream({
+    async pull(controller) {
+      const { value, done } = await iterator.next();
+      if (done) controller.close();
+      else controller.enqueue(value);
+    },
+    async cancel(reason) {
+      await iterator.return?.(reason);
+    }
+  });
+}
+function stream_text(head, chunks) {
+  return stream_from_iterable((async function* () {
+    yield text_encoder.encode(head);
+    for await (const chunk of chunks) if (chunk) yield text_encoder.encode(chunk);
+  })());
+}
+var text_decoder = new TextDecoder();
+function base64_encode(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 buffer2 = globalThis.Buffer.from(encoded, "base64");
+    return new Uint8Array(buffer2);
+  }
+  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;
+}
+var DATA_SUFFIX = "/__data.json";
+var HTML_DATA_SUFFIX = ".html__data.json";
+function has_data_suffix(pathname) {
+  return pathname.endsWith(DATA_SUFFIX) || pathname.endsWith(HTML_DATA_SUFFIX);
+}
+function add_data_suffix(pathname) {
+  if (pathname.endsWith(".html")) return pathname.replace(/\.html$/, HTML_DATA_SUFFIX);
+  return pathname.replace(/\/$/, "") + DATA_SUFFIX;
+}
+function strip_data_suffix(pathname) {
+  if (pathname.endsWith(HTML_DATA_SUFFIX)) return pathname.slice(0, -16) + ".html";
+  return pathname.slice(0, -12);
+}
+var ROUTE_SUFFIX = "/__route.js";
+var HTML_ROUTE_SUFFIX = ".html__route.js";
+function has_resolution_suffix(pathname) {
+  return pathname.endsWith(ROUTE_SUFFIX) || pathname.endsWith(HTML_ROUTE_SUFFIX);
+}
+function add_resolution_suffix(pathname) {
+  if (pathname.endsWith(".html")) return pathname.replace(/\.html$/, HTML_ROUTE_SUFFIX);
+  return pathname.replace(/\/$/, "") + ROUTE_SUFFIX;
+}
+function strip_resolution_suffix(pathname) {
+  if (pathname.endsWith(HTML_ROUTE_SUFFIX)) return pathname.slice(0, -15) + ".html";
+  return pathname.slice(0, -11);
+}
+function form_field_array_conflict(_values) {
+  if (verbose) throw_error("form_field_array_conflict", `Invalid array key \`${_values.key}\``, form_field_array_conflict);
+  throw new Error("https://svelte.dev/e/kit/form_field_array_conflict");
+}
+function form_field_duplicate(_values) {
+  if (verbose) throw_error("form_field_duplicate", `Form cannot contain duplicated keys \u2014 \`${_values.name}\` has ${_values.count} values`, form_field_duplicate);
+  throw new Error("https://svelte.dev/e/kit/form_field_duplicate");
+}
+function form_field_forbidden_key(_values) {
+  if (verbose) throw_error("form_field_forbidden_key", `Invalid key \`${_values.key}\`: This key is not allowed to prevent prototype pollution.`, form_field_forbidden_key);
+  throw new Error("https://svelte.dev/e/kit/form_field_forbidden_key");
+}
+function form_field_invalid_name(_values) {
+  if (verbose) throw_error("form_field_invalid_name", `Invalid field name \`${_values.name}\`: field names are written in JS object notation, so keys that would need quoting are not supported. See https://svelte.dev/docs/kit/remote-functions#form-Fields`, form_field_invalid_name);
+  throw new Error("https://svelte.dev/e/kit/form_field_invalid_name");
+}
+function form_field_unbound(_values) {
+  if (verbose) throw_error("form_field_unbound", `Form contained a field that wasn't created with \`form.fields.as(...)\`: \`${_values.name}\``, form_field_unbound);
+  throw new Error("https://svelte.dev/e/kit/form_field_unbound");
+}
+function invalid_export(_values) {
+  if (verbose) throw_error("invalid_export", _values?.file !== void 0 ? `Invalid export \`${_values.key}\` in \`${_values.file}\` (valid exports are ${_values.exports}, or anything with a \`'_'\` prefix)` : `Invalid export \`${_values.key}\` (valid exports are ${_values.exports}, or anything with a \`'_'\` prefix)`, invalid_export);
+  throw new Error("https://svelte.dev/e/kit/invalid_export");
+}
+function invalid_export_location(_values) {
+  if (verbose) throw_error("invalid_export_location", _values?.file !== void 0 ? `Invalid export \`${_values.key}\` in \`${_values.file}\` (\`${_values.key}\` is a valid export in ${_values.locations})` : `Invalid export \`${_values.key}\` (\`${_values.key}\` is a valid export in ${_values.locations})`, invalid_export_location);
+  throw new Error("https://svelte.dev/e/kit/invalid_export_location");
+}
+function param_matcher_async(_values) {
+  if (verbose) throw_error("param_matcher_async", `Async param matchers are not supported`, param_matcher_async);
+  throw new Error("https://svelte.dev/e/kit/param_matcher_async");
+}
+function param_matcher_result_invalid(_values) {
+  if (verbose) throw_error("param_matcher_result_invalid", `Param matcher must return a string, number, boolean, or bigint`, param_matcher_result_invalid);
+  throw new Error("https://svelte.dev/e/kit/param_matcher_result_invalid");
+}
+function url_hash_unavailable(_values) {
+  if (verbose) throw_error("url_hash_unavailable", `Cannot access \`event.url.hash\`. Consider using \`page.url.hash\` inside a component instead`, url_hash_unavailable);
+  throw new Error("https://svelte.dev/e/kit/url_hash_unavailable");
+}
+var escape_sequence_pattern = /\[([ux])\+([^\]]+)\]/;
+function run_matcher(matcher, value) {
+  const result = matcher["~standard"].validate(value);
+  if (result instanceof Promise) param_matcher_async();
+  if (result.issues) return { success: false };
+  const parsed = result.value;
+  if (typeof parsed !== "string" && typeof parsed !== "number" && typeof parsed !== "boolean" && typeof parsed !== "bigint") param_matcher_result_invalid();
+  return {
+    success: true,
+    value: parsed
+  };
+}
+function exec(match, params, matchers) {
+  const result = {};
+  const values = match.slice(1);
+  const values_needing_match = values.filter((value) => value !== void 0);
+  let buffered = 0;
+  for (let i = 0; i < params.length; i += 1) {
+    const param = params[i];
+    let value = values[i - buffered];
+    if (param.chained && param.rest && buffered) {
+      value = values.slice(i - buffered, i + 1).filter((s) => s).join("/");
+      buffered = 0;
+    }
+    if (value === void 0) {
+      if (param.rest) value = "";
+      else continue;
+    }
+    const decoded = decodeURIComponent(value);
+    if (param.matcher) {
+      const outcome = run_matcher(matchers[param.matcher], decoded);
+      if (!outcome.success) {
+        if (param.optional && param.chained) {
+          buffered++;
+          continue;
+        }
+        return;
+      }
+      result[param.name] = outcome.value;
+    } else result[param.name] = decoded;
+    const next_param = params[i + 1];
+    const next_value = values[i + 1];
+    if (next_param && !next_param.rest && next_param.optional && next_value && param.chained) buffered = 0;
+    if (!next_param && !next_value && Object.keys(result).length === values_needing_match.length) buffered = 0;
+  }
+  if (buffered) return;
+  return result;
+}
+new RegExp(`${escape_sequence_pattern.source}|${/\[(\[)?(\.\.\.)?([\w-]+?)(?:=([\w-]+))?\]\]?/g.source}`, "g");
+function find_route(path2, routes, matchers) {
+  for (const route of routes) {
+    const match = route.pattern.exec(path2);
+    if (!match) continue;
+    const matched = exec(match, route.params, matchers);
+    if (matched) return {
+      route,
+      params: matched
+    };
+  }
+  return null;
+}
+var internal = new URL("a://");
+function resolve(base, path2) {
+  if (path2[0] === "/" && path2[1] === "/") return path2;
+  let url2 = new URL(base, internal);
+  url2 = new URL(path2, url2);
+  return url2.protocol === internal.protocol ? url2.pathname + url2.search + url2.hash : url2.href;
+}
+function relative_pathname(from, to) {
+  const segment = to.replace(/\/$/, "").split("/").at(-1);
+  return from.endsWith("/") ? `../${segment}` : `./${segment}/`;
+}
+function normalize_path(path2, trailing_slash) {
+  if (path2 === "/" || trailing_slash === "ignore") return path2;
+  if (trailing_slash === "never") return path2.endsWith("/") ? path2.slice(0, -1) : path2;
+  else if (trailing_slash === "always" && !path2.endsWith("/")) return path2 + "/";
+  return path2;
+}
+function decode_pathname(pathname) {
+  return pathname.split("%25").map(decodeURI).join("%25");
+}
+function make_trackable(url2, callback, search_params_callback, allow_hash = false) {
+  const tracked = new URL(url2);
+  Object.defineProperty(tracked, "searchParams", {
+    value: new Proxy(tracked.searchParams, { get(obj, key) {
+      if (key === "get" || key === "getAll" || key === "has") return (param, ...rest) => {
+        search_params_callback(param);
+        return obj[key](param, ...rest);
+      };
+      callback();
+      const value = Reflect.get(obj, key);
+      return typeof value === "function" ? value.bind(obj) : value;
+    } }),
+    enumerable: true,
+    configurable: true
+  });
+  const tracked_url_properties = [
+    "href",
+    "pathname",
+    "search",
+    "toString",
+    "toJSON"
+  ];
+  if (allow_hash) tracked_url_properties.push("hash");
+  for (const property of tracked_url_properties) Object.defineProperty(tracked, property, {
+    get() {
+      callback();
+      return url2[property];
+    },
+    enumerable: true,
+    configurable: true
+  });
+  tracked[Symbol.for("nodejs.util.inspect.custom")] = (_depth, opts, inspect) => {
+    return inspect(url2, opts);
+  };
+  tracked.searchParams[Symbol.for("nodejs.util.inspect.custom")] = (_depth, opts, inspect) => {
+    return inspect(url2.searchParams, opts);
+  };
+  if (!allow_hash) disable_hash(tracked);
+  return tracked;
+}
+function disable_hash(url2) {
+  allow_nodejs_console_log(url2);
+  Object.defineProperty(url2, "hash", { get() {
+    return url_hash_unavailable();
+  } });
+}
+function disable_search(url2) {
+  allow_nodejs_console_log(url2);
+  for (const property of ["search", "searchParams"]) Object.defineProperty(url2, property, { get() {
+    return url_search_unavailable_prerender({ property });
+  } });
+}
+function allow_nodejs_console_log(url2) {
+  url2[Symbol.for("nodejs.util.inspect.custom")] = (_depth, opts, inspect) => {
+    return inspect(new URL(url2), opts);
+  };
+}
+var error_template_default = ({ status, message }) => '<!doctype html>\n<html lang="en">\n	<head>\n		<meta charset="utf-8" />\n		<title>' + message + `</title>
+
+		<style>
+			body {
+				--bg: white;
+				--fg: #222;
+				--divider: #ccc;
+				background: var(--bg);
+				color: var(--fg);
+				font-family:
+					system-ui,
+					-apple-system,
+					BlinkMacSystemFont,
+					'Segoe UI',
+					Roboto,
+					Oxygen,
+					Ubuntu,
+					Cantarell,
+					'Open Sans',
+					'Helvetica Neue',
+					sans-serif;
+				display: flex;
+				align-items: center;
+				justify-content: center;
+				height: 100vh;
+				margin: 0;
+			}
+
+			.error {
+				display: flex;
+				align-items: center;
+				max-width: 32rem;
+				margin: 0 1rem;
+			}
+
+			.status {
+				font-weight: 200;
+				font-size: 3rem;
+				line-height: 1;
+				position: relative;
+				top: -0.05rem;
+			}
+
+			.message {
+				border-left: 1px solid var(--divider);
+				padding: 0 0 0 1rem;
+				margin: 0 0 0 1rem;
+				min-height: 2.5rem;
+				display: flex;
+				align-items: center;
+			}
+
+			.message h1 {
+				font-weight: 400;
+				font-size: 1em;
+				margin: 0;
+			}
+
+			@media (prefers-color-scheme: dark) {
+				body {
+					--bg: #222;
+					--fg: #ddd;
+					--divider: #666;
+				}
+			}
+		</style>
+	</head>
+	<body>
+		<div class="error">
+			<span class="status">` + status + '</span>\n			<div class="message">\n				<h1>' + message + "</h1>\n			</div>\n		</div>\n	</body>\n</html>\n";
+var options = {
+  app_template_contains_nonce: false,
+  csp: {
+    "mode": "auto",
+    "directives": {
+      "upgrade-insecure-requests": false,
+      "block-all-mixed-content": false
+    },
+    "reportOnly": {
+      "upgrade-insecure-requests": false,
+      "block-all-mixed-content": false
+    }
+  },
+  csrf_trusted_origins: [],
+  service_worker_options: void 0,
+  templates: {
+    app: ({ head, body, assets: assets2, nonce, env }) => '<!doctype html>\n<html lang="en" data-theme="dark">\n	<head>\n		<meta charset="utf-8" />\n		<meta name="viewport" content="width=device-width,initial-scale=1" />\n		<meta name="color-scheme" content="dark light" />\n		<link rel="icon" href="' + assets2 + '/favicon.ico" sizes="48x48" />\n		<link rel="icon" href="' + assets2 + '/favicon.svg" type="image/svg+xml" />\n		<link rel="apple-touch-icon" href="' + assets2 + '/apple-touch-icon.png" />\n		<link rel="manifest" href="' + assets2 + `/manifest.webmanifest" />
+		<script>
+			// Service Dark is dark first; light only when the system prefers it.
+			if (matchMedia('(prefers-color-scheme: light)').matches) document.documentElement.dataset.theme = 'light';
+		</script>
+		` + head + '\n	</head>\n	<body data-sveltekit-preload-data="off">\n		<div style="display: contents">' + body + "</div>\n	</body>\n</html>\n",
+    error: error_template_default
+  }
+};
+async function get_hooks() {
+  let handle;
+  let handleFetch;
+  let handleError;
+  let init;
+  ({ handle, handleFetch, handleError, init } = await import("./hooks.server-34IMHRKC.js"));
+  let reroute;
+  let transport;
+  return {
+    handle,
+    handleFetch,
+    handleError,
+    init,
+    reroute,
+    transport
+  };
+}
+function encode_native(array_buffer) {
+  return new Uint8Array(array_buffer).toBase64();
+}
+function decode_native(base64) {
+  return Uint8Array.fromBase64(base64).buffer;
+}
+function encode_buffer(array_buffer) {
+  return Buffer.from(array_buffer).toString("base64");
+}
+function decode_buffer(base64) {
+  return Uint8Array.from(Buffer.from(base64, "base64")).buffer;
+}
+function encode_legacy(array_buffer) {
+  const array = new Uint8Array(array_buffer);
+  let binary = "";
+  const chunk_size = 32768;
+  for (let i = 0; i < array.length; i += chunk_size) {
+    const chunk = array.subarray(i, i + chunk_size);
+    binary += String.fromCharCode.apply(null, chunk);
+  }
+  return btoa(binary);
+}
+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;
+}
+var native = typeof Uint8Array.fromBase64 === "function";
+var buffer = typeof process === "object" && process.versions?.node !== void 0;
+var encode64 = native ? encode_native : buffer ? encode_buffer : encode_legacy;
+var decode64 = native ? decode_native : buffer ? decode_buffer : decode_legacy;
+function merge_operations(defaults, overrides) {
+  if (!overrides) return defaults;
+  const merged = {};
+  for (const key of Object.keys(defaults)) merged[key] = overrides[key] ?? defaults[key];
+  return merged;
+}
+var NOT_PLAIN = /* @__PURE__ */ Object.freeze({ kind: "not-plain" });
+var SYMBOL_KEYS = /* @__PURE__ */ Object.freeze({ kind: "symbol-keys" });
+var default_stringify_operations = /* @__PURE__ */ Object.freeze({
+  identify: (value) => value,
+  typeOf: (value) => value === null ? "null" : typeof value,
+  toPrimitive: (value) => value,
+  tagOf: (value) => get_type(value),
+  isThenable: (value) => typeof value.then === "function",
+  toPromise: (thenable) => Promise.resolve(thenable),
+  unbox: (boxed) => boxed.valueOf(),
+  toISOString: (date) => isNaN(date.getDate()) ? "" : date.toISOString(),
+  toStringValue: (value) => value.toString(),
+  regExpInfo: (regexp) => ({
+    source: regexp.source,
+    flags: regexp.flags
+  }),
+  valuesOf: (set) => set,
+  entriesOf: (map) => map,
+  viewInfo: (view) => {
+    if (is_buffer(view)) view = new Uint8Array(view);
+    return {
+      buffer: view.buffer,
+      byteOffset: view.byteOffset,
+      byteLength: view.byteLength,
+      length: view.length,
+      bufferByteLength: view.buffer.byteLength
+    };
+  },
+  toArrayBuffer: (buffer2) => buffer2,
+  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]
+});
+var array_buffer_byte_length = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "byteLength").get;
+var shared_array_buffer_byte_length = typeof SharedArrayBuffer === "undefined" ? void 0 : Object.getOwnPropertyDescriptor(SharedArrayBuffer.prototype, "byteLength").get;
+var default_parse_operations = /* @__PURE__ */ Object.freeze({
+  fromPrimitive: (primitive) => primitive,
+  fromISOString: (iso) => new Date(iso),
+  fromStringValue: (tag, text2) => {
+    if (tag === "URL") return new URL(text2);
+    if (tag === "URLSearchParams") return new URLSearchParams(text2);
+    return Temporal[tag.slice(9)].from(text2);
+  },
+  fromArrayBuffer: (buffer2) => buffer2,
+  fromRegExpInfo: (source, flags) => new RegExp(source, flags),
+  fromViewInfo: (tag, buffer2, byteOffset, length) => {
+    try {
+      array_buffer_byte_length.call(buffer2);
+    } catch (error2) {
+      if (!shared_array_buffer_byte_length) throw error2;
+      shared_array_buffer_byte_length.call(buffer2);
+    }
+    const Constructor = globalThis[tag];
+    return byteOffset !== void 0 ? new Constructor(buffer2, byteOffset, length) : new Constructor(buffer2);
+  },
+  box: (value) => Object(value),
+  createArray: (length) => new Array(length),
+  createSparseArray: (length) => {
+    const array = [];
+    array[MAX_ARRAY_INDEX] = void 0;
+    delete array[MAX_ARRAY_INDEX];
+    array.length = length;
+    return array;
+  },
+  createObject: () => ({}),
+  createNullPrototypeObject: () => /* @__PURE__ */ Object.create(null),
+  createSet: () => /* @__PURE__ */ new Set(),
+  createMap: () => /* @__PURE__ */ new Map(),
+  set: (target, key, value) => {
+    target[key] = value;
+  },
+  addValue: (set, value) => {
+    set.add(value);
+  },
+  addEntry: (map, key, value) => {
+    map.set(key, value);
+  }
+});
+function parse$1(serialized, revivers, options2) {
+  return unflatten(JSON.parse(serialized), revivers, options2);
+}
+function unflatten(parsed, revivers, options2) {
+  const ops = merge_operations(default_parse_operations, options2?.operations);
+  if (typeof parsed === "number") return hydrate(parsed, true);
+  if (!Array.isArray(parsed) || parsed.length === 0) throw new Error("Invalid input");
+  const values = parsed;
+  const hydrated = Array(values.length);
+  let hydrating = null;
+  function hydrate(index, standalone = false) {
+    if (index === -1) return ops.fromPrimitive(void 0);
+    if (index === -3) return ops.fromPrimitive(NaN);
+    if (index === -4) return ops.fromPrimitive(Infinity);
+    if (index === -5) return ops.fromPrimitive(-Infinity);
+    if (index === -6) return ops.fromPrimitive(-0);
+    if (standalone || typeof index !== "number") throw new Error(`Invalid input`);
+    if (index in hydrated) return hydrated[index];
+    if (index >= values.length) throw new Error(`Invalid input`);
+    const value = values[index];
+    if (!value || typeof value !== "object") hydrated[index] = ops.fromPrimitive(value);
+    else if (Array.isArray(value)) {
+      if (typeof value[0] === "string") {
+        const type = value[0];
+        const reviver = revivers && Object.hasOwn(revivers, type) ? revivers[type] : void 0;
+        if (reviver) {
+          let i = value[1];
+          if (typeof i !== "number") i = values.push(value[1]) - 1;
+          if (Object.hasOwn(hydrated, i)) return hydrated[index] = reviver(hydrated[i]);
+          hydrating ??= /* @__PURE__ */ new Set();
+          if (hydrating.has(i)) throw new Error("Invalid circular reference");
+          hydrating.add(i);
+          hydrated[index] = reviver(hydrate(i));
+          hydrating.delete(i);
+          return hydrated[index];
+        }
+        switch (type) {
+          case "Date":
+            hydrated[index] = ops.fromISOString(value[1]);
+            break;
+          case "Set":
+            const set = ops.createSet();
+            hydrated[index] = set;
+            for (let i = 1; i < value.length; i += 1) ops.addValue(set, hydrate(value[i]));
+            break;
+          case "Map":
+            const map = ops.createMap();
+            hydrated[index] = map;
+            for (let i = 1; i < value.length; i += 2) ops.addEntry(map, hydrate(value[i]), hydrate(value[i + 1]));
+            break;
+          case "RegExp":
+            hydrated[index] = ops.fromRegExpInfo(value[1], value[2]);
+            break;
+          case "Object": {
+            const wrapped_index = value[1];
+            if (typeof values[wrapped_index] === "object" && values[wrapped_index][0] !== "BigInt") 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) {
+              const key = value[i];
+              if (typeof key !== "string") throw new Error("Cannot parse an object with a non-string key");
+              if (key === "__proto__") throw new Error("Cannot parse an object with a `__proto__` property");
+              ops.set(obj, key, hydrate(value[i + 1]));
+            }
+            break;
+          case "Int8Array":
+          case "Uint8Array":
+          case "Uint8ClampedArray":
+          case "Int16Array":
+          case "Uint16Array":
+          case "Float16Array":
+          case "Int32Array":
+          case "Uint32Array":
+          case "Float32Array":
+          case "Float64Array":
+          case "BigInt64Array":
+          case "BigUint64Array":
+          case "DataView": {
+            if (values[value[1]][0] !== "ArrayBuffer") throw new Error("Invalid data");
+            const buffer2 = hydrate(value[1]);
+            hydrated[index] = ops.fromViewInfo(type, buffer2, value[2], value[3]);
+            break;
+          }
+          case "ArrayBuffer": {
+            const base64 = value[1];
+            if (typeof base64 !== "string") throw new Error("Invalid ArrayBuffer encoding");
+            hydrated[index] = ops.fromArrayBuffer(decode64(base64));
+            break;
+          }
+          case "URL":
+          case "URLSearchParams":
+          case "Temporal.Duration":
+          case "Temporal.Instant":
+          case "Temporal.PlainDate":
+          case "Temporal.PlainTime":
+          case "Temporal.PlainDateTime":
+          case "Temporal.PlainMonthDay":
+          case "Temporal.PlainYearMonth":
+          case "Temporal.ZonedDateTime":
+            hydrated[index] = ops.fromStringValue(type, value[1]);
+            break;
+          default:
+            throw new Error(`Unknown type ${type}`);
+        }
+      } else if (value[0] === -7) {
+        const len = value[1];
+        if (!is_valid_array_len(len)) throw new Error("Invalid input");
+        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 === -2) continue;
+          ops.set(array, i, hydrate(n));
+        }
+      }
+    } else {
+      const object = ops.createObject();
+      hydrated[index] = object;
+      for (const key of Object.keys(value)) {
+        if (key === "__proto__") throw new Error("Cannot parse an object with a `__proto__` property");
+        ops.set(object, key, hydrate(value[key]));
+      }
+    }
+    return hydrated[index];
+  }
+  return hydrate(0);
+}
+function stringify$1(value, reducers, options2) {
+  const stringified = run(false, value, reducers, options2);
+  return typeof stringified === "string" ? stringified : `[${stringified.join(",")}]`;
+}
+function run(async, value, reducers, options2) {
+  const ops = merge_operations(default_stringify_operations, options2?.operations);
+  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) {
+    const type = ops.typeOf(thing);
+    if (type === "undefined") return -1;
+    let number;
+    if (type === "number") {
+      number = ops.toPrimitive(thing);
+      if (Number.isNaN(number)) return -3;
+      if (number === Infinity) return -4;
+      if (number === -Infinity) return -5;
+      if (number === 0 && 1 / number < 0) return -6;
+    }
+    const id = ops.identify(thing);
+    if (indexes.has(id)) return indexes.get(id);
+    index2 ??= p++;
+    indexes.set(id, index2);
+    for (const { key, fn } of custom) {
+      const value2 = fn(thing);
+      if (value2) {
+        stringified[index2] = `["${key}",${flatten(value2)}]`;
+        return index2;
+      }
+    }
+    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);
+    let str = "";
+    if (type !== "object") str = stringify_primitive(type === "number" ? number : ops.toPrimitive(thing));
+    else if (ops.isThenable(thing)) {
+      if (!async) throw new DevalueError(`Cannot stringify a Promise or thenable \u2014 use stringifyAsync instead`, keys, thing, value);
+      str = ops.toPromise(thing).then((value2) => {
+        const i = flatten(value2, index2);
+        if (i < 0) stringified[index2] = i;
+      });
+      str.catch(() => {
+      });
+    } else {
+      const tag = ops.tagOf(thing);
+      switch (tag) {
+        case "Number":
+        case "String":
+        case "Boolean":
+        case "BigInt":
+          str = `["Object",${flatten(ops.unbox(thing))}]`;
+          break;
+        case "Date":
+          str = `["Date","${ops.toISOString(thing)}"]`;
+          break;
+        case "URL":
+          str = `["URL",${stringify_string(ops.toStringValue(thing))}]`;
+          break;
+        case "URLSearchParams":
+          str = `["URLSearchParams",${stringify_string(ops.toStringValue(thing))}]`;
+          break;
+        case "RegExp":
+          const { source, flags } = ops.regExpInfo(thing);
+          str = flags ? `["RegExp",${stringify_string(source)},"${flags}"]` : `["RegExp",${stringify_string(source)}]`;
+          break;
+        case "Array": {
+          let mostly_dense = false;
+          const length = ops.lengthOf(thing);
+          str = "[";
+          for (let i = 0; i < length; i += 1) {
+            if (i > 0) str += ",";
+            if (ops.hasOwn(thing, i)) {
+              keys.push(`[${i}]`);
+              str += flatten(ops.get(thing, i));
+              keys.pop();
+            } else if (mostly_dense) str += -2;
+            else {
+              const populated_keys = ops.indicesOf(thing);
+              const population = populated_keys.length;
+              const d = String(length).length;
+              if ((length - population) * 3 > 4 + d + population * (d + 1)) {
+                str = "[-7," + length;
+                for (let j = 0; j < populated_keys.length; j++) {
+                  const key = populated_keys[j];
+                  keys.push(`[${key}]`);
+                  str += "," + key + "," + flatten(ops.get(thing, key));
+                  keys.pop();
+                }
+                break;
+              } else {
+                mostly_dense = true;
+                str += -2;
+              }
+            }
+          }
+          str += "]";
+          break;
+        }
+        case "Set":
+          str = '["Set"';
+          for (const value2 of ops.valuesOf(thing)) str += `,${flatten(value2)}`;
+          str += "]";
+          break;
+        case "Map":
+          str = '["Map"';
+          for (const [key, value2] 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(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": {
+          const info = ops.viewInfo(thing);
+          str = '["' + tag + '",' + flatten(info.buffer);
+          if (info.byteLength !== info.bufferByteLength) str += `,${info.byteOffset},${info.length}`;
+          str += "]";
+          break;
+        }
+        case "DataView": {
+          const info = ops.viewInfo(thing);
+          str = '["' + tag + '",' + flatten(info.buffer);
+          if (info.byteLength !== info.bufferByteLength) str += `,${info.byteOffset},${info.byteLength}`;
+          str += "]";
+          break;
+        }
+        case "ArrayBuffer":
+          str = `["ArrayBuffer","${encode64(ops.toArrayBuffer(thing))}"]`;
+          break;
+        case "Temporal.Duration":
+        case "Temporal.Instant":
+        case "Temporal.PlainDate":
+        case "Temporal.PlainTime":
+        case "Temporal.PlainDateTime":
+        case "Temporal.PlainMonthDay":
+        case "Temporal.PlainYearMonth":
+        case "Temporal.ZonedDateTime":
+          str = `["${tag}",${stringify_string(ops.toStringValue(thing))}]`;
+          break;
+        default: {
+          const shape = ops.shapeOf(thing);
+          if (shape.kind === "not-plain") 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[index2] = str;
+    return index2;
+  }
+  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 (-1).toString();
+  if (thing === 0 && 1 / thing < 0) return (-6).toString();
+  if (type === "bigint") return `["BigInt","${thing}"]`;
+  return String(thing);
+}
+function noop() {
+}
+function once(fn) {
+  let done = false;
+  let result;
+  return () => {
+    if (done) return result;
+    done = true;
+    return result = fn();
+  };
+}
+function disallow_on_server(name, parens = "(...)") {
+  return () => {
+    server_api_unavailable({ name: `${name}${parens}` });
+  };
+}
+function set_nested_value(object, field, value) {
+  deep_set(object, split_path(field.name), value);
+}
+function parse_form_key(form_id, key) {
+  const suffix = "/" + form_id;
+  let name = key;
+  let image_coordinate = "";
+  if (name.startsWith("i:") && (name.endsWith(suffix + ".x") || name.endsWith(suffix + ".y"))) {
+    image_coordinate = name[name.length - 1];
+    name = name.slice(0, -2);
+  }
+  if (!name.endsWith(suffix)) form_field_unbound({ name });
+  name = name.slice(0, -suffix.length);
+  let type = null;
+  if (name.startsWith("n:")) {
+    name = name.slice(2);
+    type = "number";
+  } else if (name.startsWith("b:")) {
+    name = name.slice(2);
+    type = "boolean";
+  } else if (name.startsWith("i:")) {
+    name = name.slice(2);
+    type = "number";
+  }
+  const is_array = name.endsWith("[]");
+  if (is_array) name = name.slice(0, -2);
+  if (image_coordinate) name += "." + image_coordinate;
+  return {
+    name,
+    type,
+    is_array
+  };
+}
+function coerce_form_value(type, value) {
+  if (Array.isArray(value)) return value.map((value2) => coerce_form_value(type, value2));
+  if (type === "number") return value === "" ? void 0 : parseFloat(value);
+  if (type === "boolean") return value === "on";
+  return value;
+}
+var DELETE_KEY = {};
+function group_formdata(data) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const [name, value] of data) {
+    const values = grouped.get(name);
+    if (values) values.push(value);
+    else grouped.set(name, [value]);
+  }
+  return grouped;
+}
+function convert_formdata(form_id, data) {
+  const result = {};
+  for (const [field_name, values] of group_formdata(data)) {
+    const field = parse_form_key(form_id, field_name);
+    const entries = values.filter((entry) => typeof entry === "string" || entry.name !== "" || entry.size > 0);
+    if (entries.length === 0 && !field.is_array) continue;
+    if (entries.length > 1 && !field.is_array) form_field_duplicate({
+      name: field.name,
+      count: String(entries.length)
+    });
+    set_nested_value(result, field, coerce_form_value(field.type, field.is_array ? entries : entries[0]));
+  }
+  return result;
+}
+var BINARY_FORM_CONTENT_TYPE = "application/x-sveltekit-formdata";
+var BINARY_FORM_VERSION = 0;
+var HEADER_BYTES = 7;
+async function deserialize_binary_form(request, form_id) {
+  if (request.headers.get("content-type") !== "application/x-sveltekit-formdata") {
+    const form_data = await request.formData();
+    return {
+      data: convert_formdata(form_id, form_data),
+      meta: {},
+      form_data
+    };
+  }
+  if (!request.body) throw deserialize_error("no body");
+  const reader = request.body.getReader();
+  const chunks = [];
+  function get_chunk(index) {
+    if (index in chunks) return chunks[index];
+    let i = chunks.length;
+    while (i <= index) {
+      const previous = chunks[i - 1] ?? Promise.resolve(void 0);
+      chunks[i] = previous.then(() => reader.read()).then((chunk) => chunk.value);
+      i++;
+    }
+    return chunks[index];
+  }
+  async function get_buffer(offset, length) {
+    const parts = [];
+    let total = 0;
+    for await (const part of read_range(get_chunk, offset, length)) {
+      parts.push(part);
+      total += part.byteLength;
+    }
+    if (total < length || parts.length === 0) return null;
+    if (parts.length === 1) return parts[0];
+    const buffer2 = new Uint8Array(length);
+    let cursor = 0;
+    for (const part of parts) {
+      buffer2.set(part, cursor);
+      cursor += part.byteLength;
+    }
+    return buffer2;
+  }
+  const header = await get_buffer(0, HEADER_BYTES);
+  if (!header) throw deserialize_error("too short");
+  if (header[0] !== BINARY_FORM_VERSION) throw deserialize_error(`got version ${header[0]}, expected version ${BINARY_FORM_VERSION}`);
+  const header_view = new DataView(header.buffer, header.byteOffset, header.byteLength);
+  const data_length = header_view.getUint32(1, true);
+  const file_offsets_length = header_view.getUint16(5, true);
+  const data_buffer = await get_buffer(HEADER_BYTES, data_length);
+  if (!data_buffer) throw deserialize_error("data too short");
+  let file_offsets;
+  let files_start_offset;
+  if (file_offsets_length > 0) {
+    const file_offsets_buffer = await get_buffer(HEADER_BYTES + data_length, file_offsets_length);
+    if (!file_offsets_buffer) throw deserialize_error("file offset table too short");
+    const parsed_offsets = JSON.parse(text_decoder.decode(file_offsets_buffer));
+    if (!Array.isArray(parsed_offsets) || parsed_offsets.some((n) => typeof n !== "number" || !Number.isInteger(n) || n < 0)) throw deserialize_error("invalid file offset table");
+    file_offsets = parsed_offsets;
+    files_start_offset = HEADER_BYTES + data_length + file_offsets_length;
+  }
+  const file_spans = [];
+  const [data, meta] = parse$1(text_decoder.decode(data_buffer), { File: ([name, type, size, last_modified, index]) => {
+    if (typeof name !== "string" || typeof type !== "string" || !Number.isSafeInteger(size) || size < 0 || !Number.isSafeInteger(last_modified) || !Number.isSafeInteger(index) || index < 0) throw deserialize_error("invalid file metadata");
+    let offset = file_offsets[index];
+    if (offset === void 0) throw deserialize_error("duplicate file offset table index");
+    file_offsets[index] = void 0;
+    offset += files_start_offset;
+    file_spans.push({
+      offset,
+      size
+    });
+    return new Proxy(new LazyFile(name, type, size, last_modified, get_chunk, offset), { getPrototypeOf() {
+      return File.prototype;
+    } });
+  } });
+  file_spans.sort((a, b) => a.offset - b.offset || a.size - b.size);
+  for (let i = 1; i < file_spans.length; i++) {
+    const previous = file_spans[i - 1];
+    const current = file_spans[i];
+    const previous_end = previous.offset + previous.size;
+    if (previous_end < current.offset) throw deserialize_error("gaps in file data");
+    if (previous_end > current.offset) throw deserialize_error("overlapping file data");
+  }
+  (async () => {
+    let has_more = true;
+    while (has_more) has_more = !!await get_chunk(chunks.length);
+  })().catch(noop);
+  return {
+    data,
+    meta,
+    form_data: null
+  };
+}
+function deserialize_error(message) {
+  return new SvelteKitError(400, "Bad Request", `Could not deserialize binary form: ${message}`);
+}
+async function* read_range(get_chunk, offset, length) {
+  let chunk_start = 0;
+  for (let index = 0; ; index++) {
+    const chunk = await get_chunk(index);
+    if (!chunk) return;
+    const chunk_end = chunk_start + chunk.byteLength;
+    if (chunk_end > offset) {
+      yield chunk.subarray(Math.max(0, offset - chunk_start), Math.min(chunk.byteLength, offset + length - chunk_start));
+      if (offset + length <= chunk_end) return;
+    }
+    chunk_start = chunk_end;
+  }
+}
+var LazyFile = class LazyFile2 {
+  /** @type {(index: number) => Promise<Uint8Array<ArrayBuffer> | undefined>} */
+  #get_chunk;
+  /** @type {number} */
+  #offset;
+  /**
+  * @param {string} name
+  * @param {string} type
+  * @param {number} size
+  * @param {number} last_modified
+  * @param {(index: number) => Promise<Uint8Array<ArrayBuffer> | undefined>} get_chunk
+  * @param {number} offset
+  */
+  constructor(name, type, size, last_modified, get_chunk, offset) {
+    this.name = name;
+    this.type = type;
+    this.size = size;
+    this.lastModified = last_modified;
+    this.webkitRelativePath = "";
+    this.#get_chunk = get_chunk;
+    this.#offset = offset;
+    this.arrayBuffer = this.arrayBuffer.bind(this);
+    this.bytes = this.bytes.bind(this);
+    this.slice = this.slice.bind(this);
+    this.stream = this.stream.bind(this);
+    this.text = this.text.bind(this);
+  }
+  /** @type {ArrayBuffer | undefined} */
+  #buffer;
+  async arrayBuffer() {
+    this.#buffer ??= await new Response(this.stream()).arrayBuffer();
+    return this.#buffer;
+  }
+  async bytes() {
+    return new Uint8Array(await this.arrayBuffer());
+  }
+  /**
+  * @param {number=} start
+  * @param {number=} end
+  * @param {string=} contentType
+  */
+  slice(start = 0, end = this.size, contentType = this.type) {
+    if (start < 0) start = Math.max(this.size + start, 0);
+    else start = Math.min(start, this.size);
+    if (end < 0) end = Math.max(this.size + end, 0);
+    else end = Math.min(end, this.size);
+    const size = Math.max(end - start, 0);
+    return new LazyFile2(this.name, contentType, size, this.lastModified, this.#get_chunk, this.#offset + start);
+  }
+  stream() {
+    const range = read_range(this.#get_chunk, this.#offset, this.size);
+    const size = this.size;
+    return stream_from_iterable((async function* () {
+      let cursor = 0;
+      for await (const chunk of range) {
+        cursor += chunk.byteLength;
+        yield chunk;
+      }
+      if (cursor < size) throw new Error("incomplete file data");
+    })());
+  }
+  async text() {
+    return text_decoder.decode(await this.arrayBuffer());
+  }
+};
+var path_regex = /^[a-zA-Z_$]\w*(\.[a-zA-Z_$]\w*|\[\d+\])*$/;
+function split_path(path2) {
+  if (!path_regex.test(path2)) form_field_invalid_name({ name: path2 });
+  return path2.split(/\.|\[|\]/).filter(Boolean);
+}
+function check_prototype_pollution(key) {
+  if (key === "__proto__" || key === "constructor" || key === "prototype") form_field_forbidden_key({ key });
+}
+function deep_set(object, keys, value) {
+  let current = object;
+  for (let i = 0; i < keys.length - 1; i += 1) {
+    const key = keys[i];
+    check_prototype_pollution(key);
+    const is_array = /^\d+$/.test(keys[i + 1]);
+    const inner = Object.hasOwn(current, key) ? current[key] : void 0;
+    const exists = inner != null;
+    if (exists && is_array !== Array.isArray(inner)) form_field_array_conflict({ key: keys[i + 1] });
+    if (!exists) {
+      if (value === DELETE_KEY) return;
+      current[key] = is_array ? [] : {};
+    }
+    current = current[key];
+  }
+  const final_key = keys[keys.length - 1];
+  check_prototype_pollution(final_key);
+  if (value === DELETE_KEY) delete current[final_key];
+  else current[final_key] = value;
+}
+function negotiate(accept, types) {
+  const parts = [];
+  accept.split(",").forEach((str, i) => {
+    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
+      });
+    }
+  });
+  parts.sort((a, b) => {
+    if (a.q !== b.q) return b.q - a.q;
+    if (a.subtype === "*" !== (b.subtype === "*")) return a.subtype === "*" ? 1 : -1;
+    if (a.type === "*" !== (b.type === "*")) return a.type === "*" ? 1 : -1;
+    return a.i - b.i;
+  });
+  let accepted;
+  let min_priority = Infinity;
+  for (const mimetype of types) {
+    const [type, subtype] = mimetype.split("/");
+    const priority = parts.findIndex((part) => (part.type === type || part.type === "*") && (part.subtype === subtype || part.subtype === "*"));
+    if (priority !== -1 && priority < min_priority) {
+      accepted = mimetype;
+      min_priority = priority;
+    }
+  }
+  return accepted;
+}
+function matches_content_type(header, ...types) {
+  const type = header?.split(";", 1)[0].trim() ?? "";
+  return types.includes(type.toLowerCase());
+}
+function is_form_content_type(request) {
+  return matches_content_type(request.headers.get("content-type"), "application/x-www-form-urlencoded", "multipart/form-data", "text/plain", BINARY_FORM_CONTENT_TYPE);
+}
+var uneval2 = () => {
+  throw new Error("");
+};
+var stringify = () => {
+  throw new Error("");
+};
+var parse = () => {
+  throw new Error("");
+};
+var encoders = {};
+var decoders = {};
+var has_custom_transporters = false;
+function init_transport(transport) {
+  const transporters = Object.entries(transport);
+  has_custom_transporters = transporters.length > 0;
+  const replacer = (thing) => {
+    for (const key of Object.keys(transport)) {
+      const encoded = transport[key].encode(thing);
+      if (encoded) return `app.decode('${key}', ${uneval(encoded, replacer)})`;
+    }
+  };
+  encoders = Object.fromEntries(transporters.map(([k, v]) => [k, v.encode]));
+  decoders = Object.fromEntries(transporters.map(([k, v]) => [k, v.decode]));
+  uneval2 = (data) => uneval(data, replacer);
+  stringify = (data) => stringify$1(data, encoders);
+  parse = (data) => parse$1(data, decoders);
+}
+function fetch_cache_url(url2, page) {
+  return url2.origin === page.origin ? url2.href.slice(page.origin.length) : url2.href;
+}
+var INVALIDATED_PARAM = "x-sveltekit-invalidated";
+var TRAILING_SLASH_PARAM = "x-sveltekit-trailing-slash";
+var remote_object = "__skrao";
+var remote_map = "__skram";
+var remote_set = "__skras";
+var remote_file = "__skraf";
+var remote_arg_marker = Symbol(remote_object);
+function create_remote_arg_revivers() {
+  const remote_fns_revivers = {
+    /** @type {(value: unknown) => unknown} */
+    [remote_object]: (value) => value,
+    /** @type {(value: unknown) => Map<unknown, unknown>} */
+    [remote_map]: (value) => {
+      if (!Array.isArray(value)) throw new Error("Invalid data for Map reviver");
+      const map = /* @__PURE__ */ new Map();
+      for (const item of value) {
+        if (!Array.isArray(item) || item.length !== 2 || typeof item[0] !== "string" || typeof item[1] !== "string") throw new Error("Invalid data for Map reviver");
+        const [key, val] = item;
+        map.set(parse2(key), parse2(val));
+      }
+      return map;
+    },
+    /** @type {(value: unknown) => Set<unknown>} */
+    [remote_set]: (value) => {
+      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");
+        set.add(parse2(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 all_revivers = {
+    ...decoders,
+    ...remote_fns_revivers
+  };
+  const parse2 = (data) => parse$1(data, all_revivers);
+  return all_revivers;
+}
+function parse_remote_arg(string) {
+  if (!string) return void 0;
+  return parse$1(text_decoder.decode(base64_decode(string.replaceAll("-", "+").replaceAll("_", "/"))), create_remote_arg_revivers());
+}
+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 set_error_stack(error2, stack) {
+  try {
+    Reflect.set(error2, "stack", stack);
+  } catch {
+  }
+  return error2.stack;
+}
+function coalesce_to_error(err) {
+  return err instanceof Error || err && err.name && err.message ? err : new Error(JSON.stringify(err));
+}
+function normalize_error(error2) {
+  return error2;
+}
+function get_status(error2) {
+  return error2 instanceof HttpError || error2 instanceof SvelteKitError ? error2.status : 500;
+}
+function handle_error_async_without_async_svelte(_values) {
+  console.warn("https://svelte.dev/e/kit/handle_error_async_without_async_svelte");
+}
+function handle_error_and_jsonify(event, state2, error2) {
+  if (error2 instanceof HandledHttpError) return error2.body;
+  let caught;
+  if (error2 instanceof HttpError) caught = {
+    kind: "app",
+    error: error2.body
+  };
+  else if (error2 instanceof SvelteKitError) caught = {
+    kind: "framework",
+    error: {
+      status: error2.status,
+      message: error2.text
+    }
+  };
+  else if (error2 instanceof ValidationError) caught = {
+    kind: "validation",
+    error: {
+      status: 400,
+      message: "Bad Request"
+    },
+    issues: error2.issues
+  };
+  else {
+    caught = {
+      kind: "unknown",
+      error: error2
+    };
+    let e = error2;
+    while (e instanceof Error) {
+      fix_stack_trace(e);
+      e = e.cause;
+    }
+  }
+  const fallback = caught.kind === "unknown" ? {
+    status: 500,
+    message: "Internal Error"
+  } : caught.error;
+  function merge(body) {
+    return {
+      ...fallback,
+      ...body
+    };
+  }
+  let result;
+  try {
+    const input = {
+      ...caught,
+      event
+    };
+    result = with_request_store({
+      event,
+      state: state2
+    }, () => hooks.handleError(input));
+  } catch (hook_error) {
+    log_handle_error_hook_failure(error2, hook_error);
+    return {
+      status: fallback.status,
+      message: "Internal Error"
+    };
+  }
+  if (result instanceof Promise) {
+    if (state2.is_in_render) {
+      handle_error_async_without_async_svelte();
+      result.catch((hook_error) => log_handle_error_hook_failure(error2, hook_error));
+      return {
+        status: fallback.status,
+        message: "Internal Error"
+      };
+    }
+    return result.then(merge, (hook_error) => {
+      log_handle_error_hook_failure(error2, hook_error);
+      return {
+        status: fallback.status,
+        message: "Internal Error"
+      };
+    });
+  }
+  return merge(result);
+}
+function log_handle_error_hook_failure(error2, hook_error) {
+  const failure = capture_error(() => handle_error_hook_failed(void 0, { cause: coalesce_to_error(hook_error) }));
+  failure.stack = `${failure.name}: ${failure.message}`;
+  console.error(failure);
+  if (error2 instanceof SvelteKitError) console.error(`Original error: ${error2.status} ${error2.text}: ${error2.message}`);
+  else console.error("Original error:", error2);
+}
+var ENDPOINT_METHODS = [
+  "GET",
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE",
+  "OPTIONS",
+  "HEAD",
+  "QUERY"
+];
+var MUTATIVE_METHODS = [
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE"
+];
+var BODY_DEPENDENT_METHODS = [...MUTATIVE_METHODS, "QUERY"];
+var PAGE_METHODS = [
+  "GET",
+  "POST",
+  "HEAD"
+];
+import.meta.dirname;
+var IN_WEBCONTAINER = !!globalThis.process?.versions?.webcontainer;
+var REROUTED_URL_HEADER = "x-sveltekit-rerouted-url";
+function method_not_allowed(mod, method) {
+  return text(`${method} method not allowed`, {
+    status: 405,
+    headers: { allow: allowed_methods(mod).join(", ") }
+  });
+}
+function allowed_methods(mod) {
+  const allowed = ENDPOINT_METHODS.filter((method) => method in mod);
+  if ("GET" in mod && !("HEAD" in mod)) allowed.push("HEAD");
+  return allowed;
+}
+function redirect_response(status, location) {
+  return new Response(void 0, {
+    status,
+    headers: { location }
+  });
+}
+function with_version_header(response) {
+  response.headers.set("x-sveltekit-version", "1794327600754");
+  return response;
+}
+function throw_devalue_error(event, error2) {
+  const id = event.route.id;
+  if (error2.path) load_not_serializable({
+    id,
+    message: error2.message,
+    path: error2.path
+  }, { cause: error2 });
+  if (error2.path === "") load_not_plain_object({ id }, { cause: error2 });
+  throw new Error(error2.message, { cause: error2 });
+}
+function serialize_uses(node) {
+  const uses = {};
+  if (node.uses && node.uses.dependencies.size > 0) uses.dependencies = Array.from(node.uses.dependencies);
+  if (node.uses && node.uses.search_params.size > 0) uses.search_params = Array.from(node.uses.search_params);
+  if (node.uses && node.uses.params.size > 0) uses.params = Array.from(node.uses.params);
+  if (node.uses?.parent) uses.parent = 1;
+  if (node.uses?.route) uses.route = 1;
+  if (node.uses?.url) uses.url = 1;
+  return uses;
+}
+function has_prerendered_path(pathname) {
+  return manifest.prerendered_routes.has(pathname) || pathname.at(-1) === "/" && manifest.prerendered_routes.has(pathname.slice(0, -1));
+}
+function get_node_type(node_id) {
+  const filename = node_id?.split("/")?.at(-1);
+  if (!filename) return "unknown";
+  return filename.split(".").slice(0, -1).join(".");
+}
+function is_action_json_request(event) {
+  return negotiate(event.request.headers.get("accept") ?? "*/*", ["application/json", "text/html"]) === "application/json" && event.request.method === "POST";
+}
+async function handle_action_json_request(event, state2, server) {
+  return action_result_json(event, state2, await handle_action_request(event, state2, server));
+}
+async function action_result_json(event, state2, result) {
+  if (result.type === "redirect") return action_json(result);
+  if (result.type === "error") {
+    const error2 = await handle_error_and_jsonify(event, state2, result.error);
+    return action_json({
+      ...result,
+      error: error2
+    }, { status: error2.status });
+  }
+  if (result.type === "success" && !result.data) return action_json({
+    ...result,
+    status: 204,
+    data: void 0
+  });
+  try {
+    return action_json({
+      ...result,
+      data: try_serialize(result.data, stringify, event.route.id)
+    }, { status: result.status });
+  } catch (error2) {
+    return action_result_json(event, state2, action_error_result(error2, result.location));
+  }
+}
+function get_action_location(url2) {
+  const location = new URL(url2);
+  for (const key of location.searchParams.keys()) if (key.startsWith("/")) {
+    location.searchParams.delete(key);
+    break;
+  }
+  return (location.pathname.startsWith("//") ? "/." + location.pathname : location.pathname) + location.search;
+}
+function method_not_allowed_result(event, location) {
+  event.setHeaders({ allow: "GET" });
+  return {
+    type: "error",
+    location,
+    error: new SvelteKitError(405, "Method Not Allowed", `POST method not allowed. No form actions exist for this page`)
+  };
+}
+function action_error_result(error2, location) {
+  const err = normalize_error(error2);
+  if (err instanceof Redirect) return {
+    type: "redirect",
+    status: err.status,
+    location: err.location
+  };
+  return {
+    type: "error",
+    location,
+    error: err
+  };
+}
+function action_json_redirect(redirect) {
+  return action_json({
+    type: "redirect",
+    status: redirect.status,
+    location: redirect.location
+  });
+}
+function action_json(data, init) {
+  return with_version_header(Response.json(data, init));
+}
+function is_action_request(event) {
+  return event.request.method === "POST";
+}
+async function handle_action_request(event, state2, server) {
+  const actions = server?.actions;
+  const location = get_action_location(event.url);
+  if (!actions) return method_not_allowed_result(event, location);
+  check_named_default_separate(actions);
+  try {
+    const data = await call_action(event, state2, actions);
+    if (data instanceof ActionFailure) return {
+      type: "failure",
+      status: data.status,
+      location,
+      data: data.data
+    };
+    else return {
+      type: "success",
+      status: 200,
+      location,
+      data
+    };
+  } catch (error2) {
+    return action_error_result(error2 instanceof ActionFailure ? capture_error(() => action_throw_fail()) : error2, location);
+  }
+}
+function check_named_default_separate(actions) {
+  if (actions.default && Object.keys(actions).length > 1) action_default_with_named();
+}
+async function call_action(event, state2, actions) {
+  const url2 = new URL(event.request.url);
+  let name = "default";
+  for (const param of url2.searchParams) if (param[0].startsWith("/")) {
+    name = param[0].slice(1);
+    if (name === "default") action_name_reserved();
+    break;
+  }
+  if (!Object.hasOwn(actions, name)) throw new SvelteKitError(404, "Not Found", `No action with name '${name}' found`);
+  const action = actions[name];
+  if (!is_form_content_type(event.request)) throw new SvelteKitError(415, "Unsupported Media Type", `Form actions expect form-encoded data \u2014 received ${event.request.headers.get("content-type")}`);
+  return record_span({
+    name: "sveltekit.form_action",
+    attributes: {
+      "sveltekit.form_action.name": name,
+      "http.route": event.route.id || "unknown"
+    },
+    fn: async (current) => {
+      const traced_event = merge_tracing(event, current);
+      const result = await with_request_store({
+        event: traced_event,
+        state: state2
+      }, () => action(traced_event));
+      if (result instanceof ActionFailure) current.setAttributes({
+        "sveltekit.form_action.result.type": "failure",
+        "sveltekit.form_action.result.status": result.status
+      });
+      return result;
+    }
+  });
+}
+function uneval_action_response(data, route_id) {
+  return try_serialize(data, uneval2, route_id);
+}
+function try_serialize(data, fn, route_id) {
+  try {
+    return fn(data);
+  } catch (error2) {
+    if (data instanceof Response) action_response_not_serializable({ id: route_id }, { cause: error2 });
+    if ("path" in error2) {
+      const values = {
+        id: route_id,
+        message: error2.message
+      };
+      action_data_not_serializable(error2.path === "" ? values : {
+        ...values,
+        path: `data${error2.path}`
+      }, { cause: error2 });
+    }
+    throw error2;
+  }
+}
+var KEEP_ALIVE_INTERVAL = 3e4;
+function create_live_query_response(event, state2, internals, arg) {
+  const cancellation = new AbortController();
+  const live_event = {
+    ...event,
+    request: new Request(event.request, { signal: AbortSignal.any([event.request.signal, cancellation.signal]) })
+  };
+  const generator = internals.run(live_event, state2, arg);
+  let open = true;
+  let pulling = false;
+  let stream_controller;
+  let keep_alive;
+  let result;
+  function schedule_keep_alive() {
+    clearTimeout(keep_alive);
+    keep_alive = setTimeout(() => {
+      if (!open) return;
+      if ((stream_controller.desiredSize ?? 0) > 0) stream_controller.enqueue(text_encoder.encode(": keep-alive\n\n"));
+      schedule_keep_alive();
+    }, KEEP_ALIVE_INTERVAL);
+  }
+  function send(data) {
+    if (!open) return;
+    stream_controller.enqueue(text_encoder.encode("data: " + JSON.stringify(data) + "\n\n"));
+    schedule_keep_alive();
+  }
+  function teardown(cancelled) {
+    if (!open) return;
+    open = false;
+    clearTimeout(keep_alive);
+    cancellation.abort();
+    if (!cancelled) stream_controller.close();
+    generator.return(void 0).catch(() => {
+    });
+  }
+  event.request.signal.addEventListener("abort", () => teardown(true), { once: true });
+  return new Response(new ReadableStream({
+    start(controller) {
+      stream_controller = controller;
+      schedule_keep_alive();
+    },
+    async pull() {
+      if (!open || pulling) return;
+      pulling = true;
+      try {
+        while (open) {
+          const { value, done } = await generator.next();
+          if (!open) return;
+          if (done) {
+            teardown(false);
+            return;
+          }
+          if (result !== (result = stringify(value))) {
+            send({
+              type: "result",
+              result
+            });
+            return;
+          }
+        }
+      } catch (error2) {
+        if (!open) return;
+        if (error2 instanceof Redirect) send({
+          type: "redirect",
+          location: error2.location
+        });
+        else send({
+          type: "error",
+          error: await handle_error_and_jsonify(event, state2, error2)
+        });
+        teardown(false);
+      } finally {
+        pulling = false;
+      }
+    },
+    cancel() {
+      teardown(true);
+    }
+  }), { headers: {
+    "cache-control": "private, no-store",
+    "content-type": "text/event-stream"
+  } });
+}
+async function handle_remote_call(event, state2, id) {
+  return record_span({
+    name: "sveltekit.remote.call",
+    attributes: { "sveltekit.remote.call.id": id },
+    fn: async (current) => {
+      const traced_event = merge_tracing(event, current);
+      return with_version_header(await with_request_store({
+        event: traced_event,
+        state: state2
+      }, () => handle_remote_call_internal(traced_event, state2, id)));
+    }
+  });
+}
+async function handle_remote_call_internal(event, state2, id) {
+  const [hash, name, additional_args] = id.split("/");
+  const remotes = manifest.remotes;
+  if (!Object.hasOwn(remotes, hash)) error(404);
+  const module2 = await remotes[hash]();
+  const fn = Object.hasOwn(module2.default, name) ? module2.default[name] : void 0;
+  if (!fn) error(404);
+  const internals = fn.__;
+  event.tracing.current.setAttributes({
+    "sveltekit.remote.call.type": internals.type,
+    "sveltekit.remote.call.name": internals.name
+  });
+  const headers = state2.prerendering ? void 0 : { "cache-control": "private, no-store" };
+  try {
+    const data = {};
+    switch (internals.type) {
+      case "query_live":
+        if (event.request.method !== "GET") throw new SvelteKitError(405, "Method Not Allowed", `\`query.live\` functions must be invoked via GET request, not ${event.request.method}`);
+        return create_live_query_response(event, state2, internals, parse_remote_arg(new URL(event.request.url).searchParams.get("payload")));
+      case "query_batch": {
+        if (event.request.method !== "POST") throw new SvelteKitError(405, "Method Not Allowed", `\`query.batch\` functions must be invoked via POST request, not ${event.request.method}`);
+        const { payloads } = await event.request.json();
+        const args = await Promise.all(payloads.map((payload) => parse_remote_arg(payload)));
+        data._ = await with_request_store({
+          event,
+          state: state2
+        }, () => internals.run(args));
+        break;
+      }
+      case "form": {
+        if (event.request.method !== "POST") throw new SvelteKitError(405, "Method Not Allowed", `\`form\` functions must be invoked via POST request, not ${event.request.method}`);
+        if (!is_form_content_type(event.request)) throw new SvelteKitError(415, "Unsupported Media Type", `\`form\` functions expect form-encoded data \u2014 received ${event.request.headers.get("content-type")}`);
+        const { data: input, meta, form_data } = await deserialize_binary_form(event.request, internals.id);
+        state2.remote.requested = create_requested_map(meta.remote_refreshes);
+        if (additional_args && !("id" in input)) input.id = JSON.parse(decodeURIComponent(additional_args));
+        const fn2 = internals.fn;
+        data._ = await with_request_store({
+          event,
+          state: {
+            ...state2,
+            is_in_remote_form_or_command: true
+          }
+        }, () => fn2(input, meta, form_data));
+        if (data._.issues) return Response.json({
+          type: "result",
+          data: stringify(data)
+        }, { headers });
+        break;
+      }
+      case "command": {
+        const { payload, refreshes } = await event.request.json();
+        state2.remote.requested = create_requested_map(refreshes);
+        const arg = parse_remote_arg(payload);
+        data._ = await with_request_store({
+          event,
+          state: {
+            ...state2,
+            is_in_remote_form_or_command: true
+          }
+        }, () => fn(arg));
+        break;
+      }
+      case "prerender":
+        data._ = await with_request_store({
+          event,
+          state: state2
+        }, () => fn(parse_remote_arg(additional_args)));
+        break;
+      case "query": {
+        const payload = new URL(event.request.url).searchParams.get("payload");
+        data._ = await with_request_store({
+          event,
+          state: state2
+        }, () => fn(parse_remote_arg(payload)));
+        break;
+      }
+    }
+    await collect_remote_data(data, event, state2);
+    if (state2.remote.ignored?.size) data.i = Array.from(state2.remote.ignored);
+    return Response.json({
+      type: "result",
+      data: stringify(data)
+    }, { headers });
+  } catch (error2) {
+    if (error2 instanceof Redirect) {
+      const data = await collect_remote_data({ redirect: error2.location }, event, state2);
+      return Response.json({
+        type: "result",
+        data: stringify(data)
+      }, { headers });
+    }
+    const transformed = await handle_error_and_jsonify(event, state2, error2);
+    return Response.json({
+      type: "error",
+      error: transformed
+    }, {
+      status: state2.prerendering ? transformed.status : void 0,
+      headers: { "cache-control": "private, no-store" }
+    });
+  }
+}
+async function collect_remote_data(data, event, state2) {
+  function convert_error(error2) {
+    return Promise.resolve(handle_error_and_jsonify(event, state2, error2));
+  }
+  const promises = [];
+  const processed = /* @__PURE__ */ new Set();
+  if (state2.remote.explicit) {
+    const { explicit } = state2.remote;
+    const inflight = [];
+    const drain = () => {
+      for (const [remote_key, { internals, fn }] of explicit) {
+        explicit.delete(remote_key);
+        if (processed.has(remote_key)) continue;
+        processed.add(remote_key);
+        data.r = true;
+        const type = internals.type === "query_live" ? "l" : internals.type[0];
+        inflight.push(fn().then((v) => {
+          (data[type] ??= {})[remote_key] = { v };
+          drain();
+        }, async (e) => {
+          if (!(e instanceof Redirect)) (data[type] ??= {})[remote_key] = { e: await convert_error(e) };
+          drain();
+        }));
+      }
+    };
+    drain();
+    for (const promise of inflight) await promise;
+  }
+  if (state2.remote.implicit) for (const [internals, record] of state2.remote.implicit) {
+    if (!internals.id) continue;
+    for (const key in record) {
+      const remote_key = internals.type === "form" ? key : create_remote_key(internals.id, key);
+      if (processed.has(remote_key)) continue;
+      const type = internals.type === "query_live" ? "l" : internals.type[0];
+      const promise = state2.remote.data?.get(internals)?.[key] ?? record[key]();
+      let resolved = true;
+      await Promise.race([Promise.resolve(promise).then((v) => {
+        if (resolved) ((data[type] ??= {})[remote_key] ??= {}).v = v;
+      }, (e) => {
+        if (e instanceof Redirect) return;
+        if (resolved) promises.push(convert_error(e).then((e2) => {
+          ((data[type] ??= {})[remote_key] ??= {}).e = e2;
+        }));
+      }), Promise.resolve().then(() => resolved = false)]);
+    }
+  }
+  await Promise.all(promises);
+  return data;
+}
+function create_requested_map(refreshes) {
+  const requested = /* @__PURE__ */ new Map();
+  for (const key of refreshes ?? []) {
+    const parts = split_remote_key(key);
+    const existing = requested.get(parts.id);
+    if (existing) existing.add(parts.payload);
+    else requested.set(parts.id, /* @__PURE__ */ new Set([parts.payload]));
+  }
+  return requested;
+}
+async function handle_remote_form_post(event, state2, id) {
+  return record_span({
+    name: "sveltekit.remote.form.post",
+    attributes: { "sveltekit.remote.form.post.id": id },
+    fn: (current) => {
+      const traced_event = merge_tracing(event, current);
+      return with_request_store({
+        event: traced_event,
+        state: state2
+      }, () => handle_remote_form_post_internal(traced_event, state2, id));
+    }
+  });
+}
+async function handle_remote_form_post_internal(event, state2, id) {
+  const location = get_action_location(event.url);
+  const [hash, name, ...rest] = id.split("/");
+  const action_id = rest.join("/");
+  const remotes = manifest.remotes;
+  const module2 = Object.hasOwn(remotes, hash) ? await remotes[hash]() : void 0;
+  let form = module2 && Object.hasOwn(module2.default, name) ? module2.default[name] : void 0;
+  if (!form) return method_not_allowed_result(event, location);
+  if (action_id) form = with_request_store({
+    event,
+    state: state2
+  }, () => form.for(JSON.parse(action_id)));
+  try {
+    const __ = form.__;
+    const { data, meta, form_data } = await deserialize_binary_form(event.request, __.id);
+    if (action_id && !("id" in data)) data.id = JSON.parse(decodeURIComponent(action_id));
+    await with_request_store({
+      event,
+      state: {
+        ...state2,
+        is_in_remote_form_or_command: true
+      }
+    }, () => __.fn(data, meta, form_data));
+    return {
+      type: "success",
+      status: 200,
+      location
+    };
+  } catch (e) {
+    return action_error_result(e, location);
+  }
+}
+function has_remote_prefix(url2) {
+  return url2.pathname.startsWith(`/${app_dir}/remote/`);
+}
+function strip_remote_prefix(url2) {
+  return url2.pathname.replace(`/${app_dir}/remote/`, "");
+}
+function get_remote_id(url2) {
+  return has_remote_prefix(url2) && strip_remote_prefix(url2);
+}
+function get_remote_action(url2) {
+  return url2.searchParams.get("/remote");
+}
+var fs = globalThis.process?.getBuiltinModule?.("node:fs");
+var url = globalThis.process?.getBuiltinModule?.("node:url");
+var path = globalThis.process?.getBuiltinModule?.("node:path");
+var module = globalThis.process?.getBuiltinModule?.("node:module");
+var cwd = globalThis.process?.cwd?.();
+var relative = cwd ? (file) => path.relative(cwd, file) : (file) => file;
+var fix_stack_trace = (error2) => {
+  if (!error2.stack || !fs) return;
+  let end = 0;
+  set_error_stack(error2, error2.stack.split("\n").map((line, i) => {
+    const match = line.match(/^ {4}at.+(file:\/\/\/.*):(\d+):(\d+)(\)?)$/);
+    if (!match) {
+      if (!line.includes("node:internal/")) end = i + 1;
+      return line;
+    }
+    const file = url.fileURLToPath(match[1]);
+    const traced = trace(file, Number(match[2]) - 1, Number(match[3]) - 1);
+    if (!/[\\/]node_modules[\\/]/.test(traced?.file ?? file)) end = i + 1;
+    if (traced?.line) {
+      const location = `${match[1]}:${match[2]}:${match[3]}`;
+      const original = `${relative(traced.file)}:${traced.line}:${traced.column}`;
+      return line.replace(location, original);
+    }
+    if (traced) return `${line.replace(match[1], relative(file))} [${traced.file}]`;
+    return line;
+  }).slice(0, end).join("\n"));
+};
+function set_fix_stack_trace(fn) {
+  fix_stack_trace = fn;
+}
+var source_maps = /* @__PURE__ */ new Map();
+var source_regions = /* @__PURE__ */ new Map();
+function get_source_map(file) {
+  if (source_maps.has(file)) return source_maps.get(file);
+  try {
+    let source;
+    let directory = path.dirname(file);
+    const code = fs.readFileSync(file, "utf8");
+    const url2 = Array.from(code.matchAll(/\/\/[#@]\s*sourceMappingURL=(\S+)/g)).at(-1)?.[1];
+    if (url2?.startsWith("data:")) {
+      const comma = url2.indexOf(",");
+      const metadata = url2.slice(5, comma);
+      const data = url2.slice(comma + 1);
+      source = metadata.endsWith(";base64") ? Buffer.from(data, "base64").toString() : decodeURIComponent(data);
+    } else {
+      const map_file = url2 ? path.resolve(path.dirname(file), decodeURIComponent(url2)) : `${file}.map`;
+      if (fs.existsSync(map_file)) {
+        directory = path.dirname(map_file);
+        source = fs.readFileSync(map_file, "utf8");
+      }
+    }
+    if (source) {
+      const source_map = {
+        map: new module.SourceMap(JSON.parse(source)),
+        directory
+      };
+      source_maps.set(file, source_map);
+      return source_map;
+    }
+  } catch {
+  }
+  source_maps.set(file, null);
+  return null;
+}
+function trace(file, line, column) {
+  const source_map = get_source_map(file);
+  if (!source_map) return null;
+  const entry = source_map.map.findEntry(line, column);
+  if (entry && "originalSource" in entry && entry.originalSource && typeof entry.originalLine === "number" && typeof entry.originalColumn === "number") {
+    const traced = {
+      file: entry.originalSource.startsWith("file:") ? url.fileURLToPath(entry.originalSource) : path.resolve(source_map.directory, entry.originalSource),
+      line: entry.originalLine + 1,
+      column: entry.originalColumn + 1
+    };
+    return trace(traced.file, traced.line - 1, traced.column - 1) ?? traced;
+  }
+  let regions = source_regions.get(file);
+  if (!regions) {
+    let source2;
+    regions = fs.readFileSync(file, "utf8").split("\n").map((line2) => {
+      const start = line2.match(/^\/\/#region (.+)$/);
+      if (start) source2 = start[1];
+      if (line2 === "//#endregion") source2 = void 0;
+      return source2;
+    });
+    source_regions.set(file, regions);
+  }
+  const source = regions[line];
+  if (source) return { file: source };
+  return null;
+}
+var styleText = globalThis.process?.getBuiltinModule?.("node:util")?.styleText ?? ((_format, text2) => text2);
+var read_implementation = false;
+var manifest = false;
+var hooks = false;
+function set_read_implementation(read) {
+  read_implementation = (file) => {
+    const result = read(file);
+    if (result instanceof ReadableStream) return result;
+    return stream_from_iterable((async function* () {
+      const stream = await result;
+      if (stream) yield* stream;
+    })());
+  };
+}
+function set_manifest(value) {
+  manifest = value;
+}
+function set_hooks(value) {
+  hooks = value;
+}
+
+export {
+  enable_verbose_errors,
+  assets,
+  app_dir,
+  set_assets,
+  text_encoder,
+  stream_text,
+  base64_encode,
+  has_data_suffix,
+  add_data_suffix,
+  strip_data_suffix,
+  has_resolution_suffix,
+  add_resolution_suffix,
+  strip_resolution_suffix,
+  invalid_export,
+  invalid_export_location,
+  find_route,
+  resolve,
+  relative_pathname,
+  normalize_path,
+  decode_pathname,
+  make_trackable,
+  disable_search,
+  options,
+  get_hooks,
+  stringify$1,
+  noop,
+  once,
+  disallow_on_server,
+  negotiate,
+  is_form_content_type,
+  uneval2 as uneval,
+  encoders,
+  has_custom_transporters,
+  init_transport,
+  fetch_cache_url,
+  INVALIDATED_PARAM,
+  TRAILING_SLASH_PARAM,
+  normalize_error,
+  get_status,
+  handle_error_and_jsonify,
+  ENDPOINT_METHODS,
+  BODY_DEPENDENT_METHODS,
+  PAGE_METHODS,
+  IN_WEBCONTAINER,
+  REROUTED_URL_HEADER,
+  method_not_allowed,
+  redirect_response,
+  with_version_header,
+  throw_devalue_error,
+  serialize_uses,
+  has_prerendered_path,
+  get_node_type,
+  is_action_json_request,
+  handle_action_json_request,
+  action_json_redirect,
+  is_action_request,
+  handle_action_request,
+  uneval_action_response,
+  handle_remote_call,
+  collect_remote_data,
+  handle_remote_form_post,
+  get_remote_id,
+  get_remote_action,
+  set_fix_stack_trace,
+  read_implementation,
+  manifest,
+  hooks,
+  set_read_implementation,
+  set_manifest,
+  set_hooks
+};