void 0.1.6 → 0.7.0

package/dist/pages/client.mjs

@@ -0,0 +1,980 @@
+import { applyClientHead, initClientHead } from "./head-client.mjs";
+import { PrefetchCache, parseCacheFor } from "./prefetch.mjs";
+//#region src/pages/action-result.ts
+var VoidActionError = class extends Error {
+	body;
+	status;
+	statusText;
+	url;
+	constructor({ body, status, statusText, url }) {
+		super(statusText ? `Action failed with ${status} ${statusText}` : `Action failed with ${status}`);
+		this.name = "VoidActionError";
+		this.body = body;
+		this.status = status;
+		this.statusText = statusText;
+		this.url = url;
+	}
+};
+function categorizeActionError(status) {
+	switch (status) {
+		case 400:
+		case 402:
+		case 404:
+		case 408:
+		case 409:
+		case 412:
+		case 413:
+		case 415:
+		case 422:
+		case 429:
+		case 499: return "callSite";
+		default: return "boundary";
+	}
+}
+function isCallSiteActionError(error) {
+	return typeof error === "object" && error !== null && "name" in error && error.name === "VoidActionError" && "status" in error && typeof error.status === "number" && categorizeActionError(error.status) === "callSite";
+}
+function isAbortError(error) {
+	return typeof error === "object" && error !== null && "name" in error && error.name === "AbortError";
+}
+async function readActionErrorBody(response) {
+	const contentType = response.headers.get("content-type") || "";
+	try {
+		if (contentType.includes("application/json")) return await response.json();
+		return await response.text() || null;
+	} catch {
+		return null;
+	}
+}
+async function createActionErrorFromResponse(response, url) {
+	return new VoidActionError({
+		body: await readActionErrorBody(response),
+		status: response.status,
+		statusText: response.statusText,
+		url
+	});
+}
+//#endregion
+//#region src/pages/navigation-engine.ts
+const PAGE_DATA_SCRIPT_ID = "__VOID_PAGE_DATA__";
+const STATIC_PAGE_DATA_PREFIX = "/_void/pages";
+function isFile$1(value) {
+	return typeof File !== "undefined" && value instanceof File || value instanceof Blob || typeof FileList !== "undefined" && value instanceof FileList && value.length > 0;
+}
+function hasFiles$1(data) {
+	return isFile$1(data) || typeof data === "object" && data !== null && Object.values(data).some(hasFiles$1);
+}
+function objectToFormData$1(source, form, parentKey) {
+	form = form || new FormData();
+	for (const key in source) {
+		if (!Object.prototype.hasOwnProperty.call(source, key)) continue;
+		const composed = parentKey ? parentKey + "[" + key + "]" : key;
+		const value = source[key];
+		if (value instanceof File) form.append(composed, value, value.name);
+		else if (value instanceof Blob) form.append(composed, value);
+		else if (typeof FileList !== "undefined" && value instanceof FileList) for (let i = 0; i < value.length; i++) form.append(composed + "[]", value[i], value[i].name);
+		else if (Array.isArray(value)) for (let i = 0; i < value.length; i++) objectToFormData$1({ [i]: value[i] }, form, composed);
+		else if (value instanceof Date) form.append(composed, value.toISOString());
+		else if (typeof value === "boolean") form.append(composed, value ? "1" : "0");
+		else if (typeof value === "string") form.append(composed, value);
+		else if (typeof value === "number") form.append(composed, String(value));
+		else if (value === null || value === void 0) form.append(composed, "");
+		else objectToFormData$1(value, form, composed);
+	}
+	return form;
+}
+function clonePageData(pageData) {
+	return JSON.parse(JSON.stringify(pageData));
+}
+function readInitialPageData(appEl) {
+	const scriptEl = document.getElementById(PAGE_DATA_SCRIPT_ID);
+	if (scriptEl?.textContent) return JSON.parse(scriptEl.textContent);
+	const legacyData = appEl.getAttribute("data-page");
+	if (legacyData) return JSON.parse(legacyData);
+	throw new Error("pages: Missing initial page payload.");
+}
+function parsePageDataFromHtml(html) {
+	const scriptEl = new DOMParser().parseFromString(html, "text/html").getElementById(PAGE_DATA_SCRIPT_ID);
+	if (!scriptEl?.textContent) return null;
+	try {
+		return JSON.parse(scriptEl.textContent);
+	} catch {
+		return null;
+	}
+}
+function isAbortError$1(error) {
+	return typeof error === "object" && error !== null && "name" in error && error.name === "AbortError";
+}
+function abortError() {
+	return new DOMException("Navigation aborted", "AbortError");
+}
+function abortSignalPromise(signal) {
+	if (signal.aborted) return Promise.reject(abortError());
+	return new Promise((_resolve, reject) => {
+		signal.addEventListener("abort", () => reject(abortError()), { once: true });
+	});
+}
+async function fetchPageResponse(fetchUrl, init) {
+	try {
+		return await fetch(fetchUrl, init);
+	} catch (error) {
+		if (init.signal?.aborted || isAbortError$1(error)) throw abortError();
+		return null;
+	}
+}
+async function createPageNavigationEngine(config) {
+	const { adapter, components, layoutTree, routeMeta, matchRoute, staticPageData: STATIC_PAGE_DATA_ENABLED = false, staticPageDataFastPath: STATIC_PAGE_DATA_FAST_PATH = STATIC_PAGE_DATA_ENABLED, prefetchHoverDelay: PREFETCH_HOVER_DELAY, prefetchDefaultCacheFor: PREFETCH_DEFAULT_CACHE_FOR } = config;
+	const _prefetchCache = new PrefetchCache();
+	const _staticPageDataCacheKeys = /* @__PURE__ */ new Set();
+	let _nextNavigationId = 0;
+	let _pendingResource = null;
+	let _committedResource = null;
+	let _committedDeferredRegistry = null;
+	let _htmlDeferredRegistry = null;
+	let _currentFetchUrl = window.location.pathname + window.location.search;
+	let popStateHandler = null;
+	function getPageDataCacheKey(url, method = "GET") {
+		return `${method}:${url}`;
+	}
+	async function resolveComponent(id) {
+		const loader = components[id];
+		if (!loader) throw new Error(`pages: Unknown page component '${id}'.`);
+		return (await loader()).default;
+	}
+	async function resolveLayouts(componentId) {
+		const ids = layoutTree[componentId] || [];
+		return Promise.all(ids.map(async (id) => (await components[id]()).default));
+	}
+	function getStaticPageDataUrl(url) {
+		const { pathname } = new URL(url || "/", window.location.origin);
+		return `${STATIC_PAGE_DATA_PREFIX}/${pathname === "/" ? "index" : pathname.replace(/^\/+/, "")}.json`;
+	}
+	function isUsablePageData(pageData, matchedId) {
+		return typeof pageData === "object" && pageData !== null && "component" in pageData && typeof pageData.component === "string" && "props" in pageData && typeof pageData.props === "object" && pageData.props !== null && typeof pageData.component === "string" && pageData.component === matchedId && !routeMeta[pageData.component]?.island && Boolean(components[pageData.component]);
+	}
+	class DeferredRegistry {
+		active = true;
+		keyRefs = {};
+		props = {};
+		groups = {};
+		preservedSource = null;
+		preservedKeys = null;
+		setupPending(pageData) {
+			this.props = pageData.props;
+			this.keyRefs = {};
+			this.groups = {};
+			if (!pageData.deferredKeys) return;
+			for (const [key, group] of Object.entries(pageData.deferredKeys)) {
+				const ref = adapter.createDeferred();
+				this.keyRefs[key] = ref;
+				this.props[key] = ref;
+				(this.groups[group] ??= []).push(key);
+			}
+		}
+		setupResolved(pageData) {
+			this.props = pageData.props;
+			this.keyRefs = {};
+			this.groups = {};
+			if (!pageData.deferredKeys) return;
+			for (const [key, group] of Object.entries(pageData.deferredKeys)) {
+				const ref = adapter.createDeferred();
+				const updated = adapter.resolveDeferred(ref, pageData.props[key]);
+				this.keyRefs[key] = updated;
+				this.props[key] = updated;
+				(this.groups[group] ??= []).push(key);
+			}
+		}
+		preserveValuesFrom(source, pageData) {
+			if (!source) return;
+			const keys = source.applyPreservedValues(pageData);
+			if (keys) {
+				this.preservedSource = source;
+				this.preservedKeys = keys;
+			}
+		}
+		commitPreservedValues(source, pageData) {
+			if (!this.preservedSource || this.preservedSource !== source || !this.preservedKeys) return null;
+			this.preservedSource.retainOnly(this.preservedKeys, pageData.props);
+			return this.preservedSource;
+		}
+		applyPreservedValues(pageData) {
+			let keys = null;
+			for (const key of Object.keys(this.keyRefs)) if (pageData.props[key] === null && this.props[key] !== void 0) {
+				pageData.props[key] = this.props[key];
+				(keys ??= /* @__PURE__ */ new Set()).add(key);
+			}
+			return keys;
+		}
+		resolve(group, data, error) {
+			if (!this.active) return;
+			if (data !== void 0) if (typeof data === "object" && data !== null && !Array.isArray(data)) {
+				let resolvedAny = false;
+				for (const [key, value] of Object.entries(data)) if (this.keyRefs[key]) {
+					this.resolveKey(key, value);
+					resolvedAny = true;
+				}
+				if (!resolvedAny) this.resolveGroup(group, data);
+			} else this.resolveGroup(group, data);
+			else if (error !== void 0) this.rejectGroup(group, typeof error === "string" ? error : String(error));
+			adapter.onDeferredUpdate?.(this.props);
+		}
+		rejectPending(error, notify = true) {
+			if (!this.active) return;
+			for (const [key, ref] of Object.entries(this.keyRefs)) if (adapter.isLoading(ref)) {
+				const updated = adapter.rejectDeferred(ref, error);
+				this.keyRefs[key] = updated;
+				this.props[key] = updated;
+			}
+			if (notify) adapter.onDeferredUpdate?.(this.props);
+		}
+		dispose() {
+			if (!this.active) return;
+			this.rejectPending("Navigation disposed before deferred props resolved", false);
+			this.active = false;
+		}
+		retainOnly(keys, props) {
+			const keyRefs = {};
+			const groups = {};
+			for (const [key, ref] of Object.entries(this.keyRefs)) if (keys.has(key)) {
+				keyRefs[key] = ref;
+				props[key] = this.props[key];
+			} else if (adapter.isLoading(ref)) adapter.rejectDeferred(ref, "Navigation disposed before deferred props resolved");
+			for (const [group, groupKeys] of Object.entries(this.groups)) {
+				const preservedGroupKeys = groupKeys.filter((key) => keys.has(key));
+				if (preservedGroupKeys.length > 0) groups[group] = preservedGroupKeys;
+			}
+			this.props = props;
+			this.keyRefs = keyRefs;
+			this.groups = groups;
+			adapter.onDeferredUpdate?.(this.props);
+		}
+		resolveGroup(group, data) {
+			const keys = this.groups[group] ?? (this.keyRefs[group] ? [group] : []);
+			for (const key of keys) this.resolveKey(key, data);
+		}
+		resolveKey(key, value) {
+			const ref = this.keyRefs[key];
+			if (!ref || !adapter.isLoading(ref)) return;
+			const updated = adapter.resolveDeferred(ref, value);
+			this.keyRefs[key] = updated;
+			this.props[key] = updated;
+		}
+		rejectGroup(group, error) {
+			const keys = this.groups[group] ?? Object.keys(this.keyRefs);
+			for (const key of keys) {
+				const ref = this.keyRefs[key];
+				if (ref && adapter.isLoading(ref)) {
+					const updated = adapter.rejectDeferred(ref, error);
+					this.keyRefs[key] = updated;
+					this.props[key] = updated;
+				}
+			}
+		}
+	}
+	const _resourceDeferredRegistries = /* @__PURE__ */ new WeakMap();
+	const _preservedDeferredResources = /* @__PURE__ */ new WeakMap();
+	async function loadStaticPageDataFile(fetchUrl, signal) {
+		const matchedId = matchRoute(fetchUrl || window.location.pathname + window.location.search);
+		if (!matchedId || routeMeta[matchedId]?.island || !components[matchedId]) return null;
+		try {
+			const pageDataResponse = await fetch(getStaticPageDataUrl(fetchUrl), {
+				headers: { Accept: "application/json" },
+				signal
+			});
+			if (pageDataResponse.ok) {
+				const pageData = await pageDataResponse.json();
+				if (isUsablePageData(pageData, matchedId)) return {
+					pageData,
+					resolvedDeferred: true
+				};
+			}
+		} catch (error) {
+			if (signal?.aborted || isAbortError$1(error)) throw abortError();
+		}
+		return null;
+	}
+	async function loadStaticPageData(fetchUrl, response, signal, verifyPageResponse = false) {
+		if (!response.ok) return null;
+		const matchedId = matchRoute(fetchUrl || window.location.pathname + window.location.search);
+		if (!matchedId || routeMeta[matchedId]?.island || !components[matchedId]) return null;
+		const contentType = response.headers.get("content-type") || "";
+		if (contentType && !contentType.includes("text/html")) return null;
+		if (verifyPageResponse) {
+			const pageData = parsePageDataFromHtml(await response.text());
+			if (!isUsablePageData(pageData, matchedId)) return null;
+			if (!pageData.deferredKeys) return {
+				pageData,
+				resolvedDeferred: false
+			};
+			return loadStaticPageDataFile(fetchUrl, signal);
+		}
+		const filePageData = await loadStaticPageDataFile(fetchUrl, signal);
+		if (filePageData) return filePageData;
+		const pageData = parsePageDataFromHtml(await response.text());
+		if (!isUsablePageData(pageData, matchedId) || pageData.deferredKeys) return null;
+		return {
+			pageData,
+			resolvedDeferred: false
+		};
+	}
+	const deferredWindow = window;
+	deferredWindow.__resolveDeferred = (group, data) => _htmlDeferredRegistry?.resolve(group, data, void 0);
+	deferredWindow.__rejectDeferred = (group, error) => _htmlDeferredRegistry?.resolve(group, void 0, error);
+	function commitHashNavigation(effectiveFetchUrl, hash, options, writeHistory) {
+		_currentFetchUrl = effectiveFetchUrl;
+		if (writeHistory) if (options.replace) history.replaceState({}, "", effectiveFetchUrl + hash);
+		else {
+			history.replaceState({
+				scrollX: window.scrollX,
+				scrollY: window.scrollY
+			}, "");
+			history.pushState({}, "", effectiveFetchUrl + hash);
+		}
+		if (options._scrollPosition) {
+			window.scrollTo(options._scrollPosition.x, options._scrollPosition.y);
+			return;
+		}
+		if (hash) {
+			const el = document.getElementById(hash.slice(1));
+			if (el) {
+				el.scrollIntoView();
+				return;
+			}
+		}
+		window.scrollTo(0, 0);
+	}
+	async function loadNavigationShell(id, url, fetchUrl, method, hash, options, signal, commitTarget, deferredRegistry) {
+		if (method !== "GET") {
+			_prefetchCache.flushAll();
+			_staticPageDataCacheKeys.clear();
+		}
+		const headers = {
+			"X-VoidPages": "true",
+			Accept: "application/json"
+		};
+		const fetchOptions = {
+			method,
+			headers,
+			signal
+		};
+		if (options.data && method !== "GET") if (hasFiles$1(options.data)) fetchOptions.body = objectToFormData$1(options.data);
+		else {
+			headers["Content-Type"] = "application/json";
+			fetchOptions.body = JSON.stringify(options.data);
+		}
+		let pageData;
+		const cacheEntry = method === "GET" ? _prefetchCache.get(fetchUrl, method) : null;
+		if (cacheEntry) {
+			const cachedPageData = await cacheEntry.response;
+			_prefetchCache.consume(fetchUrl, method);
+			if (cachedPageData === null) {
+				window.location.href = url;
+				return;
+			}
+			pageData = _staticPageDataCacheKeys.has(getPageDataCacheKey(fetchUrl, method)) ? clonePageData(cachedPageData) : cachedPageData;
+			deferredRegistry.setupResolved(pageData);
+			if (!_prefetchCache.isFresh(cacheEntry)) {
+				const bgHeaders = {
+					"X-VoidPages": "true",
+					Accept: "application/json",
+					Purpose: "prefetch"
+				};
+				const bgFetch = (STATIC_PAGE_DATA_ENABLED && STATIC_PAGE_DATA_FAST_PATH && method === "GET" ? loadStaticPageDataFile(fetchUrl).then((result) => result?.pageData) : Promise.resolve(void 0)).then((pageData) => {
+					if (pageData !== void 0) return pageData;
+					return fetchPageResponse(fetchUrl, {
+						method,
+						headers: bgHeaders
+					}).then(async (r) => {
+						if (!r || r.redirected) return null;
+						if (!r.headers.get("X-VoidPages")) return (await loadStaticPageData(fetchUrl, r, void 0, !STATIC_PAGE_DATA_FAST_PATH))?.pageData ?? null;
+						return r.json();
+					});
+				});
+				_prefetchCache.set(fetchUrl, method, bgFetch, PREFETCH_DEFAULT_CACHE_FOR);
+			}
+		} else {
+			if (method === "GET" && STATIC_PAGE_DATA_ENABLED && STATIC_PAGE_DATA_FAST_PATH) {
+				const staticPageData = await loadStaticPageDataFile(fetchUrl, signal);
+				if (staticPageData) {
+					pageData = staticPageData.pageData;
+					_staticPageDataCacheKeys.add(getPageDataCacheKey(fetchUrl, method));
+					_prefetchCache.set(fetchUrl, method, Promise.resolve(clonePageData(pageData)), PREFETCH_DEFAULT_CACHE_FOR);
+					if (staticPageData.resolvedDeferred) deferredRegistry.setupResolved(pageData);
+					else deferredRegistry.setupPending(pageData);
+				}
+			}
+			const response = pageData === void 0 ? method === "GET" ? await fetchPageResponse(fetchUrl, fetchOptions) : await fetch(fetchUrl, fetchOptions) : null;
+			if (pageData === void 0 && !response) {
+				window.location.href = url;
+				return;
+			}
+			if (response?.redirected) {
+				const redirectUrl = new URL(response.url, window.location.origin);
+				if (redirectUrl.origin !== window.location.origin) {
+					window.location.href = method === "GET" ? url : response.url;
+					return;
+				}
+				commitTarget.fetchUrl = redirectUrl.pathname + redirectUrl.search;
+				commitTarget.hash = redirectUrl.hash;
+				return loadNavigationShell(id, redirectUrl.pathname + redirectUrl.search + redirectUrl.hash, redirectUrl.pathname + redirectUrl.search, "GET", redirectUrl.hash, {
+					preserveScroll: options.preserveScroll,
+					preserveState: options.preserveState,
+					replace: options.replace,
+					viewTransition: options.viewTransition
+				}, signal, commitTarget, deferredRegistry);
+			}
+			if (response && method !== "GET" && !response.ok) throw await createActionErrorFromResponse(response, fetchUrl);
+			if (response && !response.headers.get("X-VoidPages")) if (method === "GET") {
+				const staticPageData = await loadStaticPageData(fetchUrl, response, signal, !STATIC_PAGE_DATA_FAST_PATH);
+				if (staticPageData) {
+					pageData = staticPageData.pageData;
+					if (staticPageData.resolvedDeferred) deferredRegistry.setupResolved(pageData);
+					else deferredRegistry.setupPending(pageData);
+				} else {
+					window.location.href = url;
+					return;
+				}
+			} else {
+				window.location.href = url;
+				return;
+			}
+			const contentType = response?.headers.get("content-type") || "";
+			if (pageData !== void 0) {} else if (contentType.includes("application/x-ndjson")) {
+				const reader = response.body.getReader();
+				const decoder = new TextDecoder();
+				let buffer = "";
+				let firstLine = true;
+				const processLines = () => {
+					let newlineIdx;
+					while ((newlineIdx = buffer.indexOf("\n")) !== -1) {
+						const line = buffer.slice(0, newlineIdx);
+						buffer = buffer.slice(newlineIdx + 1);
+						if (!line) continue;
+						if (firstLine) {
+							pageData = JSON.parse(line);
+							deferredRegistry.setupPending(pageData);
+							firstLine = false;
+						} else {
+							const msg = JSON.parse(line);
+							if (msg.__deferred) deferredRegistry.resolve(msg.__deferred, msg.data, msg.error);
+						}
+					}
+				};
+				while (firstLine) {
+					const { done, value } = await reader.read();
+					if (done) break;
+					buffer += decoder.decode(value, { stream: true });
+					processLines();
+				}
+				(async () => {
+					try {
+						while (!signal.aborted) {
+							const { done, value } = await reader.read();
+							if (done) break;
+							buffer += decoder.decode(value, { stream: true });
+							processLines();
+						}
+						if (buffer.trim()) processLines();
+					} catch (e) {
+						if (!(e instanceof Error) || e.name !== "AbortError") deferredRegistry.rejectPending("Stream closed before resolution");
+					}
+				})();
+			} else {
+				pageData = await response.json();
+				deferredRegistry.setupPending(pageData);
+			}
+		}
+		if (!pageData) throw new Error("pages: Missing page payload.");
+		if (method !== "GET") deferredRegistry.preserveValuesFrom(_committedDeferredRegistry, pageData);
+		const [component, layouts] = await Promise.race([Promise.all([resolveComponent(pageData.component), resolveLayouts(pageData.component)]), abortSignalPromise(signal)]);
+		if (id !== _nextNavigationId && signal.aborted) throw abortError();
+		return {
+			pageData,
+			component,
+			layouts
+		};
+	}
+	function makeCommit(commitTarget, options, shell, deferredRegistry, resourceId, getResource) {
+		let committed = false;
+		return async () => {
+			if (committed) return;
+			committed = true;
+			const result = await shell;
+			if (!result) return;
+			if (_pendingResource?.id === resourceId) _pendingResource = null;
+			const previousResource = _committedResource;
+			const previousDeferredRegistry = _committedDeferredRegistry;
+			const preservedDeferredRegistry = deferredRegistry.commitPreservedValues(previousDeferredRegistry, result.pageData);
+			_committedResource = getResource();
+			const previousResourceOwnsPreservedRegistry = Boolean(previousResource && preservedDeferredRegistry && _resourceDeferredRegistries.get(previousResource) === preservedDeferredRegistry);
+			if (previousResource && previousResource !== _committedResource && !previousResourceOwnsPreservedRegistry) previousResource.dispose();
+			if (previousResource && preservedDeferredRegistry && previousResourceOwnsPreservedRegistry) _preservedDeferredResources.set(preservedDeferredRegistry, previousResource);
+			_committedDeferredRegistry = preservedDeferredRegistry ?? deferredRegistry;
+			const preservedDeferredResource = previousDeferredRegistry ? _preservedDeferredResources.get(previousDeferredRegistry) : void 0;
+			if (previousDeferredRegistry && previousDeferredRegistry !== _committedDeferredRegistry) {
+				previousDeferredRegistry.dispose();
+				if (preservedDeferredResource && preservedDeferredResource !== previousResource && preservedDeferredResource !== _committedResource) preservedDeferredResource.dispose();
+				_preservedDeferredResources.delete(previousDeferredRegistry);
+			}
+			if (preservedDeferredRegistry && preservedDeferredRegistry !== deferredRegistry) deferredRegistry.dispose();
+			applyClientHead(result.pageData.head);
+			_currentFetchUrl = commitTarget.fetchUrl;
+			if (!options.preserveState) {
+				const historyUrl = commitTarget.fetchUrl + commitTarget.hash;
+				if (options.replace) history.replaceState({}, "", historyUrl);
+				else {
+					history.replaceState({
+						scrollX: window.scrollX,
+						scrollY: window.scrollY
+					}, "");
+					history.pushState({}, "", historyUrl);
+				}
+			}
+			const doScroll = () => {
+				if (options.preserveScroll) return;
+				if (options._scrollPosition) window.scrollTo(options._scrollPosition.x, options._scrollPosition.y);
+				else if (commitTarget.hash) {
+					const el = document.getElementById(commitTarget.hash.slice(1));
+					if (el) el.scrollIntoView();
+					else window.scrollTo(0, 0);
+				} else window.scrollTo(0, 0);
+			};
+			requestAnimationFrame(doScroll);
+		};
+	}
+	const initialPageData = readInitialPageData(document.getElementById("app"));
+	const [initialComponent, initialLayouts] = await Promise.all([resolveComponent(initialPageData.component), resolveLayouts(initialPageData.component)]);
+	const initialDeferredRegistry = new DeferredRegistry();
+	initialDeferredRegistry.setupPending(initialPageData);
+	_committedDeferredRegistry = initialDeferredRegistry;
+	_htmlDeferredRegistry = initialDeferredRegistry;
+	return {
+		_hoverDelay: PREFETCH_HOVER_DELAY,
+		initialPageData,
+		initialComponent,
+		initialLayouts,
+		prepareVisit(url, options = {}) {
+			const hashIndex = url.indexOf("#");
+			const hash = hashIndex !== -1 ? url.slice(hashIndex) : "";
+			const fetchUrl = hashIndex !== -1 ? url.slice(0, hashIndex) : url;
+			const currentPath = window.location.pathname + window.location.search;
+			const effectiveFetchUrl = fetchUrl || currentPath;
+			const method = (options.method || "GET").toUpperCase();
+			const id = ++_nextNavigationId;
+			const hashNavigationBaseUrl = options._popstate ? _currentFetchUrl : currentPath;
+			_pendingResource?.abort();
+			_pendingResource = null;
+			if (effectiveFetchUrl === hashNavigationBaseUrl && method === "GET" && !options.data && Boolean(hash || options._popstate)) {
+				commitHashNavigation(effectiveFetchUrl, hash, options, !options._popstate && !options.preserveState);
+				return {
+					id,
+					url,
+					fetchUrl: effectiveFetchUrl,
+					hash,
+					method,
+					options,
+					immediate: true,
+					shell: Promise.resolve(void 0),
+					abort() {},
+					async commit() {},
+					dispose() {}
+				};
+			}
+			const controller = new AbortController();
+			const deferredRegistry = new DeferredRegistry();
+			const commitTarget = {
+				fetchUrl: effectiveFetchUrl,
+				hash
+			};
+			const shell = loadNavigationShell(id, url, effectiveFetchUrl, method, hash, options, controller.signal, commitTarget, deferredRegistry);
+			let commitResource = async () => {};
+			const resource = {
+				id,
+				url,
+				fetchUrl: effectiveFetchUrl,
+				hash,
+				method,
+				options,
+				immediate: false,
+				shell,
+				abort() {
+					controller.abort(abortError());
+					deferredRegistry.dispose();
+				},
+				commit() {
+					return commitResource();
+				},
+				dispose() {
+					controller.abort(abortError());
+					deferredRegistry.dispose();
+				}
+			};
+			_resourceDeferredRegistries.set(resource, deferredRegistry);
+			commitResource = makeCommit(commitTarget, options, shell, deferredRegistry, id, () => resource);
+			_pendingResource = resource;
+			return resource;
+		},
+		prefetch(url, options = {}) {
+			const method = (options.method || "GET").toUpperCase();
+			if (method !== "GET") throw new Error("Void Router: prefetch() only supports GET requests.");
+			const id = matchRoute(url);
+			if (!id) return Promise.resolve(void 0);
+			if (routeMeta[id]?.island) {
+				if (!document.querySelector("link[rel=\"prefetch\"][href=\"" + url + "\"]")) {
+					const link = document.createElement("link");
+					link.rel = "prefetch";
+					link.href = url;
+					link.as = "document";
+					document.head.appendChild(link);
+				}
+				return Promise.resolve(void 0);
+			}
+			if (components[id]) components[id]();
+			const layoutIds = layoutTree[id] || [];
+			for (const lid of layoutIds) if (components[lid]) components[lid]();
+			const hashIdx = url.indexOf("#");
+			const prefetchUrl = hashIdx !== -1 ? url.slice(0, hashIdx) : url;
+			const existing = _prefetchCache.get(prefetchUrl, method);
+			if (existing) return existing.response;
+			const ttl = options.cacheFor ? parseCacheFor(options.cacheFor) : PREFETCH_DEFAULT_CACHE_FOR;
+			const headers = {
+				"X-VoidPages": "true",
+				Accept: "application/json",
+				Purpose: "prefetch"
+			};
+			const fetchPromise = (STATIC_PAGE_DATA_ENABLED && STATIC_PAGE_DATA_FAST_PATH && method === "GET" ? loadStaticPageDataFile(prefetchUrl).then((result) => result?.pageData) : Promise.resolve(void 0)).then((pageData) => {
+				if (pageData !== void 0) return pageData;
+				return fetchPageResponse(prefetchUrl, {
+					method,
+					headers
+				}).then((r) => {
+					if (!r || r.redirected) return null;
+					if (!r.headers.get("X-VoidPages")) {
+						if (method !== "GET") return null;
+						return loadStaticPageData(prefetchUrl, r, void 0, !STATIC_PAGE_DATA_FAST_PATH).then((result) => result?.pageData ?? null);
+					}
+					return r.json();
+				});
+			});
+			_prefetchCache.set(prefetchUrl, method, fetchPromise, ttl);
+			return fetchPromise;
+		},
+		flush(url, method = "GET") {
+			_prefetchCache.flush(url, method);
+			_staticPageDataCacheKeys.delete(getPageDataCacheKey(url, method));
+		},
+		flushAll() {
+			_prefetchCache.flushAll();
+			_staticPageDataCacheKeys.clear();
+		},
+		setPopStateHandler(handler) {
+			popStateHandler = handler;
+		},
+		start() {
+			history.scrollRestoration = "manual";
+			history.replaceState({
+				scrollX: window.scrollX,
+				scrollY: window.scrollY
+			}, "");
+			initClientHead(initialPageData.head);
+			if (deferredWindow.__deferredQueue) {
+				for (const entry of deferredWindow.__deferredQueue) if (entry.length === 3) _htmlDeferredRegistry?.resolve(entry[0], void 0, entry[2]);
+				else _htmlDeferredRegistry?.resolve(entry[0], entry[1], void 0);
+				delete deferredWindow.__deferredQueue;
+			}
+			window.addEventListener("popstate", (e) => {
+				const saved = e.state;
+				const url = window.location.pathname + window.location.search + window.location.hash;
+				const options = {
+					preserveState: true,
+					_scrollPosition: saved ? {
+						x: saved.scrollX ?? 0,
+						y: saved.scrollY ?? 0
+					} : null,
+					_popstate: true
+				};
+				if (popStateHandler) popStateHandler(url, options);
+			});
+		}
+	};
+}
+//#endregion
+//#region src/pages/form-value-equality.ts
+function isPlainObject(value) {
+	if (value === null || typeof value !== "object") return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+}
+function isEqualFormValue(a, b) {
+	if (Object.is(a, b)) return true;
+	if (Array.isArray(a) || Array.isArray(b)) {
+		if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false;
+		return a.every((value, index) => isEqualFormValue(value, b[index]));
+	}
+	if (isPlainObject(a) || isPlainObject(b)) {
+		if (!isPlainObject(a) || !isPlainObject(b)) return false;
+		const aKeys = Object.keys(a);
+		const bKeys = Object.keys(b);
+		if (aKeys.length !== bKeys.length) return false;
+		return aKeys.every((key) => Object.hasOwn(b, key) && isEqualFormValue(a[key], b[key]));
+	}
+	return false;
+}
+//#endregion
+//#region src/pages/client.ts
+function currentUrl() {
+	return window.location.pathname + window.location.search + window.location.hash;
+}
+function getUrlOrigin() {
+	return typeof window === "undefined" ? "http://localhost" : window.location.origin;
+}
+function toUrl(value) {
+	return value instanceof URL ? new URL(value.href) : new URL(value || "/", getUrlOrigin());
+}
+function normalizeUrl(value) {
+	if (typeof value === "string" && value.startsWith("#")) return value;
+	const url = toUrl(value);
+	return url.origin === getUrlOrigin() ? url.pathname + url.search + url.hash : url.href;
+}
+function navigationMethod(method) {
+	const normalized = method.toUpperCase();
+	if (normalized === "POST" || normalized === "PUT" || normalized === "PATCH" || normalized === "DELETE") return normalized;
+	return "GET";
+}
+function navigationStateFor(url, method) {
+	const normalized = navigationMethod(method);
+	return {
+		state: normalized === "GET" ? "loading" : "submitting",
+		location: toUrl(url),
+		method: normalized
+	};
+}
+function idleNavigationState() {
+	return {
+		state: "idle",
+		location: null,
+		method: null
+	};
+}
+function createRouterFacade(router, getCurrentUrl) {
+	return {
+		get _hoverDelay() {
+			return router._hoverDelay;
+		},
+		get url() {
+			return toUrl(getCurrentUrl());
+		},
+		get path() {
+			return this.url.pathname;
+		},
+		get query() {
+			return this.url.searchParams;
+		},
+		visit(url, options = {}) {
+			return router.visit(url, options);
+		},
+		refresh(options = {}) {
+			return router.refresh(options);
+		},
+		prefetch(url, options = {}) {
+			return router.prefetch(url, options);
+		},
+		flush(url, method = "GET") {
+			router.flush(url, method);
+		},
+		flushAll() {
+			router.flushAll();
+		}
+	};
+}
+function createSsrRouter(url = "/") {
+	return {
+		_hoverDelay: 75,
+		get url() {
+			return toUrl(url);
+		},
+		get path() {
+			return this.url.pathname;
+		},
+		get query() {
+			return this.url.searchParams;
+		},
+		visit() {
+			throw new Error("Void Router: visit() is not available during SSR.");
+		},
+		refresh() {
+			throw new Error("Void Router: refresh() is not available during SSR.");
+		},
+		prefetch() {
+			throw new Error("Void Router: prefetch() is not available during SSR.");
+		},
+		flush() {
+			throw new Error("Void Router: flush() is not available during SSR.");
+		},
+		flushAll() {
+			throw new Error("Void Router: flushAll() is not available during SSR.");
+		}
+	};
+}
+function isFile(value) {
+	return typeof File !== "undefined" && value instanceof File || value instanceof Blob || typeof FileList !== "undefined" && value instanceof FileList && value.length > 0;
+}
+function hasFiles(data) {
+	return isFile(data) || typeof data === "object" && data !== null && Object.values(data).some(hasFiles);
+}
+function objectToFormData(source, form, parentKey) {
+	form = form || new FormData();
+	for (const key in source) {
+		if (!Object.prototype.hasOwnProperty.call(source, key)) continue;
+		const composed = parentKey ? parentKey + "[" + key + "]" : key;
+		const value = source[key];
+		if (value instanceof File) form.append(composed, value, value.name);
+		else if (value instanceof Blob) form.append(composed, value);
+		else if (typeof FileList !== "undefined" && value instanceof FileList) for (let i = 0; i < value.length; i++) form.append(composed + "[]", value[i], value[i].name);
+		else if (Array.isArray(value)) for (let i = 0; i < value.length; i++) objectToFormData({ [i]: value[i] }, form, composed);
+		else if (value instanceof Date) form.append(composed, value.toISOString());
+		else if (typeof value === "boolean") form.append(composed, value ? "1" : "0");
+		else if (typeof value === "string") form.append(composed, value);
+		else if (typeof value === "number") form.append(composed, String(value));
+		else if (value === null || value === void 0) form.append(composed, "");
+		else objectToFormData(value, form, composed);
+	}
+	return form;
+}
+const ssrProxy = createSsrRouter();
+async function submitAction(router, url, options) {
+	try {
+		const pageData = await router.visit(url, options);
+		if (typeof pageData === "object" && pageData !== null && "errors" in pageData && pageData.errors) return {
+			ok: false,
+			error: new VoidActionError({
+				body: { errors: pageData.errors },
+				status: 422,
+				statusText: "Unprocessable Content",
+				url
+			})
+		};
+		return {
+			ok: true,
+			pageData
+		};
+	} catch (error) {
+		if (isCallSiteActionError(error)) return {
+			ok: false,
+			error
+		};
+		throw error;
+	}
+}
+async function createVoidRouter(config) {
+	{
+		const engine = await createPageNavigationEngine(config);
+		let routeUrl = currentUrl();
+		let activeNavigationId = null;
+		const setRouteUrl = (url) => {
+			routeUrl = url;
+			config.onRouteChange?.(url);
+		};
+		const setNavigation = (navigation) => {
+			config.onNavigationChange?.(navigation);
+		};
+		async function applyNavigationResource(resource) {
+			activeNavigationId = resource.id;
+			setNavigation(navigationStateFor(resource.fetchUrl + resource.hash, resource.method));
+			try {
+				const result = await resource.shell;
+				if (!result) return;
+				const applyUpdate = () => config.adapter.applyUpdate(result.pageData, result.component, result.layouts);
+				if ((resource.options.viewTransition ?? config.viewTransitions) && document.startViewTransition) await document.startViewTransition(() => applyUpdate()).updateCallbackDone;
+				else await applyUpdate();
+				await resource.commit();
+				if (activeNavigationId === resource.id) setRouteUrl(currentUrl());
+				return result.pageData;
+			} finally {
+				if (activeNavigationId === resource.id) {
+					activeNavigationId = null;
+					setRouteUrl(currentUrl());
+					setNavigation(idleNavigationState());
+				}
+			}
+		}
+		const rawRouter = {
+			_hoverDelay: engine._hoverDelay,
+			get url() {
+				return toUrl(routeUrl);
+			},
+			get path() {
+				return this.url.pathname;
+			},
+			get query() {
+				return this.url.searchParams;
+			},
+			visit(url, options = {}) {
+				return applyNavigationResource(engine.prepareVisit(normalizeUrl(url), options));
+			},
+			refresh(options = {}) {
+				return rawRouter.visit(window.location.pathname + window.location.search, {
+					preserveState: true,
+					preserveScroll: true,
+					...options
+				});
+			},
+			prefetch(url, options = {}) {
+				return engine.prefetch(normalizeUrl(url), options);
+			},
+			flush(url, method = "GET") {
+				engine.flush(normalizeUrl(url), method);
+			},
+			flushAll() {
+				engine.flushAll();
+			}
+		};
+		const router = createRouterFacade(rawRouter, () => routeUrl);
+		engine.setPopStateHandler((url, options) => {
+			router.visit(url, options);
+		});
+		return {
+			router,
+			initialPageData: engine.initialPageData,
+			initialComponent: engine.initialComponent,
+			initialLayouts: engine.initialLayouts,
+			start: engine.start
+		};
+	}
+}
+function scheduleHydration(el, loader, props, strategy, hydrateFn) {
+	const hydrate = () => loader().then((mod) => hydrateFn(el, mod, props));
+	if (strategy === "load") hydrate();
+	else if (strategy === "visible") {
+		const observer = new IntersectionObserver((entries) => {
+			if (entries[0].isIntersecting) {
+				observer.disconnect();
+				hydrate();
+			}
+		});
+		observer.observe(el);
+	} else if (strategy === "idle") (window.requestIdleCallback?.bind(window) ?? ((cb) => setTimeout(cb, 1)))(() => hydrate());
+	else if (strategy.startsWith("media:")) {
+		const query = strategy.slice(6);
+		const mql = matchMedia(query);
+		const check = () => {
+			if (mql.matches) {
+				mql.removeEventListener("change", check);
+				hydrate();
+			}
+		};
+		mql.addEventListener("change", check);
+		check();
+	}
+}
+function initIslands(islands, hydrateFn) {
+	document.querySelectorAll("[data-island]").forEach((el) => {
+		const id = el.getAttribute("data-island");
+		const props = JSON.parse(el.getAttribute("data-props") || "{}");
+		const strategy = el.getAttribute("data-hydrate") || "load";
+		const loader = islands[id];
+		if (loader) scheduleHydration(el, loader, props, strategy, hydrateFn);
+	});
+}
+//#endregion
+export { VoidActionError, categorizeActionError, createPageNavigationEngine, createRouterFacade, createSsrRouter, createVoidRouter, hasFiles, idleNavigationState, initIslands, isAbortError, isCallSiteActionError, isEqualFormValue, isFile, objectToFormData, scheduleHydration, ssrProxy, submitAction };