convex-cms 0.0.6 → 0.0.7

package/admin-dist/server/_ssr/index.mjs

@@ -1,22 +1,10 @@
-import { a as createMemoryHistory } from "../_chunks/_libs/@tanstack/history.mjs";
-import { w as parseRedirect, x as mergeHeaders, f as isRedirect, y as getNormalizedURL, z as getOrigin, A as attachRouterServerSsrUtils, C as createSerializationAdapter, D as createRawStreamRPCPlugin, i as isNotFound, E as isResolvedRedirect, F as executeRewriteInput, G as defaultSerovalPlugins, H as makeSerovalPlugin, b as rootRouteId, I as defineHandlerCallback } from "../_chunks/_libs/@tanstack/router-core.mjs";
 import { AsyncLocalStorage } from "node:async_hooks";
-import { H as H3Event, t as toResponse } from "../_libs/h3-v2.mjs";
-import { i as invariant } from "../_libs/tiny-invariant.mjs";
-import { a as au, I as Iu, o as ou } from "../_libs/seroval.mjs";
 import { j as jsxRuntimeExports } from "../_chunks/_libs/react.mjs";
 import { r as renderRouterToStream, R as RouterProvider } from "../_chunks/_libs/@tanstack/react-router.mjs";
-import "../_libs/cookie-es.mjs";
-import "../_chunks/_libs/@tanstack/store.mjs";
-import "../_libs/seroval-plugins.mjs";
-import "node:stream/web";
-import "node:stream";
-import "../_libs/rou3.mjs";
-import "../_libs/srvx.mjs";
-import "node:http";
-import "node:https";
-import "node:http2";
+import { p as defineHandlerCallback } from "../_chunks/_libs/@tanstack/router-core.mjs";
 import "../_libs/tiny-warning.mjs";
+import "../_libs/tiny-invariant.mjs";
+import "node:stream";
 import "../_chunks/_libs/react-dom.mjs";
 import "util";
 import "crypto";
@@ -25,17 +13,2637 @@ import "stream";
 import "../_libs/isbot.mjs";
 import "../_chunks/_libs/@tanstack/react-store.mjs";
 import "../_libs/use-sync-external-store.mjs";
+import "../_chunks/_libs/@tanstack/store.mjs";
+import "../_chunks/_libs/@tanstack/history.mjs";
+import "node:stream/web";
 function StartServer(props) {
   return /* @__PURE__ */ jsxRuntimeExports.jsx(RouterProvider, { router: props.router });
 }
-const defaultStreamHandler = defineHandlerCallback(
-  ({ request, router, responseHeaders }) => renderRouterToStream({
-    request,
-    router,
-    responseHeaders,
-    children: /* @__PURE__ */ jsxRuntimeExports.jsx(StartServer, { router })
-  })
-);
+const defaultStreamHandler = defineHandlerCallback(
+  ({ request, router, responseHeaders }) => renderRouterToStream({
+    request,
+    router,
+    responseHeaders,
+    children: /* @__PURE__ */ jsxRuntimeExports.jsx(StartServer, { router })
+  })
+);
+const stateIndexKey = "__TSR_index";
+function createHistory(opts) {
+  let location = opts.getLocation();
+  const subscribers = /* @__PURE__ */ new Set();
+  const notify = (action) => {
+    location = opts.getLocation();
+    subscribers.forEach((subscriber) => subscriber({ location, action }));
+  };
+  const handleIndexChange = (action) => {
+    if (opts.notifyOnIndexChange ?? true) notify(action);
+    else location = opts.getLocation();
+  };
+  const tryNavigation = async ({
+    task,
+    navigateOpts,
+    ...actionInfo
+  }) => {
+    const ignoreBlocker = navigateOpts?.ignoreBlocker ?? false;
+    if (ignoreBlocker) {
+      task();
+      return;
+    }
+    const blockers = opts.getBlockers?.() ?? [];
+    const isPushOrReplace = actionInfo.type === "PUSH" || actionInfo.type === "REPLACE";
+    if (typeof document !== "undefined" && blockers.length && isPushOrReplace) {
+      for (const blocker of blockers) {
+        const nextLocation = parseHref(actionInfo.path, actionInfo.state);
+        const isBlocked = await blocker.blockerFn({
+          currentLocation: location,
+          nextLocation,
+          action: actionInfo.type
+        });
+        if (isBlocked) {
+          opts.onBlocked?.();
+          return;
+        }
+      }
+    }
+    task();
+  };
+  return {
+    get location() {
+      return location;
+    },
+    get length() {
+      return opts.getLength();
+    },
+    subscribers,
+    subscribe: (cb) => {
+      subscribers.add(cb);
+      return () => {
+        subscribers.delete(cb);
+      };
+    },
+    push: (path, state, navigateOpts) => {
+      const currentIndex = location.state[stateIndexKey];
+      state = assignKeyAndIndex(currentIndex + 1, state);
+      tryNavigation({
+        task: () => {
+          opts.pushState(path, state);
+          notify({ type: "PUSH" });
+        },
+        navigateOpts,
+        type: "PUSH",
+        path,
+        state
+      });
+    },
+    replace: (path, state, navigateOpts) => {
+      const currentIndex = location.state[stateIndexKey];
+      state = assignKeyAndIndex(currentIndex, state);
+      tryNavigation({
+        task: () => {
+          opts.replaceState(path, state);
+          notify({ type: "REPLACE" });
+        },
+        navigateOpts,
+        type: "REPLACE",
+        path,
+        state
+      });
+    },
+    go: (index, navigateOpts) => {
+      tryNavigation({
+        task: () => {
+          opts.go(index);
+          handleIndexChange({ type: "GO", index });
+        },
+        navigateOpts,
+        type: "GO"
+      });
+    },
+    back: (navigateOpts) => {
+      tryNavigation({
+        task: () => {
+          opts.back(navigateOpts?.ignoreBlocker ?? false);
+          handleIndexChange({ type: "BACK" });
+        },
+        navigateOpts,
+        type: "BACK"
+      });
+    },
+    forward: (navigateOpts) => {
+      tryNavigation({
+        task: () => {
+          opts.forward(navigateOpts?.ignoreBlocker ?? false);
+          handleIndexChange({ type: "FORWARD" });
+        },
+        navigateOpts,
+        type: "FORWARD"
+      });
+    },
+    canGoBack: () => location.state[stateIndexKey] !== 0,
+    createHref: (str) => opts.createHref(str),
+    block: (blocker) => {
+      if (!opts.setBlockers) return () => {
+      };
+      const blockers = opts.getBlockers?.() ?? [];
+      opts.setBlockers([...blockers, blocker]);
+      return () => {
+        const blockers2 = opts.getBlockers?.() ?? [];
+        opts.setBlockers?.(blockers2.filter((b2) => b2 !== blocker));
+      };
+    },
+    flush: () => opts.flush?.(),
+    destroy: () => opts.destroy?.(),
+    notify
+  };
+}
+function assignKeyAndIndex(index, state) {
+  if (!state) {
+    state = {};
+  }
+  const key = createRandomKey();
+  return {
+    ...state,
+    key,
+    // TODO: Remove in v2 - use __TSR_key instead
+    __TSR_key: key,
+    [stateIndexKey]: index
+  };
+}
+function createMemoryHistory(opts = {
+  initialEntries: ["/"]
+}) {
+  const entries = opts.initialEntries;
+  let index = opts.initialIndex ? Math.min(Math.max(opts.initialIndex, 0), entries.length - 1) : entries.length - 1;
+  const states = entries.map(
+    (_entry, index2) => assignKeyAndIndex(index2, void 0)
+  );
+  const getLocation = () => parseHref(entries[index], states[index]);
+  let blockers = [];
+  const _getBlockers = () => blockers;
+  const _setBlockers = (newBlockers) => blockers = newBlockers;
+  return createHistory({
+    getLocation,
+    getLength: () => entries.length,
+    pushState: (path, state) => {
+      if (index < entries.length - 1) {
+        entries.splice(index + 1);
+        states.splice(index + 1);
+      }
+      states.push(state);
+      entries.push(path);
+      index = Math.max(entries.length - 1, 0);
+    },
+    replaceState: (path, state) => {
+      states[index] = state;
+      entries[index] = path;
+    },
+    back: () => {
+      index = Math.max(index - 1, 0);
+    },
+    forward: () => {
+      index = Math.min(index + 1, entries.length - 1);
+    },
+    go: (n2) => {
+      index = Math.min(Math.max(index + n2, 0), entries.length - 1);
+    },
+    createHref: (path) => path,
+    getBlockers: _getBlockers,
+    setBlockers: _setBlockers
+  });
+}
+function sanitizePath(path) {
+  let sanitized = path.replace(/[\x00-\x1f\x7f]/g, "");
+  if (sanitized.startsWith("//")) {
+    sanitized = "/" + sanitized.replace(/^\/+/, "");
+  }
+  return sanitized;
+}
+function parseHref(href, state) {
+  const sanitizedHref = sanitizePath(href);
+  const hashIndex = sanitizedHref.indexOf("#");
+  const searchIndex = sanitizedHref.indexOf("?");
+  const addedKey = createRandomKey();
+  return {
+    href: sanitizedHref,
+    pathname: sanitizedHref.substring(
+      0,
+      hashIndex > 0 ? searchIndex > 0 ? Math.min(hashIndex, searchIndex) : hashIndex : searchIndex > 0 ? searchIndex : sanitizedHref.length
+    ),
+    hash: hashIndex > -1 ? sanitizedHref.substring(hashIndex) : "",
+    search: searchIndex > -1 ? sanitizedHref.slice(
+      searchIndex,
+      hashIndex === -1 ? void 0 : hashIndex
+    ) : "",
+    state: state || { [stateIndexKey]: 0, key: addedKey, __TSR_key: addedKey }
+  };
+}
+function createRandomKey() {
+  return (Math.random() + 1).toString(36).substring(7);
+}
+function splitSetCookieString(cookiesString) {
+  if (Array.isArray(cookiesString)) {
+    return cookiesString.flatMap((c2) => splitSetCookieString(c2));
+  }
+  if (typeof cookiesString !== "string") {
+    return [];
+  }
+  const cookiesStrings = [];
+  let pos = 0;
+  let start;
+  let ch;
+  let lastComma;
+  let nextStart;
+  let cookiesSeparatorFound;
+  const skipWhitespace = () => {
+    while (pos < cookiesString.length && /\s/.test(cookiesString.charAt(pos))) {
+      pos += 1;
+    }
+    return pos < cookiesString.length;
+  };
+  const notSpecialChar = () => {
+    ch = cookiesString.charAt(pos);
+    return ch !== "=" && ch !== ";" && ch !== ",";
+  };
+  while (pos < cookiesString.length) {
+    start = pos;
+    cookiesSeparatorFound = false;
+    while (skipWhitespace()) {
+      ch = cookiesString.charAt(pos);
+      if (ch === ",") {
+        lastComma = pos;
+        pos += 1;
+        skipWhitespace();
+        nextStart = pos;
+        while (pos < cookiesString.length && notSpecialChar()) {
+          pos += 1;
+        }
+        if (pos < cookiesString.length && cookiesString.charAt(pos) === "=") {
+          cookiesSeparatorFound = true;
+          pos = nextStart;
+          cookiesStrings.push(cookiesString.slice(start, lastComma));
+          start = pos;
+        } else {
+          pos = lastComma + 1;
+        }
+      } else {
+        pos += 1;
+      }
+    }
+    if (!cookiesSeparatorFound || pos >= cookiesString.length) {
+      cookiesStrings.push(cookiesString.slice(start));
+    }
+  }
+  return cookiesStrings;
+}
+function toHeadersInstance(init) {
+  if (init instanceof Headers) {
+    return new Headers(init);
+  } else if (Array.isArray(init)) {
+    return new Headers(init);
+  } else if (typeof init === "object") {
+    return new Headers(init);
+  } else {
+    return new Headers();
+  }
+}
+function mergeHeaders(...headers) {
+  return headers.reduce((acc, header) => {
+    const headersInstance = toHeadersInstance(header);
+    for (const [key, value] of headersInstance.entries()) {
+      if (key === "set-cookie") {
+        const splitCookies = splitSetCookieString(value);
+        splitCookies.forEach((cookie) => acc.append("set-cookie", cookie));
+      } else {
+        acc.set(key, value);
+      }
+    }
+    return acc;
+  }, new Headers());
+}
+var prefix = "Invariant failed";
+function invariant(condition, message) {
+  if (condition) {
+    return;
+  }
+  {
+    throw new Error(prefix);
+  }
+}
+function isNotFound(obj) {
+  return !!obj?.isNotFound;
+}
+function sanitizePathSegment(segment) {
+  return segment.replace(/[\x00-\x1f\x7f]/g, "");
+}
+function decodeSegment(segment) {
+  let decoded;
+  try {
+    decoded = decodeURI(segment);
+  } catch {
+    decoded = segment.replaceAll(/%[0-9A-F]{2}/gi, (match) => {
+      try {
+        return decodeURI(match);
+      } catch {
+        return match;
+      }
+    });
+  }
+  return sanitizePathSegment(decoded);
+}
+const SAFE_URL_PROTOCOLS = ["http:", "https:", "mailto:", "tel:"];
+function isDangerousProtocol(url) {
+  if (!url) return false;
+  try {
+    const parsed = new URL(url);
+    return !SAFE_URL_PROTOCOLS.includes(parsed.protocol);
+  } catch {
+    return false;
+  }
+}
+function decodePath(path, decodeIgnore) {
+  if (!path) return path;
+  const re2 = /%25|%5C/gi;
+  let cursor = 0;
+  let result = "";
+  let match;
+  while (null !== (match = re2.exec(path))) {
+    result += decodeSegment(path.slice(cursor, match.index)) + match[0];
+    cursor = re2.lastIndex;
+  }
+  result = result + decodeSegment(cursor ? path.slice(cursor) : path);
+  if (result.startsWith("//")) {
+    result = "/" + result.replace(/^\/+/, "");
+  }
+  return result;
+}
+function createLRUCache(max) {
+  const cache = /* @__PURE__ */ new Map();
+  let oldest;
+  let newest;
+  const touch = (entry) => {
+    if (!entry.next) return;
+    if (!entry.prev) {
+      entry.next.prev = void 0;
+      oldest = entry.next;
+      entry.next = void 0;
+      if (newest) {
+        entry.prev = newest;
+        newest.next = entry;
+      }
+    } else {
+      entry.prev.next = entry.next;
+      entry.next.prev = entry.prev;
+      entry.next = void 0;
+      if (newest) {
+        newest.next = entry;
+        entry.prev = newest;
+      }
+    }
+    newest = entry;
+  };
+  return {
+    get(key) {
+      const entry = cache.get(key);
+      if (!entry) return void 0;
+      touch(entry);
+      return entry.value;
+    },
+    set(key, value) {
+      if (cache.size >= max && oldest) {
+        const toDelete = oldest;
+        cache.delete(toDelete.key);
+        if (toDelete.next) {
+          oldest = toDelete.next;
+          toDelete.next.prev = void 0;
+        }
+        if (toDelete === newest) {
+          newest = void 0;
+        }
+      }
+      const existing = cache.get(key);
+      if (existing) {
+        existing.value = value;
+        touch(existing);
+      } else {
+        const entry = { key, value, prev: newest };
+        if (newest) newest.next = entry;
+        newest = entry;
+        if (!oldest) oldest = entry;
+        cache.set(key, entry);
+      }
+    },
+    clear() {
+      cache.clear();
+      oldest = void 0;
+      newest = void 0;
+    }
+  };
+}
+const rootRouteId = "__root__";
+function redirect(opts) {
+  opts.statusCode = opts.statusCode || opts.code || 307;
+  if (typeof opts.href === "string" && isDangerousProtocol(opts.href)) {
+    throw new Error(
+      `Redirect blocked: unsafe protocol in href "${opts.href}". Only ${SAFE_URL_PROTOCOLS.join(", ")} protocols are allowed.`
+    );
+  }
+  if (!opts.reloadDocument && typeof opts.href === "string") {
+    try {
+      new URL(opts.href);
+      opts.reloadDocument = true;
+    } catch {
+    }
+  }
+  const headers = new Headers(opts.headers);
+  if (opts.href && headers.get("Location") === null) {
+    headers.set("Location", opts.href);
+  }
+  const response = new Response(null, {
+    status: opts.statusCode,
+    headers
+  });
+  response.options = opts;
+  if (opts.throw) {
+    throw response;
+  }
+  return response;
+}
+function isRedirect(obj) {
+  return obj instanceof Response && !!obj.options;
+}
+function isResolvedRedirect(obj) {
+  return isRedirect(obj) && !!obj.options.href;
+}
+function parseRedirect(obj) {
+  if (obj !== null && typeof obj === "object" && obj.isSerializedRedirect) {
+    return redirect(obj);
+  }
+  return void 0;
+}
+function executeRewriteInput(rewrite, url) {
+  const res = rewrite?.input?.({ url });
+  if (res) {
+    if (typeof res === "string") {
+      return new URL(res);
+    } else if (res instanceof URL) {
+      return res;
+    }
+  }
+  return url;
+}
+var L = ((i) => (i[i.AggregateError = 1] = "AggregateError", i[i.ArrowFunction = 2] = "ArrowFunction", i[i.ErrorPrototypeStack = 4] = "ErrorPrototypeStack", i[i.ObjectAssign = 8] = "ObjectAssign", i[i.BigIntTypedArray = 16] = "BigIntTypedArray", i[i.RegExp = 32] = "RegExp", i))(L || {});
+var v = Symbol.asyncIterator, mr = Symbol.hasInstance, R = Symbol.isConcatSpreadable, C = Symbol.iterator, pr = Symbol.match, dr = Symbol.matchAll, gr = Symbol.replace, yr = Symbol.search, Nr = Symbol.species, br = Symbol.split, vr = Symbol.toPrimitive, P$1 = Symbol.toStringTag, Cr = Symbol.unscopables;
+var rt = { 0: "Symbol.asyncIterator", 1: "Symbol.hasInstance", 2: "Symbol.isConcatSpreadable", 3: "Symbol.iterator", 4: "Symbol.match", 5: "Symbol.matchAll", 6: "Symbol.replace", 7: "Symbol.search", 8: "Symbol.species", 9: "Symbol.split", 10: "Symbol.toPrimitive", 11: "Symbol.toStringTag", 12: "Symbol.unscopables" }, ve = { [v]: 0, [mr]: 1, [R]: 2, [C]: 3, [pr]: 4, [dr]: 5, [gr]: 6, [yr]: 7, [Nr]: 8, [br]: 9, [vr]: 10, [P$1]: 11, [Cr]: 12 }, tt = { 0: v, 1: mr, 2: R, 3: C, 4: pr, 5: dr, 6: gr, 7: yr, 8: Nr, 9: br, 10: vr, 11: P$1, 12: Cr }, nt = { 2: "!0", 3: "!1", 1: "void 0", 0: "null", 4: "-0", 5: "1/0", 6: "-1/0", 7: "0/0" }, o = void 0, ot = { 2: true, 3: false, 1: o, 0: null, 4: -0, 5: Number.POSITIVE_INFINITY, 6: Number.NEGATIVE_INFINITY, 7: Number.NaN };
+var Ce = { 0: "Error", 1: "EvalError", 2: "RangeError", 3: "ReferenceError", 4: "SyntaxError", 5: "TypeError", 6: "URIError" }, at = { 0: Error, 1: EvalError, 2: RangeError, 3: ReferenceError, 4: SyntaxError, 5: TypeError, 6: URIError };
+function c(e, r, t, n2, a, s, i, u, l, g, S, d) {
+  return { t: e, i: r, s: t, c: n2, m: a, p: s, e: i, a: u, f: l, b: g, o: S, l: d };
+}
+function F(e) {
+  return c(2, o, e, o, o, o, o, o, o, o, o, o);
+}
+var J = F(2), Z = F(3), Ae = F(1), Ee = F(0), st = F(4), it = F(5), ut = F(6), lt = F(7);
+function fn(e) {
+  switch (e) {
+    case '"':
+      return '\\"';
+    case "\\":
+      return "\\\\";
+    case `
+`:
+      return "\\n";
+    case "\r":
+      return "\\r";
+    case "\b":
+      return "\\b";
+    case "	":
+      return "\\t";
+    case "\f":
+      return "\\f";
+    case "<":
+      return "\\x3C";
+    case "\u2028":
+      return "\\u2028";
+    case "\u2029":
+      return "\\u2029";
+    default:
+      return o;
+  }
+}
+function y(e) {
+  let r = "", t = 0, n2;
+  for (let a = 0, s = e.length; a < s; a++) n2 = fn(e[a]), n2 && (r += e.slice(t, a) + n2, t = a + 1);
+  return t === 0 ? r = e : r += e.slice(t), r;
+}
+function Sn(e) {
+  switch (e) {
+    case "\\\\":
+      return "\\";
+    case '\\"':
+      return '"';
+    case "\\n":
+      return `
+`;
+    case "\\r":
+      return "\r";
+    case "\\b":
+      return "\b";
+    case "\\t":
+      return "	";
+    case "\\f":
+      return "\f";
+    case "\\x3C":
+      return "<";
+    case "\\u2028":
+      return "\u2028";
+    case "\\u2029":
+      return "\u2029";
+    default:
+      return e;
+  }
+}
+function B(e) {
+  return e.replace(/(\\\\|\\"|\\n|\\r|\\b|\\t|\\f|\\u2028|\\u2029|\\x3C)/g, Sn);
+}
+var U = "__SEROVAL_REFS__", ce = "$R", Ie = `self.${ce}`;
+function mn(e) {
+  return `(${Ie}=${Ie}||{})["${y(e)}"]=[]`;
+}
+var Ar = /* @__PURE__ */ new Map(), j = /* @__PURE__ */ new Map();
+function Er(e) {
+  return Ar.has(e);
+}
+function dn(e) {
+  return j.has(e);
+}
+function ct(e) {
+  if (Er(e)) return Ar.get(e);
+  throw new Re(e);
+}
+function ft(e) {
+  if (dn(e)) return j.get(e);
+  throw new Pe(e);
+}
+typeof globalThis != "undefined" ? Object.defineProperty(globalThis, U, { value: j, configurable: true, writable: false, enumerable: false }) : typeof window != "undefined" ? Object.defineProperty(window, U, { value: j, configurable: true, writable: false, enumerable: false }) : typeof self != "undefined" ? Object.defineProperty(self, U, { value: j, configurable: true, writable: false, enumerable: false }) : typeof global != "undefined" && Object.defineProperty(global, U, { value: j, configurable: true, writable: false, enumerable: false });
+function xe(e) {
+  return e instanceof EvalError ? 1 : e instanceof RangeError ? 2 : e instanceof ReferenceError ? 3 : e instanceof SyntaxError ? 4 : e instanceof TypeError ? 5 : e instanceof URIError ? 6 : 0;
+}
+function gn(e) {
+  let r = Ce[xe(e)];
+  return e.name !== r ? { name: e.name } : e.constructor.name !== r ? { name: e.constructor.name } : {};
+}
+function $(e, r) {
+  let t = gn(e), n2 = Object.getOwnPropertyNames(e);
+  for (let a = 0, s = n2.length, i; a < s; a++) i = n2[a], i !== "name" && i !== "message" && (i === "stack" ? r & 4 && (t = t || {}, t[i] = e[i]) : (t = t || {}, t[i] = e[i]));
+  return t;
+}
+function Oe(e) {
+  return Object.isFrozen(e) ? 3 : Object.isSealed(e) ? 2 : Object.isExtensible(e) ? 0 : 1;
+}
+function Te(e) {
+  switch (e) {
+    case Number.POSITIVE_INFINITY:
+      return it;
+    case Number.NEGATIVE_INFINITY:
+      return ut;
+  }
+  return e !== e ? lt : Object.is(e, -0) ? st : c(0, o, e, o, o, o, o, o, o, o, o, o);
+}
+function X(e) {
+  return c(1, o, y(e), o, o, o, o, o, o, o, o, o);
+}
+function we(e) {
+  return c(3, o, "" + e, o, o, o, o, o, o, o, o, o);
+}
+function mt(e) {
+  return c(4, e, o, o, o, o, o, o, o, o, o, o);
+}
+function he(e, r) {
+  let t = r.valueOf();
+  return c(5, e, t !== t ? "" : r.toISOString(), o, o, o, o, o, o, o, o, o);
+}
+function ze(e, r) {
+  return c(6, e, o, y(r.source), r.flags, o, o, o, o, o, o, o);
+}
+function pt(e, r) {
+  return c(17, e, ve[r], o, o, o, o, o, o, o, o, o);
+}
+function dt(e, r) {
+  return c(18, e, y(ct(r)), o, o, o, o, o, o, o, o, o);
+}
+function fe(e, r, t) {
+  return c(25, e, t, y(r), o, o, o, o, o, o, o, o);
+}
+function _e(e, r, t) {
+  return c(9, e, o, o, o, o, o, t, o, o, Oe(r), o);
+}
+function ke(e, r) {
+  return c(21, e, o, o, o, o, o, o, r, o, o, o);
+}
+function De(e, r, t) {
+  return c(15, e, o, r.constructor.name, o, o, o, o, t, r.byteOffset, o, r.length);
+}
+function Fe(e, r, t) {
+  return c(16, e, o, r.constructor.name, o, o, o, o, t, r.byteOffset, o, r.byteLength);
+}
+function Be(e, r, t) {
+  return c(20, e, o, o, o, o, o, o, t, r.byteOffset, o, r.byteLength);
+}
+function Ve(e, r, t) {
+  return c(13, e, xe(r), o, y(r.message), t, o, o, o, o, o, o);
+}
+function Me(e, r, t) {
+  return c(14, e, xe(r), o, y(r.message), t, o, o, o, o, o, o);
+}
+function Le(e, r) {
+  return c(7, e, o, o, o, o, o, r, o, o, o, o);
+}
+function Ue(e, r) {
+  return c(28, o, o, o, o, o, o, [e, r], o, o, o, o);
+}
+function je(e, r) {
+  return c(30, o, o, o, o, o, o, [e, r], o, o, o, o);
+}
+function Ye(e, r, t) {
+  return c(31, e, o, o, o, o, o, t, r, o, o, o);
+}
+function qe(e, r) {
+  return c(32, e, o, o, o, o, o, o, r, o, o, o);
+}
+function We(e, r) {
+  return c(33, e, o, o, o, o, o, o, r, o, o, o);
+}
+function Ge(e, r) {
+  return c(34, e, o, o, o, o, o, o, r, o, o, o);
+}
+function Ke(e, r, t, n2) {
+  return c(35, e, t, o, o, o, o, r, o, o, o, n2);
+}
+var yn = { parsing: 1, serialization: 2, deserialization: 3 };
+function Nn(e) {
+  return `Seroval Error (step: ${yn[e]})`;
+}
+var bn = (e, r) => Nn(e), Se = class extends Error {
+  constructor(t, n2) {
+    super(bn(t));
+    this.cause = n2;
+  }
+}, z = class extends Se {
+  constructor(r) {
+    super("parsing", r);
+  }
+}, He = class extends Se {
+  constructor(r) {
+    super("deserialization", r);
+  }
+};
+function _(e) {
+  return `Seroval Error (specific: ${e})`;
+}
+var x$1 = class x extends Error {
+  constructor(t) {
+    super(_(1));
+    this.value = t;
+  }
+}, w$1 = class w extends Error {
+  constructor(r) {
+    super(_(2));
+  }
+}, Q = class extends Error {
+  constructor(r) {
+    super(_(3));
+  }
+}, V = class extends Error {
+  constructor(r) {
+    super(_(4));
+  }
+}, Re = class extends Error {
+  constructor(t) {
+    super(_(5));
+    this.value = t;
+  }
+}, Pe = class extends Error {
+  constructor(r) {
+    super(_(6));
+  }
+}, Je = class extends Error {
+  constructor(r) {
+    super(_(7));
+  }
+}, h = class extends Error {
+  constructor(r) {
+    super(_(8));
+  }
+}, ee$1 = class ee extends Error {
+  constructor(r) {
+    super(_(9));
+  }
+};
+var Y = class {
+  constructor(r, t) {
+    this.value = r;
+    this.replacement = t;
+  }
+};
+var re = () => {
+  let e = { p: 0, s: 0, f: 0 };
+  return e.p = new Promise((r, t) => {
+    e.s = r, e.f = t;
+  }), e;
+}, vn = (e, r) => {
+  e.s(r), e.p.s = 1, e.p.v = r;
+}, Cn = (e, r) => {
+  e.f(r), e.p.s = 2, e.p.v = r;
+}, yt = re.toString(), Nt = vn.toString(), bt = Cn.toString(), Rr = () => {
+  let e = [], r = [], t = true, n2 = false, a = 0, s = (l, g, S) => {
+    for (S = 0; S < a; S++) r[S] && r[S][g](l);
+  }, i = (l, g, S, d) => {
+    for (g = 0, S = e.length; g < S; g++) d = e[g], !t && g === S - 1 ? l[n2 ? "return" : "throw"](d) : l.next(d);
+  }, u = (l, g) => (t && (g = a++, r[g] = l), i(l), () => {
+    t && (r[g] = r[a], r[a--] = void 0);
+  });
+  return { __SEROVAL_STREAM__: true, on: (l) => u(l), next: (l) => {
+    t && (e.push(l), s(l, "next"));
+  }, throw: (l) => {
+    t && (e.push(l), s(l, "throw"), t = false, n2 = false, r.length = 0);
+  }, return: (l) => {
+    t && (e.push(l), s(l, "return"), t = false, n2 = true, r.length = 0);
+  } };
+}, vt = Rr.toString(), Pr = (e) => (r) => () => {
+  let t = 0, n2 = { [e]: () => n2, next: () => {
+    if (t > r.d) return { done: true, value: void 0 };
+    let a = t++, s = r.v[a];
+    if (a === r.t) throw s;
+    return { done: a === r.d, value: s };
+  } };
+  return n2;
+}, Ct = Pr.toString(), xr = (e, r) => (t) => () => {
+  let n2 = 0, a = -1, s = false, i = [], u = [], l = (S = 0, d = u.length) => {
+    for (; S < d; S++) u[S].s({ done: true, value: void 0 });
+  };
+  t.on({ next: (S) => {
+    let d = u.shift();
+    d && d.s({ done: false, value: S }), i.push(S);
+  }, throw: (S) => {
+    let d = u.shift();
+    d && d.f(S), l(), a = i.length, s = true, i.push(S);
+  }, return: (S) => {
+    let d = u.shift();
+    d && d.s({ done: true, value: S }), l(), a = i.length, i.push(S);
+  } });
+  let g = { [e]: () => g, next: () => {
+    if (a === -1) {
+      let K = n2++;
+      if (K >= i.length) {
+        let et = r();
+        return u.push(et), et.p;
+      }
+      return { done: false, value: i[K] };
+    }
+    if (n2 > a) return { done: true, value: void 0 };
+    let S = n2++, d = i[S];
+    if (S !== a) return { done: false, value: d };
+    if (s) throw d;
+    return { done: true, value: d };
+  } };
+  return g;
+}, At = xr.toString(), Or = (e) => {
+  let r = atob(e), t = r.length, n2 = new Uint8Array(t);
+  for (let a = 0; a < t; a++) n2[a] = r.charCodeAt(a);
+  return n2.buffer;
+}, Et = Or.toString();
+function Ze(e) {
+  return "__SEROVAL_SEQUENCE__" in e;
+}
+function Tr(e, r, t) {
+  return { __SEROVAL_SEQUENCE__: true, v: e, t: r, d: t };
+}
+function $e(e) {
+  let r = [], t = -1, n2 = -1, a = e[C]();
+  for (; ; ) try {
+    let s = a.next();
+    if (r.push(s.value), s.done) {
+      n2 = r.length - 1;
+      break;
+    }
+  } catch (s) {
+    t = r.length, r.push(s);
+  }
+  return Tr(r, t, n2);
+}
+var An = Pr(C);
+function It(e) {
+  return An(e);
+}
+var Rt = {}, Pt = {};
+var xt = { 0: {}, 1: {}, 2: {}, 3: {}, 4: {}, 5: {} }, Ot = { 0: "[]", 1: yt, 2: Nt, 3: bt, 4: vt, 5: Et };
+function M(e) {
+  return "__SEROVAL_STREAM__" in e;
+}
+function te() {
+  return Rr();
+}
+function Xe(e) {
+  let r = te(), t = e[v]();
+  async function n2() {
+    try {
+      let a = await t.next();
+      a.done ? r.return(a.value) : (r.next(a.value), await n2());
+    } catch (a) {
+      r.throw(a);
+    }
+  }
+  return n2().catch(() => {
+  }), r;
+}
+var En = xr(v, re);
+function Tt(e) {
+  return En(e);
+}
+async function wr(e) {
+  try {
+    return [1, await e];
+  } catch (r) {
+    return [0, r];
+  }
+}
+function pe(e, r) {
+  return { plugins: r.plugins, mode: e, marked: /* @__PURE__ */ new Set(), features: 63 ^ (r.disabledFeatures || 0), refs: r.refs || /* @__PURE__ */ new Map(), depthLimit: r.depthLimit || 1e3 };
+}
+function de(e, r) {
+  e.marked.add(r);
+}
+function hr(e, r) {
+  let t = e.refs.size;
+  return e.refs.set(r, t), t;
+}
+function Qe(e, r) {
+  let t = e.refs.get(r);
+  return t != null ? (de(e, t), { type: 1, value: mt(t) }) : { type: 0, value: hr(e, r) };
+}
+function q(e, r) {
+  let t = Qe(e, r);
+  return t.type === 1 ? t : Er(r) ? { type: 2, value: dt(t.value, r) } : t;
+}
+function I(e, r) {
+  let t = q(e, r);
+  if (t.type !== 0) return t.value;
+  if (r in ve) return pt(t.value, r);
+  throw new x$1(r);
+}
+function k(e, r) {
+  let t = Qe(e, xt[r]);
+  return t.type === 1 ? t.value : c(26, t.value, r, o, o, o, o, o, o, o, o, o);
+}
+function er(e) {
+  let r = Qe(e, Rt);
+  return r.type === 1 ? r.value : c(27, r.value, o, o, o, o, o, o, I(e, C), o, o, o);
+}
+function rr(e) {
+  let r = Qe(e, Pt);
+  return r.type === 1 ? r.value : c(29, r.value, o, o, o, o, o, [k(e, 1), I(e, v)], o, o, o, o);
+}
+function tr(e, r, t, n2) {
+  return c(t ? 11 : 10, e, o, o, o, n2, o, o, o, o, Oe(r), o);
+}
+function nr(e, r, t, n2) {
+  return c(8, r, o, o, o, o, { k: t, v: n2 }, o, k(e, 0), o, o, o);
+}
+function ht(e, r, t) {
+  return c(22, r, t, o, o, o, o, o, k(e, 1), o, o, o);
+}
+function or(e, r, t) {
+  let n2 = new Uint8Array(t), a = "";
+  for (let s = 0, i = n2.length; s < i; s++) a += String.fromCharCode(n2[s]);
+  return c(19, r, y(btoa(a)), o, o, o, o, o, k(e, 5), o, o, o);
+}
+function ne(e, r) {
+  return { base: pe(e, r), child: void 0 };
+}
+var _r = class {
+  constructor(r, t) {
+    this._p = r;
+    this.depth = t;
+  }
+  parse(r) {
+    return N(this._p, this.depth, r);
+  }
+};
+async function Rn(e, r, t) {
+  let n2 = [];
+  for (let a = 0, s = t.length; a < s; a++) a in t ? n2[a] = await N(e, r, t[a]) : n2[a] = 0;
+  return n2;
+}
+async function Pn(e, r, t, n2) {
+  return _e(t, n2, await Rn(e, r, n2));
+}
+async function kr(e, r, t) {
+  let n2 = Object.entries(t), a = [], s = [];
+  for (let i = 0, u = n2.length; i < u; i++) a.push(y(n2[i][0])), s.push(await N(e, r, n2[i][1]));
+  return C in t && (a.push(I(e.base, C)), s.push(Ue(er(e.base), await N(e, r, $e(t))))), v in t && (a.push(I(e.base, v)), s.push(je(rr(e.base), await N(e, r, Xe(t))))), P$1 in t && (a.push(I(e.base, P$1)), s.push(X(t[P$1]))), R in t && (a.push(I(e.base, R)), s.push(t[R] ? J : Z)), { k: a, v: s };
+}
+async function zr(e, r, t, n2, a) {
+  return tr(t, n2, a, await kr(e, r, n2));
+}
+async function xn(e, r, t, n2) {
+  return ke(t, await N(e, r, n2.valueOf()));
+}
+async function On(e, r, t, n2) {
+  return De(t, n2, await N(e, r, n2.buffer));
+}
+async function Tn(e, r, t, n2) {
+  return Fe(t, n2, await N(e, r, n2.buffer));
+}
+async function wn(e, r, t, n2) {
+  return Be(t, n2, await N(e, r, n2.buffer));
+}
+async function zt(e, r, t, n2) {
+  let a = $(n2, e.base.features);
+  return Ve(t, n2, a ? await kr(e, r, a) : o);
+}
+async function hn(e, r, t, n2) {
+  let a = $(n2, e.base.features);
+  return Me(t, n2, a ? await kr(e, r, a) : o);
+}
+async function zn(e, r, t, n2) {
+  let a = [], s = [];
+  for (let [i, u] of n2.entries()) a.push(await N(e, r, i)), s.push(await N(e, r, u));
+  return nr(e.base, t, a, s);
+}
+async function _n(e, r, t, n2) {
+  let a = [];
+  for (let s of n2.keys()) a.push(await N(e, r, s));
+  return Le(t, a);
+}
+async function _t(e, r, t, n2) {
+  let a = e.base.plugins;
+  if (a) for (let s = 0, i = a.length; s < i; s++) {
+    let u = a[s];
+    if (u.parse.async && u.test(n2)) return fe(t, u.tag, await u.parse.async(n2, new _r(e, r), { id: t }));
+  }
+  return o;
+}
+async function kn(e, r, t, n2) {
+  let [a, s] = await wr(n2);
+  return c(12, t, a, o, o, o, o, o, await N(e, r, s), o, o, o);
+}
+function Dn(e, r, t, n2, a) {
+  let s = [], i = t.on({ next: (u) => {
+    de(this.base, r), N(this, e, u).then((l) => {
+      s.push(qe(r, l));
+    }, (l) => {
+      a(l), i();
+    });
+  }, throw: (u) => {
+    de(this.base, r), N(this, e, u).then((l) => {
+      s.push(We(r, l)), n2(s), i();
+    }, (l) => {
+      a(l), i();
+    });
+  }, return: (u) => {
+    de(this.base, r), N(this, e, u).then((l) => {
+      s.push(Ge(r, l)), n2(s), i();
+    }, (l) => {
+      a(l), i();
+    });
+  } });
+}
+async function Fn(e, r, t, n2) {
+  return Ye(t, k(e.base, 4), await new Promise(Dn.bind(e, r, t, n2)));
+}
+async function Bn(e, r, t, n2) {
+  let a = [];
+  for (let s = 0, i = n2.v.length; s < i; s++) a[s] = await N(e, r, n2.v[s]);
+  return Ke(t, a, n2.t, n2.d);
+}
+async function Vn(e, r, t, n2) {
+  if (Array.isArray(n2)) return Pn(e, r, t, n2);
+  if (M(n2)) return Fn(e, r, t, n2);
+  if (Ze(n2)) return Bn(e, r, t, n2);
+  let a = n2.constructor;
+  if (a === Y) return N(e, r, n2.replacement);
+  let s = await _t(e, r, t, n2);
+  if (s) return s;
+  switch (a) {
+    case Object:
+      return zr(e, r, t, n2, false);
+    case o:
+      return zr(e, r, t, n2, true);
+    case Date:
+      return he(t, n2);
+    case Error:
+    case EvalError:
+    case RangeError:
+    case ReferenceError:
+    case SyntaxError:
+    case TypeError:
+    case URIError:
+      return zt(e, r, t, n2);
+    case Number:
+    case Boolean:
+    case String:
+    case BigInt:
+      return xn(e, r, t, n2);
+    case ArrayBuffer:
+      return or(e.base, t, n2);
+    case Int8Array:
+    case Int16Array:
+    case Int32Array:
+    case Uint8Array:
+    case Uint16Array:
+    case Uint32Array:
+    case Uint8ClampedArray:
+    case Float32Array:
+    case Float64Array:
+      return On(e, r, t, n2);
+    case DataView:
+      return wn(e, r, t, n2);
+    case Map:
+      return zn(e, r, t, n2);
+    case Set:
+      return _n(e, r, t, n2);
+  }
+  if (a === Promise || n2 instanceof Promise) return kn(e, r, t, n2);
+  let i = e.base.features;
+  if (i & 32 && a === RegExp) return ze(t, n2);
+  if (i & 16) switch (a) {
+    case BigInt64Array:
+    case BigUint64Array:
+      return Tn(e, r, t, n2);
+  }
+  if (i & 1 && typeof AggregateError != "undefined" && (a === AggregateError || n2 instanceof AggregateError)) return hn(e, r, t, n2);
+  if (n2 instanceof Error) return zt(e, r, t, n2);
+  if (C in n2 || v in n2) return zr(e, r, t, n2, !!a);
+  throw new x$1(n2);
+}
+async function Mn(e, r, t) {
+  let n2 = q(e.base, t);
+  if (n2.type !== 0) return n2.value;
+  let a = await _t(e, r, n2.value, t);
+  if (a) return a;
+  throw new x$1(t);
+}
+async function N(e, r, t) {
+  switch (typeof t) {
+    case "boolean":
+      return t ? J : Z;
+    case "undefined":
+      return Ae;
+    case "string":
+      return X(t);
+    case "number":
+      return Te(t);
+    case "bigint":
+      return we(t);
+    case "object": {
+      if (t) {
+        let n2 = q(e.base, t);
+        return n2.type === 0 ? await Vn(e, r + 1, n2.value, t) : n2.value;
+      }
+      return Ee;
+    }
+    case "symbol":
+      return I(e.base, t);
+    case "function":
+      return Mn(e, r, t);
+    default:
+      throw new x$1(t);
+  }
+}
+async function oe(e, r) {
+  try {
+    return await N(e, 0, r);
+  } catch (t) {
+    throw t instanceof z ? t : new z(t);
+  }
+}
+var ae = ((t) => (t[t.Vanilla = 1] = "Vanilla", t[t.Cross = 2] = "Cross", t))(ae || {});
+function ni(e) {
+  return e;
+}
+function kt(e, r) {
+  for (let t = 0, n2 = r.length; t < n2; t++) {
+    let a = r[t];
+    e.has(a) || (e.add(a), a.extends && kt(e, a.extends));
+  }
+}
+function A(e) {
+  if (e) {
+    let r = /* @__PURE__ */ new Set();
+    return kt(r, e), [...r];
+  }
+}
+function Dt(e) {
+  switch (e) {
+    case "Int8Array":
+      return Int8Array;
+    case "Int16Array":
+      return Int16Array;
+    case "Int32Array":
+      return Int32Array;
+    case "Uint8Array":
+      return Uint8Array;
+    case "Uint16Array":
+      return Uint16Array;
+    case "Uint32Array":
+      return Uint32Array;
+    case "Uint8ClampedArray":
+      return Uint8ClampedArray;
+    case "Float32Array":
+      return Float32Array;
+    case "Float64Array":
+      return Float64Array;
+    case "BigInt64Array":
+      return BigInt64Array;
+    case "BigUint64Array":
+      return BigUint64Array;
+    default:
+      throw new Je(e);
+  }
+}
+var Ln = 1e6, Un = 1e4, jn = 2e4;
+function Bt(e, r) {
+  switch (r) {
+    case 3:
+      return Object.freeze(e);
+    case 1:
+      return Object.preventExtensions(e);
+    case 2:
+      return Object.seal(e);
+    default:
+      return e;
+  }
+}
+var Yn = 1e3;
+function Vt(e, r) {
+  var t;
+  return { mode: e, plugins: r.plugins, refs: r.refs || /* @__PURE__ */ new Map(), features: (t = r.features) != null ? t : 63 ^ (r.disabledFeatures || 0), depthLimit: r.depthLimit || Yn };
+}
+function Mt(e) {
+  return { mode: 1, base: Vt(1, e), child: o, state: { marked: new Set(e.markedRefs) } };
+}
+var Dr = class {
+  constructor(r, t) {
+    this._p = r;
+    this.depth = t;
+  }
+  deserialize(r) {
+    return p$1(this._p, this.depth, r);
+  }
+};
+function Ut(e, r) {
+  if (r < 0 || !Number.isFinite(r) || !Number.isInteger(r)) throw new h({ t: 4, i: r });
+  if (e.refs.has(r)) throw new Error("Conflicted ref id: " + r);
+}
+function qn(e, r, t) {
+  return Ut(e.base, r), e.state.marked.has(r) && e.base.refs.set(r, t), t;
+}
+function Wn(e, r, t) {
+  return Ut(e.base, r), e.base.refs.set(r, t), t;
+}
+function b(e, r, t) {
+  return e.mode === 1 ? qn(e, r, t) : Wn(e, r, t);
+}
+function Fr(e, r, t) {
+  if (Object.hasOwn(r, t)) return r[t];
+  throw new h(e);
+}
+function Gn(e, r) {
+  return b(e, r.i, ft(B(r.s)));
+}
+function Kn(e, r, t) {
+  let n2 = t.a, a = n2.length, s = b(e, t.i, new Array(a));
+  for (let i = 0, u; i < a; i++) u = n2[i], u && (s[i] = p$1(e, r, u));
+  return Bt(s, t.o), s;
+}
+function Hn(e) {
+  switch (e) {
+    case "constructor":
+    case "__proto__":
+    case "prototype":
+    case "__defineGetter__":
+    case "__defineSetter__":
+    case "__lookupGetter__":
+    case "__lookupSetter__":
+      return false;
+    default:
+      return true;
+  }
+}
+function Jn(e) {
+  switch (e) {
+    case v:
+    case R:
+    case P$1:
+    case C:
+      return true;
+    default:
+      return false;
+  }
+}
+function Ft(e, r, t) {
+  Hn(r) ? e[r] = t : Object.defineProperty(e, r, { value: t, configurable: true, enumerable: true, writable: true });
+}
+function Zn(e, r, t, n2, a) {
+  if (typeof n2 == "string") Ft(t, n2, p$1(e, r, a));
+  else {
+    let s = p$1(e, r, n2);
+    switch (typeof s) {
+      case "string":
+        Ft(t, s, p$1(e, r, a));
+        break;
+      case "symbol":
+        Jn(s) && (t[s] = p$1(e, r, a));
+        break;
+      default:
+        throw new h(n2);
+    }
+  }
+}
+function jt(e, r, t, n2) {
+  let a = t.k;
+  if (a.length > 0) for (let i = 0, u = t.v, l = a.length; i < l; i++) Zn(e, r, n2, a[i], u[i]);
+  return n2;
+}
+function $n(e, r, t) {
+  let n2 = b(e, t.i, t.t === 10 ? {} : /* @__PURE__ */ Object.create(null));
+  return jt(e, r, t.p, n2), Bt(n2, t.o), n2;
+}
+function Xn(e, r) {
+  return b(e, r.i, new Date(r.s));
+}
+function Qn(e, r) {
+  if (e.base.features & 32) {
+    let t = B(r.c);
+    if (t.length > jn) throw new h(r);
+    return b(e, r.i, new RegExp(t, r.m));
+  }
+  throw new w$1(r);
+}
+function eo(e, r, t) {
+  let n2 = b(e, t.i, /* @__PURE__ */ new Set());
+  for (let a = 0, s = t.a, i = s.length; a < i; a++) n2.add(p$1(e, r, s[a]));
+  return n2;
+}
+function ro(e, r, t) {
+  let n2 = b(e, t.i, /* @__PURE__ */ new Map());
+  for (let a = 0, s = t.e.k, i = t.e.v, u = s.length; a < u; a++) n2.set(p$1(e, r, s[a]), p$1(e, r, i[a]));
+  return n2;
+}
+function to(e, r) {
+  if (r.s.length > Ln) throw new h(r);
+  return b(e, r.i, Or(B(r.s)));
+}
+function no(e, r, t) {
+  var u;
+  let n2 = Dt(t.c), a = p$1(e, r, t.f), s = (u = t.b) != null ? u : 0;
+  if (s < 0 || s > a.byteLength) throw new h(t);
+  return b(e, t.i, new n2(a, s, t.l));
+}
+function oo(e, r, t) {
+  var i;
+  let n2 = p$1(e, r, t.f), a = (i = t.b) != null ? i : 0;
+  if (a < 0 || a > n2.byteLength) throw new h(t);
+  return b(e, t.i, new DataView(n2, a, t.l));
+}
+function Yt(e, r, t, n2) {
+  if (t.p) {
+    let a = jt(e, r, t.p, {});
+    Object.defineProperties(n2, Object.getOwnPropertyDescriptors(a));
+  }
+  return n2;
+}
+function ao(e, r, t) {
+  let n2 = b(e, t.i, new AggregateError([], B(t.m)));
+  return Yt(e, r, t, n2);
+}
+function so(e, r, t) {
+  let n2 = Fr(t, at, t.s), a = b(e, t.i, new n2(B(t.m)));
+  return Yt(e, r, t, a);
+}
+function io(e, r, t) {
+  let n2 = re(), a = b(e, t.i, n2.p), s = p$1(e, r, t.f);
+  return t.s ? n2.s(s) : n2.f(s), a;
+}
+function uo(e, r, t) {
+  return b(e, t.i, Object(p$1(e, r, t.f)));
+}
+function lo(e, r, t) {
+  let n2 = e.base.plugins;
+  if (n2) {
+    let a = B(t.c);
+    for (let s = 0, i = n2.length; s < i; s++) {
+      let u = n2[s];
+      if (u.tag === a) return b(e, t.i, u.deserialize(t.s, new Dr(e, r), { id: t.i }));
+    }
+  }
+  throw new Q(t.c);
+}
+function co(e, r) {
+  return b(e, r.i, b(e, r.s, re()).p);
+}
+function fo(e, r, t) {
+  let n2 = e.base.refs.get(t.i);
+  if (n2) return n2.s(p$1(e, r, t.a[1])), o;
+  throw new V("Promise");
+}
+function So(e, r, t) {
+  let n2 = e.base.refs.get(t.i);
+  if (n2) return n2.f(p$1(e, r, t.a[1])), o;
+  throw new V("Promise");
+}
+function mo(e, r, t) {
+  p$1(e, r, t.a[0]);
+  let n2 = p$1(e, r, t.a[1]);
+  return It(n2);
+}
+function po(e, r, t) {
+  p$1(e, r, t.a[0]);
+  let n2 = p$1(e, r, t.a[1]);
+  return Tt(n2);
+}
+function go(e, r, t) {
+  let n2 = b(e, t.i, te()), a = t.a, s = a.length;
+  if (s) for (let i = 0; i < s; i++) p$1(e, r, a[i]);
+  return n2;
+}
+function yo(e, r, t) {
+  let n2 = e.base.refs.get(t.i);
+  if (n2 && M(n2)) return n2.next(p$1(e, r, t.f)), o;
+  throw new V("Stream");
+}
+function No(e, r, t) {
+  let n2 = e.base.refs.get(t.i);
+  if (n2 && M(n2)) return n2.throw(p$1(e, r, t.f)), o;
+  throw new V("Stream");
+}
+function bo(e, r, t) {
+  let n2 = e.base.refs.get(t.i);
+  if (n2 && M(n2)) return n2.return(p$1(e, r, t.f)), o;
+  throw new V("Stream");
+}
+function vo(e, r, t) {
+  return p$1(e, r, t.f), o;
+}
+function Co(e, r, t) {
+  return p$1(e, r, t.a[1]), o;
+}
+function Ao(e, r, t) {
+  let n2 = b(e, t.i, Tr([], t.s, t.l));
+  for (let a = 0, s = t.a.length; a < s; a++) n2.v[a] = p$1(e, r, t.a[a]);
+  return n2;
+}
+function p$1(e, r, t) {
+  if (r > e.base.depthLimit) throw new ee$1(e.base.depthLimit);
+  switch (r += 1, t.t) {
+    case 2:
+      return Fr(t, ot, t.s);
+    case 0:
+      return Number(t.s);
+    case 1:
+      return B(String(t.s));
+    case 3:
+      if (String(t.s).length > Un) throw new h(t);
+      return BigInt(t.s);
+    case 4:
+      return e.base.refs.get(t.i);
+    case 18:
+      return Gn(e, t);
+    case 9:
+      return Kn(e, r, t);
+    case 10:
+    case 11:
+      return $n(e, r, t);
+    case 5:
+      return Xn(e, t);
+    case 6:
+      return Qn(e, t);
+    case 7:
+      return eo(e, r, t);
+    case 8:
+      return ro(e, r, t);
+    case 19:
+      return to(e, t);
+    case 16:
+    case 15:
+      return no(e, r, t);
+    case 20:
+      return oo(e, r, t);
+    case 14:
+      return ao(e, r, t);
+    case 13:
+      return so(e, r, t);
+    case 12:
+      return io(e, r, t);
+    case 17:
+      return Fr(t, tt, t.s);
+    case 21:
+      return uo(e, r, t);
+    case 25:
+      return lo(e, r, t);
+    case 22:
+      return co(e, t);
+    case 23:
+      return fo(e, r, t);
+    case 24:
+      return So(e, r, t);
+    case 28:
+      return mo(e, r, t);
+    case 30:
+      return po(e, r, t);
+    case 31:
+      return go(e, r, t);
+    case 32:
+      return yo(e, r, t);
+    case 33:
+      return No(e, r, t);
+    case 34:
+      return bo(e, r, t);
+    case 27:
+      return vo(e, r, t);
+    case 29:
+      return Co(e, r, t);
+    case 35:
+      return Ao(e, r, t);
+    default:
+      throw new w$1(t);
+  }
+}
+function ar(e, r) {
+  try {
+    return p$1(e, 0, r);
+  } catch (t) {
+    throw new He(t);
+  }
+}
+var Eo = () => T, Io = Eo.toString(), qt = /=>/.test(Io);
+function sr(e, r) {
+  return qt ? (e.length === 1 ? e[0] : "(" + e.join(",") + ")") + "=>" + (r.startsWith("{") ? "(" + r + ")" : r) : "function(" + e.join(",") + "){return " + r + "}";
+}
+function Wt(e, r) {
+  return qt ? (e.length === 1 ? e[0] : "(" + e.join(",") + ")") + "=>{" + r + "}" : "function(" + e.join(",") + "){" + r + "}";
+}
+var Ht = "hjkmoquxzABCDEFGHIJKLNPQRTUVWXYZ$_", Gt = Ht.length, Jt = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789$_", Kt = Jt.length;
+function Br(e) {
+  let r = e % Gt, t = Ht[r];
+  for (e = (e - r) / Gt; e > 0; ) r = e % Kt, t += Jt[r], e = (e - r) / Kt;
+  return t;
+}
+var Ro = /^[$A-Z_][0-9A-Z_$]*$/i;
+function Vr(e) {
+  let r = e[0];
+  return (r === "$" || r === "_" || r >= "A" && r <= "Z" || r >= "a" && r <= "z") && Ro.test(e);
+}
+function ye(e) {
+  switch (e.t) {
+    case 0:
+      return e.s + "=" + e.v;
+    case 2:
+      return e.s + ".set(" + e.k + "," + e.v + ")";
+    case 1:
+      return e.s + ".add(" + e.v + ")";
+    case 3:
+      return e.s + ".delete(" + e.k + ")";
+  }
+}
+function Po(e) {
+  let r = [], t = e[0];
+  for (let n2 = 1, a = e.length, s, i = t; n2 < a; n2++) s = e[n2], s.t === 0 && s.v === i.v ? t = { t: 0, s: s.s, k: o, v: ye(t) } : s.t === 2 && s.s === i.s ? t = { t: 2, s: ye(t), k: s.k, v: s.v } : s.t === 1 && s.s === i.s ? t = { t: 1, s: ye(t), k: o, v: s.v } : s.t === 3 && s.s === i.s ? t = { t: 3, s: ye(t), k: s.k, v: o } : (r.push(t), t = s), i = s;
+  return r.push(t), r;
+}
+function tn(e) {
+  if (e.length) {
+    let r = "", t = Po(e);
+    for (let n2 = 0, a = t.length; n2 < a; n2++) r += ye(t[n2]) + ",";
+    return r;
+  }
+  return o;
+}
+var xo = "Object.create(null)", Oo = "new Set", To = "new Map", wo = "Promise.resolve", ho = "Promise.reject", zo = { 3: "Object.freeze", 2: "Object.seal", 1: "Object.preventExtensions", 0: o };
+function nn(e, r) {
+  return { mode: e, plugins: r.plugins, features: r.features, marked: new Set(r.markedRefs), stack: [], flags: [], assignments: [] };
+}
+function ur(e) {
+  return { mode: 2, base: nn(2, e), state: e, child: o };
+}
+var Mr = class {
+  constructor(r) {
+    this._p = r;
+  }
+  serialize(r) {
+    return f(this._p, r);
+  }
+};
+function ko(e, r) {
+  let t = e.valid.get(r);
+  t == null && (t = e.valid.size, e.valid.set(r, t));
+  let n2 = e.vars[t];
+  return n2 == null && (n2 = Br(t), e.vars[t] = n2), n2;
+}
+function Do(e) {
+  return ce + "[" + e + "]";
+}
+function m(e, r) {
+  return e.mode === 1 ? ko(e.state, r) : Do(r);
+}
+function O(e, r) {
+  e.marked.add(r);
+}
+function Lr(e, r) {
+  return e.marked.has(r);
+}
+function jr(e, r, t) {
+  r !== 0 && (O(e.base, t), e.base.flags.push({ type: r, value: m(e, t) }));
+}
+function Fo(e) {
+  let r = "";
+  for (let t = 0, n2 = e.flags, a = n2.length; t < a; t++) {
+    let s = n2[t];
+    r += zo[s.type] + "(" + s.value + "),";
+  }
+  return r;
+}
+function on(e) {
+  let r = tn(e.assignments), t = Fo(e);
+  return r ? t ? r + t : r : t;
+}
+function Yr(e, r, t) {
+  e.assignments.push({ t: 0, s: r, k: o, v: t });
+}
+function Bo(e, r, t) {
+  e.base.assignments.push({ t: 1, s: m(e, r), k: o, v: t });
+}
+function ge(e, r, t, n2) {
+  e.base.assignments.push({ t: 2, s: m(e, r), k: t, v: n2 });
+}
+function Zt(e, r, t) {
+  e.base.assignments.push({ t: 3, s: m(e, r), k: t, v: o });
+}
+function Ne(e, r, t, n2) {
+  Yr(e.base, m(e, r) + "[" + t + "]", n2);
+}
+function Ur(e, r, t, n2) {
+  Yr(e.base, m(e, r) + "." + t, n2);
+}
+function Vo(e, r, t, n2) {
+  Yr(e.base, m(e, r) + ".v[" + t + "]", n2);
+}
+function D(e, r) {
+  return r.t === 4 && e.stack.includes(r.i);
+}
+function se(e, r, t) {
+  return e.mode === 1 && !Lr(e.base, r) ? t : m(e, r) + "=" + t;
+}
+function Mo(e) {
+  return U + '.get("' + e.s + '")';
+}
+function $t(e, r, t, n2) {
+  return t ? D(e.base, t) ? (O(e.base, r), Ne(e, r, n2, m(e, t.i)), "") : f(e, t) : "";
+}
+function Lo(e, r) {
+  let t = r.i, n2 = r.a, a = n2.length;
+  if (a > 0) {
+    e.base.stack.push(t);
+    let s = $t(e, t, n2[0], 0), i = s === "";
+    for (let u = 1, l; u < a; u++) l = $t(e, t, n2[u], u), s += "," + l, i = l === "";
+    return e.base.stack.pop(), jr(e, r.o, r.i), "[" + s + (i ? ",]" : "]");
+  }
+  return "[]";
+}
+function Xt(e, r, t, n2) {
+  if (typeof t == "string") {
+    let a = Number(t), s = a >= 0 && a.toString() === t || Vr(t);
+    if (D(e.base, n2)) {
+      let i = m(e, n2.i);
+      return O(e.base, r.i), s && a !== a ? Ur(e, r.i, t, i) : Ne(e, r.i, s ? t : '"' + t + '"', i), "";
+    }
+    return (s ? t : '"' + t + '"') + ":" + f(e, n2);
+  }
+  return "[" + f(e, t) + "]:" + f(e, n2);
+}
+function an(e, r, t) {
+  let n2 = t.k, a = n2.length;
+  if (a > 0) {
+    let s = t.v;
+    e.base.stack.push(r.i);
+    let i = Xt(e, r, n2[0], s[0]);
+    for (let u = 1, l = i; u < a; u++) l = Xt(e, r, n2[u], s[u]), i += (l && i && ",") + l;
+    return e.base.stack.pop(), "{" + i + "}";
+  }
+  return "{}";
+}
+function Uo(e, r) {
+  return jr(e, r.o, r.i), an(e, r, r.p);
+}
+function jo(e, r, t, n2) {
+  let a = an(e, r, t);
+  return a !== "{}" ? "Object.assign(" + n2 + "," + a + ")" : n2;
+}
+function Yo(e, r, t, n2, a) {
+  let s = e.base, i = f(e, a), u = Number(n2), l = u >= 0 && u.toString() === n2 || Vr(n2);
+  if (D(s, a)) l && u !== u ? Ur(e, r.i, n2, i) : Ne(e, r.i, l ? n2 : '"' + n2 + '"', i);
+  else {
+    let g = s.assignments;
+    s.assignments = t, l && u !== u ? Ur(e, r.i, n2, i) : Ne(e, r.i, l ? n2 : '"' + n2 + '"', i), s.assignments = g;
+  }
+}
+function qo(e, r, t, n2, a) {
+  if (typeof n2 == "string") Yo(e, r, t, n2, a);
+  else {
+    let s = e.base, i = s.stack;
+    s.stack = [];
+    let u = f(e, a);
+    s.stack = i;
+    let l = s.assignments;
+    s.assignments = t, Ne(e, r.i, f(e, n2), u), s.assignments = l;
+  }
+}
+function Wo(e, r, t) {
+  let n2 = t.k, a = n2.length;
+  if (a > 0) {
+    let s = [], i = t.v;
+    e.base.stack.push(r.i);
+    for (let u = 0; u < a; u++) qo(e, r, s, n2[u], i[u]);
+    return e.base.stack.pop(), tn(s);
+  }
+  return o;
+}
+function qr(e, r, t) {
+  if (r.p) {
+    let n2 = e.base;
+    if (n2.features & 8) t = jo(e, r, r.p, t);
+    else {
+      O(n2, r.i);
+      let a = Wo(e, r, r.p);
+      if (a) return "(" + se(e, r.i, t) + "," + a + m(e, r.i) + ")";
+    }
+  }
+  return t;
+}
+function Go(e, r) {
+  return jr(e, r.o, r.i), qr(e, r, xo);
+}
+function Ko(e) {
+  return 'new Date("' + e.s + '")';
+}
+function Ho(e, r) {
+  if (e.base.features & 32) return "/" + r.c + "/" + r.m;
+  throw new w$1(r);
+}
+function Qt(e, r, t) {
+  let n2 = e.base;
+  return D(n2, t) ? (O(n2, r), Bo(e, r, m(e, t.i)), "") : f(e, t);
+}
+function Jo(e, r) {
+  let t = Oo, n2 = r.a, a = n2.length, s = r.i;
+  if (a > 0) {
+    e.base.stack.push(s);
+    let i = Qt(e, s, n2[0]);
+    for (let u = 1, l = i; u < a; u++) l = Qt(e, s, n2[u]), i += (l && i && ",") + l;
+    e.base.stack.pop(), i && (t += "([" + i + "])");
+  }
+  return t;
+}
+function en(e, r, t, n2, a) {
+  let s = e.base;
+  if (D(s, t)) {
+    let i = m(e, t.i);
+    if (O(s, r), D(s, n2)) {
+      let l = m(e, n2.i);
+      return ge(e, r, i, l), "";
+    }
+    if (n2.t !== 4 && n2.i != null && Lr(s, n2.i)) {
+      let l = "(" + f(e, n2) + ",[" + a + "," + a + "])";
+      return ge(e, r, i, m(e, n2.i)), Zt(e, r, a), l;
+    }
+    let u = s.stack;
+    return s.stack = [], ge(e, r, i, f(e, n2)), s.stack = u, "";
+  }
+  if (D(s, n2)) {
+    let i = m(e, n2.i);
+    if (O(s, r), t.t !== 4 && t.i != null && Lr(s, t.i)) {
+      let l = "(" + f(e, t) + ",[" + a + "," + a + "])";
+      return ge(e, r, m(e, t.i), i), Zt(e, r, a), l;
+    }
+    let u = s.stack;
+    return s.stack = [], ge(e, r, f(e, t), i), s.stack = u, "";
+  }
+  return "[" + f(e, t) + "," + f(e, n2) + "]";
+}
+function Zo(e, r) {
+  let t = To, n2 = r.e.k, a = n2.length, s = r.i, i = r.f, u = m(e, i.i), l = e.base;
+  if (a > 0) {
+    let g = r.e.v;
+    l.stack.push(s);
+    let S = en(e, s, n2[0], g[0], u);
+    for (let d = 1, K = S; d < a; d++) K = en(e, s, n2[d], g[d], u), S += (K && S && ",") + K;
+    l.stack.pop(), S && (t += "([" + S + "])");
+  }
+  return i.t === 26 && (O(l, i.i), t = "(" + f(e, i) + "," + t + ")"), t;
+}
+function $o(e, r) {
+  return W(e, r.f) + '("' + r.s + '")';
+}
+function Xo(e, r) {
+  return "new " + r.c + "(" + f(e, r.f) + "," + r.b + "," + r.l + ")";
+}
+function Qo(e, r) {
+  return "new DataView(" + f(e, r.f) + "," + r.b + "," + r.l + ")";
+}
+function ea(e, r) {
+  let t = r.i;
+  e.base.stack.push(t);
+  let n2 = qr(e, r, 'new AggregateError([],"' + r.m + '")');
+  return e.base.stack.pop(), n2;
+}
+function ra(e, r) {
+  return qr(e, r, "new " + Ce[r.s] + '("' + r.m + '")');
+}
+function ta(e, r) {
+  let t, n2 = r.f, a = r.i, s = r.s ? wo : ho, i = e.base;
+  if (D(i, n2)) {
+    let u = m(e, n2.i);
+    t = s + (r.s ? "().then(" + sr([], u) + ")" : "().catch(" + Wt([], "throw " + u) + ")");
+  } else {
+    i.stack.push(a);
+    let u = f(e, n2);
+    i.stack.pop(), t = s + "(" + u + ")";
+  }
+  return t;
+}
+function na(e, r) {
+  return "Object(" + f(e, r.f) + ")";
+}
+function W(e, r) {
+  let t = f(e, r);
+  return r.t === 4 ? t : "(" + t + ")";
+}
+function oa(e, r) {
+  if (e.mode === 1) throw new w$1(r);
+  return "(" + se(e, r.s, W(e, r.f) + "()") + ").p";
+}
+function aa(e, r) {
+  if (e.mode === 1) throw new w$1(r);
+  return W(e, r.a[0]) + "(" + m(e, r.i) + "," + f(e, r.a[1]) + ")";
+}
+function sa(e, r) {
+  if (e.mode === 1) throw new w$1(r);
+  return W(e, r.a[0]) + "(" + m(e, r.i) + "," + f(e, r.a[1]) + ")";
+}
+function ia(e, r) {
+  let t = e.base.plugins;
+  if (t) for (let n2 = 0, a = t.length; n2 < a; n2++) {
+    let s = t[n2];
+    if (s.tag === r.c) return e.child == null && (e.child = new Mr(e)), s.serialize(r.s, e.child, { id: r.i });
+  }
+  throw new Q(r.c);
+}
+function ua(e, r) {
+  let t = "", n2 = false;
+  return r.f.t !== 4 && (O(e.base, r.f.i), t = "(" + f(e, r.f) + ",", n2 = true), t += se(e, r.i, "(" + Ct + ")(" + m(e, r.f.i) + ")"), n2 && (t += ")"), t;
+}
+function la(e, r) {
+  return W(e, r.a[0]) + "(" + f(e, r.a[1]) + ")";
+}
+function ca(e, r) {
+  let t = r.a[0], n2 = r.a[1], a = e.base, s = "";
+  t.t !== 4 && (O(a, t.i), s += "(" + f(e, t)), n2.t !== 4 && (O(a, n2.i), s += (s ? "," : "(") + f(e, n2)), s && (s += ",");
+  let i = se(e, r.i, "(" + At + ")(" + m(e, n2.i) + "," + m(e, t.i) + ")");
+  return s ? s + i + ")" : i;
+}
+function fa(e, r) {
+  return W(e, r.a[0]) + "(" + f(e, r.a[1]) + ")";
+}
+function Sa(e, r) {
+  let t = se(e, r.i, W(e, r.f) + "()"), n2 = r.a.length;
+  if (n2) {
+    let a = f(e, r.a[0]);
+    for (let s = 1; s < n2; s++) a += "," + f(e, r.a[s]);
+    return "(" + t + "," + a + "," + m(e, r.i) + ")";
+  }
+  return t;
+}
+function ma(e, r) {
+  return m(e, r.i) + ".next(" + f(e, r.f) + ")";
+}
+function pa(e, r) {
+  return m(e, r.i) + ".throw(" + f(e, r.f) + ")";
+}
+function da(e, r) {
+  return m(e, r.i) + ".return(" + f(e, r.f) + ")";
+}
+function rn(e, r, t, n2) {
+  let a = e.base;
+  return D(a, n2) ? (O(a, r), Vo(e, r, t, m(e, n2.i)), "") : f(e, n2);
+}
+function ga(e, r) {
+  let t = r.a, n2 = t.length, a = r.i;
+  if (n2 > 0) {
+    e.base.stack.push(a);
+    let s = rn(e, a, 0, t[0]);
+    for (let i = 1, u = s; i < n2; i++) u = rn(e, a, i, t[i]), s += (u && s && ",") + u;
+    if (e.base.stack.pop(), s) return "{__SEROVAL_SEQUENCE__:!0,v:[" + s + "],t:" + r.s + ",d:" + r.l + "}";
+  }
+  return "{__SEROVAL_SEQUENCE__:!0,v:[],t:-1,d:0}";
+}
+function ya(e, r) {
+  switch (r.t) {
+    case 17:
+      return rt[r.s];
+    case 18:
+      return Mo(r);
+    case 9:
+      return Lo(e, r);
+    case 10:
+      return Uo(e, r);
+    case 11:
+      return Go(e, r);
+    case 5:
+      return Ko(r);
+    case 6:
+      return Ho(e, r);
+    case 7:
+      return Jo(e, r);
+    case 8:
+      return Zo(e, r);
+    case 19:
+      return $o(e, r);
+    case 16:
+    case 15:
+      return Xo(e, r);
+    case 20:
+      return Qo(e, r);
+    case 14:
+      return ea(e, r);
+    case 13:
+      return ra(e, r);
+    case 12:
+      return ta(e, r);
+    case 21:
+      return na(e, r);
+    case 22:
+      return oa(e, r);
+    case 25:
+      return ia(e, r);
+    case 26:
+      return Ot[r.s];
+    case 35:
+      return ga(e, r);
+    default:
+      throw new w$1(r);
+  }
+}
+function f(e, r) {
+  switch (r.t) {
+    case 2:
+      return nt[r.s];
+    case 0:
+      return "" + r.s;
+    case 1:
+      return '"' + r.s + '"';
+    case 3:
+      return r.s + "n";
+    case 4:
+      return m(e, r.i);
+    case 23:
+      return aa(e, r);
+    case 24:
+      return sa(e, r);
+    case 27:
+      return ua(e, r);
+    case 28:
+      return la(e, r);
+    case 29:
+      return ca(e, r);
+    case 30:
+      return fa(e, r);
+    case 31:
+      return Sa(e, r);
+    case 32:
+      return ma(e, r);
+    case 33:
+      return pa(e, r);
+    case 34:
+      return da(e, r);
+    default:
+      return se(e, r.i, ya(e, r));
+  }
+}
+function cr(e, r) {
+  let t = f(e, r), n2 = r.i;
+  if (n2 == null) return t;
+  let a = on(e.base), s = m(e, n2), i = e.state.scopeId, u = i == null ? "" : ce, l = a ? "(" + t + "," + a + s + ")" : t;
+  if (u === "") return r.t === 10 && !a ? "(" + l + ")" : l;
+  let g = i == null ? "()" : "(" + ce + '["' + y(i) + '"])';
+  return "(" + sr([u], l) + ")" + g;
+}
+var Gr = class {
+  constructor(r, t) {
+    this._p = r;
+    this.depth = t;
+  }
+  parse(r) {
+    return E(this._p, this.depth, r);
+  }
+}, Kr = class {
+  constructor(r, t) {
+    this._p = r;
+    this.depth = t;
+  }
+  parse(r) {
+    return E(this._p, this.depth, r);
+  }
+  parseWithError(r) {
+    return G(this._p, this.depth, r);
+  }
+  isAlive() {
+    return this._p.state.alive;
+  }
+  pushPendingState() {
+    Xr(this._p);
+  }
+  popPendingState() {
+    be(this._p);
+  }
+  onParse(r) {
+    ie(this._p, r);
+  }
+  onError(r) {
+    Zr(this._p, r);
+  }
+};
+function Na(e) {
+  return { alive: true, pending: 0, initial: true, buffer: [], onParse: e.onParse, onError: e.onError, onDone: e.onDone };
+}
+function Hr(e) {
+  return { type: 2, base: pe(2, e), state: Na(e) };
+}
+function ba(e, r, t) {
+  let n2 = [];
+  for (let a = 0, s = t.length; a < s; a++) a in t ? n2[a] = E(e, r, t[a]) : n2[a] = 0;
+  return n2;
+}
+function va(e, r, t, n2) {
+  return _e(t, n2, ba(e, r, n2));
+}
+function Jr(e, r, t) {
+  let n2 = Object.entries(t), a = [], s = [];
+  for (let i = 0, u = n2.length; i < u; i++) a.push(y(n2[i][0])), s.push(E(e, r, n2[i][1]));
+  return C in t && (a.push(I(e.base, C)), s.push(Ue(er(e.base), E(e, r, $e(t))))), v in t && (a.push(I(e.base, v)), s.push(je(rr(e.base), E(e, r, e.type === 1 ? te() : Xe(t))))), P$1 in t && (a.push(I(e.base, P$1)), s.push(X(t[P$1]))), R in t && (a.push(I(e.base, R)), s.push(t[R] ? J : Z)), { k: a, v: s };
+}
+function Wr(e, r, t, n2, a) {
+  return tr(t, n2, a, Jr(e, r, n2));
+}
+function Ca(e, r, t, n2) {
+  return ke(t, E(e, r, n2.valueOf()));
+}
+function Aa(e, r, t, n2) {
+  return De(t, n2, E(e, r, n2.buffer));
+}
+function Ea(e, r, t, n2) {
+  return Fe(t, n2, E(e, r, n2.buffer));
+}
+function Ia(e, r, t, n2) {
+  return Be(t, n2, E(e, r, n2.buffer));
+}
+function sn(e, r, t, n2) {
+  let a = $(n2, e.base.features);
+  return Ve(t, n2, a ? Jr(e, r, a) : o);
+}
+function Ra(e, r, t, n2) {
+  let a = $(n2, e.base.features);
+  return Me(t, n2, a ? Jr(e, r, a) : o);
+}
+function Pa(e, r, t, n2) {
+  let a = [], s = [];
+  for (let [i, u] of n2.entries()) a.push(E(e, r, i)), s.push(E(e, r, u));
+  return nr(e.base, t, a, s);
+}
+function xa(e, r, t, n2) {
+  let a = [];
+  for (let s of n2.keys()) a.push(E(e, r, s));
+  return Le(t, a);
+}
+function Oa(e, r, t, n2) {
+  let a = Ye(t, k(e.base, 4), []);
+  return e.type === 1 || (Xr(e), n2.on({ next: (s) => {
+    if (e.state.alive) {
+      let i = G(e, r, s);
+      i && ie(e, qe(t, i));
+    }
+  }, throw: (s) => {
+    if (e.state.alive) {
+      let i = G(e, r, s);
+      i && ie(e, We(t, i));
+    }
+    be(e);
+  }, return: (s) => {
+    if (e.state.alive) {
+      let i = G(e, r, s);
+      i && ie(e, Ge(t, i));
+    }
+    be(e);
+  } })), a;
+}
+function Ta(e, r, t) {
+  if (this.state.alive) {
+    let n2 = G(this, r, t);
+    n2 && ie(this, c(23, e, o, o, o, o, o, [k(this.base, 2), n2], o, o, o, o)), be(this);
+  }
+}
+function wa(e, r, t) {
+  if (this.state.alive) {
+    let n2 = G(this, r, t);
+    n2 && ie(this, c(24, e, o, o, o, o, o, [k(this.base, 3), n2], o, o, o, o));
+  }
+  be(this);
+}
+function ha(e, r, t, n2) {
+  let a = hr(e.base, {});
+  return e.type === 2 && (Xr(e), n2.then(Ta.bind(e, a, r), wa.bind(e, a, r))), ht(e.base, t, a);
+}
+function za(e, r, t, n2, a) {
+  for (let s = 0, i = a.length; s < i; s++) {
+    let u = a[s];
+    if (u.parse.sync && u.test(n2)) return fe(t, u.tag, u.parse.sync(n2, new Gr(e, r), { id: t }));
+  }
+  return o;
+}
+function _a(e, r, t, n2, a) {
+  for (let s = 0, i = a.length; s < i; s++) {
+    let u = a[s];
+    if (u.parse.stream && u.test(n2)) return fe(t, u.tag, u.parse.stream(n2, new Kr(e, r), { id: t }));
+  }
+  return o;
+}
+function un(e, r, t, n2) {
+  let a = e.base.plugins;
+  return a ? e.type === 1 ? za(e, r, t, n2, a) : _a(e, r, t, n2, a) : o;
+}
+function ka(e, r, t, n2) {
+  let a = [];
+  for (let s = 0, i = n2.v.length; s < i; s++) a[s] = E(e, r, n2.v[s]);
+  return Ke(t, a, n2.t, n2.d);
+}
+function Da(e, r, t, n2, a) {
+  switch (a) {
+    case Object:
+      return Wr(e, r, t, n2, false);
+    case o:
+      return Wr(e, r, t, n2, true);
+    case Date:
+      return he(t, n2);
+    case Error:
+    case EvalError:
+    case RangeError:
+    case ReferenceError:
+    case SyntaxError:
+    case TypeError:
+    case URIError:
+      return sn(e, r, t, n2);
+    case Number:
+    case Boolean:
+    case String:
+    case BigInt:
+      return Ca(e, r, t, n2);
+    case ArrayBuffer:
+      return or(e.base, t, n2);
+    case Int8Array:
+    case Int16Array:
+    case Int32Array:
+    case Uint8Array:
+    case Uint16Array:
+    case Uint32Array:
+    case Uint8ClampedArray:
+    case Float32Array:
+    case Float64Array:
+      return Aa(e, r, t, n2);
+    case DataView:
+      return Ia(e, r, t, n2);
+    case Map:
+      return Pa(e, r, t, n2);
+    case Set:
+      return xa(e, r, t, n2);
+  }
+  if (a === Promise || n2 instanceof Promise) return ha(e, r, t, n2);
+  let s = e.base.features;
+  if (s & 32 && a === RegExp) return ze(t, n2);
+  if (s & 16) switch (a) {
+    case BigInt64Array:
+    case BigUint64Array:
+      return Ea(e, r, t, n2);
+  }
+  if (s & 1 && typeof AggregateError != "undefined" && (a === AggregateError || n2 instanceof AggregateError)) return Ra(e, r, t, n2);
+  if (n2 instanceof Error) return sn(e, r, t, n2);
+  if (C in n2 || v in n2) return Wr(e, r, t, n2, !!a);
+  throw new x$1(n2);
+}
+function Fa(e, r, t, n2) {
+  if (Array.isArray(n2)) return va(e, r, t, n2);
+  if (M(n2)) return Oa(e, r, t, n2);
+  if (Ze(n2)) return ka(e, r, t, n2);
+  let a = n2.constructor;
+  if (a === Y) return E(e, r, n2.replacement);
+  let s = un(e, r, t, n2);
+  return s || Da(e, r, t, n2, a);
+}
+function Ba(e, r, t) {
+  let n2 = q(e.base, t);
+  if (n2.type !== 0) return n2.value;
+  let a = un(e, r, n2.value, t);
+  if (a) return a;
+  throw new x$1(t);
+}
+function E(e, r, t) {
+  if (r >= e.base.depthLimit) throw new ee$1(e.base.depthLimit);
+  switch (typeof t) {
+    case "boolean":
+      return t ? J : Z;
+    case "undefined":
+      return Ae;
+    case "string":
+      return X(t);
+    case "number":
+      return Te(t);
+    case "bigint":
+      return we(t);
+    case "object": {
+      if (t) {
+        let n2 = q(e.base, t);
+        return n2.type === 0 ? Fa(e, r + 1, n2.value, t) : n2.value;
+      }
+      return Ee;
+    }
+    case "symbol":
+      return I(e.base, t);
+    case "function":
+      return Ba(e, r, t);
+    default:
+      throw new x$1(t);
+  }
+}
+function ie(e, r) {
+  e.state.initial ? e.state.buffer.push(r) : $r(e, r, false);
+}
+function Zr(e, r) {
+  if (e.state.onError) e.state.onError(r);
+  else throw r instanceof z ? r : new z(r);
+}
+function ln(e) {
+  e.state.onDone && e.state.onDone();
+}
+function $r(e, r, t) {
+  try {
+    e.state.onParse(r, t);
+  } catch (n2) {
+    Zr(e, n2);
+  }
+}
+function Xr(e) {
+  e.state.pending++;
+}
+function be(e) {
+  --e.state.pending <= 0 && ln(e);
+}
+function G(e, r, t) {
+  try {
+    return E(e, r, t);
+  } catch (n2) {
+    return Zr(e, n2), o;
+  }
+}
+function Qr(e, r) {
+  let t = G(e, 0, r);
+  t && ($r(e, t, true), e.state.initial = false, Va(e, e.state), e.state.pending <= 0 && fr(e));
+}
+function Va(e, r) {
+  for (let t = 0, n2 = r.buffer.length; t < n2; t++) $r(e, r.buffer[t], false);
+}
+function fr(e) {
+  e.state.alive && (ln(e), e.state.alive = false);
+}
+async function ou(e, r = {}) {
+  let t = A(r.plugins), n2 = ne(2, { plugins: t, disabledFeatures: r.disabledFeatures, refs: r.refs });
+  return await oe(n2, e);
+}
+function cn(e, r) {
+  let t = A(r.plugins), n2 = Hr({ plugins: t, refs: r.refs, disabledFeatures: r.disabledFeatures, onParse(a, s) {
+    let i = ur({ plugins: t, features: n2.base.features, scopeId: r.scopeId, markedRefs: n2.base.marked }), u;
+    try {
+      u = cr(i, a);
+    } catch (l) {
+      r.onError && r.onError(l);
+      return;
+    }
+    r.onSerialize(u, s);
+  }, onError: r.onError, onDone: r.onDone });
+  return Qr(n2, e), fr.bind(null, n2);
+}
+function au(e, r) {
+  let t = A(r.plugins), n2 = Hr({ plugins: t, refs: r.refs, disabledFeatures: r.disabledFeatures, onParse: r.onParse, onError: r.onError, onDone: r.onDone });
+  return Qr(n2, e), fr.bind(null, n2);
+}
+function Iu(e, r = {}) {
+  var i;
+  let t = A(r.plugins), n2 = r.disabledFeatures || 0, a = (i = e.f) != null ? i : 63, s = Mt({ plugins: t, markedRefs: e.m, features: a & ~n2, disabledFeatures: n2 });
+  return ar(s, e.t);
+}
+const GLOBAL_TSR = "$_TSR";
+const TSR_SCRIPT_BARRIER_ID = "$tsr-stream-barrier";
+function createSerializationAdapter(opts) {
+  return opts;
+}
+function makeSsrSerovalPlugin(serializationAdapter, options) {
+  return ni({
+    tag: "$TSR/t/" + serializationAdapter.key,
+    test: serializationAdapter.test,
+    parse: {
+      stream(value, ctx) {
+        return ctx.parse(serializationAdapter.toSerializable(value));
+      }
+    },
+    serialize(node, ctx) {
+      options.didRun = true;
+      return GLOBAL_TSR + '.t.get("' + serializationAdapter.key + '")(' + ctx.serialize(node) + ")";
+    },
+    // we never deserialize on the server during SSR
+    deserialize: void 0
+  });
+}
+function makeSerovalPlugin(serializationAdapter) {
+  return ni({
+    tag: "$TSR/t/" + serializationAdapter.key,
+    test: serializationAdapter.test,
+    parse: {
+      sync(value, ctx) {
+        return ctx.parse(serializationAdapter.toSerializable(value));
+      },
+      async async(value, ctx) {
+        return await ctx.parse(serializationAdapter.toSerializable(value));
+      },
+      stream(value, ctx) {
+        return ctx.parse(serializationAdapter.toSerializable(value));
+      }
+    },
+    // we don't generate JS code outside of SSR (for now)
+    serialize: void 0,
+    deserialize(node, ctx) {
+      return serializationAdapter.fromSerializable(ctx.deserialize(node));
+    }
+  });
+}
+var n = {}, P = (e) => new ReadableStream({ start: (r) => {
+  e.on({ next: (a) => {
+    try {
+      r.enqueue(a);
+    } catch (t) {
+    }
+  }, throw: (a) => {
+    r.error(a);
+  }, return: () => {
+    try {
+      r.close();
+    } catch (a) {
+    }
+  } });
+} }), x2 = ni({ tag: "seroval-plugins/web/ReadableStreamFactory", test(e) {
+  return e === n;
+}, parse: { sync() {
+  return n;
+}, async async() {
+  return await Promise.resolve(n);
+}, stream() {
+  return n;
+} }, serialize() {
+  return P.toString();
+}, deserialize() {
+  return n;
+} });
+function w2(e) {
+  let r = te(), a = e.getReader();
+  async function t() {
+    try {
+      let s = await a.read();
+      s.done ? r.return(s.value) : (r.next(s.value), await t());
+    } catch (s) {
+      r.throw(s);
+    }
+  }
+  return t().catch(() => {
+  }), r;
+}
+var ee2 = ni({ tag: "seroval/plugins/web/ReadableStream", extends: [x2], test(e) {
+  return typeof ReadableStream == "undefined" ? false : e instanceof ReadableStream;
+}, parse: { sync(e, r) {
+  return { factory: r.parse(n), stream: r.parse(te()) };
+}, async async(e, r) {
+  return { factory: await r.parse(n), stream: await r.parse(w2(e)) };
+}, stream(e, r) {
+  return { factory: r.parse(n), stream: r.parse(w2(e)) };
+} }, serialize(e, r) {
+  return "(" + r.serialize(e.factory) + ")(" + r.serialize(e.stream) + ")";
+}, deserialize(e, r) {
+  let a = r.deserialize(e.stream);
+  return P(a);
+} }), p = ee2;
+const ShallowErrorPlugin = /* @__PURE__ */ ni({
+  tag: "$TSR/Error",
+  test(value) {
+    return value instanceof Error;
+  },
+  parse: {
+    sync(value, ctx) {
+      return {
+        message: ctx.parse(value.message)
+      };
+    },
+    async async(value, ctx) {
+      return {
+        message: await ctx.parse(value.message)
+      };
+    },
+    stream(value, ctx) {
+      return {
+        message: ctx.parse(value.message)
+      };
+    }
+  },
+  serialize(node, ctx) {
+    return "new Error(" + ctx.serialize(node.message) + ")";
+  },
+  deserialize(node, ctx) {
+    return new Error(ctx.deserialize(node.message));
+  }
+});
+class RawStream {
+  constructor(stream, options) {
+    this.stream = stream;
+    this.hint = options?.hint ?? "binary";
+  }
+}
+const BufferCtor = globalThis.Buffer;
+const hasNodeBuffer = !!BufferCtor && typeof BufferCtor.from === "function";
+function uint8ArrayToBase64(bytes) {
+  if (bytes.length === 0) return "";
+  if (hasNodeBuffer) {
+    return BufferCtor.from(bytes).toString("base64");
+  }
+  const CHUNK_SIZE = 32768;
+  const chunks = [];
+  for (let i = 0; i < bytes.length; i += CHUNK_SIZE) {
+    const chunk = bytes.subarray(i, i + CHUNK_SIZE);
+    chunks.push(String.fromCharCode.apply(null, chunk));
+  }
+  return btoa(chunks.join(""));
+}
+function base64ToUint8Array(base64) {
+  if (base64.length === 0) return new Uint8Array(0);
+  if (hasNodeBuffer) {
+    const buf = BufferCtor.from(base64, "base64");
+    return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+  }
+  const binary = atob(base64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+const RAW_STREAM_FACTORY_BINARY = /* @__PURE__ */ Object.create(null);
+const RAW_STREAM_FACTORY_TEXT = /* @__PURE__ */ Object.create(null);
+const RAW_STREAM_FACTORY_CONSTRUCTOR_BINARY = (stream) => new ReadableStream({
+  start(controller) {
+    stream.on({
+      next(base64) {
+        try {
+          controller.enqueue(base64ToUint8Array(base64));
+        } catch {
+        }
+      },
+      throw(error) {
+        controller.error(error);
+      },
+      return() {
+        try {
+          controller.close();
+        } catch {
+        }
+      }
+    });
+  }
+});
+const textEncoderForFactory = new TextEncoder();
+const RAW_STREAM_FACTORY_CONSTRUCTOR_TEXT = (stream) => {
+  return new ReadableStream({
+    start(controller) {
+      stream.on({
+        next(value) {
+          try {
+            if (typeof value === "string") {
+              controller.enqueue(textEncoderForFactory.encode(value));
+            } else {
+              controller.enqueue(base64ToUint8Array(value.$b64));
+            }
+          } catch {
+          }
+        },
+        throw(error) {
+          controller.error(error);
+        },
+        return() {
+          try {
+            controller.close();
+          } catch {
+          }
+        }
+      });
+    }
+  });
+};
+const FACTORY_BINARY = `(s=>new ReadableStream({start(c){s.on({next(b){try{const d=atob(b),a=new Uint8Array(d.length);for(let i=0;i<d.length;i++)a[i]=d.charCodeAt(i);c.enqueue(a)}catch(_){}},throw(e){c.error(e)},return(){try{c.close()}catch(_){}}})}}))`;
+const FACTORY_TEXT = `(s=>{const e=new TextEncoder();return new ReadableStream({start(c){s.on({next(v){try{if(typeof v==='string'){c.enqueue(e.encode(v))}else{const d=atob(v.$b64),a=new Uint8Array(d.length);for(let i=0;i<d.length;i++)a[i]=d.charCodeAt(i);c.enqueue(a)}}catch(_){}},throw(x){c.error(x)},return(){try{c.close()}catch(_){}}})}})})`;
+function toBinaryStream(readable) {
+  const stream = te();
+  const reader = readable.getReader();
+  (async () => {
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+          stream.return(void 0);
+          break;
+        }
+        stream.next(uint8ArrayToBase64(value));
+      }
+    } catch (error) {
+      stream.throw(error);
+    } finally {
+      reader.releaseLock();
+    }
+  })();
+  return stream;
+}
+function toTextStream(readable) {
+  const stream = te();
+  const reader = readable.getReader();
+  const decoder = new TextDecoder("utf-8", { fatal: true });
+  (async () => {
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+          try {
+            const remaining = decoder.decode();
+            if (remaining.length > 0) {
+              stream.next(remaining);
+            }
+          } catch {
+          }
+          stream.return(void 0);
+          break;
+        }
+        try {
+          const text = decoder.decode(value, { stream: true });
+          if (text.length > 0) {
+            stream.next(text);
+          }
+        } catch {
+          stream.next({ $b64: uint8ArrayToBase64(value) });
+        }
+      }
+    } catch (error) {
+      stream.throw(error);
+    } finally {
+      reader.releaseLock();
+    }
+  })();
+  return stream;
+}
+const RawStreamFactoryBinaryPlugin = ni({
+  tag: "tss/RawStreamFactory",
+  test(value) {
+    return value === RAW_STREAM_FACTORY_BINARY;
+  },
+  parse: {
+    sync() {
+      return void 0;
+    },
+    async() {
+      return Promise.resolve(void 0);
+    },
+    stream() {
+      return void 0;
+    }
+  },
+  serialize() {
+    return FACTORY_BINARY;
+  },
+  deserialize() {
+    return RAW_STREAM_FACTORY_BINARY;
+  }
+});
+const RawStreamFactoryTextPlugin = ni({
+  tag: "tss/RawStreamFactoryText",
+  test(value) {
+    return value === RAW_STREAM_FACTORY_TEXT;
+  },
+  parse: {
+    sync() {
+      return void 0;
+    },
+    async() {
+      return Promise.resolve(void 0);
+    },
+    stream() {
+      return void 0;
+    }
+  },
+  serialize() {
+    return FACTORY_TEXT;
+  },
+  deserialize() {
+    return RAW_STREAM_FACTORY_TEXT;
+  }
+});
+const RawStreamSSRPlugin = ni({
+  tag: "tss/RawStream",
+  extends: [RawStreamFactoryBinaryPlugin, RawStreamFactoryTextPlugin],
+  test(value) {
+    return value instanceof RawStream;
+  },
+  parse: {
+    sync(value, ctx) {
+      const factory = value.hint === "text" ? RAW_STREAM_FACTORY_TEXT : RAW_STREAM_FACTORY_BINARY;
+      return {
+        hint: value.hint,
+        factory: ctx.parse(factory),
+        stream: ctx.parse(te())
+      };
+    },
+    async async(value, ctx) {
+      const factory = value.hint === "text" ? RAW_STREAM_FACTORY_TEXT : RAW_STREAM_FACTORY_BINARY;
+      const encodedStream = value.hint === "text" ? toTextStream(value.stream) : toBinaryStream(value.stream);
+      return {
+        hint: value.hint,
+        factory: await ctx.parse(factory),
+        stream: await ctx.parse(encodedStream)
+      };
+    },
+    stream(value, ctx) {
+      const factory = value.hint === "text" ? RAW_STREAM_FACTORY_TEXT : RAW_STREAM_FACTORY_BINARY;
+      const encodedStream = value.hint === "text" ? toTextStream(value.stream) : toBinaryStream(value.stream);
+      return {
+        hint: value.hint,
+        factory: ctx.parse(factory),
+        stream: ctx.parse(encodedStream)
+      };
+    }
+  },
+  serialize(node, ctx) {
+    return "(" + ctx.serialize(node.factory) + ")(" + ctx.serialize(node.stream) + ")";
+  },
+  deserialize(node, ctx) {
+    const stream = ctx.deserialize(node.stream);
+    return node.hint === "text" ? RAW_STREAM_FACTORY_CONSTRUCTOR_TEXT(stream) : RAW_STREAM_FACTORY_CONSTRUCTOR_BINARY(stream);
+  }
+});
+function createRawStreamRPCPlugin(onRawStream) {
+  let nextStreamId = 1;
+  return ni({
+    tag: "tss/RawStream",
+    test(value) {
+      return value instanceof RawStream;
+    },
+    parse: {
+      async(value) {
+        const streamId = nextStreamId++;
+        onRawStream(streamId, value.stream);
+        return Promise.resolve({ streamId });
+      },
+      stream(value) {
+        const streamId = nextStreamId++;
+        onRawStream(streamId, value.stream);
+        return { streamId };
+      }
+    },
+    serialize() {
+      throw new Error(
+        "RawStreamRPCPlugin.serialize should not be called. RPC uses JSON serialization, not JS code generation."
+      );
+    },
+    deserialize() {
+      throw new Error(
+        "RawStreamRPCPlugin.deserialize should not be called. Use createRawStreamDeserializePlugin on client."
+      );
+    }
+  });
+}
+const defaultSerovalPlugins = [
+  ShallowErrorPlugin,
+  // RawStreamSSRPlugin must come before ReadableStreamPlugin to match first
+  RawStreamSSRPlugin,
+  // ReadableStreamNode is not exported by seroval
+  p
+];
 const TSS_FORMDATA_CONTEXT = "__TSS_CONTEXT";
 const TSS_SERVER_FUNCTION = /* @__PURE__ */ Symbol.for("TSS_SERVER_FUNCTION");
 const TSS_SERVER_FUNCTION_FACTORY = /* @__PURE__ */ Symbol.for(
@@ -63,8 +2671,8 @@ if (!globalObj$1[GLOBAL_STORAGE_KEY]) {
   globalObj$1[GLOBAL_STORAGE_KEY] = new AsyncLocalStorage();
 }
 const startStorage = globalObj$1[GLOBAL_STORAGE_KEY];
-async function runWithStartContext(context, fn) {
-  return startStorage.run(context, fn);
+async function runWithStartContext(context, fn2) {
+  return startStorage.run(context, fn2);
 }
 function getStartContext(opts) {
   const context = startStorage.getStore();
@@ -111,13 +2719,13 @@ const createServerFn = (options, __opts) => {
     options: resolvedOptions,
     middleware: (middleware) => {
       const newMiddleware = [...resolvedOptions.middleware || []];
-      middleware.map((m) => {
-        if (TSS_SERVER_FUNCTION_FACTORY in m) {
-          if (m.options.middleware) {
-            newMiddleware.push(...m.options.middleware);
+      middleware.map((m2) => {
+        if (TSS_SERVER_FUNCTION_FACTORY in m2) {
+          if (m2.options.middleware) {
+            newMiddleware.push(...m2.options.middleware);
           }
         } else {
-          newMiddleware.push(m);
+          newMiddleware.push(m2);
         }
       });
       const newOptions = {
@@ -150,9 +2758,9 @@ const createServerFn = (options, __opts) => {
             fetch: opts?.fetch,
             context: createNullProtoObject()
           });
-          const redirect = parseRedirect(result.error);
-          if (redirect) {
-            throw redirect;
+          const redirect2 = parseRedirect(result.error);
+          if (redirect2) {
+            throw redirect2;
           }
           if (result.error) throw result.error;
           return result.result;
@@ -215,7 +2823,7 @@ async function executeMiddleware$1(middlewares, env, opts) {
     const startContext = getStartContextServerOnly({ throwIfNotFound: false });
     if (startContext?.executedRequestMiddlewares) {
       flattenedMiddlewares = flattenedMiddlewares.filter(
-        (m) => !startContext.executedRequestMiddlewares.has(m)
+        (m2) => !startContext.executedRequestMiddlewares.has(m2)
       );
     }
   }
@@ -306,13 +2914,13 @@ function flattenMiddlewares(middlewares, maxDepth = 100) {
         `Middleware nesting depth exceeded maximum of ${maxDepth}. Check for circular references.`
       );
     }
-    middleware.forEach((m) => {
-      if (m.options.middleware) {
-        recurse(m.options.middleware, depth + 1);
+    middleware.forEach((m2) => {
+      if (m2.options.middleware) {
+        recurse(m2.options.middleware, depth + 1);
       }
-      if (!seen.has(m)) {
-        seen.add(m);
-        flattened.push(m);
+      if (!seen.has(m2)) {
+        seen.add(m2);
+        flattened.push(m2);
       }
     });
   };
@@ -368,6 +2976,795 @@ function getDefaultSerovalPlugins() {
     ...defaultSerovalPlugins
   ];
 }
+const minifiedTsrBootStrapScript = "self.$_TSR={h(){this.hydrated=!0,this.c()},e(){this.streamEnded=!0,this.c()},c(){this.hydrated&&this.streamEnded&&(delete self.$_TSR,delete self.$R.tsr)},p(e){this.initialized?e():this.buffer.push(e)},buffer:[]};\n";
+const SCOPE_ID = "tsr";
+const TSR_PREFIX = GLOBAL_TSR + ".router=";
+const P_PREFIX = GLOBAL_TSR + ".p(()=>";
+const P_SUFFIX = ")";
+function dehydrateMatch(match) {
+  const dehydratedMatch = {
+    i: match.id,
+    u: match.updatedAt,
+    s: match.status
+  };
+  const properties = [
+    ["__beforeLoadContext", "b"],
+    ["loaderData", "l"],
+    ["error", "e"],
+    ["ssr", "ssr"]
+  ];
+  for (const [key, shorthand] of properties) {
+    if (match[key] !== void 0) {
+      dehydratedMatch[shorthand] = match[key];
+    }
+  }
+  return dehydratedMatch;
+}
+const INITIAL_SCRIPTS = [
+  mn(SCOPE_ID),
+  minifiedTsrBootStrapScript
+];
+class ScriptBuffer {
+  constructor(router) {
+    this._scriptBarrierLifted = false;
+    this._cleanedUp = false;
+    this._pendingMicrotask = false;
+    this.router = router;
+    this._queue = INITIAL_SCRIPTS.slice();
+  }
+  enqueue(script) {
+    if (this._cleanedUp) return;
+    this._queue.push(script);
+    if (this._scriptBarrierLifted && !this._pendingMicrotask) {
+      this._pendingMicrotask = true;
+      queueMicrotask(() => {
+        this._pendingMicrotask = false;
+        this.injectBufferedScripts();
+      });
+    }
+  }
+  liftBarrier() {
+    if (this._scriptBarrierLifted || this._cleanedUp) return;
+    this._scriptBarrierLifted = true;
+    if (this._queue.length > 0 && !this._pendingMicrotask) {
+      this._pendingMicrotask = true;
+      queueMicrotask(() => {
+        this._pendingMicrotask = false;
+        this.injectBufferedScripts();
+      });
+    }
+  }
+  /**
+   * Flushes any pending scripts synchronously.
+   * Call this before emitting onSerializationFinished to ensure all scripts are injected.
+   *
+   * IMPORTANT: Only injects if the barrier has been lifted. Before the barrier is lifted,
+   * scripts should remain in the queue so takeBufferedScripts() can retrieve them
+   */
+  flush() {
+    if (!this._scriptBarrierLifted) return;
+    if (this._cleanedUp) return;
+    this._pendingMicrotask = false;
+    const scriptsToInject = this.takeAll();
+    if (scriptsToInject && this.router?.serverSsr) {
+      this.router.serverSsr.injectScript(scriptsToInject);
+    }
+  }
+  takeAll() {
+    const bufferedScripts = this._queue;
+    this._queue = [];
+    if (bufferedScripts.length === 0) {
+      return void 0;
+    }
+    if (bufferedScripts.length === 1) {
+      return bufferedScripts[0] + ";document.currentScript.remove()";
+    }
+    return bufferedScripts.join(";") + ";document.currentScript.remove()";
+  }
+  injectBufferedScripts() {
+    if (this._cleanedUp) return;
+    if (this._queue.length === 0) return;
+    const scriptsToInject = this.takeAll();
+    if (scriptsToInject && this.router?.serverSsr) {
+      this.router.serverSsr.injectScript(scriptsToInject);
+    }
+  }
+  cleanup() {
+    this._cleanedUp = true;
+    this._queue = [];
+    this.router = void 0;
+  }
+}
+const MANIFEST_CACHE_SIZE = 100;
+const manifestCaches = /* @__PURE__ */ new WeakMap();
+function getManifestCache(manifest2) {
+  const cache = manifestCaches.get(manifest2);
+  if (cache) return cache;
+  const newCache = createLRUCache(MANIFEST_CACHE_SIZE);
+  manifestCaches.set(manifest2, newCache);
+  return newCache;
+}
+function attachRouterServerSsrUtils({
+  router,
+  manifest: manifest2
+}) {
+  router.ssr = {
+    manifest: manifest2
+  };
+  let _dehydrated = false;
+  let _serializationFinished = false;
+  const renderFinishedListeners = [];
+  const serializationFinishedListeners = [];
+  const scriptBuffer = new ScriptBuffer(router);
+  let injectedHtmlBuffer = "";
+  router.serverSsr = {
+    injectHtml: (html) => {
+      if (!html) return;
+      injectedHtmlBuffer += html;
+      router.emit({
+        type: "onInjectedHtml"
+      });
+    },
+    injectScript: (script) => {
+      if (!script) return;
+      const html = `<script${router.options.ssr?.nonce ? ` nonce='${router.options.ssr.nonce}'` : ""}>${script}<\/script>`;
+      router.serverSsr.injectHtml(html);
+    },
+    dehydrate: async () => {
+      invariant(!_dehydrated);
+      let matchesToDehydrate = router.state.matches;
+      if (router.isShell()) {
+        matchesToDehydrate = matchesToDehydrate.slice(0, 1);
+      }
+      const matches = matchesToDehydrate.map(dehydrateMatch);
+      let manifestToDehydrate = void 0;
+      if (manifest2) {
+        const currentRouteIdsList = matchesToDehydrate.map((m2) => m2.routeId);
+        const manifestCacheKey = currentRouteIdsList.join("\0");
+        let filteredRoutes;
+        {
+          filteredRoutes = getManifestCache(manifest2).get(manifestCacheKey);
+        }
+        if (!filteredRoutes) {
+          const currentRouteIds = new Set(currentRouteIdsList);
+          const nextFilteredRoutes = {};
+          for (const routeId in manifest2.routes) {
+            const routeManifest = manifest2.routes[routeId];
+            if (currentRouteIds.has(routeId)) {
+              nextFilteredRoutes[routeId] = routeManifest;
+            } else if (routeManifest.assets && routeManifest.assets.length > 0) {
+              nextFilteredRoutes[routeId] = {
+                assets: routeManifest.assets
+              };
+            }
+          }
+          {
+            getManifestCache(manifest2).set(manifestCacheKey, nextFilteredRoutes);
+          }
+          filteredRoutes = nextFilteredRoutes;
+        }
+        manifestToDehydrate = {
+          routes: filteredRoutes
+        };
+      }
+      const dehydratedRouter = {
+        manifest: manifestToDehydrate,
+        matches
+      };
+      const lastMatchId = matchesToDehydrate[matchesToDehydrate.length - 1]?.id;
+      if (lastMatchId) {
+        dehydratedRouter.lastMatchId = lastMatchId;
+      }
+      const dehydratedData = await router.options.dehydrate?.();
+      if (dehydratedData) {
+        dehydratedRouter.dehydratedData = dehydratedData;
+      }
+      _dehydrated = true;
+      const trackPlugins = { didRun: false };
+      const serializationAdapters = router.options.serializationAdapters;
+      const plugins = serializationAdapters ? serializationAdapters.map((t) => makeSsrSerovalPlugin(t, trackPlugins)).concat(defaultSerovalPlugins) : defaultSerovalPlugins;
+      const signalSerializationComplete = () => {
+        _serializationFinished = true;
+        try {
+          serializationFinishedListeners.forEach((l) => l());
+          router.emit({ type: "onSerializationFinished" });
+        } catch (err) {
+          console.error("Serialization listener error:", err);
+        } finally {
+          serializationFinishedListeners.length = 0;
+          renderFinishedListeners.length = 0;
+        }
+      };
+      cn(dehydratedRouter, {
+        refs: /* @__PURE__ */ new Map(),
+        plugins,
+        onSerialize: (data, initial) => {
+          let serialized = initial ? TSR_PREFIX + data : data;
+          if (trackPlugins.didRun) {
+            serialized = P_PREFIX + serialized + P_SUFFIX;
+          }
+          scriptBuffer.enqueue(serialized);
+        },
+        scopeId: SCOPE_ID,
+        onDone: () => {
+          scriptBuffer.enqueue(GLOBAL_TSR + ".e()");
+          scriptBuffer.flush();
+          signalSerializationComplete();
+        },
+        onError: (err) => {
+          console.error("Serialization error:", err);
+          signalSerializationComplete();
+        }
+      });
+    },
+    isDehydrated() {
+      return _dehydrated;
+    },
+    isSerializationFinished() {
+      return _serializationFinished;
+    },
+    onRenderFinished: (listener) => renderFinishedListeners.push(listener),
+    onSerializationFinished: (listener) => serializationFinishedListeners.push(listener),
+    setRenderFinished: () => {
+      try {
+        renderFinishedListeners.forEach((l) => l());
+      } catch (err) {
+        console.error("Error in render finished listener:", err);
+      } finally {
+        renderFinishedListeners.length = 0;
+      }
+      scriptBuffer.liftBarrier();
+    },
+    takeBufferedScripts() {
+      const scripts = scriptBuffer.takeAll();
+      const serverBufferedScript = {
+        tag: "script",
+        attrs: {
+          nonce: router.options.ssr?.nonce,
+          className: "$tsr",
+          id: TSR_SCRIPT_BARRIER_ID
+        },
+        children: scripts
+      };
+      return serverBufferedScript;
+    },
+    liftScriptBarrier() {
+      scriptBuffer.liftBarrier();
+    },
+    takeBufferedHtml() {
+      if (!injectedHtmlBuffer) {
+        return void 0;
+      }
+      const buffered = injectedHtmlBuffer;
+      injectedHtmlBuffer = "";
+      return buffered;
+    },
+    cleanup() {
+      if (!router.serverSsr) return;
+      renderFinishedListeners.length = 0;
+      serializationFinishedListeners.length = 0;
+      injectedHtmlBuffer = "";
+      scriptBuffer.cleanup();
+      router.serverSsr = void 0;
+    }
+  };
+}
+function getOrigin(request) {
+  try {
+    return new URL(request.url).origin;
+  } catch {
+  }
+  return "http://localhost";
+}
+function getNormalizedURL(url, base) {
+  if (typeof url === "string") url = url.replace("\\", "%5C");
+  const rawUrl = new URL(url, base);
+  const decodedPathname = decodePath(rawUrl.pathname);
+  const searchParams = new URLSearchParams(rawUrl.search);
+  const normalizedHref = decodedPathname + (searchParams.size > 0 ? "?" : "") + searchParams.toString() + rawUrl.hash;
+  return new URL(normalizedHref, rawUrl.origin);
+}
+const NullProtoObj = /* @__PURE__ */ (() => {
+  const e = function() {
+  };
+  return e.prototype = /* @__PURE__ */ Object.create(null), Object.freeze(e.prototype), e;
+})();
+function lazyInherit(target, source, sourceKey) {
+  for (const key of [...Object.getOwnPropertyNames(source), ...Object.getOwnPropertySymbols(source)]) {
+    if (key === "constructor") continue;
+    const targetDesc = Object.getOwnPropertyDescriptor(target, key);
+    const desc = Object.getOwnPropertyDescriptor(source, key);
+    let modified = false;
+    if (desc.get) {
+      modified = true;
+      desc.get = targetDesc?.get || function() {
+        return this[sourceKey][key];
+      };
+    }
+    if (desc.set) {
+      modified = true;
+      desc.set = targetDesc?.set || function(value) {
+        this[sourceKey][key] = value;
+      };
+    }
+    if (!targetDesc?.value && typeof desc.value === "function") {
+      modified = true;
+      desc.value = function(...args) {
+        return this[sourceKey][key](...args);
+      };
+    }
+    if (modified) Object.defineProperty(target, key, desc);
+  }
+}
+const FastURL = /* @__PURE__ */ (() => {
+  const NativeURL = globalThis.URL;
+  const FastURL$1 = class URL {
+    #url;
+    #href;
+    #protocol;
+    #host;
+    #pathname;
+    #search;
+    #searchParams;
+    #pos;
+    constructor(url) {
+      if (typeof url === "string") this.#href = url;
+      else {
+        this.#protocol = url.protocol;
+        this.#host = url.host;
+        this.#pathname = url.pathname;
+        this.#search = url.search;
+      }
+    }
+    static [Symbol.hasInstance](val) {
+      return val instanceof NativeURL;
+    }
+    get _url() {
+      if (this.#url) return this.#url;
+      this.#url = new NativeURL(this.href);
+      this.#href = void 0;
+      this.#protocol = void 0;
+      this.#host = void 0;
+      this.#pathname = void 0;
+      this.#search = void 0;
+      this.#searchParams = void 0;
+      this.#pos = void 0;
+      return this.#url;
+    }
+    get href() {
+      if (this.#url) return this.#url.href;
+      if (!this.#href) this.#href = `${this.#protocol || "http:"}//${this.#host || "localhost"}${this.#pathname || "/"}${this.#search || ""}`;
+      return this.#href;
+    }
+    #getPos() {
+      if (!this.#pos) {
+        const url = this.href;
+        const protoIndex = url.indexOf("://");
+        const pathnameIndex = protoIndex === -1 ? -1 : url.indexOf("/", protoIndex + 4);
+        this.#pos = [
+          protoIndex,
+          pathnameIndex,
+          pathnameIndex === -1 ? -1 : url.indexOf("?", pathnameIndex)
+        ];
+      }
+      return this.#pos;
+    }
+    get pathname() {
+      if (this.#url) return this.#url.pathname;
+      if (this.#pathname === void 0) {
+        const [, pathnameIndex, queryIndex] = this.#getPos();
+        if (pathnameIndex === -1) return this._url.pathname;
+        this.#pathname = this.href.slice(pathnameIndex, queryIndex === -1 ? void 0 : queryIndex);
+      }
+      return this.#pathname;
+    }
+    get search() {
+      if (this.#url) return this.#url.search;
+      if (this.#search === void 0) {
+        const [, pathnameIndex, queryIndex] = this.#getPos();
+        if (pathnameIndex === -1) return this._url.search;
+        const url = this.href;
+        this.#search = queryIndex === -1 || queryIndex === url.length - 1 ? "" : url.slice(queryIndex);
+      }
+      return this.#search;
+    }
+    get searchParams() {
+      if (this.#url) return this.#url.searchParams;
+      if (!this.#searchParams) this.#searchParams = new URLSearchParams(this.search);
+      return this.#searchParams;
+    }
+    get protocol() {
+      if (this.#url) return this.#url.protocol;
+      if (this.#protocol === void 0) {
+        const [protocolIndex] = this.#getPos();
+        if (protocolIndex === -1) return this._url.protocol;
+        this.#protocol = this.href.slice(0, protocolIndex + 1);
+      }
+      return this.#protocol;
+    }
+    toString() {
+      return this.href;
+    }
+    toJSON() {
+      return this.href;
+    }
+  };
+  lazyInherit(FastURL$1.prototype, NativeURL.prototype, "_url");
+  Object.setPrototypeOf(FastURL$1.prototype, NativeURL.prototype);
+  Object.setPrototypeOf(FastURL$1, NativeURL);
+  return FastURL$1;
+})();
+const NodeResponse = /* @__PURE__ */ (() => {
+  const NativeResponse = globalThis.Response;
+  const STATUS_CODES = globalThis.process?.getBuiltinModule?.("node:http")?.STATUS_CODES || {};
+  class NodeResponse$1 {
+    #body;
+    #init;
+    #headers;
+    #response;
+    constructor(body, init) {
+      this.#body = body;
+      this.#init = init;
+    }
+    static [Symbol.hasInstance](val) {
+      return val instanceof NativeResponse;
+    }
+    get status() {
+      return this.#response?.status || this.#init?.status || 200;
+    }
+    get statusText() {
+      return this.#response?.statusText || this.#init?.statusText || STATUS_CODES[this.status] || "";
+    }
+    get headers() {
+      if (this.#response) return this.#response.headers;
+      if (this.#headers) return this.#headers;
+      const initHeaders = this.#init?.headers;
+      return this.#headers = initHeaders instanceof Headers ? initHeaders : new Headers(initHeaders);
+    }
+    get ok() {
+      if (this.#response) return this.#response.ok;
+      const status = this.status;
+      return status >= 200 && status < 300;
+    }
+    get _response() {
+      if (this.#response) return this.#response;
+      this.#response = new NativeResponse(this.#body, this.#headers ? {
+        ...this.#init,
+        headers: this.#headers
+      } : this.#init);
+      this.#init = void 0;
+      this.#headers = void 0;
+      this.#body = void 0;
+      return this.#response;
+    }
+    _toNodeResponse() {
+      const status = this.status;
+      const statusText = this.statusText;
+      let body;
+      let contentType;
+      let contentLength;
+      if (this.#response) body = this.#response.body;
+      else if (this.#body) if (this.#body instanceof ReadableStream) body = this.#body;
+      else if (typeof this.#body === "string") {
+        body = this.#body;
+        contentType = "text/plain; charset=UTF-8";
+        contentLength = Buffer.byteLength(this.#body);
+      } else if (this.#body instanceof ArrayBuffer) {
+        body = Buffer.from(this.#body);
+        contentLength = this.#body.byteLength;
+      } else if (this.#body instanceof Uint8Array) {
+        body = this.#body;
+        contentLength = this.#body.byteLength;
+      } else if (this.#body instanceof DataView) {
+        body = Buffer.from(this.#body.buffer);
+        contentLength = this.#body.byteLength;
+      } else if (this.#body instanceof Blob) {
+        body = this.#body.stream();
+        contentType = this.#body.type;
+        contentLength = this.#body.size;
+      } else if (typeof this.#body.pipe === "function") body = this.#body;
+      else body = this._response.body;
+      const headers = [];
+      const initHeaders = this.#init?.headers;
+      const headerEntries = this.#response?.headers || this.#headers || (initHeaders ? Array.isArray(initHeaders) ? initHeaders : initHeaders?.entries ? initHeaders.entries() : Object.entries(initHeaders).map(([k2, v2]) => [k2.toLowerCase(), v2]) : void 0);
+      let hasContentTypeHeader;
+      let hasContentLength;
+      if (headerEntries) for (const [key, value] of headerEntries) {
+        if (Array.isArray(value)) for (const v2 of value) headers.push([key, v2]);
+        else headers.push([key, value]);
+        if (key === "content-type") hasContentTypeHeader = true;
+        else if (key === "content-length") hasContentLength = true;
+      }
+      if (contentType && !hasContentTypeHeader) headers.push(["content-type", contentType]);
+      if (contentLength && !hasContentLength) headers.push(["content-length", String(contentLength)]);
+      this.#init = void 0;
+      this.#headers = void 0;
+      this.#response = void 0;
+      this.#body = void 0;
+      return {
+        status,
+        statusText,
+        headers,
+        body
+      };
+    }
+  }
+  lazyInherit(NodeResponse$1.prototype, NativeResponse.prototype, "_response");
+  Object.setPrototypeOf(NodeResponse$1, NativeResponse);
+  Object.setPrototypeOf(NodeResponse$1.prototype, NativeResponse.prototype);
+  return NodeResponse$1;
+})();
+const kEventNS = "h3.internal.event.";
+const kEventRes = /* @__PURE__ */ Symbol.for(`${kEventNS}res`);
+const kEventResHeaders = /* @__PURE__ */ Symbol.for(`${kEventNS}res.headers`);
+var H3Event = class {
+  app;
+  req;
+  url;
+  context;
+  static __is_event__ = true;
+  constructor(req, context, app) {
+    this.context = context || req.context || new NullProtoObj();
+    this.req = req;
+    this.app = app;
+    const _url = req._url;
+    this.url = _url && _url instanceof URL ? _url : new FastURL(req.url);
+  }
+  get res() {
+    return this[kEventRes] ||= new H3EventResponse();
+  }
+  get runtime() {
+    return this.req.runtime;
+  }
+  waitUntil(promise) {
+    this.req.waitUntil?.(promise);
+  }
+  toString() {
+    return `[${this.req.method}] ${this.req.url}`;
+  }
+  toJSON() {
+    return this.toString();
+  }
+  get node() {
+    return this.req.runtime?.node;
+  }
+  get headers() {
+    return this.req.headers;
+  }
+  get path() {
+    return this.url.pathname + this.url.search;
+  }
+  get method() {
+    return this.req.method;
+  }
+};
+var H3EventResponse = class {
+  status;
+  statusText;
+  get headers() {
+    return this[kEventResHeaders] ||= new Headers();
+  }
+};
+const DISALLOWED_STATUS_CHARS = /[^\u0009\u0020-\u007E]/g;
+function sanitizeStatusMessage(statusMessage = "") {
+  return statusMessage.replace(DISALLOWED_STATUS_CHARS, "");
+}
+function sanitizeStatusCode(statusCode, defaultStatusCode = 200) {
+  if (!statusCode) return defaultStatusCode;
+  if (typeof statusCode === "string") statusCode = +statusCode;
+  if (statusCode < 100 || statusCode > 599) return defaultStatusCode;
+  return statusCode;
+}
+var HTTPError = class HTTPError2 extends Error {
+  get name() {
+    return "HTTPError";
+  }
+  status;
+  statusText;
+  headers;
+  cause;
+  data;
+  body;
+  unhandled;
+  static isError(input) {
+    return input instanceof Error && input?.name === "HTTPError";
+  }
+  static status(status, statusText, details) {
+    return new HTTPError2({
+      ...details,
+      statusText,
+      status
+    });
+  }
+  constructor(arg1, arg2) {
+    let messageInput;
+    let details;
+    if (typeof arg1 === "string") {
+      messageInput = arg1;
+      details = arg2;
+    } else details = arg1;
+    const status = sanitizeStatusCode(details?.status || details?.cause?.status || details?.status || details?.statusCode, 500);
+    const statusText = sanitizeStatusMessage(details?.statusText || details?.cause?.statusText || details?.statusText || details?.statusMessage);
+    const message = messageInput || details?.message || details?.cause?.message || details?.statusText || details?.statusMessage || [
+      "HTTPError",
+      status,
+      statusText
+    ].filter(Boolean).join(" ");
+    super(message, { cause: details });
+    this.cause = details;
+    this.status = status;
+    this.statusText = statusText || void 0;
+    const rawHeaders = details?.headers || details?.cause?.headers;
+    this.headers = rawHeaders ? new Headers(rawHeaders) : void 0;
+    this.unhandled = details?.unhandled ?? details?.cause?.unhandled ?? void 0;
+    this.data = details?.data;
+    this.body = details?.body;
+  }
+  get statusCode() {
+    return this.status;
+  }
+  get statusMessage() {
+    return this.statusText;
+  }
+  toJSON() {
+    const unhandled = this.unhandled;
+    return {
+      status: this.status,
+      statusText: this.statusText,
+      unhandled,
+      message: unhandled ? "HTTPError" : this.message,
+      data: unhandled ? void 0 : this.data,
+      ...unhandled ? void 0 : this.body
+    };
+  }
+};
+function isJSONSerializable(value, _type) {
+  if (value === null || value === void 0) return true;
+  if (_type !== "object") return _type === "boolean" || _type === "number" || _type === "string";
+  if (typeof value.toJSON === "function") return true;
+  if (Array.isArray(value)) return true;
+  if (typeof value.pipe === "function" || typeof value.pipeTo === "function") return false;
+  if (value instanceof NullProtoObj) return true;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+const kNotFound = /* @__PURE__ */ Symbol.for("h3.notFound");
+const kHandled = /* @__PURE__ */ Symbol.for("h3.handled");
+function toResponse(val, event, config = {}) {
+  if (typeof val?.then === "function") return (val.catch?.((error) => error) || Promise.resolve(val)).then((resolvedVal) => toResponse(resolvedVal, event, config));
+  const response = prepareResponse(val, event, config);
+  if (typeof response?.then === "function") return toResponse(response, event, config);
+  const { onResponse: onResponse$1 } = config;
+  return onResponse$1 ? Promise.resolve(onResponse$1(response, event)).then(() => response) : response;
+}
+var HTTPResponse = class {
+  #headers;
+  #init;
+  body;
+  constructor(body, init) {
+    this.body = body;
+    this.#init = init;
+  }
+  get status() {
+    return this.#init?.status || 200;
+  }
+  get statusText() {
+    return this.#init?.statusText || "OK";
+  }
+  get headers() {
+    return this.#headers ||= new Headers(this.#init?.headers);
+  }
+};
+function prepareResponse(val, event, config, nested) {
+  if (val === kHandled) return new NodeResponse(null);
+  if (val === kNotFound) val = new HTTPError({
+    status: 404,
+    message: `Cannot find any route matching [${event.req.method}] ${event.url}`
+  });
+  if (val && val instanceof Error) {
+    const isHTTPError = HTTPError.isError(val);
+    const error = isHTTPError ? val : new HTTPError(val);
+    if (!isHTTPError) {
+      error.unhandled = true;
+      if (val?.stack) error.stack = val.stack;
+    }
+    if (error.unhandled && !config.silent) console.error(error);
+    const { onError: onError$1 } = config;
+    return onError$1 && !nested ? Promise.resolve(onError$1(error, event)).catch((error$1) => error$1).then((newVal) => prepareResponse(newVal ?? val, event, config, true)) : errorResponse(error, config.debug);
+  }
+  const preparedRes = event[kEventRes];
+  const preparedHeaders = preparedRes?.[kEventResHeaders];
+  event[kEventRes] = void 0;
+  if (!(val instanceof Response)) {
+    const res = prepareResponseBody(val, event, config);
+    const status = res.status || preparedRes?.status;
+    return new NodeResponse(nullBody(event.req.method, status) ? null : res.body, {
+      status,
+      statusText: res.statusText || preparedRes?.statusText,
+      headers: res.headers && preparedHeaders ? mergeHeaders$1(res.headers, preparedHeaders) : res.headers || preparedHeaders
+    });
+  }
+  if (!preparedHeaders || nested || !val.ok) return val;
+  try {
+    mergeHeaders$1(val.headers, preparedHeaders, val.headers);
+    return val;
+  } catch {
+    return new NodeResponse(nullBody(event.req.method, val.status) ? null : val.body, {
+      status: val.status,
+      statusText: val.statusText,
+      headers: mergeHeaders$1(val.headers, preparedHeaders)
+    });
+  }
+}
+function mergeHeaders$1(base, overrides, target = new Headers(base)) {
+  for (const [name, value] of overrides) if (name === "set-cookie") target.append(name, value);
+  else target.set(name, value);
+  return target;
+}
+const frozenHeaders = () => {
+  throw new Error("Headers are frozen");
+};
+var FrozenHeaders = class extends Headers {
+  constructor(init) {
+    super(init);
+    this.set = this.append = this.delete = frozenHeaders;
+  }
+};
+const emptyHeaders = /* @__PURE__ */ new FrozenHeaders({ "content-length": "0" });
+const jsonHeaders = /* @__PURE__ */ new FrozenHeaders({ "content-type": "application/json;charset=UTF-8" });
+function prepareResponseBody(val, event, config) {
+  if (val === null || val === void 0) return {
+    body: "",
+    headers: emptyHeaders
+  };
+  const valType = typeof val;
+  if (valType === "string") return { body: val };
+  if (val instanceof Uint8Array) {
+    event.res.headers.set("content-length", val.byteLength.toString());
+    return { body: val };
+  }
+  if (val instanceof HTTPResponse || val?.constructor?.name === "HTTPResponse") return val;
+  if (isJSONSerializable(val, valType)) return {
+    body: JSON.stringify(val, void 0, config.debug ? 2 : void 0),
+    headers: jsonHeaders
+  };
+  if (valType === "bigint") return {
+    body: val.toString(),
+    headers: jsonHeaders
+  };
+  if (val instanceof Blob) {
+    const headers = new Headers({
+      "content-type": val.type,
+      "content-length": val.size.toString()
+    });
+    let filename = val.name;
+    if (filename) {
+      filename = encodeURIComponent(filename);
+      headers.set("content-disposition", `filename="${filename}"; filename*=UTF-8''${filename}`);
+    }
+    return {
+      body: val.stream(),
+      headers
+    };
+  }
+  if (valType === "symbol") return { body: val.toString() };
+  if (valType === "function") return { body: `${val.name}()` };
+  return { body: val };
+}
+function nullBody(method, status) {
+  return method === "HEAD" || status === 100 || status === 101 || status === 102 || status === 204 || status === 205 || status === 304;
+}
+function errorResponse(error, debug) {
+  return new NodeResponse(JSON.stringify({
+    ...error.toJSON(),
+    stack: debug && error.stack ? error.stack.split("\n").map((l) => l.trim()) : void 0
+  }, void 0, debug ? 2 : void 0), {
+    status: error.status,
+    statusText: error.statusText,
+    headers: error.headers ? mergeHeaders$1(jsonHeaders, error.headers) : new Headers(jsonHeaders)
+  });
+}
+new TextEncoder();
 const GLOBAL_EVENT_STORAGE_KEY = /* @__PURE__ */ Symbol.for("tanstack-start:event-storage");
 const globalObj = globalThis;
 if (!globalObj[GLOBAL_EVENT_STORAGE_KEY]) {
@@ -440,7 +3837,7 @@ function getResponse() {
   return event.res;
 }
 async function getStartManifest(matchedRoutes) {
-  const { tsrStartManifest } = await import("./_tanstack-start-manifest_v-Dk-FIYPN.mjs");
+  const { tsrStartManifest } = await import("./_tanstack-start-manifest_v-CC7UrHKE.mjs");
   const startManifest = tsrStartManifest();
   const rootRoute = startManifest.routes[rootRouteId] = startManifest.routes[rootRouteId] || {};
   rootRoute.assets = rootRoute.assets || [];
@@ -455,21 +3852,21 @@ async function getStartManifest(matchedRoutes) {
   });
   const manifest2 = {
     routes: Object.fromEntries(
-      Object.entries(startManifest.routes).flatMap(([k, v]) => {
+      Object.entries(startManifest.routes).flatMap(([k2, v2]) => {
         const result = {};
         let hasData = false;
-        if (v.preloads && v.preloads.length > 0) {
-          result["preloads"] = v.preloads;
+        if (v2.preloads && v2.preloads.length > 0) {
+          result["preloads"] = v2.preloads;
           hasData = true;
         }
-        if (v.assets && v.assets.length > 0) {
-          result["assets"] = v.assets;
+        if (v2.assets && v2.assets.length > 0) {
+          result["assets"] = v2.assets;
           hasData = true;
         }
         if (!hasData) {
           return [];
         }
-        return [[k, result]];
+        return [[k2, result]];
       })
     )
   };
@@ -600,7 +3997,7 @@ function createMultiplexedStream(jsonStream, rawStreams) {
 }
 const manifest = { "dff4e5b7f7b29b6a323200a2df0a5335d739cf583e83c9e514598af6b5ade819": {
   functionName: "getServerConfig_createServerFn_handler",
-  importer: () => import("./config.server-D7JHDcDv.mjs")
+  importer: () => import("./config.server-BOr7Jxr4.mjs")
 } };
 async function getServerFnById(id) {
   const serverFnInfo = manifest[id];
@@ -886,19 +4283,19 @@ const HEADERS = {
 };
 const ServerFunctionSerializationAdapter = createSerializationAdapter({
   key: "$TSS/serverfn",
-  test: (v) => {
-    if (typeof v !== "function") return false;
-    if (!(TSS_SERVER_FUNCTION in v)) return false;
-    return !!v[TSS_SERVER_FUNCTION];
+  test: (v2) => {
+    if (typeof v2 !== "function") return false;
+    if (!(TSS_SERVER_FUNCTION in v2)) return false;
+    return !!v2[TSS_SERVER_FUNCTION];
   },
   toSerializable: ({ serverFnMeta }) => ({ functionId: serverFnMeta.id }),
   fromSerializable: ({ functionId }) => {
-    const fn = async (opts, signal) => {
+    const fn2 = async (opts, signal) => {
       const serverFn = await getServerFnById(functionId);
       const result = await serverFn(opts ?? {}, signal);
       return result.result;
     };
-    return fn;
+    return fn2;
   }
 });
 function getStartResponseHeaders(opts) {
@@ -915,7 +4312,7 @@ function getStartResponseHeaders(opts) {
 let entriesPromise;
 let manifestPromise;
 async function loadEntries() {
-  const routerEntry = await import("./router-x6Ab8T4s.mjs").then((n) => n.t);
+  const routerEntry = await import("./router-vd1nySeP.mjs").then((n2) => n2.M);
   const startEntry = await import("./start-HYkvq4Ni.mjs");
   return { startEntry, routerEntry };
 }
@@ -1190,14 +4587,14 @@ async function handleRedirectResponse(response, request, getRouter) {
     );
   }
   const router = await getRouter();
-  const redirect = router.resolveRedirect(response);
+  const redirect2 = router.resolveRedirect(response);
   if (request.headers.get("x-tsr-serverFn") === "true") {
     return Response.json(
       { ...response.options, isSerializedRedirect: true },
       { headers: response.headers }
     );
   }
-  return redirect;
+  return redirect2;
 }
 async function handleServerRoutes({
   getRouter,
@@ -1217,9 +4614,9 @@ async function handleServerRoutes({
     const serverMiddleware = route.options.server?.middleware;
     if (serverMiddleware) {
       const flattened = flattenMiddlewares(serverMiddleware);
-      for (const m of flattened) {
-        if (!executedRequestMiddlewares.has(m)) {
-          routeMiddlewares.push(m.options.server);
+      for (const m2 of flattened) {
+        if (!executedRequestMiddlewares.has(m2)) {
+          routeMiddlewares.push(m2.options.server);
         }
       }
     }
@@ -1236,8 +4633,8 @@ async function handleServerRoutes({
       } else {
         if (handler.middleware?.length) {
           const handlerMiddlewares = flattenMiddlewares(handler.middleware);
-          for (const m of handlerMiddlewares) {
-            routeMiddlewares.push(m.options.server);
+          for (const m2 of handlerMiddlewares) {
+            routeMiddlewares.push(m2.options.server);
           }
         }
         if (handler.handler) {