@ilha/router 0.10.4 → 0.11.1

package/dist/index.js

@@ -1,4 +1,701 @@
-import { A as wrapLayout, C as routePath, D as useContext, E as src_default, F as getHistoryMode, I as setHistoryMode, O as useRoute, P as httpResponse, S as routeParams, T as router, _ as prefetch, a as RouterView, b as resolveRedirectTarget, c as composeLoaders, d as error, f as invalidate, g as navigating, h as navigate, i as RouterLink, k as wrapError, l as defineLayout, m as loader, n as LoaderError, o as afterNavigate, p as isActive, r as Redirect, s as beforeNavigate, t as LOADER_ENDPOINT, u as enableLinkInterception, v as prime, w as routeSearch, x as routeHash, y as redirect } from "./src-PCXNZfql.js";
-import { o as head, s as serializeHead } from "./snapshot-CsEaY6h_.js";
+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 { h, mount, renderToString } from "ilha";
 
-export { LOADER_ENDPOINT, LoaderError, Redirect, RouterLink, RouterView, afterNavigate, beforeNavigate, composeLoaders, src_default as default, defineLayout, enableLinkInterception, error, getHistoryMode, head, httpResponse, invalidate, isActive, loader, navigate, navigating, prefetch, prime, redirect, resolveRedirectTarget, routeHash, routeParams, routePath, routeSearch, router, serializeHead, setHistoryMode, useContext, useRoute, wrapError, wrapLayout };
+//#region src/hash.ts
+const isBrowser$1 = typeof window !== "undefined" && typeof document !== "undefined";
+const historyAdapter = {
+	readLocation() {
+		if (!isBrowser$1) return {
+			pathname: "/",
+			search: "",
+			hash: ""
+		};
+		return {
+			pathname: location.pathname,
+			search: location.search,
+			hash: location.hash
+		};
+	},
+	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 stripped = rawHash.startsWith("#") ? rawHash.slice(1) : rawHash;
+	const path = stripped === "" ? "/" : stripped.startsWith("/") ? stripped : "/" + stripped;
+	const u = new URL(path, "http://_");
+	return {
+		pathname: u.pathname,
+		search: u.search,
+		hash: u.hash
+	};
+}
+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 (href.startsWith("#")) {
+			const inner = href.slice(1);
+			if (inner === "" || !inner.startsWith("/")) return null;
+			return inner;
+		}
+		if (/^https?:\/\//i.test(href)) try {
+			const u = new URL(href);
+			if (u.origin !== location.origin) return null;
+			if (!u.hash || u.hash === "#") return null;
+			const inner = u.hash.slice(1);
+			if (!inner.startsWith("/")) return null;
+			return inner;
+		} catch {
+			return null;
+		}
+		return href;
+	}
+};
+let _mode = "history";
+let _adapter = historyAdapter;
+/**
+* Set the router's history mode. Call this once at app entry, before
+* mounting any router. Defaults to "history" (HTML5 History API).
+*
+* Use "hash" when the document is loaded over file:// (Electron, Tauri, etc.)
+* or any time there's no server able to serve a SPA fallback at arbitrary
+* pathnames.
+*
+* Switching modes mid-session is supported but not common — listeners
+* registered before the switch will keep using their original adapter
+* until they're re-attached (typically by unmounting and remounting
+* the router).
+*/
+function setHistoryMode(mode) {
+	_mode = mode;
+	_adapter = mode === "hash" ? hashAdapter : historyAdapter;
+}
+function getHistoryMode() {
+	return _mode;
+}
+/** Internal — used by index.ts. Not part of the public API. */
+function getAdapter() {
+	return _adapter;
+}
+
+//#endregion
+//#region src/http.ts
+/**
+* Build an HTTP `Response` for SSR output with sensible security headers:
+* `Content-Type: text/html`, `X-Content-Type-Options: nosniff`,
+* `Referrer-Policy`, `Cache-Control: no-store`, and an optional CSP. This is
+* a low-level helper — prefer {@link RouterBuilder.respond} for the full
+* render+head+headers pipeline.
+*/
+function 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 (!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
+	});
+}
+const EMPTY_HEAD = {
+	headTags: "",
+	htmlAttrs: "",
+	bodyAttrs: ""
+};
+/**
+* Options for {@link RouterBuilder.respond}.
+*/
+
+//#endregion
+//#region src/route-match.ts
+function parsePattern(pattern) {
+	const segments = pattern.split("/").filter(Boolean);
+	return {
+		segments,
+		kinds: segments.map((segment) => segment.startsWith("*") ? 0 : segment.startsWith(":") ? 1 : 2)
+	};
+}
+/**
+* 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 pathSegments = pathname.split("/").filter(Boolean);
+	const params = {};
+	let cursor = 0;
+	for (let i = 0; i < segments.length; i++) {
+		const segment = segments[i];
+		const isLast = i === segments.length - 1;
+		if (segment.startsWith("**") && isLast) {
+			const name = segment.slice(2).replace(/^:/, "");
+			if (name) params[name] = pathSegments.slice(cursor).join("/");
+			cursor = pathSegments.length;
+			break;
+		}
+		if (segment.startsWith("*")) {
+			if (pathSegments[cursor] === void 0) return null;
+			cursor++;
+			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++;
+		else return null;
+	}
+	return cursor === pathSegments.length ? params : null;
+}
+/** Decode a route-param value, tolerating malformed percent-encoding. */
+function safeDecode(value) {
+	try {
+		return decodeURIComponent(value);
+	} catch {
+		return value;
+	}
+}
+
+//#endregion
+//#region src/index.ts
+const isBrowser = typeof window !== "undefined" && typeof document !== "undefined";
+var Redirect = class {
+	__ilhaRedirect = true;
+	to;
+	status;
+	constructor(to, status = 302) {
+		this.to = to;
+		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) {
+	throw new Redirect(to, status);
+}
+function error(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) {
+	registry.push({
+		pattern,
+		parsed: parsePattern(pattern),
+		data
+	});
+}
+function matchRoute(registry, pathname) {
+	let best = null;
+	let bestScore = -1;
+	for (const entry of registry) {
+		if (matchSegments(entry.parsed.segments, pathname) == null) continue;
+		const score = entry.parsed.kinds.reduce((s, k) => s + k, 0);
+		if (score > bestScore) {
+			best = entry;
+			bestScore = score;
+		}
+	}
+	return best;
+}
+function 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 = {};
+let _search = "";
+let _hash = "";
+const _navigating = false;
+let _navKeyCounter = 0;
+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
+	};
+}
+function useContext() {
+	return { request: globalThis[REQUEST_ALS_KEY]?.getStore?.() };
+}
+function syncFromParts(pathname, search, hash, routes = _routes) {
+	_path = pathname || "/";
+	_search = search;
+	_hash = hash;
+	_params = extractParams(matchRoute(routes, _path), _path);
+}
+function syncRouteFromLocation() {
+	const loc = getAdapter().readLocation();
+	syncFromParts(loc.pathname, loc.search, loc.hash);
+}
+function prime() {
+	if (isBrowser) syncRouteFromLocation();
+}
+function beforeNavigate(fn) {
+	_beforeNavigateHooks.push(fn);
+	return () => {
+		const i = _beforeNavigateHooks.indexOf(fn);
+		if (i >= 0) _beforeNavigateHooks.splice(i, 1);
+	};
+}
+function afterNavigate(fn) {
+	_afterNavigateHooks.push(fn);
+	return () => {
+		const i = _afterNavigateHooks.indexOf(fn);
+		if (i >= 0) _afterNavigateHooks.splice(i, 1);
+	};
+}
+function runAfterNavigateHooks(nav) {
+	for (const fn of _afterNavigateHooks) try {
+		fn(nav);
+	} catch (e) {
+		console.error("[ilha-router] afterNavigate hook threw:", e);
+	}
+}
+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() {
+	if (!isBrowser) return;
+	_scrollPositions.set(_lastNavKey, {
+		x: window.scrollX,
+		y: window.scrollY
+	});
+}
+function scrollAfterNavigate(hash) {
+	if (!isBrowser) return;
+	if (hash && hash.length > 1) {
+		const id = hash.slice(1);
+		const el = document.getElementById(id);
+		if (el) {
+			el.scrollIntoView();
+			return;
+		}
+	}
+	window.scrollTo(0, 0);
+}
+function restoreScrollPosition() {
+	const pos = _scrollPositions.get(currentNavKey());
+	if (!pos) return;
+	requestAnimationFrame(() => window.scrollTo(pos.x, pos.y));
+}
+function 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;
+	for (const fn of _beforeNavigateHooks) try {
+		fn({
+			from: current,
+			to,
+			type,
+			cancel: () => cancelled = true
+		});
+	} catch (e) {
+		console.error("[ilha-router] beforeNavigate hook threw:", e);
+	}
+	if (cancelled) return;
+	if (opts.replace) adapter.replace(to, { __ilhaNavKey: currentNavKey() });
+	else {
+		saveScrollPosition();
+		_navKeyCounter = Math.max(_navKeyCounter + 1, currentNavKey() + 1);
+		adapter.push(to, { __ilhaNavKey: _navKeyCounter });
+	}
+	_lastNavKey = currentNavKey();
+	const prevPath = cur.pathname;
+	syncRouteFromLocation();
+	if (opts.scroll !== false) {
+		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);
+	}
+	runAfterNavigateHooks({
+		from: current,
+		to,
+		type
+	});
+}
+function enableLinkInterception(root = document, _options = {}) {
+	if (!isBrowser) return () => {};
+	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;
+		if (href.startsWith("#") && getHistoryMode() !== "hash") return;
+		if (href.startsWith("#") && !href.startsWith("#/")) return;
+		let url;
+		try {
+			url = new URL(href, location.href);
+		} catch {
+			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);
+	};
+	root.addEventListener("click", clickHandler);
+	return () => root.removeEventListener("click", clickHandler);
+}
+function 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 };
+	try {
+		const u = new URL(to, base);
+		if (!/^https?:$/.test(u.protocol)) return { ok: false };
+		if (u.origin === base.origin) return {
+			ok: true,
+			to: u.pathname + u.search + u.hash
+		};
+		return allowExternal ? {
+			ok: true,
+			to: u.href
+		} : { ok: false };
+	} catch {
+		return { ok: false };
+	}
+}
+function resolveRequestUrl(urlOrRequest) {
+	try {
+		if (urlOrRequest instanceof Request) return new URL(urlOrRequest.url);
+		return typeof urlOrRequest === "string" ? new URL(urlOrRequest, "http://localhost") : urlOrRequest;
+	} catch {
+		return new URL("http://localhost/");
+	}
+}
+function 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 mode = options.mode ?? "spa";
+	const defaultInterceptLinks = options.interceptLinks !== false;
+	const allowExternalRedirects = options.allowExternalRedirects === true;
+	const records = [];
+	const routes = createRouteRegistry();
+	const patternToData = /* @__PURE__ */ new Map();
+	const notFound = options.notFound ?? null;
+	_routes = routes;
+	options.viewTransitions;
+	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) {
+				console.warn(`[ilha-router] errorBoundary("${pattern}"): pattern was never registered via .route().`);
+				return builder;
+			}
+			data.errorHandler = handler;
+			return builder;
+		},
+		routes() {
+			return records.map((r) => ({ ...r }));
+		},
+		prime,
+		mount(target, { hydrate = false, interceptLinks: mountInterceptLinks } = {}) {
+			if (!isBrowser) {
+				console.warn("[ilha-router] mount() called in a non-browser environment");
+				return () => {};
+			}
+			const host = typeof target === "string" ? document.querySelector(target) : target;
+			if (!host) {
+				console.warn(`[ilha-router] No element found for selector "${target}"`);
+				return () => {};
+			}
+			if (mode === "static") {
+				console.warn("[ilha-router] router.mount() is a no-op in static mode.");
+				return () => {};
+			}
+			syncRouteFromLocation();
+			_lastNavKey = currentNavKey();
+			if (hydrate && getHistoryMode() === "hash") console.warn("[ilha-router] mount({ hydrate: true }) was called in hash mode. The server never sees the hash, so SSR HTML is for '/'.");
+			let mounted = true;
+			const prevScroll = "scrollRestoration" in history ? history.scrollRestoration : null;
+			if (prevScroll !== null) history.scrollRestoration = "manual";
+			const popHandler = () => {
+				if (!mounted) return;
+				const prevPath = _path + _search + _hash;
+				_scrollPositions.set(_lastNavKey, {
+					x: window.scrollX,
+					y: window.scrollY
+				});
+				_lastNavKey = currentNavKey();
+				syncRouteFromLocation();
+				restoreScrollPosition();
+				runAfterNavigateHooks({
+					from: prevPath,
+					to: _path + _search + _hash,
+					type: "pop"
+				});
+				remount();
+			};
+			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();
+			});
+			return () => {
+				mounted = false;
+				offNav();
+				unmountView?.();
+				navChangeCleanup?.();
+				linkCleanup?.();
+				if (prevScroll !== null) history.scrollRestoration = prevScroll;
+			};
+		},
+		async render(url, options) {
+			const result = await builder.renderResponse(url, options);
+			if (result.kind === "html") return result.html;
+			if (result.kind === "redirect") return "";
+			return result.html;
+		},
+		async renderResponse(url, options) {
+			const parsed = resolveRequestUrl(url);
+			syncFromParts(parsed.pathname, parsed.search, parsed.hash, routes);
+			const store = { entries: [] };
+			try {
+				const page = pageForPath(parsed.pathname, routes, notFound);
+				if (!page) throw new RouteError(404, "Not found");
+				let captured;
+				const wrapped = async () => {
+					try {
+						return await Promise.resolve(page());
+					} catch (err) {
+						captured = err;
+						throw err;
+					}
+				};
+				const html = await withHeadStore(store, () => renderPage(wrapped, options));
+				if (captured instanceof Redirect || captured instanceof RouteError) throw captured;
+				return {
+					kind: "html",
+					html,
+					status: 200,
+					head: serializeHead(store.entries)
+				};
+			} catch (e) {
+				if (e instanceof Redirect) {
+					const safe = resolveRedirectTarget(e.to, parsed, allowExternalRedirects);
+					if (!safe.ok) return {
+						kind: "error",
+						status: 500,
+						message: "unsafe redirect target",
+						html: "",
+						head: EMPTY_HEAD
+					};
+					return {
+						kind: "redirect",
+						to: safe.to,
+						status: e.status
+					};
+				}
+				if (e instanceof RouteError) {
+					const boundary = matchRoute(routes, parsed.pathname)?.data.errorHandler;
+					let html = "";
+					if (boundary) {
+						const view = boundary({
+							message: e.message,
+							status: e.status
+						}, snapshot());
+						html = await renderPage(typeof view === "function" ? view : async () => view, options);
+					}
+					return {
+						kind: "error",
+						status: e.status,
+						message: e.message,
+						html,
+						head: serializeHead(store.entries)
+					};
+				}
+				throw e;
+			}
+		},
+		async respond(url, options = {}) {
+			const result = await builder.renderResponse(url, options);
+			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;
+			return httpResponse(body, {
+				status: result.kind === "error" ? result.status : result.status ?? 200,
+				headers: options.headers,
+				cspNonce: options.cspNonce,
+				contentSecurityPolicy: options.contentSecurityPolicy
+			});
+		},
+		hydrate(opts = {}) {
+			const root = opts.root ?? (isBrowser ? document.body : null);
+			if (!root) return () => {};
+			return builder.mount(root, {
+				hydrate: true,
+				interceptLinks: opts.interceptLinks
+			});
+		}
+	};
+	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 };