@hot-updater/console 0.28.0 → 0.29.0

package/.output/server/_ssr/ssr.mjs

@@ -0,0 +1,5050 @@
+import { P as require_jsx_runtime } from "../_libs/@radix-ui/react-alert-dialog+[...].mjs";
+import { i as RouterProvider, t as renderRouterToStream } from "../_libs/@tanstack/react-router+[...].mjs";
+import { t as defineHandlerCallback } from "../_libs/tanstack__router-core.mjs";
+import { PassThrough, Readable } from "node:stream";
+import { AsyncLocalStorage } from "node:async_hooks";
+//#region node_modules/.nitro/vite/services/ssr/index.js
+var import_jsx_runtime = require_jsx_runtime();
+function StartServer(props) {
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(RouterProvider, { router: props.router });
+}
+var defaultStreamHandler = defineHandlerCallback(({ request, router, responseHeaders }) => renderRouterToStream({
+	request,
+	router,
+	responseHeaders,
+	children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(StartServer, { router })
+}));
+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((b) => b !== 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: (n) => {
+			index = Math.min(Math.max(index + n, 0), entries.length - 1);
+		},
+		createHref: (path) => path,
+		getBlockers: _getBlockers,
+		setBlockers: _setBlockers
+	});
+}
+function sanitizePath(path) {
+	let sanitized = path.replace(/[\x00-\x1f\x7f]/g, "");
+	if (sanitized.startsWith("//")) sanitized = "/" + sanitized.replace(/^\/+/, "");
+	return sanitized;
+}
+function parseHref(href, state) {
+	const sanitizedHref = sanitizePath(href);
+	const hashIndex = sanitizedHref.indexOf("#");
+	const searchIndex = sanitizedHref.indexOf("?");
+	const addedKey = createRandomKey();
+	return {
+		href: sanitizedHref,
+		pathname: sanitizedHref.substring(0, hashIndex > 0 ? searchIndex > 0 ? Math.min(hashIndex, searchIndex) : hashIndex : searchIndex > 0 ? searchIndex : sanitizedHref.length),
+		hash: hashIndex > -1 ? sanitizedHref.substring(hashIndex) : "",
+		search: searchIndex > -1 ? sanitizedHref.slice(searchIndex, hashIndex === -1 ? void 0 : hashIndex) : "",
+		state: state || {
+			[stateIndexKey]: 0,
+			key: addedKey,
+			__TSR_key: addedKey
+		}
+	};
+}
+function createRandomKey() {
+	return (Math.random() + 1).toString(36).substring(7);
+}
+function splitSetCookieString(cookiesString) {
+	if (Array.isArray(cookiesString)) return cookiesString.flatMap((c) => splitSetCookieString(c));
+	if (typeof cookiesString !== "string") return [];
+	const cookiesStrings = [];
+	let pos = 0;
+	let start;
+	let ch;
+	let lastComma;
+	let nextStart;
+	let cookiesSeparatorFound;
+	const skipWhitespace = () => {
+		while (pos < cookiesString.length && /\s/.test(cookiesString.charAt(pos))) pos += 1;
+		return pos < cookiesString.length;
+	};
+	const notSpecialChar = () => {
+		ch = cookiesString.charAt(pos);
+		return ch !== "=" && ch !== ";" && ch !== ",";
+	};
+	while (pos < cookiesString.length) {
+		start = pos;
+		cookiesSeparatorFound = false;
+		while (skipWhitespace()) {
+			ch = cookiesString.charAt(pos);
+			if (ch === ",") {
+				lastComma = pos;
+				pos += 1;
+				skipWhitespace();
+				nextStart = pos;
+				while (pos < cookiesString.length && notSpecialChar()) pos += 1;
+				if (pos < cookiesString.length && cookiesString.charAt(pos) === "=") {
+					cookiesSeparatorFound = true;
+					pos = nextStart;
+					cookiesStrings.push(cookiesString.slice(start, lastComma));
+					start = pos;
+				} else pos = lastComma + 1;
+			} else pos += 1;
+		}
+		if (!cookiesSeparatorFound || pos >= cookiesString.length) cookiesStrings.push(cookiesString.slice(start));
+	}
+	return cookiesStrings;
+}
+function toHeadersInstance(init) {
+	if (init instanceof Headers) return init;
+	else if (Array.isArray(init)) return new Headers(init);
+	else if (typeof init === "object") return new Headers(init);
+	else return null;
+}
+function mergeHeaders(...headers) {
+	return headers.reduce((acc, header) => {
+		const headersInstance = toHeadersInstance(header);
+		if (!headersInstance) return acc;
+		for (const [key, value] of headersInstance.entries()) if (key === "set-cookie") splitSetCookieString(value).forEach((cookie) => acc.append("set-cookie", cookie));
+		else acc.set(key, value);
+		return acc;
+	}, new Headers());
+}
+var isProduction = true;
+var prefix = "Invariant failed";
+function invariant(condition, message) {
+	if (condition) return;
+	if (isProduction) throw new Error(prefix);
+	var provided = typeof message === "function" ? message() : message;
+	var value = provided ? "".concat(prefix, ": ").concat(provided) : prefix;
+	throw new Error(value);
+}
+function isNotFound(obj) {
+	return !!obj?.isNotFound;
+}
+function sanitizePathSegment(segment) {
+	return segment.replace(/[\x00-\x1f\x7f]/g, "");
+}
+function decodeSegment(segment) {
+	let decoded;
+	try {
+		decoded = decodeURI(segment);
+	} catch {
+		decoded = segment.replaceAll(/%[0-9A-F]{2}/gi, (match) => {
+			try {
+				return decodeURI(match);
+			} catch {
+				return match;
+			}
+		});
+	}
+	return sanitizePathSegment(decoded);
+}
+function decodePath(path) {
+	if (!path) return {
+		path,
+		handledProtocolRelativeURL: false
+	};
+	if (!/[%\\\x00-\x1f\x7f]/.test(path) && !path.startsWith("//")) return {
+		path,
+		handledProtocolRelativeURL: false
+	};
+	const re = /%25|%5C/gi;
+	let cursor = 0;
+	let result = "";
+	let match;
+	while (null !== (match = re.exec(path))) {
+		result += decodeSegment(path.slice(cursor, match.index)) + match[0];
+		cursor = re.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 dehydrateSsrMatchId(id) {
+	return id.replaceAll("/", "\0");
+}
+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;
+		}
+	};
+}
+var rootRouteId = "__root__";
+function redirect(opts) {
+	opts.statusCode = opts.statusCode || opts.code || 307;
+	if (!opts._builtLocation && !opts.reloadDocument && typeof opts.href === "string") try {
+		new URL(opts.href);
+		opts.reloadDocument = true;
+	} catch {}
+	const headers = new Headers(opts.headers);
+	if (opts.href && headers.get("Location") === null) headers.set("Location", opts.href);
+	const response = new Response(null, {
+		status: opts.statusCode,
+		headers
+	});
+	response.options = opts;
+	if (opts.throw) throw response;
+	return response;
+}
+function isRedirect(obj) {
+	return obj instanceof Response && !!obj.options;
+}
+function isResolvedRedirect(obj) {
+	return isRedirect(obj) && !!obj.options.href;
+}
+function parseRedirect(obj) {
+	if (obj !== null && typeof obj === "object" && obj.isSerializedRedirect) return redirect(obj);
+}
+function executeRewriteInput(rewrite, url) {
+	const res = rewrite?.input?.({ url });
+	if (res) {
+		if (typeof res === "string") return new URL(res);
+		else if (res instanceof URL) return res;
+	}
+	return url;
+}
+var L$1 = ((i) => (i[i.AggregateError = 1] = "AggregateError", i[i.ArrowFunction = 2] = "ArrowFunction", i[i.ErrorPrototypeStack = 4] = "ErrorPrototypeStack", i[i.ObjectAssign = 8] = "ObjectAssign", i[i.BigIntTypedArray = 16] = "BigIntTypedArray", i[i.RegExp = 32] = "RegExp", i))(L$1 || {});
+var v$1 = Symbol.asyncIterator, mr = Symbol.hasInstance, R = Symbol.isConcatSpreadable, C = Symbol.iterator, pr = Symbol.match, dr = Symbol.matchAll, gr = Symbol.replace, yr = Symbol.search, Nr = Symbol.species, br = Symbol.split, vr = Symbol.toPrimitive, P$1 = Symbol.toStringTag, Cr = Symbol.unscopables;
+var rt = {
+	0: "Symbol.asyncIterator",
+	1: "Symbol.hasInstance",
+	2: "Symbol.isConcatSpreadable",
+	3: "Symbol.iterator",
+	4: "Symbol.match",
+	5: "Symbol.matchAll",
+	6: "Symbol.replace",
+	7: "Symbol.search",
+	8: "Symbol.species",
+	9: "Symbol.split",
+	10: "Symbol.toPrimitive",
+	11: "Symbol.toStringTag",
+	12: "Symbol.unscopables"
+}, ve = {
+	[v$1]: 0,
+	[mr]: 1,
+	[R]: 2,
+	[C]: 3,
+	[pr]: 4,
+	[dr]: 5,
+	[gr]: 6,
+	[yr]: 7,
+	[Nr]: 8,
+	[br]: 9,
+	[vr]: 10,
+	[P$1]: 11,
+	[Cr]: 12
+}, tt = {
+	0: v$1,
+	1: mr,
+	2: R,
+	3: C,
+	4: pr,
+	5: dr,
+	6: gr,
+	7: yr,
+	8: Nr,
+	9: br,
+	10: vr,
+	11: P$1,
+	12: Cr
+}, nt = {
+	2: "!0",
+	3: "!1",
+	1: "void 0",
+	0: "null",
+	4: "-0",
+	5: "1/0",
+	6: "-1/0",
+	7: "0/0"
+}, o$1 = void 0, ot = {
+	2: !0,
+	3: !1,
+	1: o$1,
+	0: null,
+	4: -0,
+	5: Number.POSITIVE_INFINITY,
+	6: Number.NEGATIVE_INFINITY,
+	7: NaN
+};
+var Ce = {
+	0: "Error",
+	1: "EvalError",
+	2: "RangeError",
+	3: "ReferenceError",
+	4: "SyntaxError",
+	5: "TypeError",
+	6: "URIError"
+}, at = {
+	0: Error,
+	1: EvalError,
+	2: RangeError,
+	3: ReferenceError,
+	4: SyntaxError,
+	5: TypeError,
+	6: URIError
+};
+function c$1(e, r, t, n, a, s, i, u, l, g, S, d) {
+	return {
+		t: e,
+		i: r,
+		s: t,
+		c: n,
+		m: a,
+		p: s,
+		e: i,
+		a: u,
+		f: l,
+		b: g,
+		o: S,
+		l: d
+	};
+}
+function F(e) {
+	return c$1(2, o$1, e, o$1, o$1, o$1, o$1, o$1, o$1, o$1, o$1, o$1);
+}
+var J = F(2), Z = F(3), Ae = F(1), Ee = F(0), st = F(4), it = F(5), ut = F(6), lt = F(7);
+function fn(e) {
+	switch (e) {
+		case "\"": return "\\\"";
+		case "\\": return "\\\\";
+		case `
+`: return "\\n";
+		case "\r": return "\\r";
+		case "\b": return "\\b";
+		case "	": return "\\t";
+		case "\f": return "\\f";
+		case "<": return "\\x3C";
+		case "\u2028": return "\\u2028";
+		case "\u2029": return "\\u2029";
+		default: return o$1;
+	}
+}
+function y$1(e) {
+	let r = "", t = 0, n;
+	for (let a = 0, s = e.length; a < s; a++) n = fn(e[a]), n && (r += e.slice(t, a) + n, t = a + 1);
+	return t === 0 ? r = e : r += e.slice(t), r;
+}
+function Sn(e) {
+	switch (e) {
+		case "\\\\": return "\\";
+		case "\\\"": return "\"";
+		case "\\n": return `
+`;
+		case "\\r": return "\r";
+		case "\\b": return "\b";
+		case "\\t": return "	";
+		case "\\f": return "\f";
+		case "\\x3C": return "<";
+		case "\\u2028": return "\u2028";
+		case "\\u2029": return "\u2029";
+		default: return e;
+	}
+}
+function B$1(e) {
+	return e.replace(/(\\\\|\\"|\\n|\\r|\\b|\\t|\\f|\\u2028|\\u2029|\\x3C)/g, Sn);
+}
+var U = "__SEROVAL_REFS__", ce = "$R", Ie = `self.${ce}`;
+function mn(e) {
+	return e == null ? `${Ie}=${Ie}||[]` : `(${Ie}=${Ie}||{})["${y$1(e)}"]=[]`;
+}
+var Ar = /* @__PURE__ */ new Map(), j = /* @__PURE__ */ new Map();
+function Er(e) {
+	return Ar.has(e);
+}
+function dn(e) {
+	return j.has(e);
+}
+function ct(e) {
+	if (Er(e)) return Ar.get(e);
+	throw new Re(e);
+}
+function ft(e) {
+	if (dn(e)) return j.get(e);
+	throw new Pe(e);
+}
+typeof globalThis != "undefined" ? Object.defineProperty(globalThis, U, {
+	value: j,
+	configurable: !0,
+	writable: !1,
+	enumerable: !1
+}) : typeof window != "undefined" ? Object.defineProperty(window, U, {
+	value: j,
+	configurable: !0,
+	writable: !1,
+	enumerable: !1
+}) : typeof self != "undefined" ? Object.defineProperty(self, U, {
+	value: j,
+	configurable: !0,
+	writable: !1,
+	enumerable: !1
+}) : typeof global != "undefined" && Object.defineProperty(global, U, {
+	value: j,
+	configurable: !0,
+	writable: !1,
+	enumerable: !1
+});
+function xe(e) {
+	return e instanceof EvalError ? 1 : e instanceof RangeError ? 2 : e instanceof ReferenceError ? 3 : e instanceof SyntaxError ? 4 : e instanceof TypeError ? 5 : e instanceof URIError ? 6 : 0;
+}
+function gn(e) {
+	let r = Ce[xe(e)];
+	return e.name !== r ? { name: e.name } : e.constructor.name !== r ? { name: e.constructor.name } : {};
+}
+function $$1(e, r) {
+	let t = gn(e), n = Object.getOwnPropertyNames(e);
+	for (let a = 0, s = n.length, i; a < s; a++) i = n[a], i !== "name" && i !== "message" && (i === "stack" ? r & 4 && (t = t || {}, t[i] = e[i]) : (t = t || {}, t[i] = e[i]));
+	return t;
+}
+function Oe(e) {
+	return Object.isFrozen(e) ? 3 : Object.isSealed(e) ? 2 : Object.isExtensible(e) ? 0 : 1;
+}
+function Te(e) {
+	switch (e) {
+		case Number.POSITIVE_INFINITY: return it;
+		case Number.NEGATIVE_INFINITY: return ut;
+	}
+	return e !== e ? lt : Object.is(e, -0) ? st : c$1(0, o$1, e, o$1, o$1, o$1, o$1, o$1, o$1, o$1, o$1, o$1);
+}
+function X(e) {
+	return c$1(1, o$1, y$1(e), o$1, o$1, o$1, o$1, o$1, o$1, o$1, o$1, o$1);
+}
+function we(e) {
+	return c$1(3, o$1, "" + e, o$1, o$1, o$1, o$1, o$1, o$1, o$1, o$1, o$1);
+}
+function mt(e) {
+	return c$1(4, e, o$1, o$1, o$1, o$1, o$1, o$1, o$1, o$1, o$1, o$1);
+}
+function he(e, r) {
+	let t = r.valueOf();
+	return c$1(5, e, t !== t ? "" : r.toISOString(), o$1, o$1, o$1, o$1, o$1, o$1, o$1, o$1, o$1);
+}
+function ze(e, r) {
+	return c$1(6, e, o$1, y$1(r.source), r.flags, o$1, o$1, o$1, o$1, o$1, o$1, o$1);
+}
+function pt(e, r) {
+	return c$1(17, e, ve[r], o$1, o$1, o$1, o$1, o$1, o$1, o$1, o$1, o$1);
+}
+function dt(e, r) {
+	return c$1(18, e, y$1(ct(r)), o$1, o$1, o$1, o$1, o$1, o$1, o$1, o$1, o$1);
+}
+function fe$1(e, r, t) {
+	return c$1(25, e, t, y$1(r), o$1, o$1, o$1, o$1, o$1, o$1, o$1, o$1);
+}
+function _e(e, r, t) {
+	return c$1(9, e, o$1, o$1, o$1, o$1, o$1, t, o$1, o$1, Oe(r), o$1);
+}
+function ke(e, r) {
+	return c$1(21, e, o$1, o$1, o$1, o$1, o$1, o$1, r, o$1, o$1, o$1);
+}
+function De(e, r, t) {
+	return c$1(15, e, o$1, r.constructor.name, o$1, o$1, o$1, o$1, t, r.byteOffset, o$1, r.length);
+}
+function Fe(e, r, t) {
+	return c$1(16, e, o$1, r.constructor.name, o$1, o$1, o$1, o$1, t, r.byteOffset, o$1, r.byteLength);
+}
+function Be(e, r, t) {
+	return c$1(20, e, o$1, o$1, o$1, o$1, o$1, o$1, t, r.byteOffset, o$1, r.byteLength);
+}
+function Ve(e, r, t) {
+	return c$1(13, e, xe(r), o$1, y$1(r.message), t, o$1, o$1, o$1, o$1, o$1, o$1);
+}
+function Me(e, r, t) {
+	return c$1(14, e, xe(r), o$1, y$1(r.message), t, o$1, o$1, o$1, o$1, o$1, o$1);
+}
+function Le(e, r) {
+	return c$1(7, e, o$1, o$1, o$1, o$1, o$1, r, o$1, o$1, o$1, o$1);
+}
+function Ue(e, r) {
+	return c$1(28, o$1, o$1, o$1, o$1, o$1, o$1, [e, r], o$1, o$1, o$1, o$1);
+}
+function je(e, r) {
+	return c$1(30, o$1, o$1, o$1, o$1, o$1, o$1, [e, r], o$1, o$1, o$1, o$1);
+}
+function Ye(e, r, t) {
+	return c$1(31, e, o$1, o$1, o$1, o$1, o$1, t, r, o$1, o$1, o$1);
+}
+function qe(e, r) {
+	return c$1(32, e, o$1, o$1, o$1, o$1, o$1, o$1, r, o$1, o$1, o$1);
+}
+function We(e, r) {
+	return c$1(33, e, o$1, o$1, o$1, o$1, o$1, o$1, r, o$1, o$1, o$1);
+}
+function Ge(e, r) {
+	return c$1(34, e, o$1, o$1, o$1, o$1, o$1, o$1, r, o$1, o$1, o$1);
+}
+function Ke(e, r, t, n) {
+	return c$1(35, e, t, o$1, o$1, o$1, o$1, r, o$1, o$1, o$1, n);
+}
+var { toString: ys } = Object.prototype;
+var yn = {
+	parsing: 1,
+	serialization: 2,
+	deserialization: 3
+};
+function Nn(e) {
+	return `Seroval Error (step: ${yn[e]})`;
+}
+var bn = (e, r) => Nn(e), Se = class extends Error {
+	constructor(t, n) {
+		super(bn(t, n));
+		this.cause = n;
+	}
+}, z = class extends Se {
+	constructor(r) {
+		super("parsing", r);
+	}
+}, He = class extends Se {
+	constructor(r) {
+		super("deserialization", r);
+	}
+};
+function _(e) {
+	return `Seroval Error (specific: ${e})`;
+}
+var x$1 = class extends Error {
+	constructor(t) {
+		super(_(1));
+		this.value = t;
+	}
+}, w$1 = class extends Error {
+	constructor(r) {
+		super(_(2));
+	}
+}, Q = class extends Error {
+	constructor(r) {
+		super(_(3));
+	}
+}, V = class extends Error {
+	constructor(r) {
+		super(_(4));
+	}
+}, Re = class extends Error {
+	constructor(t) {
+		super(_(5));
+		this.value = t;
+	}
+}, Pe = class extends Error {
+	constructor(r) {
+		super(_(6));
+	}
+}, Je = class extends Error {
+	constructor(r) {
+		super(_(7));
+	}
+}, h$1 = class extends Error {
+	constructor(r) {
+		super(_(8));
+	}
+};
+var ee = class extends Error {
+	constructor(r) {
+		super(_(9));
+	}
+};
+var Y$1 = class {
+	constructor(r, t) {
+		this.value = r;
+		this.replacement = t;
+	}
+};
+var re = () => {
+	let e = {
+		p: 0,
+		s: 0,
+		f: 0
+	};
+	return e.p = new Promise((r, t) => {
+		e.s = r, e.f = t;
+	}), e;
+}, vn = (e, r) => {
+	e.s(r), e.p.s = 1, e.p.v = r;
+}, Cn = (e, r) => {
+	e.f(r), e.p.s = 2, e.p.v = r;
+}, yt = re.toString(), Nt = vn.toString(), bt = Cn.toString(), Rr = () => {
+	let e = [], r = [], t = !0, n = !1, 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[n ? "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__: !0,
+		on: (l) => u(l),
+		next: (l) => {
+			t && (e.push(l), s(l, "next"));
+		},
+		throw: (l) => {
+			t && (e.push(l), s(l, "throw"), t = !1, n = !1, r.length = 0);
+		},
+		return: (l) => {
+			t && (e.push(l), s(l, "return"), t = !1, n = !0, r.length = 0);
+		}
+	};
+}, vt = Rr.toString(), Pr = (e) => (r) => () => {
+	let t = 0, n = {
+		[e]: () => n,
+		next: () => {
+			if (t > r.d) return {
+				done: !0,
+				value: void 0
+			};
+			let a = t++, s = r.v[a];
+			if (a === r.t) throw s;
+			return {
+				done: a === r.d,
+				value: s
+			};
+		}
+	};
+	return n;
+}, Ct = Pr.toString(), xr = (e, r) => (t) => () => {
+	let n = 0, a = -1, s = !1, i = [], u = [], l = (S = 0, d = u.length) => {
+		for (; S < d; S++) u[S].s({
+			done: !0,
+			value: void 0
+		});
+	};
+	t.on({
+		next: (S) => {
+			let d = u.shift();
+			d && d.s({
+				done: !1,
+				value: S
+			}), i.push(S);
+		},
+		throw: (S) => {
+			let d = u.shift();
+			d && d.f(S), l(), a = i.length, s = !0, i.push(S);
+		},
+		return: (S) => {
+			let d = u.shift();
+			d && d.s({
+				done: !0,
+				value: S
+			}), l(), a = i.length, i.push(S);
+		}
+	});
+	let g = {
+		[e]: () => g,
+		next: () => {
+			if (a === -1) {
+				let K = n++;
+				if (K >= i.length) {
+					let et = r();
+					return u.push(et), et.p;
+				}
+				return {
+					done: !1,
+					value: i[K]
+				};
+			}
+			if (n > a) return {
+				done: !0,
+				value: void 0
+			};
+			let S = n++, d = i[S];
+			if (S !== a) return {
+				done: !1,
+				value: d
+			};
+			if (s) throw d;
+			return {
+				done: !0,
+				value: d
+			};
+		}
+	};
+	return g;
+}, At = xr.toString(), Or = (e) => {
+	let r = atob(e), t = r.length, n = new Uint8Array(t);
+	for (let a = 0; a < t; a++) n[a] = r.charCodeAt(a);
+	return n.buffer;
+}, Et = Or.toString();
+function Ze(e) {
+	return "__SEROVAL_SEQUENCE__" in e;
+}
+function Tr(e, r, t) {
+	return {
+		__SEROVAL_SEQUENCE__: !0,
+		v: e,
+		t: r,
+		d: t
+	};
+}
+function $e(e) {
+	let r = [], t = -1, n = -1, a = e[C]();
+	for (;;) try {
+		let s = a.next();
+		if (r.push(s.value), s.done) {
+			n = r.length - 1;
+			break;
+		}
+	} catch (s) {
+		t = r.length, r.push(s);
+	}
+	return Tr(r, t, n);
+}
+var An = Pr(C);
+function It(e) {
+	return An(e);
+}
+var Rt = {}, Pt = {};
+var xt = {
+	0: {},
+	1: {},
+	2: {},
+	3: {},
+	4: {},
+	5: {}
+}, Ot = {
+	0: "[]",
+	1: yt,
+	2: Nt,
+	3: bt,
+	4: vt,
+	5: Et
+};
+function M(e) {
+	return "__SEROVAL_STREAM__" in e;
+}
+function te$1() {
+	return Rr();
+}
+function Xe(e) {
+	let r = te$1(), t = e[v$1]();
+	async function n() {
+		try {
+			let a = await t.next();
+			a.done ? r.return(a.value) : (r.next(a.value), await n());
+		} catch (a) {
+			r.throw(a);
+		}
+	}
+	return n().catch(() => {}), r;
+}
+var En = xr(v$1, re);
+function Tt(e) {
+	return En(e);
+}
+async function wr(e) {
+	try {
+		return [1, await e];
+	} catch (r) {
+		return [0, r];
+	}
+}
+function pe$1(e, r) {
+	return {
+		plugins: r.plugins,
+		mode: e,
+		marked: /* @__PURE__ */ new Set(),
+		features: 63 ^ (r.disabledFeatures || 0),
+		refs: r.refs || /* @__PURE__ */ new Map(),
+		depthLimit: r.depthLimit || 1e3
+	};
+}
+function de(e, r) {
+	e.marked.add(r);
+}
+function hr(e, r) {
+	let t = e.refs.size;
+	return e.refs.set(r, t), t;
+}
+function Qe(e, r) {
+	let t = e.refs.get(r);
+	return t != null ? (de(e, t), {
+		type: 1,
+		value: mt(t)
+	}) : {
+		type: 0,
+		value: hr(e, r)
+	};
+}
+function q$1(e, r) {
+	let t = Qe(e, r);
+	return t.type === 1 ? t : Er(r) ? {
+		type: 2,
+		value: dt(t.value, r)
+	} : t;
+}
+function I(e, r) {
+	let t = q$1(e, r);
+	if (t.type !== 0) return t.value;
+	if (r in ve) return pt(t.value, r);
+	throw new x$1(r);
+}
+function k(e, r) {
+	let t = Qe(e, xt[r]);
+	return t.type === 1 ? t.value : c$1(26, t.value, r, o$1, o$1, o$1, o$1, o$1, o$1, o$1, o$1, o$1);
+}
+function er(e) {
+	let r = Qe(e, Rt);
+	return r.type === 1 ? r.value : c$1(27, r.value, o$1, o$1, o$1, o$1, o$1, o$1, I(e, C), o$1, o$1, o$1);
+}
+function rr(e) {
+	let r = Qe(e, Pt);
+	return r.type === 1 ? r.value : c$1(29, r.value, o$1, o$1, o$1, o$1, o$1, [k(e, 1), I(e, v$1)], o$1, o$1, o$1, o$1);
+}
+function tr(e, r, t, n) {
+	return c$1(t ? 11 : 10, e, o$1, o$1, o$1, n, o$1, o$1, o$1, o$1, Oe(r), o$1);
+}
+function nr(e, r, t, n) {
+	return c$1(8, r, o$1, o$1, o$1, o$1, {
+		k: t,
+		v: n
+	}, o$1, k(e, 0), o$1, o$1, o$1);
+}
+function ht(e, r, t) {
+	return c$1(22, r, t, o$1, o$1, o$1, o$1, o$1, k(e, 1), o$1, o$1, o$1);
+}
+function or(e, r, t) {
+	let n = new Uint8Array(t), a = "";
+	for (let s = 0, i = n.length; s < i; s++) a += String.fromCharCode(n[s]);
+	return c$1(19, r, y$1(btoa(a)), o$1, o$1, o$1, o$1, o$1, k(e, 5), o$1, o$1, o$1);
+}
+function ne$1(e, r) {
+	return {
+		base: pe$1(e, r),
+		child: void 0
+	};
+}
+var _r = class {
+	constructor(r, t) {
+		this._p = r;
+		this.depth = t;
+	}
+	parse(r) {
+		return N$1(this._p, this.depth, r);
+	}
+};
+async function Rn(e, r, t) {
+	let n = [];
+	for (let a = 0, s = t.length; a < s; a++) a in t ? n[a] = await N$1(e, r, t[a]) : n[a] = 0;
+	return n;
+}
+async function Pn(e, r, t, n) {
+	return _e(t, n, await Rn(e, r, n));
+}
+async function kr(e, r, t) {
+	let n = Object.entries(t), a = [], s = [];
+	for (let i = 0, u = n.length; i < u; i++) a.push(y$1(n[i][0])), s.push(await N$1(e, r, n[i][1]));
+	return C in t && (a.push(I(e.base, C)), s.push(Ue(er(e.base), await N$1(e, r, $e(t))))), v$1 in t && (a.push(I(e.base, v$1)), s.push(je(rr(e.base), await N$1(e, r, Xe(t))))), P$1 in t && (a.push(I(e.base, P$1)), s.push(X(t[P$1]))), R in t && (a.push(I(e.base, R)), s.push(t[R] ? J : Z)), {
+		k: a,
+		v: s
+	};
+}
+async function zr(e, r, t, n, a) {
+	return tr(t, n, a, await kr(e, r, n));
+}
+async function xn(e, r, t, n) {
+	return ke(t, await N$1(e, r, n.valueOf()));
+}
+async function On(e, r, t, n) {
+	return De(t, n, await N$1(e, r, n.buffer));
+}
+async function Tn(e, r, t, n) {
+	return Fe(t, n, await N$1(e, r, n.buffer));
+}
+async function wn(e, r, t, n) {
+	return Be(t, n, await N$1(e, r, n.buffer));
+}
+async function zt(e, r, t, n) {
+	let a = $$1(n, e.base.features);
+	return Ve(t, n, a ? await kr(e, r, a) : o$1);
+}
+async function hn(e, r, t, n) {
+	let a = $$1(n, e.base.features);
+	return Me(t, n, a ? await kr(e, r, a) : o$1);
+}
+async function zn(e, r, t, n) {
+	let a = [], s = [];
+	for (let [i, u] of n.entries()) a.push(await N$1(e, r, i)), s.push(await N$1(e, r, u));
+	return nr(e.base, t, a, s);
+}
+async function _n(e, r, t, n) {
+	let a = [];
+	for (let s of n.keys()) a.push(await N$1(e, r, s));
+	return Le(t, a);
+}
+async function _t(e, r, t, n) {
+	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(n)) return fe$1(t, u.tag, await u.parse.async(n, new _r(e, r), { id: t }));
+	}
+	return o$1;
+}
+async function kn(e, r, t, n) {
+	let [a, s] = await wr(n);
+	return c$1(12, t, a, o$1, o$1, o$1, o$1, o$1, await N$1(e, r, s), o$1, o$1, o$1);
+}
+function Dn(e, r, t, n, a) {
+	let s = [], i = t.on({
+		next: (u) => {
+			de(this.base, r), N$1(this, e, u).then((l) => {
+				s.push(qe(r, l));
+			}, (l) => {
+				a(l), i();
+			});
+		},
+		throw: (u) => {
+			de(this.base, r), N$1(this, e, u).then((l) => {
+				s.push(We(r, l)), n(s), i();
+			}, (l) => {
+				a(l), i();
+			});
+		},
+		return: (u) => {
+			de(this.base, r), N$1(this, e, u).then((l) => {
+				s.push(Ge(r, l)), n(s), i();
+			}, (l) => {
+				a(l), i();
+			});
+		}
+	});
+}
+async function Fn(e, r, t, n) {
+	return Ye(t, k(e.base, 4), await new Promise(Dn.bind(e, r, t, n)));
+}
+async function Bn(e, r, t, n) {
+	let a = [];
+	for (let s = 0, i = n.v.length; s < i; s++) a[s] = await N$1(e, r, n.v[s]);
+	return Ke(t, a, n.t, n.d);
+}
+async function Vn(e, r, t, n) {
+	if (Array.isArray(n)) return Pn(e, r, t, n);
+	if (M(n)) return Fn(e, r, t, n);
+	if (Ze(n)) return Bn(e, r, t, n);
+	let a = n.constructor;
+	if (a === Y$1) return N$1(e, r, n.replacement);
+	let s = await _t(e, r, t, n);
+	if (s) return s;
+	switch (a) {
+		case Object: return zr(e, r, t, n, !1);
+		case o$1: return zr(e, r, t, n, !0);
+		case Date: return he(t, n);
+		case Error:
+		case EvalError:
+		case RangeError:
+		case ReferenceError:
+		case SyntaxError:
+		case TypeError:
+		case URIError: return zt(e, r, t, n);
+		case Number:
+		case Boolean:
+		case String:
+		case BigInt: return xn(e, r, t, n);
+		case ArrayBuffer: return or(e.base, t, n);
+		case Int8Array:
+		case Int16Array:
+		case Int32Array:
+		case Uint8Array:
+		case Uint16Array:
+		case Uint32Array:
+		case Uint8ClampedArray:
+		case Float32Array:
+		case Float64Array: return On(e, r, t, n);
+		case DataView: return wn(e, r, t, n);
+		case Map: return zn(e, r, t, n);
+		case Set: return _n(e, r, t, n);
+		default: break;
+	}
+	if (a === Promise || n instanceof Promise) return kn(e, r, t, n);
+	let i = e.base.features;
+	if (i & 32 && a === RegExp) return ze(t, n);
+	if (i & 16) switch (a) {
+		case BigInt64Array:
+		case BigUint64Array: return Tn(e, r, t, n);
+		default: break;
+	}
+	if (i & 1 && typeof AggregateError != "undefined" && (a === AggregateError || n instanceof AggregateError)) return hn(e, r, t, n);
+	if (n instanceof Error) return zt(e, r, t, n);
+	if (C in n || v$1 in n) return zr(e, r, t, n, !!a);
+	throw new x$1(n);
+}
+async function Mn(e, r, t) {
+	let n = q$1(e.base, t);
+	if (n.type !== 0) return n.value;
+	let a = await _t(e, r, n.value, t);
+	if (a) return a;
+	throw new x$1(t);
+}
+async function N$1(e, r, t) {
+	switch (typeof t) {
+		case "boolean": return t ? J : Z;
+		case "undefined": return Ae;
+		case "string": return X(t);
+		case "number": return Te(t);
+		case "bigint": return we(t);
+		case "object":
+			if (t) {
+				let n = q$1(e.base, t);
+				return n.type === 0 ? await Vn(e, r + 1, n.value, t) : n.value;
+			}
+			return Ee;
+		case "symbol": return I(e.base, t);
+		case "function": return Mn(e, r, t);
+		default: throw new x$1(t);
+	}
+}
+async function oe(e, r) {
+	try {
+		return await N$1(e, 0, r);
+	} catch (t) {
+		throw t instanceof z ? t : new z(t);
+	}
+}
+var ae = ((t) => (t[t.Vanilla = 1] = "Vanilla", t[t.Cross = 2] = "Cross", t))(ae || {});
+function ni(e) {
+	return e;
+}
+function kt(e, r) {
+	for (let t = 0, n = r.length; t < n; t++) {
+		let a = r[t];
+		e.has(a) || (e.add(a), a.extends && kt(e, a.extends));
+	}
+}
+function A(e) {
+	if (e) {
+		let r = /* @__PURE__ */ new Set();
+		return kt(r, e), [...r];
+	}
+}
+function Dt(e) {
+	switch (e) {
+		case "Int8Array": return Int8Array;
+		case "Int16Array": return Int16Array;
+		case "Int32Array": return Int32Array;
+		case "Uint8Array": return Uint8Array;
+		case "Uint16Array": return Uint16Array;
+		case "Uint32Array": return Uint32Array;
+		case "Uint8ClampedArray": return Uint8ClampedArray;
+		case "Float32Array": return Float32Array;
+		case "Float64Array": return Float64Array;
+		case "BigInt64Array": return BigInt64Array;
+		case "BigUint64Array": return BigUint64Array;
+		default: throw new Je(e);
+	}
+}
+var Ln = 1e6, Un = 1e4, jn = 2e4;
+function Bt(e, r) {
+	switch (r) {
+		case 3: return Object.freeze(e);
+		case 1: return Object.preventExtensions(e);
+		case 2: return Object.seal(e);
+		default: return e;
+	}
+}
+var Yn = 1e3;
+function Vt(e, r) {
+	var t;
+	return {
+		mode: e,
+		plugins: r.plugins,
+		refs: r.refs || /* @__PURE__ */ new Map(),
+		features: (t = r.features) != null ? t : 63 ^ (r.disabledFeatures || 0),
+		depthLimit: r.depthLimit || Yn
+	};
+}
+function Mt(e) {
+	return {
+		mode: 1,
+		base: Vt(1, e),
+		child: o$1,
+		state: { marked: new Set(e.markedRefs) }
+	};
+}
+var Dr = class {
+	constructor(r, t) {
+		this._p = r;
+		this.depth = t;
+	}
+	deserialize(r) {
+		return p$1(this._p, this.depth, r);
+	}
+};
+function Ut(e, r) {
+	if (r < 0 || !Number.isFinite(r) || !Number.isInteger(r)) throw new h$1({
+		t: 4,
+		i: r
+	});
+	if (e.refs.has(r)) throw new Error("Conflicted ref id: " + r);
+}
+function qn(e, r, t) {
+	return Ut(e.base, r), e.state.marked.has(r) && e.base.refs.set(r, t), t;
+}
+function Wn(e, r, t) {
+	return Ut(e.base, r), e.base.refs.set(r, t), t;
+}
+function b(e, r, t) {
+	return e.mode === 1 ? qn(e, r, t) : Wn(e, r, t);
+}
+function Fr(e, r, t) {
+	if (Object.hasOwn(r, t)) return r[t];
+	throw new h$1(e);
+}
+function Gn(e, r) {
+	return b(e, r.i, ft(B$1(r.s)));
+}
+function Kn(e, r, t) {
+	let n = t.a, a = n.length, s = b(e, t.i, new Array(a));
+	for (let i = 0, u; i < a; i++) u = n[i], u && (s[i] = p$1(e, r, u));
+	return Bt(s, t.o), s;
+}
+function Hn(e) {
+	switch (e) {
+		case "constructor":
+		case "__proto__":
+		case "prototype":
+		case "__defineGetter__":
+		case "__defineSetter__":
+		case "__lookupGetter__":
+		case "__lookupSetter__": return !1;
+		default: return !0;
+	}
+}
+function Jn(e) {
+	switch (e) {
+		case v$1:
+		case R:
+		case P$1:
+		case C: return !0;
+		default: return !1;
+	}
+}
+function Ft(e, r, t) {
+	Hn(r) ? e[r] = t : Object.defineProperty(e, r, {
+		value: t,
+		configurable: !0,
+		enumerable: !0,
+		writable: !0
+	});
+}
+function Zn(e, r, t, n, a) {
+	if (typeof n == "string") Ft(t, n, p$1(e, r, a));
+	else {
+		let s = p$1(e, r, n);
+		switch (typeof s) {
+			case "string":
+				Ft(t, s, p$1(e, r, a));
+				break;
+			case "symbol":
+				Jn(s) && (t[s] = p$1(e, r, a));
+				break;
+			default: throw new h$1(n);
+		}
+	}
+}
+function jt(e, r, t, n) {
+	let a = t.k;
+	if (a.length > 0) for (let i = 0, u = t.v, l = a.length; i < l; i++) Zn(e, r, n, a[i], u[i]);
+	return n;
+}
+function $n(e, r, t) {
+	let n = b(e, t.i, t.t === 10 ? {} : Object.create(null));
+	return jt(e, r, t.p, n), Bt(n, t.o), n;
+}
+function Xn(e, r) {
+	return b(e, r.i, new Date(r.s));
+}
+function Qn(e, r) {
+	if (e.base.features & 32) {
+		let t = B$1(r.c);
+		if (t.length > jn) throw new h$1(r);
+		return b(e, r.i, new RegExp(t, r.m));
+	}
+	throw new w$1(r);
+}
+function eo(e, r, t) {
+	let n = b(e, t.i, /* @__PURE__ */ new Set());
+	for (let a = 0, s = t.a, i = s.length; a < i; a++) n.add(p$1(e, r, s[a]));
+	return n;
+}
+function ro(e, r, t) {
+	let n = 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++) n.set(p$1(e, r, s[a]), p$1(e, r, i[a]));
+	return n;
+}
+function to(e, r) {
+	if (r.s.length > Ln) throw new h$1(r);
+	return b(e, r.i, Or(B$1(r.s)));
+}
+function no(e, r, t) {
+	var u;
+	let n = Dt(t.c), a = p$1(e, r, t.f), s = (u = t.b) != null ? u : 0;
+	if (s < 0 || s > a.byteLength) throw new h$1(t);
+	return b(e, t.i, new n(a, s, t.l));
+}
+function oo(e, r, t) {
+	var i;
+	let n = p$1(e, r, t.f), a = (i = t.b) != null ? i : 0;
+	if (a < 0 || a > n.byteLength) throw new h$1(t);
+	return b(e, t.i, new DataView(n, a, t.l));
+}
+function Yt(e, r, t, n) {
+	if (t.p) {
+		let a = jt(e, r, t.p, {});
+		Object.defineProperties(n, Object.getOwnPropertyDescriptors(a));
+	}
+	return n;
+}
+function ao(e, r, t) {
+	return Yt(e, r, t, b(e, t.i, new AggregateError([], B$1(t.m))));
+}
+function so(e, r, t) {
+	let n = Fr(t, at, t.s);
+	return Yt(e, r, t, b(e, t.i, new n(B$1(t.m))));
+}
+function io(e, r, t) {
+	let n = re(), a = b(e, t.i, n.p), s = p$1(e, r, t.f);
+	return t.s ? n.s(s) : n.f(s), a;
+}
+function uo(e, r, t) {
+	return b(e, t.i, Object(p$1(e, r, t.f)));
+}
+function lo(e, r, t) {
+	let n = e.base.plugins;
+	if (n) {
+		let a = B$1(t.c);
+		for (let s = 0, i = n.length; s < i; s++) {
+			let u = n[s];
+			if (u.tag === a) return b(e, t.i, u.deserialize(t.s, new Dr(e, r), { id: t.i }));
+		}
+	}
+	throw new Q(t.c);
+}
+function co(e, r) {
+	return b(e, r.i, b(e, r.s, re()).p);
+}
+function fo(e, r, t) {
+	let n = e.base.refs.get(t.i);
+	if (n) return n.s(p$1(e, r, t.a[1])), o$1;
+	throw new V("Promise");
+}
+function So(e, r, t) {
+	let n = e.base.refs.get(t.i);
+	if (n) return n.f(p$1(e, r, t.a[1])), o$1;
+	throw new V("Promise");
+}
+function mo(e, r, t) {
+	p$1(e, r, t.a[0]);
+	return It(p$1(e, r, t.a[1]));
+}
+function po(e, r, t) {
+	p$1(e, r, t.a[0]);
+	return Tt(p$1(e, r, t.a[1]));
+}
+function go(e, r, t) {
+	let n = b(e, t.i, te$1()), a = t.a, s = a.length;
+	if (s) for (let i = 0; i < s; i++) p$1(e, r, a[i]);
+	return n;
+}
+function yo(e, r, t) {
+	let n = e.base.refs.get(t.i);
+	if (n && M(n)) return n.next(p$1(e, r, t.f)), o$1;
+	throw new V("Stream");
+}
+function No(e, r, t) {
+	let n = e.base.refs.get(t.i);
+	if (n && M(n)) return n.throw(p$1(e, r, t.f)), o$1;
+	throw new V("Stream");
+}
+function bo(e, r, t) {
+	let n = e.base.refs.get(t.i);
+	if (n && M(n)) return n.return(p$1(e, r, t.f)), o$1;
+	throw new V("Stream");
+}
+function vo(e, r, t) {
+	return p$1(e, r, t.f), o$1;
+}
+function Co(e, r, t) {
+	return p$1(e, r, t.a[1]), o$1;
+}
+function Ao(e, r, t) {
+	let n = b(e, t.i, Tr([], t.s, t.l));
+	for (let a = 0, s = t.a.length; a < s; a++) n.v[a] = p$1(e, r, t.a[a]);
+	return n;
+}
+function p$1(e, r, t) {
+	if (r > e.base.depthLimit) throw new ee(e.base.depthLimit);
+	switch (r += 1, t.t) {
+		case 2: return Fr(t, ot, t.s);
+		case 0: return Number(t.s);
+		case 1: return B$1(String(t.s));
+		case 3:
+			if (String(t.s).length > Un) throw new h$1(t);
+			return BigInt(t.s);
+		case 4: return e.base.refs.get(t.i);
+		case 18: return Gn(e, t);
+		case 9: return Kn(e, r, t);
+		case 10:
+		case 11: return $n(e, r, t);
+		case 5: return Xn(e, t);
+		case 6: return Qn(e, t);
+		case 7: return eo(e, r, t);
+		case 8: return ro(e, r, t);
+		case 19: return to(e, t);
+		case 16:
+		case 15: return no(e, r, t);
+		case 20: return oo(e, r, t);
+		case 14: return ao(e, r, t);
+		case 13: return so(e, r, t);
+		case 12: return io(e, r, t);
+		case 17: return Fr(t, tt, t.s);
+		case 21: return uo(e, r, t);
+		case 25: return lo(e, r, t);
+		case 22: return co(e, t);
+		case 23: return fo(e, r, t);
+		case 24: return So(e, r, t);
+		case 28: return mo(e, r, t);
+		case 30: return po(e, r, t);
+		case 31: return go(e, r, t);
+		case 32: return yo(e, r, t);
+		case 33: return No(e, r, t);
+		case 34: return bo(e, r, t);
+		case 27: return vo(e, r, t);
+		case 29: return Co(e, r, t);
+		case 35: return Ao(e, r, t);
+		default: throw new w$1(t);
+	}
+}
+function ar(e, r) {
+	try {
+		return p$1(e, 0, r);
+	} catch (t) {
+		throw new He(t);
+	}
+}
+var Eo = () => T, Io = Eo.toString(), qt = /=>/.test(Io);
+function sr(e, r) {
+	return qt ? (e.length === 1 ? e[0] : "(" + e.join(",") + ")") + "=>" + (r.startsWith("{") ? "(" + r + ")" : r) : "function(" + e.join(",") + "){return " + r + "}";
+}
+function Wt(e, r) {
+	return qt ? (e.length === 1 ? e[0] : "(" + e.join(",") + ")") + "=>{" + r + "}" : "function(" + e.join(",") + "){" + r + "}";
+}
+var Ht = "hjkmoquxzABCDEFGHIJKLNPQRTUVWXYZ$_", Gt = Ht.length, Jt = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789$_", Kt = Jt.length;
+function Br(e) {
+	let r = e % Gt, t = Ht[r];
+	for (e = (e - r) / Gt; e > 0;) r = e % Kt, t += Jt[r], e = (e - r) / Kt;
+	return t;
+}
+var Ro = /^[$A-Z_][0-9A-Z_$]*$/i;
+function Vr(e) {
+	let r = e[0];
+	return (r === "$" || r === "_" || r >= "A" && r <= "Z" || r >= "a" && r <= "z") && Ro.test(e);
+}
+function ye(e) {
+	switch (e.t) {
+		case 0: return e.s + "=" + e.v;
+		case 2: return e.s + ".set(" + e.k + "," + e.v + ")";
+		case 1: return e.s + ".add(" + e.v + ")";
+		case 3: return e.s + ".delete(" + e.k + ")";
+	}
+}
+function Po(e) {
+	let r = [], t = e[0];
+	for (let n = 1, a = e.length, s, i = t; n < a; n++) s = e[n], s.t === 0 && s.v === i.v ? t = {
+		t: 0,
+		s: s.s,
+		k: o$1,
+		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$1,
+		v: s.v
+	} : s.t === 3 && s.s === i.s ? t = {
+		t: 3,
+		s: ye(t),
+		k: s.k,
+		v: o$1
+	} : (r.push(t), t = s), i = s;
+	return r.push(t), r;
+}
+function tn(e) {
+	if (e.length) {
+		let r = "", t = Po(e);
+		for (let n = 0, a = t.length; n < a; n++) r += ye(t[n]) + ",";
+		return r;
+	}
+	return o$1;
+}
+var xo = "Object.create(null)", Oo = "new Set", To = "new Map", wo = "Promise.resolve", ho = "Promise.reject", zo = {
+	3: "Object.freeze",
+	2: "Object.seal",
+	1: "Object.preventExtensions",
+	0: o$1
+};
+function nn(e, r) {
+	return {
+		mode: e,
+		plugins: r.plugins,
+		features: r.features,
+		marked: new Set(r.markedRefs),
+		stack: [],
+		flags: [],
+		assignments: []
+	};
+}
+function ur(e) {
+	return {
+		mode: 2,
+		base: nn(2, e),
+		state: e,
+		child: o$1
+	};
+}
+var Mr = class {
+	constructor(r) {
+		this._p = r;
+	}
+	serialize(r) {
+		return f$1(this._p, r);
+	}
+};
+function ko(e, r) {
+	let t = e.valid.get(r);
+	t ?? (t = e.valid.size, e.valid.set(r, t));
+	let n = e.vars[t];
+	return n ?? (n = Br(t), e.vars[t] = n), n;
+}
+function Do(e) {
+	return ce + "[" + e + "]";
+}
+function m$1(e, r) {
+	return e.mode === 1 ? ko(e.state, r) : Do(r);
+}
+function O$1(e, r) {
+	e.marked.add(r);
+}
+function Lr(e, r) {
+	return e.marked.has(r);
+}
+function jr(e, r, t) {
+	r !== 0 && (O$1(e.base, t), e.base.flags.push({
+		type: r,
+		value: m$1(e, t)
+	}));
+}
+function Fo(e) {
+	let r = "";
+	for (let t = 0, n = e.flags, a = n.length; t < a; t++) {
+		let s = n[t];
+		r += zo[s.type] + "(" + s.value + "),";
+	}
+	return r;
+}
+function on(e) {
+	let r = tn(e.assignments), t = Fo(e);
+	return r ? t ? r + t : r : t;
+}
+function Yr(e, r, t) {
+	e.assignments.push({
+		t: 0,
+		s: r,
+		k: o$1,
+		v: t
+	});
+}
+function Bo(e, r, t) {
+	e.base.assignments.push({
+		t: 1,
+		s: m$1(e, r),
+		k: o$1,
+		v: t
+	});
+}
+function ge(e, r, t, n) {
+	e.base.assignments.push({
+		t: 2,
+		s: m$1(e, r),
+		k: t,
+		v: n
+	});
+}
+function Zt(e, r, t) {
+	e.base.assignments.push({
+		t: 3,
+		s: m$1(e, r),
+		k: t,
+		v: o$1
+	});
+}
+function Ne(e, r, t, n) {
+	Yr(e.base, m$1(e, r) + "[" + t + "]", n);
+}
+function Ur(e, r, t, n) {
+	Yr(e.base, m$1(e, r) + "." + t, n);
+}
+function Vo(e, r, t, n) {
+	Yr(e.base, m$1(e, r) + ".v[" + t + "]", n);
+}
+function D$1(e, r) {
+	return r.t === 4 && e.stack.includes(r.i);
+}
+function se(e, r, t) {
+	return e.mode === 1 && !Lr(e.base, r) ? t : m$1(e, r) + "=" + t;
+}
+function Mo(e) {
+	return U + ".get(\"" + e.s + "\")";
+}
+function $t(e, r, t, n) {
+	return t ? D$1(e.base, t) ? (O$1(e.base, r), Ne(e, r, n, m$1(e, t.i)), "") : f$1(e, t) : "";
+}
+function Lo(e, r) {
+	let t = r.i, n = r.a, a = n.length;
+	if (a > 0) {
+		e.base.stack.push(t);
+		let s = $t(e, t, n[0], 0), i = s === "";
+		for (let u = 1, l; u < a; u++) l = $t(e, t, n[u], u), s += "," + l, i = l === "";
+		return e.base.stack.pop(), jr(e, r.o, r.i), "[" + s + (i ? ",]" : "]");
+	}
+	return "[]";
+}
+function Xt(e, r, t, n) {
+	if (typeof t == "string") {
+		let a = Number(t), s = a >= 0 && a.toString() === t || Vr(t);
+		if (D$1(e.base, n)) {
+			let i = m$1(e, n.i);
+			return O$1(e.base, r.i), s && a !== a ? Ur(e, r.i, t, i) : Ne(e, r.i, s ? t : "\"" + t + "\"", i), "";
+		}
+		return (s ? t : "\"" + t + "\"") + ":" + f$1(e, n);
+	}
+	return "[" + f$1(e, t) + "]:" + f$1(e, n);
+}
+function an(e, r, t) {
+	let n = t.k, a = n.length;
+	if (a > 0) {
+		let s = t.v;
+		e.base.stack.push(r.i);
+		let i = Xt(e, r, n[0], s[0]);
+		for (let u = 1, l = i; u < a; u++) l = Xt(e, r, n[u], s[u]), i += (l && i && ",") + l;
+		return e.base.stack.pop(), "{" + i + "}";
+	}
+	return "{}";
+}
+function Uo(e, r) {
+	return jr(e, r.o, r.i), an(e, r, r.p);
+}
+function jo(e, r, t, n) {
+	let a = an(e, r, t);
+	return a !== "{}" ? "Object.assign(" + n + "," + a + ")" : n;
+}
+function Yo(e, r, t, n, a) {
+	let s = e.base, i = f$1(e, a), u = Number(n), l = u >= 0 && u.toString() === n || Vr(n);
+	if (D$1(s, a)) l && u !== u ? Ur(e, r.i, n, i) : Ne(e, r.i, l ? n : "\"" + n + "\"", i);
+	else {
+		let g = s.assignments;
+		s.assignments = t, l && u !== u ? Ur(e, r.i, n, i) : Ne(e, r.i, l ? n : "\"" + n + "\"", i), s.assignments = g;
+	}
+}
+function qo(e, r, t, n, a) {
+	if (typeof n == "string") Yo(e, r, t, n, a);
+	else {
+		let s = e.base, i = s.stack;
+		s.stack = [];
+		let u = f$1(e, a);
+		s.stack = i;
+		let l = s.assignments;
+		s.assignments = t, Ne(e, r.i, f$1(e, n), u), s.assignments = l;
+	}
+}
+function Wo(e, r, t) {
+	let n = t.k, a = n.length;
+	if (a > 0) {
+		let s = [], i = t.v;
+		e.base.stack.push(r.i);
+		for (let u = 0; u < a; u++) qo(e, r, s, n[u], i[u]);
+		return e.base.stack.pop(), tn(s);
+	}
+	return o$1;
+}
+function qr(e, r, t) {
+	if (r.p) {
+		let n = e.base;
+		if (n.features & 8) t = jo(e, r, r.p, t);
+		else {
+			O$1(n, r.i);
+			let a = Wo(e, r, r.p);
+			if (a) return "(" + se(e, r.i, t) + "," + a + m$1(e, r.i) + ")";
+		}
+	}
+	return t;
+}
+function Go(e, r) {
+	return jr(e, r.o, r.i), qr(e, r, xo);
+}
+function Ko(e) {
+	return "new Date(\"" + e.s + "\")";
+}
+function Ho(e, r) {
+	if (e.base.features & 32) return "/" + r.c + "/" + r.m;
+	throw new w$1(r);
+}
+function Qt(e, r, t) {
+	let n = e.base;
+	return D$1(n, t) ? (O$1(n, r), Bo(e, r, m$1(e, t.i)), "") : f$1(e, t);
+}
+function Jo(e, r) {
+	let t = Oo, n = r.a, a = n.length, s = r.i;
+	if (a > 0) {
+		e.base.stack.push(s);
+		let i = Qt(e, s, n[0]);
+		for (let u = 1, l = i; u < a; u++) l = Qt(e, s, n[u]), i += (l && i && ",") + l;
+		e.base.stack.pop(), i && (t += "([" + i + "])");
+	}
+	return t;
+}
+function en(e, r, t, n, a) {
+	let s = e.base;
+	if (D$1(s, t)) {
+		let i = m$1(e, t.i);
+		if (O$1(s, r), D$1(s, n)) return ge(e, r, i, m$1(e, n.i)), "";
+		if (n.t !== 4 && n.i != null && Lr(s, n.i)) {
+			let l = "(" + f$1(e, n) + ",[" + a + "," + a + "])";
+			return ge(e, r, i, m$1(e, n.i)), Zt(e, r, a), l;
+		}
+		let u = s.stack;
+		return s.stack = [], ge(e, r, i, f$1(e, n)), s.stack = u, "";
+	}
+	if (D$1(s, n)) {
+		let i = m$1(e, n.i);
+		if (O$1(s, r), t.t !== 4 && t.i != null && Lr(s, t.i)) {
+			let l = "(" + f$1(e, t) + ",[" + a + "," + a + "])";
+			return ge(e, r, m$1(e, t.i), i), Zt(e, r, a), l;
+		}
+		let u = s.stack;
+		return s.stack = [], ge(e, r, f$1(e, t), i), s.stack = u, "";
+	}
+	return "[" + f$1(e, t) + "," + f$1(e, n) + "]";
+}
+function Zo(e, r) {
+	let t = To, n = r.e.k, a = n.length, s = r.i, i = r.f, u = m$1(e, i.i), l = e.base;
+	if (a > 0) {
+		let g = r.e.v;
+		l.stack.push(s);
+		let S = en(e, s, n[0], g[0], u);
+		for (let d = 1, K = S; d < a; d++) K = en(e, s, n[d], g[d], u), S += (K && S && ",") + K;
+		l.stack.pop(), S && (t += "([" + S + "])");
+	}
+	return i.t === 26 && (O$1(l, i.i), t = "(" + f$1(e, i) + "," + t + ")"), t;
+}
+function $o(e, r) {
+	return W(e, r.f) + "(\"" + r.s + "\")";
+}
+function Xo(e, r) {
+	return "new " + r.c + "(" + f$1(e, r.f) + "," + r.b + "," + r.l + ")";
+}
+function Qo(e, r) {
+	return "new DataView(" + f$1(e, r.f) + "," + r.b + "," + r.l + ")";
+}
+function ea(e, r) {
+	let t = r.i;
+	e.base.stack.push(t);
+	let n = qr(e, r, "new AggregateError([],\"" + r.m + "\")");
+	return e.base.stack.pop(), n;
+}
+function ra(e, r) {
+	return qr(e, r, "new " + Ce[r.s] + "(\"" + r.m + "\")");
+}
+function ta(e, r) {
+	let t, n = r.f, a = r.i, s = r.s ? wo : ho, i = e.base;
+	if (D$1(i, n)) {
+		let u = m$1(e, n.i);
+		t = s + (r.s ? "().then(" + sr([], u) + ")" : "().catch(" + Wt([], "throw " + u) + ")");
+	} else {
+		i.stack.push(a);
+		let u = f$1(e, n);
+		i.stack.pop(), t = s + "(" + u + ")";
+	}
+	return t;
+}
+function na(e, r) {
+	return "Object(" + f$1(e, r.f) + ")";
+}
+function W(e, r) {
+	let t = f$1(e, r);
+	return r.t === 4 ? t : "(" + t + ")";
+}
+function oa(e, r) {
+	if (e.mode === 1) throw new w$1(r);
+	return "(" + se(e, r.s, W(e, r.f) + "()") + ").p";
+}
+function aa(e, r) {
+	if (e.mode === 1) throw new w$1(r);
+	return W(e, r.a[0]) + "(" + m$1(e, r.i) + "," + f$1(e, r.a[1]) + ")";
+}
+function sa(e, r) {
+	if (e.mode === 1) throw new w$1(r);
+	return W(e, r.a[0]) + "(" + m$1(e, r.i) + "," + f$1(e, r.a[1]) + ")";
+}
+function ia(e, r) {
+	let t = e.base.plugins;
+	if (t) for (let n = 0, a = t.length; n < a; n++) {
+		let s = t[n];
+		if (s.tag === r.c) return e.child ??= new Mr(e), s.serialize(r.s, e.child, { id: r.i });
+	}
+	throw new Q(r.c);
+}
+function ua(e, r) {
+	let t = "", n = !1;
+	return r.f.t !== 4 && (O$1(e.base, r.f.i), t = "(" + f$1(e, r.f) + ",", n = !0), t += se(e, r.i, "(" + Ct + ")(" + m$1(e, r.f.i) + ")"), n && (t += ")"), t;
+}
+function la(e, r) {
+	return W(e, r.a[0]) + "(" + f$1(e, r.a[1]) + ")";
+}
+function ca(e, r) {
+	let t = r.a[0], n = r.a[1], a = e.base, s = "";
+	t.t !== 4 && (O$1(a, t.i), s += "(" + f$1(e, t)), n.t !== 4 && (O$1(a, n.i), s += (s ? "," : "(") + f$1(e, n)), s && (s += ",");
+	let i = se(e, r.i, "(" + At + ")(" + m$1(e, n.i) + "," + m$1(e, t.i) + ")");
+	return s ? s + i + ")" : i;
+}
+function fa(e, r) {
+	return W(e, r.a[0]) + "(" + f$1(e, r.a[1]) + ")";
+}
+function Sa(e, r) {
+	let t = se(e, r.i, W(e, r.f) + "()"), n = r.a.length;
+	if (n) {
+		let a = f$1(e, r.a[0]);
+		for (let s = 1; s < n; s++) a += "," + f$1(e, r.a[s]);
+		return "(" + t + "," + a + "," + m$1(e, r.i) + ")";
+	}
+	return t;
+}
+function ma(e, r) {
+	return m$1(e, r.i) + ".next(" + f$1(e, r.f) + ")";
+}
+function pa(e, r) {
+	return m$1(e, r.i) + ".throw(" + f$1(e, r.f) + ")";
+}
+function da(e, r) {
+	return m$1(e, r.i) + ".return(" + f$1(e, r.f) + ")";
+}
+function rn(e, r, t, n) {
+	let a = e.base;
+	return D$1(a, n) ? (O$1(a, r), Vo(e, r, t, m$1(e, n.i)), "") : f$1(e, n);
+}
+function ga(e, r) {
+	let t = r.a, n = t.length, a = r.i;
+	if (n > 0) {
+		e.base.stack.push(a);
+		let s = rn(e, a, 0, t[0]);
+		for (let i = 1, u = s; i < n; i++) u = rn(e, a, i, t[i]), s += (u && s && ",") + u;
+		if (e.base.stack.pop(), s) return "{__SEROVAL_SEQUENCE__:!0,v:[" + s + "],t:" + r.s + ",d:" + r.l + "}";
+	}
+	return "{__SEROVAL_SEQUENCE__:!0,v:[],t:-1,d:0}";
+}
+function ya(e, r) {
+	switch (r.t) {
+		case 17: return rt[r.s];
+		case 18: return Mo(r);
+		case 9: return Lo(e, r);
+		case 10: return Uo(e, r);
+		case 11: return Go(e, r);
+		case 5: return Ko(r);
+		case 6: return Ho(e, r);
+		case 7: return Jo(e, r);
+		case 8: return Zo(e, r);
+		case 19: return $o(e, r);
+		case 16:
+		case 15: return Xo(e, r);
+		case 20: return Qo(e, r);
+		case 14: return ea(e, r);
+		case 13: return ra(e, r);
+		case 12: return ta(e, r);
+		case 21: return na(e, r);
+		case 22: return oa(e, r);
+		case 25: return ia(e, r);
+		case 26: return Ot[r.s];
+		case 35: return ga(e, r);
+		default: throw new w$1(r);
+	}
+}
+function f$1(e, r) {
+	switch (r.t) {
+		case 2: return nt[r.s];
+		case 0: return "" + r.s;
+		case 1: return "\"" + r.s + "\"";
+		case 3: return r.s + "n";
+		case 4: return m$1(e, r.i);
+		case 23: return aa(e, r);
+		case 24: return sa(e, r);
+		case 27: return ua(e, r);
+		case 28: return la(e, r);
+		case 29: return ca(e, r);
+		case 30: return fa(e, r);
+		case 31: return Sa(e, r);
+		case 32: return ma(e, r);
+		case 33: return pa(e, r);
+		case 34: return da(e, r);
+		default: return se(e, r.i, ya(e, r));
+	}
+}
+function cr(e, r) {
+	let t = f$1(e, r), n = r.i;
+	if (n == null) return t;
+	let a = on(e.base), s = m$1(e, n), i = e.state.scopeId, u = i == null ? "" : ce, l = a ? "(" + t + "," + a + s + ")" : t;
+	if (u === "") return r.t === 10 && !a ? "(" + l + ")" : l;
+	let g = i == null ? "()" : "(" + ce + "[\"" + y$1(i) + "\"])";
+	return "(" + sr([u], l) + ")" + g;
+}
+var Gr = class {
+	constructor(r, t) {
+		this._p = r;
+		this.depth = t;
+	}
+	parse(r) {
+		return E$1(this._p, this.depth, r);
+	}
+}, Kr = class {
+	constructor(r, t) {
+		this._p = r;
+		this.depth = t;
+	}
+	parse(r) {
+		return E$1(this._p, this.depth, r);
+	}
+	parseWithError(r) {
+		return G(this._p, this.depth, r);
+	}
+	isAlive() {
+		return this._p.state.alive;
+	}
+	pushPendingState() {
+		Xr(this._p);
+	}
+	popPendingState() {
+		be(this._p);
+	}
+	onParse(r) {
+		ie(this._p, r);
+	}
+	onError(r) {
+		Zr(this._p, r);
+	}
+};
+function Na(e) {
+	return {
+		alive: !0,
+		pending: 0,
+		initial: !0,
+		buffer: [],
+		onParse: e.onParse,
+		onError: e.onError,
+		onDone: e.onDone
+	};
+}
+function Hr(e) {
+	return {
+		type: 2,
+		base: pe$1(2, e),
+		state: Na(e)
+	};
+}
+function ba(e, r, t) {
+	let n = [];
+	for (let a = 0, s = t.length; a < s; a++) a in t ? n[a] = E$1(e, r, t[a]) : n[a] = 0;
+	return n;
+}
+function va(e, r, t, n) {
+	return _e(t, n, ba(e, r, n));
+}
+function Jr(e, r, t) {
+	let n = Object.entries(t), a = [], s = [];
+	for (let i = 0, u = n.length; i < u; i++) a.push(y$1(n[i][0])), s.push(E$1(e, r, n[i][1]));
+	return C in t && (a.push(I(e.base, C)), s.push(Ue(er(e.base), E$1(e, r, $e(t))))), v$1 in t && (a.push(I(e.base, v$1)), s.push(je(rr(e.base), E$1(e, r, e.type === 1 ? te$1() : Xe(t))))), P$1 in t && (a.push(I(e.base, P$1)), s.push(X(t[P$1]))), R in t && (a.push(I(e.base, R)), s.push(t[R] ? J : Z)), {
+		k: a,
+		v: s
+	};
+}
+function Wr(e, r, t, n, a) {
+	return tr(t, n, a, Jr(e, r, n));
+}
+function Ca(e, r, t, n) {
+	return ke(t, E$1(e, r, n.valueOf()));
+}
+function Aa(e, r, t, n) {
+	return De(t, n, E$1(e, r, n.buffer));
+}
+function Ea(e, r, t, n) {
+	return Fe(t, n, E$1(e, r, n.buffer));
+}
+function Ia(e, r, t, n) {
+	return Be(t, n, E$1(e, r, n.buffer));
+}
+function sn(e, r, t, n) {
+	let a = $$1(n, e.base.features);
+	return Ve(t, n, a ? Jr(e, r, a) : o$1);
+}
+function Ra(e, r, t, n) {
+	let a = $$1(n, e.base.features);
+	return Me(t, n, a ? Jr(e, r, a) : o$1);
+}
+function Pa(e, r, t, n) {
+	let a = [], s = [];
+	for (let [i, u] of n.entries()) a.push(E$1(e, r, i)), s.push(E$1(e, r, u));
+	return nr(e.base, t, a, s);
+}
+function xa(e, r, t, n) {
+	let a = [];
+	for (let s of n.keys()) a.push(E$1(e, r, s));
+	return Le(t, a);
+}
+function Oa(e, r, t, n) {
+	let a = Ye(t, k(e.base, 4), []);
+	return e.type === 1 || (Xr(e), n.on({
+		next: (s) => {
+			if (e.state.alive) {
+				let i = G(e, r, s);
+				i && ie(e, qe(t, i));
+			}
+		},
+		throw: (s) => {
+			if (e.state.alive) {
+				let i = G(e, r, s);
+				i && ie(e, We(t, i));
+			}
+			be(e);
+		},
+		return: (s) => {
+			if (e.state.alive) {
+				let i = G(e, r, s);
+				i && ie(e, Ge(t, i));
+			}
+			be(e);
+		}
+	})), a;
+}
+function Ta(e, r, t) {
+	if (this.state.alive) {
+		let n = G(this, r, t);
+		n && ie(this, c$1(23, e, o$1, o$1, o$1, o$1, o$1, [k(this.base, 2), n], o$1, o$1, o$1, o$1)), be(this);
+	}
+}
+function wa(e, r, t) {
+	if (this.state.alive) {
+		let n = G(this, r, t);
+		n && ie(this, c$1(24, e, o$1, o$1, o$1, o$1, o$1, [k(this.base, 3), n], o$1, o$1, o$1, o$1));
+	}
+	be(this);
+}
+function ha(e, r, t, n) {
+	let a = hr(e.base, {});
+	return e.type === 2 && (Xr(e), n.then(Ta.bind(e, a, r), wa.bind(e, a, r))), ht(e.base, t, a);
+}
+function za(e, r, t, n, a) {
+	for (let s = 0, i = a.length; s < i; s++) {
+		let u = a[s];
+		if (u.parse.sync && u.test(n)) return fe$1(t, u.tag, u.parse.sync(n, new Gr(e, r), { id: t }));
+	}
+	return o$1;
+}
+function _a(e, r, t, n, a) {
+	for (let s = 0, i = a.length; s < i; s++) {
+		let u = a[s];
+		if (u.parse.stream && u.test(n)) return fe$1(t, u.tag, u.parse.stream(n, new Kr(e, r), { id: t }));
+	}
+	return o$1;
+}
+function un(e, r, t, n) {
+	let a = e.base.plugins;
+	return a ? e.type === 1 ? za(e, r, t, n, a) : _a(e, r, t, n, a) : o$1;
+}
+function ka(e, r, t, n) {
+	let a = [];
+	for (let s = 0, i = n.v.length; s < i; s++) a[s] = E$1(e, r, n.v[s]);
+	return Ke(t, a, n.t, n.d);
+}
+function Da(e, r, t, n, a) {
+	switch (a) {
+		case Object: return Wr(e, r, t, n, !1);
+		case o$1: return Wr(e, r, t, n, !0);
+		case Date: return he(t, n);
+		case Error:
+		case EvalError:
+		case RangeError:
+		case ReferenceError:
+		case SyntaxError:
+		case TypeError:
+		case URIError: return sn(e, r, t, n);
+		case Number:
+		case Boolean:
+		case String:
+		case BigInt: return Ca(e, r, t, n);
+		case ArrayBuffer: return or(e.base, t, n);
+		case Int8Array:
+		case Int16Array:
+		case Int32Array:
+		case Uint8Array:
+		case Uint16Array:
+		case Uint32Array:
+		case Uint8ClampedArray:
+		case Float32Array:
+		case Float64Array: return Aa(e, r, t, n);
+		case DataView: return Ia(e, r, t, n);
+		case Map: return Pa(e, r, t, n);
+		case Set: return xa(e, r, t, n);
+		default: break;
+	}
+	if (a === Promise || n instanceof Promise) return ha(e, r, t, n);
+	let s = e.base.features;
+	if (s & 32 && a === RegExp) return ze(t, n);
+	if (s & 16) switch (a) {
+		case BigInt64Array:
+		case BigUint64Array: return Ea(e, r, t, n);
+		default: break;
+	}
+	if (s & 1 && typeof AggregateError != "undefined" && (a === AggregateError || n instanceof AggregateError)) return Ra(e, r, t, n);
+	if (n instanceof Error) return sn(e, r, t, n);
+	if (C in n || v$1 in n) return Wr(e, r, t, n, !!a);
+	throw new x$1(n);
+}
+function Fa(e, r, t, n) {
+	if (Array.isArray(n)) return va(e, r, t, n);
+	if (M(n)) return Oa(e, r, t, n);
+	if (Ze(n)) return ka(e, r, t, n);
+	let a = n.constructor;
+	if (a === Y$1) return E$1(e, r, n.replacement);
+	return un(e, r, t, n) || Da(e, r, t, n, a);
+}
+function Ba(e, r, t) {
+	let n = q$1(e.base, t);
+	if (n.type !== 0) return n.value;
+	let a = un(e, r, n.value, t);
+	if (a) return a;
+	throw new x$1(t);
+}
+function E$1(e, r, t) {
+	if (r >= e.base.depthLimit) throw new ee(e.base.depthLimit);
+	switch (typeof t) {
+		case "boolean": return t ? J : Z;
+		case "undefined": return Ae;
+		case "string": return X(t);
+		case "number": return Te(t);
+		case "bigint": return we(t);
+		case "object":
+			if (t) {
+				let n = q$1(e.base, t);
+				return n.type === 0 ? Fa(e, r + 1, n.value, t) : n.value;
+			}
+			return Ee;
+		case "symbol": return I(e.base, t);
+		case "function": return Ba(e, r, t);
+		default: throw new x$1(t);
+	}
+}
+function ie(e, r) {
+	e.state.initial ? e.state.buffer.push(r) : $r(e, r, !1);
+}
+function Zr(e, r) {
+	if (e.state.onError) e.state.onError(r);
+	else throw r instanceof z ? r : new z(r);
+}
+function ln(e) {
+	e.state.onDone && e.state.onDone();
+}
+function $r(e, r, t) {
+	try {
+		e.state.onParse(r, t);
+	} catch (n) {
+		Zr(e, n);
+	}
+}
+function Xr(e) {
+	e.state.pending++;
+}
+function be(e) {
+	--e.state.pending <= 0 && ln(e);
+}
+function G(e, r, t) {
+	try {
+		return E$1(e, r, t);
+	} catch (n) {
+		return Zr(e, n), o$1;
+	}
+}
+function Qr(e, r) {
+	let t = G(e, 0, r);
+	t && ($r(e, t, !0), e.state.initial = !1, Va(e, e.state), e.state.pending <= 0 && fr(e));
+}
+function Va(e, r) {
+	for (let t = 0, n = r.buffer.length; t < n; t++) $r(e, r.buffer[t], !1);
+}
+function fr(e) {
+	e.state.alive && (ln(e), e.state.alive = !1);
+}
+async function ou(e, r = {}) {
+	return await oe(ne$1(2, {
+		plugins: A(r.plugins),
+		disabledFeatures: r.disabledFeatures,
+		refs: r.refs
+	}), e);
+}
+function cn(e, r) {
+	let t = A(r.plugins), n = Hr({
+		plugins: t,
+		refs: r.refs,
+		disabledFeatures: r.disabledFeatures,
+		onParse(a, s) {
+			let i = ur({
+				plugins: t,
+				features: n.base.features,
+				scopeId: r.scopeId,
+				markedRefs: n.base.marked
+			}), u;
+			try {
+				u = cr(i, a);
+			} catch (l) {
+				r.onError && r.onError(l);
+				return;
+			}
+			r.onSerialize(u, s);
+		},
+		onError: r.onError,
+		onDone: r.onDone
+	});
+	return Qr(n, e), fr.bind(null, n);
+}
+function au(e, r) {
+	let n = Hr({
+		plugins: A(r.plugins),
+		refs: r.refs,
+		disabledFeatures: r.disabledFeatures,
+		depthLimit: r.depthLimit,
+		onParse: r.onParse,
+		onError: r.onError,
+		onDone: r.onDone
+	});
+	return Qr(n, e), fr.bind(null, n);
+}
+function Iu(e, r = {}) {
+	var i;
+	let t = A(r.plugins), n = r.disabledFeatures || 0, a = (i = e.f) != null ? i : 63;
+	return ar(Mt({
+		plugins: t,
+		markedRefs: e.m,
+		features: a & ~n,
+		disabledFeatures: n
+	}), e.t);
+}
+var GLOBAL_TSR = "$_TSR";
+var TSR_SCRIPT_BARRIER_ID = "$tsr-stream-barrier";
+function createSerializationAdapter(opts) {
+	return opts;
+}
+function makeSsrSerovalPlugin(serializationAdapter, options) {
+	return ni({
+		tag: "$TSR/t/" + serializationAdapter.key,
+		test: serializationAdapter.test,
+		parse: { stream(value, ctx) {
+			return ctx.parse(serializationAdapter.toSerializable(value));
+		} },
+		serialize(node, ctx) {
+			options.didRun = true;
+			return GLOBAL_TSR + ".t.get(\"" + serializationAdapter.key + "\")(" + ctx.serialize(node) + ")";
+		},
+		deserialize: void 0
+	});
+}
+function makeSerovalPlugin(serializationAdapter) {
+	return ni({
+		tag: "$TSR/t/" + serializationAdapter.key,
+		test: serializationAdapter.test,
+		parse: {
+			sync(value, ctx) {
+				return ctx.parse(serializationAdapter.toSerializable(value));
+			},
+			async async(value, ctx) {
+				return await ctx.parse(serializationAdapter.toSerializable(value));
+			},
+			stream(value, ctx) {
+				return ctx.parse(serializationAdapter.toSerializable(value));
+			}
+		},
+		serialize: void 0,
+		deserialize(node, ctx) {
+			return serializationAdapter.fromSerializable(ctx.deserialize(node));
+		}
+	});
+}
+var u = (e) => {
+	let r = new AbortController(), a = r.abort.bind(r);
+	return e.then(a, a), r;
+};
+function E(e) {
+	e(this.reason);
+}
+function D(e) {
+	this.addEventListener("abort", E.bind(this, e), { once: !0 });
+}
+function c(e) {
+	return new Promise(D.bind(e));
+}
+var i = {};
+ni({
+	tag: "seroval-plugins/web/AbortSignal",
+	extends: [ni({
+		tag: "seroval-plugins/web/AbortControllerFactoryPlugin",
+		test(e) {
+			return e === i;
+		},
+		parse: {
+			sync() {
+				return i;
+			},
+			async async() {
+				return await Promise.resolve(i);
+			},
+			stream() {
+				return i;
+			}
+		},
+		serialize() {
+			return u.toString();
+		},
+		deserialize() {
+			return u;
+		}
+	})],
+	test(e) {
+		return typeof AbortSignal == "undefined" ? !1 : e instanceof AbortSignal;
+	},
+	parse: {
+		sync(e, r) {
+			return e.aborted ? { reason: r.parse(e.reason) } : {};
+		},
+		async async(e, r) {
+			if (e.aborted) return { reason: await r.parse(e.reason) };
+			let a = await c(e);
+			return { reason: await r.parse(a) };
+		},
+		stream(e, r) {
+			if (e.aborted) return { reason: r.parse(e.reason) };
+			let a = c(e);
+			return {
+				factory: r.parse(i),
+				controller: r.parse(a)
+			};
+		}
+	},
+	serialize(e, r) {
+		return e.reason ? "AbortSignal.abort(" + r.serialize(e.reason) + ")" : e.controller && e.factory ? "(" + r.serialize(e.factory) + ")(" + r.serialize(e.controller) + ").signal" : "(new AbortController).signal";
+	},
+	deserialize(e, r) {
+		return e.reason ? AbortSignal.abort(r.deserialize(e.reason)) : e.controller ? u(r.deserialize(e.controller)).signal : new AbortController().signal;
+	}
+});
+ni({
+	tag: "seroval-plugins/web/Blob",
+	test(e) {
+		return typeof Blob == "undefined" ? !1 : e instanceof Blob;
+	},
+	parse: { async async(e, r) {
+		return {
+			type: await r.parse(e.type),
+			buffer: await r.parse(await e.arrayBuffer())
+		};
+	} },
+	serialize(e, r) {
+		return "new Blob([" + r.serialize(e.buffer) + "],{type:" + r.serialize(e.type) + "})";
+	},
+	deserialize(e, r) {
+		return new Blob([r.deserialize(e.buffer)], { type: r.deserialize(e.type) });
+	}
+});
+function d(e) {
+	return {
+		detail: e.detail,
+		bubbles: e.bubbles,
+		cancelable: e.cancelable,
+		composed: e.composed
+	};
+}
+ni({
+	tag: "seroval-plugins/web/CustomEvent",
+	test(e) {
+		return typeof CustomEvent == "undefined" ? !1 : e instanceof CustomEvent;
+	},
+	parse: {
+		sync(e, r) {
+			return {
+				type: r.parse(e.type),
+				options: r.parse(d(e))
+			};
+		},
+		async async(e, r) {
+			return {
+				type: await r.parse(e.type),
+				options: await r.parse(d(e))
+			};
+		},
+		stream(e, r) {
+			return {
+				type: r.parse(e.type),
+				options: r.parse(d(e))
+			};
+		}
+	},
+	serialize(e, r) {
+		return "new CustomEvent(" + r.serialize(e.type) + "," + r.serialize(e.options) + ")";
+	},
+	deserialize(e, r) {
+		return new CustomEvent(r.deserialize(e.type), r.deserialize(e.options));
+	}
+});
+ni({
+	tag: "seroval-plugins/web/DOMException",
+	test(e) {
+		return typeof DOMException == "undefined" ? !1 : e instanceof DOMException;
+	},
+	parse: {
+		sync(e, r) {
+			return {
+				name: r.parse(e.name),
+				message: r.parse(e.message)
+			};
+		},
+		async async(e, r) {
+			return {
+				name: await r.parse(e.name),
+				message: await r.parse(e.message)
+			};
+		},
+		stream(e, r) {
+			return {
+				name: r.parse(e.name),
+				message: r.parse(e.message)
+			};
+		}
+	},
+	serialize(e, r) {
+		return "new DOMException(" + r.serialize(e.message) + "," + r.serialize(e.name) + ")";
+	},
+	deserialize(e, r) {
+		return new DOMException(r.deserialize(e.message), r.deserialize(e.name));
+	}
+});
+function f(e) {
+	return {
+		bubbles: e.bubbles,
+		cancelable: e.cancelable,
+		composed: e.composed
+	};
+}
+ni({
+	tag: "seroval-plugins/web/Event",
+	test(e) {
+		return typeof Event == "undefined" ? !1 : e instanceof Event;
+	},
+	parse: {
+		sync(e, r) {
+			return {
+				type: r.parse(e.type),
+				options: r.parse(f(e))
+			};
+		},
+		async async(e, r) {
+			return {
+				type: await r.parse(e.type),
+				options: await r.parse(f(e))
+			};
+		},
+		stream(e, r) {
+			return {
+				type: r.parse(e.type),
+				options: r.parse(f(e))
+			};
+		}
+	},
+	serialize(e, r) {
+		return "new Event(" + r.serialize(e.type) + "," + r.serialize(e.options) + ")";
+	},
+	deserialize(e, r) {
+		return new Event(r.deserialize(e.type), r.deserialize(e.options));
+	}
+});
+var m = ni({
+	tag: "seroval-plugins/web/File",
+	test(e) {
+		return typeof File == "undefined" ? !1 : e instanceof File;
+	},
+	parse: { async async(e, r) {
+		return {
+			name: await r.parse(e.name),
+			options: await r.parse({
+				type: e.type,
+				lastModified: e.lastModified
+			}),
+			buffer: await r.parse(await e.arrayBuffer())
+		};
+	} },
+	serialize(e, r) {
+		return "new File([" + r.serialize(e.buffer) + "]," + r.serialize(e.name) + "," + r.serialize(e.options) + ")";
+	},
+	deserialize(e, r) {
+		return new File([r.deserialize(e.buffer)], r.deserialize(e.name), r.deserialize(e.options));
+	}
+});
+function y(e) {
+	let r = [];
+	return e.forEach((a, t) => {
+		r.push([t, a]);
+	}), r;
+}
+var o = {}, v = (e, r = new FormData(), a = 0, t = e.length, s) => {
+	for (; a < t; a++) s = e[a], r.append(s[0], s[1]);
+	return r;
+};
+ni({
+	tag: "seroval-plugins/web/FormData",
+	extends: [m, ni({
+		tag: "seroval-plugins/web/FormDataFactory",
+		test(e) {
+			return e === o;
+		},
+		parse: {
+			sync() {
+				return o;
+			},
+			async async() {
+				return await Promise.resolve(o);
+			},
+			stream() {
+				return o;
+			}
+		},
+		serialize() {
+			return v.toString();
+		},
+		deserialize() {
+			return o;
+		}
+	})],
+	test(e) {
+		return typeof FormData == "undefined" ? !1 : e instanceof FormData;
+	},
+	parse: {
+		sync(e, r) {
+			return {
+				factory: r.parse(o),
+				entries: r.parse(y(e))
+			};
+		},
+		async async(e, r) {
+			return {
+				factory: await r.parse(o),
+				entries: await r.parse(y(e))
+			};
+		},
+		stream(e, r) {
+			return {
+				factory: r.parse(o),
+				entries: r.parse(y(e))
+			};
+		}
+	},
+	serialize(e, r) {
+		return "(" + r.serialize(e.factory) + ")(" + r.serialize(e.entries) + ")";
+	},
+	deserialize(e, r) {
+		return v(r.deserialize(e.entries));
+	}
+});
+function g(e) {
+	let r = [];
+	return e.forEach((a, t) => {
+		r.push([t, a]);
+	}), r;
+}
+var l = ni({
+	tag: "seroval-plugins/web/Headers",
+	test(e) {
+		return typeof Headers == "undefined" ? !1 : e instanceof Headers;
+	},
+	parse: {
+		sync(e, r) {
+			return { value: r.parse(g(e)) };
+		},
+		async async(e, r) {
+			return { value: await r.parse(g(e)) };
+		},
+		stream(e, r) {
+			return { value: r.parse(g(e)) };
+		}
+	},
+	serialize(e, r) {
+		return "new Headers(" + r.serialize(e.value) + ")";
+	},
+	deserialize(e, r) {
+		return new Headers(r.deserialize(e.value));
+	}
+});
+ni({
+	tag: "seroval-plugins/web/ImageData",
+	test(e) {
+		return typeof ImageData == "undefined" ? !1 : e instanceof ImageData;
+	},
+	parse: {
+		sync(e, r) {
+			return {
+				data: r.parse(e.data),
+				width: r.parse(e.width),
+				height: r.parse(e.height),
+				options: r.parse({ colorSpace: e.colorSpace })
+			};
+		},
+		async async(e, r) {
+			return {
+				data: await r.parse(e.data),
+				width: await r.parse(e.width),
+				height: await r.parse(e.height),
+				options: await r.parse({ colorSpace: e.colorSpace })
+			};
+		},
+		stream(e, r) {
+			return {
+				data: r.parse(e.data),
+				width: r.parse(e.width),
+				height: r.parse(e.height),
+				options: r.parse({ colorSpace: e.colorSpace })
+			};
+		}
+	},
+	serialize(e, r) {
+		return "new ImageData(" + r.serialize(e.data) + "," + r.serialize(e.width) + "," + r.serialize(e.height) + "," + r.serialize(e.options) + ")";
+	},
+	deserialize(e, r) {
+		return new ImageData(r.deserialize(e.data), r.deserialize(e.width), r.deserialize(e.height), r.deserialize(e.options));
+	}
+});
+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) {}
+		}
+	});
+} }), x = ni({
+	tag: "seroval-plugins/web/ReadableStreamFactory",
+	test(e) {
+		return e === n;
+	},
+	parse: {
+		sync() {
+			return n;
+		},
+		async async() {
+			return await Promise.resolve(n);
+		},
+		stream() {
+			return n;
+		}
+	},
+	serialize() {
+		return P.toString();
+	},
+	deserialize() {
+		return n;
+	}
+});
+function w(e) {
+	let r = te$1(), 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 p = ni({
+	tag: "seroval/plugins/web/ReadableStream",
+	extends: [x],
+	test(e) {
+		return typeof ReadableStream == "undefined" ? !1 : e instanceof ReadableStream;
+	},
+	parse: {
+		sync(e, r) {
+			return {
+				factory: r.parse(n),
+				stream: r.parse(te$1())
+			};
+		},
+		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) {
+		return P(r.deserialize(e.stream));
+	}
+});
+function N(e, r) {
+	return {
+		body: r,
+		cache: e.cache,
+		credentials: e.credentials,
+		headers: e.headers,
+		integrity: e.integrity,
+		keepalive: e.keepalive,
+		method: e.method,
+		mode: e.mode,
+		redirect: e.redirect,
+		referrer: e.referrer,
+		referrerPolicy: e.referrerPolicy
+	};
+}
+ni({
+	tag: "seroval-plugins/web/Request",
+	extends: [p, l],
+	test(e) {
+		return typeof Request == "undefined" ? !1 : e instanceof Request;
+	},
+	parse: {
+		async async(e, r) {
+			return {
+				url: await r.parse(e.url),
+				options: await r.parse(N(e, e.body && !e.bodyUsed ? await e.clone().arrayBuffer() : null))
+			};
+		},
+		stream(e, r) {
+			return {
+				url: r.parse(e.url),
+				options: r.parse(N(e, e.body && !e.bodyUsed ? e.clone().body : null))
+			};
+		}
+	},
+	serialize(e, r) {
+		return "new Request(" + r.serialize(e.url) + "," + r.serialize(e.options) + ")";
+	},
+	deserialize(e, r) {
+		return new Request(r.deserialize(e.url), r.deserialize(e.options));
+	}
+});
+function h(e) {
+	return {
+		headers: e.headers,
+		status: e.status,
+		statusText: e.statusText
+	};
+}
+ni({
+	tag: "seroval-plugins/web/Response",
+	extends: [p, l],
+	test(e) {
+		return typeof Response == "undefined" ? !1 : e instanceof Response;
+	},
+	parse: {
+		async async(e, r) {
+			return {
+				body: await r.parse(e.body && !e.bodyUsed ? await e.clone().arrayBuffer() : null),
+				options: await r.parse(h(e))
+			};
+		},
+		stream(e, r) {
+			return {
+				body: r.parse(e.body && !e.bodyUsed ? e.clone().body : null),
+				options: r.parse(h(e))
+			};
+		}
+	},
+	serialize(e, r) {
+		return "new Response(" + r.serialize(e.body) + "," + r.serialize(e.options) + ")";
+	},
+	deserialize(e, r) {
+		return new Response(r.deserialize(e.body), r.deserialize(e.options));
+	}
+});
+ni({
+	tag: "seroval-plugins/web/URL",
+	test(e) {
+		return typeof URL == "undefined" ? !1 : e instanceof URL;
+	},
+	parse: {
+		sync(e, r) {
+			return { value: r.parse(e.href) };
+		},
+		async async(e, r) {
+			return { value: await r.parse(e.href) };
+		},
+		stream(e, r) {
+			return { value: r.parse(e.href) };
+		}
+	},
+	serialize(e, r) {
+		return "new URL(" + r.serialize(e.value) + ")";
+	},
+	deserialize(e, r) {
+		return new URL(r.deserialize(e.value));
+	}
+});
+ni({
+	tag: "seroval-plugins/web/URLSearchParams",
+	test(e) {
+		return typeof URLSearchParams == "undefined" ? !1 : e instanceof URLSearchParams;
+	},
+	parse: {
+		sync(e, r) {
+			return { value: r.parse(e.toString()) };
+		},
+		async async(e, r) {
+			return { value: await r.parse(e.toString()) };
+		},
+		stream(e, r) {
+			return { value: r.parse(e.toString()) };
+		}
+	},
+	serialize(e, r) {
+		return "new URLSearchParams(" + r.serialize(e.value) + ")";
+	},
+	deserialize(e, r) {
+		return new URLSearchParams(r.deserialize(e.value));
+	}
+});
+var ShallowErrorPlugin = /* @__PURE__ */ ni({
+	tag: "$TSR/Error",
+	test(value) {
+		return value instanceof Error;
+	},
+	parse: {
+		sync(value, ctx) {
+			return { message: ctx.parse(value.message) };
+		},
+		async async(value, ctx) {
+			return { message: await ctx.parse(value.message) };
+		},
+		stream(value, ctx) {
+			return { message: ctx.parse(value.message) };
+		}
+	},
+	serialize(node, ctx) {
+		return "new Error(" + ctx.serialize(node.message) + ")";
+	},
+	deserialize(node, ctx) {
+		return new Error(ctx.deserialize(node.message));
+	}
+});
+var RawStream = class {
+	constructor(stream, options) {
+		this.stream = stream;
+		this.hint = options?.hint ?? "binary";
+	}
+};
+var BufferCtor = globalThis.Buffer;
+var 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;
+}
+var RAW_STREAM_FACTORY_BINARY = /* @__PURE__ */ Object.create(null);
+var RAW_STREAM_FACTORY_TEXT = /* @__PURE__ */ Object.create(null);
+var 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 {}
+		}
+	});
+} });
+var textEncoderForFactory = new TextEncoder();
+var 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 {}
+			}
+		});
+	} });
+};
+var 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(_){}}})}}))`;
+var FACTORY_TEXT = `(s=>{const e=new TextEncoder();return new ReadableStream({start(c){s.on({next(v){try{if(typeof v==='string'){c.enqueue(e.encode(v))}else{const d=atob(v.$b64),a=new Uint8Array(d.length);for(let i=0;i<d.length;i++)a[i]=d.charCodeAt(i);c.enqueue(a)}}catch(_){}},throw(x){c.error(x)},return(){try{c.close()}catch(_){}}})}})})`;
+function toBinaryStream(readable) {
+	const stream = te$1();
+	const reader = readable.getReader();
+	(async () => {
+		try {
+			while (true) {
+				const { done, value } = await reader.read();
+				if (done) {
+					stream.return(void 0);
+					break;
+				}
+				stream.next(uint8ArrayToBase64(value));
+			}
+		} catch (error) {
+			stream.throw(error);
+		} finally {
+			reader.releaseLock();
+		}
+	})();
+	return stream;
+}
+function toTextStream(readable) {
+	const stream = te$1();
+	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;
+}
+var RawStreamSSRPlugin = ni({
+	tag: "tss/RawStream",
+	extends: [ni({
+		tag: "tss/RawStreamFactory",
+		test(value) {
+			return value === RAW_STREAM_FACTORY_BINARY;
+		},
+		parse: {
+			sync() {},
+			async() {
+				return Promise.resolve(void 0);
+			},
+			stream() {}
+		},
+		serialize() {
+			return FACTORY_BINARY;
+		},
+		deserialize() {
+			return RAW_STREAM_FACTORY_BINARY;
+		}
+	}), ni({
+		tag: "tss/RawStreamFactoryText",
+		test(value) {
+			return value === RAW_STREAM_FACTORY_TEXT;
+		},
+		parse: {
+			sync() {},
+			async() {
+				return Promise.resolve(void 0);
+			},
+			stream() {}
+		},
+		serialize() {
+			return FACTORY_TEXT;
+		},
+		deserialize() {
+			return RAW_STREAM_FACTORY_TEXT;
+		}
+	})],
+	test(value) {
+		return value instanceof RawStream;
+	},
+	parse: {
+		sync(value, ctx) {
+			const factory = value.hint === "text" ? RAW_STREAM_FACTORY_TEXT : RAW_STREAM_FACTORY_BINARY;
+			return {
+				hint: value.hint,
+				factory: ctx.parse(factory),
+				stream: ctx.parse(te$1())
+			};
+		},
+		async async(value, ctx) {
+			const factory = value.hint === "text" ? RAW_STREAM_FACTORY_TEXT : RAW_STREAM_FACTORY_BINARY;
+			const encodedStream = value.hint === "text" ? toTextStream(value.stream) : toBinaryStream(value.stream);
+			return {
+				hint: value.hint,
+				factory: await ctx.parse(factory),
+				stream: await ctx.parse(encodedStream)
+			};
+		},
+		stream(value, ctx) {
+			const factory = value.hint === "text" ? RAW_STREAM_FACTORY_TEXT : RAW_STREAM_FACTORY_BINARY;
+			const encodedStream = value.hint === "text" ? toTextStream(value.stream) : toBinaryStream(value.stream);
+			return {
+				hint: value.hint,
+				factory: ctx.parse(factory),
+				stream: ctx.parse(encodedStream)
+			};
+		}
+	},
+	serialize(node, ctx) {
+		return "(" + ctx.serialize(node.factory) + ")(" + ctx.serialize(node.stream) + ")";
+	},
+	deserialize(node, ctx) {
+		const stream = ctx.deserialize(node.stream);
+		return node.hint === "text" ? RAW_STREAM_FACTORY_CONSTRUCTOR_TEXT(stream) : RAW_STREAM_FACTORY_CONSTRUCTOR_BINARY(stream);
+	}
+});
+function createRawStreamRPCPlugin(onRawStream) {
+	let nextStreamId = 1;
+	return ni({
+		tag: "tss/RawStream",
+		test(value) {
+			return value instanceof RawStream;
+		},
+		parse: {
+			async(value) {
+				const streamId = nextStreamId++;
+				onRawStream(streamId, value.stream);
+				return Promise.resolve({ streamId });
+			},
+			stream(value) {
+				const streamId = nextStreamId++;
+				onRawStream(streamId, value.stream);
+				return { streamId };
+			}
+		},
+		serialize() {
+			throw new Error("RawStreamRPCPlugin.serialize should not be called. RPC uses JSON serialization, not JS code generation.");
+		},
+		deserialize() {
+			throw new Error("RawStreamRPCPlugin.deserialize should not be called. Use createRawStreamDeserializePlugin on client.");
+		}
+	});
+}
+var defaultSerovalPlugins = [
+	ShallowErrorPlugin,
+	RawStreamSSRPlugin,
+	p
+];
+var TSS_FORMDATA_CONTEXT = "__TSS_CONTEXT";
+var TSS_SERVER_FUNCTION = /* @__PURE__ */ Symbol.for("TSS_SERVER_FUNCTION");
+var TSS_SERVER_FUNCTION_FACTORY = /* @__PURE__ */ Symbol.for("TSS_SERVER_FUNCTION_FACTORY");
+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 TSS_CONTENT_TYPE_FRAMED_VERSIONED = `${TSS_CONTENT_TYPE_FRAMED}; v=1`;
+var GLOBAL_STORAGE_KEY = /* @__PURE__ */ Symbol.for("tanstack-start:start-storage-context");
+var globalObj$1 = globalThis;
+if (!globalObj$1[GLOBAL_STORAGE_KEY]) globalObj$1[GLOBAL_STORAGE_KEY] = new AsyncLocalStorage();
+var startStorage = globalObj$1[GLOBAL_STORAGE_KEY];
+async function runWithStartContext(context, fn) {
+	return startStorage.run(context, fn);
+}
+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;
+var getStartContextServerOnly = getStartContext;
+function isSafeKey(key) {
+	return key !== "__proto__" && key !== "constructor" && key !== "prototype";
+}
+function safeObjectMerge(target, source) {
+	const result = /* @__PURE__ */ Object.create(null);
+	if (target) {
+		for (const key of Object.keys(target)) if (isSafeKey(key)) result[key] = target[key];
+	}
+	if (source && typeof source === "object") {
+		for (const key of Object.keys(source)) if (isSafeKey(key)) result[key] = source[key];
+	}
+	return result;
+}
+function createNullProtoObject(source) {
+	if (!source) return /* @__PURE__ */ Object.create(null);
+	const obj = /* @__PURE__ */ Object.create(null);
+	for (const key of Object.keys(source)) if (isSafeKey(key)) obj[key] = source[key];
+	return obj;
+}
+var createServerFn = (options, __opts) => {
+	const resolvedOptions = __opts || options || {};
+	if (typeof resolvedOptions.method === "undefined") resolvedOptions.method = "GET";
+	const res = {
+		options: resolvedOptions,
+		middleware: (middleware) => {
+			const newMiddleware = [...resolvedOptions.middleware || []];
+			middleware.map((m) => {
+				if (TSS_SERVER_FUNCTION_FACTORY in m) {
+					if (m.options.middleware) newMiddleware.push(...m.options.middleware);
+				} else newMiddleware.push(m);
+			});
+			const res2 = createServerFn(void 0, {
+				...resolvedOptions,
+				middleware: newMiddleware
+			});
+			res2[TSS_SERVER_FUNCTION_FACTORY] = true;
+			return res2;
+		},
+		inputValidator: (inputValidator) => {
+			return createServerFn(void 0, {
+				...resolvedOptions,
+				inputValidator
+			});
+		},
+		handler: (...args) => {
+			const [extractedFn, serverFn] = args;
+			const newOptions = {
+				...resolvedOptions,
+				extractedFn,
+				serverFn
+			};
+			const resolvedMiddleware = [...newOptions.middleware || [], serverFnBaseToMiddleware(newOptions)];
+			extractedFn.method = resolvedOptions.method;
+			return Object.assign(async (opts) => {
+				const result = await executeMiddleware$1(resolvedMiddleware, "client", {
+					...extractedFn,
+					...newOptions,
+					data: opts?.data,
+					headers: opts?.headers,
+					signal: opts?.signal,
+					fetch: opts?.fetch,
+					context: createNullProtoObject()
+				});
+				const redirect = parseRedirect(result.error);
+				if (redirect) throw redirect;
+				if (result.error) throw result.error;
+				return result.result;
+			}, {
+				...extractedFn,
+				method: resolvedOptions.method,
+				__executeServer: async (opts) => {
+					const startContext = getStartContextServerOnly();
+					const serverContextAfterGlobalMiddlewares = startContext.contextAfterGlobalMiddlewares;
+					return await executeMiddleware$1(resolvedMiddleware, "server", {
+						...extractedFn,
+						...opts,
+						serverFnMeta: extractedFn.serverFnMeta,
+						context: safeObjectMerge(serverContextAfterGlobalMiddlewares, opts.context),
+						request: startContext.request
+					}).then((d) => ({
+						result: d.result,
+						error: d.error,
+						context: d.sendContext
+					}));
+				}
+			});
+		}
+	};
+	const fun = (options2) => {
+		return createServerFn(void 0, {
+			...resolvedOptions,
+			...options2
+		});
+	};
+	return Object.assign(fun, res);
+};
+async function executeMiddleware$1(middlewares, env, opts) {
+	let flattenedMiddlewares = flattenMiddlewares([...getStartOptions()?.functionMiddleware || [], ...middlewares]);
+	if (env === "server") {
+		const startContext = getStartContextServerOnly({ throwIfNotFound: false });
+		if (startContext?.executedRequestMiddlewares) flattenedMiddlewares = flattenedMiddlewares.filter((m) => !startContext.executedRequestMiddlewares.has(m));
+	}
+	const callNextMiddleware = async (ctx) => {
+		const nextMiddleware = flattenedMiddlewares.shift();
+		if (!nextMiddleware) return ctx;
+		try {
+			if ("inputValidator" in nextMiddleware.options && nextMiddleware.options.inputValidator && env === "server") ctx.data = await execValidator(nextMiddleware.options.inputValidator, ctx.data);
+			let middlewareFn = void 0;
+			if (env === "client") {
+				if ("client" in nextMiddleware.options) middlewareFn = nextMiddleware.options.client;
+			} else if ("server" in nextMiddleware.options) middlewareFn = nextMiddleware.options.server;
+			if (middlewareFn) {
+				const userNext = async (userCtx = {}) => {
+					const result2 = await callNextMiddleware({
+						...ctx,
+						...userCtx,
+						context: safeObjectMerge(ctx.context, userCtx.context),
+						sendContext: safeObjectMerge(ctx.sendContext, userCtx.sendContext),
+						headers: mergeHeaders(ctx.headers, userCtx.headers),
+						_callSiteFetch: ctx._callSiteFetch,
+						fetch: ctx._callSiteFetch ?? userCtx.fetch ?? ctx.fetch,
+						result: userCtx.result !== void 0 ? userCtx.result : userCtx instanceof Response ? userCtx : ctx.result,
+						error: userCtx.error ?? ctx.error
+					});
+					if (result2.error) throw result2.error;
+					return result2;
+				};
+				const result = await middlewareFn({
+					...ctx,
+					next: userNext
+				});
+				if (isRedirect(result)) return {
+					...ctx,
+					error: result
+				};
+				if (result instanceof Response) return {
+					...ctx,
+					result
+				};
+				if (!result) throw new Error("User middleware returned undefined. You must call next() or return a result in your middlewares.");
+				return result;
+			}
+			return callNextMiddleware(ctx);
+		} catch (error) {
+			return {
+				...ctx,
+				error
+			};
+		}
+	};
+	return callNextMiddleware({
+		...opts,
+		headers: opts.headers || {},
+		sendContext: opts.sendContext || {},
+		context: opts.context || createNullProtoObject(),
+		_callSiteFetch: opts.fetch
+	});
+}
+function flattenMiddlewares(middlewares, maxDepth = 100) {
+	const seen = /* @__PURE__ */ new Set();
+	const flattened = [];
+	const recurse = (middleware, depth) => {
+		if (depth > maxDepth) throw new Error(`Middleware nesting depth exceeded maximum of ${maxDepth}. Check for circular references.`);
+		middleware.forEach((m) => {
+			if (m.options.middleware) recurse(m.options.middleware, depth + 1);
+			if (!seen.has(m)) {
+				seen.add(m);
+				flattened.push(m);
+			}
+		});
+	};
+	recurse(middlewares, 0);
+	return flattened;
+}
+async function execValidator(validator, input) {
+	if (validator == null) return {};
+	if ("~standard" in validator) {
+		const result = await validator["~standard"].validate(input);
+		if (result.issues) throw new Error(JSON.stringify(result.issues, void 0, 2));
+		return result.value;
+	}
+	if ("parse" in validator) return validator.parse(input);
+	if (typeof validator === "function") return validator(input);
+	throw new Error("Invalid validator type!");
+}
+function serverFnBaseToMiddleware(options) {
+	return {
+		"~types": void 0,
+		options: {
+			inputValidator: options.inputValidator,
+			client: async ({ next, sendContext, fetch, ...ctx }) => {
+				const payload = {
+					...ctx,
+					context: sendContext,
+					fetch
+				};
+				return next(await options.extractedFn?.(payload));
+			},
+			server: async ({ next, ...ctx }) => {
+				const result = await options.serverFn?.(ctx);
+				return next({
+					...ctx,
+					result
+				});
+			}
+		}
+	};
+}
+function getDefaultSerovalPlugins() {
+	return [...(getStartOptions()?.serializationAdapters)?.map(makeSerovalPlugin) ?? [], ...defaultSerovalPlugins];
+}
+var minifiedTsrBootStrapScript = "self.$_TSR={h(){this.hydrated=!0,this.c()},e(){this.streamEnded=!0,this.c()},c(){this.hydrated&&this.streamEnded&&(delete self.$_TSR,delete self.$R.tsr)},p(e){this.initialized?e():this.buffer.push(e)},buffer:[]};\n";
+var SCOPE_ID = "tsr";
+var TSR_PREFIX = GLOBAL_TSR + ".router=";
+var P_PREFIX = GLOBAL_TSR + ".p(()=>";
+var 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;
+}
+var INITIAL_SCRIPTS = [mn(SCOPE_ID), minifiedTsrBootStrapScript];
+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;
+	}
+};
+var MANIFEST_CACHE_SIZE = 100;
+var manifestCaches = /* @__PURE__ */ new WeakMap();
+function getManifestCache(manifest) {
+	const cache = manifestCaches.get(manifest);
+	if (cache) return cache;
+	const newCache = createLRUCache(MANIFEST_CACHE_SIZE);
+	manifestCaches.set(manifest, newCache);
+	return newCache;
+}
+function attachRouterServerSsrUtils({ router, manifest }) {
+	router.ssr = { manifest };
+	let _dehydrated = false;
+	let _serializationFinished = false;
+	const renderFinishedListeners = [];
+	const serializationFinishedListeners = [];
+	const scriptBuffer = new ScriptBuffer(router);
+	let injectedHtmlBuffer = "";
+	router.serverSsr = {
+		injectHtml: (html) => {
+			if (!html) return;
+			injectedHtmlBuffer += html;
+			router.emit({ type: "onInjectedHtml" });
+		},
+		injectScript: (script) => {
+			if (!script) return;
+			const html = `<script${router.options.ssr?.nonce ? ` nonce='${router.options.ssr.nonce}'` : ""}>${script}<\/script>`;
+			router.serverSsr.injectHtml(html);
+		},
+		dehydrate: async () => {
+			invariant(!_dehydrated, "router is already dehydrated!");
+			let matchesToDehydrate = router.state.matches;
+			if (router.isShell()) matchesToDehydrate = matchesToDehydrate.slice(0, 1);
+			const matches = matchesToDehydrate.map(dehydrateMatch);
+			let manifestToDehydrate = void 0;
+			if (manifest) {
+				const currentRouteIdsList = matchesToDehydrate.map((m) => m.routeId);
+				const manifestCacheKey = currentRouteIdsList.join("\0");
+				let filteredRoutes;
+				filteredRoutes = getManifestCache(manifest).get(manifestCacheKey);
+				if (!filteredRoutes) {
+					const currentRouteIds = new Set(currentRouteIdsList);
+					const nextFilteredRoutes = {};
+					for (const routeId in manifest.routes) {
+						const routeManifest = manifest.routes[routeId];
+						if (currentRouteIds.has(routeId)) nextFilteredRoutes[routeId] = routeManifest;
+						else if (routeManifest.assets && routeManifest.assets.length > 0) nextFilteredRoutes[routeId] = { assets: routeManifest.assets };
+					}
+					getManifestCache(manifest).set(manifestCacheKey, nextFilteredRoutes);
+					filteredRoutes = nextFilteredRoutes;
+				}
+				manifestToDehydrate = { routes: filteredRoutes };
+			}
+			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) => makeSsrSerovalPlugin(t, trackPlugins)).concat(defaultSerovalPlugins) : defaultSerovalPlugins;
+			const signalSerializationComplete = () => {
+				_serializationFinished = true;
+				try {
+					serializationFinishedListeners.forEach((l) => l());
+					router.emit({ type: "onSerializationFinished" });
+				} catch (err) {
+					console.error("Serialization listener error:", err);
+				} finally {
+					serializationFinishedListeners.length = 0;
+					renderFinishedListeners.length = 0;
+				}
+			};
+			cn(dehydratedRouter, {
+				refs: /* @__PURE__ */ new Map(),
+				plugins,
+				onSerialize: (data, initial) => {
+					let serialized = initial ? TSR_PREFIX + data : data;
+					if (trackPlugins.didRun) serialized = P_PREFIX + serialized + P_SUFFIX;
+					scriptBuffer.enqueue(serialized);
+				},
+				scopeId: SCOPE_ID,
+				onDone: () => {
+					scriptBuffer.enqueue(GLOBAL_TSR + ".e()");
+					scriptBuffer.flush();
+					signalSerializationComplete();
+				},
+				onError: (err) => {
+					console.error("Serialization error:", err);
+					signalSerializationComplete();
+				}
+			});
+		},
+		isDehydrated() {
+			return _dehydrated;
+		},
+		isSerializationFinished() {
+			return _serializationFinished;
+		},
+		onRenderFinished: (listener) => renderFinishedListeners.push(listener),
+		onSerializationFinished: (listener) => serializationFinishedListeners.push(listener),
+		setRenderFinished: () => {
+			try {
+				renderFinishedListeners.forEach((l) => l());
+			} catch (err) {
+				console.error("Error in render finished listener:", err);
+			} finally {
+				renderFinishedListeners.length = 0;
+			}
+			scriptBuffer.liftBarrier();
+		},
+		takeBufferedScripts() {
+			const scripts = scriptBuffer.takeAll();
+			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
+	};
+}
+var NullProtoObj = /* @__PURE__ */ (() => {
+	const e = function() {};
+	return e.prototype = 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);
+	}
+}
+var _needsNormRE = /(?:(?:^|\/)(?:\.|\.\.|%2e|%2e\.|\.%2e|%2e%2e)(?:\/|$))|[\\^\x80-\uffff]/i;
+/**
+* URL wrapper with fast paths to access to the following props:
+*
+*  - `url.pathname`
+*  - `url.search`
+*  - `url.searchParams`
+*  - `url.protocol`
+*
+* **NOTES:**
+*
+* - It is assumed that the input URL is **already encoded** and formatted from an HTTP request and contains no hash.
+* - Triggering the setters or getters on other props will deoptimize to full URL parsing.
+* - Changes to `searchParams` will be discarded as we don't track them.
+*/
+var FastURL = /* @__PURE__ */ (() => {
+	const NativeURL = globalThis.URL;
+	const FastURL = class URL {
+		#url;
+		#href;
+		#protocol;
+		#host;
+		#pathname;
+		#search;
+		#searchParams;
+		#pos;
+		constructor(url) {
+			if (typeof url === "string") this.#href = 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(FastURL.prototype, NativeURL.prototype, "_url");
+	Object.setPrototypeOf(FastURL.prototype, NativeURL.prototype);
+	Object.setPrototypeOf(FastURL, NativeURL);
+	return FastURL;
+})();
+/**
+* Fast Response for Node.js runtime
+*
+* It is faster because in most cases it doesn't create a full Response instance.
+*/
+var NodeResponse = /* @__PURE__ */ (() => {
+	const NativeResponse = globalThis.Response;
+	const STATUS_CODES = globalThis.process?.getBuiltinModule?.("node:http")?.STATUS_CODES || {};
+	class NodeResponse {
+		#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(([k, v]) => [k.toLowerCase(), v]) : void 0);
+			let hasContentTypeHeader;
+			let hasContentLength;
+			if (headerEntries) for (const [key, value] of headerEntries) {
+				if (Array.isArray(value)) for (const v of value) headers.push([key, v]);
+				else headers.push([key, value]);
+				if (key === "content-type") hasContentTypeHeader = true;
+				else if (key === "content-length") hasContentLength = true;
+			}
+			if (contentType && !hasContentTypeHeader) headers.push(["content-type", contentType]);
+			if (contentLength && !hasContentLength) headers.push(["content-length", String(contentLength)]);
+			this.#init = void 0;
+			this.#headers = void 0;
+			this.#response = void 0;
+			this.#body = void 0;
+			return {
+				status,
+				statusText,
+				headers,
+				body
+			};
+		}
+	}
+	lazyInherit(NodeResponse.prototype, NativeResponse.prototype, "_response");
+	Object.setPrototypeOf(NodeResponse, NativeResponse);
+	Object.setPrototypeOf(NodeResponse.prototype, NativeResponse.prototype);
+	return NodeResponse;
+})();
+var kEventNS = "h3.internal.event.";
+var kEventRes = /* @__PURE__ */ Symbol.for(`${kEventNS}res`);
+var kEventResHeaders = /* @__PURE__ */ Symbol.for(`${kEventNS}res.headers`);
+var H3Event = class {
+	app;
+	req;
+	url;
+	context;
+	static __is_event__ = true;
+	constructor(req, context, app) {
+		this.context = context || req.context || new NullProtoObj();
+		this.req = req;
+		this.app = app;
+		const _url = req._url;
+		this.url = _url && _url instanceof URL ? _url : new FastURL(req.url);
+	}
+	get res() {
+		return this[kEventRes] ||= new H3EventResponse();
+	}
+	get runtime() {
+		return this.req.runtime;
+	}
+	waitUntil(promise) {
+		this.req.waitUntil?.(promise);
+	}
+	toString() {
+		return `[${this.req.method}] ${this.req.url}`;
+	}
+	toJSON() {
+		return this.toString();
+	}
+	get node() {
+		return this.req.runtime?.node;
+	}
+	get headers() {
+		return this.req.headers;
+	}
+	get path() {
+		return this.url.pathname + this.url.search;
+	}
+	get method() {
+		return this.req.method;
+	}
+};
+var H3EventResponse = class {
+	status;
+	statusText;
+	get headers() {
+		return this[kEventResHeaders] ||= new Headers();
+	}
+};
+var 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 HTTPError 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 HTTPError({
+			...details,
+			statusText,
+			status
+		});
+	}
+	constructor(arg1, arg2) {
+		let messageInput;
+		let details;
+		if (typeof arg1 === "string") {
+			messageInput = arg1;
+			details = arg2;
+		} else details = arg1;
+		const status = sanitizeStatusCode(details?.status || (details?.cause)?.status || details?.status || details?.statusCode, 500);
+		const statusText = sanitizeStatusMessage(details?.statusText || (details?.cause)?.statusText || details?.statusText || details?.statusMessage);
+		const message = messageInput || details?.message || (details?.cause)?.message || details?.statusText || details?.statusMessage || [
+			"HTTPError",
+			status,
+			statusText
+		].filter(Boolean).join(" ");
+		super(message, { cause: details });
+		this.cause = details;
+		this.status = status;
+		this.statusText = statusText || void 0;
+		const rawHeaders = details?.headers || (details?.cause)?.headers;
+		this.headers = rawHeaders ? new Headers(rawHeaders) : void 0;
+		this.unhandled = details?.unhandled ?? (details?.cause)?.unhandled ?? void 0;
+		this.data = details?.data;
+		this.body = details?.body;
+	}
+	get statusCode() {
+		return this.status;
+	}
+	get statusMessage() {
+		return this.statusText;
+	}
+	toJSON() {
+		const unhandled = this.unhandled;
+		return {
+			status: this.status,
+			statusText: this.statusText,
+			unhandled,
+			message: unhandled ? "HTTPError" : this.message,
+			data: unhandled ? void 0 : this.data,
+			...unhandled ? void 0 : this.body
+		};
+	}
+};
+function isJSONSerializable(value, _type) {
+	if (value === null || value === void 0) return true;
+	if (_type !== "object") return _type === "boolean" || _type === "number" || _type === "string";
+	if (typeof value.toJSON === "function") return true;
+	if (Array.isArray(value)) return true;
+	if (typeof value.pipe === "function" || typeof value.pipeTo === "function") return false;
+	if (value instanceof NullProtoObj) return true;
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+}
+var kNotFound = /* @__PURE__ */ Symbol.for("h3.notFound");
+var kHandled = /* @__PURE__ */ Symbol.for("h3.handled");
+function toResponse(val, event, config = {}) {
+	if (typeof val?.then === "function") return (val.catch?.((error) => error) || Promise.resolve(val)).then((resolvedVal) => toResponse(resolvedVal, event, config));
+	const response = prepareResponse(val, event, config);
+	if (typeof response?.then === "function") return toResponse(response, event, config);
+	const { onResponse } = config;
+	return onResponse ? Promise.resolve(onResponse(response, event)).then(() => response) : response;
+}
+var HTTPResponse = class {
+	#headers;
+	#init;
+	body;
+	constructor(body, init) {
+		this.body = body;
+		this.#init = init;
+	}
+	get status() {
+		return this.#init?.status || 200;
+	}
+	get statusText() {
+		return this.#init?.statusText || "OK";
+	}
+	get headers() {
+		return this.#headers ||= new Headers(this.#init?.headers);
+	}
+};
+function prepareResponse(val, event, config, nested) {
+	if (val === kHandled) return new NodeResponse(null);
+	if (val === kNotFound) val = new HTTPError({
+		status: 404,
+		message: `Cannot find any route matching [${event.req.method}] ${event.url}`
+	});
+	if (val && val instanceof Error) {
+		const isHTTPError = HTTPError.isError(val);
+		const error = isHTTPError ? val : new HTTPError(val);
+		if (!isHTTPError) {
+			error.unhandled = true;
+			if (val?.stack) error.stack = val.stack;
+		}
+		if (error.unhandled && !config.silent) console.error(error);
+		const { onError } = config;
+		return onError && !nested ? Promise.resolve(onError(error, event)).catch((error) => error).then((newVal) => prepareResponse(newVal ?? val, event, config, true)) : errorResponse(error, config.debug);
+	}
+	const preparedRes = event[kEventRes];
+	const preparedHeaders = preparedRes?.[kEventResHeaders];
+	event[kEventRes] = void 0;
+	if (!(val instanceof Response)) {
+		const res = prepareResponseBody(val, event, config);
+		const status = res.status || preparedRes?.status;
+		return new NodeResponse(nullBody(event.req.method, status) ? null : res.body, {
+			status,
+			statusText: res.statusText || preparedRes?.statusText,
+			headers: res.headers && preparedHeaders ? mergeHeaders$1(res.headers, preparedHeaders) : res.headers || preparedHeaders
+		});
+	}
+	if (!preparedHeaders || nested || !val.ok) return val;
+	try {
+		mergeHeaders$1(val.headers, preparedHeaders, val.headers);
+		return val;
+	} catch {
+		return new NodeResponse(nullBody(event.req.method, val.status) ? null : val.body, {
+			status: val.status,
+			statusText: val.statusText,
+			headers: mergeHeaders$1(val.headers, preparedHeaders)
+		});
+	}
+}
+function mergeHeaders$1(base, overrides, target = new Headers(base)) {
+	for (const [name, value] of overrides) if (name === "set-cookie") target.append(name, value);
+	else target.set(name, value);
+	return target;
+}
+var 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");
+};
+var emptyHeaders = /* @__PURE__ */ new FrozenHeaders({ "content-length": "0" });
+var jsonHeaders = /* @__PURE__ */ new FrozenHeaders({ "content-type": "application/json;charset=UTF-8" });
+function prepareResponseBody(val, event, config) {
+	if (val === null || val === void 0) return {
+		body: "",
+		headers: emptyHeaders
+	};
+	const valType = typeof val;
+	if (valType === "string") return { body: val };
+	if (val instanceof Uint8Array) {
+		event.res.headers.set("content-length", val.byteLength.toString());
+		return { body: val };
+	}
+	if (val instanceof HTTPResponse || val?.constructor?.name === "HTTPResponse") return val;
+	if (isJSONSerializable(val, valType)) return {
+		body: JSON.stringify(val, void 0, config.debug ? 2 : void 0),
+		headers: jsonHeaders
+	};
+	if (valType === "bigint") return {
+		body: val.toString(),
+		headers: jsonHeaders
+	};
+	if (val instanceof Blob) {
+		const headers = new Headers({
+			"content-type": val.type,
+			"content-length": val.size.toString()
+		});
+		let filename = val.name;
+		if (filename) {
+			filename = encodeURIComponent(filename);
+			headers.set("content-disposition", `filename="${filename}"; filename*=UTF-8''${filename}`);
+		}
+		return {
+			body: val.stream(),
+			headers
+		};
+	}
+	if (valType === "symbol") return { body: val.toString() };
+	if (valType === "function") return { body: `${val.name}()` };
+	return { body: val };
+}
+function nullBody(method, status) {
+	return method === "HEAD" || status === 100 || status === 101 || status === 102 || status === 204 || status === 205 || status === 304;
+}
+function errorResponse(error, debug) {
+	return new NodeResponse(JSON.stringify({
+		...error.toJSON(),
+		stack: debug && error.stack ? error.stack.split("\n").map((l) => l.trim()) : void 0
+	}, void 0, debug ? 2 : void 0), {
+		status: error.status,
+		statusText: error.statusText,
+		headers: error.headers ? mergeHeaders$1(jsonHeaders, error.headers) : new Headers(jsonHeaders)
+	});
+}
+new TextEncoder();
+var GLOBAL_EVENT_STORAGE_KEY = /* @__PURE__ */ Symbol.for("tanstack-start:event-storage");
+var globalObj = globalThis;
+if (!globalObj[GLOBAL_EVENT_STORAGE_KEY]) globalObj[GLOBAL_EVENT_STORAGE_KEY] = new AsyncLocalStorage();
+var eventStorage = globalObj[GLOBAL_EVENT_STORAGE_KEY];
+function isPromiseLike(value) {
+	return typeof value.then === "function";
+}
+function getSetCookieValues(headers) {
+	const headersWithSetCookie = headers;
+	if (typeof headersWithSetCookie.getSetCookie === "function") return headersWithSetCookie.getSetCookie();
+	const value = headers.get("set-cookie");
+	return value ? [value] : [];
+}
+function mergeEventResponseHeaders(response, event) {
+	if (response.ok) return;
+	const eventSetCookies = getSetCookieValues(event.res.headers);
+	if (eventSetCookies.length === 0) return;
+	const responseSetCookies = getSetCookieValues(response.headers);
+	response.headers.delete("set-cookie");
+	for (const cookie of responseSetCookies) response.headers.append("set-cookie", cookie);
+	for (const cookie of eventSetCookies) response.headers.append("set-cookie", cookie);
+}
+function attachResponseHeaders(value, event) {
+	if (isPromiseLike(value)) return value.then((resolved) => {
+		if (resolved instanceof Response) mergeEventResponseHeaders(resolved, event);
+		return resolved;
+	});
+	if (value instanceof Response) mergeEventResponseHeaders(value, event);
+	return value;
+}
+function requestHandler(handler) {
+	return (request, requestOpts) => {
+		const h3Event = new H3Event(request);
+		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;
+}
+async function getStartManifest(matchedRoutes) {
+	const { tsrStartManifest } = await import("../_tanstack-start-manifest_v-DTbQVOpU.mjs");
+	const startManifest = tsrStartManifest();
+	const rootRoute = startManifest.routes[rootRouteId] = startManifest.routes["__root__"] || {};
+	rootRoute.assets = rootRoute.assets || [];
+	let injectedHeadScripts;
+	return {
+		manifest: { routes: Object.fromEntries(Object.entries(startManifest.routes).flatMap(([k, v]) => {
+			const result = {};
+			let hasData = false;
+			if (v.preloads && v.preloads.length > 0) {
+				result["preloads"] = v.preloads;
+				hasData = true;
+			}
+			if (v.assets && v.assets.length > 0) {
+				result["assets"] = v.assets;
+				hasData = true;
+			}
+			if (!hasData) return [];
+			return [[k, result]];
+		})) },
+		clientEntry: startManifest.clientEntry,
+		injectedHeadScripts
+	};
+}
+var textEncoder$1 = new TextEncoder();
+var EMPTY_PAYLOAD = new Uint8Array(0);
+function encodeFrame(type, streamId, payload) {
+	const frame = new Uint8Array(9 + 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, 9);
+	return frame;
+}
+function encodeJSONFrame(json) {
+	return encodeFrame(FrameType.JSON, 0, textEncoder$1.encode(json));
+}
+function encodeChunkFrame(streamId, chunk) {
+	return encodeFrame(FrameType.CHUNK, streamId, chunk);
+}
+function encodeEndFrame(streamId) {
+	return encodeFrame(FrameType.END, streamId, EMPTY_PAYLOAD);
+}
+function encodeErrorFrame(streamId, error) {
+	const message = error instanceof Error ? error.message : String(error ?? "Unknown error");
+	return encodeFrame(FrameType.ERROR, streamId, textEncoder$1.encode(message));
+}
+function createMultiplexedStream(jsonStream, rawStreams) {
+	let activePumps = 1 + rawStreams.size;
+	let controllerRef = null;
+	let cancelled = false;
+	const cancelReaders = [];
+	const safeEnqueue = (chunk) => {
+		if (cancelled || !controllerRef) return;
+		try {
+			controllerRef.enqueue(chunk);
+		} catch {}
+	};
+	const safeError = (err) => {
+		if (cancelled || !controllerRef) return;
+		try {
+			controllerRef.error(err);
+		} catch {}
+	};
+	const safeClose = () => {
+		if (cancelled || !controllerRef) return;
+		try {
+			controllerRef.close();
+		} catch {}
+	};
+	const checkComplete = () => {
+		activePumps--;
+		if (activePumps === 0) safeClose();
+	};
+	return new ReadableStream({
+		start(controller) {
+			controllerRef = controller;
+			cancelReaders.length = 0;
+			const pumpJSON = async () => {
+				const reader = jsonStream.getReader();
+				cancelReaders.push(() => {
+					reader.cancel().catch(() => {});
+				});
+				try {
+					while (true) {
+						const { done, value } = await reader.read();
+						if (cancelled) break;
+						if (done) break;
+						safeEnqueue(encodeJSONFrame(value));
+					}
+				} catch (error) {
+					safeError(error);
+				} finally {
+					reader.releaseLock();
+					checkComplete();
+				}
+			};
+			const pumpRawStream = async (streamId, stream) => {
+				const reader = stream.getReader();
+				cancelReaders.push(() => {
+					reader.cancel().catch(() => {});
+				});
+				try {
+					while (true) {
+						const { done, value } = await reader.read();
+						if (cancelled) break;
+						if (done) {
+							safeEnqueue(encodeEndFrame(streamId));
+							break;
+						}
+						safeEnqueue(encodeChunkFrame(streamId, value));
+					}
+				} catch (error) {
+					safeEnqueue(encodeErrorFrame(streamId, error));
+				} finally {
+					reader.releaseLock();
+					checkComplete();
+				}
+			};
+			pumpJSON();
+			for (const [streamId, stream] of rawStreams) pumpRawStream(streamId, stream);
+		},
+		cancel() {
+			cancelled = true;
+			controllerRef = null;
+			for (const cancelReader of cancelReaders) cancelReader();
+			cancelReaders.length = 0;
+		}
+	});
+}
+var manifest = {
+	"51a34c05479a893c7d320bd4cd1604427289d667698c48b9f30a01aabf8a5e68": {
+		functionName: "getConfig_createServerFn_handler",
+		importer: () => import("./api-rpc-D3ZehMIN.mjs")
+	},
+	"79ada05964de8f2123bfcd62b10097d59bf8fd689ef5c7161031e5871d8396c5": {
+		functionName: "getChannels_createServerFn_handler",
+		importer: () => import("./api-rpc-D3ZehMIN.mjs")
+	},
+	"f8bdca3d0579adb812d6404f55d9261a89cdb025e920b1fcad82883646a5fe9e": {
+		functionName: "getConfigLoaded_createServerFn_handler",
+		importer: () => import("./api-rpc-D3ZehMIN.mjs")
+	},
+	"00ccacb4a0212c83ec29f4d11719046ad91ea8291cfc557d514dbf00d3bd7f5f": {
+		functionName: "getBundles_createServerFn_handler",
+		importer: () => import("./api-rpc-D3ZehMIN.mjs")
+	},
+	"1bd85c2a50e24785cb6abb023a247a9f048f37ddfa85cbb1c57e579563bad013": {
+		functionName: "getBundle_createServerFn_handler",
+		importer: () => import("./api-rpc-D3ZehMIN.mjs")
+	},
+	"e000081a14772a0496dfdf615232fbbb1a23b89191d0e32f89a05dd67a1916f7": {
+		functionName: "getBundleDownloadUrl_createServerFn_handler",
+		importer: () => import("./api-rpc-D3ZehMIN.mjs")
+	},
+	"67f90ce4cd10fd0226cd9d77cdcd8d0f25a59a6ac406360b655e44296bc4208b": {
+		functionName: "updateBundle_createServerFn_handler",
+		importer: () => import("./api-rpc-D3ZehMIN.mjs")
+	},
+	"c4ef3bbb77ea8a4410623fd18a4741e2ff0668b1a97510bcdd032a8428eaa5da": {
+		functionName: "promoteBundle_createServerFn_handler",
+		importer: () => import("./api-rpc-D3ZehMIN.mjs")
+	},
+	"16cc7c2f080ea5b73e0c6bba815b110dbd7727796036d248ba0d8ae819ddef08": {
+		functionName: "createBundle_createServerFn_handler",
+		importer: () => import("./api-rpc-D3ZehMIN.mjs")
+	},
+	"3a27ff5679228b86a346b3fe42142e7a5bf0264f73173c0dbe5f07fb37c43cf7": {
+		functionName: "deleteBundle_createServerFn_handler",
+		importer: () => import("./api-rpc-D3ZehMIN.mjs")
+	}
+};
+async function getServerFnById(id) {
+	const serverFnInfo = manifest[id];
+	if (!serverFnInfo) throw new Error("Server function info not found for " + id);
+	const fnModule = await serverFnInfo.importer();
+	if (!fnModule) {
+		console.info("serverFnInfo", serverFnInfo);
+		throw new Error("Server function module not resolved for " + id);
+	}
+	const action = fnModule[serverFnInfo.functionName];
+	if (!action) {
+		console.info("serverFnInfo", serverFnInfo);
+		console.info("fnModule", fnModule);
+		throw new Error(`Server function module export not resolved for serverFn ID: ${id}`);
+	}
+	return action;
+}
+var serovalPlugins = void 0;
+var textEncoder = new TextEncoder();
+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, { fromClient: true });
+	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 Iu(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();
+					const plugins = [createRawStreamRPCPlugin((id, stream2) => {
+						rawStreams.set(id, stream2);
+					}), ...serovalPlugins || []];
+					let done = false;
+					const callbacks = {
+						onParse: (value) => {
+							nonStreamingBody = value;
+						},
+						onDone: () => {
+							done = true;
+						},
+						onError: (error) => {
+							throw error;
+						}
+					};
+					au(res2, {
+						refs: /* @__PURE__ */ new Map(),
+						plugins,
+						onParse(value) {
+							callbacks.onParse(value);
+						},
+						onDone() {
+							callbacks.onDone();
+						},
+						onError: (error) => {
+							callbacks.onError(error);
+						}
+					});
+					if (done && rawStreams.size === 0) return new Response(nonStreamingBody ? JSON.stringify(nonStreamingBody) : void 0, {
+						status: alsResponse.status,
+						statusText: alsResponse.statusText,
+						headers: {
+							"Content-Type": "application/json",
+							[X_TSS_SERIALIZED]: "true"
+						}
+					});
+					if (rawStreams.size > 0) {
+						const multiplexedStream = createMultiplexedStream(new ReadableStream({ start(controller) {
+							callbacks.onParse = (value) => {
+								controller.enqueue(JSON.stringify(value) + "\n");
+							};
+							callbacks.onDone = () => {
+								try {
+									controller.close();
+								} catch {}
+							};
+							callbacks.onError = (error) => controller.error(error);
+							if (nonStreamingBody !== void 0) callbacks.onParse(nonStreamingBody);
+						} }), rawStreams);
+						return new Response(multiplexedStream, {
+							status: alsResponse.status,
+							statusText: alsResponse.statusText,
+							headers: {
+								"Content-Type": TSS_CONTENT_TYPE_FRAMED_VERSIONED,
+								[X_TSS_SERIALIZED]: "true"
+							}
+						});
+					}
+					const stream = new ReadableStream({ start(controller) {
+						callbacks.onParse = (value) => controller.enqueue(textEncoder.encode(JSON.stringify(value) + "\n"));
+						callbacks.onDone = () => {
+							try {
+								controller.close();
+							} catch (error) {
+								controller.error(error);
+							}
+						};
+						callbacks.onError = (error) => controller.error(error);
+						if (nonStreamingBody !== void 0) callbacks.onParse(nonStreamingBody);
+					} });
+					return new Response(stream, {
+						status: alsResponse.status,
+						statusText: alsResponse.statusText,
+						headers: {
+							"Content-Type": "application/x-ndjson",
+							[X_TSS_SERIALIZED]: "true"
+						}
+					});
+				}
+				return new Response(void 0, {
+					status: alsResponse.status,
+					statusText: alsResponse.statusText
+				});
+			};
+			let res = await (async () => {
+				if (FORM_DATA_CONTENT_TYPES.some((type) => contentType && contentType.includes(type))) {
+					invariant(methodUpper !== "GET", "GET requests with FormData payloads are not supported");
+					const formData = await request.formData();
+					const serializedContext = formData.get(TSS_FORMDATA_CONTEXT);
+					formData.delete(TSS_FORMDATA_CONTEXT);
+					const params = {
+						context,
+						data: formData,
+						method: methodUpper
+					};
+					if (typeof serializedContext === "string") try {
+						const deserializedContext = Iu(JSON.parse(serializedContext), { plugins: serovalPlugins });
+						if (typeof deserializedContext === "object" && deserializedContext) params.context = safeObjectMerge(context, deserializedContext);
+					} catch (e) {}
+					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(context, payload2.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(ou(error, {
+				refs: /* @__PURE__ */ new Map(),
+				plugins: serovalPlugins
+			})));
+			const response2 = getResponse();
+			return new Response(serializedError, {
+				status: response2.status ?? 500,
+				statusText: response2.statusText,
+				headers: {
+					"Content-Type": "application/json",
+					[X_TSS_SERIALIZED]: "true"
+				}
+			});
+		}
+	})();
+};
+function isNotFoundResponse(error) {
+	const { headers, ...rest } = error;
+	return new Response(JSON.stringify(rest), {
+		status: 404,
+		headers: {
+			"Content-Type": "application/json",
+			...headers || {}
+		}
+	});
+}
+function resolveTransformConfig(transform) {
+	if (typeof transform === "string") {
+		const prefix = transform;
+		return {
+			type: "transform",
+			transformFn: ({ url }) => `${prefix}${url}`,
+			cache: true
+		};
+	}
+	if (typeof transform === "function") return {
+		type: "transform",
+		transformFn: transform,
+		cache: true
+	};
+	if ("createTransform" in transform && transform.createTransform) return {
+		type: "createTransform",
+		createTransform: transform.createTransform,
+		cache: transform.cache !== false
+	};
+	return {
+		type: "transform",
+		transformFn: typeof transform.transform === "string" ? (({ url }) => `${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 transformManifestUrls(source, transformFn, opts) {
+	return (async () => {
+		const manifest = opts?.clone ? structuredClone(source.manifest) : source.manifest;
+		for (const route of Object.values(manifest.routes)) {
+			if (route.preloads) route.preloads = await Promise.all(route.preloads.map((url) => Promise.resolve(transformFn({
+				url,
+				type: "modulepreload"
+			}))));
+			if (route.assets) {
+				for (const asset of route.assets) if (asset.tag === "link" && asset.attrs?.href) asset.attrs.href = await Promise.resolve(transformFn({
+					url: asset.attrs.href,
+					type: "stylesheet"
+				}));
+			}
+		}
+		const transformedClientEntry = await Promise.resolve(transformFn({
+			url: source.clientEntry,
+			type: "clientEntry"
+		}));
+		const rootRoute = manifest.routes[rootRouteId];
+		if (rootRoute) {
+			rootRoute.assets = rootRoute.assets || [];
+			rootRoute.assets.push(buildClientEntryScriptTag(transformedClientEntry, source.injectedHeadScripts));
+		}
+		return manifest;
+	})();
+}
+function buildManifestWithClientEntry(source) {
+	const scriptTag = buildClientEntryScriptTag(source.clientEntry, source.injectedHeadScripts);
+	const baseRootRoute = source.manifest.routes[rootRouteId];
+	return { routes: {
+		...source.manifest.routes,
+		...baseRootRoute ? { [rootRouteId]: {
+			...baseRootRoute,
+			assets: [...baseRootRoute.assets || [], scriptTag]
+		} } : {}
+	} };
+}
+var HEADERS = { TSS_SHELL: "X-TSS_SHELL" };
+var ServerFunctionSerializationAdapter = createSerializationAdapter({
+	key: "$TSS/serverfn",
+	test: (v) => {
+		if (typeof v !== "function") return false;
+		if (!(TSS_SERVER_FUNCTION in v)) return false;
+		return !!v[TSS_SERVER_FUNCTION];
+	},
+	toSerializable: ({ serverFnMeta }) => ({ functionId: serverFnMeta.id }),
+	fromSerializable: ({ functionId }) => {
+		const fn = async (opts, signal) => {
+			return (await (await getServerFnById(functionId, { fromClient: true }))(opts ?? {}, signal)).result;
+		};
+		return fn;
+	}
+});
+function getStartResponseHeaders(opts) {
+	return mergeHeaders({ "Content-Type": "text/html; charset=utf-8" }, ...opts.router.state.matches.map((match) => {
+		return match.headers;
+	}));
+}
+var entriesPromise;
+var baseManifestPromise;
+var cachedFinalManifestPromise;
+async function loadEntries() {
+	const routerEntry = await import("./router-pgc7NX76.mjs");
+	return {
+		startEntry: await import("./start-DQK0r85G.mjs"),
+		routerEntry
+	};
+}
+function getEntries() {
+	if (!entriesPromise) entriesPromise = loadEntries();
+	return entriesPromise;
+}
+function getBaseManifest(matchedRoutes) {
+	if (!baseManifestPromise) baseManifestPromise = getStartManifest();
+	return baseManifestPromise;
+}
+async function resolveManifest(matchedRoutes, transformFn, cache) {
+	const base = await getBaseManifest(matchedRoutes);
+	const computeFinalManifest = async () => {
+		return transformFn ? await transformManifestUrls(base, transformFn, { clone: !cache }) : buildManifestWithClientEntry(base);
+	};
+	if (!transformFn || cache) {
+		if (!cachedFinalManifestPromise) cachedFinalManifestPromise = computeFinalManifest();
+		return cachedFinalManifestPromise;
+	}
+	return computeFinalManifest();
+}
+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 cb = typeof cbOrOptions === "function" ? cbOrOptions : cbOrOptions.handler;
+	const transformAssetUrlsOption = typeof cbOrOptions === "function" ? void 0 : cbOrOptions.transformAssetUrls;
+	const warmupTransformManifest = !!transformAssetUrlsOption && typeof transformAssetUrlsOption === "object" && transformAssetUrlsOption.warmup === true;
+	const resolvedTransformConfig = transformAssetUrlsOption ? resolveTransformConfig(transformAssetUrlsOption) : void 0;
+	const cache = resolvedTransformConfig ? resolvedTransformConfig.cache : true;
+	let cachedCreateTransformPromise;
+	const getTransformFn = async (opts) => {
+		if (!resolvedTransformConfig) return void 0;
+		if (resolvedTransformConfig.type === "createTransform") {
+			if (cache) {
+				if (!cachedCreateTransformPromise) cachedCreateTransformPromise = Promise.resolve(resolvedTransformConfig.createTransform(opts));
+				return cachedCreateTransformPromise;
+			}
+			return resolvedTransformConfig.createTransform(opts);
+		}
+		return resolvedTransformConfig.transformFn;
+	};
+	if (warmupTransformManifest && cache && !cachedFinalManifestPromise) {
+		const warmupPromise = (async () => {
+			const base = await getBaseManifest(void 0);
+			const transformFn = await getTransformFn({ warmup: true });
+			return transformFn ? await transformManifestUrls(base, transformFn, { clone: false }) : buildManifestWithClientEntry(base);
+		})();
+		cachedFinalManifestPromise = warmupPromise;
+		warmupPromise.catch(() => {
+			if (cachedFinalManifestPromise === warmupPromise) cachedFinalManifestPromise = void 0;
+			cachedCreateTransformPromise = void 0;
+		});
+	}
+	const startRequestResolver = async (request, requestOpts) => {
+		let router = null;
+		let cbWillCleanup = false;
+		try {
+			const { url, handledProtocolRelativeURL } = getNormalizedURL(request.url);
+			const href = url.pathname + url.search + url.hash;
+			const origin = getOrigin(request);
+			if (handledProtocolRelativeURL) return Response.redirect(url, 308);
+			const entries = await getEntries();
+			const startOptions = await entries.startEntry.startInstance?.getOptions() || {};
+			const serializationAdapters = [...startOptions.serializationAdapters || [], ServerFunctionSerializationAdapter];
+			const requestStartOptions = {
+				...startOptions,
+				serializationAdapters
+			};
+			const flattenedRequestMiddlewares = startOptions.requestMiddleware ? flattenMiddlewares(startOptions.requestMiddleware) : [];
+			const executedRequestMiddlewares = new Set(flattenedRequestMiddlewares);
+			const getRouter = async () => {
+				if (router) return router;
+				router = await entries.routerEntry.getRouter();
+				let isShell = IS_SHELL_ENV;
+				if (IS_PRERENDERING && !isShell) isShell = request.headers.get(HEADERS.TSS_SHELL) === "true";
+				const history = createMemoryHistory({ initialEntries: [href] });
+				router.update({
+					history,
+					isShell,
+					isPrerendering: IS_PRERENDERING,
+					origin: router.options.origin ?? origin,
+					defaultSsr: requestStartOptions.defaultSsr,
+					serializationAdapters: [...requestStartOptions.serializationAdapters, ...router.options.serializationAdapters || []],
+					basepath: ROUTER_BASEPATH
+				});
+				return router;
+			};
+			if (url.pathname.startsWith(SERVER_FN_BASE)) {
+				const serverFnId = url.pathname.slice(11).split("/")[0];
+				if (!serverFnId) throw new Error("Invalid server action param for serverFnId");
+				const serverFnHandler = async ({ context }) => {
+					return runWithStartContext({
+						getRouter,
+						startOptions: requestStartOptions,
+						contextAfterGlobalMiddlewares: context,
+						request,
+						executedRequestMiddlewares
+					}, () => handleServerAction({
+						request,
+						context: requestOpts?.context,
+						serverFnId
+					}));
+				};
+				return handleRedirectResponse((await executeMiddleware([...flattenedRequestMiddlewares.map((d) => d.options.server), serverFnHandler], {
+					request,
+					pathname: url.pathname,
+					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 manifest = await resolveManifest(matchedRoutes, await getTransformFn({
+					warmup: false,
+					request
+				}), cache);
+				const routerInstance = await getRouter();
+				attachRouterServerSsrUtils({
+					router: routerInstance,
+					manifest
+				});
+				routerInstance.update({ additionalContext: { serverContext } });
+				await routerInstance.load();
+				if (routerInstance.state.redirect) return routerInstance.state.redirect;
+				await routerInstance.serverSsr.dehydrate();
+				const responseHeaders = getStartResponseHeaders({ router: routerInstance });
+				cbWillCleanup = true;
+				return cb({
+					request,
+					router: routerInstance,
+					responseHeaders
+				});
+			};
+			const requestHandlerMiddleware = async ({ context }) => {
+				return runWithStartContext({
+					getRouter,
+					startOptions: requestStartOptions,
+					contextAfterGlobalMiddlewares: context,
+					request,
+					executedRequestMiddlewares
+				}, async () => {
+					try {
+						return await handleServerRoutes({
+							getRouter,
+							request,
+							url,
+							executeRouter,
+							context,
+							executedRequestMiddlewares
+						});
+					} catch (err) {
+						if (err instanceof Response) return err;
+						throw err;
+					}
+				});
+			};
+			return handleRedirectResponse((await executeMiddleware([...flattenedRequestMiddlewares.map((d) => d.options.server), requestHandlerMiddleware], {
+				request,
+				pathname: url.pathname,
+				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 m of flattened) if (!executedRequestMiddlewares.has(m)) routeMiddlewares.push(m.options.server);
+		}
+	}
+	const server = foundRoute?.options.server;
+	if (server?.handlers && isExactMatch) {
+		const handlers = typeof server.handlers === "function" ? server.handlers({ createHandlers: (d) => d }) : server.handlers;
+		const handler = handlers[request.method.toUpperCase()] ?? handlers["ANY"];
+		if (handler) {
+			const mayDefer = !!foundRoute.options.component;
+			if (typeof handler === "function") routeMiddlewares.push(handlerToMiddleware(handler, mayDefer));
+			else {
+				if (handler.middleware?.length) {
+					const handlerMiddlewares = flattenMiddlewares(handler.middleware);
+					for (const m of handlerMiddlewares) routeMiddlewares.push(m.options.server);
+				}
+				if (handler.handler) routeMiddlewares.push(handlerToMiddleware(handler.handler, mayDefer));
+			}
+		}
+	}
+	routeMiddlewares.push((ctx2) => executeRouter(ctx2.context, matchedRoutes));
+	return (await executeMiddleware(routeMiddlewares, {
+		request,
+		context,
+		params: routeParams,
+		pathname
+	})).response;
+}
+var fetch$1 = createStartHandler(defaultStreamHandler);
+function createServerEntry(entry) {
+	return { async fetch(...args) {
+		return await entry.fetch(...args);
+	} };
+}
+var server_default = createServerEntry({ fetch: fetch$1 });
+//#endregion
+export { createServerEntry, server_default as default, createServerFn as n, TSS_SERVER_FUNCTION as r, getServerFnById as t };