@pracht/core 0.8.0 → 0.9.0

package/dist/router-E5Wh-dOR.mjs

@@ -0,0 +1,694 @@
+import { o as matchAppRoute, t as buildHref } from "./app-CGRKjZ6Z.mjs";
+import { c as fetchPrachtRouteState, d as routeNeedsServerFetch, i as getCachedRouteState, u as parseSafeNavigationUrl } from "./prefetch-cache-BNLEp9H5.mjs";
+import { a as settleNavigation, p as deserializeRouteError, r as createNavigationLocation, s as PrachtRuntimeProvider, t as beginLoadingNavigation } from "./navigation-state-BjwXTeVz.mjs";
+import { r as registerPrefetchTarget } from "./prefetch-api-ChSCTbEB.mjs";
+import { createContext, h, hydrate, options, render } from "preact";
+import { useContext, useEffect, useLayoutEffect, useMemo, useState } from "preact/hooks";
+import { Suspense } from "preact-suspense";
+//#region src/hydration.ts
+const MODE_HYDRATE$1 = 32;
+let _hydrating = false;
+let _suspensionCount = 0;
+let _hydrated = false;
+new Suspense({});
+const oldCatchError = options.__e;
+options.__e = (err, newVNode, oldVNode, errorInfo) => {
+	if (_hydrating && !_hydrated && err && err.then) {
+		if (!!(newVNode && newVNode.__u && newVNode.__u & MODE_HYDRATE$1) || !!(newVNode && newVNode.__h)) {
+			_suspensionCount++;
+			let settled = false;
+			const onSettled = () => {
+				if (settled) return;
+				settled = true;
+				_suspensionCount--;
+			};
+			err.then(onSettled, onSettled);
+		}
+	}
+	if (oldCatchError) oldCatchError(err, newVNode, oldVNode, errorInfo);
+};
+const oldCommit = options.__c;
+options.__c = (vnode, commitQueue) => {
+	if (_hydrating && !_hydrated && _suspensionCount <= 0) {
+		_hydrated = true;
+		_hydrating = false;
+	}
+	if (oldCommit) oldCommit(vnode, commitQueue);
+};
+/**
+* Mark the start of a hydration pass. Call this right before `hydrate()`.
+*/
+function markHydrating() {
+	if (!_hydrated) _hydrating = true;
+}
+/**
+* Returns `true` once the initial hydration (including all Suspense
+* boundaries) has fully resolved. During SSR and hydration this returns
+* `false`.
+*/
+function useIsHydrated() {
+	const [hydrated, setHydrated] = useState(_hydrated);
+	useEffect(() => {
+		setHydrated(true);
+	}, []);
+	return hydrated;
+}
+//#endregion
+//#region src/hydration-mismatch.ts
+const HYDRATION_BANNER_ID = "__pracht_hydration_mismatch__";
+const MODE_HYDRATE = 32;
+let installed = false;
+let prevMismatch;
+let prevCatchError;
+let prevCommit;
+const pendingSuspenseChecks = /* @__PURE__ */ new Set();
+let flushScheduled = false;
+function installHydrationMismatchWarning() {
+	if (installed) return;
+	installed = true;
+	const opts = options;
+	prevMismatch = opts.__m;
+	prevCatchError = opts.__e;
+	prevCommit = opts.__c;
+	opts.__m = function(vnode) {
+		appendHydrationWarning(vnode);
+		if (prevMismatch) prevMismatch(vnode);
+	};
+	opts.__e = function(err, newVNode, oldVNode, errorInfo) {
+		trackSuspendingVNode(err, newVNode);
+		if (prevCatchError) prevCatchError(err, newVNode, oldVNode, errorInfo);
+	};
+	opts.__c = function(vnode, commitQueue) {
+		if (prevCommit) prevCommit(vnode, commitQueue);
+		scheduleSuspenseCheckFlush();
+	};
+}
+function trackSuspendingVNode(err, vnode) {
+	if (!vnode) return;
+	if (!err || typeof err.then !== "function") return;
+	if (!!!(vnode.__u && vnode.__u & MODE_HYDRATE || vnode.__h)) return;
+	const promise = err;
+	const onSettle = () => {
+		pendingSuspenseChecks.add(vnode);
+	};
+	promise.then(onSettle, onSettle);
+}
+function scheduleSuspenseCheckFlush() {
+	if (flushScheduled) return;
+	if (pendingSuspenseChecks.size === 0) return;
+	flushScheduled = true;
+	queueMicrotask(flushSuspenseChecks);
+}
+function flushSuspenseChecks() {
+	flushScheduled = false;
+	if (pendingSuspenseChecks.size === 0) return;
+	const checks = Array.from(pendingSuspenseChecks);
+	pendingSuspenseChecks.clear();
+	for (const vnode of checks) {
+		const rendered = currentVNode(vnode);
+		const count = countTopLevelDomNodes(rendered);
+		if (count !== 1) appendSuspenseOffsetWarning(pickReportableVNode(rendered), count);
+	}
+}
+function currentVNode(vnode) {
+	return vnode.__c?.__v ?? vnode;
+}
+function pickReportableVNode(vnode) {
+	let current = vnode;
+	for (let depth = 0; depth < 4; depth++) {
+		if (!isLazyWrapperVNode(current)) break;
+		const children = current.__k;
+		if (!Array.isArray(children) || children.length !== 1) break;
+		const child = children[0];
+		if (!child || typeof child.type !== "function") break;
+		current = currentVNode(child);
+	}
+	return current;
+}
+function isLazyWrapperVNode(vnode) {
+	const type = vnode.type;
+	if (typeof type !== "function") return false;
+	const fn = type;
+	return fn.displayName === "Lazy" || fn.name === "Lazy";
+}
+function countTopLevelDomNodes(vnode) {
+	if (!vnode || typeof vnode !== "object") return 0;
+	const type = vnode.type;
+	if (type === null) return 1;
+	if (typeof type === "string") return 1;
+	const children = vnode.__k;
+	if (!Array.isArray(children)) return 0;
+	let total = 0;
+	for (const child of children) total += countTopLevelDomNodes(child);
+	return total;
+}
+function appendSuspenseOffsetWarning(vnode, count) {
+	if (typeof document === "undefined") return;
+	appendBannerMessage(`Suspense boundary resolved during hydration: <${getVNodeName(vnode)}> ${count === 0 ? "rendered 0 DOM nodes" : `rendered ${count} DOM nodes`}. Components that unsuspend during hydration must render exactly one DOM node — otherwise sibling offsets can drift and later updates may bind to the wrong nodes.`);
+}
+function appendHydrationWarning(vnode) {
+	appendBannerMessage(`Hydration mismatch detected on <${getVNodeName(vnode)}>. The server-rendered HTML did not match the client.`);
+}
+function appendBannerMessage(message) {
+	if (typeof document === "undefined") return;
+	let banner = document.getElementById(HYDRATION_BANNER_ID);
+	if (banner) {
+		const list = banner.querySelector(`[data-pracht-mismatch-list]`);
+		if (list) {
+			const item = document.createElement("li");
+			item.textContent = message;
+			list.appendChild(item);
+		}
+		return;
+	}
+	banner = document.createElement("div");
+	banner.id = HYDRATION_BANNER_ID;
+	banner.setAttribute("role", "alert");
+	banner.style.cssText = [
+		"position:fixed",
+		"top:0",
+		"left:0",
+		"right:0",
+		"z-index:2147483647",
+		"background:#1a1a2e",
+		"color:#ff6b6b",
+		"padding:12px 16px",
+		"font:12px/1.5 ui-monospace,Menlo,Consolas,monospace",
+		"border-bottom:2px solid #e74c3c",
+		"box-shadow:0 2px 8px rgba(0,0,0,0.3)"
+	].join(";");
+	const title = document.createElement("strong");
+	title.textContent = "pracht: hydration mismatch";
+	title.style.cssText = "display:block;margin-bottom:4px;color:#fff";
+	banner.appendChild(title);
+	const list = document.createElement("ul");
+	list.setAttribute("data-pracht-mismatch-list", "");
+	list.style.cssText = "margin:0;padding-left:18px";
+	const item = document.createElement("li");
+	item.textContent = message;
+	list.appendChild(item);
+	banner.appendChild(list);
+	document.body.appendChild(banner);
+}
+function getVNodeName(vnode) {
+	if (!vnode) return "Unknown";
+	const type = vnode.type;
+	if (typeof type === "string") return type;
+	if (typeof type === "function") {
+		const fn = type;
+		return fn.displayName || fn.name || "Component";
+	}
+	return "Unknown";
+}
+//#endregion
+//#region src/scroll-restoration.ts
+const STORAGE_KEY = "pracht:scroll-positions";
+const MAX_SCROLL_ENTRIES = 50;
+const HISTORY_STATE_KEY = "__prachtScrollKey";
+function readEntries(storage) {
+	if (!storage) return [];
+	let raw = null;
+	try {
+		raw = storage.getItem(STORAGE_KEY);
+	} catch {
+		return [];
+	}
+	if (!raw) return [];
+	try {
+		const parsed = JSON.parse(raw);
+		if (!Array.isArray(parsed)) return [];
+		return parsed.filter((entry) => Array.isArray(entry) && typeof entry[0] === "string" && typeof entry[1] === "number" && typeof entry[2] === "number");
+	} catch {
+		return [];
+	}
+}
+/**
+* Create a scroll position store backed by the given storage (normally
+* `sessionStorage`). Storage failures (private mode, quota) degrade to an
+* in-memory map for the current page lifetime.
+*/
+function createScrollPositionStore(storage, maxEntries = MAX_SCROLL_ENTRIES) {
+	const positions = /* @__PURE__ */ new Map();
+	for (const [key, x, y] of readEntries(storage)) positions.set(key, {
+		x,
+		y
+	});
+	function persist() {
+		if (!storage) return;
+		const entries = [];
+		for (const [key, position] of positions) entries.push([
+			key,
+			position.x,
+			position.y
+		]);
+		try {
+			storage.setItem(STORAGE_KEY, JSON.stringify(entries));
+		} catch {}
+	}
+	return {
+		get(key) {
+			return positions.get(key) ?? null;
+		},
+		set(key, position) {
+			positions.delete(key);
+			positions.set(key, position);
+			while (positions.size > maxEntries) {
+				const oldest = positions.keys().next();
+				if (oldest.done) break;
+				positions.delete(oldest.value);
+			}
+			persist();
+		}
+	};
+}
+function getSessionScrollStorage() {
+	if (typeof window === "undefined") return null;
+	try {
+		return window.sessionStorage ?? null;
+	} catch {
+		return null;
+	}
+}
+function generateScrollKey() {
+	return Math.random().toString(36).slice(2, 10);
+}
+/** Read the pracht scroll key from a `history.state` value, if present. */
+function readScrollKeyFromHistoryState(state) {
+	if (!state || typeof state !== "object") return null;
+	const key = state[HISTORY_STATE_KEY];
+	return typeof key === "string" ? key : null;
+}
+/** Merge the pracht scroll key into an existing `history.state` value. */
+function withScrollKeyInHistoryState(state, key) {
+	if (state && typeof state === "object" && !Array.isArray(state)) return {
+		...state,
+		[HISTORY_STATE_KEY]: key
+	};
+	return { [HISTORY_STATE_KEY]: key };
+}
+//#endregion
+//#region src/router.ts
+const NavigateContext = createContext(async () => {});
+function useNavigate() {
+	return useContext(NavigateContext);
+}
+async function initClientRouter(options) {
+	const { app, routeModules, shellModules, root, findModuleKey } = options;
+	if (import.meta.env?.DEV) installHydrationMismatchWarning();
+	const moduleCache = /* @__PURE__ */ new Map();
+	function loadModule(modules, key) {
+		let cached = moduleCache.get(key);
+		if (!cached) {
+			cached = modules[key]();
+			moduleCache.set(key, cached);
+		}
+		return cached;
+	}
+	function startRouteImport(match) {
+		const routeKey = findModuleKey(routeModules, match.route.file);
+		if (!routeKey) return null;
+		return loadModule(routeModules, routeKey);
+	}
+	function startShellImport(match) {
+		if (!match.route.shellFile) return null;
+		const shellKey = findModuleKey(shellModules, match.route.shellFile);
+		if (!shellKey) return null;
+		return loadModule(shellModules, shellKey);
+	}
+	let updateRouteState = null;
+	let routeStateVersion = 0;
+	let latestNavigationId = 0;
+	let activeNavigationAbort = null;
+	const scrollStore = createScrollPositionStore(getSessionScrollStorage());
+	if ("scrollRestoration" in history) history.scrollRestoration = "manual";
+	let currentScrollKey = readScrollKeyFromHistoryState(history.state) ?? "";
+	const hadExistingScrollKey = currentScrollKey !== "";
+	if (!hadExistingScrollKey) {
+		currentScrollKey = generateScrollKey();
+		try {
+			history.replaceState(withScrollKeyInHistoryState(history.state, currentScrollKey), "", window.location.href);
+		} catch {}
+	}
+	function saveScrollPosition() {
+		scrollStore.set(currentScrollKey, {
+			x: window.scrollX,
+			y: window.scrollY
+		});
+	}
+	window.addEventListener("pagehide", saveScrollPosition);
+	function restoreOrResetScroll(opts, browserUrl) {
+		if (opts?.preserveScroll) return;
+		if (opts?._popstate) {
+			const saved = scrollStore.get(currentScrollKey);
+			window.scrollTo(saved?.x ?? 0, saved?.y ?? 0);
+			return;
+		}
+		const hashIndex = browserUrl.indexOf("#");
+		if (hashIndex !== -1) {
+			let id = browserUrl.slice(hashIndex + 1);
+			try {
+				id = decodeURIComponent(id);
+			} catch {}
+			const hashTarget = id ? document.getElementById(id) : null;
+			if (hashTarget && typeof hashTarget.scrollIntoView === "function") {
+				hashTarget.scrollIntoView();
+				return;
+			}
+		}
+		window.scrollTo(0, 0);
+	}
+	let afterCommitCallback = null;
+	function RouterRoot({ initialState }) {
+		const [routeState, setRouteState] = useState(initialState);
+		updateRouteState = setRouteState;
+		const navigateValue = useMemo(() => navigate, []);
+		const { Shell, Component, componentProps, data, params, routeId, url, version } = routeState;
+		useLayoutEffect(() => {
+			if (!afterCommitCallback) return;
+			const callback = afterCommitCallback;
+			afterCommitCallback = null;
+			callback();
+		}, [version]);
+		const componentTree = Shell ? h(Shell, null, h(Component, componentProps)) : h(Component, componentProps);
+		return h(NavigateContext.Provider, { value: navigateValue }, h(PrachtRuntimeProvider, {
+			data,
+			params,
+			routeId,
+			routes: app.routes,
+			stateVersion: version,
+			url
+		}, componentTree));
+	}
+	function applyRouteState(routeState) {
+		if (updateRouteState) {
+			updateRouteState(routeState);
+			return;
+		}
+		render(h(RouterRoot, { initialState: routeState }), root);
+	}
+	async function resolveRouteState(match, state, currentUrl, routeModPromise, shellModPromise) {
+		const routeMod = await (routeModPromise ?? startRouteImport(match));
+		if (!routeMod) return null;
+		let Shell = null;
+		const resolvedShell = await (shellModPromise ?? startShellImport(match));
+		if (resolvedShell) Shell = resolvedShell.Shell;
+		const DefaultComponent = typeof routeMod.default === "function" ? routeMod.default : void 0;
+		const ErrorBoundary = routeMod.ErrorBoundary ?? resolvedShell?.ErrorBoundary;
+		const Component = state.error ? ErrorBoundary : routeMod.Component ?? DefaultComponent;
+		if (!Component) return null;
+		const componentProps = state.error ? { error: deserializeRouteError(state.error) } : {
+			data: state.data,
+			params: match.params
+		};
+		return {
+			Shell,
+			Component,
+			componentProps,
+			data: state.data,
+			params: match.params,
+			routeId: match.route.id ?? "",
+			url: currentUrl,
+			version: ++routeStateVersion
+		};
+	}
+	async function resolveSpaPendingState(match, currentUrl, shellModPromise) {
+		const resolvedShell = await (shellModPromise ?? startShellImport(match));
+		if (!resolvedShell) return null;
+		const Shell = resolvedShell.Shell ?? null;
+		const Loading = resolvedShell.Loading;
+		if (!Shell && !Loading) return null;
+		return {
+			Shell,
+			Component: Loading ?? (() => null),
+			componentProps: {},
+			data: void 0,
+			params: match.params,
+			routeId: match.route.id ?? "",
+			url: currentUrl,
+			version: ++routeStateVersion
+		};
+	}
+	function resolveRedirectTarget(location) {
+		const targetUrl = parseSafeNavigationUrl(location, window.location.href);
+		if (!targetUrl) return {
+			isCurrentLocation: false,
+			unsafe: true
+		};
+		const fullInternalTarget = targetUrl.pathname + targetUrl.search + targetUrl.hash;
+		const internalPath = targetUrl.pathname + targetUrl.search;
+		const currentPath = window.location.pathname + window.location.search + window.location.hash;
+		const isCurrentLocation = targetUrl.origin === window.location.origin && fullInternalTarget === currentPath;
+		if (targetUrl.origin !== window.location.origin) return {
+			externalUrl: targetUrl.toString(),
+			isCurrentLocation: false
+		};
+		if (targetUrl.hash) return {
+			documentUrl: targetUrl.toString(),
+			isCurrentLocation
+		};
+		return {
+			internalPath,
+			isCurrentLocation
+		};
+	}
+	async function navigate(to, opts) {
+		const navigationId = ++latestNavigationId;
+		activeNavigationAbort?.abort();
+		const abortController = new AbortController();
+		activeNavigationAbort = abortController;
+		const navigationTarget = typeof to === "string" ? to : buildHref(app.routes, to.route, to);
+		const target = resolveBrowserRouteTarget(navigationTarget);
+		if (!target) {
+			const safeUrl = parseSafeNavigationUrl(navigationTarget, window.location.href);
+			if (safeUrl) window.location.href = safeUrl.toString();
+			else if (navigationTarget) console.error(`[pracht] refused to navigate to unsafe URL: ${navigationTarget}`);
+			return;
+		}
+		const match = matchAppRoute(app, target.pathname);
+		if (!match) {
+			window.location.href = target.browserUrl;
+			return;
+		}
+		const navigationToken = beginLoadingNavigation(createNavigationLocation(target.browserUrl));
+		try {
+			let statePromise;
+			if (routeNeedsServerFetch(match.route)) statePromise = getCachedRouteState(target.requestUrl) ?? fetchPrachtRouteState(target.requestUrl, { signal: abortController.signal });
+			else statePromise = Promise.resolve({
+				type: "data",
+				data: void 0
+			});
+			const routeModPromise = startRouteImport(match);
+			const shellModPromise = startShellImport(match);
+			let state = {
+				data: void 0,
+				error: null
+			};
+			try {
+				const result = await statePromise;
+				if (navigationId !== latestNavigationId) return;
+				if (result.type === "redirect") {
+					if (result.location) {
+						const redirect = resolveRedirectTarget(result.location);
+						if (redirect.unsafe) {
+							console.error(`[pracht] refused to navigate to unsafe URL: ${result.location}`);
+							return;
+						}
+						if (redirect.externalUrl) {
+							window.location.href = redirect.externalUrl;
+							return;
+						}
+						if (redirect.isCurrentLocation) return;
+						if (redirect.documentUrl) {
+							window.location.href = redirect.documentUrl;
+							return;
+						}
+						if (redirect.internalPath) {
+							await navigate(redirect.internalPath, opts);
+							return;
+						}
+						window.location.href = target.browserUrl;
+						return;
+					}
+					window.location.href = target.browserUrl;
+					return;
+				}
+				if (result.type === "error") state = {
+					data: void 0,
+					error: result.error
+				};
+				else state = {
+					data: result.data,
+					error: null
+				};
+			} catch {
+				if (abortController.signal.aborted || navigationId !== latestNavigationId) return;
+				window.location.href = target.browserUrl;
+				return;
+			}
+			if (navigationId !== latestNavigationId) return;
+			if (!opts?._popstate) {
+				saveScrollPosition();
+				if (opts?.replace) history.replaceState(withScrollKeyInHistoryState(history.state, currentScrollKey), "", target.browserUrl);
+				else {
+					const nextScrollKey = generateScrollKey();
+					history.pushState(withScrollKeyInHistoryState(null, nextScrollKey), "", target.browserUrl);
+					currentScrollKey = nextScrollKey;
+				}
+			}
+			const routeState = await resolveRouteState(match, state, target.requestUrl, routeModPromise, shellModPromise);
+			if (navigationId !== latestNavigationId) return;
+			if (!routeState) {
+				window.location.href = target.browserUrl;
+				return;
+			}
+			const commit = () => {
+				afterCommitCallback = () => restoreOrResetScroll(opts, target.browserUrl);
+				applyRouteState(routeState);
+			};
+			await commitWithOptionalViewTransition(commit, opts?.viewTransition ?? app.viewTransitions === true);
+		} finally {
+			settleNavigation(navigationToken);
+		}
+	}
+	const initialTarget = resolveBrowserRouteTarget(options.initialState.url);
+	const initialRequestUrl = initialTarget?.requestUrl ?? options.initialState.url;
+	const initialBrowserUrl = initialTarget?.browserUrl ?? options.initialState.url;
+	const initialMatch = matchAppRoute(app, initialTarget?.pathname ?? options.initialState.url);
+	if (initialMatch) {
+		const initialShellPromise = initialMatch.route.render === "spa" && options.initialState.pending ? startShellImport(initialMatch) : null;
+		let state = {
+			data: options.initialState.data,
+			error: options.initialState.error ?? null
+		};
+		if (initialMatch.route.render === "spa" && options.initialState.pending) {
+			const dataPromise = fetchPrachtRouteState(initialRequestUrl, { useDataParam: true });
+			const pendingState = await resolveSpaPendingState(initialMatch, initialRequestUrl, initialShellPromise);
+			if (pendingState) hydrate(h(RouterRoot, { initialState: pendingState }), root);
+			try {
+				const result = await dataPromise;
+				if (result.type === "redirect") {
+					const safeRedirect = parseSafeNavigationUrl(result.location, window.location.href);
+					if (!safeRedirect) {
+						console.error(`[pracht] refused to navigate to unsafe URL: ${result.location}`);
+						return;
+					}
+					window.location.href = safeRedirect.toString();
+					return;
+				}
+				if (result.type === "error") state = {
+					data: void 0,
+					error: result.error
+				};
+				else state = {
+					data: result.data,
+					error: null
+				};
+			} catch {
+				window.location.href = initialBrowserUrl;
+				return;
+			}
+			const resolvedState = await resolveRouteState(initialMatch, state, initialRequestUrl, void 0, initialShellPromise);
+			if (resolvedState) applyRouteState(resolvedState);
+		} else {
+			const initialRouteState = await resolveRouteState(initialMatch, state, initialRequestUrl, void 0, initialShellPromise);
+			if (initialRouteState) if (initialMatch.route.render === "spa") render(h(RouterRoot, { initialState: initialRouteState }), root);
+			else {
+				markHydrating();
+				hydrate(h(RouterRoot, { initialState: initialRouteState }), root);
+			}
+		}
+	}
+	document.addEventListener("click", (e) => {
+		const anchor = e.target.closest?.("a");
+		if (!anchor) return;
+		if (e.metaKey || e.ctrlKey || e.shiftKey || e.altKey) return;
+		if (e.defaultPrevented) return;
+		if (e.button !== 0) return;
+		const target = anchor.getAttribute("target");
+		if (target && target !== "_self") return;
+		if (anchor.hasAttribute("download")) return;
+		const href = anchor.getAttribute("href");
+		if (!href || href.startsWith("#")) return;
+		let url;
+		try {
+			url = new URL(href, window.location.origin);
+		} catch {
+			return;
+		}
+		if (url.origin !== window.location.origin) return;
+		e.preventDefault();
+		const navOptions = {};
+		if (anchor.hasAttribute("data-pracht-preserve-scroll")) navOptions.preserveScroll = true;
+		if (anchor.hasAttribute("data-pracht-view-transition")) navOptions.viewTransition = true;
+		navigate(url.pathname + url.search + url.hash, navOptions);
+	});
+	window.addEventListener("popstate", () => {
+		saveScrollPosition();
+		let nextScrollKey = readScrollKeyFromHistoryState(history.state);
+		if (!nextScrollKey) {
+			nextScrollKey = generateScrollKey();
+			try {
+				history.replaceState(withScrollKeyInHistoryState(history.state, nextScrollKey), "", window.location.href);
+			} catch {}
+		}
+		currentScrollKey = nextScrollKey;
+		navigate(window.location.pathname + window.location.search + window.location.hash, { _popstate: true });
+	});
+	window.__PRACHT_NAVIGATE__ = navigate;
+	window.__PRACHT_ROUTER_READY__ = true;
+	document.documentElement.setAttribute("data-pracht-hydrated", "true");
+	if (hadExistingScrollKey) {
+		const savedPosition = scrollStore.get(currentScrollKey);
+		if (savedPosition) window.scrollTo(savedPosition.x, savedPosition.y);
+	}
+	const warmModules = (match) => {
+		startRouteImport(match);
+		startShellImport(match);
+	};
+	registerPrefetchTarget(app, warmModules);
+	import("./prefetch-COYeuvQK.mjs").then(({ setupPrefetching }) => {
+		setupPrefetching(app, warmModules);
+	});
+}
+/**
+* Commit a navigation's DOM update, optionally wrapped in
+* `document.startViewTransition()`. Falls back to a plain commit when view
+* transitions are disabled or unsupported. Resolves once the DOM update has
+* been applied (not when the transition animation finishes).
+*/
+async function commitWithOptionalViewTransition(commit, useViewTransition) {
+	const doc = document;
+	if (!useViewTransition || typeof doc.startViewTransition !== "function") {
+		commit();
+		return;
+	}
+	let committed = false;
+	let transition;
+	try {
+		transition = doc.startViewTransition(async () => {
+			committed = true;
+			commit();
+			await new Promise((resolve) => setTimeout(resolve, 0));
+		});
+	} catch {}
+	try {
+		await transition?.updateCallbackDone;
+	} catch {}
+	if (!committed) commit();
+}
+function resolveBrowserRouteTarget(to) {
+	if (typeof window === "undefined") return null;
+	try {
+		const url = new URL(to, window.location.href);
+		if (url.origin !== window.location.origin) return null;
+		return {
+			browserUrl: url.pathname + url.search + url.hash,
+			pathname: url.pathname,
+			requestUrl: url.pathname + url.search
+		};
+	} catch {
+		return null;
+	}
+}
+//#endregion
+export { useNavigate as n, useIsHydrated as r, initClientRouter as t };

package/dist/{runtime-context-ytVd7GmZ.d.mts → runtime-context-BYBwVA0M.d.mts}

@@ -1,4 +1,4 @@
-import { A as HrefRouteDefinition, st as RouteParams } from "./app-BWriseLj.mjs";
+import { b as HrefRouteDefinition, et as RouteParams } from "./types-B-sfVjaH.mjs";
 import * as _$preact from "preact";
 import { ComponentChildren } from "preact";