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

package/lib/chunks/head.qwik.mjs

@@ -0,0 +1,1202 @@
+import { t as ensureSlash } from "./pathname.mjs";
+import { o as getLoaderName } from "./request-path.mjs";
+import { i as RedirectMessage, n as throwIfControlFlowSignal, t as ServerError } from "./server-error.mjs";
+import { _captures, createComputedQrl, createContextId, implicit$FirstArg, inlinedQrl, isDev, isServer, withLocale } from "@qwik.dev/core";
+import * as qwikRouterConfig from "@qwik-router-config";
+import { SerializerSymbol, _UNINITIALIZED, _deserialize, _getAsyncLocalStorage, _getContextEvent, _injectAsyncSignalValue, _markSignalAsExternallyOwned, _resolveContextWithoutSequentialScope, _verifySerializable } from "@qwik.dev/core/internal";
+import { isServer as isServer$1 } from "@qwik.dev/core/build";
+/** @internal */ var _asyncRequestStore;
+if (isServer$1) {
+	const AsyncLocalStorage = _getAsyncLocalStorage();
+	if (AsyncLocalStorage) _asyncRequestStore = new AsyncLocalStorage();
+	else console.warn("\n=====================\n  Qwik Router Warning:\n    AsyncLocalStorage is not available, continuing without it.\n    This impacts concurrent async server calls, where they lose access to the ServerRequestEv object.\n=====================\n\n");
+}
+var QACTION_KEY = "qaction";
+var QFN_KEY = "qfunc";
+var QDATA_KEY = "qdata";
+/** @public */ var Q_ROUTE = "q:route";
+var DEFAULT_LOADERS_SERIALIZATION_STRATEGY = globalThis.__DEFAULT_LOADERS_SERIALIZATION_STRATEGY__ || "never";
+var RouteStateContext = /*#__PURE__*/ createContextId("qr-s");
+var RouteLoaderCtxContext = /*#__PURE__*/ createContextId("qr-lc");
+var ContentContext = /*#__PURE__*/ createContextId("qr-c");
+var ContentInternalContext = /*#__PURE__*/ createContextId("qr-ic");
+var DocumentHeadContext = /*#__PURE__*/ createContextId("qr-h");
+var RouteLocationContext = /*#__PURE__*/ createContextId("qr-l");
+var RouteNavigateContext = /*#__PURE__*/ createContextId("qr-n");
+var RouteActionContext = /*#__PURE__*/ createContextId("qr-a");
+var RoutePreventNavigateContext = /*#__PURE__*/ createContextId("qr-p");
+var HttpStatusContext = /*#__PURE__*/ createContextId("qr-hs");
+/**
+* Route loaders read data before the route rendering starts, based on the route being navigated to.
+* They automatically update when the route changes on the client.
+*
+* They are represented by a ComputedSignal.
+*/ var REQUEST_ROUTE_LOADER_STATE = "@routeLoaderState";
+var REQUEST_LOADER_PATHS_STORE = "@loaderPathsStore";
+var REQUEST_ROUTE_LOADERS = "@routeLoaders";
+var REQUEST_ROUTE_LOADER_PROMISES = "@routeLoaderPromises";
+var REQUEST_ROUTE_LOADER_EVENTS = "@routeLoaderEvents";
+var REQUEST_ROUTE_LOADER_ROOT_EVENT = "@routeLoaderRootEvent";
+var ROUTE_LOADER_VALUE_PREFIX = "__qwik_route_loader_value__";
+/** Header name sent by client to tell the server the actual page URL for loader requests. */ var FULLPATH_HEADER = "X-Qwik-fullpath";
+/** Dev route hint that preserves the loader URL. */ var ROUTE_PATH_HEADER = "X-Qwik-route-path";
+/**
+* Per-navigation fetch dedupe: shares in-flight and completed fetches (hover prefetch → click nav)
+* and prevents repeat hover fetches. Cleared after each navigation kicks off its loader fetches;
+* across navigations the browser HTTP cache is the freshness authority.
+*/ var navFetchCache = /* @__PURE__ */ new Map();
+var clearNavFetchCache = () => navFetchCache.clear();
+var isRedirectStatus = (status) => status >= 300 && status < 400;
+/** We don't have aborts when preloading so we just pretend we do */ var wrapWithAbort = (promise, signal) => {
+	if (signal.aborted) return Promise.reject(signal.reason);
+	return new Promise((resolve, reject) => {
+		const abort = () => reject(signal.reason);
+		signal.addEventListener("abort", abort, { once: true });
+		promise.finally(() => signal.removeEventListener("abort", abort)).then(resolve, reject);
+	});
+};
+var getRouteLoaderValueStateKey = (loaderId) => `${ROUTE_LOADER_VALUE_PREFIX}${loaderId}`;
+var isRequestEvent = (value) => !!value && typeof value === "object" && Object.prototype.hasOwnProperty.call(value, "sharedMap") && Object.prototype.hasOwnProperty.call(value, "cookie");
+var isLoaderInternal = (value) => typeof value === "function" && value.__brand === "server_loader";
+/**
+* Fetch a single loader's raw JSON response from the server.
+*
+* URL pattern: `{basePath}{routePath}/q-loader-{loaderId}.{manifestHash}.json`
+*/ var fetchRouteLoaderData = async (loaderId, routePath, manifestHash, opts) => {
+	if (!routePath) return;
+	let resolvedPath = routePath;
+	const basePath = opts?.basePath ?? "/";
+	if (basePath !== "/" && !resolvedPath.startsWith(basePath)) resolvedPath = basePath + resolvedPath.slice(1);
+	const pathBase = ensureSlash(resolvedPath);
+	const pageUrl = opts?.pageUrl;
+	const search = pageUrl?.search ?? "";
+	const url = `${pathBase}${getLoaderName(loaderId, manifestHash)}${search}`;
+	const headers = {};
+	if (pageUrl && pageUrl.pathname !== pathBase) {
+		if (!globalThis.__STRICT_LOADERS__) headers[FULLPATH_HEADER] = pageUrl.pathname;
+		else if (isDev) headers[ROUTE_PATH_HEADER] = pageUrl.pathname;
+	}
+	const cacheKey = `${url}\n${headers["X-Qwik-fullpath"] ?? ""}`;
+	if (!opts?.ignoreCache) {
+		const entry = navFetchCache.get(cacheKey);
+		if (entry) return opts?.signal ? wrapWithAbort(entry, opts.signal) : entry;
+	}
+	const request = async () => {
+		const response = await fetch(url, {
+			signal: opts?.signal,
+			cache: opts?.ignoreCache ? "reload" : "default",
+			headers
+		});
+		if (response.redirected) return { r: response.url };
+		if (isRedirectStatus(response.status)) {
+			const location1 = response.headers.get("Location");
+			if (location1) return { r: location1 };
+		}
+		if (!response.ok) return;
+		return { raw: await response.text() };
+	};
+	if (opts?.ignoreCache) return request();
+	if (opts?.signal) return request().then((value) => {
+		if (value !== void 0 && !navFetchCache.has(cacheKey)) navFetchCache.set(cacheKey, Promise.resolve(value));
+		return value;
+	});
+	const promise = request().then((value) => {
+		if (value === void 0) navFetchCache.delete(cacheKey);
+		return value;
+	}, (err) => {
+		navFetchCache.delete(cacheKey);
+		throw err;
+	});
+	navFetchCache.set(cacheKey, promise);
+	return promise;
+};
+/** Build a sorted, stable search string from only the allowed param names. */ var filterSearchParams = (params, allowed) => {
+	const filtered = new URLSearchParams();
+	for (let i = 0; i < allowed.length; i++) {
+		const name = allowed[i];
+		const values = params.getAll(name);
+		for (let j = 0; j < values.length; j++) filtered.append(name, values[j]);
+	}
+	filtered.sort();
+	return filtered.toString() ? `?${filtered.toString()}` : "";
+};
+var getLoaderOptions = (rest) => {
+	let id;
+	let serializationStrategy = DEFAULT_LOADERS_SERIALIZATION_STRATEGY;
+	let cacheControl;
+	let eTag;
+	let cacheKey;
+	let search;
+	let blockSSR = true;
+	const validators = [];
+	if (rest.length === 1) {
+		const options = rest[0];
+		if (options && typeof options === "object") {
+			if ("validate" in options) validators.push(options);
+			else {
+				if (options.id) id = options.id;
+				if (options.serializationStrategy) serializationStrategy = options.serializationStrategy;
+				if (options.validation) validators.push(...options.validation);
+				if ("cacheControl" in options) cacheControl = options.cacheControl;
+				if ("eTag" in options) eTag = options.eTag;
+				if ("cacheKey" in options) cacheKey = options.cacheKey;
+				if (options.search) search = options.search;
+				else if (globalThis.__STRICT_LOADERS__) search = [];
+				if (options.blockSSR === false) {
+					if (!__EXPERIMENTAL__.blockSSR) throw new Error("`blockSSR: false` is an experimental feature and is not enabled. Please enable the feature flag by adding `experimental: [\"blockSSR\"]` to your qwikVite plugin options.");
+					blockSSR = false;
+				}
+			}
+		}
+	} else if (rest.length > 1) validators.push(...rest.filter(Boolean));
+	return {
+		id,
+		validators: validators.reverse(),
+		serializationStrategy,
+		cacheControl,
+		eTag,
+		cacheKey,
+		search,
+		blockSSR
+	};
+};
+/**
+* Returns the current RequestEvent if possible. Only usable on the server, and only during request
+* processing.
+*
+* @public
+*/ var getRequestEvent = (thisArg) => {
+	if (!isServer) throw new Error("getRequestEvent() can only be used on the server.");
+	return _asyncRequestStore?.getStore() || [thisArg, _getContextEvent()].find(isRequestEvent);
+};
+var REQUEST_ROUTE_LOADER_VALUES = "@routeLoaderValues";
+/** Get/create the record of pre-loaded loader values (used by middleware before component). */ function getRouteLoaderValues(requestEv) {
+	let values = requestEv.sharedMap.get(REQUEST_ROUTE_LOADER_VALUES);
+	if (!values) {
+		values = {};
+		requestEv.sharedMap.set(REQUEST_ROUTE_LOADER_VALUES, values);
+	}
+	return values;
+}
+function getRouteLoaderPromises(requestEv) {
+	let promises = requestEv.sharedMap.get(REQUEST_ROUTE_LOADER_PROMISES);
+	if (!promises) {
+		promises = {};
+		requestEv.sharedMap.set(REQUEST_ROUTE_LOADER_PROMISES, promises);
+	}
+	return promises;
+}
+/** Clear loader state before rendering a route-independent error boundary. */ function clearRouteLoaderData(requestEv) {
+	requestEv.sharedMap.delete(REQUEST_ROUTE_LOADER_STATE);
+	requestEv.sharedMap.delete(REQUEST_ROUTE_LOADER_VALUES);
+	requestEv.sharedMap.delete(REQUEST_ROUTE_LOADER_PROMISES);
+	requestEv.sharedMap.delete(REQUEST_ROUTE_LOADER_EVENTS);
+	requestEv.sharedMap.delete(REQUEST_ROUTE_LOADER_ROOT_EVENT);
+	requestEv.sharedMap.delete(REQUEST_ROUTE_LOADERS);
+}
+/** Store the route loader internals on the request for SSG to read. */ function setRouteLoaders(requestEv, loaders) {
+	requestEv.sharedMap.set(REQUEST_ROUTE_LOADERS, loaders);
+}
+/** Get the route loader internals stored on the request. */ function getRouteLoaders(requestEv) {
+	return requestEv.sharedMap.get(REQUEST_ROUTE_LOADERS) ?? [];
+}
+function getRouteLoaderCtx(requestEv) {
+	let ctx = requestEv.sharedMap.get(REQUEST_LOADER_PATHS_STORE);
+	if (!ctx) {
+		ctx = { loaderPaths: {} };
+		requestEv.sharedMap.set(REQUEST_LOADER_PATHS_STORE, ctx);
+	}
+	return ctx;
+}
+/** Update route loader matching state on navigation. */ var updateRouteLoaderPaths = (ctx, loaderPaths, pageUrl) => {
+	if (!isServer) {
+		ctx.pagePathname = pageUrl.pathname;
+		ctx.pageSearch = pageUrl.search;
+		ctx.routeLoaderCandidates = loaderPaths;
+	} else if (loaderPaths) for (const key in loaderPaths) ctx.loaderPaths[key] = loaderPaths[key];
+};
+var getModuleRouteLoaders = (mods) => {
+	const routeLoaders = [];
+	const seen = /* @__PURE__ */ new Map();
+	for (let i = 0; i < mods.length; i++) {
+		const mod = mods[i];
+		if (!mod) continue;
+		for (const key in mod) {
+			const value = mod[key];
+			if (isLoaderInternal(value)) {
+				const existing = seen.get(value.__id);
+				if (existing) {
+					if (isDev && existing !== value) console.warn(`Two route loaders share the same id "${value.__id}". Only the first will run; the others are ignored. If they are created by a shared wrapper around routeLoader$, give each loader a distinct \`id\` option.`);
+					continue;
+				}
+				seen.set(value.__id, value);
+				routeLoaders.push(value);
+			}
+		}
+	}
+	return routeLoaders;
+};
+/**
+* Loader ids declared `cacheControl: 'immutable'`. Their data cannot change until a rebuild, so
+* nav-wide invalidation skips them; they still re-fetch when their tracked URL inputs change.
+* Registered on every nav via ensureRouteLoaderSignal, so resumed signals are covered too.
+*/ var immutableLoaderIds = /* @__PURE__ */ new Set();
+var isImmutableLoader = (loaderId) => immutableLoaderIds.has(loaderId);
+/**
+* Invalidate every loader signal on navigation: the browser HTTP cache (driven by each loader's
+* cacheControl) decides freshness. Unsubscribed signals only mark stale and refetch lazily when
+* read again. Immutable loaders are skipped — their data cannot change until a rebuild; tracked URL
+* inputs still invalidate them.
+*/ var invalidateNavRouteLoaders = (state) => {
+	for (const id in state) if (!id.startsWith(ROUTE_LOADER_VALUE_PREFIX) && !immutableLoaderIds.has(id)) state[id].invalidate();
+};
+var applyClientRouteLoaderPath = (loaderId, ctx) => {
+	const currentPath = ctx.routeLoaderCandidates?.[loaderId];
+	if (currentPath) ctx.loaderPaths[loaderId] = currentPath;
+	else if (isDev && ctx.pagePathname) ctx.loaderPaths[loaderId] = ctx.pagePathname;
+};
+/**
+* Inject a pre-loaded value into a ComputedSignal while preserving subscriptions. Delegates to the
+* core helper which calls `invalidate({__v})` + `$computeIfNeeded$()` so the compute function runs
+* synchronously and returns the pre-loaded value without fetching. Must go through the core helper
+* because `$computeIfNeeded$` is mangled in core builds and not directly callable from this
+* package.
+*/ var setLoaderSignalValue = (signal, value) => {
+	_injectAsyncSignalValue(signal, value);
+};
+var matchesRouteLoaderId = (loader, loaderId) => {
+	return typeof loaderId === "string" && (loader.__id === loaderId || isDev && loader.__qrl.getHash() === loaderId);
+};
+var resolveRouteLoaderByHash = (routeLoaders, loaderId) => {
+	return routeLoaders.find((loader) => matchesRouteLoaderId(loader, loaderId));
+};
+/** @internal */ var getLoaderRequestEvent = (loader, requestEv) => {
+	let rootRequestEv = requestEv.sharedMap.get(REQUEST_ROUTE_LOADER_ROOT_EVENT);
+	if (!rootRequestEv) {
+		rootRequestEv = requestEv;
+		requestEv.sharedMap.set(REQUEST_ROUTE_LOADER_ROOT_EVENT, rootRequestEv);
+	}
+	const url = new URL(rootRequestEv.url);
+	const pathname = globalThis.__STRICT_LOADERS__ ? getRouteLoaderCtx(rootRequestEv).loaderPaths[loader.__id] || rootRequestEv.url.pathname : rootRequestEv.url.pathname;
+	const filteredSearch = loader.__search ? filterSearchParams(url.searchParams, loader.__search) : rootRequestEv.url.search;
+	if (pathname === rootRequestEv.url.pathname && filteredSearch === rootRequestEv.url.search) return rootRequestEv;
+	let events = rootRequestEv.sharedMap.get(REQUEST_ROUTE_LOADER_EVENTS);
+	if (!events) {
+		events = /* @__PURE__ */ new Map();
+		rootRequestEv.sharedMap.set(REQUEST_ROUTE_LOADER_EVENTS, events);
+	}
+	const eventKey = `${pathname}\n${filteredSearch}`;
+	let loaderRequestEv = events.get(eventKey);
+	if (!loaderRequestEv) {
+		url.pathname = pathname;
+		url.search = filteredSearch;
+		const request = new Request(url, rootRequestEv.request);
+		loaderRequestEv = Object.create(rootRequestEv, {
+			originalUrl: {
+				value: new URL(url),
+				enumerable: true
+			},
+			params: {
+				value: rootRequestEv.params,
+				enumerable: true
+			},
+			pathname: {
+				get: () => url.pathname,
+				enumerable: true
+			},
+			query: {
+				get: () => url.searchParams,
+				enumerable: true
+			},
+			request: {
+				value: request,
+				enumerable: true
+			},
+			url: {
+				value: url,
+				enumerable: true
+			}
+		});
+		events.set(eventKey, loaderRequestEv);
+	}
+	return loaderRequestEv;
+};
+/**
+* View of a request event whose response controls (status/headers/redirect/error/fail/cacheControl)
+* are captured locally, so a background (`blockSSR: false`) loader's status/redirect/error surfaces
+* on its own signal instead of mutating the page response. The originals also call `check()`, which
+* throws once SSR streaming has started — a background loader must fail on its signal, not crash.
+*/ var detachResponseFromEvent = (requestEv) => {
+	let status = 200;
+	const headers = new Headers();
+	return Object.create(requestEv, {
+		headers: {
+			value: headers,
+			enumerable: true
+		},
+		status: {
+			value: (statusCode) => {
+				if (typeof statusCode === "number") status = statusCode;
+				return status;
+			},
+			enumerable: true
+		},
+		error: {
+			value: (statusCode, message) => {
+				status = statusCode;
+				return new ServerError(statusCode, message);
+			},
+			enumerable: true
+		},
+		redirect: {
+			value: (statusCode, url) => {
+				status = statusCode;
+				if (url) headers.set("Location", url);
+				return new RedirectMessage();
+			},
+			enumerable: true
+		},
+		fail: {
+			value: (statusCode, data) => {
+				status = statusCode;
+				return {
+					failed: true,
+					...data
+				};
+			},
+			enumerable: true
+		},
+		cacheControl: {
+			value: () => {},
+			enumerable: true
+		}
+	});
+};
+async function runValidators(requestEv, validators, data) {
+	let lastResult = {
+		success: true,
+		data
+	};
+	if (validators) for (let i = 0; i < validators.length; i++) {
+		lastResult = await validators[i].validate(requestEv, data);
+		if (!lastResult.success) return lastResult;
+		data = lastResult.data;
+	}
+	return lastResult;
+}
+function verifySerializable(data, qrl) {
+	try {
+		_verifySerializable(data, void 0);
+	} catch (error) {
+		if (error instanceof Error && qrl.dev) error.loc = qrl.dev;
+		throw error;
+	}
+}
+/** Run a loader and return its raw value. Errors/redirects propagate as exceptions. */ var getRouteLoaderData = async (loaderQrl, validators, requestEv) => {
+	const loaderRequestEv = requestEv;
+	const result = await runValidators(requestEv, validators, void 0);
+	if (!result.success) return loaderRequestEv.fail(result.status ?? 500, result.error);
+	const resolved = await loaderQrl.call(loaderRequestEv, loaderRequestEv);
+	const value = typeof resolved === "function" ? resolved() : resolved;
+	throwIfControlFlowSignal(value);
+	if (isDev) verifySerializable(value, loaderQrl);
+	return value;
+};
+var loadRouteLoaderByQrl = (loaderId, loaderQrl, validators, requestEv) => {
+	const values = getRouteLoaderValues(requestEv);
+	if (loaderId in values) return Promise.resolve(values[loaderId]);
+	const promises = getRouteLoaderPromises(requestEv);
+	let promise = promises[loaderId];
+	if (!promise) {
+		promise = getRouteLoaderData(loaderQrl, validators, requestEv).then((value) => {
+			values[loaderId] = value;
+			return value;
+		}, (err) => {
+			delete promises[loaderId];
+			throw err;
+		});
+		promises[loaderId] = promise;
+	}
+	return promise;
+};
+var ServerRouteLoaderCapture = class {
+	hash;
+	qrl;
+	validators;
+	blockSSR;
+	constructor(hash, qrl, validators, blockSSR) {
+		this.hash = hash;
+		this.qrl = qrl;
+		this.validators = validators;
+		this.blockSSR = blockSSR;
+	}
+	load() {
+		const requestEv = getRequestEvent();
+		if (!requestEv) throw new Error("Unable to determine the current RequestEvent.");
+		const values = getRouteLoaderValues(requestEv);
+		if (this.hash in values) return values[this.hash];
+		const ev = this.blockSSR ? requestEv : detachResponseFromEvent(requestEv);
+		return loadRouteLoaderByQrl(this.hash, this.qrl, this.validators, ev);
+	}
+	[SerializerSymbol]() {
+		return this.hash;
+	}
+};
+var createRouteLoaderSignal = (loader, routeLoaderCtx, state) => {
+	const id = loader.__id;
+	const stateValues = state;
+	const resumeValueKey = getRouteLoaderValueStateKey(id);
+	const capture = isServer ? new ServerRouteLoaderCapture(id, loader.__qrl, loader.__validators, loader.__blockSSR) : id;
+	const searchFilter = loader.__search;
+	const signal = createComputedQrl(/*#__PURE__*/ inlinedQrl(async (ctx) => {
+		const capture = _captures[0], id = _captures[1], lastFetch = _captures[2], resumeValueKey = _captures[3], routeLoaderCtx = _captures[4], searchFilter = _captures[5], stateValues = _captures[6];
+		const hasInjectedValue = !!ctx.info && typeof ctx.info === "object" && "__v" in ctx.info;
+		const trackedRoutePath = ctx.track(routeLoaderCtx.loaderPaths, id);
+		const trackedPagePathname = ctx.track(routeLoaderCtx, "pagePathname");
+		const trackedPageSearch = ctx.track(routeLoaderCtx, "pageSearch");
+		if (hasInjectedValue) {
+			const value = ctx.info.__v;
+			if (!isServer && resumeValueKey in stateValues) stateValues[resumeValueKey] = value;
+			lastFetch.raw = void 0;
+			return value;
+		}
+		if (isServer) return capture.load();
+		const pagePathname = trackedPagePathname || location.pathname;
+		const pageSearch = trackedPageSearch || location.search;
+		const pageUrl = new URL(pagePathname + pageSearch, location.href);
+		const mHash = routeLoaderCtx.manifestHash || "dev";
+		const basePath = qwikRouterConfig.basePathname ?? "/";
+		const needsResumeFetch = stateValues[resumeValueKey] === _UNINITIALIZED;
+		const fetchRoutePath = trackedRoutePath || (needsResumeFetch ? pageUrl.pathname : void 0);
+		if (!fetchRoutePath) return ctx.previous;
+		let fetchUrl = pageUrl;
+		if (searchFilter) {
+			fetchUrl = new URL(pageUrl.href);
+			fetchUrl.search = filterSearchParams(pageUrl.searchParams, searchFilter);
+		}
+		const result = await fetchRouteLoaderData(id, fetchRoutePath, mHash, {
+			pageUrl: fetchUrl,
+			basePath,
+			ignoreCache: ctx.info === true,
+			signal: ctx.abortSignal
+		});
+		if (!result) throw new Error(`Loader ${id} returned empty response`);
+		let response;
+		if (result.raw === void 0) response = result;
+		else {
+			if (result.raw === lastFetch.raw && ctx.previous !== void 0) return ctx.previous;
+			response = await _deserialize(result.raw);
+			if (!response) throw new Error(`Loader ${id} returned empty response`);
+		}
+		if (response.r) {
+			const goto = routeLoaderCtx.goto;
+			if (goto) goto(response.r, { replaceState: true });
+			else location.href = response.r;
+			return ctx.previous;
+		}
+		if (response.e) throw response.e;
+		lastFetch.raw = result.raw;
+		if (needsResumeFetch) stateValues[resumeValueKey] = response.d;
+		return response.d;
+	}, "createRouteLoaderSignal_signal_createComputed_4s4ZDCYhDOA", [
+		capture,
+		id,
+		{},
+		resumeValueKey,
+		routeLoaderCtx,
+		searchFilter,
+		stateValues
+	]), { serializationStrategy: loader.__serializationStrategy });
+	_markSignalAsExternallyOwned(signal);
+	return signal;
+};
+var ensureRouteLoaderSignal = (loader, state, routeLoaderCtx) => {
+	if (!isServer && routeLoaderCtx.pagePathname) applyClientRouteLoaderPath(loader.__id, routeLoaderCtx);
+	if (loader.__cacheControl === "immutable") immutableLoaderIds.add(loader.__id);
+	if (isServer && loader.__serializationStrategy === "never") state[getRouteLoaderValueStateKey(loader.__id)] = _UNINITIALIZED;
+	return state[loader.__id] ||= createRouteLoaderSignal(loader, routeLoaderCtx, state);
+};
+var ensureRouteLoaderSignals = (mods, state, routeLoaderCtx) => {
+	const loaders = getModuleRouteLoaders(mods);
+	for (let i = 0; i < loaders.length; i++) ensureRouteLoaderSignal(loaders[i], state, routeLoaderCtx);
+	return loaders;
+};
+var loadRouteLoader = (loader, requestEv) => {
+	const loaderEv = getLoaderRequestEvent(loader, requestEv);
+	return loadRouteLoaderByQrl(loader.__id, loader.__qrl, loader.__validators, loader.__blockSSR ? loaderEv : detachResponseFromEvent(loaderEv));
+};
+/** Run a loader and wrap the result in a LoaderResponse envelope. Catches redirects/errors. */ var getRouteLoaderResponse = async (loaderQrl, validators, requestEv) => {
+	try {
+		return { d: await getRouteLoaderData(loaderQrl, validators, requestEv) };
+	} catch (err) {
+		if (err instanceof RedirectMessage) {
+			const location1 = requestEv.headers.get("Location") || "/";
+			requestEv.headers.delete("Location");
+			return { r: location1 };
+		}
+		if (err instanceof ServerError) return { e: err };
+		throw err;
+	}
+};
+/** @internal */ var routeLoaderQrl = (loaderQrl, ...rest) => {
+	const { id, validators, serializationStrategy, cacheControl, eTag, cacheKey, search, blockSSR } = getLoaderOptions(rest);
+	function loader() {
+		const signal = ensureRouteLoaderSignal(loader, _resolveContextWithoutSequentialScope(RouteStateContext), _resolveContextWithoutSequentialScope(RouteLoaderCtxContext));
+		signal.promise();
+		return signal;
+	}
+	loader.__brand = "server_loader";
+	loader.__qrl = loaderQrl;
+	loader.__validators = validators;
+	loader.__id = id ?? loaderQrl.getHash();
+	loader.__serializationStrategy = serializationStrategy;
+	loader.__cacheControl = cacheControl;
+	loader.__eTag = eTag;
+	loader.__cacheKey = cacheKey;
+	loader.__search = search;
+	loader.__blockSSR = blockSSR;
+	Object.freeze(loader);
+	return loader;
+};
+/**
+* Define a route loader that fetches data before the route renders.
+*
+* Route loaders run on the server during SSR and return data as a `ComputedSignal`. On the client,
+* loaders automatically re-fetch when the route changes (SPA navigation). Each loader gets its own
+* JSON endpoint (`q-loader-{id}.{hash}.json`), so only the loaders present on the target route are
+* fetched.
+*
+* **Important:** Route loader data uses Qwik's custom serialization format, not standard JSON. This
+* means the data supports features like circular references, Dates, and other non-JSON types, but
+* it cannot be consumed by external clients expecting plain JSON.
+*
+* ## Options
+*
+* - `search: string[]`: Allowlist of URL search params the loader depends on. Only listed params are
+*   sent in the request and changes to other params are ignored. During SSR and loader JSON
+*   requests, the loader's request event is filtered to those params too. `search: []` means no
+*   search params are sent and only route path changes trigger a re-fetch.
+* - `eTag`: Enable ETag-based caching. Can be `true` (auto-hash), a string, or a function.
+* - `cacheControl`: Cache-Control for loader JSON responses; the browser HTTP cache controls
+*   client-side freshness. `'immutable'` additionally lets SSG write the loader file.
+*
+* The `strictLoaders` Vite plugin option applies `search: []` globally for all loaders that don't
+* specify an explicit `search` option.
+*
+* @public
+*/ var routeLoader$ = /*#__PURE__*/ implicit$FirstArg(routeLoaderQrl);
+var deepFreeze = (obj) => {
+	if (obj == null) return obj;
+	Object.getOwnPropertyNames(obj).forEach((prop) => {
+		const value = obj[prop];
+		if (value && typeof value === "object" && !Object.isFrozen(value)) try {
+			deepFreeze(value);
+		} catch {
+			return obj;
+		}
+	});
+	return Object.freeze(obj);
+};
+/** LoadRoute() runs in both client and server. */ var MODULE_CACHE = /*#__PURE__*/ new WeakMap();
+/** Built-in fallback error component loader */ var httpErrorLoader = () => import("./http-error.qwik.mjs");
+/**
+* Walk trie keys from root, gathering `_L` layouts along the way. Returns the final node and
+* collected layouts, or undefined if any key is missing.
+*/ function walkTrieKeys(root, keys) {
+	let node = root;
+	const layouts = [];
+	if (node._L) layouts.push(node._L);
+	for (let i = 0; i < keys.length; i++) {
+		const key = keys[i];
+		let next = node[key];
+		if (!next && node._M) for (let j = 0; j < node._M.length; j++) {
+			const group = node._M[j];
+			next = group[key];
+			if (next) {
+				if (group._L) layouts.push(group._L);
+				break;
+			}
+		}
+		if (!next) return;
+		node = next;
+		if (node._L) layouts.push(node._L);
+	}
+	return {
+		node,
+		layouts
+	};
+}
+/**
+* The full chain to render for a boundary: a bare loader in its snapshot layouts, an override
+* as-is.
+*/ var boundaryChain = (ref) => ref.v ? Array.isArray(ref.v) ? ref.v : [...ref.layouts, ref.v] : void 0;
+/**
+* Collect layouts, the nearest error (`_E`) and not-found (`_4`) boundaries, and the menu from a
+* node and the group ancestors entered to reach it.
+*/ function collectNodeMeta(node, groups, layouts, errorLoaderRef, notFoundLoaderRef, menuLoaderRef, loaderHashes, loaderPathsByHash, matchedPathname = "/") {
+	for (let j = 0; j < groups.length; j++) {
+		const g = groups[j];
+		if (g._L) layouts.push(g._L);
+		if (g._R && loaderHashes) {
+			loaderHashes.push(...g._R);
+			if (loaderPathsByHash) for (let i = 0; i < g._R.length; i++) {
+				const hash = g._R[i];
+				loaderPathsByHash[hash] = matchedPathname;
+			}
+		}
+		if (g._E) {
+			errorLoaderRef.v = g._E;
+			errorLoaderRef.layouts = [...layouts];
+		}
+		if (g._4) {
+			notFoundLoaderRef.v = g._4;
+			notFoundLoaderRef.layouts = [...layouts];
+		}
+		if (g._N) menuLoaderRef.v = g._N;
+	}
+	if (node._L) layouts.push(node._L);
+	if (node._R && loaderHashes) {
+		loaderHashes.push(...node._R);
+		if (loaderPathsByHash) for (let i = 0; i < node._R.length; i++) {
+			const hash = node._R[i];
+			loaderPathsByHash[hash] = matchedPathname;
+		}
+	}
+	if (node._E) {
+		errorLoaderRef.v = node._E;
+		errorLoaderRef.layouts = [...layouts];
+	}
+	if (node._4) {
+		notFoundLoaderRef.v = node._4;
+		notFoundLoaderRef.layouts = [...layouts];
+	}
+	if (node._N) menuLoaderRef.v = node._N;
+}
+/** Try to match a segment against a node's wildcard children (_W, _A). */ function tryWildcardMatch(node, part, partLower, parts, partIndex) {
+	let next = node._W;
+	if (next) {
+		const prefix = next._0;
+		const suffix = next._9;
+		if (prefix || suffix) {
+			const pre = prefix || "";
+			const suf = suffix || "";
+			if (partLower.length > pre.length + suf.length && (!pre || partLower.startsWith(pre.toLowerCase())) && (!suf || partLower.endsWith(suf.toLowerCase()))) {
+				const paramName = next._P;
+				const value = part.slice(pre.length, suf ? part.length - suf.length : void 0);
+				return {
+					next,
+					routePart: `${pre}[${paramName}]${suf}`,
+					done: false,
+					kind: 1,
+					paramName,
+					paramValue: value
+				};
+			}
+		} else {
+			const paramName = next._P;
+			return {
+				next,
+				routePart: `[${paramName}]`,
+				done: false,
+				kind: 1,
+				paramName,
+				paramValue: part
+			};
+		}
+	}
+	next = node._A;
+	if (next) {
+		const paramName = next._P;
+		const restValue = parts.slice(partIndex).join("/");
+		return {
+			next,
+			routePart: `[...${paramName}]`,
+			done: true,
+			kind: 2,
+			paramName,
+			paramValue: restValue
+		};
+	}
+}
+/**
+* Try to find a child matching `partLower` in `node`, including inside group children (_M). Returns
+* the matched child node, the groups entered to reach it, what to push to routeParts, and which
+* kind of edge matched. Returns undefined if no match.
+*
+* Priority: exact match → _M groups (recursively) → _W wildcard → _A rest wildcard. This ensures
+* exact matches inside nested groups take precedence over wildcards at parent level.
+*/ function findChild(node, part, partLower, parts, partIndex) {
+	const exact = node[partLower];
+	if (exact) return {
+		next: exact,
+		groups: [],
+		routePart: part,
+		done: false,
+		kind: 0
+	};
+	if (node._M) for (let j = 0; j < node._M.length; j++) {
+		const group = node._M[j];
+		const groupResult = findChild(group, part, partLower, parts, partIndex);
+		if (groupResult) {
+			groupResult.groups.unshift(group);
+			return groupResult;
+		}
+	}
+	const wildcard = tryWildcardMatch(node, part, partLower, parts, partIndex);
+	if (wildcard) return {
+		...wildcard,
+		groups: []
+	};
+}
+/**
+* Descend through a node and its pathless `_M` groups (depth-first, in `_M` order), returning the
+* first node for which `hit` yields a value, plus the chain of groups entered to reach it. The
+* shared traversal behind the index / rest / boundary lookups inside groups.
+*/ function descendGroups(node, hit) {
+	const value = hit(node);
+	if (value !== void 0) return {
+		value,
+		node,
+		groups: []
+	};
+	if (node._M) for (let j = 0; j < node._M.length; j++) {
+		const group = node._M[j];
+		const result = descendGroups(group, hit);
+		if (result) {
+			result.groups.unshift(group);
+			return result;
+		}
+	}
+}
+/**
+* Find a node with `_I`/`_G` at the current level, including inside `_M` groups. Returns it and the
+* groups entered to reach it — excluding the target itself, whose `_L` the caller applies (so it
+* isn't double-counted).
+*/ function findIndexNode(node) {
+	const r = descendGroups(node, (n) => n._I || n._G != null ? n : void 0);
+	return r ? {
+		target: r.node,
+		groups: r.groups.filter((g) => g !== r.node)
+	} : void 0;
+}
+/**
+* Given a matched node that has `_I` or `_G`, resolve the final loaders array.
+*
+* - `_G`: re-walk from root to gather target's layouts and `_I`
+* - `_I` array: use as-is (override, e.g. layout stop)
+* - `_I` function: prepend gathered layouts
+*/ function resolveLoaders(root, node, gatheredLayouts) {
+	if (node._G != null) {
+		const target = walkTrieKeys(root, node._G.split("/").filter((p) => p.length > 0));
+		if (!target) return;
+		let targetNode = target.node;
+		const targetLayouts = target.layouts;
+		if (!targetNode._I && targetNode._G == null) {
+			const indexResult = findIndexNode(targetNode);
+			if (indexResult) {
+				for (let j = 0; j < indexResult.groups.length; j++) {
+					const g = indexResult.groups[j];
+					if (g._L) targetLayouts.push(g._L);
+				}
+				targetNode = indexResult.target;
+				if (targetNode._L) targetLayouts.push(targetNode._L);
+			}
+		}
+		return resolveLoaders(root, targetNode, targetLayouts);
+	}
+	const index = node._I;
+	if (!index) return;
+	if (Array.isArray(index)) return index;
+	return [...gatheredLayouts, index];
+}
+/**
+* Find a rest wildcard (`_A`) at the current node or inside its `_M` groups, with the groups
+* entered to reach it. Used to save fallback checkpoints during matching.
+*/ function findRestNode(node) {
+	const r = descendGroups(node, (n) => n._A);
+	return r ? {
+		next: r.value,
+		groups: r.groups
+	} : void 0;
+}
+/**
+* Find a `_4`/`_E` boundary inside a node's pathless `_M` groups (first in `_M` order), wrapped in
+* those groups' layouts.
+*/ function findGroupBoundary(node, layouts, kind) {
+	const r = descendGroups(node, (n) => n[kind]);
+	if (!r) return;
+	const groupLayouts = [...layouts];
+	for (const g of r.groups) if (g._L) groupLayouts.push(g._L);
+	return {
+		v: r.value,
+		layouts: groupLayouts
+	};
+}
+/**
+* Match a URL pathname against the route trie.
+*
+* Always returns a result. When no route matches, `notFound` is true and `loaders` contains only
+* the error component (from the nearest `_E` or `_4` ancestor, or the built-in fallback).
+*
+* Group nodes (in `_M` arrays) are pathless — they don't consume a URL segment but contribute their
+* `_L` layout to the chain. The matcher transparently enters groups when searching for a matching
+* child.
+*/ function matchRouteTree(root = {}, pathname) {
+	let node = root;
+	const params = {};
+	const routeParts = [];
+	const layouts = [];
+	const loaderHashes = [];
+	const loaderPathsByHash = {};
+	const errorLoaderRef = {
+		v: void 0,
+		layouts: []
+	};
+	const notFoundLoaderRef = {
+		v: void 0,
+		layouts: []
+	};
+	const menuLoaderRef = { v: void 0 };
+	const groupNodes = [];
+	collectNodeMeta(root, [], layouts, errorLoaderRef, notFoundLoaderRef, menuLoaderRef, loaderHashes, loaderPathsByHash);
+	if (root._M) groupNodes.push({
+		node: root,
+		depth: layouts.length
+	});
+	let done = false;
+	let matched = true;
+	const parts = pathname.split("/").filter((p) => p.length > 0).map(decodeURIComponent);
+	let restFallback;
+	let i = 0;
+	const len = parts.length;
+	for (; !done && i < len; i++) {
+		const part = parts[i];
+		const partLower = part.toLowerCase();
+		const found = findChild(node, part, partLower, parts, i);
+		if (!found) {
+			matched = false;
+			break;
+		}
+		const restInfo = found.kind === 1 ? findRestNode(node) : void 0;
+		if (restInfo) restFallback = {
+			aNode: restInfo.next,
+			groups: restInfo.groups,
+			paramName: restInfo.next._P,
+			restValue: parts.slice(i).join("/"),
+			routeParts: [...routeParts],
+			params: { ...params },
+			layouts: [...layouts],
+			loaderPathsByHash: { ...loaderPathsByHash },
+			errorLoader: errorLoaderRef.v,
+			errorLayouts: errorLoaderRef.layouts,
+			notFoundLoader: notFoundLoaderRef.v,
+			notFoundLayouts: notFoundLoaderRef.layouts,
+			menuLoader: menuLoaderRef.v
+		};
+		if (found.paramName) params[found.paramName] = found.paramValue;
+		routeParts.push(found.routePart);
+		done = found.done;
+		node = found.next;
+		const matchedPathname = `/${parts.slice(0, found.done ? len : i + 1).join("/")}/`;
+		collectNodeMeta(node, found.groups, layouts, errorLoaderRef, notFoundLoaderRef, menuLoaderRef, loaderHashes, loaderPathsByHash, matchedPathname);
+		if (node._M) groupNodes.push({
+			node,
+			depth: layouts.length
+		});
+	}
+	if (matched && !done && i === len) {
+		if (!node._I && node._G == null) {
+			const indexResult = findIndexNode(node);
+			if (indexResult) {
+				collectNodeMeta(indexResult.target, indexResult.groups, layouts, errorLoaderRef, notFoundLoaderRef, menuLoaderRef, loaderHashes, loaderPathsByHash, pathname);
+				node = indexResult.target;
+			}
+		}
+		if (!node._I && node._G == null) {
+			const restInfo = findRestNode(node);
+			if (restInfo) {
+				const next = restInfo.next;
+				const paramName = next._P;
+				params[paramName] = "";
+				routeParts.push(`[...${paramName}]`);
+				collectNodeMeta(next, restInfo.groups, layouts, errorLoaderRef, notFoundLoaderRef, menuLoaderRef, loaderHashes, loaderPathsByHash, pathname);
+				node = next;
+			}
+		}
+	}
+	const loaders = matched && (done || i >= len) ? resolveLoaders(root, node, layouts) : void 0;
+	if (!loaders && restFallback) {
+		const fb = restFallback;
+		const fbParams = {
+			...fb.params,
+			[fb.paramName]: fb.restValue
+		};
+		const fbRouteParts = [...fb.routeParts, `[...${fb.paramName}]`];
+		const fbLayouts = [...fb.layouts];
+		const fbLoaderPathsByHash = { ...fb.loaderPathsByHash };
+		const fbErrorRef = {
+			v: fb.errorLoader,
+			layouts: fb.errorLayouts
+		};
+		const fbNotFoundRef = {
+			v: fb.notFoundLoader,
+			layouts: fb.notFoundLayouts
+		};
+		const fbMenuRef = { v: fb.menuLoader };
+		const fbLoaderHashes = [];
+		collectNodeMeta(fb.aNode, fb.groups, fbLayouts, fbErrorRef, fbNotFoundRef, fbMenuRef, fbLoaderHashes, fbLoaderPathsByHash, pathname);
+		const fbLoaders = resolveLoaders(root, fb.aNode, fbLayouts);
+		if (fbLoaders) return {
+			loaders: fbLoaders,
+			params: fbParams,
+			routeParts: fbRouteParts,
+			notFound: false,
+			routeBundleNames: fb.aNode._B,
+			loaderHashes: fbLoaderHashes.length > 0 ? fbLoaderHashes : void 0,
+			loaderPathsByHash: Object.keys(fbLoaderPathsByHash).length > 0 ? fbLoaderPathsByHash : void 0,
+			menuLoader: fbMenuRef.v,
+			errorLoader: boundaryChain(fbErrorRef)
+		};
+		errorLoaderRef.v = fbErrorRef.v;
+		errorLoaderRef.layouts = fbErrorRef.layouts;
+		notFoundLoaderRef.v = fbNotFoundRef.v;
+		notFoundLoaderRef.layouts = fbNotFoundRef.layouts;
+		menuLoaderRef.v = fbMenuRef.v;
+	}
+	if (!loaders) {
+		const recover = (kind) => {
+			for (let k = groupNodes.length - 1; k >= 0; k--) {
+				const found = findGroupBoundary(groupNodes[k].node, layouts.slice(0, groupNodes[k].depth), kind);
+				if (found) return found;
+			}
+		};
+		if (!notFoundLoaderRef.v) {
+			const g = recover("_4");
+			if (g) {
+				notFoundLoaderRef.v = g.v;
+				notFoundLoaderRef.layouts = g.layouts;
+			}
+		}
+		if (!errorLoaderRef.v) {
+			const g = recover("_E");
+			if (g) {
+				errorLoaderRef.v = g.v;
+				errorLoaderRef.layouts = g.layouts;
+			}
+		}
+		const ref = notFoundLoaderRef.v ? notFoundLoaderRef : errorLoaderRef.v ? errorLoaderRef : null;
+		const boundary = ref?.v ?? httpErrorLoader;
+		const boundaryLayouts = ref ? ref.layouts : layouts;
+		return {
+			loaders: Array.isArray(boundary) ? boundary : [...boundaryLayouts, boundary],
+			params,
+			routeParts,
+			notFound: true,
+			routeBundleNames: void 0,
+			loaderHashes: void 0,
+			loaderPathsByHash: void 0,
+			menuLoader: menuLoaderRef.v,
+			errorLoader: boundaryChain(errorLoaderRef)
+		};
+	}
+	if (node._R) {
+		loaderHashes.push(...node._R);
+		const matchedPathname = ensureSlash(pathname);
+		for (let i = 0; i < node._R.length; i++) {
+			const hash = node._R[i];
+			loaderPathsByHash[hash] = matchedPathname;
+		}
+	}
+	return {
+		loaders,
+		params,
+		routeParts,
+		notFound: false,
+		routeBundleNames: node._B,
+		loaderHashes: loaderHashes.length > 0 ? loaderHashes : void 0,
+		loaderPathsByHash: Object.keys(loaderPathsByHash).length > 0 ? loaderPathsByHash : void 0,
+		menuLoader: menuLoaderRef.v,
+		errorLoader: boundaryChain(errorLoaderRef)
+	};
+}
+var loadModule = (moduleLoader, pendingLoads, moduleSetter, cacheModules) => {
+	if (typeof moduleLoader === "function") {
+		const loadedModule = MODULE_CACHE.get(moduleLoader);
+		if (loadedModule) moduleSetter(loadedModule);
+		else {
+			const moduleOrPromise = moduleLoader();
+			if (typeof moduleOrPromise.then === "function") pendingLoads.push(moduleOrPromise.then((loadedModule) => {
+				if (cacheModules !== false) MODULE_CACHE.set(moduleLoader, loadedModule);
+				moduleSetter(loadedModule);
+			}));
+			else if (moduleOrPromise) moduleSetter(moduleOrPromise);
+		}
+	}
+};
+var loadRoute = async (routes, cacheModules, pathname) => {
+	const { loaders, params, routeParts, notFound, routeBundleNames, loaderHashes, loaderPathsByHash, menuLoader, errorLoader } = matchRouteTree(routes, pathname);
+	const routeName = "/" + routeParts.join("/");
+	const modules = new Array(loaders.length);
+	const pendingLoads = [];
+	for (let i = 0; i < loaders.length; i++) {
+		const moduleLoader = loaders[i];
+		loadModule(moduleLoader, pendingLoads, (routeModule) => modules[i] = routeModule, cacheModules);
+	}
+	let menu = void 0;
+	loadModule(menuLoader, pendingLoads, (menuModule) => menu = menuModule?.default, cacheModules);
+	if (pendingLoads.length > 0) await Promise.all(pendingLoads);
+	return {
+		$routeName$: routeName,
+		$params$: params,
+		$mods$: modules,
+		$menu$: deepFreeze(menu),
+		$routeBundleNames$: routeBundleNames,
+		$notFound$: notFound,
+		$errorLoader$: errorLoader,
+		$loaders$: loaderHashes,
+		$loaderPaths$: loaderPathsByHash
+	};
+};
+/** Gets an absolute url path string (url.pathname + url.search + url.hash) */ var toPath = (url) => url.pathname + url.search + url.hash;
+/** Create a URL from a string and baseUrl */ var toUrl = (url, baseUrl) => new URL(url, baseUrl.href);
+/** Checks only if the origins are the same. */ var isSameOrigin = (a, b) => a.origin === b.origin;
+/** Checks only if the pathnames are the same for the URLs (doesn't include search and hash) */ var isSamePathname = ({ pathname: a }, { pathname: b }) => {
+	const lDiff = Math.abs(a.length - b.length);
+	return lDiff === 0 ? a === b : lDiff === 1 && ensureSlash(a) === ensureSlash(b);
+};
+/** Checks only if the search query strings are the same for the URLs */ var isSameSearchQuery = (a, b) => a.search === b.search;
+/** Checks only if the pathname + search are the same for the URLs. */ var isSamePath = (a, b) => isSameSearchQuery(a, b) && isSamePathname(a, b);
+var getClientNavPath = (props, baseUrl) => {
+	const href = props.href;
+	if (typeof href === "string" && typeof props.target !== "string" && !props.reload) try {
+		const linkUrl = toUrl(href.trim(), baseUrl.url);
+		if (isSameOrigin(linkUrl, toUrl("", baseUrl.url))) return toPath(linkUrl);
+	} catch (e) {
+		console.error(e);
+	}
+	else if (props.reload) return toPath(toUrl("", baseUrl.url));
+	return null;
+};
+var shouldPreload = (clientNavPath, currentLoc) => {
+	if (clientNavPath) return !isSamePathname(toUrl(clientNavPath, currentLoc.url), toUrl("", currentLoc.url));
+	return false;
+};
+var isPromise = (value) => {
+	return value && typeof value.then === "function";
+};
+var mergeArray = (existingArr, newArr) => {
+	if (Array.isArray(newArr)) for (const newItem of newArr) {
+		if (typeof newItem.key === "string") {
+			const existingIndex = existingArr.findIndex((i) => i.key === newItem.key);
+			if (existingIndex > -1) {
+				existingArr[existingIndex] = newItem;
+				continue;
+			}
+		}
+		existingArr.push(newItem);
+	}
+};
+var resolveDocumentHead = (resolvedHead, updatedHead) => {
+	if (typeof updatedHead.title === "string") resolvedHead.title = updatedHead.title;
+	mergeArray(resolvedHead.meta, updatedHead.meta);
+	mergeArray(resolvedHead.links, updatedHead.links);
+	mergeArray(resolvedHead.styles, updatedHead.styles);
+	mergeArray(resolvedHead.scripts, updatedHead.scripts);
+	Object.assign(resolvedHead.frontmatter, updatedHead.frontmatter);
+};
+var createDocumentHead = (defaults, manifestHash) => ({
+	title: defaults?.title || "",
+	meta: [...defaults?.meta || []],
+	links: [...defaults?.links || []],
+	styles: [...defaults?.styles || []],
+	scripts: [...defaults?.scripts || []],
+	frontmatter: { ...defaults?.frontmatter },
+	manifestHash: manifestHash || "dev"
+});
+/**
+* Resolve the full route config (head + eTag + cacheKey) from all content modules. Uses the same
+* resolution rules as DocumentHead: objects are merged immediately, functions are queued and
+* executed inner-before-outer.
+*/ var resolveRouteConfig = (resolveValue, routeLocation, contentModules, locale, status, defaults) => withLocale(locale, () => {
+	const head = createDocumentHead(defaults);
+	let eTag;
+	let cacheKey;
+	const fns = [];
+	for (let i = 0; i < contentModules.length; i++) {
+		const contentModule = contentModules[i];
+		if (!contentModule) continue;
+		const isLast = i === contentModules.length - 1;
+		let config;
+		if (contentModule.routeConfig) config = contentModule.routeConfig;
+		else if (contentModule.head) {
+			const synthetic = { head: void 0 };
+			const headExport = contentModule.head;
+			if (typeof headExport === "function") {
+				const mod = contentModule;
+				config = (props) => ({
+					head: headExport(props),
+					eTag: mod.eTag,
+					cacheKey: mod.cacheKey
+				});
+			} else {
+				synthetic.head = headExport;
+				const mod = contentModule;
+				if (mod.eTag !== void 0) synthetic.eTag = mod.eTag;
+				if (mod.cacheKey !== void 0) synthetic.cacheKey = mod.cacheKey;
+				config = synthetic;
+			}
+		} else {
+			const mod = contentModule;
+			if (mod.eTag !== void 0 || mod.cacheKey !== void 0) config = {
+				eTag: mod.eTag,
+				cacheKey: mod.cacheKey
+			};
+		}
+		if (!config) continue;
+		if (typeof config === "function") fns.unshift({
+			fn: config,
+			isLast
+		});
+		else {
+			if (config.head) resolveDocumentHead(head, config.head);
+			if (config.eTag !== void 0) eTag = config.eTag;
+			if (config.cacheKey !== void 0) cacheKey = config.cacheKey;
+		}
+	}
+	if (fns.length) {
+		const headProps = {
+			head,
+			status,
+			withLocale: (fn) => fn(),
+			resolveValue,
+			...routeLocation
+		};
+		for (const { fn } of fns) {
+			const result = fn(headProps);
+			if (result.head) resolveDocumentHead(head, result.head);
+			if (result.eTag !== void 0) eTag = result.eTag;
+			if (result.cacheKey !== void 0) cacheKey = result.cacheKey;
+		}
+	}
+	return {
+		head,
+		eTag,
+		cacheKey
+	};
+});
+/**
+* Resolve only the document head from all content modules. This is the browser-side entry point
+* that ignores eTag/cacheKey (server-only concerns).
+*
+* Signal values may throw a promise on the client when still loading — callers should wrap this in
+* `retryOnPromise` to handle that.
+*/ var resolveHead = (actionData, loaderState, routeLocation, contentModules, locale, defaults) => {
+	const getData = (loaderOrAction) => {
+		const id = loaderOrAction.__id;
+		const signal = loaderState?.[id];
+		if (signal) return signal.value;
+		if (actionData?.action === id) return actionData.actionResult;
+	};
+	return resolveRouteConfig(getData, routeLocation, contentModules, locale, actionData?.status ?? 200, defaults).head;
+};
+export { routeLoader$ as A, RouteLoaderCtxContext as B, getRouteLoaderValues as C, loadRouteLoader as D, isImmutableLoader as E, ContentContext as F, QACTION_KEY as G, RouteNavigateContext as H, ContentInternalContext as I, Q_ROUTE as J, QDATA_KEY as K, DocumentHeadContext as L, setLoaderSignalValue as M, setRouteLoaders as N, matchesRouteLoaderId as O, updateRouteLoaderPaths as P, HttpStatusContext as R, getRouteLoaderResponse as S, invalidateNavRouteLoaders as T, RoutePreventNavigateContext as U, RouteLocationContext as V, RouteStateContext as W, _asyncRequestStore as Y, fetchRouteLoaderData as _, isPromise as a, getRequestEvent as b, shouldPreload as c, loadRoute as d, FULLPATH_HEADER as f, ensureRouteLoaderSignals as g, clearRouteLoaderData as h, getClientNavPath as i, routeLoaderQrl as j, resolveRouteLoaderByHash as k, toPath as l, clearNavFetchCache as m, resolveHead as n, isSameOrigin as o, ROUTE_PATH_HEADER as p, QFN_KEY as q, resolveRouteConfig as r, isSamePath as s, createDocumentHead as t, toUrl as u, getLoaderRequestEvent as v, getRouteLoaders as w, getRouteLoaderCtx as x, getModuleRouteLoaders as y, RouteActionContext as z };