@qwik.dev/router 2.0.0-beta.4 → 2.0.0-beta.40

package/lib/chunks/user-response.mjs

@@ -0,0 +1,1707 @@
+import { t as ensureSlash } from "./pathname.mjs";
+import { C as getRouteLoaderValues, D as loadRouteLoader, G as QACTION_KEY, J as Q_ROUTE, K as QDATA_KEY, N as setRouteLoaders, O as matchesRouteLoaderId, S as getRouteLoaderResponse, Y as _asyncRequestStore, a as isPromise, f as FULLPATH_HEADER, h as clearRouteLoaderData, k as resolveRouteLoaderByHash, q as QFN_KEY, r as resolveRouteConfig, v as getLoaderRequestEvent, x as getRouteLoaderCtx } from "./head.qwik.mjs";
+import { a as QLoaderId, c as resolveValidInternalFullPathname, i as QActionId, s as recognizeRequest, t as IsQAction, u as trimRecognizedInternalPathname } from "./request-path.mjs";
+import { i as RedirectMessage, n as throwIfControlFlowSignal, r as AbortMessage, t as ServerError } from "./server-error.mjs";
+import { inlinedQrl, isDev } from "@qwik.dev/core";
+import { _deserialize, _serialize, _verifySerializable, isDev as isDev$1 } from "@qwik.dev/core/internal";
+/**
+* FNV-1a 32-bit hash for generating eTags from response data. Cheap to compute, sufficient
+* collision resistance for cache validation (not cryptographic).
+*/ function hash(str) {
+	let hash = 2166136261;
+	for (let i = 0; i < str.length; i++) {
+		hash ^= str.charCodeAt(i);
+		hash = hash * 16777619 | 0;
+	}
+	return (hash >>> 0).toString(36);
+}
+/**
+* Normalize an ETag header value (or a single `If-None-Match` entry) into a canonical form so byte
+* equality compares the same logical tag. Strips weak ETag syntax (`W/"..."`), quotes, and any
+* character outside RFC 7232's `etagc` grammar (printable ASCII except DQUOTE — no escape mechanism
+* exists, and non-ASCII bytes are mangled by many HTTP stacks even though `obs-text` technically
+* permits them). Idempotent.
+*/ function normalizeETag(raw) {
+	let tag = raw.trim();
+	if (tag.endsWith("\"") && tag.startsWith("W/\"")) tag = tag.slice(3);
+	tag = tag.replace(/[^!#-~]/g, "");
+	return tag;
+}
+function setETagHeader(requestEv, normalizedETag) {
+	const headerETag = `"${normalizedETag}"`;
+	requestEv.headers.set("ETag", headerETag);
+}
+/**
+* Set the strong ETag header on the response and check the request's `If-None-Match` against it.
+* The eTag argument must already be normalized. Returns true if a 304 was sent (caller should stop
+* processing).
+*/ function performETagMatch(requestEv, normalizedETag) {
+	setETagHeader(requestEv, normalizedETag);
+	const ifNoneMatch = requestEv.request.headers.get("If-None-Match");
+	if (ifNoneMatch) {
+		let found = ifNoneMatch.trim() === "*";
+		if (!found) {
+			for (const entry of ifNoneMatch.split(",")) if (normalizeETag(entry) === normalizedETag) {
+				found = true;
+				break;
+			}
+		}
+		if (found) {
+			requestEv.status(304);
+			requestEv.send(304, "");
+			return true;
+		}
+	}
+	return false;
+}
+function createCacheControl(cacheControl) {
+	const controls = [];
+	if (cacheControl === "day") cacheControl = 86400;
+	else if (cacheControl === "week") cacheControl = 604800;
+	else if (cacheControl === "month") cacheControl = 2592e3;
+	else if (cacheControl === "year") cacheControl = 31536e3;
+	else if (cacheControl === "private") cacheControl = {
+		private: true,
+		noCache: true
+	};
+	else if (cacheControl === "immutable") cacheControl = {
+		public: true,
+		immutable: true,
+		maxAge: 31536e3
+	};
+	else if (cacheControl === "no-cache") cacheControl = { noCache: true };
+	if (typeof cacheControl === "number") cacheControl = {
+		maxAge: cacheControl,
+		sMaxAge: cacheControl
+	};
+	if (cacheControl.immutable) controls.push("immutable");
+	if (cacheControl.maxAge) controls.push(`max-age=${cacheControl.maxAge}`);
+	if (cacheControl.sMaxAge) controls.push(`s-maxage=${cacheControl.sMaxAge}`);
+	if (cacheControl.noStore) controls.push("no-store");
+	if (cacheControl.noCache) controls.push("no-cache");
+	if (cacheControl.private) controls.push("private");
+	if (cacheControl.public) controls.push("public");
+	if (cacheControl.staleWhileRevalidate) controls.push(`stale-while-revalidate=${cacheControl.staleWhileRevalidate}`);
+	if (cacheControl.staleIfError) controls.push(`stale-if-error=${cacheControl.staleIfError}`);
+	return controls.join(", ");
+}
+var SAMESITE = {
+	lax: "Lax",
+	Lax: "Lax",
+	None: "None",
+	none: "None",
+	strict: "Strict",
+	Strict: "Strict"
+};
+var UNIT = {
+	seconds: 1,
+	minutes: 60,
+	hours: 3600,
+	days: 86400,
+	weeks: 604800
+};
+function tryDecodeUriComponent(str) {
+	try {
+		return decodeURIComponent(str);
+	} catch {
+		return str;
+	}
+}
+var parseCookieString = (cookieString) => {
+	const cookie = {};
+	if (typeof cookieString === "string" && cookieString !== "") {
+		const cookieSegments = cookieString.split(";");
+		for (const cookieSegment of cookieSegments) {
+			const separatorIndex = cookieSegment.indexOf("=");
+			if (separatorIndex !== -1) cookie[tryDecodeUriComponent(cookieSegment.slice(0, separatorIndex).trim())] = tryDecodeUriComponent(cookieSegment.slice(separatorIndex + 1).trim());
+		}
+	}
+	return cookie;
+};
+function resolveSameSite(sameSite) {
+	if (sameSite === true) return "Strict";
+	if (sameSite === false) return "None";
+	if (sameSite) return SAMESITE[sameSite];
+}
+var createSetCookieValue = (cookieName, cookieValue, options) => {
+	const c = [`${cookieName}=${cookieValue}`];
+	if (typeof options.domain === "string") c.push(`Domain=${options.domain}`);
+	if (typeof options.maxAge === "number") c.push(`Max-Age=${options.maxAge}`);
+	else if (Array.isArray(options.maxAge)) c.push(`Max-Age=${options.maxAge[0] * UNIT[options.maxAge[1]]}`);
+	else if (typeof options.expires === "number" || typeof options.expires == "string") c.push(`Expires=${options.expires}`);
+	else if (options.expires instanceof Date) c.push(`Expires=${options.expires.toUTCString()}`);
+	if (options.httpOnly) c.push("HttpOnly");
+	if (typeof options.path === "string") c.push(`Path=${options.path}`);
+	const sameSite = resolveSameSite(options.sameSite);
+	if (sameSite) c.push(`SameSite=${sameSite}`);
+	if (options.secure) c.push("Secure");
+	return c.join("; ");
+};
+var REQ_COOKIE = Symbol("request-cookies");
+var RES_COOKIE = Symbol("response-cookies");
+var LIVE_COOKIE = Symbol("live-cookies");
+var Cookie = class {
+	[REQ_COOKIE];
+	[RES_COOKIE] = {};
+	[LIVE_COOKIE] = {};
+	appendCounter = 0;
+	constructor(cookieString) {
+		this[REQ_COOKIE] = parseCookieString(cookieString);
+		this[LIVE_COOKIE] = { ...this[REQ_COOKIE] };
+	}
+	get(cookieName, live = true) {
+		const value = this[live ? LIVE_COOKIE : REQ_COOKIE][cookieName];
+		if (!value) return null;
+		return {
+			value,
+			json() {
+				return JSON.parse(value);
+			},
+			number() {
+				return Number(value);
+			}
+		};
+	}
+	getAll(live = true) {
+		return Object.keys(this[live ? LIVE_COOKIE : REQ_COOKIE]).reduce((cookies, cookieName) => {
+			cookies[cookieName] = this.get(cookieName);
+			return cookies;
+		}, {});
+	}
+	has(cookieName, live = true) {
+		return !!this[live ? LIVE_COOKIE : REQ_COOKIE][cookieName];
+	}
+	set(cookieName, cookieValue, options = {}) {
+		this[LIVE_COOKIE][cookieName] = typeof cookieValue === "string" ? cookieValue : JSON.stringify(cookieValue);
+		const resolvedValue = typeof cookieValue === "string" ? cookieValue : encodeURIComponent(JSON.stringify(cookieValue));
+		this[RES_COOKIE][cookieName] = createSetCookieValue(cookieName, resolvedValue, options);
+	}
+	append(cookieName, cookieValue, options = {}) {
+		this[LIVE_COOKIE][cookieName] = typeof cookieValue === "string" ? cookieValue : JSON.stringify(cookieValue);
+		const resolvedValue = typeof cookieValue === "string" ? cookieValue : encodeURIComponent(JSON.stringify(cookieValue));
+		this[RES_COOKIE][++this.appendCounter] = createSetCookieValue(cookieName, resolvedValue, options);
+	}
+	delete(name, options) {
+		this.set(name, "deleted", {
+			...options,
+			maxAge: 0
+		});
+		this[LIVE_COOKIE][name] = null;
+	}
+	headers() {
+		return Object.values(this[RES_COOKIE]);
+	}
+};
+/** @public */ var mergeHeadersCookies = (headers, cookies) => {
+	const cookieHeaders = cookies.headers();
+	if (cookieHeaders.length > 0) {
+		const newHeaders = new Headers(headers);
+		for (const cookie of cookieHeaders) newHeaders.append("Set-Cookie", cookie);
+		return newHeaders;
+	}
+	return headers;
+};
+/** @public */ var RewriteMessage = class extends AbortMessage {
+	pathname;
+	constructor(pathname) {
+		super(), this.pathname = pathname;
+	}
+};
+var encoder = /*#__PURE__*/ new TextEncoder();
+function getContentType(headers) {
+	return (headers.get("content-type")?.split(/[;,]/, 1)[0].trim() ?? "").toLowerCase();
+}
+function isContentType(headers, ...types) {
+	const type = getContentType(headers);
+	for (let i = 0; i < types.length; i++) if (types[i].toLowerCase() === type) return true;
+	return false;
+}
+var RequestEvMode = Symbol("RequestEvMode");
+var RequestEvRoute = Symbol("RequestEvRoute");
+var RequestRouteName = "@routeName";
+var RequestEvSharedActionId = "@actionId";
+var RequestEvSharedActionFormData = "@actionFormData";
+var RequestEvSharedNonce = "@nonce";
+var RequestEvIsRewrite = "@rewrite";
+var RequestEvShareServerTiming = "@serverTiming";
+var RequestEvETagCacheKey = "@eTagCacheKey";
+var RequestEvHttpStatusMessage = "@httpStatusMessage";
+function getRequestRoute(requestEv) {
+	return requestEv[RequestEvRoute];
+}
+function getRequestMode(requestEv) {
+	return requestEv[RequestEvMode];
+}
+var ABORT_INDEX = Number.MAX_SAFE_INTEGER;
+var isDangerousKey = (k) => k === "__proto__" || k === "constructor" || k === "prototype";
+var isArrayIndexKey = (k) => /^(0|[1-9]\d*)$/.test(k);
+var createFormPathNode = () => ({
+	children: /* @__PURE__ */ new Map(),
+	isArray: true
+});
+var getFormPathTree = (formData) => {
+	const root = createFormPathNode();
+	for (const [name] of formData) {
+		const keys = name.split(".");
+		let hasDangerousKey = false;
+		for (const key of keys) if (isDangerousKey(key)) {
+			hasDangerousKey = true;
+			break;
+		}
+		if (hasDangerousKey) continue;
+		let pathNode = root;
+		for (let i = 0; i < keys.length - 1; i++) {
+			const key = keys[i];
+			if (key.endsWith("[]")) break;
+			let childNode = pathNode.children.get(key);
+			if (!childNode) {
+				childNode = createFormPathNode();
+				pathNode.children.set(key, childNode);
+			}
+			if (!isArrayIndexKey(keys[i + 1])) childNode.isArray = false;
+			pathNode = childNode;
+		}
+	}
+	return root;
+};
+var formToObj = (formData) => {
+	/**
+	* Convert FormData to object Handle nested form input using dot notation Handle array input using
+	* indexed dot notation (name.0, name.0) or bracket notation (name[]), the later is needed for
+	* multiselects Create values object by form data entries
+	*/ const values = Object.create(null);
+	const pathTree = getFormPathTree(formData);
+	for (const [name, value] of formData) {
+		const keys = name.split(".");
+		let hasDangerousKey = false;
+		for (let i = 0; i < keys.length; i++) if (isDangerousKey(keys[i])) {
+			hasDangerousKey = true;
+			break;
+		}
+		if (hasDangerousKey) continue;
+		let object = values;
+		let pathNode = pathTree;
+		for (let i = 0; i < keys.length; i++) {
+			const key = keys[i];
+			if (key.endsWith("[]")) {
+				const arrayKey = key.slice(0, -2);
+				if (isDangerousKey(arrayKey)) break;
+				const existingValue = object[arrayKey];
+				if (existingValue !== void 0 && !Array.isArray(existingValue)) break;
+				object[arrayKey] = existingValue || [];
+				object[arrayKey].push(value);
+				break;
+			}
+			if (Array.isArray(object) && !isArrayIndexKey(key)) break;
+			if (i < keys.length - 1) {
+				const childNode = pathNode.children.get(key);
+				const nextValue = object[key];
+				if (nextValue !== void 0) {
+					object = nextValue;
+					pathNode = childNode;
+					continue;
+				}
+				object = object[key] = childNode.isArray ? [] : Object.create(null);
+				pathNode = childNode;
+			} else object[key] = value;
+		}
+	}
+	return values;
+};
+var parseRequest = async ({ request, method, query }, sharedMap) => {
+	const type = getContentType(request.headers);
+	if (type === "application/x-www-form-urlencoded" || type === "multipart/form-data") {
+		const formData = await request.formData();
+		sharedMap.set(RequestEvSharedActionFormData, formData);
+		return formToObj(formData);
+	} else if (type === "application/json") return await request.json();
+	else if (type === "application/qwik-json") {
+		if (method === "GET" && query.has("qdata")) {
+			const data = query.get(QDATA_KEY);
+			if (data) try {
+				return await _deserialize(decodeURIComponent(data));
+			} catch {}
+		}
+		return await _deserialize(await request.text());
+	}
+};
+function createRequestEvent(serverRequestEv, loadedRoute, requestHandlers, basePathname, resolved) {
+	const { request, platform, env } = serverRequestEv;
+	const sharedMap = /* @__PURE__ */ new Map();
+	const cookie = new Cookie(request.headers.get("cookie"));
+	const headers = new Headers();
+	const url = new URL(request.url);
+	let internalRequest = false;
+	const recognized = recognizeRequest(url.pathname);
+	if (recognized) {
+		url.pathname = trimRecognizedInternalPathname(url.pathname, recognized);
+		sharedMap.set(recognized.type, true);
+		internalRequest = "loader";
+		if (recognized.data?.loaderId) sharedMap.set(QLoaderId, recognized.data.loaderId);
+	}
+	const actionId = url.searchParams.get(QACTION_KEY);
+	if (actionId) {
+		sharedMap.set(IsQAction, true);
+		sharedMap.set(QActionId, actionId);
+		if (request.method === "POST" && request.headers.get("accept")?.includes("application/json")) internalRequest = "action";
+	}
+	let routeModuleIndex = -1;
+	let writableStream = null;
+	let requestData = void 0;
+	let locale = serverRequestEv.locale;
+	let status = loadedRoute?.$notFound$ ? 404 : 200;
+	const next = async () => {
+		routeModuleIndex++;
+		while (routeModuleIndex < requestHandlers.length) {
+			const moduleRequestHandler = requestHandlers[routeModuleIndex];
+			const result = moduleRequestHandler(requestEv);
+			throwIfControlFlowSignal(isPromise(result) ? await result : result);
+			routeModuleIndex++;
+		}
+	};
+	const resetRoute = (_loadedRoute, _requestHandlers, _url = url) => {
+		loadedRoute = _loadedRoute;
+		status = loadedRoute?.$notFound$ ? 404 : 200;
+		requestHandlers = _requestHandlers;
+		url.pathname = _url.pathname;
+		url.search = _url.search;
+		routeModuleIndex = -1;
+	};
+	const check = () => {
+		if (writableStream !== null) throw new Error("Response already sent");
+	};
+	const send = (statusOrResponse, body) => {
+		check();
+		if (typeof statusOrResponse === "number") {
+			status = statusOrResponse;
+			const writer = requestEv.getWritableStream().getWriter();
+			writer.write(typeof body === "string" ? encoder.encode(body) : body);
+			writer.close();
+		} else {
+			status = statusOrResponse.status;
+			statusOrResponse.headers.forEach((value, key) => {
+				if (key.toLowerCase() === "set-cookie") return;
+				headers.append(key, value);
+			});
+			statusOrResponse.headers.getSetCookie().forEach((ck) => {
+				const index = ck.indexOf("=");
+				if (index === -1) return;
+				const key = ck.slice(0, index).trim();
+				const value = ck.slice(index + 1).trim();
+				cookie.set(key, value);
+			});
+			if (statusOrResponse.body) {
+				const writableStream = requestEv.getWritableStream();
+				statusOrResponse.body.pipeTo(writableStream);
+			} else requestEv.getWritableStream().getWriter().close();
+		}
+		return exit();
+	};
+	const exit = (message = new AbortMessage()) => {
+		routeModuleIndex = ABORT_INDEX;
+		return message;
+	};
+	const requestEv = {
+		[RequestEvMode]: serverRequestEv.mode,
+		get [RequestEvRoute]() {
+			return loadedRoute;
+		},
+		cookie,
+		headers,
+		env,
+		method: request.method,
+		signal: request.signal,
+		originalUrl: new URL(url),
+		get params() {
+			return loadedRoute?.$params$ ?? {};
+		},
+		get pathname() {
+			return url.pathname;
+		},
+		platform,
+		get query() {
+			return url.searchParams;
+		},
+		request,
+		url,
+		internalRequest,
+		basePathname,
+		sharedMap,
+		get headersSent() {
+			return writableStream !== null;
+		},
+		get exited() {
+			return routeModuleIndex >= ABORT_INDEX;
+		},
+		get clientConn() {
+			return serverRequestEv.getClientConn();
+		},
+		next,
+		resetRoute,
+		exit,
+		cacheControl: (cacheControl, target = "Cache-Control") => {
+			check();
+			headers.set(target, createCacheControl(cacheControl));
+		},
+		resolveValue: async (loaderOrAction) => {
+			if (loaderOrAction.__brand === "server_loader") {
+				const loaderValues = getRouteLoaderValues(requestEv);
+				if (loaderOrAction.__id in loaderValues) return loaderValues[loaderOrAction.__id];
+				return loadRouteLoader(loaderOrAction, requestEv);
+			}
+		},
+		status: (statusCode) => {
+			if (typeof statusCode === "number") {
+				check();
+				status = statusCode;
+				return statusCode;
+			}
+			return status;
+		},
+		locale: (_locale) => {
+			if (typeof _locale === "string") locale = _locale;
+			return locale || "";
+		},
+		error: (statusCode, message) => {
+			status = statusCode;
+			headers.delete("Cache-Control");
+			return new ServerError(statusCode, message);
+		},
+		redirect: (statusCode, url) => {
+			check();
+			status = statusCode;
+			if (url) {
+				if (/^\/\//.test(url) || /([^:])\/\/+/.test(url)) {
+					const fixedURL = url.replace(/^\/\/+/, "/").replace(/([^:])\/\/+/g, "$1/");
+					console.warn(`Redirect URL ${url} is invalid, fixing to ${fixedURL}`);
+					url = fixedURL;
+				}
+				headers.set("Location", url);
+			}
+			headers.delete("Cache-Control");
+			if (statusCode > 301) headers.set("Cache-Control", "no-store");
+			if (internalRequest === "loader") return new RedirectMessage();
+			return exit(new RedirectMessage());
+		},
+		rewrite: (pathname) => {
+			check();
+			if (pathname.startsWith("http")) throw new ServerError(400, isDev$1 ? "Rewrite does not support absolute urls" : "Bad Request");
+			sharedMap.set(RequestEvIsRewrite, true);
+			return exit(new RewriteMessage(pathname.replace(/\/+/g, "/")));
+		},
+		defer: (returnData) => {
+			return typeof returnData === "function" ? returnData : () => returnData;
+		},
+		fail: (statusCode, data) => {
+			check();
+			status = statusCode;
+			headers.delete("Cache-Control");
+			return {
+				failed: true,
+				...data
+			};
+		},
+		text: (statusCode, text) => {
+			headers.set("Content-Type", "text/plain; charset=utf-8");
+			return send(statusCode, text);
+		},
+		html: (statusCode, html) => {
+			headers.set("Content-Type", "text/html; charset=utf-8");
+			return send(statusCode, html);
+		},
+		parseBody: async () => {
+			if (requestData !== void 0) return requestData;
+			return requestData = parseRequest(requestEv, sharedMap);
+		},
+		json: (statusCode, data) => {
+			headers.set("Content-Type", "application/json; charset=utf-8");
+			return send(statusCode, JSON.stringify(data));
+		},
+		send,
+		isDirty: () => {
+			return writableStream !== null;
+		},
+		getWritableStream: () => {
+			if (writableStream === null) {
+				if (isDev$1) {
+					const serverTiming = sharedMap.get(RequestEvShareServerTiming);
+					if (serverTiming) headers.set("Server-Timing", serverTiming.map(([name, duration]) => `${name};dur=${duration}`).join(","));
+				}
+				writableStream = serverRequestEv.getWritableStream(status, headers, cookie, resolved, requestEv);
+			}
+			return writableStream;
+		}
+	};
+	return requestEv;
+}
+var MAX_CACHE_SIZE = typeof globalThis.__SSR_CACHE_SIZE__ === "number" ? globalThis.__SSR_CACHE_SIZE__ : 50;
+function createLruCache() {
+	const cache = /* @__PURE__ */ new Map();
+	return {
+		get(key) {
+			const entry = cache.get(key);
+			if (entry !== void 0) {
+				cache.delete(key);
+				cache.set(key, entry);
+			}
+			return entry;
+		},
+		set(key, entry) {
+			if (MAX_CACHE_SIZE <= 0) return;
+			if (cache.size >= MAX_CACHE_SIZE) {
+				const firstKey = cache.keys().next().value;
+				cache.delete(firstKey);
+			}
+			cache.set(key, entry);
+		},
+		clear(key) {
+			if (key != null) cache.delete(key);
+			else cache.clear();
+		}
+	};
+}
+var ssrCache = createLruCache();
+var loaderCache = createLruCache();
+/**
+* Resolve an eTag value from a ContentModuleETag (string, function, or undefined). Returns the eTag
+* string or null.
+*/ function resolveETag(eTagExport, headProps) {
+	if (eTagExport === void 0) return null;
+	if (typeof eTagExport === "function") return eTagExport(headProps);
+	return eTagExport;
+}
+/**
+* Resolve a cache key from a CacheKeyFn. The default key callback is only called when `cacheKey ===
+* true`.
+*/ function resolveCacheKey(cacheKeyExport, defaultKey, requestEv, eTag) {
+	if (cacheKeyExport === true) return defaultKey(requestEv, eTag);
+	if (typeof cacheKeyExport !== "function") return "";
+	return cacheKeyExport(requestEv, eTag) || "";
+}
+/** Build the default SSR cache key. eTag slot is dropped when no eTag was resolved. */ function defaultSsrCacheKey(requestEv, eTag) {
+	const status = requestEv.status();
+	const pathname = requestEv.url.pathname;
+	return eTag ? `${status}|${eTag}|${pathname}` : `${status}|${pathname}`;
+}
+/** Build the default loader cache key. eTag slot is dropped when no eTag was resolved. */ function defaultLoaderCacheKey(requestEv, eTag) {
+	const loaderId = requestEv.sharedMap.get(QLoaderId);
+	const base = `${requestEv.url.pathname}|${requestEv.url.search}|${loaderId}`;
+	return eTag ? `${base}|${eTag}` : base;
+}
+/** Get a cached SSR entry by key (LRU touch). */ function getCachedSsr(key) {
+	return ssrCache.get(key);
+}
+/** Cache an SSR entry by key, evicting the least recently used entry if at capacity. */ function setCachedSsr(key, entry) {
+	ssrCache.set(key, entry);
+}
+/** Get a cached loader entry by key (LRU touch). */ function getCachedLoader(key) {
+	return loaderCache.get(key);
+}
+/** Cache a loader entry by key, evicting the least recently used entry if at capacity. */ function setCachedLoader(key, entry) {
+	loaderCache.set(key, entry);
+}
+/**
+* Clear the in-memory SSR cache. Call after deployments or data changes.
+*
+* When `cacheKey` is provided, only that single entry is removed; otherwise the entire cache is
+* cleared.
+*
+* @public
+*/ function clearSsrCache(cacheKey) {
+	ssrCache.clear(cacheKey);
+}
+/**
+* Clear the in-memory loader cache. Call after deployments or data changes.
+*
+* When `cacheKey` is provided, only that single entry is removed; otherwise the entire cache is
+* cleared.
+*
+* @public
+*/ function clearLoaderCache(cacheKey) {
+	loaderCache.clear(cacheKey);
+}
+/**
+* Create per-loader request event views. Loader-specific URL/search data is scoped to the view,
+* while request-wide state (headers, cookies, loader value maps, etc.) still delegates to the
+* original request event.
+*/ function createLoaderRequestEventFactory(requestEv) {
+	return (loader) => getLoaderRequestEvent(loader, requestEv);
+}
+/**
+* Resolve the loader's cacheControl option. Loaders default to `no-cache` so the browser always
+* revalidates; pair with `eTag` for cheap 304s. A function form may return `null` to skip the
+* header entirely.
+*/ function resolveLoaderCacheControl(option, requestEv) {
+	const value = typeof option === "function" ? option(requestEv) : option;
+	return value === void 0 ? "no-cache" : value;
+}
+async function runBlockingLoadersBeforeTarget(routeLoaders, targetLoader, requestEv) {
+	for (const loader of routeLoaders) {
+		if (loader === targetLoader) return;
+		if (loader.__blockSSR) await loadRouteLoader(loader, requestEv);
+	}
+}
+function setLoaderData(requestEv, routeLoaders, loaderPaths) {
+	if (loaderPaths) Object.assign(getRouteLoaderCtx(requestEv).loaderPaths, loaderPaths);
+	setRouteLoaders(requestEv, routeLoaders);
+}
+/** Resolve eTag from a static string or function (before running the loader). */ function resolvePreETag(eTagOption, requestEv) {
+	if (typeof eTagOption === "string") return normalizeETag(eTagOption);
+	const result = eTagOption(requestEv);
+	return result ? normalizeETag(result) : "";
+}
+function addVaryHeader(requestEv, value) {
+	const vary = requestEv.headers.get("Vary");
+	if (!vary) {
+		requestEv.headers.set("Vary", value);
+		return;
+	}
+	if (!vary.split(",").map((item) => item.trim().toLowerCase()).includes(value.toLowerCase())) requestEv.headers.set("Vary", `${vary}, ${value}`);
+}
+async function sendLoaderResponse(requestEv, data, cacheControl) {
+	requestEv.headers.set("Content-Type", "application/json; charset=utf-8");
+	addVaryHeader(requestEv, FULLPATH_HEADER);
+	if (cacheControl !== null && !requestEv.headers.has("Cache-Control")) requestEv.cacheControl(cacheControl);
+	requestEv.send(200, data);
+}
+/**
+* Handler that executes the requested loader and returns the result as JSON. Runs AFTER
+* plugin/route middleware, so middleware redirects/errors are handled by `jsonRequestWrapper`. The
+* loader function's own redirects/errors are caught by getRouteLoaderResponse and serialized in the
+* LoaderResponse envelope ({ d, r, e }).
+*/ function loaderHandler(routeLoaders, loaderPaths) {
+	return async (requestEvent) => {
+		const requestEv = requestEvent;
+		if (!requestEv.sharedMap.has("@isQLoader")) return;
+		if (requestEv.headersSent || requestEv.exited) return;
+		const loaderId = requestEv.sharedMap.get(QLoaderId);
+		const loader = resolveRouteLoaderByHash(routeLoaders, loaderId);
+		if (!loader) {
+			requestEv.json(404, { error: "Loader not found" });
+			return;
+		}
+		setLoaderData(requestEv, routeLoaders, loaderPaths);
+		await runBlockingLoadersBeforeTarget(routeLoaders, loader, requestEv);
+		const loaderRequestEv = createLoaderRequestEventFactory(requestEv)(loader);
+		const cacheControl = resolveLoaderCacheControl(loader.__cacheControl, loaderRequestEv);
+		const normalizedETag = loader.__eTag !== void 0 ? resolvePreETag(loader.__eTag, loaderRequestEv) : "";
+		if (normalizedETag && performETagMatch(loaderRequestEv, normalizedETag)) return;
+		let cacheKey = "";
+		if (loader.__cacheKey) cacheKey = resolveCacheKey(loader.__cacheKey, defaultLoaderCacheKey, loaderRequestEv, normalizedETag);
+		if (cacheKey) {
+			const cached = getCachedLoader(cacheKey);
+			if (cached) {
+				if (!normalizedETag) {
+					if (performETagMatch(loaderRequestEv, cached.eTag)) return;
+				} else setETagHeader(loaderRequestEv, cached.eTag);
+				await sendLoaderResponse(requestEv, cached.body, cacheControl);
+				return;
+			}
+		}
+		const responseData = await getRouteLoaderResponse(loader.__qrl, loader.__validators, loaderRequestEv);
+		const data = await _serialize(responseData);
+		const failed = responseData.d && typeof responseData.d === "object" && responseData.d.failed;
+		const cacheable = cacheKey && !responseData.r && !responseData.e && !failed;
+		const finalETag = normalizedETag || (cacheable ? hash(data) : "");
+		if (cacheable && finalETag) setCachedLoader(cacheKey, {
+			eTag: finalETag,
+			body: data
+		});
+		if (!normalizedETag && finalETag && performETagMatch(loaderRequestEv, finalETag)) return;
+		await sendLoaderResponse(requestEv, data, cacheControl);
+	};
+}
+/** Serialize and send a JSON response (used by error/redirect paths in jsonRequestWrapper). */ async function sendJsonResponse(requestEv, responseData, status = 200) {
+	const data = await _serialize(responseData);
+	requestEv.headers.set("Content-Type", "application/json; charset=utf-8");
+	requestEv.send(status, data);
+}
+async function sendActionResponse(requestEv, responseData) {
+	const data = await _serialize(responseData);
+	requestEv.headers.set("Content-Type", "application/json; charset=utf-8");
+	requestEv.send(responseData.s || 200, data);
+}
+/**
+* Early handler that wraps `next()` for JSON API requests (q-loader and q-action).
+*
+* For `IsQLoader` requests, it also rewrites the URL using the `X-Qwik-fullpath` header so that
+* downstream middleware sees the real page URL.
+*
+* By calling `await next()` inside a try/catch, middleware redirects and errors are captured and
+* returned as JSON envelopes instead of HTTP redirects/error pages. This keeps SPA navigation
+* intact on the client.
+*/ function jsonRequestWrapper() {
+	return async (requestEvent) => {
+		const requestEv = requestEvent;
+		const isLoader = requestEv.internalRequest === "loader";
+		const isActionJson = requestEv.internalRequest === "action";
+		if (!isLoader && !isActionJson) return;
+		if (isLoader) {
+			addVaryHeader(requestEv, FULLPATH_HEADER);
+			const pagePath = requestEv.request.headers.get(FULLPATH_HEADER);
+			const pagePathname = resolveValidInternalFullPathname(requestEv.url.pathname, pagePath);
+			if (pagePathname) requestEv.url.pathname = pagePathname;
+		}
+		try {
+			await requestEv.next();
+		} catch (err) {
+			if (requestEv.headersSent) return;
+			if (err instanceof RedirectMessage) {
+				const location = requestEv.headers.get("Location") || "/";
+				requestEv.headers.delete("Location");
+				if (isLoader) await sendJsonResponse(requestEv, { r: location });
+				else await sendActionResponse(requestEv, { redirect: location });
+			} else if (err instanceof ServerError) {
+				if (isLoader) await sendJsonResponse(requestEv, { e: err });
+				else await sendActionResponse(requestEv, {
+					e: err,
+					s: err.status
+				});
+			} else if (err instanceof Error) {
+				console.error("JSON request error:", err);
+				const message = isDev ? `${err.message}\n(this is only visible in dev mode)` : "Internal Server Error";
+				const se = new ServerError(500, message);
+				if (isLoader) await sendJsonResponse(requestEv, { e: se });
+				else await sendActionResponse(requestEv, {
+					e: se,
+					s: 500
+				});
+			} else throw err;
+		}
+	};
+}
+function verifySerializable$1(data, qrl) {
+	try {
+		_verifySerializable(data, void 0);
+	} catch (e) {
+		if (e instanceof Error && qrl.dev) e.loc = qrl.dev;
+		throw e;
+	}
+}
+async function measure$1(requestEv, name, fn) {
+	const start = performance.now();
+	try {
+		return await fn();
+	} finally {
+		const duration = performance.now() - start;
+		let measurements = requestEv.sharedMap.get("@serverTiming");
+		if (!measurements) requestEv.sharedMap.set("@serverTiming", measurements = []);
+		measurements.push([name, duration]);
+	}
+}
+async function runValidators(requestEv, validators, data, devMode) {
+	let lastResult = {
+		success: true,
+		data
+	};
+	if (validators) for (const validator of validators) {
+		if (devMode) lastResult = await measure$1(requestEv, `validator$`, () => validator.validate(requestEv, data));
+		else lastResult = await validator.validate(requestEv, data);
+		if (!lastResult.success) return lastResult;
+		else data = lastResult.data;
+	}
+	return lastResult;
+}
+/**
+* Handler for action requests (`?qaction={actionId}`).
+*
+* When the request has `Accept: application/json`, returns the action result as JSON. Otherwise,
+* falls through to let the page render (progressive enhancement for forms).
+*
+* If the action has no `invalidate` list, the client invalidates all current route loaders unless
+* strict loaders mode treats it as `invalidate: []`. If `invalidate` is specified, only those
+* loader hashes are sent for the client to re-fetch.
+*/ function actionHandler(routeActions) {
+	return async (requestEvent) => {
+		const requestEv = requestEvent;
+		if (!requestEv.sharedMap.has("@isQAction")) return;
+		if (!requestEv.request.headers.get("accept")?.includes("application/json")) return;
+		if (requestEv.headersSent || requestEv.exited) return;
+		const actionId = requestEv.sharedMap.get(QActionId);
+		const method = requestEv.method;
+		const devMode = isDev$1;
+		if (devMode && method === "GET") console.warn("Seems like you are submitting a Qwik Action via GET request. Qwik Actions should be submitted via POST request.\nMake sure your <form> has method=\"POST\" attribute, like this: <form method=\"POST\">");
+		if (method !== "POST") return;
+		let action;
+		for (const routeAction of routeActions) if (routeAction.__id === actionId) action = routeAction;
+		if (!action) action = globalThis._qwikActionsMap?.get(actionId);
+		if (!action) {
+			requestEv.json(404, { error: "Action not found" });
+			return;
+		}
+		const data = await requestEv.parseBody();
+		if (!data || typeof data !== "object") throw new Error(`Expected request data for the action id ${actionId} to be an object`);
+		let actionResult;
+		const result = await runValidators(requestEv, action.__validators, data, devMode);
+		if (!result.success) actionResult = requestEv.fail(result.status ?? 500, result.error);
+		else {
+			const actionResolved = devMode ? await measure$1(requestEv, action.__qrl.getHash(), () => action.__qrl.call(requestEv, result.data, requestEv)) : await action.__qrl.call(requestEv, result.data, requestEv);
+			throwIfControlFlowSignal(actionResolved);
+			if (devMode) verifySerializable$1(actionResolved, action.__qrl);
+			actionResult = actionResolved;
+		}
+		if (requestEv.headers.has("Location")) throw new RedirectMessage();
+		const responseData = { result: actionResult };
+		requestEv.sharedMap.set(RequestEvSharedActionId, actionId);
+		requestEv.sharedMap.set("@actionResult", actionResult);
+		if (action.__invalidate) responseData.loaderHashes = action.__invalidate;
+		else if (globalThis.__STRICT_LOADERS__) responseData.loaderHashes = [];
+		const serialized = await _serialize(responseData);
+		requestEv.headers.set("Content-Type", "application/json; charset=utf-8");
+		requestEv.send(requestEv.status(), serialized);
+	};
+}
+/**
+* Hypertext Transfer Protocol (HTTP) response status codes.
+*
+* @see {@link https://en.wikipedia.org/wiki/List_of_HTTP_status_codes}
+*/ var HttpStatus = /*#__PURE__*/ function(HttpStatus) {
+	/**
+	* The server has received the request headers and the client should proceed to send the request
+	* body (in the case of a request for which a body needs to be sent; for example, a POST request).
+	* Sending a large request body to a server after a request has been rejected for inappropriate
+	* headers would be inefficient. To have a server check the request's headers, a client must send
+	* Expect: 100-continue as a header in its initial request and receive a 100 Continue status code
+	* in response before sending the body. The response 417 Expectation Failed indicates the request
+	* should not be continued.
+	*/ HttpStatus[HttpStatus["Continue"] = 100] = "Continue";
+	/** The requester has asked the server to switch protocols and the server has agreed to do so. */ HttpStatus[HttpStatus["SwitchingProtocols"] = 101] = "SwitchingProtocols";
+	/**
+	* A WebDAV request may contain many sub-requests involving file operations, requiring a long time
+	* to complete the request. This code indicates that the server has received and is processing the
+	* request, but no response is available yet. This prevents the client from timing out and
+	* assuming the request was lost.
+	*/ HttpStatus[HttpStatus["Processing"] = 102] = "Processing";
+	/**
+	* Standard response for successful HTTP requests. The actual response will depend on the request
+	* method used. In a GET request, the response will contain an entity corresponding to the
+	* requested resource. In a POST request, the response will contain an entity describing or
+	* containing the result of the action.
+	*/ HttpStatus[HttpStatus["Ok"] = 200] = "Ok";
+	/** The request has been fulfilled, resulting in the creation of a new resource. */ HttpStatus[HttpStatus["Created"] = 201] = "Created";
+	/**
+	* The request has been accepted for processing, but the processing has not been completed. The
+	* request might or might not be eventually acted upon, and may be disallowed when processing
+	* occurs.
+	*/ HttpStatus[HttpStatus["Accepted"] = 202] = "Accepted";
+	/**
+	* SINCE HTTP/1.1 The server is a transforming proxy that received a 200 OK from its origin, but
+	* is returning a modified version of the origin's response.
+	*/ HttpStatus[HttpStatus["NonAuthoritativeInformation"] = 203] = "NonAuthoritativeInformation";
+	/** The server successfully processed the request and is not returning any content. */ HttpStatus[HttpStatus["NoContent"] = 204] = "NoContent";
+	/**
+	* The server successfully processed the request, but is not returning any content. Unlike a 204
+	* response, this response requires that the requester reset the document view.
+	*/ HttpStatus[HttpStatus["ResetContent"] = 205] = "ResetContent";
+	/**
+	* The server is delivering only part of the resource (byte serving) due to a range header sent by
+	* the client. The range header is used by HTTP clients to enable resuming of interrupted
+	* downloads, or split a download into multiple simultaneous streams.
+	*/ HttpStatus[HttpStatus["PartialContent"] = 206] = "PartialContent";
+	/**
+	* The message body that follows is an XML message and can contain a number of separate response
+	* codes, depending on how many sub-requests were made.
+	*/ HttpStatus[HttpStatus["MultiStatus"] = 207] = "MultiStatus";
+	/**
+	* The members of a DAV binding have already been enumerated in a preceding part of the
+	* (multistatus) response, and are not being included again.
+	*/ HttpStatus[HttpStatus["AlreadyReported"] = 208] = "AlreadyReported";
+	/**
+	* The server has fulfilled a request for the resource, and the response is a representation of
+	* the result of one or more instance-manipulations applied to the current instance.
+	*/ HttpStatus[HttpStatus["ImUsed"] = 226] = "ImUsed";
+	/**
+	* Indicates multiple options for the resource from which the client may choose (via agent-driven
+	* content negotiation). For example, this code could be used to present multiple video format
+	* options, to list files with different filename extensions, or to suggest word-sense
+	* disambiguation.
+	*/ HttpStatus[HttpStatus["MultipleChoices"] = 300] = "MultipleChoices";
+	/** This and all future requests should be directed to the given URI. */ HttpStatus[HttpStatus["MovedPermanently"] = 301] = "MovedPermanently";
+	/**
+	* This is an example of industry practice contradicting the standard. The HTTP/1.0 specification
+	* (RFC 1945) required the client to perform a temporary redirect (the original describing phrase
+	* was "Moved Temporarily"), but popular browsers implemented 302 with the functionality of a 303
+	* See Other. Therefore, HTTP/1.1 added status codes 303 and 307 to distinguish between the two
+	* behaviors. However, some Web applications and frameworks use the 302 status code as if it were
+	* the 303.
+	*/ HttpStatus[HttpStatus["Found"] = 302] = "Found";
+	/**
+	* SINCE HTTP/1.1 The response to the request can be found under another URI using a GET method.
+	* When received in response to a POST (or PUT/DELETE), the client should presume that the server
+	* has received the data and should issue a redirect with a separate GET message.
+	*/ HttpStatus[HttpStatus["SeeOther"] = 303] = "SeeOther";
+	/**
+	* Indicates that the resource has not been modified since the version specified by the request
+	* headers If-Modified-Since or If-None-Match. In such case, there is no need to retransmit the
+	* resource since the client still has a previously-downloaded copy.
+	*/ HttpStatus[HttpStatus["NotModified"] = 304] = "NotModified";
+	/**
+	* SINCE HTTP/1.1 The requested resource is available only through a proxy, the address for which
+	* is provided in the response. Many HTTP clients (such as Mozilla and Internet Explorer) do not
+	* correctly handle responses with this status code, primarily for security reasons.
+	*/ HttpStatus[HttpStatus["UseProxy"] = 305] = "UseProxy";
+	/** No longer used. Originally meant "Subsequent requests should use the specified proxy." */ HttpStatus[HttpStatus["SwitchProxy"] = 306] = "SwitchProxy";
+	/**
+	* SINCE HTTP/1.1 In this case, the request should be repeated with another URI; however, future
+	* requests should still use the original URI. In contrast to how 302 was historically
+	* implemented, the request method is not allowed to be changed when reissuing the original
+	* request. For example, a POST request should be repeated using another POST request.
+	*/ HttpStatus[HttpStatus["TemporaryRedirect"] = 307] = "TemporaryRedirect";
+	/**
+	* The request and all future requests should be repeated using another URI. 307 and 308 parallel
+	* the behaviors of 302 and 301, but do not allow the HTTP method to change. So, for example,
+	* submitting a form to a permanently redirected resource may continue smoothly.
+	*/ HttpStatus[HttpStatus["PermanentRedirect"] = 308] = "PermanentRedirect";
+	/**
+	* The server cannot or will not process the request due to an apparent client error (e.g.,
+	* malformed request syntax, too large size, invalid request message framing, or deceptive request
+	* routing).
+	*/ HttpStatus[HttpStatus["BadRequest"] = 400] = "BadRequest";
+	/**
+	* Similar to 403 Forbidden, but specifically for use when authentication is required and has
+	* failed or has not yet been provided. The response must include a WWW-Authenticate header field
+	* containing a challenge applicable to the requested resource. See Basic access authentication
+	* and Digest access authentication. 401 semantically means "unauthenticated",i.e. the user does
+	* not have the necessary credentials.
+	*/ HttpStatus[HttpStatus["Unauthorized"] = 401] = "Unauthorized";
+	/**
+	* Reserved for future use. The original intention was that this code might be used as part of
+	* some form of digital cash or micro payment scheme, but that has not happened, and this code is
+	* not usually used. Google Developers API uses this status if a particular developer has exceeded
+	* the daily limit on requests.
+	*/ HttpStatus[HttpStatus["PaymentRequired"] = 402] = "PaymentRequired";
+	/**
+	* The request was valid, but the server is refusing action. The user might not have the necessary
+	* permissions for a resource.
+	*/ HttpStatus[HttpStatus["Forbidden"] = 403] = "Forbidden";
+	/**
+	* The requested resource could not be found but may be available in the future. Subsequent
+	* requests by the client are permissible.
+	*/ HttpStatus[HttpStatus["NotFound"] = 404] = "NotFound";
+	/**
+	* A request method is not supported for the requested resource; for example, a GET request on a
+	* form that requires data to be presented via POST, or a PUT request on a read-only resource.
+	*/ HttpStatus[HttpStatus["MethodNotAllowed"] = 405] = "MethodNotAllowed";
+	/**
+	* The requested resource is capable of generating only content not acceptable according to the
+	* Accept headers sent in the request.
+	*/ HttpStatus[HttpStatus["NotAcceptable"] = 406] = "NotAcceptable";
+	/** The client must first authenticate itself with the proxy. */ HttpStatus[HttpStatus["ProxyAuthenticationRequired"] = 407] = "ProxyAuthenticationRequired";
+	/**
+	* The server timed out waiting for the request. According to HTTP specifications: "The client did
+	* not produce a request within the time that the server was prepared to wait. The client MAY
+	* repeat the request without modifications at any later time."
+	*/ HttpStatus[HttpStatus["RequestTimeout"] = 408] = "RequestTimeout";
+	/**
+	* Indicates that the request could not be processed because of conflict in the request, such as
+	* an edit conflict between multiple simultaneous updates.
+	*/ HttpStatus[HttpStatus["Conflict"] = 409] = "Conflict";
+	/**
+	* Indicates that the resource requested is no longer available and will not be available again.
+	* This should be used when a resource has been intentionally removed and the resource should be
+	* purged. Upon receiving a 410 status code, the client should not request the resource in the
+	* future. Clients such as search engines should remove the resource from their indices. Most use
+	* cases do not require clients and search engines to purge the resource, and a "404 Not Found"
+	* may be used instead.
+	*/ HttpStatus[HttpStatus["Gone"] = 410] = "Gone";
+	/**
+	* The request did not specify the length of its content, which is required by the requested
+	* resource.
+	*/ HttpStatus[HttpStatus["LengthRequired"] = 411] = "LengthRequired";
+	/** The server does not meet one of the preconditions that the requester put on the request. */ HttpStatus[HttpStatus["PreconditionFailed"] = 412] = "PreconditionFailed";
+	/**
+	* The request is larger than the server is willing or able to process. Previously called "Request
+	* Entity Too Large".
+	*/ HttpStatus[HttpStatus["PayloadTooLarge"] = 413] = "PayloadTooLarge";
+	/**
+	* The URI provided was too long for the server to process. Often the result of too much data
+	* being encoded as a query-string of a GET request, in which case it should be converted to a
+	* POST request. Called "Request-URI Too Long" previously.
+	*/ HttpStatus[HttpStatus["UriTooLong"] = 414] = "UriTooLong";
+	/**
+	* The request entity has a media type which the server or resource does not support. For example,
+	* the client uploads an image as image/svg+xml, but the server requires that images use a
+	* different format.
+	*/ HttpStatus[HttpStatus["UnsupportedMediaType"] = 415] = "UnsupportedMediaType";
+	/**
+	* The client has asked for a portion of the file (byte serving), but the server cannot supply
+	* that portion. For example, if the client asked for a part of the file that lies beyond the end
+	* of the file. Called "Requested Range Not Satisfiable" previously.
+	*/ HttpStatus[HttpStatus["RangeNotSatisfiable"] = 416] = "RangeNotSatisfiable";
+	/** The server cannot meet the requirements of the Expect request-header field. */ HttpStatus[HttpStatus["ExpectationFailed"] = 417] = "ExpectationFailed";
+	/**
+	* This code was defined in 1998 as one of the traditional IETF April Fools' jokes, in RFC 2324,
+	* Hyper Text Coffee Pot Control Protocol, and is not expected to be implemented by actual HTTP
+	* servers. The RFC specifies this code should be returned by teapots requested to brew coffee.
+	* This HTTP status is used as an Easter egg in some websites, including Google.com.
+	*/ HttpStatus[HttpStatus["IAmATeapot"] = 418] = "IAmATeapot";
+	/**
+	* The request was directed at a server that is not able to produce a response (for example
+	* because a connection reuse).
+	*/ HttpStatus[HttpStatus["MisdirectedRequest"] = 421] = "MisdirectedRequest";
+	/** The request was well-formed but was unable to be followed due to semantic errors. */ HttpStatus[HttpStatus["UnprocessableEntity"] = 422] = "UnprocessableEntity";
+	/** The resource that is being accessed is locked. */ HttpStatus[HttpStatus["Locked"] = 423] = "Locked";
+	/** The request failed due to failure of a previous request (e.g., a PROPPATCH). */ HttpStatus[HttpStatus["FailedDependency"] = 424] = "FailedDependency";
+	/**
+	* The client should switch to a different protocol such as TLS/1.0, given in the Upgrade header
+	* field.
+	*/ HttpStatus[HttpStatus["UpgradeRequired"] = 426] = "UpgradeRequired";
+	/**
+	* The origin server requires the request to be conditional. Intended to prevent "the 'lost
+	* update' problem, where a client GETs a resource's state, modifies it, and PUTs it back to the
+	* server, when meanwhile a third party has modified the state on the server, leading to a
+	* conflict."
+	*/ HttpStatus[HttpStatus["PreconditionRequired"] = 428] = "PreconditionRequired";
+	/**
+	* The user has sent too many requests in a given amount of time. Intended for use with
+	* rate-limiting schemes.
+	*/ HttpStatus[HttpStatus["TooManyRequests"] = 429] = "TooManyRequests";
+	/**
+	* The server is unwilling to process the request because either an individual header field, or
+	* all the header fields collectively, are too large.
+	*/ HttpStatus[HttpStatus["RequestHeaderFieldsTooLarge"] = 431] = "RequestHeaderFieldsTooLarge";
+	/**
+	* A server operator has received a legal demand to deny access to a resource or to a set of
+	* resources that includes the requested resource. The code 451 was chosen as a reference to the
+	* novel Fahrenheit 451.
+	*/ HttpStatus[HttpStatus["UnavailableForLegalReasons"] = 451] = "UnavailableForLegalReasons";
+	/**
+	* A generic error message, given when an unexpected condition was encountered and no more
+	* specific message is suitable.
+	*/ HttpStatus[HttpStatus["InternalServerError"] = 500] = "InternalServerError";
+	/**
+	* The server either does not recognize the request method, or it lacks the ability to fulfill the
+	* request. Usually this implies future availability (e.g., a new feature of a web-service API).
+	*/ HttpStatus[HttpStatus["NotImplemented"] = 501] = "NotImplemented";
+	/**
+	* The server was acting as a gateway or proxy and received an invalid response from the upstream
+	* server.
+	*/ HttpStatus[HttpStatus["BadGateway"] = 502] = "BadGateway";
+	/**
+	* The server is currently unavailable (because it is overloaded or down for maintenance).
+	* Generally, this is a temporary state.
+	*/ HttpStatus[HttpStatus["ServiceUnavailable"] = 503] = "ServiceUnavailable";
+	/**
+	* The server was acting as a gateway or proxy and did not receive a timely response from the
+	* upstream server.
+	*/ HttpStatus[HttpStatus["GatewayTimeout"] = 504] = "GatewayTimeout";
+	/** The server does not support the HTTP protocol version used in the request */ HttpStatus[HttpStatus["HttpVersionNotSupported"] = 505] = "HttpVersionNotSupported";
+	/** Transparent content negotiation for the request results in a circular reference. */ HttpStatus[HttpStatus["VariantAlsoNegotiates"] = 506] = "VariantAlsoNegotiates";
+	/** The server is unable to store the representation needed to complete the request. */ HttpStatus[HttpStatus["InsufficientStorage"] = 507] = "InsufficientStorage";
+	/** The server detected an infinite loop while processing the request. */ HttpStatus[HttpStatus["LoopDetected"] = 508] = "LoopDetected";
+	/** Further extensions to the request are required for the server to fulfill it. */ HttpStatus[HttpStatus["NotExtended"] = 510] = "NotExtended";
+	/**
+	* The client needs to authenticate to gain network access. Intended for use by intercepting
+	* proxies used to control access to the network (e.g., "captive portals" used to require
+	* agreement to Terms of Service before granting full Internet access via a Wi-Fi hotspot).
+	*/ HttpStatus[HttpStatus["NetworkAuthenticationRequired"] = 511] = "NetworkAuthenticationRequired";
+	return HttpStatus;
+}({});
+function getQwikRouterServerData(requestEv) {
+	const { params, request, status, locale, originalUrl } = requestEv;
+	const requestHeaders = {};
+	request.headers.forEach((value, key) => requestHeaders[key] = value);
+	const action = requestEv.sharedMap.get(RequestEvSharedActionId);
+	const actionResult = requestEv.sharedMap.get("@actionResult");
+	const formData = requestEv.sharedMap.get(RequestEvSharedActionFormData);
+	const routeName = requestEv.sharedMap.get(RequestRouteName);
+	const nonce = requestEv.sharedMap.get(RequestEvSharedNonce);
+	const headers = requestEv.request.headers;
+	const reconstructedUrl = new URL(originalUrl.pathname + originalUrl.search, originalUrl);
+	const host = headers.get("X-Forwarded-Host");
+	const protocol = headers.get("X-Forwarded-Proto");
+	if (host) {
+		reconstructedUrl.port = "";
+		reconstructedUrl.host = host;
+	}
+	if (protocol) reconstructedUrl.protocol = protocol;
+	const routeLoaderCtx = getRouteLoaderCtx(requestEv);
+	const loaderValues = getRouteLoaderValues(requestEv);
+	return {
+		url: reconstructedUrl.href,
+		requestHeaders,
+		renderMode: getRequestMode(requestEv),
+		locale: locale(),
+		nonce,
+		containerAttributes: { [Q_ROUTE]: routeName },
+		qwikrouter: {
+			routeName,
+			ev: requestEv,
+			params: { ...params },
+			loadedRoute: getRequestRoute(requestEv),
+			routeLoaderCtx,
+			loaderValues,
+			response: {
+				status: status(),
+				statusMessage: requestEv.sharedMap.get(RequestEvHttpStatusMessage),
+				action,
+				actionResult,
+				formData
+			}
+		}
+	};
+}
+var loadHttpError = () => import("./http-error.qwik.mjs");
+function createResolveRequestHandlers() {
+	const resolveRequestHandlers = (serverPlugins, route, method, checkOrigin, renderHandler) => {
+		const routeLoaders = [];
+		const routeActions = [];
+		const requestHandlers = [];
+		const isPageRoute = !!isLastModulePageRoute(route.$mods$);
+		if (isPageRoute) {
+			/**
+			* JSON request wrapper must be before all middleware so it can rewrite the URL and catch
+			* redirects/errors from plugin/route middleware via try/catch on next()
+			*/ requestHandlers.push(jsonRequestWrapper());
+			requestHandlers.push(serverErrorMiddleware(route, renderHandler));
+		}
+		if (serverPlugins) _resolveRequestHandlers(routeLoaders, routeActions, requestHandlers, serverPlugins, isPageRoute, method);
+		if (!route.$notFound$ && isPageRoute && (method === "POST" || method === "GET")) requestHandlers.push(runServerFunction);
+		const routeModules = route.$mods$;
+		_resolveRequestHandlers(routeLoaders, routeActions, requestHandlers, routeModules, isPageRoute, method, isPageRoute);
+		const routeName = route.$routeName$;
+		if (checkOrigin && (method === "POST" || method === "PUT" || method === "PATCH" || method === "DELETE")) {
+			if (checkOrigin === "lax-proto") requestHandlers.unshift(csrfLaxProtoCheckMiddleware);
+			else requestHandlers.unshift(csrfCheckMiddleware);
+		}
+		if (isPageRoute) {
+			requestHandlers.push(loaderHandler(routeLoaders, route.$loaderPaths$));
+			requestHandlers.push(actionHandler(routeActions));
+			if (!route.$notFound$) requestHandlers.push(fixTrailingSlash);
+		}
+		if (isPageRoute) {
+			requestHandlers.push((ev) => {
+				ev.sharedMap.set(RequestRouteName, routeName);
+			});
+			requestHandlers.push(actionsMiddleware(routeActions));
+			requestHandlers.push(loadersMiddleware(routeLoaders, route));
+			requestHandlers.push(eTagMiddleware(route));
+			requestHandlers.push(renderHandler);
+		}
+		return requestHandlers;
+	};
+	function _resolveRequestHandlers(routeLoaders, routeActions, requestHandlers, routeModules, collectActions, method, guardPageHandlersForLoader = false) {
+		for (let i = 0; i < routeModules.length; i++) {
+			const routeModule = routeModules[i];
+			const moduleHandlers = getModuleRequestHandlers(routeModule, method);
+			const shouldGuardPageHandlers = guardPageHandlersForLoader && i === routeModules.length - 1;
+			requestHandlers.push(...shouldGuardPageHandlers ? moduleHandlers.map((handler) => guardPageHandlerForLoader(routeModule, handler)) : moduleHandlers);
+			if (collectActions) {
+				for (const module of Object.values(routeModule)) if (typeof module === "function") {
+					if (module.__brand === "server_loader") routeLoaders.push(module);
+					else if (module.__brand === "server_action") routeActions.push(module);
+				}
+			}
+		}
+	}
+	function getModuleRequestHandlers(routeModule, method) {
+		const handlers = [];
+		addRequestHandlers(handlers, routeModule.onRequest);
+		let methodReqHandler;
+		switch (method) {
+			case "GET":
+				methodReqHandler = routeModule.onGet;
+				break;
+			case "POST":
+				methodReqHandler = routeModule.onPost;
+				break;
+			case "PUT":
+				methodReqHandler = routeModule.onPut;
+				break;
+			case "PATCH":
+				methodReqHandler = routeModule.onPatch;
+				break;
+			case "DELETE":
+				methodReqHandler = routeModule.onDelete;
+				break;
+			case "OPTIONS":
+				methodReqHandler = routeModule.onOptions;
+				break;
+			case "HEAD": methodReqHandler = routeModule.onHead;
+		}
+		addRequestHandlers(handlers, methodReqHandler);
+		return handlers;
+	}
+	function addRequestHandlers(handlers, handler) {
+		if (typeof handler === "function") handlers.push(handler);
+		else if (Array.isArray(handler)) handlers.push(...handler);
+	}
+	function guardPageHandlerForLoader(routeModule, handler) {
+		return (requestEv) => {
+			if (requestEv.sharedMap.has("@isQLoader")) {
+				if (!moduleHasLoader(routeModule, requestEv.sharedMap.get("@loaderId"))) return;
+			}
+			return handler(requestEv);
+		};
+	}
+	function moduleHasLoader(routeModule, loaderId) {
+		if (typeof loaderId !== "string") return false;
+		for (const value of Object.values(routeModule)) if (checkBrand(value, "server_loader") && matchesRouteLoaderId(value, loaderId)) return true;
+		return false;
+	}
+	const checkBrand = (obj, brand) => {
+		return obj && typeof obj === "function" && obj.__brand === brand;
+	};
+	function actionsMiddleware(routeActions) {
+		return async (requestEvent) => {
+			const requestEv = requestEvent;
+			if (requestEv.headersSent) {
+				requestEv.exit();
+				return;
+			}
+			const { method } = requestEv;
+			if (isDev && method === "GET") {
+				if (requestEv.query.has("qaction")) console.warn("Seems like you are submitting a Qwik Action via GET request. Qwik Actions should be submitted via POST request.\nMake sure your <form> has method=\"POST\" attribute, like this: <form method=\"POST\">");
+			}
+			if (method === "POST") {
+				const selectedActionId = requestEv.query.get(QACTION_KEY);
+				if (selectedActionId) {
+					const serverActionsMap = globalThis._qwikActionsMap;
+					const action = routeActions.find((action) => action.__id === selectedActionId) ?? serverActionsMap?.get(selectedActionId);
+					if (action) {
+						requestEv.sharedMap.set(RequestEvSharedActionId, selectedActionId);
+						const data = await requestEv.parseBody();
+						if (!data || typeof data !== "object") throw new Error(`Expected request data for the action id ${selectedActionId} to be an object`);
+						const result = await runValidators(requestEv, action.__validators, data);
+						let actionResult;
+						if (!result.success) actionResult = requestEv.fail(result.status ?? 500, result.error);
+						else {
+							const actionResolved = isDev ? await measure(requestEv, action.__qrl.getHash(), () => action.__qrl.call(requestEv, result.data, requestEv)) : await action.__qrl.call(requestEv, result.data, requestEv);
+							throwIfControlFlowSignal(actionResolved);
+							if (isDev) verifySerializable(actionResolved, action.__qrl);
+							actionResult = actionResolved;
+						}
+						requestEv.sharedMap.set("@actionResult", actionResult);
+					}
+				}
+			}
+		};
+	}
+	function loadersMiddleware(routeLoaders, route) {
+		return (requestEvent) => {
+			if (requestEvent.headersSent) {
+				requestEvent.exit();
+				return;
+			}
+			if (routeLoaders.length === 0) return;
+			setLoaderData(requestEvent, routeLoaders, route);
+			let allBlockSSRLoaders;
+			for (let i = 0; i < routeLoaders.length; i++) {
+				const loader = routeLoaders[i];
+				const promise = loadRouteLoader(loader, requestEvent);
+				promise.catch(() => {});
+				if (loader.__blockSSR) allBlockSSRLoaders = allBlockSSRLoaders ? allBlockSSRLoaders.then(() => promise) : promise;
+			}
+			return allBlockSSRLoaders;
+		};
+	}
+	function setLoaderData(requestEv, routeLoaders, route) {
+		if (routeLoaders.length === 0) return;
+		const routeLoaderCtx = getRouteLoaderCtx(requestEv);
+		if (route.$loaderPaths$) Object.assign(routeLoaderCtx.loaderPaths, route.$loaderPaths$);
+		setRouteLoaders(requestEv, routeLoaders);
+	}
+	function eTagMiddleware(route) {
+		return (requestEv) => {
+			if (requestEv.headersSent) return;
+			if (requestEv.method !== "GET") return;
+			const mods = route.$mods$;
+			if (!mods.some((m) => {
+				if (!m) return false;
+				if (m.routeConfig) return typeof m.routeConfig === "function" || m.routeConfig.eTag !== void 0 || m.routeConfig.cacheKey !== void 0;
+				return m.eTag !== void 0 || m.cacheKey !== void 0;
+			})) return;
+			const loaderValues = getRouteLoaderValues(requestEv);
+			const getData = (loaderOrAction) => {
+				const id = loaderOrAction.__id;
+				if (loaderOrAction.__brand === "server_loader") {
+					if (!(id in loaderValues)) throw new Error("Loader not executed for this request.");
+					return loaderValues[id];
+				}
+				return requestEv.sharedMap.get("@actionId") === id ? requestEv.sharedMap.get("@actionResult") : void 0;
+			};
+			const routeLocation = {
+				params: requestEv.params,
+				url: requestEv.url,
+				isNavigating: false,
+				prevUrl: void 0
+			};
+			const status = requestEv.status();
+			const config = resolveRouteConfig(getData, routeLocation, mods, "", status);
+			const headProps = {
+				head: config.head,
+				status,
+				withLocale: (fn) => fn(),
+				resolveValue: getData,
+				...routeLocation
+			};
+			const resolvedETag = resolveETag(config.eTag, headProps);
+			const normalizedETag = resolvedETag !== null ? normalizeETag(resolvedETag) : "";
+			if (normalizedETag && performETagMatch(requestEv, normalizedETag)) return;
+			if (MAX_CACHE_SIZE <= 0) return;
+			const cacheKey = resolveCacheKey(config.cacheKey, defaultSsrCacheKey, requestEv, normalizedETag);
+			if (!cacheKey) return;
+			const cached = getCachedSsr(cacheKey);
+			if (cached) {
+				requestEv.headers.set("Content-Type", "text/html; charset=utf-8");
+				requestEv.headers.set("X-SSR-Cache", "HIT");
+				if (!normalizedETag) {
+					if (performETagMatch(requestEv, cached.eTag)) return;
+				} else setETagHeader(requestEv, cached.eTag);
+				requestEv.send(status, cached.body);
+				return;
+			}
+			requestEv.sharedMap.set(RequestEvETagCacheKey, {
+				key: cacheKey,
+				eTag: normalizedETag
+			});
+		};
+	}
+	function serverErrorMiddleware(route, renderHandler) {
+		return async (requestEv) => {
+			try {
+				await requestEv.next();
+			} catch (e) {
+				if (!(e instanceof ServerError) || requestEv.headersSent) throw e;
+				const accept = requestEv.request.headers.get("Accept");
+				if (accept && !accept.includes("text/html")) throw e;
+				const status = e.status;
+				requestEv.status(status);
+				const errorLoader = route.$errorLoader$;
+				route.$mods$ = errorLoader ? await Promise.all(errorLoader.map((load) => load())) : [await loadHttpError()];
+				requestEv.sharedMap.set(RequestEvHttpStatusMessage, typeof e.data === "string" ? e.data : "Server Error");
+				clearErrorResponseData(requestEv);
+				await renderHandler(requestEv);
+			}
+		};
+	}
+	function clearErrorResponseData(requestEv) {
+		clearRouteLoaderData(requestEv);
+		requestEv.sharedMap.delete(RequestEvSharedActionId);
+		requestEv.sharedMap.delete(RequestEvSharedActionFormData);
+		requestEv.sharedMap.delete("@actionResult");
+	}
+	async function runValidators(requestEv, validators, data) {
+		let lastResult = {
+			success: true,
+			data
+		};
+		if (validators) for (const validator of validators) {
+			if (isDev) lastResult = await measure(requestEv, `validator$`, () => validator.validate(requestEv, data));
+			else lastResult = await validator.validate(requestEv, data);
+			if (!lastResult.success) return lastResult;
+			else data = lastResult.data;
+		}
+		return lastResult;
+	}
+	function isAsyncIterator(obj) {
+		return obj ? typeof obj === "object" && Symbol.asyncIterator in obj : false;
+	}
+	async function runServerFunction(ev) {
+		const serverFnHash = ev.query.get(QFN_KEY);
+		if (serverFnHash && ev.request.headers.get("X-QRL") === serverFnHash && ev.request.headers.get("Content-Type") === "application/qwik-json") {
+			ev.exit();
+			const data = await ev.parseBody();
+			if (!Array.isArray(data) || !(Array.isArray(data[0]) || data[0] === void 0)) throw ev.error(500, "Invalid request");
+			const qrl = inlinedQrl(null, serverFnHash, data.slice(1));
+			let result;
+			try {
+				if (isDev) result = await measure(ev, `server_${serverFnHash}`, () => qrl.apply(ev, data[0]));
+				else result = await qrl.apply(ev, data[0]);
+			} catch (err) {
+				if (err instanceof ServerError) throw ev.error(err.status, err.data);
+				console.error(`Server function ${serverFnHash} failed:`, err);
+				throw ev.error(500, "Invalid request");
+			}
+			throwIfControlFlowSignal(result);
+			if (isAsyncIterator(result)) await streamServerFunctionResult(ev, result, qrl);
+			else {
+				verifySerializable(result, qrl);
+				ev.headers.set("Content-Type", "application/qwik-json");
+				const message = await _serialize(result);
+				ev.send(200, message);
+			}
+			return;
+		}
+	}
+	async function streamServerFunctionResult(ev, result, qrl) {
+		ev.headers.set("Content-Type", "text/qwik-json-stream");
+		const stream = ev.getWritableStream().getWriter();
+		for await (const item of result) {
+			if (isDev) verifySerializable(item, qrl);
+			const message = await _serialize(item);
+			if (ev.signal.aborted) break;
+			await stream.write(encoder.encode(`${message}\n`)).catch((err) => {
+				if (isDev) console.error(`Server function ${qrl.getSymbol()} stream write failed:`, err);
+			});
+		}
+		await stream.close().catch((err) => {
+			if (isDev) console.error(`Server function ${qrl.getSymbol()} stream close failed:`, err);
+		});
+	}
+	function fixTrailingSlash(ev) {
+		const { basePathname, originalUrl } = ev;
+		const { pathname, search } = originalUrl;
+		if (!pathname.startsWith("/") || pathname.startsWith("//")) return;
+		if (pathname !== basePathname && !pathname.endsWith(".html")) {
+			if (!globalThis.__NO_TRAILING_SLASH__) {
+				if (!pathname.endsWith("/")) throw ev.redirect(HttpStatus.MovedPermanently, ensureSlash(pathname) + search);
+			} else if (pathname.endsWith("/")) throw ev.redirect(HttpStatus.MovedPermanently, pathname.slice(0, pathname.length - 1) + search);
+		}
+	}
+	function verifySerializable(data, qrl) {
+		try {
+			_verifySerializable(data, void 0);
+		} catch (e) {
+			if (e instanceof Error && qrl.dev) e.loc = qrl.dev;
+			throw e;
+		}
+	}
+	const isQrl = (value) => {
+		return typeof value === "function" && typeof value.getSymbol === "function";
+	};
+	function isLastModulePageRoute(routeModules) {
+		const lastRouteModule = routeModules[routeModules.length - 1];
+		return lastRouteModule && typeof lastRouteModule.default === "function";
+	}
+	function getPathname(url) {
+		url = new URL(url);
+		if (!globalThis.__NO_TRAILING_SLASH__) {
+			if (!url.pathname.endsWith("/")) url.pathname = ensureSlash(url.pathname);
+		} else if (url.pathname.endsWith("/")) url.pathname = url.pathname.slice(0, -1);
+		const search = url.search.slice(1).replaceAll(/&?q(action|data|func|loaders)=[^&]+/g, "");
+		return `${url.pathname}${search ? `?${search}` : ""}${url.hash}`;
+	}
+	function csrfLaxProtoCheckMiddleware(requestEv) {
+		checkCSRF(requestEv, "lax-proto");
+	}
+	function csrfCheckMiddleware(requestEv) {
+		checkCSRF(requestEv);
+	}
+	function checkCSRF(requestEv, laxProto) {
+		if (!requestEv.request.headers.get("content-type") || isContentType(requestEv.request.headers, "application/x-www-form-urlencoded", "multipart/form-data", "text/plain")) {
+			const inputOrigin = requestEv.request.headers.get("origin");
+			const origin = requestEv.url.origin;
+			let forbidden = inputOrigin !== origin;
+			if (forbidden && laxProto && inputOrigin?.replace(/^http(s)?/g, "") === origin.replace(/^http(s)?/g, "")) forbidden = false;
+			if (forbidden) throw requestEv.error(403, `CSRF check failed. Cross-site ${requestEv.method} form submissions are forbidden.
+The request origin "${inputOrigin}" does not match the server origin "${origin}".`);
+		}
+	}
+	function renderQwikMiddleware(render) {
+		return async (requestEv) => {
+			if (requestEv.headersSent) return;
+			const responseHeaders = requestEv.headers;
+			if (!responseHeaders.has("Content-Type")) responseHeaders.set("Content-Type", "text/html; charset=utf-8");
+			const cachePlan = requestEv.sharedMap.get(RequestEvETagCacheKey);
+			const { readable, writable } = new TextEncoderStream();
+			const writableStream = requestEv.getWritableStream();
+			let cacheChunks;
+			let pipeSource = readable;
+			if (cachePlan) {
+				cacheChunks = [];
+				const capture = new TransformStream({ transform(chunk, controller) {
+					cacheChunks.push(chunk);
+					controller.enqueue(chunk);
+				} });
+				pipeSource = readable.pipeThrough(capture);
+			}
+			let pipeError;
+			const pipe = pipeSource.pipeTo(writableStream, { preventClose: true }).catch((error) => {
+				pipeError = error;
+			});
+			const stream = writable.getWriter();
+			try {
+				const isStatic = getRequestMode(requestEv) === "static";
+				const serverData = getQwikRouterServerData(requestEv);
+				const result = await render({
+					base: requestEv.basePathname + "build/",
+					stream,
+					streaming: isStatic ? { outOfOrder: false } : void 0,
+					serverData,
+					containerAttributes: {
+						["q:render"]: isStatic ? "static" : "",
+						...serverData.containerAttributes
+					}
+				});
+				if (typeof result.html === "string") await stream.write(result.html);
+			} finally {
+				await stream.ready;
+				await stream.close();
+				await pipe;
+			}
+			if (pipeError) throw pipeError;
+			if (cachePlan && cacheChunks && cacheChunks.length > 0) {
+				const totalLength = cacheChunks.reduce((sum, chunk) => sum + chunk.length, 0);
+				const combined = new Uint8Array(totalLength);
+				let offset = 0;
+				for (const chunk of cacheChunks) {
+					combined.set(chunk, offset);
+					offset += chunk.length;
+				}
+				const html = new TextDecoder().decode(combined);
+				const cachedETag = cachePlan.eTag || hash(html);
+				setCachedSsr(cachePlan.key, {
+					eTag: cachedETag,
+					body: html
+				});
+			}
+			await writableStream.close();
+		};
+	}
+	function now() {
+		return typeof performance !== "undefined" ? performance.now() : 0;
+	}
+	async function measure(requestEv, name, fn) {
+		const start = now();
+		try {
+			return await fn();
+		} finally {
+			const duration = now() - start;
+			let measurements = requestEv.sharedMap.get(RequestEvShareServerTiming);
+			if (!measurements) requestEv.sharedMap.set(RequestEvShareServerTiming, measurements = []);
+			measurements.push([name, duration]);
+		}
+	}
+	return {
+		actionsMiddleware,
+		checkBrand,
+		checkCSRF,
+		fixTrailingSlash,
+		getPathname,
+		isLastModulePageRoute,
+		isQrl,
+		loadersMiddleware,
+		measure,
+		renderQwikMiddleware,
+		resolveRequestHandlers,
+		streamServerFunctionResult,
+		verifySerializable
+	};
+}
+var { actionsMiddleware, checkBrand, checkCSRF, fixTrailingSlash, getPathname, isLastModulePageRoute, isQrl, loadersMiddleware, measure, renderQwikMiddleware, resolveRequestHandlers, streamServerFunctionResult, verifySerializable } = createResolveRequestHandlers();
+/** @public */ var ESCAPE_HTML = /[&<>]/g;
+var escapeHtml = (s) => {
+	return s.replace(ESCAPE_HTML, (c) => {
+		switch (c) {
+			case "&": return "&amp;";
+			case "<": return "&lt;";
+			case ">": return "&gt;";
+			default: return "";
+		}
+	});
+};
+var COLOR_400 = "#006ce9";
+var COLOR_500 = "#713fc2";
+function minimalHtmlResponse(status, message) {
+	if (typeof status !== "number") status = 500;
+	if (typeof message === "string") message = escapeHtml(message);
+	else message = "";
+	const width = typeof message === "string" ? "600px" : "300px";
+	const color = status >= 500 ? COLOR_500 : COLOR_400;
+	return `
+<head>
+  <meta charset="utf-8">
+  <meta http-equiv="Status" content="${status}">
+  <title>${status} ${message}</title>
+  <meta name="viewport" content="width=device-width,initial-scale=1">
+  <style>
+    body { color: ${color}; background-color: #fafafa; padding: 30px; font-family: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, Roboto, sans-serif; }
+    p { max-width: ${width}; margin: 60px auto 30px auto; background: white; border-radius: 4px; box-shadow: 0px 0px 50px -20px ${color}; overflow: hidden; }
+    strong { display: inline-block; padding: 15px; background: ${color}; color: white; }
+    span { display: inline-block; padding: 15px; }
+  </style>
+</head>
+<body><p><strong>${status}</strong> <span>${message}</span></p></body>
+`;
+}
+function getErrorHtml(status, e) {
+	let message = "Server Error";
+	if (e != null) {
+		if (typeof e.message === "string") message = e.message;
+		else message = String(e);
+	}
+	return `<html>` + minimalHtmlResponse(status, message) + `</html>`;
+}
+var ensureError = (e) => e instanceof Error || typeof e === "object" && e !== null ? e : new Error(String(e));
+async function runNext(requestEv, rebuildRouteInfo, resolve) {
+	try {
+		const isValidURL = (url) => new URL(url.pathname + url.search, url);
+		isValidURL(requestEv.originalUrl);
+	} catch {
+		const status = 404;
+		const message = "Resource Not Found";
+		requestEv.status(status);
+		requestEv.html(status, getErrorHtml(status, message));
+		return new ServerError(status, message);
+	}
+	let rewriteAttempt = 1;
+	async function runOnce() {
+		try {
+			await requestEv.next();
+		} catch (e) {
+			if (e instanceof RedirectMessage) {
+				await requestEv.getWritableStream().close();
+				return e;
+			} else if (e instanceof RewriteMessage) {
+				if (rewriteAttempt > 50) return /* @__PURE__ */ new Error(`Infinite rewrite loop`);
+				rewriteAttempt += 1;
+				const url = new URL(requestEv.url);
+				url.pathname = e.pathname;
+				const { loadedRoute, requestHandlers } = await rebuildRouteInfo(url);
+				requestEv.resetRoute(loadedRoute, requestHandlers, url);
+				return await runOnce();
+			} else if (e instanceof AbortMessage) return;
+			else if (e instanceof ServerError && !requestEv.headersSent) {
+				const status = e.status;
+				const accept = requestEv.request.headers.get("Accept");
+				if (accept && !accept.includes("text/html")) {
+					requestEv.headers.set("Content-Type", "application/qwik-json");
+					requestEv.send(status, await _serialize(e.data));
+				} else requestEv.html(status, getErrorHtml(status, e.data));
+				return e;
+			}
+			if (!isDev$1) try {
+				if (!requestEv.headersSent) {
+					requestEv.headers.set("content-type", "text/html; charset=utf-8");
+					requestEv.cacheControl({ noCache: true });
+					requestEv.status(500);
+				}
+				const stream = requestEv.getWritableStream();
+				if (!stream.locked) {
+					const writer = stream.getWriter();
+					await writer.write(encoder.encode(getErrorHtml(500, "Internal Server Error")));
+					await writer.close();
+				}
+			} catch {
+				console.error("Unable to render error page");
+			}
+			return e instanceof Error || typeof e === "object" && e !== null ? e : new Error(String(e));
+		}
+	}
+	try {
+		return await runOnce();
+	} finally {
+		if (!requestEv.isDirty()) resolve(null);
+	}
+}
+function runQwikRouter(serverRequestEv, loadedRoute, requestHandlers, rebuildRouteInfo, basePathname = "/") {
+	let resolve;
+	const responsePromise = new Promise((r) => resolve = r);
+	try {
+		const requestEv = createRequestEvent(serverRequestEv, loadedRoute, requestHandlers, basePathname, resolve);
+		return {
+			response: responsePromise,
+			requestEv,
+			completion: _asyncRequestStore ? _asyncRequestStore.run(requestEv, runNext, requestEv, rebuildRouteInfo, resolve) : runNext(requestEv, rebuildRouteInfo, resolve)
+		};
+	} catch (e) {
+		resolve(null);
+		return {
+			response: responsePromise,
+			requestEv: { headersSent: false },
+			completion: Promise.resolve(ensureError(e))
+		};
+	}
+}
+export { clearLoaderCache as a, mergeHeadersCookies as c, resolveRequestHandlers as i, getErrorHtml as n, clearSsrCache as o, renderQwikMiddleware as r, RewriteMessage as s, runQwikRouter as t };