hermium 0.2.0 → 0.3.1

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

@@ -0,0 +1,4890 @@
+import { j as jsxRuntimeExports } from "../_libs/react.mjs";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { Readable, PassThrough } from "node:stream";
+import { r as renderRouterToStream, R as RouterProvider } from "../_libs/tanstack__react-router.mjs";
+import { e as defineHandlerCallback } from "../_libs/tanstack__router-core.mjs";
+import "../_libs/react-dom.mjs";
+import "util";
+import "crypto";
+import "async_hooks";
+import "stream";
+import "../_libs/isbot.mjs";
+import "../_libs/tanstack__history.mjs";
+import "node:stream/web";
+function StartServer(props) {
+  return /* @__PURE__ */ jsxRuntimeExports.jsx(RouterProvider, { router: props.router });
+}
+var defaultStreamHandler = defineHandlerCallback(({ request, router, responseHeaders }) => renderRouterToStream({
+  request,
+  router,
+  responseHeaders,
+  children: /* @__PURE__ */ jsxRuntimeExports.jsx(StartServer, { router })
+}));
+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 _needsNormRE = /(?:(?:^|\/)(?:\.|\.\.|%2e|%2e\.|\.%2e|%2e%2e)(?:\/|$))|[\\^\x80-\uffff]/i;
+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") if (url[0] === "/") this.#href = url;
+      else this.#url = new NativeURL(url);
+      else if (_needsNormRE.test(url.pathname)) this.#url = new NativeURL(`${url.protocol || "http:"}//${url.host || "localhost"}${url.pathname}${url.search || ""}`);
+      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;
+})();
+function decodePathname(pathname) {
+  return decodeURI(pathname.includes("%25") ? pathname.replace(/%25/g, "%2525") : pathname);
+}
+const kEventNS = "h3.internal.event.";
+const kEventRes = /* @__PURE__ */ Symbol.for(`${kEventNS}res`);
+const kEventResHeaders = /* @__PURE__ */ Symbol.for(`${kEventNS}res.headers`);
+const kEventResErrHeaders = /* @__PURE__ */ Symbol.for(`${kEventNS}res.err.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;
+    const url = _url && _url instanceof URL ? _url : new FastURL(req.url);
+    if (url.pathname.includes("%")) url.pathname = decodePathname(url.pathname);
+    this.url = 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();
+  }
+  get errHeaders() {
+    return this[kEventResErrHeaders] ||= 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?.statusCode || details?.cause?.status || details?.cause?.statusCode, 500);
+    const statusText = sanitizeStatusMessage(details?.statusText || details?.statusMessage || details?.cause?.statusText || details?.cause?.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;
+    const errHeaders = event[kEventRes]?.[kEventResErrHeaders];
+    return onError && !nested ? Promise.resolve(onError(error, event)).catch((error2) => error2).then((newVal) => prepareResponse(newVal ?? val, event, config, true)) : errorResponse(error, config.debug, errHeaders);
+  }
+  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, errHeaders) {
+  let headers = error.headers ? mergeHeaders$1(jsonHeaders, error.headers) : new Headers(jsonHeaders);
+  if (errHeaders) headers = mergeHeaders$1(headers, errHeaders);
+  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
+  });
+}
+var GLOBAL_EVENT_STORAGE_KEY = /* @__PURE__ */ Symbol.for("tanstack-start:event-storage");
+var globalObj$1 = globalThis;
+if (!globalObj$1[GLOBAL_EVENT_STORAGE_KEY]) globalObj$1[GLOBAL_EVENT_STORAGE_KEY] = new AsyncLocalStorage();
+var eventStorage = globalObj$1[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) => {
+    let h3Event;
+    try {
+      h3Event = new H3Event(request);
+    } catch (error) {
+      if (error instanceof URIError) return new Response(null, {
+        status: 400,
+        statusText: "Bad Request"
+      });
+      throw error;
+    }
+    return toResponse(attachResponseHeaders(eventStorage.run({ h3Event }, () => handler(request, requestOpts)), 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 getResponse() {
+  return getH3Event().res;
+}
+var HEADERS = { TSS_SHELL: "X-TSS_SHELL" };
+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 invariant() {
+  throw new Error("Invariant failed");
+}
+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;
+    }
+  };
+}
+function isNotFound(obj) {
+  return obj?.isNotFound === true;
+}
+const rootRouteId = "__root__";
+function isRedirect(obj) {
+  return obj instanceof Response && !!obj.options;
+}
+function isResolvedRedirect(obj) {
+  return isRedirect(obj) && !!obj.options.href;
+}
+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 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 }) => {
+    if (navigateOpts?.ignoreBlocker ?? false) {
+      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);
+      if (await blocker.blockerFn({
+        currentLocation: location,
+        nextLocation,
+        action: actionInfo.type
+      })) {
+        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,
+    __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 resolveManifestAssetLink(link) {
+  if (typeof link === "string") return {
+    href: link,
+    crossOrigin: void 0
+  };
+  return link;
+}
+function getStylesheetHref(asset) {
+  if (asset.tag !== "link") return void 0;
+  const rel = asset.attrs?.rel;
+  const href = asset.attrs?.href;
+  if (typeof href !== "string") return void 0;
+  if (!(typeof rel === "string" ? rel.split(/\s+/) : []).includes("stylesheet")) return void 0;
+  return href;
+}
+function isInlinableStylesheet(manifest2, asset) {
+  const href = getStylesheetHref(asset);
+  return !!href && manifest2?.inlineCss?.styles[href] !== void 0;
+}
+function createInlineCssStyleAsset(css) {
+  return {
+    tag: "style",
+    attrs: { suppressHydrationWarning: true },
+    inlineCss: true,
+    children: css
+  };
+}
+function createInlineCssPlaceholderAsset() {
+  return {
+    tag: "style",
+    attrs: { suppressHydrationWarning: true },
+    inlineCss: true
+  };
+}
+const GLOBAL_TSR = "$_TSR";
+const TSR_SCRIPT_BARRIER_ID = "$tsr-stream-barrier";
+var M = ((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))(M || {});
+var v = Symbol.asyncIterator, pr = Symbol.hasInstance, R = Symbol.isConcatSpreadable, C = Symbol.iterator, dr = Symbol.match, gr = Symbol.matchAll, yr = Symbol.replace, Nr = Symbol.search, br = Symbol.species, vr = Symbol.split, Cr = Symbol.toPrimitive, P$1 = Symbol.toStringTag, Ar = Symbol.unscopables;
+var tt = { 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, [pr]: 1, [R]: 2, [C]: 3, [dr]: 4, [gr]: 5, [yr]: 6, [Nr]: 7, [br]: 8, [vr]: 9, [Cr]: 10, [P$1]: 11, [Ar]: 12 }, nt = { 0: v, 1: pr, 2: R, 3: C, 4: dr, 5: gr, 6: yr, 7: Nr, 8: br, 9: vr, 10: Cr, 11: P$1, 12: Ar }, ot = { 2: "!0", 3: "!1", 1: "void 0", 0: "null", 4: "-0", 5: "1/0", 6: "-1/0", 7: "0/0" }, o = void 0, at = { 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" }, st = { 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 B(e) {
+  return c(2, o, e, o, o, o, o, o, o, o, o, o);
+}
+var H = B(2), J = B(3), Ae = B(1), Ee = B(0), it = B(4), ut = B(5), lt = B(6), ct = B(7);
+function mn(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 = mn(e[a]), n2 && (r += e.slice(t, a) + n2, t = a + 1);
+  return t === 0 ? r = e : r += e.slice(t), r;
+}
+function pn(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 D(e) {
+  return e.replace(/(\\\\|\\"|\\n|\\r|\\b|\\t|\\f|\\u2028|\\u2029|\\x3C)/g, pn);
+}
+var L = "__SEROVAL_REFS__", le = "$R", Ie = `self.${le}`;
+function dn(e) {
+  return `(${Ie}=${Ie}||{})["${y(e)}"]=[]`;
+}
+var Er = /* @__PURE__ */ new Map(), U = /* @__PURE__ */ new Map();
+function Ir(e) {
+  return Er.has(e);
+}
+function yn(e) {
+  return U.has(e);
+}
+function ft(e) {
+  if (Ir(e)) return Er.get(e);
+  throw new Re(e);
+}
+function St(e) {
+  if (yn(e)) return U.get(e);
+  throw new Pe(e);
+}
+typeof globalThis != "undefined" ? Object.defineProperty(globalThis, L, { value: U, configurable: true, writable: false, enumerable: false }) : typeof window != "undefined" ? Object.defineProperty(window, L, { value: U, configurable: true, writable: false, enumerable: false }) : typeof self != "undefined" ? Object.defineProperty(self, L, { value: U, configurable: true, writable: false, enumerable: false }) : typeof global != "undefined" && Object.defineProperty(global, L, { value: U, 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 Nn(e) {
+  let r = Ce[xe(e)];
+  return e.name !== r ? { name: e.name } : e.constructor.name !== r ? { name: e.constructor.name } : {};
+}
+function Z(e, r) {
+  let t = Nn(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 Te(e) {
+  return Object.isFrozen(e) ? 3 : Object.isSealed(e) ? 2 : Object.isExtensible(e) ? 0 : 1;
+}
+function Oe(e) {
+  switch (e) {
+    case Number.POSITIVE_INFINITY:
+      return ut;
+    case Number.NEGATIVE_INFINITY:
+      return lt;
+  }
+  return e !== e ? ct : Object.is(e, -0) ? it : c(0, o, e, o, o, o, o, o, o, o, o, o);
+}
+function $(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 pt(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 dt(e, r) {
+  return c(17, e, ve[r], o, o, o, o, o, o, o, o, o);
+}
+function gt(e, r) {
+  return c(18, e, y(ft(r)), o, o, o, o, o, o, o, o, o);
+}
+function ce(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, Te(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 bn = { parsing: 1, serialization: 2, deserialization: 3 };
+function vn(e) {
+  return `Seroval Error (step: ${bn[e]})`;
+}
+var Cn = (e, r) => vn(e), fe = class extends Error {
+  constructor(t, n2) {
+    super(Cn(t));
+    this.cause = n2;
+  }
+}, z = class extends fe {
+  constructor(r) {
+    super("parsing", r);
+  }
+}, He = class extends fe {
+  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;
+  }
+}, h = class extends Error {
+  constructor(r) {
+    super(_(2));
+  }
+}, X = 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));
+  }
+}, O = class extends Error {
+  constructor(r) {
+    super(_(8));
+  }
+}, Q = class extends Error {
+  constructor(r) {
+    super(_(9));
+  }
+};
+var j = class {
+  constructor(r, t) {
+    this.value = r;
+    this.replacement = t;
+  }
+};
+var ee$1 = () => {
+  let e = { p: 0, s: 0, f: 0 };
+  return e.p = new Promise((r, t) => {
+    e.s = r, e.f = t;
+  }), e;
+}, An = (e, r) => {
+  e.s(r), e.p.s = 1, e.p.v = r;
+}, En = (e, r) => {
+  e.f(r), e.p.s = 2, e.p.v = r;
+}, Nt = ee$1.toString(), bt = An.toString(), vt = En.toString(), Pr = () => {
+  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);
+  } };
+}, Ct = Pr.toString(), xr = (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;
+}, At = xr.toString(), Tr = (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 G = n2++;
+      if (G >= i.length) {
+        let rt = r();
+        return u.push(rt), rt.p;
+      }
+      return { done: false, value: i[G] };
+    }
+    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;
+}, Et = Tr.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;
+}, It = Or.toString();
+function Ze(e) {
+  return "__SEROVAL_SEQUENCE__" in e;
+}
+function wr(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 wr(r, t, n2);
+}
+var In = xr(C);
+function Rt(e) {
+  return In(e);
+}
+var Pt = {}, xt = {};
+var Tt = { 0: {}, 1: {}, 2: {}, 3: {}, 4: {}, 5: {} }, Ot = { 0: "[]", 1: Nt, 2: bt, 3: vt, 4: Ct, 5: It };
+function Xe(e) {
+  return "__SEROVAL_STREAM__" in e;
+}
+function re() {
+  return Pr();
+}
+function Qe(e) {
+  let r = re(), 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 Rn = Tr(v, ee$1);
+function wt(e) {
+  return Rn(e);
+}
+async function hr(e) {
+  try {
+    return [1, await e];
+  } catch (r) {
+    return [0, r];
+  }
+}
+function me(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 pe(e, r) {
+  e.marked.add(r);
+}
+function zr(e, r) {
+  let t = e.refs.size;
+  return e.refs.set(r, t), t;
+}
+function er(e, r) {
+  let t = e.refs.get(r);
+  return t != null ? (pe(e, t), { type: 1, value: pt(t) }) : { type: 0, value: zr(e, r) };
+}
+function Y(e, r) {
+  let t = er(e, r);
+  return t.type === 1 ? t : Ir(r) ? { type: 2, value: gt(t.value, r) } : t;
+}
+function I(e, r) {
+  let t = Y(e, r);
+  if (t.type !== 0) return t.value;
+  if (r in ve) return dt(t.value, r);
+  throw new x$1(r);
+}
+function k(e, r) {
+  let t = er(e, Tt[r]);
+  return t.type === 1 ? t.value : c(26, t.value, r, o, o, o, o, o, o, o, o, o);
+}
+function rr(e) {
+  let r = er(e, Pt);
+  return r.type === 1 ? r.value : c(27, r.value, o, o, o, o, o, o, I(e, C), o, o, o);
+}
+function tr(e) {
+  let r = er(e, xt);
+  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 nr(e, r, t, n2) {
+  return c(t ? 11 : 10, e, o, o, o, n2, o, o, o, o, Te(r), o);
+}
+function or(e, r, t, n2) {
+  return c(8, r, o, o, o, o, { k: t, v: n2 }, o, k(e, 0), o, o, o);
+}
+function zt(e, r, t) {
+  return c(22, r, t, o, o, o, o, o, k(e, 1), o, o, o);
+}
+function ar(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 te(e, r) {
+  return { base: me(e, r), child: void 0 };
+}
+var kr = class {
+  constructor(r, t) {
+    this._p = r;
+    this.depth = t;
+  }
+  parse(r) {
+    return N(this._p, this.depth, r);
+  }
+};
+async function xn(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 Tn(e, r, t, n2) {
+  return _e(t, n2, await xn(e, r, n2));
+}
+async function Dr(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(rr(e.base), await N(e, r, $e(t))))), v in t && (a.push(I(e.base, v)), s.push(je(tr(e.base), await N(e, r, Qe(t))))), P$1 in t && (a.push(I(e.base, P$1)), s.push($(t[P$1]))), R in t && (a.push(I(e.base, R)), s.push(t[R] ? H : J)), { k: a, v: s };
+}
+async function _r(e, r, t, n2, a) {
+  return nr(t, n2, a, await Dr(e, r, n2));
+}
+async function On(e, r, t, n2) {
+  return ke(t, await N(e, r, n2.valueOf()));
+}
+async function wn(e, r, t, n2) {
+  return De(t, n2, await N(e, r, n2.buffer));
+}
+async function hn(e, r, t, n2) {
+  return Fe(t, n2, await N(e, r, n2.buffer));
+}
+async function zn(e, r, t, n2) {
+  return Be(t, n2, await N(e, r, n2.buffer));
+}
+async function _t(e, r, t, n2) {
+  let a = Z(n2, e.base.features);
+  return Ve(t, n2, a ? await Dr(e, r, a) : o);
+}
+async function _n(e, r, t, n2) {
+  let a = Z(n2, e.base.features);
+  return Me(t, n2, a ? await Dr(e, r, a) : o);
+}
+async function kn(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 or(e.base, t, a, s);
+}
+async function Dn(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 kt(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 ce(t, u.tag, await u.parse.async(n2, new kr(e, r), { id: t }));
+  }
+  return o;
+}
+async function Fn(e, r, t, n2) {
+  let [a, s] = await hr(n2);
+  return c(12, t, a, o, o, o, o, o, await N(e, r, s), o, o, o);
+}
+function Bn(e, r, t, n2, a) {
+  let s = [], i = t.on({ next: (u) => {
+    pe(this.base, r), N(this, e, u).then((l) => {
+      s.push(qe(r, l));
+    }, (l) => {
+      a(l), i();
+    });
+  }, throw: (u) => {
+    pe(this.base, r), N(this, e, u).then((l) => {
+      s.push(We(r, l)), n2(s), i();
+    }, (l) => {
+      a(l), i();
+    });
+  }, return: (u) => {
+    pe(this.base, r), N(this, e, u).then((l) => {
+      s.push(Ge(r, l)), n2(s), i();
+    }, (l) => {
+      a(l), i();
+    });
+  } });
+}
+async function Vn(e, r, t, n2) {
+  return Ye(t, k(e.base, 4), await new Promise(Bn.bind(e, r, t, n2)));
+}
+async function Mn(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 Ln(e, r, t, n2) {
+  if (Array.isArray(n2)) return Tn(e, r, t, n2);
+  if (Xe(n2)) return Vn(e, r, t, n2);
+  if (Ze(n2)) return Mn(e, r, t, n2);
+  let a = n2.constructor;
+  if (a === j) return N(e, r, n2.replacement);
+  let s = await kt(e, r, t, n2);
+  if (s) return s;
+  switch (a) {
+    case Object:
+      return _r(e, r, t, n2, false);
+    case o:
+      return _r(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 _t(e, r, t, n2);
+    case Number:
+    case Boolean:
+    case String:
+    case BigInt:
+      return On(e, r, t, n2);
+    case ArrayBuffer:
+      return ar(e.base, t, n2);
+    case Int8Array:
+    case Int16Array:
+    case Int32Array:
+    case Uint8Array:
+    case Uint16Array:
+    case Uint32Array:
+    case Uint8ClampedArray:
+    case Float32Array:
+    case Float64Array:
+      return wn(e, r, t, n2);
+    case DataView:
+      return zn(e, r, t, n2);
+    case Map:
+      return kn(e, r, t, n2);
+    case Set:
+      return Dn(e, r, t, n2);
+  }
+  if (a === Promise || n2 instanceof Promise) return Fn(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 hn(e, r, t, n2);
+  }
+  if (i & 1 && typeof AggregateError != "undefined" && (a === AggregateError || n2 instanceof AggregateError)) return _n(e, r, t, n2);
+  if (n2 instanceof Error) return _t(e, r, t, n2);
+  if (C in n2 || v in n2) return _r(e, r, t, n2, !!a);
+  throw new x$1(n2);
+}
+async function Un(e, r, t) {
+  let n2 = Y(e.base, t);
+  if (n2.type !== 0) return n2.value;
+  let a = await kt(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 ? H : J;
+    case "undefined":
+      return Ae;
+    case "string":
+      return $(t);
+    case "number":
+      return Oe(t);
+    case "bigint":
+      return we(t);
+    case "object": {
+      if (t) {
+        let n2 = Y(e.base, t);
+        return n2.type === 0 ? await Ln(e, r + 1, n2.value, t) : n2.value;
+      }
+      return Ee;
+    }
+    case "symbol":
+      return I(e.base, t);
+    case "function":
+      return Un(e, r, t);
+    default:
+      throw new x$1(t);
+  }
+}
+async function ne(e, r) {
+  try {
+    return await N(e, 0, r);
+  } catch (t) {
+    throw t instanceof z ? t : new z(t);
+  }
+}
+var oe = ((t) => (t[t.Vanilla = 1] = "Vanilla", t[t.Cross = 2] = "Cross", t))(oe || {});
+function ai(e) {
+  return e;
+}
+function Dt(e, r) {
+  for (let t = 0, n2 = r.length; t < n2; t++) {
+    let a = r[t];
+    e.has(a) || (e.add(a), a.extends && Dt(e, a.extends));
+  }
+}
+function A(e) {
+  if (e) {
+    let r = /* @__PURE__ */ new Set();
+    return Dt(r, e), [...r];
+  }
+}
+function Ft(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 jn = 1e6, Yn = 1e4, qn = 2e4;
+function Vt(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 Wn = 1e3;
+function Mt(e, r) {
+  var n2;
+  let t = r.refs || /* @__PURE__ */ new Map();
+  return "types" in t || Object.assign(t, { types: /* @__PURE__ */ new Map() }), { mode: e, plugins: r.plugins, refs: t, features: (n2 = r.features) != null ? n2 : 63 ^ (r.disabledFeatures || 0), depthLimit: r.depthLimit || Wn };
+}
+function Lt(e) {
+  return { mode: 1, base: Mt(1, e), child: o, state: { marked: new Set(e.markedRefs) } };
+}
+var Fr = class {
+  constructor(r, t) {
+    this._p = r;
+    this.depth = t;
+  }
+  deserialize(r) {
+    return p$1(this._p, this.depth, r);
+  }
+};
+function jt(e, r) {
+  if (r < 0 || !Number.isFinite(r) || !Number.isInteger(r)) throw new O({ t: 4, i: r });
+  if (e.refs.has(r)) throw new Error("Conflicted ref id: " + r);
+}
+function Gn(e, r, t) {
+  return jt(e.base, r), e.state.marked.has(r) && e.base.refs.set(r, t), t;
+}
+function Kn(e, r, t) {
+  return jt(e.base, r), e.base.refs.set(r, t), t;
+}
+function b(e, r, t) {
+  return e.mode === 1 ? Gn(e, r, t) : Kn(e, r, t);
+}
+function Br(e, r, t) {
+  if (Object.hasOwn(r, t)) return r[t];
+  throw new O(e);
+}
+function Hn(e, r) {
+  return b(e, r.i, St(D(r.s)));
+}
+function Jn(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 Vt(s, t.o), s;
+}
+function Zn(e) {
+  switch (e) {
+    case "constructor":
+    case "__proto__":
+    case "prototype":
+    case "__defineGetter__":
+    case "__defineSetter__":
+    case "__lookupGetter__":
+    case "__lookupSetter__":
+      return false;
+    default:
+      return true;
+  }
+}
+function $n(e) {
+  switch (e) {
+    case v:
+    case R:
+    case P$1:
+    case C:
+      return true;
+    default:
+      return false;
+  }
+}
+function Bt(e, r, t) {
+  Zn(r) ? e[r] = t : Object.defineProperty(e, r, { value: t, configurable: true, enumerable: true, writable: true });
+}
+function Xn(e, r, t, n2, a) {
+  if (typeof n2 == "string") Bt(t, D(n2), p$1(e, r, a));
+  else {
+    let s = p$1(e, r, n2);
+    switch (typeof s) {
+      case "string":
+        Bt(t, s, p$1(e, r, a));
+        break;
+      case "symbol":
+        $n(s) && (t[s] = p$1(e, r, a));
+        break;
+      default:
+        throw new O(n2);
+    }
+  }
+}
+function Yt(e, r, t) {
+  e.base.refs.types.set(r, t);
+}
+function de(e, r, t, n2) {
+  if (e.base.refs.types.get(t) !== n2) throw new O(r);
+}
+function qt(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++) Xn(e, r, n2, a[i], u[i]);
+  return n2;
+}
+function Qn(e, r, t) {
+  let n2 = b(e, t.i, t.t === 10 ? {} : /* @__PURE__ */ Object.create(null));
+  return qt(e, r, t.p, n2), Vt(n2, t.o), n2;
+}
+function eo(e, r) {
+  return b(e, r.i, new Date(r.s));
+}
+function ro(e, r) {
+  if (e.base.features & 32) {
+    let t = D(r.c);
+    if (t.length > qn) throw new O(r);
+    return b(e, r.i, new RegExp(t, r.m));
+  }
+  throw new h(r);
+}
+function to(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 no(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 oo(e, r) {
+  if (r.s.length > jn) throw new O(r);
+  return b(e, r.i, Or(D(r.s)));
+}
+function ao(e, r, t) {
+  var u;
+  let n2 = Ft(t.c), a = p$1(e, r, t.f), s = (u = t.b) != null ? u : 0;
+  if (s < 0 || s > a.byteLength) throw new O(t);
+  return b(e, t.i, new n2(a, s, t.l));
+}
+function so(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 O(t);
+  return b(e, t.i, new DataView(n2, a, t.l));
+}
+function Wt(e, r, t, n2) {
+  if (t.p) {
+    let a = qt(e, r, t.p, {});
+    Object.defineProperties(n2, Object.getOwnPropertyDescriptors(a));
+  }
+  return n2;
+}
+function io(e, r, t) {
+  let n2 = b(e, t.i, new AggregateError([], D(t.m)));
+  return Wt(e, r, t, n2);
+}
+function uo(e, r, t) {
+  let n2 = Br(t, st, t.s), a = b(e, t.i, new n2(D(t.m)));
+  return Wt(e, r, t, a);
+}
+function lo(e, r, t) {
+  let n2 = ee$1(), 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 co(e, r, t) {
+  return b(e, t.i, Object(p$1(e, r, t.f)));
+}
+function fo(e, r, t) {
+  let n2 = e.base.plugins;
+  if (n2) {
+    let a = D(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 Fr(e, r), { id: t.i }));
+    }
+  }
+  throw new X(t.c);
+}
+function So(e, r) {
+  let t = b(e, r.i, b(e, r.s, ee$1()).p);
+  return Yt(e, r.s, 22), t;
+}
+function mo(e, r, t) {
+  let n2 = e.base.refs.get(t.i);
+  if (n2) return de(e, t, t.i, 22), n2.s(p$1(e, r, t.a[1])), o;
+  throw new V("Promise");
+}
+function po(e, r, t) {
+  let n2 = e.base.refs.get(t.i);
+  if (n2) return de(e, t, t.i, 22), n2.f(p$1(e, r, t.a[1])), o;
+  throw new V("Promise");
+}
+function go(e, r, t) {
+  p$1(e, r, t.a[0]);
+  let n2 = p$1(e, r, t.a[1]);
+  return Rt(n2);
+}
+function yo(e, r, t) {
+  p$1(e, r, t.a[0]);
+  let n2 = p$1(e, r, t.a[1]);
+  return wt(n2);
+}
+function No(e, r, t) {
+  let n2 = b(e, t.i, re());
+  Yt(e, t.i, 31);
+  let a = t.a, s = a.length;
+  if (s) for (let i = 0; i < s; i++) p$1(e, r, a[i]);
+  return n2;
+}
+function bo(e, r, t) {
+  let n2 = e.base.refs.get(t.i);
+  if (n2) return de(e, t, t.i, 31), n2.next(p$1(e, r, t.f)), o;
+  throw new V("Stream");
+}
+function vo(e, r, t) {
+  let n2 = e.base.refs.get(t.i);
+  if (n2) return de(e, t, t.i, 31), n2.throw(p$1(e, r, t.f)), o;
+  throw new V("Stream");
+}
+function Co(e, r, t) {
+  let n2 = e.base.refs.get(t.i);
+  if (n2) return de(e, t, t.i, 31), n2.return(p$1(e, r, t.f)), o;
+  throw new V("Stream");
+}
+function Ao(e, r, t) {
+  return p$1(e, r, t.f), o;
+}
+function Eo(e, r, t) {
+  return p$1(e, r, t.a[1]), o;
+}
+function Io(e, r, t) {
+  let n2 = b(e, t.i, wr([], 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 Q(e.base.depthLimit);
+  switch (r += 1, t.t) {
+    case 2:
+      return Br(t, at, t.s);
+    case 0:
+      return Number(t.s);
+    case 1:
+      return D(String(t.s));
+    case 3:
+      if (String(t.s).length > Yn) throw new O(t);
+      return BigInt(t.s);
+    case 4:
+      return e.base.refs.get(t.i);
+    case 18:
+      return Hn(e, t);
+    case 9:
+      return Jn(e, r, t);
+    case 10:
+    case 11:
+      return Qn(e, r, t);
+    case 5:
+      return eo(e, t);
+    case 6:
+      return ro(e, t);
+    case 7:
+      return to(e, r, t);
+    case 8:
+      return no(e, r, t);
+    case 19:
+      return oo(e, t);
+    case 16:
+    case 15:
+      return ao(e, r, t);
+    case 20:
+      return so(e, r, t);
+    case 14:
+      return io(e, r, t);
+    case 13:
+      return uo(e, r, t);
+    case 12:
+      return lo(e, r, t);
+    case 17:
+      return Br(t, nt, t.s);
+    case 21:
+      return co(e, r, t);
+    case 25:
+      return fo(e, r, t);
+    case 22:
+      return So(e, t);
+    case 23:
+      return mo(e, r, t);
+    case 24:
+      return po(e, r, t);
+    case 28:
+      return go(e, r, t);
+    case 30:
+      return yo(e, r, t);
+    case 31:
+      return No(e, r, t);
+    case 32:
+      return bo(e, r, t);
+    case 33:
+      return vo(e, r, t);
+    case 34:
+      return Co(e, r, t);
+    case 27:
+      return Ao(e, r, t);
+    case 29:
+      return Eo(e, r, t);
+    case 35:
+      return Io(e, r, t);
+    default:
+      throw new h(t);
+  }
+}
+function sr(e, r) {
+  try {
+    return p$1(e, 0, r);
+  } catch (t) {
+    throw new He(t);
+  }
+}
+var Ro = () => T, Po = Ro.toString(), Gt = /=>/.test(Po);
+function ir(e, r) {
+  return Gt ? (e.length === 1 ? e[0] : "(" + e.join(",") + ")") + "=>" + (r.startsWith("{") ? "(" + r + ")" : r) : "function(" + e.join(",") + "){return " + r + "}";
+}
+function Kt(e, r) {
+  return Gt ? (e.length === 1 ? e[0] : "(" + e.join(",") + ")") + "=>{" + r + "}" : "function(" + e.join(",") + "){" + r + "}";
+}
+var Zt = "hjkmoquxzABCDEFGHIJKLNPQRTUVWXYZ$_", Ht = Zt.length, $t = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789$_", Jt = $t.length;
+function Vr(e) {
+  let r = e % Ht, t = Zt[r];
+  for (e = (e - r) / Ht; e > 0; ) r = e % Jt, t += $t[r], e = (e - r) / Jt;
+  return t;
+}
+var xo = /^[$A-Z_][0-9A-Z_$]*$/i;
+function Mr(e) {
+  let r = e[0];
+  return (r === "$" || r === "_" || r >= "A" && r <= "Z" || r >= "a" && r <= "z") && xo.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 To(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 on(e) {
+  if (e.length) {
+    let r = "", t = To(e);
+    for (let n2 = 0, a = t.length; n2 < a; n2++) r += ye(t[n2]) + ",";
+    return r;
+  }
+  return o;
+}
+var Oo = "Object.create(null)", wo = "new Set", ho = "new Map", zo = "Promise.resolve", _o = "Promise.reject", ko = { 3: "Object.freeze", 2: "Object.seal", 1: "Object.preventExtensions", 0: o };
+function an(e, r) {
+  return { mode: e, plugins: r.plugins, features: r.features, marked: new Set(r.markedRefs), stack: [], flags: [], assignments: [] };
+}
+function lr(e) {
+  return { mode: 2, base: an(2, e), state: e, child: o };
+}
+var Lr = class {
+  constructor(r) {
+    this._p = r;
+  }
+  serialize(r) {
+    return f(this._p, r);
+  }
+};
+function Fo(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 = Vr(t), e.vars[t] = n2), n2;
+}
+function Bo(e) {
+  return le + "[" + e + "]";
+}
+function m(e, r) {
+  return e.mode === 1 ? Fo(e.state, r) : Bo(r);
+}
+function w$1(e, r) {
+  e.marked.add(r);
+}
+function Ur(e, r) {
+  return e.marked.has(r);
+}
+function Yr(e, r, t) {
+  r !== 0 && (w$1(e.base, t), e.base.flags.push({ type: r, value: m(e, t) }));
+}
+function Vo(e) {
+  let r = "";
+  for (let t = 0, n2 = e.flags, a = n2.length; t < a; t++) {
+    let s = n2[t];
+    r += ko[s.type] + "(" + s.value + "),";
+  }
+  return r;
+}
+function sn(e) {
+  let r = on(e.assignments), t = Vo(e);
+  return r ? t ? r + t : r : t;
+}
+function qr(e, r, t) {
+  e.assignments.push({ t: 0, s: r, k: o, v: t });
+}
+function Mo(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 Xt(e, r, t) {
+  e.base.assignments.push({ t: 3, s: m(e, r), k: t, v: o });
+}
+function Ne(e, r, t, n2) {
+  qr(e.base, m(e, r) + "[" + t + "]", n2);
+}
+function jr(e, r, t, n2) {
+  qr(e.base, m(e, r) + "." + t, n2);
+}
+function Lo(e, r, t, n2) {
+  qr(e.base, m(e, r) + ".v[" + t + "]", n2);
+}
+function F(e, r) {
+  return r.t === 4 && e.stack.includes(r.i);
+}
+function ae(e, r, t) {
+  return e.mode === 1 && !Ur(e.base, r) ? t : m(e, r) + "=" + t;
+}
+function Uo(e) {
+  return L + '.get("' + e.s + '")';
+}
+function Qt(e, r, t, n2) {
+  return t ? F(e.base, t) ? (w$1(e.base, r), Ne(e, r, n2, m(e, t.i)), "") : f(e, t) : "";
+}
+function jo(e, r) {
+  let t = r.i, n2 = r.a, a = n2.length;
+  if (a > 0) {
+    e.base.stack.push(t);
+    let s = Qt(e, t, n2[0], 0), i = s === "";
+    for (let u = 1, l; u < a; u++) l = Qt(e, t, n2[u], u), s += "," + l, i = l === "";
+    return e.base.stack.pop(), Yr(e, r.o, r.i), "[" + s + (i ? ",]" : "]");
+  }
+  return "[]";
+}
+function en(e, r, t, n2) {
+  if (typeof t == "string") {
+    let a = Number(t), s = a >= 0 && a.toString() === t || Mr(t);
+    if (F(e.base, n2)) {
+      let i = m(e, n2.i);
+      return w$1(e.base, r.i), s && a !== a ? jr(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 un(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 = en(e, r, n2[0], s[0]);
+    for (let u = 1, l = i; u < a; u++) l = en(e, r, n2[u], s[u]), i += (l && i && ",") + l;
+    return e.base.stack.pop(), "{" + i + "}";
+  }
+  return "{}";
+}
+function Yo(e, r) {
+  return Yr(e, r.o, r.i), un(e, r, r.p);
+}
+function qo(e, r, t, n2) {
+  let a = un(e, r, t);
+  return a !== "{}" ? "Object.assign(" + n2 + "," + a + ")" : n2;
+}
+function Wo(e, r, t, n2, a) {
+  let s = e.base, i = f(e, a), u = Number(n2), l = u >= 0 && u.toString() === n2 || Mr(n2);
+  if (F(s, a)) l && u !== u ? jr(e, r.i, n2, i) : Ne(e, r.i, l ? n2 : '"' + n2 + '"', i);
+  else {
+    let g = s.assignments;
+    s.assignments = t, l && u !== u ? jr(e, r.i, n2, i) : Ne(e, r.i, l ? n2 : '"' + n2 + '"', i), s.assignments = g;
+  }
+}
+function Go(e, r, t, n2, a) {
+  if (typeof n2 == "string") Wo(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 Ko(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++) Go(e, r, s, n2[u], i[u]);
+    return e.base.stack.pop(), on(s);
+  }
+  return o;
+}
+function Wr(e, r, t) {
+  if (r.p) {
+    let n2 = e.base;
+    if (n2.features & 8) t = qo(e, r, r.p, t);
+    else {
+      w$1(n2, r.i);
+      let a = Ko(e, r, r.p);
+      if (a) return "(" + ae(e, r.i, t) + "," + a + m(e, r.i) + ")";
+    }
+  }
+  return t;
+}
+function Ho(e, r) {
+  return Yr(e, r.o, r.i), Wr(e, r, Oo);
+}
+function Jo(e) {
+  return 'new Date("' + e.s + '")';
+}
+function Zo(e, r) {
+  if (e.base.features & 32) return "/" + r.c + "/" + r.m;
+  throw new h(r);
+}
+function rn(e, r, t) {
+  let n2 = e.base;
+  return F(n2, t) ? (w$1(n2, r), Mo(e, r, m(e, t.i)), "") : f(e, t);
+}
+function $o(e, r) {
+  let t = wo, n2 = r.a, a = n2.length, s = r.i;
+  if (a > 0) {
+    e.base.stack.push(s);
+    let i = rn(e, s, n2[0]);
+    for (let u = 1, l = i; u < a; u++) l = rn(e, s, n2[u]), i += (l && i && ",") + l;
+    e.base.stack.pop(), i && (t += "([" + i + "])");
+  }
+  return t;
+}
+function tn(e, r, t, n2, a) {
+  let s = e.base;
+  if (F(s, t)) {
+    let i = m(e, t.i);
+    if (w$1(s, r), F(s, n2)) {
+      let l = m(e, n2.i);
+      return ge(e, r, i, l), "";
+    }
+    if (n2.t !== 4 && n2.i != null && Ur(s, n2.i)) {
+      let l = "(" + f(e, n2) + ",[" + a + "," + a + "])";
+      return ge(e, r, i, m(e, n2.i)), Xt(e, r, a), l;
+    }
+    let u = s.stack;
+    return s.stack = [], ge(e, r, i, f(e, n2)), s.stack = u, "";
+  }
+  if (F(s, n2)) {
+    let i = m(e, n2.i);
+    if (w$1(s, r), t.t !== 4 && t.i != null && Ur(s, t.i)) {
+      let l = "(" + f(e, t) + ",[" + a + "," + a + "])";
+      return ge(e, r, m(e, t.i), i), Xt(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 Xo(e, r) {
+  let t = ho, 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 = tn(e, s, n2[0], g[0], u);
+    for (let d = 1, G = S; d < a; d++) G = tn(e, s, n2[d], g[d], u), S += (G && S && ",") + G;
+    l.stack.pop(), S && (t += "([" + S + "])");
+  }
+  return i.t === 26 && (w$1(l, i.i), t = "(" + f(e, i) + "," + t + ")"), t;
+}
+function Qo(e, r) {
+  return q(e, r.f) + '("' + r.s + '")';
+}
+function ea(e, r) {
+  return "new " + r.c + "(" + f(e, r.f) + "," + r.b + "," + r.l + ")";
+}
+function ra(e, r) {
+  return "new DataView(" + f(e, r.f) + "," + r.b + "," + r.l + ")";
+}
+function ta(e, r) {
+  let t = r.i;
+  e.base.stack.push(t);
+  let n2 = Wr(e, r, 'new AggregateError([],"' + r.m + '")');
+  return e.base.stack.pop(), n2;
+}
+function na(e, r) {
+  return Wr(e, r, "new " + Ce[r.s] + '("' + r.m + '")');
+}
+function oa(e, r) {
+  let t, n2 = r.f, a = r.i, s = r.s ? zo : _o, i = e.base;
+  if (F(i, n2)) {
+    let u = m(e, n2.i);
+    t = s + (r.s ? "().then(" + ir([], u) + ")" : "().catch(" + Kt([], "throw " + u) + ")");
+  } else {
+    i.stack.push(a);
+    let u = f(e, n2);
+    i.stack.pop(), t = s + "(" + u + ")";
+  }
+  return t;
+}
+function aa(e, r) {
+  return "Object(" + f(e, r.f) + ")";
+}
+function q(e, r) {
+  let t = f(e, r);
+  return r.t === 4 ? t : "(" + t + ")";
+}
+function sa(e, r) {
+  if (e.mode === 1) throw new h(r);
+  return "(" + ae(e, r.s, q(e, r.f) + "()") + ").p";
+}
+function ia(e, r) {
+  if (e.mode === 1) throw new h(r);
+  return q(e, r.a[0]) + "(" + m(e, r.i) + "," + f(e, r.a[1]) + ")";
+}
+function ua(e, r) {
+  if (e.mode === 1) throw new h(r);
+  return q(e, r.a[0]) + "(" + m(e, r.i) + "," + f(e, r.a[1]) + ")";
+}
+function la(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 Lr(e)), s.serialize(r.s, e.child, { id: r.i });
+  }
+  throw new X(r.c);
+}
+function ca(e, r) {
+  let t = "", n2 = false;
+  return r.f.t !== 4 && (w$1(e.base, r.f.i), t = "(" + f(e, r.f) + ",", n2 = true), t += ae(e, r.i, "(" + At + ")(" + m(e, r.f.i) + ")"), n2 && (t += ")"), t;
+}
+function fa(e, r) {
+  return q(e, r.a[0]) + "(" + f(e, r.a[1]) + ")";
+}
+function Sa(e, r) {
+  let t = r.a[0], n2 = r.a[1], a = e.base, s = "";
+  t.t !== 4 && (w$1(a, t.i), s += "(" + f(e, t)), n2.t !== 4 && (w$1(a, n2.i), s += (s ? "," : "(") + f(e, n2)), s && (s += ",");
+  let i = ae(e, r.i, "(" + Et + ")(" + m(e, n2.i) + "," + m(e, t.i) + ")");
+  return s ? s + i + ")" : i;
+}
+function ma(e, r) {
+  return q(e, r.a[0]) + "(" + f(e, r.a[1]) + ")";
+}
+function pa(e, r) {
+  let t = ae(e, r.i, q(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 da(e, r) {
+  return m(e, r.i) + ".next(" + f(e, r.f) + ")";
+}
+function ga(e, r) {
+  return m(e, r.i) + ".throw(" + f(e, r.f) + ")";
+}
+function ya(e, r) {
+  return m(e, r.i) + ".return(" + f(e, r.f) + ")";
+}
+function nn(e, r, t, n2) {
+  let a = e.base;
+  return F(a, n2) ? (w$1(a, r), Lo(e, r, t, m(e, n2.i)), "") : f(e, n2);
+}
+function Na(e, r) {
+  let t = r.a, n2 = t.length, a = r.i;
+  if (n2 > 0) {
+    e.base.stack.push(a);
+    let s = nn(e, a, 0, t[0]);
+    for (let i = 1, u = s; i < n2; i++) u = nn(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 ba(e, r) {
+  switch (r.t) {
+    case 17:
+      return tt[r.s];
+    case 18:
+      return Uo(r);
+    case 9:
+      return jo(e, r);
+    case 10:
+      return Yo(e, r);
+    case 11:
+      return Ho(e, r);
+    case 5:
+      return Jo(r);
+    case 6:
+      return Zo(e, r);
+    case 7:
+      return $o(e, r);
+    case 8:
+      return Xo(e, r);
+    case 19:
+      return Qo(e, r);
+    case 16:
+    case 15:
+      return ea(e, r);
+    case 20:
+      return ra(e, r);
+    case 14:
+      return ta(e, r);
+    case 13:
+      return na(e, r);
+    case 12:
+      return oa(e, r);
+    case 21:
+      return aa(e, r);
+    case 22:
+      return sa(e, r);
+    case 25:
+      return la(e, r);
+    case 26:
+      return Ot[r.s];
+    case 35:
+      return Na(e, r);
+    default:
+      throw new h(r);
+  }
+}
+function f(e, r) {
+  switch (r.t) {
+    case 2:
+      return ot[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 ia(e, r);
+    case 24:
+      return ua(e, r);
+    case 27:
+      return ca(e, r);
+    case 28:
+      return fa(e, r);
+    case 29:
+      return Sa(e, r);
+    case 30:
+      return ma(e, r);
+    case 31:
+      return pa(e, r);
+    case 32:
+      return da(e, r);
+    case 33:
+      return ga(e, r);
+    case 34:
+      return ya(e, r);
+    default:
+      return ae(e, r.i, ba(e, r));
+  }
+}
+function fr(e, r) {
+  let t = f(e, r), n2 = r.i;
+  if (n2 == null) return t;
+  let a = sn(e.base), s = m(e, n2), i = e.state.scopeId, u = i == null ? "" : le, l = a ? "(" + t + "," + a + s + ")" : t;
+  if (u === "") return r.t === 10 && !a ? "(" + l + ")" : l;
+  let g = i == null ? "()" : "(" + le + '["' + y(i) + '"])';
+  return "(" + ir([u], l) + ")" + g;
+}
+var Kr = class {
+  constructor(r, t) {
+    this._p = r;
+    this.depth = t;
+  }
+  parse(r) {
+    return E(this._p, this.depth, r);
+  }
+}, Hr = class {
+  constructor(r, t) {
+    this._p = r;
+    this.depth = t;
+  }
+  parse(r) {
+    return E(this._p, this.depth, r);
+  }
+  parseWithError(r) {
+    return W(this._p, this.depth, r);
+  }
+  isAlive() {
+    return this._p.state.alive;
+  }
+  pushPendingState() {
+    Qr(this._p);
+  }
+  popPendingState() {
+    be(this._p);
+  }
+  onParse(r) {
+    se(this._p, r);
+  }
+  onError(r) {
+    $r(this._p, r);
+  }
+};
+function va(e) {
+  return { alive: true, pending: 0, initial: true, buffer: [], onParse: e.onParse, onError: e.onError, onDone: e.onDone };
+}
+function Jr(e) {
+  return { type: 2, base: me(2, e), state: va(e) };
+}
+function Ca(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 Aa(e, r, t, n2) {
+  return _e(t, n2, Ca(e, r, n2));
+}
+function Zr(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(rr(e.base), E(e, r, $e(t))))), v in t && (a.push(I(e.base, v)), s.push(je(tr(e.base), E(e, r, e.type === 1 ? re() : Qe(t))))), P$1 in t && (a.push(I(e.base, P$1)), s.push($(t[P$1]))), R in t && (a.push(I(e.base, R)), s.push(t[R] ? H : J)), { k: a, v: s };
+}
+function Gr(e, r, t, n2, a) {
+  return nr(t, n2, a, Zr(e, r, n2));
+}
+function Ea(e, r, t, n2) {
+  return ke(t, E(e, r, n2.valueOf()));
+}
+function Ia(e, r, t, n2) {
+  return De(t, n2, E(e, r, n2.buffer));
+}
+function Ra(e, r, t, n2) {
+  return Fe(t, n2, E(e, r, n2.buffer));
+}
+function Pa(e, r, t, n2) {
+  return Be(t, n2, E(e, r, n2.buffer));
+}
+function ln(e, r, t, n2) {
+  let a = Z(n2, e.base.features);
+  return Ve(t, n2, a ? Zr(e, r, a) : o);
+}
+function xa(e, r, t, n2) {
+  let a = Z(n2, e.base.features);
+  return Me(t, n2, a ? Zr(e, r, a) : o);
+}
+function Ta(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 or(e.base, t, a, s);
+}
+function Oa(e, r, t, n2) {
+  let a = [];
+  for (let s of n2.keys()) a.push(E(e, r, s));
+  return Le(t, a);
+}
+function wa(e, r, t, n2) {
+  let a = Ye(t, k(e.base, 4), []);
+  return e.type === 1 || (Qr(e), n2.on({ next: (s) => {
+    if (e.state.alive) {
+      let i = W(e, r, s);
+      i && se(e, qe(t, i));
+    }
+  }, throw: (s) => {
+    if (e.state.alive) {
+      let i = W(e, r, s);
+      i && se(e, We(t, i));
+    }
+    be(e);
+  }, return: (s) => {
+    if (e.state.alive) {
+      let i = W(e, r, s);
+      i && se(e, Ge(t, i));
+    }
+    be(e);
+  } })), a;
+}
+function ha(e, r, t) {
+  if (this.state.alive) {
+    let n2 = W(this, r, t);
+    n2 && se(this, c(23, e, o, o, o, o, o, [k(this.base, 2), n2], o, o, o, o)), be(this);
+  }
+}
+function za(e, r, t) {
+  if (this.state.alive) {
+    let n2 = W(this, r, t);
+    n2 && se(this, c(24, e, o, o, o, o, o, [k(this.base, 3), n2], o, o, o, o));
+  }
+  be(this);
+}
+function _a(e, r, t, n2) {
+  let a = zr(e.base, {});
+  return e.type === 2 && (Qr(e), n2.then(ha.bind(e, a, r), za.bind(e, a, r))), zt(e.base, t, a);
+}
+function ka(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 ce(t, u.tag, u.parse.sync(n2, new Kr(e, r), { id: t }));
+  }
+  return o;
+}
+function Da(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 ce(t, u.tag, u.parse.stream(n2, new Hr(e, r), { id: t }));
+  }
+  return o;
+}
+function cn(e, r, t, n2) {
+  let a = e.base.plugins;
+  return a ? e.type === 1 ? ka(e, r, t, n2, a) : Da(e, r, t, n2, a) : o;
+}
+function Fa(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 Ba(e, r, t, n2, a) {
+  switch (a) {
+    case Object:
+      return Gr(e, r, t, n2, false);
+    case o:
+      return Gr(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 ln(e, r, t, n2);
+    case Number:
+    case Boolean:
+    case String:
+    case BigInt:
+      return Ea(e, r, t, n2);
+    case ArrayBuffer:
+      return ar(e.base, t, n2);
+    case Int8Array:
+    case Int16Array:
+    case Int32Array:
+    case Uint8Array:
+    case Uint16Array:
+    case Uint32Array:
+    case Uint8ClampedArray:
+    case Float32Array:
+    case Float64Array:
+      return Ia(e, r, t, n2);
+    case DataView:
+      return Pa(e, r, t, n2);
+    case Map:
+      return Ta(e, r, t, n2);
+    case Set:
+      return Oa(e, r, t, n2);
+  }
+  if (a === Promise || n2 instanceof Promise) return _a(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 Ra(e, r, t, n2);
+  }
+  if (s & 1 && typeof AggregateError != "undefined" && (a === AggregateError || n2 instanceof AggregateError)) return xa(e, r, t, n2);
+  if (n2 instanceof Error) return ln(e, r, t, n2);
+  if (C in n2 || v in n2) return Gr(e, r, t, n2, !!a);
+  throw new x$1(n2);
+}
+function Va(e, r, t, n2) {
+  if (Array.isArray(n2)) return Aa(e, r, t, n2);
+  if (Xe(n2)) return wa(e, r, t, n2);
+  if (Ze(n2)) return Fa(e, r, t, n2);
+  let a = n2.constructor;
+  if (a === j) return E(e, r, n2.replacement);
+  let s = cn(e, r, t, n2);
+  return s || Ba(e, r, t, n2, a);
+}
+function Ma(e, r, t) {
+  let n2 = Y(e.base, t);
+  if (n2.type !== 0) return n2.value;
+  let a = cn(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 Q(e.base.depthLimit);
+  switch (typeof t) {
+    case "boolean":
+      return t ? H : J;
+    case "undefined":
+      return Ae;
+    case "string":
+      return $(t);
+    case "number":
+      return Oe(t);
+    case "bigint":
+      return we(t);
+    case "object": {
+      if (t) {
+        let n2 = Y(e.base, t);
+        return n2.type === 0 ? Va(e, r + 1, n2.value, t) : n2.value;
+      }
+      return Ee;
+    }
+    case "symbol":
+      return I(e.base, t);
+    case "function":
+      return Ma(e, r, t);
+    default:
+      throw new x$1(t);
+  }
+}
+function se(e, r) {
+  e.state.initial ? e.state.buffer.push(r) : Xr(e, r, false);
+}
+function $r(e, r) {
+  if (e.state.onError) e.state.onError(r);
+  else throw r instanceof z ? r : new z(r);
+}
+function fn(e) {
+  e.state.onDone && e.state.onDone();
+}
+function Xr(e, r, t) {
+  try {
+    e.state.onParse(r, t);
+  } catch (n2) {
+    $r(e, n2);
+  }
+}
+function Qr(e) {
+  e.state.pending++;
+}
+function be(e) {
+  --e.state.pending <= 0 && fn(e);
+}
+function W(e, r, t) {
+  try {
+    return E(e, r, t);
+  } catch (n2) {
+    return $r(e, n2), o;
+  }
+}
+function et(e, r) {
+  let t = W(e, 0, r);
+  t && (Xr(e, t, true), e.state.initial = false, La(e, e.state), e.state.pending <= 0 && Sr(e));
+}
+function La(e, r) {
+  for (let t = 0, n2 = r.buffer.length; t < n2; t++) Xr(e, r.buffer[t], false);
+}
+function Sr(e) {
+  e.state.alive && (fn(e), e.state.alive = false);
+}
+async function su(e, r = {}) {
+  let t = A(r.plugins), n2 = te(2, { plugins: t, disabledFeatures: r.disabledFeatures, refs: r.refs });
+  return await ne(n2, e);
+}
+function Sn(e, r) {
+  let t = A(r.plugins), n2 = Jr({ plugins: t, refs: r.refs, disabledFeatures: r.disabledFeatures, onParse(a, s) {
+    let i = lr({ plugins: t, features: n2.base.features, scopeId: r.scopeId, markedRefs: n2.base.marked }), u;
+    try {
+      u = fr(i, a);
+    } catch (l) {
+      r.onError && r.onError(l);
+      return;
+    }
+    r.onSerialize(u, s);
+  }, onError: r.onError, onDone: r.onDone });
+  return et(n2, e), Sr.bind(null, n2);
+}
+function iu(e, r) {
+  let t = A(r.plugins), n2 = Jr({ plugins: t, refs: r.refs, disabledFeatures: r.disabledFeatures, depthLimit: r.depthLimit, onParse: r.onParse, onError: r.onError, onDone: r.onDone });
+  return et(n2, e), Sr.bind(null, n2);
+}
+function Pu(e, r = {}) {
+  var i;
+  let t = A(r.plugins), n2 = r.disabledFeatures || 0, a = (i = e.f) != null ? i : 63, s = Lt({ plugins: t, markedRefs: e.m, features: a & ~n2, disabledFeatures: n2 });
+  return sr(s, e.t);
+}
+function createSerializationAdapter(opts) {
+  return opts;
+}
+// @__NO_SIDE_EFFECTS__
+function makeSsrSerovalPlugin(serializationAdapter, options) {
+  return /* @__PURE__ */ ai({
+    tag: "$TSR/t/" + serializationAdapter.key,
+    test: serializationAdapter.test,
+    parse: { stream(value, ctx, _data) {
+      return { v: ctx.parse(serializationAdapter.toSerializable(value)) };
+    } },
+    serialize(node, ctx, _data) {
+      options.didRun = true;
+      return GLOBAL_TSR + '.t.get("' + serializationAdapter.key + '")(' + ctx.serialize(node.v) + ")";
+    },
+    deserialize: void 0
+  });
+}
+// @__NO_SIDE_EFFECTS__
+function makeSerovalPlugin(serializationAdapter) {
+  return /* @__PURE__ */ ai({
+    tag: "$TSR/t/" + serializationAdapter.key,
+    test: serializationAdapter.test,
+    parse: {
+      sync(value, ctx, _data) {
+        return { v: ctx.parse(serializationAdapter.toSerializable(value)) };
+      },
+      async async(value, ctx, _data) {
+        return { v: await ctx.parse(serializationAdapter.toSerializable(value)) };
+      },
+      stream(value, ctx, _data) {
+        return { v: ctx.parse(serializationAdapter.toSerializable(value)) };
+      }
+    },
+    serialize: void 0,
+    deserialize(node, ctx, _data) {
+      return serializationAdapter.fromSerializable(ctx.deserialize(node.v));
+    }
+  });
+}
+var RawStream = class {
+  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 = re();
+  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 = re();
+  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 RawStreamSSRPlugin = /* @__PURE__ */ ai({
+  tag: "tss/RawStream",
+  extends: [/* @__PURE__ */ ai({
+    tag: "tss/RawStreamFactory",
+    test(value) {
+      return value === RAW_STREAM_FACTORY_BINARY;
+    },
+    parse: {
+      sync(_value, _ctx, _data) {
+        return {};
+      },
+      async async(_value, _ctx, _data) {
+        return {};
+      },
+      stream(_value, _ctx, _data) {
+        return {};
+      }
+    },
+    serialize(_node, _ctx, _data) {
+      return FACTORY_BINARY;
+    },
+    deserialize(_node, _ctx, _data) {
+      return RAW_STREAM_FACTORY_BINARY;
+    }
+  }), /* @__PURE__ */ ai({
+    tag: "tss/RawStreamFactoryText",
+    test(value) {
+      return value === RAW_STREAM_FACTORY_TEXT;
+    },
+    parse: {
+      sync(_value, _ctx, _data) {
+        return {};
+      },
+      async async(_value, _ctx, _data) {
+        return {};
+      },
+      stream(_value, _ctx, _data) {
+        return {};
+      }
+    },
+    serialize(_node, _ctx, _data) {
+      return FACTORY_TEXT;
+    },
+    deserialize(_node, _ctx, _data) {
+      return RAW_STREAM_FACTORY_TEXT;
+    }
+  })],
+  test(value) {
+    return value instanceof RawStream;
+  },
+  parse: {
+    sync(value, ctx, _data) {
+      const factory = value.hint === "text" ? RAW_STREAM_FACTORY_TEXT : RAW_STREAM_FACTORY_BINARY;
+      return {
+        hint: ctx.parse(value.hint),
+        factory: ctx.parse(factory),
+        stream: ctx.parse(re())
+      };
+    },
+    async async(value, ctx, _data) {
+      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: await ctx.parse(value.hint),
+        factory: await ctx.parse(factory),
+        stream: await ctx.parse(encodedStream)
+      };
+    },
+    stream(value, ctx, _data) {
+      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: ctx.parse(value.hint),
+        factory: ctx.parse(factory),
+        stream: ctx.parse(encodedStream)
+      };
+    }
+  },
+  serialize(node, ctx, _data) {
+    return "(" + ctx.serialize(node.factory) + ")(" + ctx.serialize(node.stream) + ")";
+  },
+  deserialize(node, ctx, _data) {
+    const stream = ctx.deserialize(node.stream);
+    return ctx.deserialize(node.hint) === "text" ? RAW_STREAM_FACTORY_CONSTRUCTOR_TEXT(stream) : RAW_STREAM_FACTORY_CONSTRUCTOR_BINARY(stream);
+  }
+});
+// @__NO_SIDE_EFFECTS__
+function createRawStreamRPCPlugin(onRawStream) {
+  let nextStreamId = 1;
+  return /* @__PURE__ */ ai({
+    tag: "tss/RawStream",
+    test(value) {
+      return value instanceof RawStream;
+    },
+    parse: {
+      async async(value, ctx, _data) {
+        const streamId = nextStreamId++;
+        onRawStream(streamId, value.stream);
+        return { streamId: await ctx.parse(streamId) };
+      },
+      stream(value, ctx, _data) {
+        const streamId = nextStreamId++;
+        onRawStream(streamId, value.stream);
+        return { streamId: ctx.parse(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 ShallowErrorPlugin = /* @__PURE__ */ ai({
+  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));
+  }
+});
+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 = ai({ 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 w(e) {
+  let r = re(), 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 ee = ai({ 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(re()) };
+}, async async(e, r) {
+  return { factory: await r.parse(n), stream: await r.parse(w(e)) };
+}, stream(e, r) {
+  return { factory: r.parse(n), stream: r.parse(w(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 = ee;
+const defaultSerovalPlugins = [
+  ShallowErrorPlugin,
+  RawStreamSSRPlugin,
+  p
+];
+async function getStartManifest(matchedRoutes) {
+  const { tsrStartManifest } = await import("../_tanstack-start-manifest_v-C7Upe2TI.mjs");
+  const startManifest = tsrStartManifest();
+  const rootRoute = startManifest.routes[rootRouteId] = startManifest.routes[rootRouteId] || {};
+  rootRoute.assets = rootRoute.assets || [];
+  let injectedHeadScripts;
+  return {
+    manifest: {
+      inlineCss: startManifest.inlineCss,
+      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]];
+      }))
+    },
+    clientEntry: startManifest.clientEntry,
+    injectedHeadScripts
+  };
+}
+const manifest = {};
+async function getServerFnById(id, access) {
+  const serverFnInfo = manifest[id];
+  if (!serverFnInfo) {
+    throw new Error("Server function info not found for " + id);
+  }
+  const fnModule = serverFnInfo.module ?? await serverFnInfo.importer();
+  if (!fnModule) {
+    throw new Error("Server function module not resolved for " + id);
+  }
+  const action = fnModule[serverFnInfo.functionName];
+  if (!action) {
+    throw new Error("Server function module export not resolved for serverFn ID: " + id);
+  }
+  return action;
+}
+var TSS_FORMDATA_CONTEXT = "__TSS_CONTEXT";
+var TSS_SERVER_FUNCTION = /* @__PURE__ */ Symbol.for("TSS_SERVER_FUNCTION");
+var X_TSS_SERIALIZED = "x-tss-serialized";
+var X_TSS_RAW_RESPONSE = "x-tss-raw";
+var TSS_CONTENT_TYPE_FRAMED = "application/x-tss-framed";
+var FrameType = {
+  JSON: 0,
+  CHUNK: 1,
+  END: 2,
+  ERROR: 3
+};
+var FRAME_HEADER_SIZE = 9;
+var TSS_CONTENT_TYPE_FRAMED_VERSIONED = `${TSS_CONTENT_TYPE_FRAMED}; v=1`;
+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;
+}
+var GLOBAL_STORAGE_KEY = /* @__PURE__ */ Symbol.for("tanstack-start:start-storage-context");
+var globalObj = globalThis;
+if (!globalObj[GLOBAL_STORAGE_KEY]) globalObj[GLOBAL_STORAGE_KEY] = new AsyncLocalStorage();
+var startStorage = globalObj[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;
+}
+var getStartOptions = () => getStartContext().startOptions;
+function splitSetCookieString(cookiesString) {
+  if (Array.isArray(cookiesString)) return cookiesString.flatMap((c2) => splitSetCookieString(c2));
+  if (typeof cookiesString !== "string") return [];
+  const cookiesStrings = [];
+  let pos = 0;
+  let start2;
+  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) {
+    start2 = 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(start2, lastComma));
+          start2 = pos;
+        } else pos = lastComma + 1;
+      } else pos += 1;
+    }
+    if (!cookiesSeparatorFound || pos >= cookiesString.length) cookiesStrings.push(cookiesString.slice(start2));
+  }
+  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") splitSetCookieString(value).forEach((cookie) => acc.append("set-cookie", cookie));
+    else acc.set(key, value);
+    return acc;
+  }, new Headers());
+}
+function dehydrateSsrMatchId(id) {
+  return id.replaceAll("/", "\0");
+}
+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;
+}
+var createMiddleware = (options, __opts) => {
+  const resolvedOptions = {
+    type: "request",
+    ...__opts || options
+  };
+  return {
+    options: resolvedOptions,
+    middleware: (middleware) => {
+      return createMiddleware({}, Object.assign(resolvedOptions, { middleware }));
+    },
+    inputValidator: (inputValidator) => {
+      return createMiddleware({}, Object.assign(resolvedOptions, { inputValidator }));
+    },
+    client: (client) => {
+      return createMiddleware({}, Object.assign(resolvedOptions, { client }));
+    },
+    server: (server2) => {
+      return createMiddleware({}, Object.assign(resolvedOptions, { server: server2 }));
+    }
+  };
+};
+var innerCreateCsrfMiddleware = (opts = {}) => {
+  const middleware = createMiddleware().server(async (ctx) => {
+    const csrfCtx = ctx;
+    if (opts.filter && !await opts.filter(csrfCtx)) return ctx.next();
+    if (await isCsrfRequestAllowed(opts, csrfCtx)) return ctx.next();
+    return getFailureResponse(opts, csrfCtx);
+  });
+  return middleware;
+};
+var createCsrfMiddleware = innerCreateCsrfMiddleware;
+async function isCsrfRequestAllowed(opts, ctx) {
+  const result = await getCsrfRequestValidationResult(opts, ctx);
+  return result === true || result === void 0 && opts.allowRequestsWithoutOriginCheck === true;
+}
+async function getCsrfRequestValidationResult(opts, ctx) {
+  const fetchSite = ctx.request.headers.get("Sec-Fetch-Site");
+  if (fetchSite !== null) return matchValue(opts.secFetchSite ?? "same-origin", fetchSite, ctx);
+  const origin = ctx.request.headers.get("Origin");
+  if (origin !== null) {
+    if (opts.origin) return matchValue(opts.origin, origin, ctx);
+    return origin === new URL(ctx.request.url).origin;
+  }
+  const referer = ctx.request.headers.get("Referer");
+  if (referer === null || opts.referer === false) return;
+  if (typeof opts.referer === "function") return opts.referer(referer, ctx);
+  if (opts.origin) {
+    const refererOrigin = getOriginFromUrl(referer);
+    return refererOrigin !== void 0 && matchValue(opts.origin, refererOrigin, ctx);
+  }
+  return isRefererSameOrigin(referer, new URL(ctx.request.url).origin);
+}
+async function matchValue(matcher, value, ctx) {
+  if (typeof matcher === "function") return matcher(value, ctx);
+  if (Array.isArray(matcher)) return matcher.includes(value);
+  return value === matcher;
+}
+function getOriginFromUrl(url) {
+  try {
+    return new URL(url).origin;
+  } catch {
+    return;
+  }
+}
+function isRefererSameOrigin(referer, requestOrigin) {
+  if (referer === requestOrigin) return true;
+  if (!referer.startsWith(requestOrigin)) return false;
+  if (referer.length === requestOrigin.length) return true;
+  const code = referer.charCodeAt(requestOrigin.length);
+  return code === 47 || code === 63 || code === 35;
+}
+async function getFailureResponse(opts, ctx) {
+  if (typeof opts.failureResponse === "function") return opts.failureResponse(ctx);
+  return opts.failureResponse?.clone() ?? new Response("Forbidden", {
+    status: 403
+  });
+}
+function getDefaultSerovalPlugins() {
+  return [...getStartOptions()?.serializationAdapters?.map(makeSerovalPlugin) ?? [], ...defaultSerovalPlugins];
+}
+var textEncoder = new TextEncoder();
+var 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.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.encode(message));
+}
+function createMultiplexedStream(jsonStream, rawStreams, lateStreamSource) {
+  let controller;
+  let cancelled = false;
+  const readers = [];
+  const enqueue = (frame) => {
+    if (cancelled) return false;
+    try {
+      controller.enqueue(frame);
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  const errorOutput = (error) => {
+    if (cancelled) return;
+    cancelled = true;
+    try {
+      controller.error(error);
+    } catch {
+    }
+    for (const reader of readers) reader.cancel().catch(() => {
+    });
+  };
+  async function pumpRawStream(streamId, stream) {
+    const reader = stream.getReader();
+    readers.push(reader);
+    try {
+      while (!cancelled) {
+        const { done, value } = await reader.read();
+        if (done) {
+          enqueue(encodeEndFrame(streamId));
+          return;
+        }
+        if (!enqueue(encodeChunkFrame(streamId, value))) return;
+      }
+    } catch (error) {
+      enqueue(encodeErrorFrame(streamId, error));
+    } finally {
+      reader.releaseLock();
+    }
+  }
+  async function pumpJSON() {
+    const reader = jsonStream.getReader();
+    readers.push(reader);
+    try {
+      while (!cancelled) {
+        const { done, value } = await reader.read();
+        if (done) return;
+        if (!enqueue(encodeJSONFrame(value))) return;
+      }
+    } catch (error) {
+      errorOutput(error);
+      throw error;
+    } finally {
+      reader.releaseLock();
+    }
+  }
+  async function pumpLateStreams() {
+    if (!lateStreamSource) return [];
+    const lateStreamPumps = [];
+    const reader = lateStreamSource.getReader();
+    readers.push(reader);
+    try {
+      while (!cancelled) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        lateStreamPumps.push(pumpRawStream(value.id, value.stream));
+      }
+    } finally {
+      reader.releaseLock();
+    }
+    return lateStreamPumps;
+  }
+  return new ReadableStream({
+    async start(ctrl) {
+      controller = ctrl;
+      const pumps = [pumpJSON()];
+      for (const [streamId, stream] of rawStreams) pumps.push(pumpRawStream(streamId, stream));
+      if (lateStreamSource) pumps.push(pumpLateStreams());
+      try {
+        const latePumps = (await Promise.all(pumps)).find(Array.isArray);
+        if (latePumps && latePumps.length > 0) await Promise.all(latePumps);
+        if (!cancelled) try {
+          controller.close();
+        } catch {
+        }
+      } catch {
+      }
+    },
+    cancel() {
+      cancelled = true;
+      for (const reader of readers) reader.cancel().catch(() => {
+      });
+      readers.length = 0;
+    }
+  });
+}
+var serovalPlugins = void 0;
+var FORM_DATA_CONTENT_TYPES = ["multipart/form-data", "application/x-www-form-urlencoded"];
+var MAX_PAYLOAD_SIZE = 1e6;
+var handleServerAction = async ({ request, context, serverFnId }) => {
+  const methodUpper = request.method.toUpperCase();
+  const url = new URL(request.url);
+  const action = await getServerFnById(serverFnId);
+  if (action.method && methodUpper !== action.method) return new Response(`expected ${action.method} method. Got ${methodUpper}`, {
+    status: 405,
+    headers: { Allow: action.method }
+  });
+  const isServerFn = request.headers.get("x-tsr-serverFn") === "true";
+  if (!serovalPlugins) serovalPlugins = getDefaultSerovalPlugins();
+  const contentType = request.headers.get("Content-Type");
+  function parsePayload(payload) {
+    return Pu(payload, { plugins: serovalPlugins });
+  }
+  return await (async () => {
+    try {
+      let serializeResult = function(res2) {
+        let nonStreamingBody = void 0;
+        const alsResponse = getResponse();
+        if (res2 !== void 0) {
+          const rawStreams = /* @__PURE__ */ new Map();
+          let initialPhase = true;
+          let lateStreamWriter;
+          let lateStreamReadable = void 0;
+          const pendingLateStreams = [];
+          const plugins = [/* @__PURE__ */ createRawStreamRPCPlugin((id, stream) => {
+            if (initialPhase) {
+              rawStreams.set(id, stream);
+              return;
+            }
+            if (lateStreamWriter) {
+              lateStreamWriter.write({
+                id,
+                stream
+              }).catch(() => {
+              });
+              return;
+            }
+            pendingLateStreams.push({
+              id,
+              stream
+            });
+          }), ...serovalPlugins || []];
+          let done = false;
+          const callbacks = {
+            onParse: (value) => {
+              nonStreamingBody = value;
+            },
+            onDone: () => {
+              done = true;
+            },
+            onError: (error) => {
+              throw error;
+            }
+          };
+          iu(res2, {
+            refs: /* @__PURE__ */ new Map(),
+            plugins,
+            onParse(value) {
+              callbacks.onParse(value);
+            },
+            onDone() {
+              callbacks.onDone();
+            },
+            onError: (error) => {
+              callbacks.onError(error);
+            }
+          });
+          initialPhase = false;
+          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"
+            }
+          });
+          const { readable, writable } = new TransformStream();
+          lateStreamReadable = readable;
+          lateStreamWriter = writable.getWriter();
+          for (const registration of pendingLateStreams) lateStreamWriter.write(registration).catch(() => {
+          });
+          pendingLateStreams.length = 0;
+          const multiplexedStream = createMultiplexedStream(new ReadableStream({
+            start(controller) {
+              callbacks.onParse = (value) => {
+                controller.enqueue(JSON.stringify(value) + "\n");
+              };
+              callbacks.onDone = () => {
+                try {
+                  controller.close();
+                } catch {
+                }
+                lateStreamWriter?.close().catch(() => {
+                }).finally(() => {
+                  lateStreamWriter = void 0;
+                });
+              };
+              callbacks.onError = (error) => {
+                controller.error(error);
+                lateStreamWriter?.abort(error).catch(() => {
+                }).finally(() => {
+                  lateStreamWriter = void 0;
+                });
+              };
+              if (nonStreamingBody !== void 0) callbacks.onParse(nonStreamingBody);
+              if (done) callbacks.onDone();
+            },
+            cancel() {
+              lateStreamWriter?.abort().catch(() => {
+              });
+              lateStreamWriter = void 0;
+            }
+          }), rawStreams, lateStreamReadable);
+          return new Response(multiplexedStream, {
+            status: alsResponse.status,
+            statusText: alsResponse.statusText,
+            headers: {
+              "Content-Type": TSS_CONTENT_TYPE_FRAMED_VERSIONED,
+              [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))) {
+          if (methodUpper === "GET") {
+            if (false) ;
+            invariant();
+          }
+          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 deserializedContext = Pu(JSON.parse(serializedContext), { plugins: serovalPlugins });
+            if (typeof deserializedContext === "object" && deserializedContext) params.context = safeObjectMerge(deserializedContext, context);
+          } catch (e) {
+            if (false) ;
+          }
+          return await action(params);
+        }
+        if (methodUpper === "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(payload2.context, context);
+          payload2.method = methodUpper;
+          return await action(payload2);
+        }
+        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(su(error, {
+        refs: /* @__PURE__ */ new Map(),
+        plugins: serovalPlugins
+      })));
+      const response = getResponse();
+      return new Response(serializedError, {
+        status: response.status ?? 500,
+        statusText: response.statusText,
+        headers: {
+          "Content-Type": "application/json",
+          [X_TSS_SERIALIZED]: "true"
+        }
+      });
+    }
+  })();
+};
+function isNotFoundResponse(error) {
+  const { headers, ...rest } = error;
+  return new Response(JSON.stringify(rest), {
+    status: 404,
+    headers: {
+      "Content-Type": "application/json",
+      ...headers || {}
+    }
+  });
+}
+var LINK_PARAM_TOKEN_RE = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
+var PRELOAD_AS_VALUES = /* @__PURE__ */ new Set([
+  "fetch",
+  "font",
+  "image",
+  "script",
+  "style",
+  "track"
+]);
+function buildLinkParam(name, value) {
+  if (value === void 0) return name;
+  if (LINK_PARAM_TOKEN_RE.test(value)) return `${name}=${value}`;
+  return `${name}=${JSON.stringify(value)}`;
+}
+function serializeEarlyHint(hint) {
+  const parts = [`<${hint.href}>`, buildLinkParam("rel", hint.rel)];
+  if (hint.as) parts.push(buildLinkParam("as", hint.as));
+  if (hint.crossOrigin !== void 0) parts.push(buildLinkParam("crossorigin", hint.crossOrigin || void 0));
+  if (hint.type) parts.push(buildLinkParam("type", hint.type));
+  if (hint.integrity) parts.push(buildLinkParam("integrity", hint.integrity));
+  if (hint.referrerPolicy) parts.push(buildLinkParam("referrerpolicy", hint.referrerPolicy));
+  if (hint.fetchPriority) parts.push(buildLinkParam("fetchpriority", hint.fetchPriority));
+  return parts.join("; ");
+}
+function getStringAttr(attrs, name, fallbackName) {
+  const value = attrs?.[name] ?? (fallbackName ? attrs?.[fallbackName] : void 0);
+  return typeof value === "string" ? value : void 0;
+}
+function getPreloadAs(attrs) {
+  const as = getStringAttr(attrs, "as");
+  return as && PRELOAD_AS_VALUES.has(as) ? as : void 0;
+}
+function addEarlyHintFetchAttrs(hint, attrs) {
+  const crossOrigin = getStringAttr(attrs, "crossOrigin", "crossorigin");
+  const type = getStringAttr(attrs, "type");
+  const integrity = getStringAttr(attrs, "integrity");
+  const referrerPolicy = getStringAttr(attrs, "referrerPolicy", "referrerpolicy");
+  const fetchPriority = getStringAttr(attrs, "fetchPriority", "fetchpriority");
+  if (crossOrigin !== void 0) hint.crossOrigin = crossOrigin;
+  if (type) hint.type = type;
+  if (integrity) hint.integrity = integrity;
+  if (referrerPolicy) hint.referrerPolicy = referrerPolicy;
+  if (fetchPriority) hint.fetchPriority = fetchPriority;
+}
+function linkAttrsToEarlyHint(attrs) {
+  const href = getStringAttr(attrs, "href");
+  const rel = getStringAttr(attrs, "rel");
+  if (!href || !rel) return void 0;
+  const relTokens = rel.split(/\s+/);
+  let hintRel;
+  let hintAs;
+  if (relTokens.includes("modulepreload")) {
+    hintRel = "modulepreload";
+    hintAs = "script";
+  } else if (relTokens.includes("stylesheet")) {
+    hintRel = "preload";
+    hintAs = "style";
+  } else if (relTokens.includes("preload")) {
+    hintAs = getPreloadAs(attrs);
+    if (!hintAs) return void 0;
+    hintRel = "preload";
+  } else if (relTokens.includes("preconnect")) {
+    hintRel = "preconnect";
+    hintAs = void 0;
+  } else if (relTokens.includes("dns-prefetch")) {
+    hintRel = "dns-prefetch";
+    hintAs = void 0;
+  }
+  if (!hintRel) return void 0;
+  const hint = {
+    href,
+    rel: hintRel
+  };
+  if (hintAs) hint.as = hintAs;
+  addEarlyHintFetchAttrs(hint, attrs);
+  return hint;
+}
+function collectStaticHintsFromManifest(manifest2, matchedRoutes) {
+  const hints = [];
+  for (const route of matchedRoutes) {
+    const routeManifest = manifest2.routes[route.id];
+    if (!routeManifest) continue;
+    for (const link of routeManifest.preloads ?? []) {
+      const { href, crossOrigin } = resolveManifestAssetLink(link);
+      const hint = {
+        href,
+        rel: "modulepreload",
+        as: "script"
+      };
+      if (crossOrigin !== void 0) hint.crossOrigin = crossOrigin;
+      hints.push(hint);
+    }
+    for (const asset of routeManifest.assets ?? []) {
+      if (asset.tag !== "link") continue;
+      const stylesheetHref = getStylesheetHref(asset);
+      if (stylesheetHref) {
+        if (manifest2.inlineCss?.styles[stylesheetHref] !== void 0) continue;
+        const hint2 = {
+          href: stylesheetHref,
+          rel: "preload",
+          as: "style"
+        };
+        addEarlyHintFetchAttrs(hint2, asset.attrs);
+        hints.push(hint2);
+        continue;
+      }
+      const hint = linkAttrsToEarlyHint(asset.attrs);
+      if (hint) hints.push(hint);
+    }
+  }
+  return hints;
+}
+function collectDynamicHintsFromMatches(matches) {
+  const hints = [];
+  for (const match of matches) {
+    const links = match.links;
+    if (!Array.isArray(links)) continue;
+    for (const link of links) {
+      const hint = linkAttrsToEarlyHint(link);
+      if (hint) hints.push(hint);
+    }
+  }
+  return hints;
+}
+function createEarlyHintsEvent(opts) {
+  const nextHints = [];
+  const nextLinks = [];
+  for (const hint of opts.hints) {
+    const link = serializeEarlyHint(hint);
+    if (opts.sentLinks.has(link)) continue;
+    opts.sentLinks.add(link);
+    opts.sentHints.push(hint);
+    nextHints.push(hint);
+    nextLinks.push(link);
+  }
+  if (!nextHints.length && opts.phase !== "dynamic") return void 0;
+  return {
+    phase: opts.phase,
+    hints: nextHints,
+    links: nextLinks,
+    allHints: opts.sentHints.slice(),
+    allLinks: Array.from(opts.sentLinks)
+  };
+}
+function createResponseLinkHeaderEntries(opts) {
+  for (const hint of opts.hints) {
+    const link = serializeEarlyHint(hint);
+    if (opts.sentLinks.has(link)) continue;
+    opts.sentLinks.add(link);
+    opts.entries.push({
+      phase: opts.phase,
+      hint,
+      link
+    });
+  }
+}
+function getResponseLinkHeaderEntries(opts) {
+  if (!opts.filter) return opts.entries.map((entry) => entry.link);
+  try {
+    const links = [];
+    for (const entry of opts.entries) if (opts.filter(entry)) links.push(entry.link);
+    return links;
+  } catch (err) {
+    console.error("Error filtering response Link headers:", err);
+    return [];
+  }
+}
+function notifyEarlyHints(phase, event, onEarlyHints) {
+  try {
+    const result = onEarlyHints(event);
+    if (result) Promise.resolve(result).catch((err) => {
+      console.error(`Error sending ${phase} early hints:`, err);
+    });
+  } catch (err) {
+    console.error(`Error sending ${phase} early hints:`, err);
+  }
+}
+function getResponseLinkHeaderFilter(responseLinkHeader) {
+  if (typeof responseLinkHeader !== "object") return;
+  return responseLinkHeader.filter;
+}
+function appendResponseLinkHeaders(opts) {
+  for (const link of getResponseLinkHeaderEntries(opts)) opts.responseHeaders.append("Link", link);
+}
+function collectResponseLinkHeaderEntries(opts) {
+  for (let index = 0; index < opts.event.hints.length; index++) opts.entries.push({
+    phase: opts.phase,
+    hint: opts.event.hints[index],
+    link: opts.event.links[index]
+  });
+}
+function collectEarlyHintsPhase(opts) {
+  const event = opts.onEarlyHints ? createEarlyHintsEvent({
+    phase: opts.phase,
+    hints: opts.hints,
+    sentLinks: opts.sentLinks,
+    sentHints: opts.sentHints
+  }) : void 0;
+  if (event) notifyEarlyHints(opts.phase, event, opts.onEarlyHints);
+  if (!opts.responseLinkHeaderEntries) return;
+  if (event) {
+    collectResponseLinkHeaderEntries({
+      phase: opts.phase,
+      event,
+      entries: opts.responseLinkHeaderEntries
+    });
+    return;
+  }
+  createResponseLinkHeaderEntries({
+    phase: opts.phase,
+    hints: opts.hints,
+    sentLinks: opts.sentLinks,
+    entries: opts.responseLinkHeaderEntries
+  });
+}
+function createEarlyHintsCollector(opts) {
+  if (!opts?.onEarlyHints && !opts?.responseLinkHeader) return;
+  const sentLinks = /* @__PURE__ */ new Set();
+  const sentHints = opts.onEarlyHints ? new Array() : void 0;
+  const responseLinkHeaderEntries = opts.responseLinkHeader ? new Array() : void 0;
+  const responseLinkHeaderFilter = getResponseLinkHeaderFilter(opts.responseLinkHeader);
+  return {
+    collectStatic: ({ manifest: manifest2, matchedRoutes }) => {
+      if (!matchedRoutes?.length) return;
+      collectEarlyHintsPhase({
+        phase: "static",
+        hints: collectStaticHintsFromManifest(manifest2, matchedRoutes),
+        sentLinks,
+        sentHints,
+        onEarlyHints: opts.onEarlyHints,
+        responseLinkHeaderEntries
+      });
+    },
+    collectDynamic: (matches) => {
+      collectEarlyHintsPhase({
+        phase: "dynamic",
+        hints: collectDynamicHintsFromMatches(matches),
+        sentLinks,
+        sentHints,
+        onEarlyHints: opts.onEarlyHints,
+        responseLinkHeaderEntries
+      });
+    },
+    appendResponseHeaders: (headers) => {
+      if (!responseLinkHeaderEntries?.length) return;
+      appendResponseLinkHeaders({
+        responseHeaders: headers,
+        entries: responseLinkHeaderEntries,
+        filter: responseLinkHeaderFilter
+      });
+    }
+  };
+}
+function normalizeTransformAssetResult(result) {
+  if (typeof result === "string") return { href: result };
+  return result;
+}
+function escapeCssString(value) {
+  return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\a ").replace(/\r/g, "\\d ").replace(/\f/g, "\\c ");
+}
+async function transformInlineCssTemplate(options) {
+  const { strings, urls } = options.template;
+  if (strings.length !== urls.length + 1) throw new Error(`TanStack Start inlineCss template for ${options.stylesheetHref} is invalid`);
+  let css = strings[0];
+  for (let index = 0; index < urls.length; index++) {
+    const transformed = normalizeTransformAssetResult(await options.transformFn({
+      kind: "css-url",
+      url: urls[index],
+      stylesheetHref: options.stylesheetHref
+    }));
+    css += escapeCssString(transformed.href) + strings[index + 1];
+  }
+  return css;
+}
+async function transformInlineCssStyles(inlineCss, transformFn) {
+  const transformedStyles = {};
+  const transformedEntries = await Promise.all(Object.entries(inlineCss.styles).map(async ([stylesheetHref, css]) => {
+    const template = inlineCss.templates?.[stylesheetHref];
+    return [stylesheetHref, template ? await transformInlineCssTemplate({
+      stylesheetHref,
+      template,
+      transformFn
+    }) : css];
+  }));
+  for (const [stylesheetHref, css] of transformedEntries) transformedStyles[stylesheetHref] = css;
+  return {
+    styles: transformedStyles,
+    ...inlineCss.templates ? { templates: inlineCss.templates } : {}
+  };
+}
+function resolveTransformAssetsCrossOrigin(config, kind) {
+  if (!config) return void 0;
+  if (typeof config === "string") return config;
+  return config[kind];
+}
+function isObjectShorthand(transform) {
+  return "prefix" in transform;
+}
+function resolveTransformAssetsConfig(transform) {
+  if (typeof transform === "string") {
+    const prefix = transform;
+    return {
+      type: "transform",
+      transformFn: ({ url }) => ({ href: `${prefix}${url}` }),
+      cache: true
+    };
+  }
+  if (typeof transform === "function") return {
+    type: "transform",
+    transformFn: transform,
+    cache: true
+  };
+  if (isObjectShorthand(transform)) {
+    const { prefix, crossOrigin } = transform;
+    return {
+      type: "transform",
+      transformFn: ({ url, kind }) => {
+        const href = `${prefix}${url}`;
+        if (kind === "clientEntry" || kind === "css-url") return { href };
+        const co2 = resolveTransformAssetsCrossOrigin(crossOrigin, kind);
+        return co2 ? {
+          href,
+          crossOrigin: co2
+        } : { href };
+      },
+      cache: true
+    };
+  }
+  if ("createTransform" in transform && transform.createTransform) return {
+    type: "createTransform",
+    createTransform: transform.createTransform,
+    cache: transform.cache !== false
+  };
+  return {
+    type: "transform",
+    transformFn: typeof transform.transform === "string" ? (({ url }) => ({ href: `${transform.transform}${url}` })) : transform.transform,
+    cache: transform.cache !== false
+  };
+}
+function buildClientEntryScriptTag(clientEntry, injectedHeadScripts) {
+  let script = `import(${JSON.stringify(clientEntry)})`;
+  if (injectedHeadScripts) script = `${injectedHeadScripts};${script}`;
+  return {
+    tag: "script",
+    attrs: {
+      type: "module",
+      async: true
+    },
+    children: script
+  };
+}
+function assignManifestAssetLink(link, next) {
+  if (typeof link === "string") return next.crossOrigin ? next : next.href;
+  return next.crossOrigin ? next : { href: next.href };
+}
+async function transformManifestAssets(source, transformFn, _opts) {
+  const manifest2 = structuredClone(source.manifest);
+  if (!(_opts?.inlineCss !== false)) delete manifest2.inlineCss;
+  else if (manifest2.inlineCss) manifest2.inlineCss = await transformInlineCssStyles(manifest2.inlineCss, transformFn);
+  for (const route of Object.values(manifest2.routes)) {
+    if (route.preloads) route.preloads = await Promise.all(route.preloads.map(async (link) => {
+      const result = normalizeTransformAssetResult(await transformFn({
+        url: resolveManifestAssetLink(link).href,
+        kind: "modulepreload"
+      }));
+      return assignManifestAssetLink(link, {
+        href: result.href,
+        crossOrigin: result.crossOrigin
+      });
+    }));
+    if (route.assets && !manifest2.inlineCss) {
+      for (const asset of route.assets) if (asset.tag === "link" && asset.attrs?.href) {
+        const rel = asset.attrs.rel;
+        if (!(typeof rel === "string" ? rel.split(/\s+/) : []).includes("stylesheet")) continue;
+        const result = normalizeTransformAssetResult(await transformFn({
+          url: asset.attrs.href,
+          kind: "stylesheet"
+        }));
+        asset.attrs.href = result.href;
+        if (result.crossOrigin) asset.attrs.crossOrigin = result.crossOrigin;
+        else delete asset.attrs.crossOrigin;
+      }
+    }
+  }
+  const transformedClientEntry = normalizeTransformAssetResult(await transformFn({
+    url: source.clientEntry,
+    kind: "clientEntry"
+  }));
+  const rootRoute = manifest2.routes[rootRouteId] = manifest2.routes[rootRouteId] || {};
+  rootRoute.assets = rootRoute.assets || [];
+  rootRoute.assets.push(buildClientEntryScriptTag(transformedClientEntry.href, source.injectedHeadScripts));
+  return manifest2;
+}
+function buildManifestWithClientEntry(source, opts) {
+  const scriptTag = buildClientEntryScriptTag(source.clientEntry, source.injectedHeadScripts);
+  const baseRootRoute = source.manifest.routes[rootRouteId];
+  const routes = {
+    ...source.manifest.routes,
+    [rootRouteId]: {
+      ...baseRootRoute,
+      assets: [...baseRootRoute?.assets || [], scriptTag]
+    }
+  };
+  return {
+    ...opts?.inlineCss === false ? {} : { inlineCss: structuredClone(source.manifest.inlineCss) },
+    routes
+  };
+}
+function getStaticHandlerInlineCssDefault(handlerInlineCss) {
+  if (typeof handlerInlineCss === "function") return;
+  return handlerInlineCss ?? true;
+}
+async function resolveInlineCssForRequest(opts) {
+  if (opts.requestInlineCss !== void 0) return opts.requestInlineCss;
+  if (typeof opts.handlerInlineCss === "function") return await opts.handlerInlineCss({ request: opts.request });
+  return opts.handlerInlineCss ?? true;
+}
+function createCachedBaseManifestLoader(loadBaseManifest) {
+  let baseManifestPromise;
+  return () => {
+    if (!baseManifestPromise) baseManifestPromise = loadBaseManifest().catch((error) => {
+      baseManifestPromise = void 0;
+      throw error;
+    });
+    return baseManifestPromise;
+  };
+}
+function createFinalManifestTransformResolver(transformAssets, opts) {
+  const transformConfig = transformAssets !== void 0 ? resolveTransformAssetsConfig(transformAssets) : void 0;
+  const cache = transformConfig ? transformConfig.cache : true;
+  const warmup = !!transformAssets && typeof transformAssets === "object" && "warmup" in transformAssets && transformAssets.warmup === true;
+  let cachedCreateTransformPromise;
+  const clearCachedCreateTransform = () => {
+    cachedCreateTransformPromise = void 0;
+  };
+  return {
+    cache,
+    warmup,
+    clearCachedCreateTransform,
+    getTransformFn: async (ctx) => {
+      if (!transformConfig) return void 0;
+      if (transformConfig.type !== "createTransform") return transformConfig.transformFn;
+      if (!cache || false) return transformConfig.createTransform(ctx);
+      if (!cachedCreateTransformPromise) cachedCreateTransformPromise = Promise.resolve(transformConfig.createTransform(ctx)).catch((error) => {
+        clearCachedCreateTransform();
+        throw error;
+      });
+      return cachedCreateTransformPromise;
+    }
+  };
+}
+function createFinalManifestResolver(opts) {
+  const finalManifestCache = /* @__PURE__ */ new Map();
+  const transformResolver = createFinalManifestTransformResolver(opts.transformAssets);
+  const handlerDefaultInlineCss = getStaticHandlerInlineCssDefault(opts.inlineCss);
+  const getRequestManifestOptions = async (requestOpts) => {
+    const transformFn = await transformResolver.getTransformFn({
+      warmup: false,
+      request: requestOpts.request
+    });
+    const inlineCss = await resolveInlineCssForRequest({
+      request: requestOpts.request,
+      handlerInlineCss: opts.inlineCss,
+      requestInlineCss: requestOpts.requestInlineCss
+    });
+    return {
+      getBaseManifest: requestOpts.getBaseManifest,
+      transformFn,
+      cache: transformResolver.cache,
+      inlineCss
+    };
+  };
+  const resolveRequest = async (requestOpts, cache) => {
+    return resolveFinalManifest({
+      ...await getRequestManifestOptions(requestOpts),
+      finalManifestCache: cache
+    });
+  };
+  return {
+    warmup: ({ getBaseManifest: getBaseManifest2 }) => warmupFinalManifest({
+      enabled: transformResolver.warmup,
+      handlerDefaultInlineCss,
+      cache: transformResolver.cache,
+      finalManifestCache,
+      getBaseManifest: getBaseManifest2,
+      getTransformFn: () => transformResolver.getTransformFn({ warmup: true }),
+      onError: transformResolver.clearCachedCreateTransform
+    }),
+    resolveCached: (requestOpts) => resolveRequest(requestOpts, finalManifestCache),
+    resolveUncached: (requestOpts) => resolveRequest(requestOpts, void 0)
+  };
+}
+function getFinalManifestCacheKey(inlineCss) {
+  return inlineCss ? "inline-css" : "linked-css";
+}
+function cacheFinalManifestPromise(cachedFinalManifestPromises, cacheKey, promise) {
+  const cachedFinalManifestPromise = promise.catch((error) => {
+    if (cachedFinalManifestPromises.get(cacheKey) === cachedFinalManifestPromise) cachedFinalManifestPromises.delete(cacheKey);
+    throw error;
+  });
+  cachedFinalManifestPromises.set(cacheKey, cachedFinalManifestPromise);
+  return cachedFinalManifestPromise;
+}
+function getOrCreateCachedFinalManifestPromise(cachedFinalManifestPromises, cacheKey, computeFinalManifest) {
+  const cachedFinalManifestPromise = cachedFinalManifestPromises.get(cacheKey);
+  if (cachedFinalManifestPromise) return cachedFinalManifestPromise;
+  return cacheFinalManifestPromise(cachedFinalManifestPromises, cacheKey, Promise.resolve().then(computeFinalManifest));
+}
+async function buildFinalManifest(opts) {
+  return opts.transformFn ? await transformManifestAssets(opts.base, opts.transformFn, { inlineCss: opts.inlineCss }) : buildManifestWithClientEntry(opts.base, { inlineCss: opts.inlineCss });
+}
+async function resolveFinalManifest(opts) {
+  const computeFinalManifest = async () => {
+    return buildFinalManifest({
+      base: await opts.getBaseManifest(),
+      transformFn: opts.transformFn,
+      inlineCss: opts.inlineCss
+    });
+  };
+  if (opts.finalManifestCache && (!opts.transformFn || opts.cache)) return getOrCreateCachedFinalManifestPromise(opts.finalManifestCache, getFinalManifestCacheKey(opts.inlineCss), computeFinalManifest);
+  return computeFinalManifest();
+}
+function warmupFinalManifest(opts) {
+  if (!opts.enabled || opts.handlerDefaultInlineCss === void 0 || !opts.cache) return;
+  const inlineCss = opts.handlerDefaultInlineCss;
+  const warmupPromise = getOrCreateCachedFinalManifestPromise(opts.finalManifestCache, getFinalManifestCacheKey(inlineCss), async () => {
+    const [base, transformFn] = await Promise.all([opts.getBaseManifest(), opts.getTransformFn()]);
+    return buildFinalManifest({
+      base,
+      transformFn,
+      inlineCss
+    });
+  });
+  if (opts.onError) warmupPromise.catch(opts.onError);
+  return warmupPromise;
+}
+var 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) => {
+      return (await (await getServerFnById(functionId))(opts ?? {}, signal)).result;
+    };
+    return fn2;
+  }
+});
+var tsrScript_default = "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:[]}";
+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: dehydrateSsrMatchId(match.id),
+    u: match.updatedAt,
+    s: match.status
+  };
+  for (const [key, shorthand] of [
+    ["__beforeLoadContext", "b"],
+    ["loaderData", "l"],
+    ["error", "e"],
+    ["ssr", "ssr"]
+  ]) if (match[key] !== void 0) dehydratedMatch[shorthand] = match[key];
+  if (match.globalNotFound) dehydratedMatch.g = true;
+  return dehydratedMatch;
+}
+const INITIAL_SCRIPTS = [dn(SCOPE_ID), tsrScript_default];
+var ScriptBuffer = class {
+  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;
+    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();
+const inlineCssCaches = /* @__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 getInlineCssCache(manifest2) {
+  const cache = inlineCssCaches.get(manifest2);
+  if (cache) return cache;
+  const newCache = createLRUCache(MANIFEST_CACHE_SIZE);
+  inlineCssCaches.set(manifest2, newCache);
+  return newCache;
+}
+function getInlineCssHrefsForMatches(manifest2, matches) {
+  const styles = manifest2?.inlineCss?.styles;
+  if (!styles) return [];
+  const seen = /* @__PURE__ */ new Set();
+  const hrefs = [];
+  for (const match of matches) {
+    const assets = manifest2?.routes[match.routeId]?.assets ?? [];
+    for (const asset of assets) {
+      const href = getStylesheetHref(asset);
+      if (!href || seen.has(href) || styles[href] === void 0) continue;
+      seen.add(href);
+      hrefs.push(href);
+    }
+  }
+  return hrefs;
+}
+function getInlineCssForHrefs(manifest2, hrefs) {
+  const styles = manifest2.inlineCss?.styles;
+  if (!styles || hrefs.length === 0) return void 0;
+  const cacheKey = hrefs.join("\0");
+  {
+    const cached = getInlineCssCache(manifest2).get(cacheKey);
+    if (cached !== void 0) return cached;
+  }
+  const css = hrefs.map((href) => styles[href]).join("");
+  getInlineCssCache(manifest2).set(cacheKey, css);
+  return css;
+}
+function getInlineCssAssetForMatches(manifest2, matches) {
+  if (!manifest2?.inlineCss) return void 0;
+  const css = getInlineCssForHrefs(manifest2, getInlineCssHrefsForMatches(manifest2, matches));
+  return css === void 0 ? void 0 : createInlineCssStyleAsset(css);
+}
+function stripInlinedStylesheetAssets(manifest2, routes, matches) {
+  if (!manifest2.inlineCss) return routes;
+  const nextRoutes = {};
+  for (const [routeId, route] of Object.entries(routes)) {
+    const assets = route.assets?.filter((asset) => !isInlinableStylesheet(manifest2, asset));
+    const nextRoute = { ...route };
+    if (assets) if (assets.length > 0) nextRoute.assets = assets;
+    else delete nextRoute.assets;
+    nextRoutes[routeId] = nextRoute;
+  }
+  if (getInlineCssAssetForMatches(manifest2, matches)) {
+    const rootRoute = nextRoutes["__root__"] ?? {};
+    nextRoutes[rootRouteId] = {
+      ...rootRoute,
+      assets: [createInlineCssPlaceholderAsset(), ...rootRoute.assets ?? []]
+    };
+  }
+  return nextRoutes;
+}
+function attachRouterServerSsrUtils({ router, manifest: manifest2, getRequestAssets, includeUnmatchedRouteAssets = true }) {
+  router.ssr = { get manifest() {
+    const requestAssets = getRequestAssets?.();
+    const inlineCssAsset = getInlineCssAssetForMatches(manifest2, router.stores.matches.get());
+    if (!requestAssets?.length && !inlineCssAsset) return manifest2;
+    return {
+      ...manifest2,
+      routes: {
+        ...manifest2?.routes,
+        [rootRouteId]: {
+          ...manifest2?.routes?.[rootRouteId],
+          assets: [
+            ...requestAssets ?? [],
+            ...inlineCssAsset ? [inlineCssAsset] : [],
+            ...manifest2?.routes?.["__root__"]?.assets ?? []
+          ]
+        }
+      }
+    };
+  } };
+  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 (opts) => {
+      if (_dehydrated) {
+        invariant();
+      }
+      let matchesToDehydrate = router.stores.matches.get();
+      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")}\0includeUnmatchedRouteAssets=${includeUnmatchedRouteAssets}`;
+        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 (includeUnmatchedRouteAssets && routeManifest.assets && routeManifest.assets.length > 0) nextFilteredRoutes[routeId] = { assets: routeManifest.assets };
+          }
+          filteredRoutes = stripInlinedStylesheetAssets(manifest2, nextFilteredRoutes, matchesToDehydrate);
+          getManifestCache(manifest2).set(manifestCacheKey, filteredRoutes);
+        }
+        manifestToDehydrate = { routes: { ...filteredRoutes } };
+        if (opts?.requestAssets?.length) {
+          const existingRoot = manifestToDehydrate.routes[rootRouteId];
+          manifestToDehydrate.routes[rootRouteId] = {
+            ...existingRoot,
+            assets: [...opts.requestAssets, ...existingRoot?.assets ?? []]
+          };
+        }
+      }
+      const dehydratedRouter = {
+        manifest: manifestToDehydrate,
+        matches
+      };
+      const lastMatchId = matchesToDehydrate[matchesToDehydrate.length - 1]?.id;
+      if (lastMatchId) dehydratedRouter.lastMatchId = dehydrateSsrMatchId(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) => /* @__PURE__ */ 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;
+        }
+      };
+      Sn(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);
+        },
+        onError: (err) => {
+          console.error("Serialization error:", err);
+          if (err && err.stack) console.error(err.stack);
+          signalSerializationComplete();
+        },
+        scopeId: SCOPE_ID,
+        onDone: () => {
+          scriptBuffer.enqueue(GLOBAL_TSR + ".e()");
+          scriptBuffer.flush();
+          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();
+      return {
+        tag: "script",
+        attrs: {
+          nonce: router.options.ssr?.nonce,
+          className: "$tsr",
+          id: TSR_SCRIPT_BARRIER_ID
+        },
+        children: scripts
+      };
+    },
+    liftScriptBarrier() {
+      scriptBuffer.liftBarrier();
+    },
+    takeBufferedHtml() {
+      if (!injectedHtmlBuffer) return;
+      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
+  };
+}
+function getStartResponseHeaders(opts) {
+  return mergeHeaders({ "Content-Type": "text/html; charset=utf-8" }, ...opts.router.stores.matches.get().map((match) => {
+    return match.headers;
+  }));
+}
+var entriesPromise;
+var defaultCsrfMiddleware = createCsrfMiddleware({ filter: (ctx) => ctx.handlerType === "serverFn" });
+var getCachedBaseManifest = createCachedBaseManifestLoader(() => getStartManifest());
+var getProdBaseManifest = () => getCachedBaseManifest();
+var getBaseManifest = getProdBaseManifest;
+var createEarlyHintsForRequest = createEarlyHintsCollector;
+async function loadEntries() {
+  const [routerEntry, startEntry, pluginAdapters] = await Promise.all([
+    import("./router-CUAfx91O.mjs").then((n2) => n2.b),
+    Promise.resolve().then(() => start),
+    import("../__23tanstack-start-plugin-adapters-Cwee5PKy.mjs")
+  ]);
+  return {
+    routerEntry,
+    startEntry,
+    pluginAdapters
+  };
+}
+function getEntries() {
+  if (!entriesPromise) entriesPromise = loadEntries();
+  return entriesPromise;
+}
+var ROUTER_BASEPATH = "/";
+var SERVER_FN_BASE = "/_serverFn/";
+var IS_PRERENDERING = process.env.TSS_PRERENDERING === "true";
+var IS_SHELL_ENV = process.env.TSS_SHELL === "true";
+var ERR_NO_RESPONSE = "Internal Server Error";
+var 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 handlerOptions = typeof cbOrOptions === "function" ? {} : cbOrOptions;
+  const cb = typeof cbOrOptions === "function" ? cbOrOptions : cbOrOptions.handler;
+  const finalManifestResolver = createFinalManifestResolver({
+    ...handlerOptions
+  });
+  const resolveManifestForRequest = finalManifestResolver.resolveCached;
+  finalManifestResolver.warmup({ getBaseManifest: () => getBaseManifest() });
+  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 hasStartInstance = !!entries.startEntry.startInstance;
+      const startOptions = await entries.startEntry.startInstance?.getOptions() || {};
+      const { hasPluginAdapters, pluginSerializationAdapters } = entries.pluginAdapters;
+      const serializationAdapters = [
+        ...startOptions.serializationAdapters || [],
+        ...hasPluginAdapters ? pluginSerializationAdapters : [],
+        ServerFunctionSerializationAdapter
+      ];
+      const requestStartOptions = {
+        ...startOptions,
+        requestMiddleware: hasStartInstance ? startOptions.requestMiddleware : [defaultCsrfMiddleware],
+        serializationAdapters
+      };
+      const flattenedRequestMiddlewares = requestStartOptions.requestMiddleware ? flattenMiddlewares(requestStartOptions.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)) {
+        if (false) ;
+        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,
+            handlerType: "serverFn"
+          }, () => handleServerAction({
+            request,
+            context: requestOpts?.context,
+            serverFnId
+          }));
+        };
+        return handleRedirectResponse((await executeMiddleware([...flattenedRequestMiddlewares.map((d) => d.options.server), serverFnHandler], {
+          request,
+          pathname: url.pathname,
+          handlerType: "serverFn",
+          context: createNullProtoObject(requestOpts?.context)
+        })).response, request, getRouter);
+      }
+      const executeRouter = async (serverContext, matchedRoutes) => {
+        const acceptParts = (request.headers.get("Accept") || "*/*").split(",");
+        if (!["*/*", "text/html"].some((mimeType) => acceptParts.some((part) => part.trim().startsWith(mimeType)))) return Response.json({ error: "Only HTML requests are supported here" }, { status: 500 });
+        const manifest2 = await resolveManifestForRequest({
+          request,
+          requestInlineCss: requestOpts?.inlineCss,
+          getBaseManifest: () => getBaseManifest(matchedRoutes)
+        });
+        const earlyHints = createEarlyHintsForRequest({
+          onEarlyHints: requestOpts?.onEarlyHints,
+          responseLinkHeader: requestOpts?.responseLinkHeader
+        });
+        earlyHints?.collectStatic({
+          manifest: manifest2,
+          matchedRoutes
+        });
+        const routerInstance = await getRouter();
+        attachRouterServerSsrUtils({
+          router: routerInstance,
+          manifest: manifest2,
+          getRequestAssets: () => getStartContext({ throwIfNotFound: false })?.requestAssets,
+          includeUnmatchedRouteAssets: false
+        });
+        routerInstance.update({ additionalContext: { serverContext } });
+        await routerInstance.load();
+        if (routerInstance.state.redirect) return routerInstance.state.redirect;
+        earlyHints?.collectDynamic(routerInstance.stores.matches.get());
+        const ctx = getStartContext({ throwIfNotFound: false });
+        await routerInstance.serverSsr.dehydrate({ requestAssets: ctx?.requestAssets });
+        const responseHeaders = getStartResponseHeaders({ router: routerInstance });
+        earlyHints?.appendResponseHeaders(responseHeaders);
+        cbWillCleanup = true;
+        return cb({
+          request,
+          router: routerInstance,
+          responseHeaders
+        });
+      };
+      const requestHandlerMiddleware = async ({ context }) => {
+        return runWithStartContext({
+          getRouter,
+          startOptions: requestStartOptions,
+          contextAfterGlobalMiddlewares: context,
+          request,
+          executedRequestMiddlewares,
+          handlerType: "router"
+        }, async () => {
+          try {
+            return await handleServerRoutes({
+              getRouter,
+              request,
+              url,
+              executeRouter,
+              context,
+              executedRequestMiddlewares
+            });
+          } catch (err) {
+            if (err instanceof Response) return err;
+            throw err;
+          }
+        });
+      };
+      return handleRedirectResponse((await executeMiddleware([...flattenedRequestMiddlewares.map((d) => d.options.server), requestHandlerMiddleware], {
+        request,
+        pathname: url.pathname,
+        handlerType: "router",
+        context: createNullProtoObject(requestOpts?.context)
+      })).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 redirect = (await getRouter()).resolveRedirect(response);
+  if (request.headers.get("x-tsr-serverFn") === "true") return Response.json({
+    ...response.options,
+    isSerializedRedirect: true
+  }, { headers: response.headers });
+  return redirect;
+}
+async function handleServerRoutes({ getRouter, request, url, executeRouter, context, executedRequestMiddlewares }) {
+  const router = await getRouter();
+  const pathname = executeRewriteInput(router.rewrite, url).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;
+  let isHeadFallback = false;
+  if (server2?.handlers && isExactMatch) {
+    const handlers = typeof server2.handlers === "function" ? server2.handlers({ createHandlers: (d) => d }) : server2.handlers;
+    const requestMethod = request.method.toUpperCase();
+    const handler = requestMethod === "HEAD" ? handlers["HEAD"] ?? handlers["GET"] ?? handlers["ANY"] : handlers[requestMethod] ?? handlers["ANY"];
+    isHeadFallback = requestMethod === "HEAD" && handler !== void 0 && !handlers["HEAD"];
+    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,
+    handlerType: "router"
+  });
+  if (isHeadFallback) {
+    if (!ctx.response) throwRouteHandlerError();
+    const resolved = await handleRedirectResponse(ctx.response, request, getRouter);
+    return new Response(null, resolved);
+  }
+  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 });
+const startInstance = void 0;
+const start = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  startInstance
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  createServerEntry,
+  server as default
+};