@ilha/router 0.11.2 → 0.11.4

package/dist/index.js

@@ -1,98 +1,74 @@
 import { t as REQUEST_ALS_KEY } from "./als-key-CVxbuM3z.js";
-import { i as withHeadStore, n as head, r as serializeHead, t as applyHeadEntriesToDocument } from "./head-DpYV3bHH.js";
+import { a as withHeadStore, i as serializeHead, n as head, r as openBrowserHead, t as applyHeadEntriesToDocument } from "./head-BLtm0xtK.js";
 import { h, mount, renderToString } from "ilha";
 
 //#region src/hash.ts
-const isBrowser$1 = typeof window !== "undefined" && typeof document !== "undefined";
+const isBrowser$1 = globalThis.window !== void 0 && globalThis.document !== void 0;
+const noop$1 = () => void 0;
+const HTTP_SCHEME = /^(?:http:|https:)$/u;
 const historyAdapter = {
+	extractLogicalPath(anchor) {
+		const href = anchor.getAttribute("href");
+		if (!href) return null;
+		if (anchor.protocol && !HTTP_SCHEME.test(anchor.protocol)) return null;
+		if (href.startsWith("#")) return null;
+		if (!!anchor.hostname && (anchor.hostname !== location.hostname || anchor.protocol !== location.protocol)) return null;
+		return anchor.pathname + anchor.search + anchor.hash;
+	},
+	onChange(handler) {
+		if (!isBrowser$1) return noop$1;
+		window.addEventListener("popstate", handler);
+		return () => window.removeEventListener("popstate", handler);
+	},
+	push(to, state) {
+		if (!isBrowser$1) return;
+		history.pushState(state ?? null, "", to);
+	},
 	readLocation() {
 		if (!isBrowser$1) return {
+			hash: "",
 			pathname: "/",
-			search: "",
-			hash: ""
+			search: ""
 		};
 		return {
+			hash: location.hash,
 			pathname: location.pathname,
-			search: location.search,
-			hash: location.hash
+			search: location.search
 		};
 	},
-	push(to, state) {
-		if (!isBrowser$1) return;
-		history.pushState(state ?? null, "", to);
-	},
 	replace(to, state) {
 		if (!isBrowser$1) return;
 		history.replaceState(state ?? null, "", to);
 	},
-	onChange(handler) {
-		if (!isBrowser$1) return () => {};
-		window.addEventListener("popstate", handler);
-		return () => window.removeEventListener("popstate", handler);
-	},
 	toLinkHref(p) {
 		return p;
-	},
-	extractLogicalPath(anchor) {
-		const href = anchor.getAttribute("href");
-		if (!href) return null;
-		if (anchor.protocol && !/^(http:|https:)$/.test(anchor.protocol)) return null;
-		if (href.startsWith("#")) return null;
-		if (!!anchor.hostname && (anchor.hostname !== location.hostname || anchor.protocol !== location.protocol)) return null;
-		return anchor.pathname + anchor.search + anchor.hash;
 	}
 };
-function parseHash(rawHash) {
+const parseHash = (rawHash) => {
 	const stripped = rawHash.startsWith("#") ? rawHash.slice(1) : rawHash;
-	const path = stripped === "" ? "/" : stripped.startsWith("/") ? stripped : "/" + stripped;
+	let path;
+	if (stripped === "") path = "/";
+	else if (stripped.startsWith("/")) path = stripped;
+	else path = `/${stripped}`;
 	const u = new URL(path, "http://_");
 	return {
+		hash: u.hash,
 		pathname: u.pathname,
-		search: u.search,
-		hash: u.hash
+		search: u.search
 	};
-}
+};
 const hashAdapter = {
-	readLocation() {
-		if (!isBrowser$1) return {
-			pathname: "/",
-			search: "",
-			hash: ""
-		};
-		return parseHash(location.hash);
-	},
-	push(to, state) {
-		if (!isBrowser$1) return;
-		history.pushState(state ?? null, "", to.startsWith("#") ? to : "#" + to);
-	},
-	replace(to, state) {
-		if (!isBrowser$1) return;
-		history.replaceState(state ?? null, "", to.startsWith("#") ? to : "#" + to);
-	},
-	onChange(handler) {
-		if (!isBrowser$1) return () => {};
-		window.addEventListener("popstate", handler);
-		window.addEventListener("hashchange", handler);
-		return () => {
-			window.removeEventListener("popstate", handler);
-			window.removeEventListener("hashchange", handler);
-		};
-	},
-	toLinkHref(p) {
-		if (p.startsWith("#")) return p;
-		return "#" + p;
-	},
 	extractLogicalPath(anchor) {
 		const href = anchor.getAttribute("href");
 		if (!href) return null;
 		if (href.startsWith("//")) return null;
-		if (anchor.protocol && !/^(http:|https:)$/.test(anchor.protocol)) return null;
+		if (anchor.protocol && !HTTP_SCHEME.test(anchor.protocol)) return null;
 		if (href.startsWith("#")) {
 			const inner = href.slice(1);
 			if (inner === "" || !inner.startsWith("/")) return null;
 			return inner;
 		}
-		if (/^https?:\/\//i.test(href)) try {
+		if (/^https?:\/\//iu.test(href)) try {
 			const u = new URL(href);
 			if (u.origin !== location.origin) return null;
 			if (!u.hash || u.hash === "#") return null;
@@ -103,6 +79,35 @@ const hashAdapter = {
 			return null;
 		}
 		return href;
+	},
+	onChange(handler) {
+		if (!isBrowser$1) return noop$1;
+		window.addEventListener("popstate", handler);
+		window.addEventListener("hashchange", handler);
+		return () => {
+			window.removeEventListener("popstate", handler);
+			window.removeEventListener("hashchange", handler);
+		};
+	},
+	push(to, state) {
+		if (!isBrowser$1) return;
+		history.pushState(state ?? null, "", to.startsWith("#") ? to : `#${to}`);
+	},
+	readLocation() {
+		if (!isBrowser$1) return {
+			hash: "",
+			pathname: "/",
+			search: ""
+		};
+		return parseHash(location.hash);
+	},
+	replace(to, state) {
+		if (!isBrowser$1) return;
+		history.replaceState(state ?? null, "", to.startsWith("#") ? to : `#${to}`);
+	},
+	toLinkHref(p) {
+		if (p.startsWith("#")) return p;
+		return `#${p}`;
 	}
 };
 let _mode = "history";
@@ -120,17 +125,13 @@ let _adapter = historyAdapter;
 * until they're re-attached (typically by unmounting and remounting
 * the router).
 */
-function setHistoryMode(mode) {
+const setHistoryMode = (mode) => {
 	_mode = mode;
 	_adapter = mode === "hash" ? hashAdapter : historyAdapter;
-}
-function getHistoryMode() {
-	return _mode;
-}
+};
+const getHistoryMode = () => _mode;
 /** Internal — used by index.ts. Not part of the public API. */
-function getAdapter() {
-	return _adapter;
-}
+const getAdapter = () => _adapter;
 
 //#endregion
 //#region src/http.ts
@@ -141,82 +142,109 @@ function getAdapter() {
 * a low-level helper — prefer {@link RouterBuilder.respond} for the full
 * render+head+headers pipeline.
 */
-function httpResponse(body, options = {}) {
+const httpResponse = (body, options = {}) => {
 	const headers = new Headers(options.headers);
-	if (body != null && !headers.has("content-type")) headers.set("content-type", "text/html; charset=utf-8");
+	if (body !== null && !headers.has("content-type")) headers.set("content-type", "text/html; charset=utf-8");
 	if (!headers.has("x-content-type-options")) headers.set("x-content-type-options", "nosniff");
 	if (!headers.has("referrer-policy")) headers.set("referrer-policy", "no-referrer");
 	if (!headers.has("cache-control")) headers.set("cache-control", "no-store");
 	const csp = options.contentSecurityPolicy ?? (options.cspNonce ? `default-src 'self'; script-src 'self' 'nonce-${options.cspNonce}'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; object-src 'none'; base-uri 'self'; frame-ancestors 'self'` : void 0);
 	if (csp) headers.set("content-security-policy", csp);
 	return new Response(body, {
-		status: options.status ?? 200,
-		headers
+		headers,
+		status: options.status ?? 200
 	});
-}
+};
 const EMPTY_HEAD = {
+	bodyAttrs: "",
 	headTags: "",
-	htmlAttrs: "",
-	bodyAttrs: ""
+	htmlAttrs: ""
 };
 /**
 * Options for {@link RouterBuilder.respond}.
 */
 
+//#endregion
+//#region src/route-error.ts
+var RouteError = class {
+	__ilhaRouteError = true;
+	status;
+	message;
+	constructor(status, message) {
+		this.message = message;
+		this.status = status >= 400 && status <= 599 ? status : 500;
+	}
+};
+
 //#endregion
 //#region src/route-match.ts
-function parsePattern(pattern) {
+const segmentKind = (segment) => {
+	if (segment.startsWith("*")) return 0;
+	if (segment.startsWith(":")) return 1;
+	return 2;
+};
+const parsePattern = (pattern) => {
 	const segments = pattern.split("/").filter(Boolean);
 	return {
-		segments,
-		kinds: segments.map((segment) => segment.startsWith("*") ? 0 : segment.startsWith(":") ? 1 : 2)
+		kinds: segments.map(segmentKind),
+		segments
 	};
-}
+};
 /**
 * Match `segments` against a pathname. Returns raw (still-encoded) captured
 * params, or `null` when the path doesn't match — the caller decides whether to
 * decode via {@link safeDecode}.
 */
-function matchSegments(segments, pathname) {
+const matchSegments = (segments, pathname) => {
 	const pathSegments = pathname.split("/").filter(Boolean);
 	const params = {};
 	let cursor = 0;
-	for (let i = 0; i < segments.length; i++) {
+	for (let i = 0; i < segments.length; i += 1) {
 		const segment = segments[i];
+		if (segment === void 0) return null;
 		const isLast = i === segments.length - 1;
 		if (segment.startsWith("**") && isLast) {
-			const name = segment.slice(2).replace(/^:/, "");
+			const name = segment.slice(2).replace(/^:/u, "");
 			if (name) params[name] = pathSegments.slice(cursor).join("/");
 			cursor = pathSegments.length;
 			break;
 		}
 		if (segment.startsWith("*")) {
 			if (pathSegments[cursor] === void 0) return null;
-			cursor++;
+			cursor += 1;
 			continue;
 		}
 		if (segment.startsWith(":")) {
 			const value = pathSegments[cursor];
 			if (value === void 0) return null;
 			params[segment.slice(1)] = value;
-			cursor++;
-		} else if (pathSegments[cursor] === segment) cursor++;
+			cursor += 1;
+		} else if (pathSegments[cursor] === segment) cursor += 1;
 		else return null;
 	}
 	return cursor === pathSegments.length ? params : null;
-}
+};
 /** Decode a route-param value, tolerating malformed percent-encoding. */
-function safeDecode(value) {
+const safeDecode = (value) => {
 	try {
 		return decodeURIComponent(value);
 	} catch {
 		return value;
 	}
-}
+};
 
 //#endregion
 //#region src/index.ts
-const isBrowser = typeof window !== "undefined" && typeof document !== "undefined";
+const objectTag = (value) => Object.prototype.toString.call(value);
+const isString = (value) => objectTag(value) === "[object String]";
+const isNumber = (value) => objectTag(value) === "[object Number]";
+const isFunction = (value) => {
+	const tag = objectTag(value);
+	return tag === "[object Function]" || tag === "[object AsyncFunction]" || tag === "[object GeneratorFunction]";
+};
+const isObject = (value) => value !== null && objectTag(value) === "[object Object]";
+const isBrowser = globalThis.window !== void 0 && globalThis.document !== void 0;
+const noop = () => void 0;
 var Redirect = class {
 	__ilhaRedirect = true;
 	to;
@@ -226,58 +254,26 @@ var Redirect = class {
 		this.status = status >= 300 && status <= 399 ? status : 302;
 	}
 };
-var RouteError = class {
-	__ilhaRouteError = true;
-	status;
-	message;
-	constructor(status, message) {
-		this.message = message;
-		this.status = status >= 400 && status <= 599 ? status : 500;
-	}
-};
-function redirect(to, status = 302) {
+const redirect = (to, status = 302) => {
 	throw new Redirect(to, status);
-}
-function error(status, message) {
+};
+const throwAppError = (status, message) => {
 	throw new RouteError(status, message);
-}
-function wrapLayout(layout, page) {
-	return function Wrapped() {
-		return h(layout, null, h(page, null));
-	};
-}
-function wrapError(handler, page) {
-	return async function Wrapped() {
-		try {
-			const out = page();
-			return out instanceof Promise ? await out : out;
-		} catch (e) {
-			const view = handler(e instanceof RouteError ? {
-				message: e.message,
-				status: e.status
-			} : { message: e instanceof Error ? e.message : String(e) }, snapshot());
-			return typeof view === "function" ? view() : view;
-		}
-	};
-}
-function defineLayout(layout) {
-	return layout;
-}
-function createRouteRegistry() {
-	return [];
-}
-function addRouteEntry(registry, pattern, data) {
+};
+const defineLayout = (layout) => layout;
+const createRouteRegistry = () => [];
+const addRouteEntry = (registry, pattern, data) => {
 	registry.push({
-		pattern,
+		data,
 		parsed: parsePattern(pattern),
-		data
+		pattern
 	});
-}
-function matchRoute(registry, pathname) {
+};
+const matchRoute = (registry, pathname) => {
 	let best = null;
 	let bestScore = -1;
 	for (const entry of registry) {
-		if (matchSegments(entry.parsed.segments, pathname) == null) continue;
+		if (matchSegments(entry.parsed.segments, pathname) === null) continue;
 		const score = entry.parsed.kinds.reduce((s, k) => s + k, 0);
 		if (score > bestScore) {
 			best = entry;
@@ -285,14 +281,14 @@ function matchRoute(registry, pathname) {
 		}
 	}
 	return best;
-}
-function extractParams(match, pathname) {
+};
+const extractParams = (match, pathname) => {
 	if (!match) return {};
 	const raw = matchSegments(match.parsed.segments, pathname) ?? {};
 	const out = {};
 	for (const [k, v] of Object.entries(raw)) out[k] = safeDecode(v);
 	return out;
-}
+};
 let _routes = [];
 let _path = "/";
 let _params = {};
@@ -304,123 +300,133 @@ let _lastNavKey = 0;
 const _scrollPositions = /* @__PURE__ */ new Map();
 const _beforeNavigateHooks = [];
 const _afterNavigateHooks = [];
-function snapshot() {
-	return {
-		path: _path,
-		params: _params,
-		search: _search,
-		hash: _hash
-	};
-}
-function routePath() {
-	return _path;
-}
-function routeParams() {
-	return _params;
-}
-function routeSearch() {
-	return _search;
-}
-function routeHash() {
-	return _hash;
-}
-function navigating() {
-	return _navigating;
-}
-function useRoute() {
-	return {
-		path: routePath,
-		params: routeParams,
-		search: routeSearch,
-		hash: routeHash,
-		navigating
+const snapshot = () => ({
+	hash: _hash,
+	params: _params,
+	path: _path,
+	search: _search
+});
+const wrapLayout = (layout, page) => {
+	const Wrapped = () => h(layout, null, h(page, null));
+	return Wrapped;
+};
+const wrapError = (handler, page) => {
+	const Wrapped = async () => {
+		try {
+			const out = page();
+			return out instanceof Promise ? await out : out;
+		} catch (error) {
+			const view = handler(error instanceof RouteError ? {
+				message: error.message,
+				status: error.status
+			} : { message: error instanceof Error ? error.message : String(error) }, snapshot());
+			return isFunction(view) ? view() : view;
+		}
 	};
-}
-function useContext() {
+	return Wrapped;
+};
+const routePath = () => _path;
+const routeParams = () => _params;
+const routeSearch = () => _search;
+const routeHash = () => _hash;
+const navigating = () => _navigating;
+const useRoute = () => ({
+	hash: routeHash,
+	navigating,
+	params: routeParams,
+	path: routePath,
+	search: routeSearch
+});
+const useContext = () => {
 	return { request: globalThis[REQUEST_ALS_KEY]?.getStore?.() };
-}
-function syncFromParts(pathname, search, hash, routes = _routes) {
+};
+const syncFromParts = (pathname, search, hash, routes = _routes) => {
 	_path = pathname || "/";
 	_search = search;
 	_hash = hash;
-	_params = extractParams(matchRoute(routes, _path), _path);
-}
-function syncRouteFromLocation() {
+	const match = matchRoute(routes, _path);
+	_params = extractParams(match, _path);
+};
+const syncRouteFromLocation = () => {
 	const loc = getAdapter().readLocation();
 	syncFromParts(loc.pathname, loc.search, loc.hash);
-}
-function prime() {
+};
+const prime = () => {
 	if (isBrowser) syncRouteFromLocation();
-}
-function beforeNavigate(fn) {
+};
+const beforeNavigate = (fn) => {
 	_beforeNavigateHooks.push(fn);
 	return () => {
 		const i = _beforeNavigateHooks.indexOf(fn);
-		if (i >= 0) _beforeNavigateHooks.splice(i, 1);
+		if (i !== -1) _beforeNavigateHooks.splice(i, 1);
 	};
-}
-function afterNavigate(fn) {
+};
+const afterNavigate = (fn) => {
 	_afterNavigateHooks.push(fn);
 	return () => {
 		const i = _afterNavigateHooks.indexOf(fn);
-		if (i >= 0) _afterNavigateHooks.splice(i, 1);
+		if (i !== -1) _afterNavigateHooks.splice(i, 1);
 	};
-}
-function runAfterNavigateHooks(nav) {
+};
+const runAfterNavigateHooks = (nav) => {
 	for (const fn of _afterNavigateHooks) try {
 		fn(nav);
-	} catch (e) {
-		console.error("[ilha-router] afterNavigate hook threw:", e);
+	} catch (error) {
+		console.error("[ilha-router] afterNavigate hook threw:", error);
 	}
-}
-function currentNavKey() {
-	const state = isBrowser ? history.state : null;
-	const key = state && typeof state === "object" ? state.__ilhaNavKey : void 0;
-	return typeof key === "number" ? key : 0;
-}
-function saveScrollPosition() {
+};
+const currentNavKey = () => {
+	const { state } = isBrowser ? history : { state: null };
+	if (!state || !isObject(state)) return 0;
+	const { __ilhaNavKey: key } = state;
+	return isNumber(key) ? key : 0;
+};
+const saveScrollPosition = () => {
 	if (!isBrowser) return;
 	_scrollPositions.set(_lastNavKey, {
 		x: window.scrollX,
 		y: window.scrollY
 	});
-}
-function scrollAfterNavigate(hash) {
+};
+const scrollAfterNavigate = (hash) => {
 	if (!isBrowser) return;
 	if (hash && hash.length > 1) {
 		const id = hash.slice(1);
-		const el = document.getElementById(id);
+		const el = document.querySelector(`[id=${JSON.stringify(id)}]`);
 		if (el) {
 			el.scrollIntoView();
 			return;
 		}
 	}
 	window.scrollTo(0, 0);
-}
-function restoreScrollPosition() {
+};
+const restoreScrollPosition = () => {
 	const pos = _scrollPositions.get(currentNavKey());
 	if (!pos) return;
 	requestAnimationFrame(() => window.scrollTo(pos.x, pos.y));
-}
-function navigate(to, opts = {}) {
+};
+const navigate = (to, opts = {}) => {
 	if (!isBrowser) return;
 	const adapter = getAdapter();
 	const cur = adapter.readLocation();
 	const current = cur.pathname + cur.search + cur.hash;
 	if (to === current) return;
 	const type = opts.replace ? "replace" : "push";
-	let cancelled = false;
+	const cancelState = { cancelled: false };
+	const cancelNav = () => {
+		cancelState.cancelled = true;
+	};
 	for (const fn of _beforeNavigateHooks) try {
 		fn({
+			cancel: cancelNav,
 			from: current,
 			to,
-			type,
-			cancel: () => cancelled = true
+			type
 		});
-	} catch (e) {
-		console.error("[ilha-router] beforeNavigate hook threw:", e);
+	} catch (error) {
+		console.error("[ilha-router] beforeNavigate hook threw:", error);
 	}
-	if (cancelled) return;
+	if (cancelState.cancelled) return;
 	if (opts.replace) adapter.replace(to, { __ilhaNavKey: currentNavKey() });
 	else {
 		saveScrollPosition();
@@ -434,23 +440,33 @@ function navigate(to, opts = {}) {
 		const dest = adapter.readLocation();
 		const fromMatch = matchRoute(_routes, prevPath);
 		const destMatch = matchRoute(_routes, dest.pathname);
-		if (!(fromMatch?.data.page != null && destMatch?.data.page === fromMatch.data.page) || dest.hash && dest.hash !== "#") scrollAfterNavigate(dest.hash);
+		if (!(fromMatch?.data.page !== null && fromMatch?.data.page !== void 0 && destMatch?.data.page === fromMatch.data.page) || dest.hash && dest.hash !== "#") scrollAfterNavigate(dest.hash);
 	}
 	runAfterNavigateHooks({
 		from: current,
 		to,
 		type
 	});
-}
-function enableLinkInterception(root = document, _options = {}) {
-	if (!isBrowser) return () => {};
+};
+const NON_NAV_SCHEME = /^(?:mailto|tel|javascript):/iu;
+const resolveClickTarget = (_href, url) => {
+	if (getHistoryMode() === "hash") {
+		if (url.hash.startsWith("#/")) return url.hash.slice(1);
+		return url.pathname + url.search;
+	}
+	return url.pathname + url.search + url.hash;
+};
+const enableLinkInterception = (root = document, _options = {}) => {
+	if (!isBrowser) return noop;
 	const clickHandler = (event) => {
-		const e = event;
-		if (e.defaultPrevented || e.button !== 0 || e.metaKey || e.ctrlKey || e.shiftKey || e.altKey) return;
-		const a = e.target?.closest?.("a");
-		if (!a || a.hasAttribute("download") || a.getAttribute("target") === "_blank" || a.hasAttribute("data-no-intercept")) return;
-		const href = a.getAttribute("href");
-		if (!href || /^(mailto|tel|javascript):/i.test(href)) return;
+		const mouseEvent = event;
+		if (mouseEvent.defaultPrevented || mouseEvent.button !== 0 || mouseEvent.metaKey || mouseEvent.ctrlKey || mouseEvent.shiftKey || mouseEvent.altKey) return;
+		const { target } = mouseEvent;
+		if (!(target instanceof Element)) return;
+		const anchor = target.closest("a");
+		if (!anchor || anchor.hasAttribute("download") || anchor.getAttribute("target") === "_blank" || anchor.matches("[data-no-intercept]")) return;
+		const href = anchor.getAttribute("href");
+		if (!href || NON_NAV_SCHEME.test(href)) return;
 		if (href.startsWith("#") && getHistoryMode() !== "hash") return;
 		if (href.startsWith("#") && !href.startsWith("#/")) return;
 		let url;
@@ -460,22 +476,25 @@ function enableLinkInterception(root = document, _options = {}) {
 			return;
 		}
 		if (url.origin !== location.origin) return;
-		e.preventDefault();
-		navigate(getHistoryMode() === "hash" ? url.hash.startsWith("#/") ? url.hash.slice(1) : url.pathname + url.search : url.pathname + url.search + url.hash);
+		mouseEvent.preventDefault();
+		navigate(resolveClickTarget(href, url));
 	};
 	root.addEventListener("click", clickHandler);
 	return () => root.removeEventListener("click", clickHandler);
-}
-function isActive(pattern, options = {}) {
+};
+const isActive = (pattern, options = {}) => {
 	if (options.end) return _path === pattern;
 	if (pattern === "/") return _path === "/";
-	return _path === pattern || _path.startsWith(pattern.endsWith("/") ? pattern : pattern + "/");
-}
-function resolveRedirectTarget(to, base, allowExternal) {
-	if (/[\\\u0000-\u0020]/.test(to)) return { ok: false };
+	return _path === pattern || _path.startsWith(pattern.endsWith("/") ? pattern : `${pattern}/`);
+};
+const resolveRedirectTarget = (to, base, allowExternal) => {
+	for (const ch of to) {
+		const code = ch.codePointAt(0) ?? 0;
+		if (code <= 32 || code === 92) return { ok: false };
+	}
 	try {
 		const u = new URL(to, base);
-		if (!/^https?:$/.test(u.protocol)) return { ok: false };
+		if (!/^https?:$/u.test(u.protocol)) return { ok: false };
 		if (u.origin === base.origin) return {
 			ok: true,
 			to: u.pathname + u.search + u.hash
@@ -487,24 +506,28 @@ function resolveRedirectTarget(to, base, allowExternal) {
 	} catch {
 		return { ok: false };
 	}
-}
-function resolveRequestUrl(urlOrRequest) {
+};
+const resolveRequestUrl = (urlOrRequest) => {
 	try {
 		if (urlOrRequest instanceof Request) return new URL(urlOrRequest.url);
-		return typeof urlOrRequest === "string" ? new URL(urlOrRequest, "http://localhost") : urlOrRequest;
+		if (isString(urlOrRequest)) return new URL(urlOrRequest, "http://localhost");
+		return urlOrRequest;
 	} catch {
 		return new URL("http://localhost/");
 	}
-}
-function pageForPath(pathname, routes, notFound) {
+};
+const pageForPath = (pathname, routes, notFound) => {
 	const match = matchRoute(routes, pathname);
 	if (match) return match.data.page;
 	return notFound;
-}
-async function renderPage(page, opts) {
-	return renderToString(page, opts);
-}
-function router(options = {}) {
+};
+const renderPage = (page, opts) => renderToString(page, opts);
+const buildRespondBody = (result, respondOpts, head) => {
+	const { html } = result;
+	if (respondOpts.shell) return respondOpts.shell(head, html);
+	return html;
+};
+const router = (options = {}) => {
 	const mode = options.mode ?? "spa";
 	const defaultInterceptLinks = options.interceptLinks !== false;
 	const allowExternalRedirects = options.allowExternalRedirects === true;
@@ -517,19 +540,6 @@ function router(options = {}) {
 	let navChangeCleanup = null;
 	let linkCleanup = null;
 	const builder = {
-		route(pattern, page) {
-			const data = {
-				page,
-				pattern
-			};
-			records.push({
-				pattern,
-				page
-			});
-			addRouteEntry(routes, pattern, data);
-			patternToData.set(pattern, data);
-			return builder;
-		},
 		errorBoundary(pattern, handler) {
 			const data = patternToData.get(pattern);
 			if (!data) {
@@ -539,23 +549,27 @@ function router(options = {}) {
 			data.errorHandler = handler;
 			return builder;
 		},
-		routes() {
-			return records.map((r) => ({ ...r }));
+		hydrate(hydrateOpts = {}) {
+			const root = hydrateOpts.root ?? (isBrowser ? document.body : null);
+			if (!root) return noop;
+			return builder.mount(root, {
+				hydrate: true,
+				interceptLinks: hydrateOpts.interceptLinks
+			});
 		},
-		prime,
 		mount(target, { hydrate = false, interceptLinks: mountInterceptLinks } = {}) {
 			if (!isBrowser) {
 				console.warn("[ilha-router] mount() called in a non-browser environment");
-				return () => {};
+				return noop;
 			}
-			const host = typeof target === "string" ? document.querySelector(target) : target;
+			const host = isString(target) ? document.querySelector(target) : target;
 			if (!host) {
 				console.warn(`[ilha-router] No element found for selector "${target}"`);
-				return () => {};
+				return noop;
 			}
 			if (mode === "static") {
 				console.warn("[ilha-router] router.mount() is a no-op in static mode.");
-				return () => {};
+				return noop;
 			}
 			syncRouteFromLocation();
 			_lastNavKey = currentNavKey();
@@ -563,6 +577,25 @@ function router(options = {}) {
 			let mounted = true;
 			const prevScroll = "scrollRestoration" in history ? history.scrollRestoration : null;
 			if (prevScroll !== null) history.scrollRestoration = "manual";
+			let unmountView = null;
+			let headSession = null;
+			const remount = () => {
+				unmountView?.();
+				headSession?.close();
+				headSession = null;
+				const page = pageForPath(_path, routes, notFound);
+				if (!page) {
+					unmountView = null;
+					applyHeadEntriesToDocument([]);
+					return;
+				}
+				const session = openBrowserHead();
+				headSession = session;
+				unmountView = mount(host, page, { hydrate: unmountView === null && hydrate });
+				queueMicrotask(() => {
+					session.flush();
+				});
+			};
 			const popHandler = () => {
 				if (!mounted) return;
 				const prevPath = _path + _search + _hash;
@@ -582,16 +615,6 @@ function router(options = {}) {
 			};
 			navChangeCleanup = getAdapter().onChange(popHandler);
 			linkCleanup = mountInterceptLinks ?? defaultInterceptLinks ? enableLinkInterception(document) : null;
-			let unmountView = null;
-			const remount = () => {
-				unmountView?.();
-				const page = pageForPath(_path, routes, notFound);
-				if (!page) {
-					unmountView = null;
-					return;
-				}
-				unmountView = mount(host, page, { hydrate: unmountView == null && hydrate });
-			};
 			remount();
 			const offNav = afterNavigate(() => {
 				if (mounted) remount();
@@ -600,18 +623,21 @@ function router(options = {}) {
 				mounted = false;
 				offNav();
 				unmountView?.();
+				headSession?.close();
+				headSession = null;
 				navChangeCleanup?.();
 				linkCleanup?.();
 				if (prevScroll !== null) history.scrollRestoration = prevScroll;
 			};
 		},
-		async render(url, options) {
-			const result = await builder.renderResponse(url, options);
+		prime,
+		async render(url, renderOpts) {
+			const result = await builder.renderResponse(url, renderOpts);
 			if (result.kind === "html") return result.html;
 			if (result.kind === "redirect") return "";
 			return result.html;
 		},
-		async renderResponse(url, options) {
+		async renderResponse(url, renderOpts) {
 			const parsed = resolveRequestUrl(url);
 			syncFromParts(parsed.pathname, parsed.search, parsed.hash, routes);
 			const store = { entries: [] };
@@ -622,80 +648,88 @@ function router(options = {}) {
 				const wrapped = async () => {
 					try {
 						return await Promise.resolve(page());
-					} catch (err) {
-						captured = err;
-						throw err;
+					} catch (error) {
+						captured = error;
+						throw error;
 					}
 				};
-				const html = await withHeadStore(store, () => renderPage(wrapped, options));
+				const html = await withHeadStore(store, () => renderPage(wrapped, renderOpts));
 				if (captured instanceof Redirect || captured instanceof RouteError) throw captured;
 				return {
-					kind: "html",
+					head: serializeHead(store.entries),
 					html,
-					status: 200,
-					head: serializeHead(store.entries)
+					kind: "html",
+					status: 200
 				};
-			} catch (e) {
-				if (e instanceof Redirect) {
-					const safe = resolveRedirectTarget(e.to, parsed, allowExternalRedirects);
+			} catch (error) {
+				if (error instanceof Redirect) {
+					const safe = resolveRedirectTarget(error.to, parsed, allowExternalRedirects);
 					if (!safe.ok) return {
+						head: EMPTY_HEAD,
+						html: "",
 						kind: "error",
-						status: 500,
 						message: "unsafe redirect target",
-						html: "",
-						head: EMPTY_HEAD
+						status: 500
 					};
 					return {
 						kind: "redirect",
-						to: safe.to,
-						status: e.status
+						status: error.status,
+						to: safe.to
 					};
 				}
-				if (e instanceof RouteError) {
+				if (error instanceof RouteError) {
 					const boundary = matchRoute(routes, parsed.pathname)?.data.errorHandler;
 					let html = "";
 					if (boundary) {
 						const view = boundary({
-							message: e.message,
-							status: e.status
+							message: error.message,
+							status: error.status
 						}, snapshot());
-						html = await renderPage(typeof view === "function" ? view : async () => view, options);
+						html = await renderPage(isFunction(view) ? view : () => view, renderOpts);
 					}
 					return {
-						kind: "error",
-						status: e.status,
-						message: e.message,
+						head: serializeHead(store.entries),
 						html,
-						head: serializeHead(store.entries)
+						kind: "error",
+						message: error.message,
+						status: error.status
 					};
 				}
-				throw e;
+				throw error;
 			}
 		},
-		async respond(url, options = {}) {
-			const result = await builder.renderResponse(url, options);
+		async respond(url, respondOpts = {}) {
+			const result = await builder.renderResponse(url, respondOpts);
 			if (result.kind === "redirect") return Response.redirect(result.to, result.status);
 			const head = result.head ?? EMPTY_HEAD;
 			if (isBrowser && result.kind === "html") applyHeadEntriesToDocument([]);
-			const body = options.shell ? options.shell(head, result.kind === "html" ? result.html : result.html) : result.kind === "html" ? result.html : result.html;
+			const body = buildRespondBody(result, respondOpts, head);
 			return httpResponse(body, {
-				status: result.kind === "error" ? result.status : result.status ?? 200,
-				headers: options.headers,
-				cspNonce: options.cspNonce,
-				contentSecurityPolicy: options.contentSecurityPolicy
+				contentSecurityPolicy: respondOpts.contentSecurityPolicy,
+				cspNonce: respondOpts.cspNonce,
+				headers: respondOpts.headers,
+				status: result.kind === "error" ? result.status : result.status ?? 200
 			});
 		},
-		hydrate(opts = {}) {
-			const root = opts.root ?? (isBrowser ? document.body : null);
-			if (!root) return () => {};
-			return builder.mount(root, {
-				hydrate: true,
-				interceptLinks: opts.interceptLinks
+		route(pattern, page) {
+			const data = {
+				page,
+				pattern
+			};
+			records.push({
+				page,
+				pattern
 			});
+			addRouteEntry(routes, pattern, data);
+			patternToData.set(pattern, data);
+			return builder;
+		},
+		routes() {
+			return records.map((r) => ({ ...r }));
 		}
 	};
 	return builder;
-}
+};
 
 //#endregion
-export { EMPTY_HEAD, Redirect, RouteError, afterNavigate, beforeNavigate, defineLayout, enableLinkInterception, error, getHistoryMode, head, httpResponse, isActive, navigate, navigating, prime, redirect, resolveRedirectTarget, routeHash, routeParams, routePath, routeSearch, router, serializeHead, setHistoryMode, useContext, useRoute, wrapError, wrapLayout };
+export { EMPTY_HEAD, Redirect, RouteError, afterNavigate, beforeNavigate, defineLayout, enableLinkInterception, throwAppError as error, getHistoryMode, head, httpResponse, isActive, navigate, navigating, prime, redirect, resolveRedirectTarget, routeHash, routeParams, routePath, routeSearch, router, serializeHead, setHistoryMode, useContext, useRoute, wrapError, wrapLayout };