@grindxp/cli 0.1.6 → 0.1.8

package/dist/web/server/server.js

@@ -0,0 +1,4889 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { Readable, PassThrough } from "node:stream";
+import { jsx } from "react/jsx-runtime";
+import { defineHandlerCallback, renderRouterToStream } from "@tanstack/react-router/ssr/server";
+import { RouterProvider } from "@tanstack/react-router";
+function StartServer(props) {
+  return /* @__PURE__ */ jsx(RouterProvider, { router: props.router });
+}
+const defaultStreamHandler = defineHandlerCallback(
+  ({ request, router, responseHeaders }) => renderRouterToStream({
+    request,
+    router,
+    responseHeaders,
+    children: /* @__PURE__ */ 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 init;
+  } else if (Array.isArray(init)) {
+    return new Headers(init);
+  } else if (typeof init === "object") {
+    return new Headers(init);
+  } else {
+    return null;
+  }
+}
+function mergeHeaders(...headers) {
+  return headers.reduce((acc, header) => {
+    const headersInstance = toHeadersInstance(header);
+    if (!headersInstance) return acc;
+    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);
+}
+function decodePath(path) {
+  if (!path) return { path, handledProtocolRelativeURL: false };
+  if (!/[%\\\x00-\x1f\x7f]/.test(path) && !path.startsWith("//")) {
+    return { path, handledProtocolRelativeURL: false };
+  }
+  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);
+  let handledProtocolRelativeURL = false;
+  if (result.startsWith("//")) {
+    handledProtocolRelativeURL = true;
+    result = "/" + result.replace(/^\/+/, "");
+  }
+  return { path: result, handledProtocolRelativeURL };
+}
+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 (!opts._builtLocation && !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 e == null ? `${Ie}=${Ie}||[]` : `(${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(
+  "TSS_SERVER_FUNCTION_FACTORY"
+);
+const X_TSS_SERIALIZED = "x-tss-serialized";
+const X_TSS_RAW_RESPONSE = "x-tss-raw";
+const TSS_CONTENT_TYPE_FRAMED = "application/x-tss-framed";
+const FrameType = {
+  /** Seroval JSON chunk (NDJSON line) */
+  JSON: 0,
+  /** Raw stream data chunk */
+  CHUNK: 1,
+  /** Raw stream end (EOF) */
+  END: 2,
+  /** Raw stream error */
+  ERROR: 3
+};
+const FRAME_HEADER_SIZE = 9;
+const TSS_FRAMED_PROTOCOL_VERSION = 1;
+const TSS_CONTENT_TYPE_FRAMED_VERSIONED = `${TSS_CONTENT_TYPE_FRAMED}; v=${TSS_FRAMED_PROTOCOL_VERSION}`;
+const GLOBAL_STORAGE_KEY = /* @__PURE__ */ Symbol.for("tanstack-start:start-storage-context");
+const globalObj$1 = globalThis;
+if (!globalObj$1[GLOBAL_STORAGE_KEY]) {
+  globalObj$1[GLOBAL_STORAGE_KEY] = new AsyncLocalStorage();
+}
+const startStorage = globalObj$1[GLOBAL_STORAGE_KEY];
+async function runWithStartContext(context, fn2) {
+  return startStorage.run(context, fn2);
+}
+function getStartContext(opts) {
+  const context = startStorage.getStore();
+  if (!context && opts?.throwIfNotFound !== false) {
+    throw new Error(
+      `No Start context found in AsyncLocalStorage. Make sure you are using the function within the server runtime.`
+    );
+  }
+  return context;
+}
+const getStartOptions = () => getStartContext().startOptions;
+const getStartContextServerOnly = getStartContext;
+function isSafeKey(key) {
+  return key !== "__proto__" && key !== "constructor" && key !== "prototype";
+}
+function safeObjectMerge(target, source) {
+  const result = /* @__PURE__ */ Object.create(null);
+  if (target) {
+    for (const key of Object.keys(target)) {
+      if (isSafeKey(key)) result[key] = target[key];
+    }
+  }
+  if (source && typeof source === "object") {
+    for (const key of Object.keys(source)) {
+      if (isSafeKey(key)) result[key] = source[key];
+    }
+  }
+  return result;
+}
+function createNullProtoObject(source) {
+  if (!source) return /* @__PURE__ */ Object.create(null);
+  const obj = /* @__PURE__ */ Object.create(null);
+  for (const key of Object.keys(source)) {
+    if (isSafeKey(key)) obj[key] = source[key];
+  }
+  return obj;
+}
+const createServerFn = (options, __opts) => {
+  const resolvedOptions = __opts || options || {};
+  if (typeof resolvedOptions.method === "undefined") {
+    resolvedOptions.method = "GET";
+  }
+  const res = {
+    options: resolvedOptions,
+    middleware: (middleware) => {
+      const newMiddleware = [...resolvedOptions.middleware || []];
+      middleware.map((m2) => {
+        if (TSS_SERVER_FUNCTION_FACTORY in m2) {
+          if (m2.options.middleware) {
+            newMiddleware.push(...m2.options.middleware);
+          }
+        } else {
+          newMiddleware.push(m2);
+        }
+      });
+      const newOptions = {
+        ...resolvedOptions,
+        middleware: newMiddleware
+      };
+      const res2 = createServerFn(void 0, newOptions);
+      res2[TSS_SERVER_FUNCTION_FACTORY] = true;
+      return res2;
+    },
+    inputValidator: (inputValidator) => {
+      const newOptions = { ...resolvedOptions, inputValidator };
+      return createServerFn(void 0, newOptions);
+    },
+    handler: (...args) => {
+      const [extractedFn, serverFn] = args;
+      const newOptions = { ...resolvedOptions, extractedFn, serverFn };
+      const resolvedMiddleware = [
+        ...newOptions.middleware || [],
+        serverFnBaseToMiddleware(newOptions)
+      ];
+      return Object.assign(
+        async (opts) => {
+          const result = await executeMiddleware$1(resolvedMiddleware, "client", {
+            ...extractedFn,
+            ...newOptions,
+            data: opts?.data,
+            headers: opts?.headers,
+            signal: opts?.signal,
+            fetch: opts?.fetch,
+            context: createNullProtoObject()
+          });
+          const redirect2 = parseRedirect(result.error);
+          if (redirect2) {
+            throw redirect2;
+          }
+          if (result.error) throw result.error;
+          return result.result;
+        },
+        {
+          // This copies over the URL, function ID
+          ...extractedFn,
+          // The extracted function on the server-side calls
+          // this function
+          __executeServer: async (opts) => {
+            const startContext = getStartContextServerOnly();
+            const serverContextAfterGlobalMiddlewares = startContext.contextAfterGlobalMiddlewares;
+            const ctx = {
+              ...extractedFn,
+              ...opts,
+              // Ensure we use the full serverFnMeta from the provider file's extractedFn
+              // (which has id, name, filename) rather than the partial one from SSR/client
+              // callers (which only has id)
+              serverFnMeta: extractedFn.serverFnMeta,
+              // Use safeObjectMerge for opts.context which comes from client
+              context: safeObjectMerge(
+                serverContextAfterGlobalMiddlewares,
+                opts.context
+              ),
+              request: startContext.request
+            };
+            const result = await executeMiddleware$1(
+              resolvedMiddleware,
+              "server",
+              ctx
+            ).then((d) => ({
+              // Only send the result and sendContext back to the client
+              result: d.result,
+              error: d.error,
+              context: d.sendContext
+            }));
+            return result;
+          }
+        }
+      );
+    }
+  };
+  const fun = (options2) => {
+    const newOptions = {
+      ...resolvedOptions,
+      ...options2
+    };
+    return createServerFn(void 0, newOptions);
+  };
+  return Object.assign(fun, res);
+};
+async function executeMiddleware$1(middlewares, env, opts) {
+  const globalMiddlewares = getStartOptions()?.functionMiddleware || [];
+  let flattenedMiddlewares = flattenMiddlewares([
+    ...globalMiddlewares,
+    ...middlewares
+  ]);
+  if (env === "server") {
+    const startContext = getStartContextServerOnly({ throwIfNotFound: false });
+    if (startContext?.executedRequestMiddlewares) {
+      flattenedMiddlewares = flattenedMiddlewares.filter(
+        (m2) => !startContext.executedRequestMiddlewares.has(m2)
+      );
+    }
+  }
+  const callNextMiddleware = async (ctx) => {
+    const nextMiddleware = flattenedMiddlewares.shift();
+    if (!nextMiddleware) {
+      return ctx;
+    }
+    try {
+      if ("inputValidator" in nextMiddleware.options && nextMiddleware.options.inputValidator && env === "server") {
+        ctx.data = await execValidator(
+          nextMiddleware.options.inputValidator,
+          ctx.data
+        );
+      }
+      let middlewareFn = void 0;
+      if (env === "client") {
+        if ("client" in nextMiddleware.options) {
+          middlewareFn = nextMiddleware.options.client;
+        }
+      } else if ("server" in nextMiddleware.options) {
+        middlewareFn = nextMiddleware.options.server;
+      }
+      if (middlewareFn) {
+        const userNext = async (userCtx = {}) => {
+          const nextCtx = {
+            ...ctx,
+            ...userCtx,
+            context: safeObjectMerge(ctx.context, userCtx.context),
+            sendContext: safeObjectMerge(ctx.sendContext, userCtx.sendContext),
+            headers: mergeHeaders(ctx.headers, userCtx.headers),
+            _callSiteFetch: ctx._callSiteFetch,
+            fetch: ctx._callSiteFetch ?? userCtx.fetch ?? ctx.fetch,
+            result: userCtx.result !== void 0 ? userCtx.result : userCtx instanceof Response ? userCtx : ctx.result,
+            error: userCtx.error ?? ctx.error
+          };
+          const result2 = await callNextMiddleware(nextCtx);
+          if (result2.error) {
+            throw result2.error;
+          }
+          return result2;
+        };
+        const result = await middlewareFn({
+          ...ctx,
+          next: userNext
+        });
+        if (isRedirect(result)) {
+          return {
+            ...ctx,
+            error: result
+          };
+        }
+        if (result instanceof Response) {
+          return {
+            ...ctx,
+            result
+          };
+        }
+        if (!result) {
+          throw new Error(
+            "User middleware returned undefined. You must call next() or return a result in your middlewares."
+          );
+        }
+        return result;
+      }
+      return callNextMiddleware(ctx);
+    } catch (error) {
+      return {
+        ...ctx,
+        error
+      };
+    }
+  };
+  return callNextMiddleware({
+    ...opts,
+    headers: opts.headers || {},
+    sendContext: opts.sendContext || {},
+    context: opts.context || createNullProtoObject(),
+    _callSiteFetch: opts.fetch
+  });
+}
+function flattenMiddlewares(middlewares, maxDepth = 100) {
+  const seen = /* @__PURE__ */ new Set();
+  const flattened = [];
+  const recurse = (middleware, depth) => {
+    if (depth > maxDepth) {
+      throw new Error(
+        `Middleware nesting depth exceeded maximum of ${maxDepth}. Check for circular references.`
+      );
+    }
+    middleware.forEach((m2) => {
+      if (m2.options.middleware) {
+        recurse(m2.options.middleware, depth + 1);
+      }
+      if (!seen.has(m2)) {
+        seen.add(m2);
+        flattened.push(m2);
+      }
+    });
+  };
+  recurse(middlewares, 0);
+  return flattened;
+}
+async function execValidator(validator, input) {
+  if (validator == null) return {};
+  if ("~standard" in validator) {
+    const result = await validator["~standard"].validate(input);
+    if (result.issues)
+      throw new Error(JSON.stringify(result.issues, void 0, 2));
+    return result.value;
+  }
+  if ("parse" in validator) {
+    return validator.parse(input);
+  }
+  if (typeof validator === "function") {
+    return validator(input);
+  }
+  throw new Error("Invalid validator type!");
+}
+function serverFnBaseToMiddleware(options) {
+  return {
+    "~types": void 0,
+    options: {
+      inputValidator: options.inputValidator,
+      client: async ({ next, sendContext, fetch, ...ctx }) => {
+        const payload = {
+          ...ctx,
+          // switch the sendContext over to context
+          context: sendContext,
+          fetch
+        };
+        const res = await options.extractedFn?.(payload);
+        return next(res);
+      },
+      server: async ({ next, ...ctx }) => {
+        const result = await options.serverFn?.(ctx);
+        return next({
+          ...ctx,
+          result
+        });
+      }
+    }
+  };
+}
+function getDefaultSerovalPlugins() {
+  const start = getStartOptions();
+  const adapters = start?.serializationAdapters;
+  return [
+    ...adapters?.map(makeSerovalPlugin) ?? [],
+    ...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 { path: decodedPathname, handledProtocolRelativeURL } = decodePath(
+    rawUrl.pathname
+  );
+  const searchParams = new URLSearchParams(rawUrl.search);
+  const normalizedHref = decodedPathname + (searchParams.size > 0 ? "?" : "") + searchParams.toString() + rawUrl.hash;
+  return {
+    url: new URL(normalizedHref, rawUrl.origin),
+    handledProtocolRelativeURL
+  };
+}
+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 FastURL2 = 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(FastURL2.prototype, NativeURL.prototype, "_url");
+  Object.setPrototypeOf(FastURL2.prototype, NativeURL.prototype);
+  Object.setPrototypeOf(FastURL2, NativeURL);
+  return FastURL2;
+})();
+const NodeResponse = /* @__PURE__ */ (() => {
+  const NativeResponse = globalThis.Response;
+  const STATUS_CODES = globalThis.process?.getBuiltinModule?.("node:http")?.STATUS_CODES || {};
+  class NodeResponse2 {
+    #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;
+      let body = this.#body;
+      if (body && typeof body.pipe === "function" && !(body instanceof Readable)) {
+        const stream = new PassThrough();
+        body.pipe(stream);
+        const abort = body.abort;
+        if (abort) stream.once("close", () => abort());
+        body = stream;
+      }
+      this.#response = new NativeResponse(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(NodeResponse2.prototype, NativeResponse.prototype, "_response");
+  Object.setPrototypeOf(NodeResponse2, NativeResponse);
+  Object.setPrototypeOf(NodeResponse2.prototype, NativeResponse.prototype);
+  return NodeResponse2;
+})();
+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 } = config;
+  return onResponse ? Promise.resolve(onResponse(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 } = config;
+    return onError && !nested ? Promise.resolve(onError(error, event)).catch((error2) => error2).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 frozen = (name) => (...args) => {
+  throw new Error(`Headers are frozen (${name} ${args.join(", ")})`);
+};
+var FrozenHeaders = class extends Headers {
+  set = frozen("set");
+  append = frozen("append");
+  delete = frozen("delete");
+};
+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)
+  });
+}
+function parse(str, options) {
+  if (typeof str !== "string") throw new TypeError("argument str must be a string");
+  const obj = {};
+  const opt = {};
+  const dec = opt.decode || decode;
+  let index = 0;
+  while (index < str.length) {
+    const eqIdx = str.indexOf("=", index);
+    if (eqIdx === -1) break;
+    let endIdx = str.indexOf(";", index);
+    if (endIdx === -1) endIdx = str.length;
+    else if (endIdx < eqIdx) {
+      index = str.lastIndexOf(";", eqIdx - 1) + 1;
+      continue;
+    }
+    const key = str.slice(index, eqIdx).trim();
+    if (opt?.filter && !opt?.filter(key)) {
+      index = endIdx + 1;
+      continue;
+    }
+    if (void 0 === obj[key]) {
+      let val = str.slice(eqIdx + 1, endIdx).trim();
+      if (val.codePointAt(0) === 34) val = val.slice(1, -1);
+      obj[key] = tryDecode(val, dec);
+    }
+    index = endIdx + 1;
+  }
+  return obj;
+}
+function decode(str) {
+  return str.includes("%") ? decodeURIComponent(str) : str;
+}
+function tryDecode(str, decode2) {
+  try {
+    return decode2(str);
+  } catch {
+    return str;
+  }
+}
+function parseCookies(event) {
+  return parse(event.req.headers.get("cookie") || "");
+}
+new TextEncoder();
+const GLOBAL_EVENT_STORAGE_KEY = /* @__PURE__ */ Symbol.for("tanstack-start:event-storage");
+const globalObj = globalThis;
+if (!globalObj[GLOBAL_EVENT_STORAGE_KEY]) {
+  globalObj[GLOBAL_EVENT_STORAGE_KEY] = new AsyncLocalStorage();
+}
+const eventStorage = globalObj[GLOBAL_EVENT_STORAGE_KEY];
+function isPromiseLike(value) {
+  return typeof value.then === "function";
+}
+function getSetCookieValues(headers) {
+  const headersWithSetCookie = headers;
+  if (typeof headersWithSetCookie.getSetCookie === "function") {
+    return headersWithSetCookie.getSetCookie();
+  }
+  const value = headers.get("set-cookie");
+  return value ? [value] : [];
+}
+function mergeEventResponseHeaders(response, event) {
+  if (response.ok) {
+    return;
+  }
+  const eventSetCookies = getSetCookieValues(event.res.headers);
+  if (eventSetCookies.length === 0) {
+    return;
+  }
+  const responseSetCookies = getSetCookieValues(response.headers);
+  response.headers.delete("set-cookie");
+  for (const cookie of responseSetCookies) {
+    response.headers.append("set-cookie", cookie);
+  }
+  for (const cookie of eventSetCookies) {
+    response.headers.append("set-cookie", cookie);
+  }
+}
+function attachResponseHeaders(value, event) {
+  if (isPromiseLike(value)) {
+    return value.then((resolved) => {
+      if (resolved instanceof Response) {
+        mergeEventResponseHeaders(resolved, event);
+      }
+      return resolved;
+    });
+  }
+  if (value instanceof Response) {
+    mergeEventResponseHeaders(value, event);
+  }
+  return value;
+}
+function requestHandler(handler) {
+  return (request, requestOpts) => {
+    const h3Event = new H3Event(request);
+    const response = eventStorage.run(
+      { h3Event },
+      () => handler(request, requestOpts)
+    );
+    return toResponse(attachResponseHeaders(response, h3Event), h3Event);
+  };
+}
+function getH3Event() {
+  const event = eventStorage.getStore();
+  if (!event) {
+    throw new Error(
+      `No StartEvent found in AsyncLocalStorage. Make sure you are using the function within the server runtime.`
+    );
+  }
+  return event.h3Event;
+}
+function getCookies() {
+  const event = getH3Event();
+  return parseCookies(event);
+}
+function getCookie(name) {
+  return getCookies()[name] || void 0;
+}
+function getResponse() {
+  const event = getH3Event();
+  return event.res;
+}
+async function getStartManifest(matchedRoutes) {
+  const { tsrStartManifest } = await import("./assets/_tanstack-start-manifest_v-B_rvI8DG.js");
+  const startManifest = tsrStartManifest();
+  const rootRoute = startManifest.routes[rootRouteId] = startManifest.routes[rootRouteId] || {};
+  rootRoute.assets = rootRoute.assets || [];
+  let injectedHeadScripts;
+  const manifest2 = {
+    routes: Object.fromEntries(
+      Object.entries(startManifest.routes).flatMap(([k2, v2]) => {
+        const result = {};
+        let hasData = false;
+        if (v2.preloads && v2.preloads.length > 0) {
+          result["preloads"] = v2.preloads;
+          hasData = true;
+        }
+        if (v2.assets && v2.assets.length > 0) {
+          result["assets"] = v2.assets;
+          hasData = true;
+        }
+        if (!hasData) {
+          return [];
+        }
+        return [[k2, result]];
+      })
+    )
+  };
+  return {
+    manifest: manifest2,
+    clientEntry: startManifest.clientEntry,
+    injectedHeadScripts
+  };
+}
+const textEncoder$1 = new TextEncoder();
+const EMPTY_PAYLOAD = new Uint8Array(0);
+function encodeFrame(type, streamId, payload) {
+  const frame = new Uint8Array(FRAME_HEADER_SIZE + payload.length);
+  frame[0] = type;
+  frame[1] = streamId >>> 24 & 255;
+  frame[2] = streamId >>> 16 & 255;
+  frame[3] = streamId >>> 8 & 255;
+  frame[4] = streamId & 255;
+  frame[5] = payload.length >>> 24 & 255;
+  frame[6] = payload.length >>> 16 & 255;
+  frame[7] = payload.length >>> 8 & 255;
+  frame[8] = payload.length & 255;
+  frame.set(payload, FRAME_HEADER_SIZE);
+  return frame;
+}
+function encodeJSONFrame(json) {
+  return encodeFrame(FrameType.JSON, 0, textEncoder$1.encode(json));
+}
+function encodeChunkFrame(streamId, chunk) {
+  return encodeFrame(FrameType.CHUNK, streamId, chunk);
+}
+function encodeEndFrame(streamId) {
+  return encodeFrame(FrameType.END, streamId, EMPTY_PAYLOAD);
+}
+function encodeErrorFrame(streamId, error) {
+  const message = error instanceof Error ? error.message : String(error ?? "Unknown error");
+  return encodeFrame(FrameType.ERROR, streamId, textEncoder$1.encode(message));
+}
+function createMultiplexedStream(jsonStream, rawStreams) {
+  let activePumps = 1 + rawStreams.size;
+  let controllerRef = null;
+  let cancelled = false;
+  const cancelReaders = [];
+  const safeEnqueue = (chunk) => {
+    if (cancelled || !controllerRef) return;
+    try {
+      controllerRef.enqueue(chunk);
+    } catch {
+    }
+  };
+  const safeError = (err) => {
+    if (cancelled || !controllerRef) return;
+    try {
+      controllerRef.error(err);
+    } catch {
+    }
+  };
+  const safeClose = () => {
+    if (cancelled || !controllerRef) return;
+    try {
+      controllerRef.close();
+    } catch {
+    }
+  };
+  const checkComplete = () => {
+    activePumps--;
+    if (activePumps === 0) {
+      safeClose();
+    }
+  };
+  return new ReadableStream({
+    start(controller) {
+      controllerRef = controller;
+      cancelReaders.length = 0;
+      const pumpJSON = async () => {
+        const reader = jsonStream.getReader();
+        cancelReaders.push(() => {
+          reader.cancel().catch(() => {
+          });
+        });
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (cancelled) break;
+            if (done) break;
+            safeEnqueue(encodeJSONFrame(value));
+          }
+        } catch (error) {
+          safeError(error);
+        } finally {
+          reader.releaseLock();
+          checkComplete();
+        }
+      };
+      const pumpRawStream = async (streamId, stream) => {
+        const reader = stream.getReader();
+        cancelReaders.push(() => {
+          reader.cancel().catch(() => {
+          });
+        });
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (cancelled) break;
+            if (done) {
+              safeEnqueue(encodeEndFrame(streamId));
+              break;
+            }
+            safeEnqueue(encodeChunkFrame(streamId, value));
+          }
+        } catch (error) {
+          safeEnqueue(encodeErrorFrame(streamId, error));
+        } finally {
+          reader.releaseLock();
+          checkComplete();
+        }
+      };
+      pumpJSON();
+      for (const [streamId, stream] of rawStreams) {
+        pumpRawStream(streamId, stream);
+      }
+    },
+    cancel() {
+      cancelled = true;
+      controllerRef = null;
+      for (const cancelReader of cancelReaders) {
+        cancelReader();
+      }
+      cancelReaders.length = 0;
+    }
+  });
+}
+const manifest = { "5ae2bb0c4c003d915f9054a906ac04c5e5445504bc009ebe1b0909b118638f63": {
+  functionName: "getSidebarPref_createServerFn_handler",
+  importer: () => import("./assets/data.functions-9hSsMFx_.js")
+}, "cbb2f7cdf3f3a605c4dfa620eb06a3cf071dae878f19986d68e6ef770b13f7fa": {
+  functionName: "getDashboardData_createServerFn_handler",
+  importer: () => import("./assets/data.functions-9hSsMFx_.js")
+}, "beec9fd37fa775f9a6fdc16dd643e042dbc9e24c2b45f88ddc7b529513bd4661": {
+  functionName: "getConversations_createServerFn_handler",
+  importer: () => import("./assets/data.functions-9hSsMFx_.js")
+}, "ca03005c412458a0bc657c061b4f332f92b1ff4b8c19f40ffaf334bca75a0749": {
+  functionName: "loadConversationMessages_createServerFn_handler",
+  importer: () => import("./assets/data.functions-9hSsMFx_.js")
+}, "184ce16af80e6368f2fae4eb2360630a351114a8cc3ee5800b1a08e02b9dd7e9": {
+  functionName: "getCompanionInfo_createServerFn_handler",
+  importer: () => import("./assets/data.functions-9hSsMFx_.js")
+}, "9a5dc52f000f13d22209e6a0728000f0667bc09e1ac65adb09228596aa34819b": {
+  functionName: "getPromptHistoryEntries_createServerFn_handler",
+  importer: () => import("./assets/data.functions-9hSsMFx_.js")
+}, "0106759db375e1456f62d4c1efe7094c3733545535507409fcecd70d465fd501": {
+  functionName: "appendPromptHistoryEntry_createServerFn_handler",
+  importer: () => import("./assets/data.functions-9hSsMFx_.js")
+}, "6856120823d177dc2bccc2b8c490fcf0742fdb07eb32f1567908fb7b7e9d60b8": {
+  functionName: "streamMessage_createServerFn_handler",
+  importer: () => import("./assets/agent.functions-zpMkBrG3.js").then((n2) => n2.a3)
+} };
+async function getServerFnById(id) {
+  const serverFnInfo = manifest[id];
+  if (!serverFnInfo) {
+    throw new Error("Server function info not found for " + id);
+  }
+  const fnModule = await serverFnInfo.importer();
+  if (!fnModule) {
+    console.info("serverFnInfo", serverFnInfo);
+    throw new Error("Server function module not resolved for " + id);
+  }
+  const action = fnModule[serverFnInfo.functionName];
+  if (!action) {
+    console.info("serverFnInfo", serverFnInfo);
+    console.info("fnModule", fnModule);
+    throw new Error(
+      `Server function module export not resolved for serverFn ID: ${id}`
+    );
+  }
+  return action;
+}
+let serovalPlugins = void 0;
+const textEncoder = new TextEncoder();
+const FORM_DATA_CONTENT_TYPES = [
+  "multipart/form-data",
+  "application/x-www-form-urlencoded"
+];
+const MAX_PAYLOAD_SIZE = 1e6;
+const handleServerAction = async ({
+  request,
+  context,
+  serverFnId
+}) => {
+  const method = request.method;
+  const methodUpper = method.toUpperCase();
+  const methodLower = method.toLowerCase();
+  const url = new URL(request.url);
+  const action = await getServerFnById(serverFnId);
+  const isServerFn = request.headers.get("x-tsr-serverFn") === "true";
+  if (!serovalPlugins) {
+    serovalPlugins = getDefaultSerovalPlugins();
+  }
+  const contentType = request.headers.get("Content-Type");
+  function parsePayload(payload) {
+    const parsedPayload = Iu(payload, { plugins: serovalPlugins });
+    return parsedPayload;
+  }
+  const response = await (async () => {
+    try {
+      let serializeResult = function(res2) {
+        let nonStreamingBody = void 0;
+        const alsResponse = getResponse();
+        if (res2 !== void 0) {
+          const rawStreams = /* @__PURE__ */ new Map();
+          const rawStreamPlugin = createRawStreamRPCPlugin(
+            (id, stream2) => {
+              rawStreams.set(id, stream2);
+            }
+          );
+          const plugins = [rawStreamPlugin, ...serovalPlugins || []];
+          let done = false;
+          const callbacks = {
+            onParse: (value) => {
+              nonStreamingBody = value;
+            },
+            onDone: () => {
+              done = true;
+            },
+            onError: (error) => {
+              throw error;
+            }
+          };
+          au(res2, {
+            refs: /* @__PURE__ */ new Map(),
+            plugins,
+            onParse(value) {
+              callbacks.onParse(value);
+            },
+            onDone() {
+              callbacks.onDone();
+            },
+            onError: (error) => {
+              callbacks.onError(error);
+            }
+          });
+          if (done && rawStreams.size === 0) {
+            return new Response(
+              nonStreamingBody ? JSON.stringify(nonStreamingBody) : void 0,
+              {
+                status: alsResponse.status,
+                statusText: alsResponse.statusText,
+                headers: {
+                  "Content-Type": "application/json",
+                  [X_TSS_SERIALIZED]: "true"
+                }
+              }
+            );
+          }
+          if (rawStreams.size > 0) {
+            const jsonStream = new ReadableStream({
+              start(controller) {
+                callbacks.onParse = (value) => {
+                  controller.enqueue(JSON.stringify(value) + "\n");
+                };
+                callbacks.onDone = () => {
+                  try {
+                    controller.close();
+                  } catch {
+                  }
+                };
+                callbacks.onError = (error) => controller.error(error);
+                if (nonStreamingBody !== void 0) {
+                  callbacks.onParse(nonStreamingBody);
+                }
+              }
+            });
+            const multiplexedStream = createMultiplexedStream(
+              jsonStream,
+              rawStreams
+            );
+            return new Response(multiplexedStream, {
+              status: alsResponse.status,
+              statusText: alsResponse.statusText,
+              headers: {
+                "Content-Type": TSS_CONTENT_TYPE_FRAMED_VERSIONED,
+                [X_TSS_SERIALIZED]: "true"
+              }
+            });
+          }
+          const stream = new ReadableStream({
+            start(controller) {
+              callbacks.onParse = (value) => controller.enqueue(
+                textEncoder.encode(JSON.stringify(value) + "\n")
+              );
+              callbacks.onDone = () => {
+                try {
+                  controller.close();
+                } catch (error) {
+                  controller.error(error);
+                }
+              };
+              callbacks.onError = (error) => controller.error(error);
+              if (nonStreamingBody !== void 0) {
+                callbacks.onParse(nonStreamingBody);
+              }
+            }
+          });
+          return new Response(stream, {
+            status: alsResponse.status,
+            statusText: alsResponse.statusText,
+            headers: {
+              "Content-Type": "application/x-ndjson",
+              [X_TSS_SERIALIZED]: "true"
+            }
+          });
+        }
+        return new Response(void 0, {
+          status: alsResponse.status,
+          statusText: alsResponse.statusText
+        });
+      };
+      let res = await (async () => {
+        if (FORM_DATA_CONTENT_TYPES.some(
+          (type) => contentType && contentType.includes(type)
+        )) {
+          invariant(
+            methodLower !== "get",
+            "GET requests with FormData payloads are not supported"
+          );
+          const formData = await request.formData();
+          const serializedContext = formData.get(TSS_FORMDATA_CONTEXT);
+          formData.delete(TSS_FORMDATA_CONTEXT);
+          const params = {
+            context,
+            data: formData,
+            method: methodUpper
+          };
+          if (typeof serializedContext === "string") {
+            try {
+              const parsedContext = JSON.parse(serializedContext);
+              const deserializedContext = Iu(parsedContext, {
+                plugins: serovalPlugins
+              });
+              if (typeof deserializedContext === "object" && deserializedContext) {
+                params.context = safeObjectMerge(
+                  context,
+                  deserializedContext
+                );
+              }
+            } catch (e) {
+              if (false) ;
+            }
+          }
+          return await action(params);
+        }
+        if (methodLower === "get") {
+          const payloadParam = url.searchParams.get("payload");
+          if (payloadParam && payloadParam.length > MAX_PAYLOAD_SIZE) {
+            throw new Error("Payload too large");
+          }
+          const payload2 = payloadParam ? parsePayload(JSON.parse(payloadParam)) : {};
+          payload2.context = safeObjectMerge(context, payload2.context);
+          payload2.method = methodUpper;
+          return await action(payload2);
+        }
+        if (methodLower !== "post") {
+          throw new Error("expected POST method");
+        }
+        let jsonPayload;
+        if (contentType?.includes("application/json")) {
+          jsonPayload = await request.json();
+        }
+        const payload = jsonPayload ? parsePayload(jsonPayload) : {};
+        payload.context = safeObjectMerge(payload.context, context);
+        payload.method = methodUpper;
+        return await action(payload);
+      })();
+      const unwrapped = res.result || res.error;
+      if (isNotFound(res)) {
+        res = isNotFoundResponse(res);
+      }
+      if (!isServerFn) {
+        return unwrapped;
+      }
+      if (unwrapped instanceof Response) {
+        if (isRedirect(unwrapped)) {
+          return unwrapped;
+        }
+        unwrapped.headers.set(X_TSS_RAW_RESPONSE, "true");
+        return unwrapped;
+      }
+      return serializeResult(res);
+    } catch (error) {
+      if (error instanceof Response) {
+        return error;
+      }
+      if (isNotFound(error)) {
+        return isNotFoundResponse(error);
+      }
+      console.info();
+      console.info("Server Fn Error!");
+      console.info();
+      console.error(error);
+      console.info();
+      const serializedError = JSON.stringify(
+        await Promise.resolve(
+          ou(error, {
+            refs: /* @__PURE__ */ new Map(),
+            plugins: serovalPlugins
+          })
+        )
+      );
+      const response2 = getResponse();
+      return new Response(serializedError, {
+        status: response2.status ?? 500,
+        statusText: response2.statusText,
+        headers: {
+          "Content-Type": "application/json",
+          [X_TSS_SERIALIZED]: "true"
+        }
+      });
+    }
+  })();
+  return response;
+};
+function isNotFoundResponse(error) {
+  const { headers, ...rest } = error;
+  return new Response(JSON.stringify(rest), {
+    status: 404,
+    headers: {
+      "Content-Type": "application/json",
+      ...headers || {}
+    }
+  });
+}
+function resolveTransformConfig(transform) {
+  if (typeof transform === "string") {
+    const prefix2 = transform;
+    return {
+      type: "transform",
+      transformFn: ({ url }) => `${prefix2}${url}`,
+      cache: true
+    };
+  }
+  if (typeof transform === "function") {
+    return {
+      type: "transform",
+      transformFn: transform,
+      cache: true
+    };
+  }
+  if ("createTransform" in transform && transform.createTransform) {
+    return {
+      type: "createTransform",
+      createTransform: transform.createTransform,
+      cache: transform.cache !== false
+    };
+  }
+  const transformFn = typeof transform.transform === "string" ? (({ url }) => `${transform.transform}${url}`) : transform.transform;
+  return {
+    type: "transform",
+    transformFn,
+    cache: transform.cache !== false
+  };
+}
+function buildClientEntryScriptTag(clientEntry, injectedHeadScripts) {
+  const clientEntryLiteral = JSON.stringify(clientEntry);
+  let script = `import(${clientEntryLiteral})`;
+  if (injectedHeadScripts) {
+    script = `${injectedHeadScripts};${script}`;
+  }
+  return {
+    tag: "script",
+    attrs: {
+      type: "module",
+      async: true
+    },
+    children: script
+  };
+}
+function transformManifestUrls(source, transformFn, opts) {
+  return (async () => {
+    const manifest2 = opts?.clone ? structuredClone(source.manifest) : source.manifest;
+    for (const route of Object.values(manifest2.routes)) {
+      if (route.preloads) {
+        route.preloads = await Promise.all(
+          route.preloads.map(
+            (url) => Promise.resolve(transformFn({ url, type: "modulepreload" }))
+          )
+        );
+      }
+      if (route.assets) {
+        for (const asset of route.assets) {
+          if (asset.tag === "link" && asset.attrs?.href) {
+            asset.attrs.href = await Promise.resolve(
+              transformFn({
+                url: asset.attrs.href,
+                type: "stylesheet"
+              })
+            );
+          }
+        }
+      }
+    }
+    const transformedClientEntry = await Promise.resolve(
+      transformFn({
+        url: source.clientEntry,
+        type: "clientEntry"
+      })
+    );
+    const rootRoute = manifest2.routes[rootRouteId];
+    if (rootRoute) {
+      rootRoute.assets = rootRoute.assets || [];
+      rootRoute.assets.push(
+        buildClientEntryScriptTag(
+          transformedClientEntry,
+          source.injectedHeadScripts
+        )
+      );
+    }
+    return manifest2;
+  })();
+}
+function buildManifestWithClientEntry(source) {
+  const scriptTag = buildClientEntryScriptTag(
+    source.clientEntry,
+    source.injectedHeadScripts
+  );
+  const baseRootRoute = source.manifest.routes[rootRouteId];
+  const routes = {
+    ...source.manifest.routes,
+    ...baseRootRoute ? {
+      [rootRouteId]: {
+        ...baseRootRoute,
+        assets: [...baseRootRoute.assets || [], scriptTag]
+      }
+    } : {}
+  };
+  return { routes };
+}
+const HEADERS = {
+  TSS_SHELL: "X-TSS_SHELL"
+};
+const ServerFunctionSerializationAdapter = createSerializationAdapter({
+  key: "$TSS/serverfn",
+  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 fn2 = async (opts, signal) => {
+      const serverFn = await getServerFnById(functionId);
+      const result = await serverFn(opts ?? {}, signal);
+      return result.result;
+    };
+    return fn2;
+  }
+});
+function getStartResponseHeaders(opts) {
+  const headers = mergeHeaders(
+    {
+      "Content-Type": "text/html; charset=utf-8"
+    },
+    ...opts.router.state.matches.map((match) => {
+      return match.headers;
+    })
+  );
+  return headers;
+}
+let entriesPromise;
+let baseManifestPromise;
+let cachedFinalManifestPromise;
+async function loadEntries() {
+  const routerEntry = await import("./assets/router-1koL9I3U.js").then((n2) => n2.r);
+  const startEntry = await import("./assets/start-HYkvq4Ni.js");
+  return { startEntry, routerEntry };
+}
+function getEntries() {
+  if (!entriesPromise) {
+    entriesPromise = loadEntries();
+  }
+  return entriesPromise;
+}
+function getBaseManifest(matchedRoutes) {
+  if (!baseManifestPromise) {
+    baseManifestPromise = getStartManifest();
+  }
+  return baseManifestPromise;
+}
+async function resolveManifest(matchedRoutes, transformFn, cache) {
+  const base = await getBaseManifest();
+  const computeFinalManifest = async () => {
+    return transformFn ? await transformManifestUrls(base, transformFn, { clone: !cache }) : buildManifestWithClientEntry(base);
+  };
+  if (!transformFn || cache) {
+    if (!cachedFinalManifestPromise) {
+      cachedFinalManifestPromise = computeFinalManifest();
+    }
+    return cachedFinalManifestPromise;
+  }
+  return computeFinalManifest();
+}
+const ROUTER_BASEPATH = "/";
+const SERVER_FN_BASE = "/_serverFn/";
+const IS_PRERENDERING = process.env.TSS_PRERENDERING === "true";
+const IS_SHELL_ENV = process.env.TSS_SHELL === "true";
+const ERR_NO_RESPONSE = "Internal Server Error";
+const ERR_NO_DEFER = "Internal Server Error";
+function throwRouteHandlerError() {
+  throw new Error(ERR_NO_RESPONSE);
+}
+function throwIfMayNotDefer() {
+  throw new Error(ERR_NO_DEFER);
+}
+function isSpecialResponse(value) {
+  return value instanceof Response || isRedirect(value);
+}
+function handleCtxResult(result) {
+  if (isSpecialResponse(result)) {
+    return { response: result };
+  }
+  return result;
+}
+function executeMiddleware(middlewares, ctx) {
+  let index = -1;
+  const next = async (nextCtx) => {
+    if (nextCtx) {
+      if (nextCtx.context) {
+        ctx.context = safeObjectMerge(ctx.context, nextCtx.context);
+      }
+      for (const key of Object.keys(nextCtx)) {
+        if (key !== "context") {
+          ctx[key] = nextCtx[key];
+        }
+      }
+    }
+    index++;
+    const middleware = middlewares[index];
+    if (!middleware) return ctx;
+    let result;
+    try {
+      result = await middleware({ ...ctx, next });
+    } catch (err) {
+      if (isSpecialResponse(err)) {
+        ctx.response = err;
+        return ctx;
+      }
+      throw err;
+    }
+    const normalized = handleCtxResult(result);
+    if (normalized) {
+      if (normalized.response !== void 0) {
+        ctx.response = normalized.response;
+      }
+      if (normalized.context) {
+        ctx.context = safeObjectMerge(ctx.context, normalized.context);
+      }
+    }
+    return ctx;
+  };
+  return next();
+}
+function handlerToMiddleware(handler, mayDefer = false) {
+  if (mayDefer) {
+    return handler;
+  }
+  return async (ctx) => {
+    const response = await handler({ ...ctx, next: throwIfMayNotDefer });
+    if (!response) {
+      throwRouteHandlerError();
+    }
+    return response;
+  };
+}
+function createStartHandler(cbOrOptions) {
+  const cb = typeof cbOrOptions === "function" ? cbOrOptions : cbOrOptions.handler;
+  const transformAssetUrlsOption = typeof cbOrOptions === "function" ? void 0 : cbOrOptions.transformAssetUrls;
+  const warmupTransformManifest = !!transformAssetUrlsOption && typeof transformAssetUrlsOption === "object" && transformAssetUrlsOption.warmup === true;
+  const resolvedTransformConfig = transformAssetUrlsOption ? resolveTransformConfig(transformAssetUrlsOption) : void 0;
+  const cache = resolvedTransformConfig ? resolvedTransformConfig.cache : true;
+  let cachedCreateTransformPromise;
+  const getTransformFn = async (opts) => {
+    if (!resolvedTransformConfig) return void 0;
+    if (resolvedTransformConfig.type === "createTransform") {
+      if (cache) {
+        if (!cachedCreateTransformPromise) {
+          cachedCreateTransformPromise = Promise.resolve(
+            resolvedTransformConfig.createTransform(opts)
+          );
+        }
+        return cachedCreateTransformPromise;
+      }
+      return resolvedTransformConfig.createTransform(opts);
+    }
+    return resolvedTransformConfig.transformFn;
+  };
+  if (warmupTransformManifest && cache && true && !cachedFinalManifestPromise) {
+    const warmupPromise = (async () => {
+      const base = await getBaseManifest();
+      const transformFn = await getTransformFn({ warmup: true });
+      return transformFn ? await transformManifestUrls(base, transformFn, { clone: false }) : buildManifestWithClientEntry(base);
+    })();
+    cachedFinalManifestPromise = warmupPromise;
+    warmupPromise.catch(() => {
+      if (cachedFinalManifestPromise === warmupPromise) {
+        cachedFinalManifestPromise = void 0;
+      }
+      cachedCreateTransformPromise = void 0;
+    });
+  }
+  const startRequestResolver = async (request, requestOpts) => {
+    let router = null;
+    let cbWillCleanup = false;
+    try {
+      const { url, handledProtocolRelativeURL } = getNormalizedURL(request.url);
+      const href = url.pathname + url.search + url.hash;
+      const origin = getOrigin(request);
+      if (handledProtocolRelativeURL) {
+        return Response.redirect(url, 308);
+      }
+      const entries = await getEntries();
+      const startOptions = await entries.startEntry.startInstance?.getOptions() || {};
+      const serializationAdapters = [
+        ...startOptions.serializationAdapters || [],
+        ServerFunctionSerializationAdapter
+      ];
+      const requestStartOptions = {
+        ...startOptions,
+        serializationAdapters
+      };
+      const flattenedRequestMiddlewares = startOptions.requestMiddleware ? flattenMiddlewares(startOptions.requestMiddleware) : [];
+      const executedRequestMiddlewares = new Set(
+        flattenedRequestMiddlewares
+      );
+      const getRouter = async () => {
+        if (router) return router;
+        router = await entries.routerEntry.getRouter();
+        let isShell = IS_SHELL_ENV;
+        if (IS_PRERENDERING && !isShell) {
+          isShell = request.headers.get(HEADERS.TSS_SHELL) === "true";
+        }
+        const history = createMemoryHistory({
+          initialEntries: [href]
+        });
+        router.update({
+          history,
+          isShell,
+          isPrerendering: IS_PRERENDERING,
+          origin: router.options.origin ?? origin,
+          ...{
+            defaultSsr: requestStartOptions.defaultSsr,
+            serializationAdapters: [
+              ...requestStartOptions.serializationAdapters,
+              ...router.options.serializationAdapters || []
+            ]
+          },
+          basepath: ROUTER_BASEPATH
+        });
+        return router;
+      };
+      if (SERVER_FN_BASE && url.pathname.startsWith(SERVER_FN_BASE)) {
+        const serverFnId = url.pathname.slice(SERVER_FN_BASE.length).split("/")[0];
+        if (!serverFnId) {
+          throw new Error("Invalid server action param for serverFnId");
+        }
+        const serverFnHandler = async ({ context }) => {
+          return runWithStartContext(
+            {
+              getRouter,
+              startOptions: requestStartOptions,
+              contextAfterGlobalMiddlewares: context,
+              request,
+              executedRequestMiddlewares
+            },
+            () => handleServerAction({
+              request,
+              context: requestOpts?.context,
+              serverFnId
+            })
+          );
+        };
+        const middlewares2 = flattenedRequestMiddlewares.map(
+          (d) => d.options.server
+        );
+        const ctx2 = await executeMiddleware([...middlewares2, serverFnHandler], {
+          request,
+          pathname: url.pathname,
+          context: createNullProtoObject(requestOpts?.context)
+        });
+        return handleRedirectResponse(ctx2.response, request, getRouter);
+      }
+      const executeRouter = async (serverContext, matchedRoutes) => {
+        const acceptHeader = request.headers.get("Accept") || "*/*";
+        const acceptParts = acceptHeader.split(",");
+        const supportedMimeTypes = ["*/*", "text/html"];
+        const isSupported = supportedMimeTypes.some(
+          (mimeType) => acceptParts.some((part) => part.trim().startsWith(mimeType))
+        );
+        if (!isSupported) {
+          return Response.json(
+            { error: "Only HTML requests are supported here" },
+            { status: 500 }
+          );
+        }
+        const manifest2 = await resolveManifest(
+          matchedRoutes,
+          await getTransformFn({ warmup: false, request }),
+          cache
+        );
+        const routerInstance = await getRouter();
+        attachRouterServerSsrUtils({
+          router: routerInstance,
+          manifest: manifest2
+        });
+        routerInstance.update({ additionalContext: { serverContext } });
+        await routerInstance.load();
+        if (routerInstance.state.redirect) {
+          return routerInstance.state.redirect;
+        }
+        await routerInstance.serverSsr.dehydrate();
+        const responseHeaders = getStartResponseHeaders({
+          router: routerInstance
+        });
+        cbWillCleanup = true;
+        return cb({
+          request,
+          router: routerInstance,
+          responseHeaders
+        });
+      };
+      const requestHandlerMiddleware = async ({ context }) => {
+        return runWithStartContext(
+          {
+            getRouter,
+            startOptions: requestStartOptions,
+            contextAfterGlobalMiddlewares: context,
+            request,
+            executedRequestMiddlewares
+          },
+          async () => {
+            try {
+              return await handleServerRoutes({
+                getRouter,
+                request,
+                url,
+                executeRouter,
+                context,
+                executedRequestMiddlewares
+              });
+            } catch (err) {
+              if (err instanceof Response) {
+                return err;
+              }
+              throw err;
+            }
+          }
+        );
+      };
+      const middlewares = flattenedRequestMiddlewares.map(
+        (d) => d.options.server
+      );
+      const ctx = await executeMiddleware(
+        [...middlewares, requestHandlerMiddleware],
+        {
+          request,
+          pathname: url.pathname,
+          context: createNullProtoObject(requestOpts?.context)
+        }
+      );
+      return handleRedirectResponse(ctx.response, request, getRouter);
+    } finally {
+      if (router && !cbWillCleanup) {
+        router.serverSsr?.cleanup();
+      }
+      router = null;
+    }
+  };
+  return requestHandler(startRequestResolver);
+}
+async function handleRedirectResponse(response, request, getRouter) {
+  if (!isRedirect(response)) {
+    return response;
+  }
+  if (isResolvedRedirect(response)) {
+    if (request.headers.get("x-tsr-serverFn") === "true") {
+      return Response.json(
+        { ...response.options, isSerializedRedirect: true },
+        { headers: response.headers }
+      );
+    }
+    return response;
+  }
+  const opts = response.options;
+  if (opts.to && typeof opts.to === "string" && !opts.to.startsWith("/")) {
+    throw new Error(
+      `Server side redirects must use absolute paths via the 'href' or 'to' options. The redirect() method's "to" property accepts an internal path only. Use the "href" property to provide an external URL. Received: ${JSON.stringify(opts)}`
+    );
+  }
+  if (["params", "search", "hash"].some(
+    (d) => typeof opts[d] === "function"
+  )) {
+    throw new Error(
+      `Server side redirects must use static search, params, and hash values and do not support functional values. Received functional values for: ${Object.keys(
+        opts
+      ).filter((d) => typeof opts[d] === "function").map((d) => `"${d}"`).join(", ")}`
+    );
+  }
+  const router = await getRouter();
+  const redirect2 = router.resolveRedirect(response);
+  if (request.headers.get("x-tsr-serverFn") === "true") {
+    return Response.json(
+      { ...response.options, isSerializedRedirect: true },
+      { headers: response.headers }
+    );
+  }
+  return redirect2;
+}
+async function handleServerRoutes({
+  getRouter,
+  request,
+  url,
+  executeRouter,
+  context,
+  executedRequestMiddlewares
+}) {
+  const router = await getRouter();
+  const rewrittenUrl = executeRewriteInput(router.rewrite, url);
+  const pathname = rewrittenUrl.pathname;
+  const { matchedRoutes, foundRoute, routeParams } = router.getMatchedRoutes(pathname);
+  const isExactMatch = foundRoute && routeParams["**"] === void 0;
+  const routeMiddlewares = [];
+  for (const route of matchedRoutes) {
+    const serverMiddleware = route.options.server?.middleware;
+    if (serverMiddleware) {
+      const flattened = flattenMiddlewares(serverMiddleware);
+      for (const m2 of flattened) {
+        if (!executedRequestMiddlewares.has(m2)) {
+          routeMiddlewares.push(m2.options.server);
+        }
+      }
+    }
+  }
+  const server2 = foundRoute?.options.server;
+  if (server2?.handlers && isExactMatch) {
+    const handlers = typeof server2.handlers === "function" ? server2.handlers({ createHandlers: (d) => d }) : server2.handlers;
+    const requestMethod = request.method.toUpperCase();
+    const handler = handlers[requestMethod] ?? handlers["ANY"];
+    if (handler) {
+      const mayDefer = !!foundRoute.options.component;
+      if (typeof handler === "function") {
+        routeMiddlewares.push(handlerToMiddleware(handler, mayDefer));
+      } else {
+        if (handler.middleware?.length) {
+          const handlerMiddlewares = flattenMiddlewares(handler.middleware);
+          for (const m2 of handlerMiddlewares) {
+            routeMiddlewares.push(m2.options.server);
+          }
+        }
+        if (handler.handler) {
+          routeMiddlewares.push(handlerToMiddleware(handler.handler, mayDefer));
+        }
+      }
+    }
+  }
+  routeMiddlewares.push(
+    (ctx2) => executeRouter(ctx2.context, matchedRoutes)
+  );
+  const ctx = await executeMiddleware(routeMiddlewares, {
+    request,
+    context,
+    params: routeParams,
+    pathname
+  });
+  return ctx.response;
+}
+const fetch$1 = createStartHandler(defaultStreamHandler);
+function createServerEntry(entry) {
+  return {
+    async fetch(...args) {
+      return await entry.fetch(...args);
+    }
+  };
+}
+const server = createServerEntry({ fetch: fetch$1 });
+export {
+  TSS_SERVER_FUNCTION as T,
+  getCookie as a,
+  createServerFn as c,
+  createServerEntry,
+  server as default,
+  getServerFnById as g
+};