mongoku 2.9.2 → 2.10.0

package/build/server/chunks/{root-otUAnOAR.js → root-Bs42DBih.js}

@@ -1,3 +1,4 @@
+import { C as render, L as LEGACY_PROPS, E as define_property, F as CONNECTED, R as REACTION_RAN, G as ERROR_VALUE, I as COMMENT_NODE, J as HYDRATION_START, K as HYDRATION_ERROR, O as STATE_SYMBOL, Q as object_prototype, T as array_prototype, V as UNINITIALIZED, W as get_descriptor, X as DERIVED, Y as DIRTY, Z as MAYBE_DIRTY, _ as is_extensible, $ as CLASS_CACHE, a0 as ATTRIBUTES_CACHE, a1 as STYLE_CACHE, a2 as TEXT_CACHE, a3 as get_prototype_of, a4 as is_array, a5 as CLEAN, a6 as INERT, a7 as EFFECT, a8 as RENDER_EFFECT, a9 as MANAGED_EFFECT, aa as BLOCK_EFFECT, ab as ASYNC, ac as DESTROYED, ad as EAGER_EFFECT, ae as deferred, af as ROOT_EFFECT, ag as BRANCH_EFFECT, ah as WAS_MARKED, ai as REACTION_IS_UPDATING, aj as run_all, ak as includes, al as EFFECT_PRESERVED, am as EFFECT_TRANSPARENT, an as HEAD_EFFECT, ao as DESTROYING, ap as BOUNDARY_EFFECT, aq as index_of, ar as STALE_REACTION, A as noop, as as array_from, at as is_passive_event, au as setContext, f as derived, av as HYDRATION_END, aw as HYDRATION_START_ELSE, ax as HYDRATION_START_FAILED, ay as USER_EFFECT } from './renderer-wJWkLEmh.js';
 import { a as async_mode_flag, t as tracing_mode_flag } from './async-DUoD1OpG.js';
 
 // eslint-disable-next-line n/prefer-global/process
@@ -12,10 +13,10 @@ const IN_WEBCONTAINER = !!globalThis.process?.versions?.webcontainer;
 let sync_store = null;
 
 /** @type {AsyncLocalStorage<RequestStore | null> | null} */
-let als$1;
+let als;
 
 import('node:async_hooks')
-	.then((hooks) => (als$1 = new hooks.AsyncLocalStorage()))
+	.then((hooks) => (als = new hooks.AsyncLocalStorage()))
 	.catch(() => {
 		// can't use AsyncLocalStorage, but can still call getRequestEvent synchronously.
 		// this isn't behind `supports` because it's basically just StackBlitz (i.e.
@@ -27,7 +28,7 @@ function get_request_store() {
 	if (!result) {
 		let message = 'Could not get the request store.';
 
-		if (als$1) {
+		if (als) {
 			message += ' This is an internal error.';
 		} else {
 			message +=
@@ -41,7 +42,7 @@ function get_request_store() {
 }
 
 function try_get_request_store() {
-	return sync_store ?? als$1?.getStore() ?? null;
+	return sync_store ?? als?.getStore() ?? null;
 }
 
 /**
@@ -52,7 +53,7 @@ function try_get_request_store() {
 function with_request_store(store, fn) {
 	try {
 		sync_store = store;
-		return als$1 ? als$1.run(store, fn) : fn();
+		return als ? als.run(store, fn) : fn();
 	} finally {
 		// Since AsyncLocalStorage is not working in webcontainers, we don't reset `sync_store`
 		// and handle only one request at a time in `src/runtime/server/index.js`.
@@ -63,642 +64,6 @@ function with_request_store(store, fn) {
 }
 
 const DEV = false;
-const UNDEFINED = -1;
-const HOLE = -2;
-const NAN = -3;
-const POSITIVE_INFINITY = -4;
-const NEGATIVE_INFINITY = -5;
-const NEGATIVE_ZERO = -6;
-const SPARSE = -7;
-const MAX_ARRAY_LEN = 2 ** 32 - 1;
-const MAX_ARRAY_INDEX = MAX_ARRAY_LEN - 1;
-const escaped = {
-  "<": "\\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;
-  }
-}
-function is_primitive(thing) {
-  return thing === null || typeof thing !== "object" && typeof thing !== "function";
-}
-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;
-}
-function get_type(thing) {
-  return Object.prototype.toString.call(thing).slice(8, -1);
-}
-function get_escaped_char(char) {
-  switch (char) {
-    case '"':
-      return '\\"';
-    case "<":
-      return "\\u003C";
-    case "\\":
-      return "\\\\";
-    case "\n":
-      return "\\n";
-    case "\r":
-      return "\\r";
-    case "	":
-      return "\\t";
-    case "\b":
-      return "\\b";
-    case "\f":
-      return "\\f";
-    case "\u2028":
-      return "\\u2028";
-    case "\u2029":
-      return "\\u2029";
-    default:
-      return char < " " ? `\\u${char.charCodeAt(0).toString(16).padStart(4, "0")}` : "";
-  }
-}
-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)}"`;
-}
-function enumerable_symbols(object) {
-  return Object.getOwnPropertySymbols(object).filter(
-    (symbol) => Object.getOwnPropertyDescriptor(object, symbol).enumerable
-  );
-}
-const is_identifier = /^[a-zA-Z_$][a-zA-Z_$0-9]*$/;
-function stringify_key(key) {
-  return is_identifier.test(key) ? "." + key : "[" + JSON.stringify(key) + "]";
-}
-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;
-}
-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;
-}
-function is_valid_array_index_string(s) {
-  if (s.length === 0) return false;
-  if (s.length > 1 && s.charCodeAt(0) === 48) return false;
-  for (let i = 0; i < s.length; i++) {
-    const c = s.charCodeAt(i);
-    if (c < 48 || c > 57) return false;
-  }
-  return is_valid_array_index(+s);
-}
-function valid_array_indices(array) {
-  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 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)$/;
-function uneval(value, replacer) {
-  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(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(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(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;
-  }
-}
-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;
-}
-function escape_unsafe_char(c) {
-  return escaped[c] || c;
-}
-function escape_unsafe_chars(str) {
-  return str.replace(unsafe_chars, escape_unsafe_char);
-}
-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(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;
-}
-function experimental_async_required(name) {
-  {
-    throw new Error(`https://svelte.dev/e/experimental_async_required`);
-  }
-}
-function lifecycle_outside_component(name) {
-  {
-    throw new Error(`https://svelte.dev/e/lifecycle_outside_component`);
-  }
-}
-function async_local_storage_unavailable() {
-  const error = new Error(`async_local_storage_unavailable
-The node API \`AsyncLocalStorage\` is not available, but is required to use async server rendering.
-https://svelte.dev/e/async_local_storage_unavailable`);
-  error.name = "Svelte error";
-  throw error;
-}
-function await_invalid() {
-  const error = new Error(`await_invalid
-Encountered asynchronous work while rendering synchronously.
-https://svelte.dev/e/await_invalid`);
-  error.name = "Svelte error";
-  throw error;
-}
-function html_deprecated() {
-  const error = new Error(`html_deprecated
-The \`html\` property of server render results has been deprecated. Use \`body\` instead.
-https://svelte.dev/e/html_deprecated`);
-  error.name = "Svelte error";
-  throw error;
-}
-function hydratable_serialization_failed(key, stack) {
-  const error = new Error(`hydratable_serialization_failed
-Failed to serialize \`hydratable\` data for key \`${key}\`.
-
-\`hydratable\` can serialize anything [\`uneval\` from \`devalue\`](https://npmjs.com/package/uneval) can, plus Promises.
-
-Cause:
-${stack}
-https://svelte.dev/e/hydratable_serialization_failed`);
-  error.name = "Svelte error";
-  throw error;
-}
-function invalid_csp() {
-  const error = new Error(`invalid_csp
-\`csp.nonce\` was set while \`csp.hash\` was \`true\`. These options cannot be used simultaneously.
-https://svelte.dev/e/invalid_csp`);
-  error.name = "Svelte error";
-  throw error;
-}
-function invalid_id_prefix() {
-  const error = new Error(`invalid_id_prefix
-The \`idPrefix\` option cannot include \`--\`.
-https://svelte.dev/e/invalid_id_prefix`);
-  error.name = "Svelte error";
-  throw error;
-}
-function server_context_required() {
-  const error = new Error(`server_context_required
-Could not resolve \`render\` context.
-https://svelte.dev/e/server_context_required`);
-  error.name = "Svelte error";
-  throw error;
-}
-var is_array = Array.isArray;
-var index_of = Array.prototype.indexOf;
-var includes = Array.prototype.includes;
-var array_from = Array.from;
-var define_property = Object.defineProperty;
-var get_descriptor = Object.getOwnPropertyDescriptor;
-var object_prototype = Object.prototype;
-var array_prototype = Array.prototype;
-var get_prototype_of = Object.getPrototypeOf;
-var is_extensible = Object.isExtensible;
-var has_own_property = Object.prototype.hasOwnProperty;
-const noop = () => {
-};
-function is_promise(value) {
-  return typeof value?.then === "function";
-}
-function run_all(arr) {
-  for (var i = 0; i < arr.length; i++) {
-    arr[i]();
-  }
-}
-function deferred() {
-  var resolve;
-  var reject;
-  var promise = new Promise((res, rej) => {
-    resolve = res;
-    reject = rej;
-  });
-  return { promise, resolve, reject };
-}
-let current_render = null;
-let context = null;
-function get_render_context() {
-  const store = context ?? als?.getStore();
-  if (!store) {
-    server_context_required();
-  }
-  return store;
-}
-async function with_render_context(fn) {
-  context = {
-    hydratable: {
-      lookup: /* @__PURE__ */ new Map(),
-      comparisons: [],
-      unresolved_promises: /* @__PURE__ */ new Map()
-    }
-  };
-  if (in_webcontainer()) {
-    const { promise, resolve } = deferred();
-    const previous_render = current_render;
-    current_render = promise;
-    await previous_render;
-    return fn().finally(resolve);
-  }
-  try {
-    if (als === null) {
-      async_local_storage_unavailable();
-    }
-    return als.run(context, fn);
-  } finally {
-    context = null;
-  }
-}
-let als = null;
-let als_import = null;
-function init_render_context() {
-  als_import ??= import('node:async_hooks').then((hooks) => {
-    als = new hooks.AsyncLocalStorage();
-  }).then(noop, noop);
-  return als_import;
-}
-function in_webcontainer() {
-  return !!globalThis.process?.versions?.webcontainer;
-}
 
 const internal = new URL("sveltekit-internal://");
 function resolve(base, path) {
@@ -797,275 +162,6 @@ function allow_nodejs_console_log(url) {
   }
 }
 
-var ssr_context = null;
-function set_ssr_context(v) {
-  ssr_context = v;
-}
-function getContext(key) {
-  const context_map = get_or_init_context_map();
-  const result = (
-    /** @type {T} */
-    context_map.get(key)
-  );
-  return result;
-}
-function setContext(key, context) {
-  get_or_init_context_map().set(key, context);
-  return context;
-}
-function get_or_init_context_map(name) {
-  if (ssr_context === null) {
-    lifecycle_outside_component();
-  }
-  return ssr_context.c ??= new Map(get_parent_context(ssr_context) || void 0);
-}
-function push$1(fn) {
-  ssr_context = { p: ssr_context, c: null, r: null };
-}
-function pop$1() {
-  ssr_context = /** @type {SSRContext} */
-  ssr_context.p;
-}
-function get_parent_context(ssr_context2) {
-  let parent = ssr_context2.p;
-  while (parent !== null) {
-    const context_map = parent.c;
-    if (context_map !== null) {
-      return context_map;
-    }
-    parent = parent.p;
-  }
-  return null;
-}
-const DERIVED = 1 << 1;
-const EFFECT = 1 << 2;
-const RENDER_EFFECT = 1 << 3;
-const MANAGED_EFFECT = 1 << 24;
-const BLOCK_EFFECT = 1 << 4;
-const BRANCH_EFFECT = 1 << 5;
-const ROOT_EFFECT = 1 << 6;
-const BOUNDARY_EFFECT = 1 << 7;
-const CONNECTED = 1 << 9;
-const CLEAN = 1 << 10;
-const DIRTY = 1 << 11;
-const MAYBE_DIRTY = 1 << 12;
-const INERT = 1 << 13;
-const DESTROYED = 1 << 14;
-const REACTION_RAN = 1 << 15;
-const DESTROYING = 1 << 25;
-const EFFECT_TRANSPARENT = 1 << 16;
-const EAGER_EFFECT = 1 << 17;
-const HEAD_EFFECT = 1 << 18;
-const EFFECT_PRESERVED = 1 << 19;
-const USER_EFFECT = 1 << 20;
-const WAS_MARKED = 1 << 16;
-const REACTION_IS_UPDATING = 1 << 21;
-const ASYNC = 1 << 22;
-const ERROR_VALUE = 1 << 23;
-const STATE_SYMBOL = /* @__PURE__ */ Symbol("$state");
-const LEGACY_PROPS = /* @__PURE__ */ Symbol("legacy props");
-const ATTRIBUTES_CACHE = /* @__PURE__ */ Symbol("attributes");
-const CLASS_CACHE = /* @__PURE__ */ Symbol("class");
-const STYLE_CACHE = /* @__PURE__ */ Symbol("style");
-const TEXT_CACHE = /* @__PURE__ */ Symbol("text");
-const STALE_REACTION = new class StaleReactionError extends Error {
-  name = "StaleReactionError";
-  message = "The reaction that called `getAbortSignal()` was re-run or destroyed";
-}();
-const COMMENT_NODE = 8;
-let controller = null;
-function abort() {
-  controller?.abort(STALE_REACTION);
-  controller = null;
-}
-const HYDRATION_START = "[";
-const HYDRATION_START_ELSE = "[!";
-const HYDRATION_START_FAILED = "[?";
-const HYDRATION_END = "]";
-const HYDRATION_ERROR = {};
-const ELEMENT_IS_NAMESPACED = 1;
-const ELEMENT_PRESERVE_ATTRIBUTE_CASE = 1 << 1;
-const ELEMENT_IS_INPUT = 1 << 2;
-const UNINITIALIZED = /* @__PURE__ */ Symbol();
-function unresolved_hydratable(key, stack) {
-  {
-    console.warn(`https://svelte.dev/e/unresolved_hydratable`);
-  }
-}
-const BLOCK_OPEN = `<!--${HYDRATION_START}-->`;
-const BLOCK_OPEN_ELSE = `<!--${HYDRATION_START_ELSE}-->`;
-const BLOCK_CLOSE = `<!--${HYDRATION_END}-->`;
-const EMPTY_COMMENT = `<!---->`;
-const ATTR_REGEX = /[&"<]/g;
-const CONTENT_REGEX = /[&<]/g;
-function escape_html(value, is_attr) {
-  const str = String(value ?? "");
-  const pattern = is_attr ? ATTR_REGEX : CONTENT_REGEX;
-  pattern.lastIndex = 0;
-  let escaped = "";
-  let last = 0;
-  while (pattern.test(str)) {
-    const i = pattern.lastIndex - 1;
-    const ch = str[i];
-    escaped += str.substring(last, i) + (ch === "&" ? "&amp;" : ch === '"' ? "&quot;" : "&lt;");
-    last = i + 1;
-  }
-  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 = {
-  translate: /* @__PURE__ */ new Map([
-    [true, "yes"],
-    [false, "no"]
-  ])
-};
-function attr(name, value, is_boolean = false) {
-  if (name === "hidden" && value !== "until-found") {
-    is_boolean = true;
-  }
-  if (value == null || !value && is_boolean) return "";
-  const normalized = has_own_property.call(replacements, name) && replacements[name].get(value) || value;
-  const assignment = is_boolean ? `=""` : `="${escape_html(normalized, true)}"`;
-  return ` ${name}${assignment}`;
-}
-function clsx(value) {
-  if (typeof value === "object") {
-    return clsx$1(value);
-  } else {
-    return value ?? "";
-  }
-}
-const whitespace = [..." 	\n\r\f \v\uFEFF"];
-function to_class(value, hash, directives) {
-  var classname = value == null ? "" : "" + value;
-  if (hash) {
-    classname = classname ? classname + " " + hash : hash;
-  }
-  if (directives) {
-    for (var key of Object.keys(directives)) {
-      if (directives[key]) {
-        classname = classname ? classname + " " + key : key;
-      } else if (classname.length) {
-        var len = key.length;
-        var a = 0;
-        while ((a = classname.indexOf(key, a)) >= 0) {
-          var b = a + len;
-          if ((a === 0 || whitespace.includes(classname[a - 1])) && (b === classname.length || whitespace.includes(classname[b]))) {
-            classname = (a === 0 ? "" : classname.substring(0, a)) + classname.substring(b + 1);
-          } else {
-            a = b;
-          }
-        }
-      }
-    }
-  }
-  return classname === "" ? null : classname;
-}
-function append_styles(styles, important = false) {
-  var separator = important ? " !important;" : ";";
-  var css = "";
-  for (var key of Object.keys(styles)) {
-    var value = styles[key];
-    if (value != null && value !== "") {
-      css += " " + key + ": " + value + separator;
-    }
-  }
-  return css;
-}
-function to_css_name(name) {
-  if (name[0] !== "-" || name[1] !== "-") {
-    return name.toLowerCase();
-  }
-  return name;
-}
-function to_style(value, styles) {
-  if (styles) {
-    var new_style = "";
-    var normal_styles;
-    var important_styles;
-    if (Array.isArray(styles)) {
-      normal_styles = styles[0];
-      important_styles = styles[1];
-    } else {
-      normal_styles = styles;
-    }
-    if (value) {
-      value = String(value).replaceAll(/\s*\/\*.*?\*\/\s*/g, "").trim();
-      var in_str = false;
-      var in_apo = 0;
-      var in_comment = false;
-      var reserved_names = [];
-      if (normal_styles) {
-        reserved_names.push(...Object.keys(normal_styles).map(to_css_name));
-      }
-      if (important_styles) {
-        reserved_names.push(...Object.keys(important_styles).map(to_css_name));
-      }
-      var start_index = 0;
-      var name_index = -1;
-      const len = value.length;
-      for (var i = 0; i < len; i++) {
-        var c = value[i];
-        if (in_comment) {
-          if (c === "/" && value[i - 1] === "*") {
-            in_comment = false;
-          }
-        } else if (in_str) {
-          if (in_str === c) {
-            in_str = false;
-          }
-        } else if (c === "/" && value[i + 1] === "*") {
-          in_comment = true;
-        } else if (c === '"' || c === "'") {
-          in_str = c;
-        } else if (c === "(") {
-          in_apo++;
-        } else if (c === ")") {
-          in_apo--;
-        }
-        if (!in_comment && in_str === false && in_apo === 0) {
-          if (c === ":" && name_index === -1) {
-            name_index = i;
-          } else if (c === ";" || i === len - 1) {
-            if (name_index !== -1) {
-              var name = to_css_name(value.substring(start_index, name_index).trim());
-              if (!reserved_names.includes(name)) {
-                if (c !== ";") {
-                  i++;
-                }
-                var property = value.substring(start_index, i).trim();
-                new_style += " " + property + ";";
-              }
-            }
-            start_index = i + 1;
-            name_index = -1;
-          }
-        }
-      }
-    }
-    if (normal_styles) {
-      new_style += append_styles(normal_styles);
-    }
-    if (important_styles) {
-      new_style += append_styles(important_styles, true);
-    }
-    new_style = new_style.trim();
-    return new_style === "" ? null : new_style;
-  }
-  return value == null ? null : String(value);
-}
 function effect_update_depth_exceeded() {
   {
     throw new Error(`https://svelte.dev/e/effect_update_depth_exceeded`);
@@ -1534,7 +630,7 @@ class Batch {
         this.#link();
       }
       const batch2 = next_batch;
-      batch2.#roots.push(...this.#roots.filter((r2) => !batch2.#roots.includes(r2)));
+      batch2.#roots.push(...this.#roots.filter((r) => !batch2.#roots.includes(r)));
     }
     if (next_batch !== null) {
       next_batch.#process();
@@ -3092,10 +2188,10 @@ function destroy_effect_children(signal, remove_dom = false) {
   var effect = signal.first;
   signal.first = signal.last = null;
   while (effect !== null) {
-    const controller2 = effect.ac;
-    if (controller2 !== null) {
+    const controller = effect.ac;
+    if (controller !== null) {
       without_reactive_context(() => {
-        controller2.abort(STALE_REACTION);
+        controller.abort(STALE_REACTION);
       });
     }
     var next2 = effect.next;
@@ -3599,939 +2695,6 @@ function untrack(fn) {
     untracking = previous_untracking;
   }
 }
-const DOM_BOOLEAN_ATTRIBUTES = [
-  "allowfullscreen",
-  "async",
-  "autofocus",
-  "autoplay",
-  "checked",
-  "controls",
-  "default",
-  "disabled",
-  "formnovalidate",
-  "indeterminate",
-  "inert",
-  "ismap",
-  "loop",
-  "multiple",
-  "muted",
-  "nomodule",
-  "novalidate",
-  "open",
-  "playsinline",
-  "readonly",
-  "required",
-  "reversed",
-  "seamless",
-  "selected",
-  "webkitdirectory",
-  "defer",
-  "disablepictureinpicture",
-  "disableremoteplayback"
-];
-function is_boolean_attribute(name) {
-  return DOM_BOOLEAN_ATTRIBUTES.includes(name);
-}
-const PASSIVE_EVENTS = ["touchstart", "touchmove"];
-function is_passive_event(name) {
-  return PASSIVE_EVENTS.includes(name);
-}
-const INVALID_ATTR_NAME_CHAR_REGEX = /[\s'">/=\u{FDD0}-\u{FDEF}\u{FFFE}\u{FFFF}\u{1FFFE}\u{1FFFF}\u{2FFFE}\u{2FFFF}\u{3FFFE}\u{3FFFF}\u{4FFFE}\u{4FFFF}\u{5FFFE}\u{5FFFF}\u{6FFFE}\u{6FFFF}\u{7FFFE}\u{7FFFF}\u{8FFFE}\u{8FFFF}\u{9FFFE}\u{9FFFF}\u{AFFFE}\u{AFFFF}\u{BFFFE}\u{BFFFF}\u{CFFFE}\u{CFFFF}\u{DFFFE}\u{DFFFF}\u{EFFFE}\u{EFFFF}\u{FFFFE}\u{FFFFF}\u{10FFFE}\u{10FFFF}]/u;
-function render(component, options = {}) {
-  if (options.csp?.hash && options.csp.nonce) {
-    invalid_csp();
-  }
-  return Renderer.render(
-    /** @type {Component<Props>} */
-    component,
-    options
-  );
-}
-function head(hash, renderer, fn) {
-  renderer.head((renderer2) => {
-    renderer2.push(`<!--${hash}-->`);
-    renderer2.child(fn);
-    renderer2.push(EMPTY_COMMENT);
-  });
-}
-function attributes(attrs, css_hash, classes, styles, flags2 = 0) {
-  if (styles) {
-    attrs.style = to_style(attrs.style, styles);
-  }
-  if (attrs.class) {
-    attrs.class = clsx(attrs.class);
-  }
-  if (css_hash || classes) {
-    attrs.class = to_class(attrs.class, css_hash, classes);
-  }
-  let attr_str = "";
-  let name;
-  const is_html = (flags2 & ELEMENT_IS_NAMESPACED) === 0;
-  const lowercase = (flags2 & ELEMENT_PRESERVE_ATTRIBUTE_CASE) === 0;
-  const is_input = (flags2 & ELEMENT_IS_INPUT) !== 0;
-  for (name of Object.keys(attrs)) {
-    if (typeof attrs[name] === "function") continue;
-    if (name[0] === "$" && name[1] === "$") continue;
-    if (name === "" || INVALID_ATTR_NAME_CHAR_REGEX.test(name)) continue;
-    var value = attrs[name];
-    var lower = name.toLowerCase();
-    if (lowercase) name = lower;
-    if (lower.length > 2 && lower.startsWith("on")) continue;
-    if (is_input) {
-      if (name === "defaultvalue" || name === "defaultchecked") {
-        name = name === "defaultvalue" ? "value" : "checked";
-        if (attrs[name]) continue;
-      }
-    }
-    attr_str += attr(name, value, is_html && is_boolean_attribute(name));
-  }
-  return attr_str;
-}
-function stringify(value) {
-  return typeof value === "string" ? value : value == null ? "" : value + "";
-}
-function attr_class(value, hash, directives) {
-  var result = to_class(value, hash, directives);
-  return result ? ` class="${escape_html(result, true)}"` : "";
-}
-function attr_style(value, directives) {
-  var result = to_style(value, directives);
-  return result ? ` style="${escape_html(result, true)}"` : "";
-}
-function bind_props(props_parent, props_now) {
-  for (const key of Object.keys(props_now)) {
-    const initial_value = props_parent[key];
-    const value = props_now[key];
-    if (initial_value === void 0 && value !== void 0 && Object.getOwnPropertyDescriptor(props_parent, key)?.set) {
-      props_parent[key] = value;
-    }
-  }
-}
-function await_block(renderer, promise, pending_fn, then_fn) {
-  if (is_promise(promise)) {
-    renderer.push(BLOCK_OPEN);
-    promise.then(null, noop);
-    if (pending_fn !== null) {
-      pending_fn();
-    }
-  } else if (then_fn !== null) {
-    renderer.push(BLOCK_OPEN_ELSE);
-    then_fn(promise);
-  }
-}
-function ensure_array_like(array_like_or_iterator) {
-  if (array_like_or_iterator) {
-    return array_like_or_iterator.length !== void 0 ? array_like_or_iterator : Array.from(array_like_or_iterator);
-  }
-  return [];
-}
-function once(get_value) {
-  let value = (
-    /** @type {V} */
-    UNINITIALIZED
-  );
-  return () => {
-    if (value === UNINITIALIZED) {
-      value = get_value();
-    }
-    return value;
-  };
-}
-function derived(fn) {
-  const get_value = ssr_context === null ? fn : once(fn);
-  let updated_value;
-  return function(new_value) {
-    if (arguments.length === 0) {
-      return updated_value ?? get_value();
-    }
-    updated_value = new_value;
-    return updated_value;
-  };
-}
-let text_encoder;
-let crypto;
-const obfuscated_import = (module_name) => import(
-  /* @vite-ignore */
-  module_name
-);
-async function sha256(data) {
-  text_encoder ??= new TextEncoder();
-  crypto ??= globalThis.crypto?.subtle?.digest ? globalThis.crypto : (
-    // @ts-ignore - we don't install node types in the prod build
-    // don't use import('node:crypto') directly because static analysers will think we rely on node when we don't
-    (await obfuscated_import("node:crypto")).webcrypto
-  );
-  const hash_buffer = await crypto.subtle.digest("SHA-256", text_encoder.encode(data));
-  return base64_encode(hash_buffer);
-}
-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);
-}
-class Renderer {
-  /**
-   * The contents of the renderer.
-   * @type {RendererItem[]}
-   */
-  #out = [];
-  /**
-   * Any `onDestroy` callbacks registered during execution of this renderer.
-   * @type {(() => void)[] | undefined}
-   */
-  #on_destroy = void 0;
-  /**
-   * Whether this renderer is a component body.
-   * @type {boolean}
-   */
-  #is_component_body = false;
-  /**
-   * If set, this renderer is an error boundary. When async collection
-   * of the children fails, the failed snippet is rendered instead.
-   * @type {{
-   * 	failed: (renderer: Renderer, error: unknown, reset: () => void) => void;
-   * 	transformError: (error: unknown) => unknown;
-   * 	context: SSRContext | null;
-   * } | null}
-   */
-  #boundary = null;
-  /**
-   * The type of string content that this renderer is accumulating.
-   * @type {RendererType}
-   */
-  type;
-  /** @type {Renderer | undefined} */
-  #parent;
-  /**
-   * Asynchronous work associated with this renderer
-   * @type {Promise<void> | undefined}
-   */
-  promise = void 0;
-  /**
-   * State which is associated with the content tree as a whole.
-   * It will be re-exposed, uncopied, on all children.
-   * @type {SSRState}
-   * @readonly
-   */
-  global;
-  /**
-   * State that is local to the branch it is declared in.
-   * It will be shallow-copied to all children.
-   *
-   * @type {{ select_value: string | undefined }}
-   */
-  local;
-  /**
-   * @param {SSRState} global
-   * @param {Renderer | undefined} [parent]
-   */
-  constructor(global, parent) {
-    this.#parent = parent;
-    this.global = global;
-    this.local = parent ? { ...parent.local } : { select_value: void 0 };
-    this.type = parent ? parent.type : "body";
-  }
-  /**
-   * @param {(renderer: Renderer) => void} fn
-   */
-  head(fn) {
-    const head2 = new Renderer(this.global, this);
-    head2.type = "head";
-    this.#out.push(head2);
-    head2.child(fn);
-  }
-  /**
-   * @param {Array<Promise<void>>} blockers
-   * @param {(renderer: Renderer) => void} fn
-   */
-  async_block(blockers, fn) {
-    this.#out.push(BLOCK_OPEN);
-    this.async(blockers, fn);
-    this.#out.push(BLOCK_CLOSE);
-  }
-  /**
-   * @param {Array<Promise<void>>} blockers
-   * @param {(renderer: Renderer) => void} fn
-   */
-  async(blockers, fn) {
-    let callback = fn;
-    if (blockers.length > 0) {
-      const context = ssr_context;
-      callback = (renderer) => {
-        return Promise.all(blockers).then(() => {
-          const previous_context = ssr_context;
-          try {
-            set_ssr_context(context);
-            return fn(renderer);
-          } finally {
-            set_ssr_context(previous_context);
-          }
-        });
-      };
-    }
-    this.child(callback);
-  }
-  /**
-   * @param {Array<() => void>} thunks
-   */
-  run(thunks) {
-    const context = ssr_context;
-    let promise = Promise.resolve(thunks[0]());
-    const promises = [promise];
-    for (const fn of thunks.slice(1)) {
-      promise = promise.then(() => {
-        const previous_context = ssr_context;
-        set_ssr_context(context);
-        try {
-          return fn();
-        } finally {
-          set_ssr_context(previous_context);
-        }
-      });
-      promises.push(promise);
-    }
-    promise.catch(noop);
-    this.promise = promise;
-    return promises;
-  }
-  /**
-   * @param {(renderer: Renderer) => MaybePromise<void>} fn
-   */
-  child_block(fn) {
-    this.#out.push(BLOCK_OPEN);
-    this.child(fn);
-    this.#out.push(BLOCK_CLOSE);
-  }
-  /**
-   * Create a child renderer. The child renderer inherits the state from the parent,
-   * but has its own content.
-   * @param {(renderer: Renderer) => MaybePromise<void>} fn
-   */
-  child(fn) {
-    const child = new Renderer(this.global, this);
-    this.#out.push(child);
-    const parent = ssr_context;
-    set_ssr_context({
-      ...ssr_context,
-      p: parent,
-      c: null,
-      r: child
-    });
-    const result = fn(child);
-    set_ssr_context(parent);
-    if (result instanceof Promise) {
-      result.catch(noop);
-      result.finally(() => set_ssr_context(null)).catch(noop);
-      if (child.global.mode === "sync") {
-        await_invalid();
-      }
-      child.promise = result;
-    }
-    return child;
-  }
-  /**
-   * Render children inside an error boundary. If the children throw and the API-level
-   * `transformError` transform handles the error (doesn't re-throw), the `failed` snippet is
-   * rendered instead. Otherwise the error propagates.
-   *
-   * @param {{ failed?: (renderer: Renderer, error: unknown, reset: () => void) => void }} props
-   * @param {(renderer: Renderer) => MaybePromise<void>} children_fn
-   */
-  boundary(props, children_fn) {
-    const child = new Renderer(this.global, this);
-    this.#out.push(child);
-    const parent_context = ssr_context;
-    if (props.failed) {
-      child.#boundary = {
-        failed: props.failed,
-        transformError: this.global.transformError,
-        context: parent_context
-      };
-    }
-    set_ssr_context({
-      ...ssr_context,
-      p: parent_context,
-      c: null,
-      r: child
-    });
-    try {
-      const result = children_fn(child);
-      set_ssr_context(parent_context);
-      if (result instanceof Promise) {
-        if (child.global.mode === "sync") {
-          await_invalid();
-        }
-        result.catch(noop);
-        child.promise = result;
-      }
-    } catch (error) {
-      set_ssr_context(parent_context);
-      const failed_snippet = props.failed;
-      if (!failed_snippet) throw error;
-      const result = this.global.transformError(error);
-      child.#out.length = 0;
-      child.#boundary = null;
-      if (result instanceof Promise) {
-        if (this.global.mode === "sync") {
-          await_invalid();
-        }
-        child.promise = /** @type {Promise<unknown>} */
-        result.then((transformed) => {
-          set_ssr_context(parent_context);
-          child.#out.push(Renderer.#serialize_failed_boundary(transformed));
-          failed_snippet(child, transformed, noop);
-          child.#out.push(BLOCK_CLOSE);
-        });
-        child.promise.catch(noop);
-      } else {
-        child.#out.push(Renderer.#serialize_failed_boundary(result));
-        failed_snippet(child, result, noop);
-        child.#out.push(BLOCK_CLOSE);
-      }
-    }
-  }
-  /**
-   * Create a component renderer. The component renderer inherits the state from the parent,
-   * but has its own content. It is treated as an ordering boundary for ondestroy callbacks.
-   * @param {(renderer: Renderer) => MaybePromise<void>} fn
-   * @param {Function} [component_fn]
-   * @returns {void}
-   */
-  component(fn, component_fn) {
-    push$1();
-    const child = this.child(fn);
-    child.#is_component_body = true;
-    pop$1();
-  }
-  /**
-   * @param {Record<string, any>} attrs
-   * @param {(renderer: Renderer) => void} fn
-   * @param {string | undefined} [css_hash]
-   * @param {Record<string, boolean> | undefined} [classes]
-   * @param {Record<string, string> | undefined} [styles]
-   * @param {number | undefined} [flags]
-   * @param {boolean | undefined} [is_rich]
-   * @returns {void}
-   */
-  select(attrs, fn, css_hash, classes, styles, flags2, is_rich) {
-    const { value, ...select_attrs } = attrs;
-    this.push(`<select${attributes(select_attrs, css_hash, classes, styles, flags2)}>`);
-    this.child((renderer) => {
-      renderer.local.select_value = value;
-      fn(renderer);
-    });
-    this.push(`${is_rich ? "<!>" : ""}</select>`);
-  }
-  /**
-   * @param {Record<string, any>} attrs
-   * @param {string | number | boolean | ((renderer: Renderer) => void)} body
-   * @param {string | undefined} [css_hash]
-   * @param {Record<string, boolean> | undefined} [classes]
-   * @param {Record<string, string> | undefined} [styles]
-   * @param {number | undefined} [flags]
-   * @param {boolean | undefined} [is_rich]
-   */
-  option(attrs, body, css_hash, classes, styles, flags2, is_rich) {
-    this.#out.push(`<option${attributes(attrs, css_hash, classes, styles, flags2)}`);
-    const close = (renderer, value, { head: head2, body: body2 }) => {
-      if (has_own_property.call(attrs, "value")) {
-        value = attrs.value;
-      }
-      if (value === this.local.select_value) {
-        renderer.#out.push(' selected=""');
-      }
-      renderer.#out.push(`>${body2}${is_rich ? "<!>" : ""}</option>`);
-      if (head2) {
-        renderer.head((child) => child.push(head2));
-      }
-    };
-    if (typeof body === "function") {
-      this.child((renderer) => {
-        const r2 = new Renderer(this.global, this);
-        body(r2);
-        if (this.global.mode === "async") {
-          return r2.#collect_content_async().then((content) => {
-            close(renderer, content.body.replaceAll("<!---->", ""), content);
-          });
-        } else {
-          const content = r2.#collect_content();
-          close(renderer, content.body.replaceAll("<!---->", ""), content);
-        }
-      });
-    } else {
-      close(this, body, { body: escape_html(body) });
-    }
-  }
-  /**
-   * @param {(renderer: Renderer) => void} fn
-   */
-  title(fn) {
-    const path = this.get_path();
-    const close = (head2) => {
-      this.global.set_title(head2, path);
-    };
-    this.child((renderer) => {
-      const r2 = new Renderer(renderer.global, renderer);
-      fn(r2);
-      if (renderer.global.mode === "async") {
-        return r2.#collect_content_async().then((content) => {
-          close(content.head);
-        });
-      } else {
-        const content = r2.#collect_content();
-        close(content.head);
-      }
-    });
-  }
-  /**
-   * @param {string | (() => Promise<string>)} content
-   */
-  push(content) {
-    if (typeof content === "function") {
-      this.child(async (renderer) => renderer.push(await content()));
-    } else {
-      this.#out.push(content);
-    }
-  }
-  /**
-   * @param {() => void} fn
-   */
-  on_destroy(fn) {
-    (this.#on_destroy ??= []).push(fn);
-  }
-  /**
-   * @returns {number[]}
-   */
-  get_path() {
-    return this.#parent ? [...this.#parent.get_path(), this.#parent.#out.indexOf(this)] : [];
-  }
-  /**
-   * @deprecated this is needed for legacy component bindings
-   */
-  copy() {
-    const copy = new Renderer(this.global, this.#parent);
-    copy.#out = this.#out.map((item) => item instanceof Renderer ? item.copy() : item);
-    copy.promise = this.promise;
-    return copy;
-  }
-  /**
-   * @param {Renderer} other
-   * @deprecated this is needed for legacy component bindings
-   */
-  subsume(other) {
-    if (this.global.mode !== other.global.mode) {
-      throw new Error(
-        "invariant: A renderer cannot switch modes. If you're seeing this, there's a compiler bug. File an issue!"
-      );
-    }
-    this.local = other.local;
-    this.#out = other.#out.map((item, i) => {
-      const current = this.#out[i];
-      if (current instanceof Renderer && item instanceof Renderer) {
-        current.subsume(item);
-        return current;
-      }
-      return item;
-    });
-    this.promise = other.promise;
-    this.type = other.type;
-  }
-  get length() {
-    return this.#out.length;
-  }
-  /**
-   * Creates the hydration comment that marks the start of a failed boundary.
-   * The error is JSON-serialized and embedded inside an HTML comment for the client
-   * to parse during hydration. The JSON is escaped to prevent `-->` or `<!--` sequences
-   * from breaking out of the comment (XSS). Uses unicode escapes which `JSON.parse()`
-   * handles transparently.
-   * @param {unknown} error
-   * @returns {string}
-   */
-  static #serialize_failed_boundary(error) {
-    var json = JSON.stringify(error);
-    var escaped = json.replace(/>/g, "\\u003e").replace(/</g, "\\u003c");
-    return `<!--${HYDRATION_START_FAILED}${escaped}-->`;
-  }
-  /**
-   * Only available on the server and when compiling with the `server` option.
-   * Takes a component and returns an object with `body` and `head` properties on it, which you can use to populate the HTML when server-rendering your app.
-   * @template {Record<string, any>} Props
-   * @param {Component<Props>} component
-   * @param {{ props?: Omit<Props, '$$slots' | '$$events'>; context?: Map<any, any>; idPrefix?: string; csp?: Csp }} [options]
-   * @returns {RenderOutput}
-   */
-  static render(component, options = {}) {
-    let sync;
-    let async;
-    const result = (
-      /** @type {RenderOutput} */
-      {}
-    );
-    Object.defineProperties(result, {
-      html: {
-        get: () => {
-          return (sync ??= Renderer.#render(component, options)).body;
-        }
-      },
-      head: {
-        get: () => {
-          return (sync ??= Renderer.#render(component, options)).head;
-        }
-      },
-      body: {
-        get: () => {
-          return (sync ??= Renderer.#render(component, options)).body;
-        }
-      },
-      hashes: {
-        value: {
-          script: ""
-        }
-      },
-      then: {
-        value: (
-          /**
-           * this is not type-safe, but honestly it's the best I can do right now, and it's a straightforward function.
-           *
-           * @template TResult1
-           * @template [TResult2=never]
-           * @param { (value: SyncRenderOutput) => TResult1 } onfulfilled
-           * @param { (reason: unknown) => TResult2 } onrejected
-           */
-          (onfulfilled, onrejected) => {
-            if (!async_mode_flag) {
-              const result2 = sync ??= Renderer.#render(component, options);
-              const user_result = onfulfilled({
-                head: result2.head,
-                body: result2.body,
-                html: result2.body,
-                hashes: { script: [] }
-              });
-              return Promise.resolve(user_result);
-            }
-            async ??= init_render_context().then(
-              () => with_render_context(() => Renderer.#render_async(component, options))
-            );
-            return async.then((result2) => {
-              Object.defineProperty(result2, "html", {
-                // eslint-disable-next-line getter-return
-                get: () => {
-                  html_deprecated();
-                }
-              });
-              return onfulfilled(
-                /** @type {SyncRenderOutput} */
-                result2
-              );
-            }, onrejected);
-          }
-        )
-      }
-    });
-    return result;
-  }
-  /**
-   * Collect all of the `onDestroy` callbacks registered during rendering. In an async context, this is only safe to call
-   * after awaiting `collect_async`.
-   *
-   * Child renderers are "porous" and don't affect execution order, but component body renderers
-   * create ordering boundaries. Within a renderer, callbacks run in order until hitting a component boundary.
-   * @returns {Iterable<() => void>}
-   */
-  *#collect_on_destroy() {
-    for (const component of this.#traverse_components()) {
-      yield* component.#collect_ondestroy();
-    }
-  }
-  /**
-   * Performs a depth-first search of renderers, yielding the deepest components first, then additional components as we backtrack up the tree.
-   * @returns {Iterable<Renderer>}
-   */
-  *#traverse_components() {
-    for (const child of this.#out) {
-      if (typeof child !== "string") {
-        yield* child.#traverse_components();
-      }
-    }
-    if (this.#is_component_body) {
-      yield this;
-    }
-  }
-  /**
-   * @returns {Iterable<() => void>}
-   */
-  *#collect_ondestroy() {
-    if (this.#on_destroy) {
-      for (const fn of this.#on_destroy) {
-        yield fn;
-      }
-    }
-    for (const child of this.#out) {
-      if (child instanceof Renderer && !child.#is_component_body) {
-        yield* child.#collect_ondestroy();
-      }
-    }
-  }
-  /**
-   * Render a component. Throws if any of the children are performing asynchronous work.
-   *
-   * @template {Record<string, any>} Props
-   * @param {Component<Props>} component
-   * @param {{ props?: Omit<Props, '$$slots' | '$$events'>; context?: Map<any, any>; idPrefix?: string }} options
-   * @returns {AccumulatedContent}
-   */
-  static #render(component, options) {
-    var previous_context = ssr_context;
-    try {
-      const renderer = Renderer.#open_render("sync", component, options);
-      const content = renderer.#collect_content();
-      return Renderer.#close_render(content, renderer);
-    } finally {
-      abort();
-      set_ssr_context(previous_context);
-    }
-  }
-  /**
-   * Render a component.
-   *
-   * @template {Record<string, any>} Props
-   * @param {Component<Props>} component
-   * @param {{ props?: Omit<Props, '$$slots' | '$$events'>; context?: Map<any, any>; idPrefix?: string; csp?: Csp }} options
-   * @returns {Promise<AccumulatedContent & { hashes: { script: Sha256Source[] } }>}
-   */
-  static async #render_async(component, options) {
-    const previous_context = ssr_context;
-    try {
-      const renderer = Renderer.#open_render("async", component, options);
-      const content = await renderer.#collect_content_async();
-      const hydratables = await renderer.#collect_hydratables();
-      if (hydratables !== null) {
-        content.head = hydratables + content.head;
-      }
-      return Renderer.#close_render(content, renderer);
-    } finally {
-      set_ssr_context(previous_context);
-      abort();
-    }
-  }
-  /**
-   * Collect all of the code from the `out` array and return it as a string, or a promise resolving to a string.
-   * @param {AccumulatedContent} content
-   * @returns {AccumulatedContent}
-   */
-  #collect_content(content = { head: "", body: "" }) {
-    for (const item of this.#out) {
-      if (typeof item === "string") {
-        content[this.type] += item;
-      } else if (item instanceof Renderer) {
-        item.#collect_content(content);
-      }
-    }
-    return content;
-  }
-  /**
-   * Collect all of the code from the `out` array and return it as a string.
-   * @param {AccumulatedContent} content
-   * @returns {Promise<AccumulatedContent>}
-   */
-  async #collect_content_async(content = { head: "", body: "" }) {
-    await this.promise;
-    for (const item of this.#out) {
-      if (typeof item === "string") {
-        content[this.type] += item;
-      } else if (item instanceof Renderer) {
-        if (item.#boundary) {
-          const boundary_content = { head: "", body: "" };
-          try {
-            await item.#collect_content_async(boundary_content);
-            content.head += boundary_content.head;
-            content.body += boundary_content.body;
-          } catch (error) {
-            const { context, failed, transformError } = item.#boundary;
-            set_ssr_context(context);
-            let promise = transformError(error);
-            set_ssr_context(null);
-            let transformed = await promise;
-            set_ssr_context(context);
-            const failed_renderer = new Renderer(item.global, item);
-            failed_renderer.type = item.type;
-            failed_renderer.#out.push(Renderer.#serialize_failed_boundary(transformed));
-            failed(failed_renderer, transformed, noop);
-            failed_renderer.#out.push(BLOCK_CLOSE);
-            await failed_renderer.#collect_content_async(content);
-          }
-        } else {
-          await item.#collect_content_async(content);
-        }
-      }
-    }
-    return content;
-  }
-  async #collect_hydratables() {
-    const ctx = get_render_context().hydratable;
-    for (const [_, key] of ctx.unresolved_promises) {
-      unresolved_hydratable(key, ctx.lookup.get(key)?.stack ?? "<missing stack trace>");
-    }
-    for (const comparison of ctx.comparisons) {
-      await comparison;
-    }
-    return await this.#hydratable_block(ctx);
-  }
-  /**
-   * @template {Record<string, any>} Props
-   * @param {'sync' | 'async'} mode
-   * @param {import('svelte').Component<Props>} component
-   * @param {{ props?: Omit<Props, '$$slots' | '$$events'>; context?: Map<any, any>; idPrefix?: string; csp?: Csp; transformError?: (error: unknown) => unknown }} options
-   * @returns {Renderer}
-   */
-  static #open_render(mode, component, options) {
-    if (options.idPrefix?.includes("--")) {
-      invalid_id_prefix();
-    }
-    var previous_context = ssr_context;
-    try {
-      const renderer = new Renderer(
-        new SSRState(
-          mode,
-          options.idPrefix ? options.idPrefix + "-" : "",
-          options.csp,
-          options.transformError
-        )
-      );
-      const context = { p: null, c: options.context ?? null, r: renderer };
-      set_ssr_context(context);
-      renderer.push(BLOCK_OPEN);
-      component(renderer, options.props ?? {});
-      renderer.push(BLOCK_CLOSE);
-      return renderer;
-    } finally {
-      set_ssr_context(previous_context);
-    }
-  }
-  /**
-   * @param {AccumulatedContent} content
-   * @param {Renderer} renderer
-   * @returns {AccumulatedContent & { hashes: { script: Sha256Source[] } }}
-   */
-  static #close_render(content, renderer) {
-    for (const cleanup of renderer.#collect_on_destroy()) {
-      cleanup();
-    }
-    let head2 = content.head + renderer.global.get_title();
-    let body = content.body;
-    for (const { hash, code } of renderer.global.css) {
-      head2 += `<style id="${hash}">${code}</style>`;
-    }
-    return {
-      head: head2,
-      body,
-      hashes: {
-        script: renderer.global.csp.script_hashes
-      }
-    };
-  }
-  /**
-   * @param {HydratableContext} ctx
-   */
-  async #hydratable_block(ctx) {
-    if (ctx.lookup.size === 0) {
-      return null;
-    }
-    let entries = [];
-    let has_promises = false;
-    for (const [k, v] of ctx.lookup) {
-      if (v.promises) {
-        has_promises = true;
-        for (const p of v.promises) await p;
-      }
-      entries.push(`[${uneval(k)},${v.serialized}]`);
-    }
-    let prelude = `const h = (window.__svelte ??= {}).h ??= new Map();`;
-    if (has_promises) {
-      prelude = `const r = (v) => Promise.resolve(v);
-				${prelude}`;
-    }
-    const body = `
-			{
-				${prelude}
-
-				for (const [k, v] of [
-					${entries.join(",\n					")}
-				]) {
-					h.set(k, v);
-				}
-			}
-		`;
-    let csp_attr = "";
-    if (this.global.csp.nonce) {
-      csp_attr = ` nonce="${this.global.csp.nonce}"`;
-    } else if (this.global.csp.hash) {
-      const hash = await sha256(body);
-      this.global.csp.script_hashes.push(`sha256-${hash}`);
-    }
-    return `
-		<script${csp_attr}>${body}<\/script>`;
-  }
-}
-class SSRState {
-  /** @readonly @type {Csp & { script_hashes: Sha256Source[] }} */
-  csp;
-  /** @readonly @type {'sync' | 'async'} */
-  mode;
-  /** @readonly @type {() => string} */
-  uid;
-  /** @readonly @type {Set<{ hash: string; code: string }>} */
-  css = /* @__PURE__ */ new Set();
-  /**
-   * `transformError` passed to `render`. Called when an error boundary catches an error.
-   * Throws by default if unset in `render`.
-   * @type {(error: unknown) => unknown}
-   */
-  transformError;
-  /** @type {{ path: number[], value: string }} */
-  #title = { path: [], value: "" };
-  /**
-   * @param {'sync' | 'async'} mode
-   * @param {string} id_prefix
-   * @param {Csp} csp
-   * @param {((error: unknown) => unknown) | undefined} [transformError]
-   */
-  constructor(mode, id_prefix = "", csp = { hash: false }, transformError) {
-    this.mode = mode;
-    this.csp = { ...csp, script_hashes: [] };
-    this.transformError = transformError ?? ((error) => {
-      throw error;
-    });
-    let uid2 = 1;
-    this.uid = () => `${id_prefix}s${uid2++}`;
-  }
-  get_title() {
-    return this.#title.value;
-  }
-  /**
-   * Performs a depth-first (lexicographic) comparison using the path. Rejects sets
-   * from earlier than or equal to the current value.
-   * @param {string} value
-   * @param {number[]} path
-   */
-  set_title(value, path) {
-    const current = this.#title.path;
-    let i = 0;
-    let l = Math.min(path.length, current.length);
-    while (i < l && path[i] === current[i]) i += 1;
-    if (path[i] === void 0) return;
-    if (current[i] === void 0 || path[i] > current[i]) {
-      this.#title.path = path;
-      this.#title.value = value;
-    }
-  }
-}
 const event_symbol = /* @__PURE__ */ Symbol("events");
 const all_registered_events = /* @__PURE__ */ new Set();
 const root_event_handles = /* @__PURE__ */ new Set();
@@ -5133,5 +3296,5 @@ function Root($$renderer, $$props) {
 }
 const root = asClassComponent(Root);
 
-export { uneval as A, hydratable_serialization_failed as B, noop as C, DevalueError as D, safe_not_equal as E, decode_params as F, try_get_request_store as G, HOLE as H, root as I, decode_pathname as J, DEV as K, normalize_path as L, MAX_ARRAY_INDEX as M, NAN as N, disable_search as O, POSITIVE_INFINITY as P, resolve as Q, make_trackable as R, SPARSE as S, get_request_store as T, UNDEFINED as U, attr as a, ensure_array_like as b, attr_class as c, derived as d, escape_html as e, clsx as f, getContext as g, head as h, await_block as i, bind_props as j, attr_style as k, NEGATIVE_INFINITY as l, NEGATIVE_ZERO as m, is_valid_array_len as n, is_valid_array_index as o, is_primitive as p, get_type as q, is_plain_object as r, stringify as s, enumerable_symbols as t, stringify_key as u, stringify_string as v, with_request_store as w, valid_array_indices as x, experimental_async_required as y, get_render_context as z };
-//# sourceMappingURL=root-otUAnOAR.js.map
+export { DEV as D, decode_pathname as a, disable_search as b, resolve as c, decode_params as d, get_request_store as g, make_trackable as m, normalize_path as n, root as r, safe_not_equal as s, try_get_request_store as t, with_request_store as w };
+//# sourceMappingURL=root-Bs42DBih.js.map