boltdocs 3.2.2 → 3.3.1

package/dist/router-C3kygdRK.cjs

@@ -0,0 +1,1285 @@
+/**
+ * Boltdocs - https://boltdocs.vercel.app
+ * Copyright (c) 2026 Jesus Alcala
+ * Licensed under the MIT License.
+ */
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (!no_symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let react = require("react");
+react = __toESM(react);
+let react_jsx_runtime = require("react/jsx-runtime");
+
+//#region src/client/router/utils.ts
+function normalizeBasename(basename) {
+	if (!basename || basename === "/") return "/";
+	return basename.replace(/\/$/, "") || "/";
+}
+function hasBasename(path, basename) {
+	const normalized = normalizeBasename(basename);
+	if (normalized === "/") return true;
+	if (path === normalized) return true;
+	return path.startsWith(`${normalized}/`);
+}
+function stripBasename(path, basename) {
+	const normalized = normalizeBasename(basename);
+	if (normalized === "/") return path;
+	if (!hasBasename(path, normalized)) return path;
+	const stripped = path.slice(normalized.length);
+	return stripped.startsWith("/") ? stripped : `/${stripped}`;
+}
+function addBasename(path, basename) {
+	const normalized = normalizeBasename(basename);
+	if (normalized === "/") return path;
+	if (hasBasename(path, normalized)) return path;
+	if (path.startsWith("/")) return `${normalized}${path}`;
+	return `${normalized}/${path}`;
+}
+
+//#endregion
+//#region src/client/router/context.tsx
+function getActiveLocale() {
+	if (typeof globalThis === "undefined") return void 0;
+	const instance = globalThis[Symbol.for("__BDOCS_BOLTDOCS_INSTANCE__")];
+	if (instance && typeof instance === "object" && "currentLocale" in instance && typeof instance.currentLocale === "string") return instance.currentLocale;
+	if (typeof window === "undefined") return void 0;
+	try {
+		const raw = window.localStorage.getItem("boltdocs-user-preferences");
+		if (!raw) return void 0;
+		const preferences = JSON.parse(raw);
+		return typeof preferences.locale === "string" ? preferences.locale : void 0;
+	} catch {
+		return;
+	}
+}
+const defaultNavigate = () => {};
+const defaultLocation = {
+	pathname: "/",
+	search: "",
+	hash: ""
+};
+const g$1 = typeof globalThis !== "undefined" ? globalThis : {};
+function getGlobalContext(key, create) {
+	const existing = g$1[key];
+	if (existing) return existing;
+	const context = create();
+	g$1[key] = context;
+	return context;
+}
+const LocationContext = getGlobalContext("__BOLTDOCS_LOCATION_CONTEXT__", () => (0, react.createContext)(defaultLocation));
+const NavigateContext = getGlobalContext("__BOLTDOCS_NAVIGATE_CONTEXT__", () => (0, react.createContext)(defaultNavigate));
+const PrefetchContext = getGlobalContext("__BOLTDOCS_PREFETCH_CONTEXT__", () => (0, react.createContext)(async () => {}));
+const RouteDataContext = getGlobalContext("__BOLTDOCS_ROUTE_DATA_CONTEXT__", () => (0, react.createContext)(null));
+const MatchesContext = getGlobalContext("__BOLTDOCS_MATCHES_CONTEXT__", () => (0, react.createContext)([]));
+function normalizeComparablePath(pathname) {
+	if (pathname.length <= 1) return pathname || "/";
+	return pathname.replace(/\/$/, "") || "/";
+}
+function dispatchNavigationStart(location) {
+	if (typeof window === "undefined") return;
+	window.dispatchEvent(new CustomEvent("boltdocs:navigation-start", { detail: location }));
+}
+function scheduleLocationUpdate(setLocation, nextLocation, viewTransitions) {
+	setTimeout(() => {
+		const enabled = typeof viewTransitions === "boolean" ? viewTransitions : viewTransitions?.enabled === true;
+		const startViewTransition = document.startViewTransition;
+		if (enabled && startViewTransition) {
+			const types = typeof viewTransitions === "object" ? viewTransitions.types : void 0;
+			startViewTransition.call(document, {
+				update: () => setLocation(nextLocation),
+				...types?.length ? { types } : {}
+			});
+			return;
+		}
+		setLocation(nextLocation);
+	}, 0);
+}
+function getLocationFromWindow() {
+	if (typeof window === "undefined") return defaultLocation;
+	return {
+		pathname: window.location.pathname || "/",
+		search: window.location.search || "",
+		hash: window.location.hash || ""
+	};
+}
+const LocationProvider = ({ pathname: propPathname, children, loaderData = null, matches = [], basename, defaultLocale, prefetch: prefetchProp, viewTransitions }) => {
+	const [location, setLocation] = (0, react.useState)(() => {
+		if (typeof window !== "undefined") return getLocationFromWindow();
+		return propPathname ? {
+			pathname: propPathname,
+			search: "",
+			hash: ""
+		} : defaultLocation;
+	});
+	(0, react.useEffect)(() => {
+		if (typeof window === "undefined") return;
+		const handlePopState = () => {
+			const nextLocation = getLocationFromWindow();
+			scheduleLocationUpdate(setLocation, nextLocation, viewTransitions);
+			dispatchNavigationStart(nextLocation);
+		};
+		window.addEventListener("popstate", handlePopState);
+		return () => window.removeEventListener("popstate", handlePopState);
+	}, [viewTransitions]);
+	const prefetched = (0, react.useRef)(/* @__PURE__ */ new Set());
+	const fallbackPrefetch = (0, react.useCallback)(async (to) => {
+		if (typeof window === "undefined" || !to || prefetched.current.has(to)) return;
+		prefetched.current.add(to);
+	}, []);
+	const prefetch = prefetchProp ?? fallbackPrefetch;
+	const navigate = (0, react.useCallback)((to, options) => {
+		if (typeof window === "undefined") return;
+		if (!to) return;
+		const normalizedBasename = normalizeBasename(basename);
+		if (/^https?:\/\//i.test(to) || to.startsWith("//")) {
+			window.location.href = to;
+			return;
+		}
+		if (to.startsWith("#")) {
+			const newUrl = new URL(to, window.location.href);
+			const nextLocation = {
+				pathname: window.location.pathname,
+				search: window.location.search,
+				hash: newUrl.hash
+			};
+			if (nextLocation.pathname === window.location.pathname && nextLocation.search === window.location.search && nextLocation.hash === window.location.hash) {
+				if (options?.state !== void 0) if (options.replace) window.history.replaceState(options.state, "", newUrl.href);
+				else window.history.pushState(options.state, "", newUrl.href);
+				return;
+			}
+			if (options?.replace) window.history.replaceState(options.state ?? null, "", newUrl.href);
+			else window.history.pushState(options?.state ?? null, "", newUrl.href);
+			scheduleLocationUpdate(setLocation, nextLocation, options?.viewTransition === false ? false : viewTransitions);
+			dispatchNavigationStart(nextLocation);
+			return;
+		}
+		const resolvedUrl = new URL(to, window.location.href);
+		if (resolvedUrl.origin !== window.location.origin) {
+			window.location.href = to;
+			return;
+		}
+		let finalPath = resolvedUrl.pathname + resolvedUrl.search + resolvedUrl.hash;
+		if (normalizedBasename !== "/" && !hasBasename(resolvedUrl.pathname, normalizedBasename)) {
+			const activeLocale = getActiveLocale();
+			if (activeLocale && defaultLocale && activeLocale !== defaultLocale && !finalPath.startsWith(`/${activeLocale}/`) && finalPath !== `/${activeLocale}`) finalPath = `/${activeLocale}${finalPath === "/" ? "" : finalPath}`;
+		} else if (normalizedBasename !== "/") finalPath = addBasename(finalPath, normalizedBasename);
+		const finalUrl = new URL(finalPath, window.location.href);
+		if (normalizeComparablePath(finalUrl.pathname) === normalizeComparablePath(window.location.pathname) && finalUrl.search === window.location.search && finalUrl.hash === window.location.hash) {
+			if (options?.state !== void 0) if (options.replace) window.history.replaceState(options.state, "", finalPath);
+			else window.history.pushState(options.state, "", finalPath);
+			return;
+		}
+		if (options?.replace) window.history.replaceState(options?.state ?? null, "", finalPath);
+		else window.history.pushState(options?.state ?? null, "", finalPath);
+		const nextLocation = {
+			pathname: finalUrl.pathname,
+			search: finalUrl.search,
+			hash: finalUrl.hash
+		};
+		scheduleLocationUpdate(setLocation, nextLocation, options?.viewTransition === false ? false : viewTransitions);
+		dispatchNavigationStart(nextLocation);
+	}, [
+		basename,
+		defaultLocale,
+		viewTransitions
+	]);
+	(0, react.useEffect)(() => {
+		if (typeof window === "undefined") return;
+		const normalizedBasename = normalizeBasename(basename);
+		const handleClick = (e) => {
+			if (e.defaultPrevented || e.button !== 0 || e.metaKey || e.altKey || e.ctrlKey || e.shiftKey) return;
+			let target = e.target;
+			while (target && target.nodeName !== "A") target = target.parentElement;
+			if (!target || target.nodeName !== "A") return;
+			const anchor = target;
+			const href = anchor.getAttribute("href");
+			if (!href || anchor.target === "_blank" || anchor.hasAttribute("download") || href.startsWith("#")) return;
+			if (/^https?:\/\//i.test(href) || href.startsWith("//")) return;
+			let resolvedPathname;
+			try {
+				const resolved = new URL(href, document.baseURI || window.location.href);
+				if (resolved.origin !== window.location.origin) return;
+				resolvedPathname = resolved.pathname;
+			} catch {
+				return;
+			}
+			const isUnderBasename = normalizedBasename === "/" || hasBasename(resolvedPathname, normalizedBasename);
+			const currentIsUnderBasename = normalizedBasename === "/" || hasBasename(window.location.pathname, normalizedBasename);
+			if (!isUnderBasename && currentIsUnderBasename) return;
+			e.preventDefault();
+			navigate(href);
+		};
+		document.addEventListener("click", handleClick);
+		return () => document.removeEventListener("click", handleClick);
+	}, [navigate, basename]);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(LocationContext.Provider, {
+		value: location,
+		children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(NavigateContext.Provider, {
+			value: navigate,
+			children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(PrefetchContext.Provider, {
+				value: prefetch,
+				children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(RouteDataContext.Provider, {
+					value: loaderData,
+					children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(MatchesContext.Provider, {
+						value: matches,
+						children
+					})
+				})
+			})
+		})
+	});
+};
+
+//#endregion
+//#region src/client/router/hooks.ts
+function useLocation() {
+	return (0, react.use)(LocationContext);
+}
+function useNavigate() {
+	return (0, react.use)(NavigateContext);
+}
+function usePrefetch() {
+	return (0, react.use)(PrefetchContext);
+}
+function useRouteData() {
+	return (0, react.use)(RouteDataContext);
+}
+/** Alias for useRouteData — parity with react-router-dom's useLoaderData */
+function useLoaderData() {
+	return (0, react.use)(RouteDataContext);
+}
+function useMatches() {
+	return (0, react.use)(MatchesContext);
+}
+
+//#endregion
+//#region src/client/router/outlet.tsx
+const g = typeof globalThis !== "undefined" ? globalThis : {};
+const existingOutletContext = g.__BOLTDOCS_OUTLET_CONTEXT__;
+const OutletContext = existingOutletContext ?? (0, react.createContext)(null);
+if (!existingOutletContext) g.__BOLTDOCS_OUTLET_CONTEXT__ = OutletContext;
+const Outlet = () => {
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(react_jsx_runtime.Fragment, { children: (0, react.use)(OutletContext) });
+};
+
+//#endregion
+//#region src/client/router/renderer.tsx
+function normalizePath(path) {
+	if (!path) return "/";
+	const normalized = path.replace(/\\/g, "/").replace(/\/+/g, "/");
+	if (normalized.length > 1 && normalized.endsWith("/")) return normalized.slice(0, -1);
+	return normalized;
+}
+function splitRoutePath(path) {
+	return normalizePath(path).replace(/^\//, "").split("/").filter((segment) => segment && segment !== ".");
+}
+const preparedRouteCache = /* @__PURE__ */ new WeakMap();
+const routeMatchCache = /* @__PURE__ */ new WeakMap();
+const routeSegmentsCache = /* @__PURE__ */ new WeakMap();
+function getRouteSegments(route) {
+	let segments = routeSegmentsCache.get(route);
+	if (!segments) {
+		segments = route.path ? splitRoutePath(route.path) : [];
+		routeSegmentsCache.set(route, segments);
+	}
+	return segments;
+}
+function getPreparedRoutes(routes) {
+	const cached = preparedRouteCache.get(routes);
+	if (cached) return cached;
+	const prepared = routes.map((route, index) => ({
+		route,
+		index,
+		segments: getRouteSegments(route),
+		score: routeScore(route),
+		children: route.children ? getPreparedRoutes(route.children) : void 0
+	})).sort((a, b) => b.score - a.score || a.index - b.index).map(({ route, segments, score, children }) => ({
+		route,
+		segments,
+		score,
+		children
+	}));
+	preparedRouteCache.set(routes, prepared);
+	return prepared;
+}
+function matchRoutePath(preparedRoute, target) {
+	const route = preparedRoute.route;
+	if (route.index || route.path === "" || route.path === ".") return target.length === 0 ? {
+		consumed: 0,
+		exact: true,
+		wildcard: false,
+		params: {}
+	} : null;
+	if (!route.path) return {
+		consumed: 0,
+		exact: !route.children?.length && target.length === 0,
+		wildcard: false,
+		params: {}
+	};
+	const routeSegments = preparedRoute.segments;
+	if (routeSegments.length === 0) return target.length === 0 ? {
+		consumed: 0,
+		exact: true,
+		wildcard: false,
+		params: {}
+	} : null;
+	let consumed = 0;
+	const params = {};
+	for (const segment of routeSegments) {
+		if (segment === "*") {
+			params["*"] = target.slice(consumed).join("/");
+			return {
+				consumed: target.length,
+				exact: true,
+				wildcard: true,
+				params
+			};
+		}
+		const targetSegment = target[consumed];
+		if (targetSegment === void 0) return null;
+		if (segment.startsWith(":")) params[segment.slice(1)] = targetSegment;
+		else if (segment !== targetSegment) return null;
+		consumed++;
+	}
+	return {
+		consumed,
+		exact: consumed === target.length,
+		wildcard: false,
+		params
+	};
+}
+function routeScore(route) {
+	if (route.index || route.path === "" || route.path === ".") return 1e3;
+	if (route.path === "*") return -1e3;
+	if (!route.path) return 0;
+	return splitRoutePath(route.path).reduce((score, segment) => {
+		if (segment === "*") return score - 100;
+		if (segment.startsWith(":")) return score + 10;
+		return score + 100;
+	}, 0);
+}
+function matchRouteBranchInternal(routes, target) {
+	for (const preparedRoute of routes) {
+		const route = preparedRoute.route;
+		const match = matchRoutePath(preparedRoute, target);
+		if (!match) continue;
+		const remaining = target.slice(match.consumed);
+		if (preparedRoute.children?.length) {
+			const childBranch = matchRouteBranchInternal(preparedRoute.children, remaining);
+			if (childBranch.length > 0) return [{
+				route,
+				params: match.params
+			}, ...childBranch.map((child) => ({
+				route: child.route,
+				params: {
+					...match.params,
+					...child.params
+				}
+			}))];
+			if (!match.exact) continue;
+		}
+		if (match.exact || match.wildcard) return [{
+			route,
+			params: match.params
+		}];
+	}
+	return [];
+}
+function getTargetSegments(pathname, basename) {
+	const normalizedPathname = normalizePath(pathname);
+	const targets = [splitRoutePath(normalizedPathname)];
+	const normalizedBasename = normalizeBasename(basename);
+	if (normalizedBasename !== "/" && hasBasename(normalizedPathname, normalizedBasename)) targets.push(splitRoutePath(stripBasename(normalizedPathname, normalizedBasename)));
+	return targets;
+}
+function matchRouteBranchWithParams(routes, pathname, basename) {
+	const cacheKey = `${normalizePath(pathname)}\u0000${normalizeBasename(basename)}`;
+	let matches = routeMatchCache.get(routes);
+	if (!matches) {
+		matches = /* @__PURE__ */ new Map();
+		routeMatchCache.set(routes, matches);
+	}
+	const cached = matches.get(cacheKey);
+	if (cached) return cached;
+	const preparedRoutes = getPreparedRoutes(routes);
+	for (const target of getTargetSegments(pathname, basename)) {
+		const branch = matchRouteBranchInternal(preparedRoutes, target);
+		if (branch.length > 0) {
+			cacheRouteEntry(matches, cacheKey, branch);
+			return branch;
+		}
+	}
+	cacheRouteEntry(matches, cacheKey, []);
+	return [];
+}
+function matchRouteBranch(routes, pathname, basename) {
+	return matchRouteBranchWithParams(routes, pathname, basename).map((match) => match.route);
+}
+const resolvedLazyCache = /* @__PURE__ */ new WeakMap();
+const pendingLazyCache = /* @__PURE__ */ new WeakMap();
+const routeCacheScopes = /* @__PURE__ */ new WeakMap();
+let nextRouteCacheScope = 0;
+const prefetchCache = /* @__PURE__ */ new Map();
+const loaderDataCache = /* @__PURE__ */ new Map();
+const MAX_ROUTE_CACHE_ENTRIES = 128;
+const MAX_ACTIVE_PREFETCHES = 2;
+const MAX_PENDING_PREFETCHES = 16;
+const ROUTE_RESOLUTION_TIMEOUT_MS = 4500;
+const ROUTE_LOADER_TIMEOUT_MS = 4500;
+const PREFETCH_SKIPPED = Symbol("prefetch-skipped");
+function withTimeout(promise, timeoutMs, message) {
+	return new Promise((resolve, reject) => {
+		const timer = setTimeout(() => reject(new Error(message)), timeoutMs);
+		promise.then((value) => {
+			clearTimeout(timer);
+			resolve(value);
+		}, (error) => {
+			clearTimeout(timer);
+			reject(error);
+		});
+	});
+}
+function createPrefetchQueue() {
+	let activePrefetches = 0;
+	const pendingPrefetches = [];
+	const drain = () => {
+		while (activePrefetches < MAX_ACTIVE_PREFETCHES && pendingPrefetches.length > 0) {
+			const task = pendingPrefetches.shift();
+			if (!task) break;
+			activePrefetches++;
+			task.run().then(task.resolve, task.reject).finally(() => {
+				activePrefetches--;
+				drain();
+			});
+		}
+	};
+	return {
+		enqueue(run) {
+			if (pendingPrefetches.length >= MAX_PENDING_PREFETCHES) return PREFETCH_SKIPPED;
+			return new Promise((resolve, reject) => {
+				pendingPrefetches.push({
+					run,
+					resolve,
+					reject
+				});
+				drain();
+			});
+		},
+		clear() {
+			for (const task of pendingPrefetches.splice(0)) task.resolve();
+		}
+	};
+}
+function getRouteCacheScope(routes) {
+	let scope = routeCacheScopes.get(routes);
+	if (scope === void 0) {
+		scope = ++nextRouteCacheScope;
+		routeCacheScopes.set(routes, scope);
+	}
+	return scope;
+}
+function cacheRouteEntry(cache, key, value) {
+	if (cache.size >= MAX_ROUTE_CACHE_ENTRIES) {
+		const oldest = cache.keys().next().value;
+		if (oldest !== void 0) cache.delete(oldest);
+	}
+	cache.set(key, value);
+}
+async function resolveRouteBranch(branch) {
+	const resolved = [];
+	for (const route of branch) {
+		if (!route.element && !route.Component && route.lazy) try {
+			let result = resolvedLazyCache.get(route);
+			if (!result) {
+				let pending = pendingLazyCache.get(route);
+				if (!pending) {
+					pending = route.lazy();
+					pendingLazyCache.set(route, pending);
+				}
+				try {
+					result = await withTimeout(pending, ROUTE_RESOLUTION_TIMEOUT_MS, "Timed out while loading a documentation route");
+				} finally {
+					pendingLazyCache.delete(route);
+				}
+				resolvedLazyCache.set(route, result);
+			}
+			resolved.push({
+				...route,
+				...result
+			});
+			continue;
+		} catch (err) {
+			console.error("[RouteRenderer] Error resolving lazy route:", err);
+		}
+		resolved.push(route);
+	}
+	return resolved;
+}
+function asLoaderData(value) {
+	return value !== null && typeof value === "object" ? value : null;
+}
+function getLoaderDataKey(routeScope, pathname, search = "") {
+	return `${routeScope}:${pathname}${search}`;
+}
+function loadRouteData(key, matches, resolvedBranch, request) {
+	const cached = loaderDataCache.get(key);
+	if (cached) return cached;
+	const pending = withTimeout(Promise.all(resolvedBranch.map(async (route, index) => {
+		if (!route?.loader) return null;
+		try {
+			return asLoaderData(await route.loader({
+				request,
+				params: matches[index].params
+			}));
+		} catch (err) {
+			console.error("[RouteRenderer] loader error:", err);
+			throw err;
+		}
+	})).then((values) => {
+		const merged = {};
+		for (const value of values) if (value) Object.assign(merged, value);
+		return merged;
+	}), ROUTE_LOADER_TIMEOUT_MS, "Timed out while loading documentation data");
+	cacheRouteEntry(loaderDataCache, key, pending);
+	pending.catch(() => loaderDataCache.delete(key));
+	return pending;
+}
+function RouteContent({ routes, initialPathname, resolvedBranch: initialResolvedBranch, basename, hasLoaderData }) {
+	const location = useLocation();
+	const currentPathname = location.pathname || initialPathname || "/";
+	const currentSearch = location.search || "";
+	const currentHash = location.hash || "";
+	const routeMatches = (0, react.useMemo)(() => matchRouteBranchWithParams(routes, currentPathname, basename), [
+		routes,
+		currentPathname,
+		basename
+	]);
+	const matchedBranch = (0, react.useMemo)(() => routeMatches.map((match) => match.route), [routeMatches]);
+	const isFirstRenderRef = (0, react.useRef)(true);
+	const isInitialNavigation = currentPathname === initialPathname && isFirstRenderRef.current;
+	const usesInitialResolvedBranch = !!initialResolvedBranch && isInitialNavigation;
+	const initialBranch = (0, react.useMemo)(() => usesInitialResolvedBranch ? initialResolvedBranch : matchedBranch, [
+		matchedBranch,
+		usesInitialResolvedBranch,
+		initialResolvedBranch
+	]);
+	const initialLoaderData = asLoaderData((0, react.use)(RouteDataContext));
+	const initialDataAvailable = isInitialNavigation && hasLoaderData === true;
+	const needsAsyncWork = initialBranch.some((route) => !usesInitialResolvedBranch && !route.element && !route.Component && !!route.lazy || !!route.loader && !initialDataAvailable);
+	const routeScope = getRouteCacheScope(routes);
+	const navigationKey = `${routeScope}\u0000${currentPathname}\u0000${currentSearch}`;
+	const outerData = initialDataAvailable ? initialLoaderData : null;
+	const outerDataRef = (0, react.useRef)(outerData);
+	outerDataRef.current = outerData;
+	const navigationIdRef = (0, react.useRef)(0);
+	const committedNavigationRef = (0, react.useRef)("");
+	const [resolved, setResolved] = (0, react.useState)(!needsAsyncWork ? {
+		branch: initialBranch,
+		key: navigationKey,
+		pathname: currentPathname,
+		search: currentSearch,
+		loaderData: outerData
+	} : null);
+	const routeNeedsAsyncWork = needsAsyncWork && resolved?.key !== navigationKey;
+	(0, react.useEffect)(() => {
+		isFirstRenderRef.current = false;
+	}, []);
+	(0, react.useEffect)(() => {
+		if (!routeNeedsAsyncWork) return;
+		const navigationId = ++navigationIdRef.current;
+		let cancelled = false;
+		const matches = routeMatches;
+		const branch = matchedBranch;
+		const requestUrl = typeof window !== "undefined" ? new URL(`${currentPathname}${currentSearch}`, window.location.origin).href : `http://localhost${currentPathname}${currentSearch}`;
+		resolveRouteBranch(branch).then(async (resolvedBranch) => {
+			if (cancelled || navigationId !== navigationIdRef.current) return;
+			let loaderData;
+			try {
+				loaderData = await loadRouteData(getLoaderDataKey(routeScope, currentPathname, currentSearch), matches, resolvedBranch, new Request(requestUrl));
+			} catch {
+				loaderData = {
+					...outerDataRef.current || {},
+					__loaderError: true
+				};
+			}
+			if (cancelled || navigationId !== navigationIdRef.current) return;
+			(0, react.startTransition)(() => {
+				setResolved({
+					branch: resolvedBranch,
+					key: navigationKey,
+					pathname: currentPathname,
+					search: currentSearch,
+					loaderData
+				});
+			});
+		}).catch((error) => {
+			if (cancelled || navigationId !== navigationIdRef.current) return;
+			console.warn("[RouteRenderer] navigation error:", error);
+			(0, react.startTransition)(() => {
+				setResolved({
+					branch,
+					key: navigationKey,
+					pathname: currentPathname,
+					search: currentSearch,
+					loaderData: {
+						...outerDataRef.current || {},
+						__routeError: true
+					}
+				});
+			});
+		});
+		return () => {
+			cancelled = true;
+		};
+	}, [
+		currentPathname,
+		currentSearch,
+		routeMatches,
+		matchedBranch,
+		routeNeedsAsyncWork,
+		navigationKey,
+		routeScope
+	]);
+	const hasResolvedCurrentRoute = resolved?.key === navigationKey;
+	const hasRenderableBranch = (0, react.useCallback)((candidate) => candidate.some((route) => route.element || route.Component), []);
+	const previousBranch = resolved?.branch;
+	const lastRenderableBranchRef = (0, react.useRef)([]);
+	const branch = usesInitialResolvedBranch ? hasResolvedCurrentRoute ? resolved.branch : initialBranch : !routeNeedsAsyncWork || hasResolvedCurrentRoute ? hasResolvedCurrentRoute ? resolved.branch : initialBranch : hasRenderableBranch(previousBranch || []) ? previousBranch || [] : hasRenderableBranch(lastRenderableBranchRef.current) ? lastRenderableBranchRef.current : matchedBranch;
+	if (hasResolvedCurrentRoute && hasRenderableBranch(branch)) lastRenderableBranchRef.current = branch;
+	(0, react.useEffect)(() => {
+		if (typeof window === "undefined") return;
+		const commitKey = `${currentPathname}${currentSearch}${currentHash}`;
+		if (committedNavigationRef.current === commitKey) return;
+		if (routeNeedsAsyncWork && !hasResolvedCurrentRoute) return;
+		if (!hasRenderableBranch(branch)) return;
+		committedNavigationRef.current = commitKey;
+		window.dispatchEvent(new CustomEvent("boltdocs:route-commit", { detail: {
+			pathname: currentPathname,
+			search: currentSearch,
+			hash: currentHash
+		} }));
+	}, [
+		branch,
+		currentHash,
+		currentPathname,
+		currentSearch,
+		hasRenderableBranch,
+		hasResolvedCurrentRoute,
+		routeNeedsAsyncWork
+	]);
+	if (branch.length === 0) return null;
+	let currentElement = null;
+	for (let i = branch.length - 1; i >= 0; i--) {
+		const route = branch[i];
+		let element = route.element;
+		if (!element && route.Component) {
+			const Comp = route.Component;
+			element = /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Comp, {}, route.path ?? `${route.index ? "index" : "route"}-${route.locale ?? "none"}`);
+		}
+		if (!element) continue;
+		if (currentElement === null) currentElement = element;
+		else {
+			let wrappedElement = element;
+			if (react.default.isValidElement(element)) {
+				const el = element;
+				const existingChildren = el.props.children;
+				wrappedElement = react.default.cloneElement(el, { children: existingChildren ?? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Outlet, {}) });
+			}
+			currentElement = /* @__PURE__ */ (0, react_jsx_runtime.jsx)(OutletContext.Provider, {
+				value: currentElement,
+				children: wrappedElement
+			});
+		}
+	}
+	const finalData = hasResolvedCurrentRoute && resolved.loaderData ? resolved.loaderData : outerData;
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(RouteDataContext.Provider, {
+		value: finalData,
+		children: currentElement
+	});
+}
+const RouteRenderer = ({ routes, pathname, loaderData, resolvedBranch, basename, defaultLocale, hasLoaderData = false, prefetch: prefetchProp, viewTransitions }) => {
+	const prefetchQueueRef = (0, react.useRef)(null);
+	if (!prefetchQueueRef.current) prefetchQueueRef.current = createPrefetchQueue();
+	const prefetchQueue = prefetchQueueRef.current;
+	(0, react.useEffect)(() => {
+		return () => prefetchQueue.clear();
+	}, [prefetchQueue]);
+	const prefetch = (0, react.useCallback)(async (to) => {
+		if (typeof window === "undefined" || !to) return;
+		const target = new URL(to, window.location.href);
+		if (target.origin !== window.location.origin || target.hash) return;
+		const key = `${getRouteCacheScope(routes)}:${target.pathname}${target.search}`;
+		const cached = prefetchCache.get(key);
+		if (cached) return cached;
+		const pending = prefetchQueue.enqueue(async () => {
+			const matches = matchRouteBranchWithParams(routes, target.pathname, basename);
+			if (matches.length === 0) return;
+			const branch = await resolveRouteBranch(matches.map((match) => match.route));
+			await loadRouteData(getLoaderDataKey(getRouteCacheScope(routes), target.pathname, target.search), matches, branch, new Request(target.href));
+		});
+		if (pending === PREFETCH_SKIPPED) return;
+		cacheRouteEntry(prefetchCache, key, pending);
+		try {
+			await pending;
+		} catch (error) {
+			prefetchCache.delete(key);
+			throw error;
+		}
+	}, [
+		routes,
+		basename,
+		prefetchQueue
+	]);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(LocationProvider, {
+		pathname,
+		loaderData,
+		basename,
+		defaultLocale,
+		prefetch: prefetchProp || prefetch,
+		viewTransitions,
+		children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(RouteContent, {
+			routes,
+			initialPathname: pathname,
+			resolvedBranch,
+			basename,
+			hasLoaderData
+		})
+	});
+};
+
+//#endregion
+//#region src/client/router/url-contract.ts
+function normalizeUrlBase(base) {
+	if (!base || base === "/") return "/";
+	return (base.startsWith("/") ? base : `/${base}`).replace(/\/+/g, "/").replace(/\/$/, "") || "/";
+}
+function normalizeUrlPath(path) {
+	if (!path) return "/";
+	const normalized = `/${path}`.replace(/\/+/g, "/");
+	if (normalized.length > 1 && normalized.endsWith("/")) return normalized.slice(0, -1);
+	return normalized;
+}
+function hasUrlBase(pathname, base) {
+	const normalizedPath = normalizeUrlPath(pathname);
+	const normalizedBase = normalizeUrlBase(base);
+	if (normalizedBase === "/") return true;
+	return normalizedPath === normalizedBase || normalizedPath.startsWith(`${normalizedBase}/`);
+}
+function stripUrlBase(pathname, base) {
+	const normalizedPath = normalizeUrlPath(pathname);
+	const normalizedBase = normalizeUrlBase(base);
+	if (normalizedBase === "/") return normalizedPath;
+	if (!hasUrlBase(normalizedPath, normalizedBase)) return normalizedPath;
+	return normalizeUrlPath(normalizedPath.slice(normalizedBase.length) || "/");
+}
+function addUrlBase(pathname, base) {
+	const normalizedPath = normalizeUrlPath(pathname);
+	const normalizedBase = normalizeUrlBase(base);
+	if (normalizedBase === "/" || hasUrlBase(normalizedPath, normalizedBase)) return normalizedPath;
+	return normalizeUrlPath(`${normalizedBase}/${normalizedPath}`);
+}
+function getConfiguredLocales(config) {
+	if (!config.i18n) return [];
+	return Array.isArray(config.i18n.locales) ? [...config.i18n.locales] : Object.keys(config.i18n.locales);
+}
+function getConfiguredVersions(config) {
+	return config.versions?.versions.map((version) => version.path) || [];
+}
+function getVersionPrefixSegments(config) {
+	const prefix = config.versions?.prefix;
+	if (!prefix) return [];
+	return normalizeUrlPath(prefix).split("/").filter(Boolean);
+}
+function getVersionSegments(version, config) {
+	if (!version || !config.versions || !isConfiguredVersion(version, config)) return [];
+	return [...getVersionPrefixSegments(config), version];
+}
+function isConfiguredLocale(value, config) {
+	return !!value && getConfiguredLocales(config).includes(value);
+}
+function isConfiguredVersion(value, config) {
+	return !!value && getConfiguredVersions(config).includes(value);
+}
+function matchConfiguredVersion(parts, start, config) {
+	const prefix = getVersionPrefixSegments(config);
+	const versionIndex = start + prefix.length;
+	if (!prefix.every((segment, index) => parts[start + index] === segment) || !isConfiguredVersion(parts[versionIndex], config)) return { nextIndex: start };
+	return {
+		version: parts[versionIndex],
+		nextIndex: versionIndex + 1
+	};
+}
+function splitUrlReference(to) {
+	const firstDelimiter = to.search(/[?#]/);
+	if (firstDelimiter < 0) return {
+		pathname: to,
+		search: "",
+		hash: ""
+	};
+	const pathname = to.slice(0, firstDelimiter);
+	const suffix = to.slice(firstDelimiter);
+	const hashIndex = suffix.indexOf("#");
+	if (hashIndex < 0) return {
+		pathname,
+		search: suffix,
+		hash: ""
+	};
+	return {
+		pathname,
+		search: suffix.slice(0, hashIndex),
+		hash: suffix.slice(hashIndex)
+	};
+}
+function stripSiteProtocol(to) {
+	if (!to.startsWith("site:")) return {
+		value: to,
+		siteProtocol: false
+	};
+	return {
+		value: to.slice(5) || "/",
+		siteProtocol: true
+	};
+}
+/** Returns true for URI schemes such as `mailto:`, `tel:`, or `data:`. */
+function hasUriScheme(value) {
+	return /^[a-z][a-z\d+.-]*:/i.test(value);
+}
+function normalizeSuffix(value, prefix) {
+	if (!value) return "";
+	return value.startsWith(prefix) ? value : `${prefix}${value}`;
+}
+function getRouteHint(pathname, routes) {
+	if (!routes) return void 0;
+	const normalized = normalizeUrlPath(pathname);
+	return routes.find((route) => normalizeUrlPath(route.path) === normalized);
+}
+function getCollectionFromPath(pathname, config) {
+	const parts = normalizeUrlPath(pathname).split("/").filter(Boolean);
+	const locales = getConfiguredLocales(config);
+	const collectionNames = Array.isArray(config.collections) ? config.collections : Object.keys(config.collections?.labels || {});
+	const collections = new Set(collectionNames);
+	let index = 0;
+	const versionMatch = matchConfiguredVersion(parts, index, config);
+	const version = versionMatch.version;
+	index = versionMatch.nextIndex;
+	let locale;
+	if (locales.includes(parts[index] || "")) {
+		locale = parts[index];
+		index++;
+	}
+	const collection = parts[index];
+	if (!collection || !collections.has(collection)) return { remainder: parts };
+	return {
+		collection,
+		locale,
+		version,
+		remainder: parts.slice(index + 1)
+	};
+}
+function classifyUrlPath(pathname, config, options = {}) {
+	if (options.kind) return options.kind;
+	const normalizedPath = normalizeUrlPath(pathname);
+	const hint = getRouteHint(normalizedPath, options.routes);
+	if (hint?.kind) return hint.kind;
+	if (hint?.collection) return "collection";
+	if (getCollectionFromPath(normalizedPath, config).collection) return "collection";
+	if (hasUrlBase(normalizedPath, config.base)) return "doc";
+	return "external";
+}
+function parseUrlReference(to, config, options = {}) {
+	const { value, siteProtocol } = stripSiteProtocol(to);
+	const split = splitUrlReference(value);
+	const pathname = normalizeUrlPath(split.pathname || "/");
+	const hadBase = hasUrlBase(pathname, config.base);
+	const kind = classifyUrlPath(pathname, config, options);
+	if (kind === "doc") {
+		const parts = stripUrlBase(pathname, config.base).split("/").filter(Boolean);
+		let index = 0;
+		const versionMatch = matchConfiguredVersion(parts, index, config);
+		const version = versionMatch.version;
+		index = versionMatch.nextIndex;
+		const locale = isConfiguredLocale(parts[index], config) ? parts[index] : void 0;
+		if (locale) index++;
+		return {
+			pathname,
+			routePath: normalizeUrlPath(parts.slice(index).join("/")),
+			search: split.search,
+			hash: split.hash,
+			kind,
+			locale,
+			version,
+			siteProtocol,
+			hadBase
+		};
+	}
+	if (kind === "collection") {
+		const collection = getCollectionFromPath(pathname, config);
+		return {
+			pathname,
+			routePath: normalizeUrlPath(collection.remainder.join("/")),
+			search: split.search,
+			hash: split.hash,
+			kind,
+			locale: collection.locale,
+			version: collection.version,
+			collection: collection.collection,
+			siteProtocol,
+			hadBase
+		};
+	}
+	const parts = pathname.split("/").filter(Boolean);
+	const locale = isConfiguredLocale(parts[0], config) ? parts[0] : void 0;
+	return {
+		pathname,
+		routePath: normalizeUrlPath((locale ? parts.slice(1) : parts).join("/")),
+		search: split.search,
+		hash: split.hash,
+		kind,
+		locale,
+		siteProtocol,
+		hadBase
+	};
+}
+function buildUrl(options, config) {
+	const routePath = normalizeUrlPath(options.path || "/");
+	const locale = options.locale && options.locale !== config.i18n?.defaultLocale ? options.locale : void 0;
+	const search = normalizeSuffix(options.search, "?");
+	const hash = normalizeSuffix(options.hash, "#");
+	let pathname;
+	if (options.kind === "doc") pathname = normalizeUrlPath([
+		normalizeUrlBase(config.base) === "/" ? void 0 : normalizeUrlBase(config.base).slice(1),
+		...getVersionSegments(options.version, config),
+		locale,
+		routePath === "/" ? void 0 : routePath.slice(1)
+	].filter(Boolean).join("/"));
+	else if (options.kind === "collection") {
+		if (!options.collection) throw new Error("A collection route requires a collection name");
+		pathname = normalizeUrlPath([
+			normalizeUrlBase(config.base) === "/" ? void 0 : normalizeUrlBase(config.base).slice(1),
+			...getVersionSegments(options.version, config),
+			locale,
+			options.collection,
+			routePath === "/" ? void 0 : routePath.slice(1)
+		].filter(Boolean).join("/"));
+	} else pathname = normalizeUrlPath([locale, routePath === "/" ? void 0 : routePath.slice(1)].filter(Boolean).join("/"));
+	return `${pathname}${search}${hash}`;
+}
+function resolveUrlReference(to, config, options = {}) {
+	const { value, siteProtocol } = stripSiteProtocol(to);
+	if (hasUriScheme(value) || /^(?:https?:)?\/\//i.test(value)) return to;
+	if (value.startsWith("#") || value.startsWith("?")) return siteProtocol ? value : to;
+	const parsed = parseUrlReference(value, config, options);
+	const kind = options.kind || parsed.kind;
+	const locale = options.locale ?? parsed.locale;
+	const version = options.version ?? parsed.version;
+	const derived = getCollectionFromPath(stripUrlBase(parsed.pathname, config.base), config);
+	const collection = parsed.collection ?? derived.collection;
+	const routePath = derived.collection && !parsed.collection ? normalizeUrlPath(derived.remainder.join("/")) : parsed.routePath;
+	return buildUrl({
+		kind: collection || parsed.kind === "collection" ? "collection" : kind,
+		path: routePath,
+		locale,
+		version,
+		collection,
+		search: parsed.search,
+		hash: parsed.hash,
+		hadBase: parsed.hadBase
+	}, config);
+}
+
+//#endregion
+Object.defineProperty(exports, 'LocationContext', {
+  enumerable: true,
+  get: function () {
+    return LocationContext;
+  }
+});
+Object.defineProperty(exports, 'LocationProvider', {
+  enumerable: true,
+  get: function () {
+    return LocationProvider;
+  }
+});
+Object.defineProperty(exports, 'MatchesContext', {
+  enumerable: true,
+  get: function () {
+    return MatchesContext;
+  }
+});
+Object.defineProperty(exports, 'NavigateContext', {
+  enumerable: true,
+  get: function () {
+    return NavigateContext;
+  }
+});
+Object.defineProperty(exports, 'Outlet', {
+  enumerable: true,
+  get: function () {
+    return Outlet;
+  }
+});
+Object.defineProperty(exports, 'OutletContext', {
+  enumerable: true,
+  get: function () {
+    return OutletContext;
+  }
+});
+Object.defineProperty(exports, 'PrefetchContext', {
+  enumerable: true,
+  get: function () {
+    return PrefetchContext;
+  }
+});
+Object.defineProperty(exports, 'RouteDataContext', {
+  enumerable: true,
+  get: function () {
+    return RouteDataContext;
+  }
+});
+Object.defineProperty(exports, 'RouteRenderer', {
+  enumerable: true,
+  get: function () {
+    return RouteRenderer;
+  }
+});
+Object.defineProperty(exports, '__exportAll', {
+  enumerable: true,
+  get: function () {
+    return __exportAll;
+  }
+});
+Object.defineProperty(exports, '__toESM', {
+  enumerable: true,
+  get: function () {
+    return __toESM;
+  }
+});
+Object.defineProperty(exports, 'addBasename', {
+  enumerable: true,
+  get: function () {
+    return addBasename;
+  }
+});
+Object.defineProperty(exports, 'addUrlBase', {
+  enumerable: true,
+  get: function () {
+    return addUrlBase;
+  }
+});
+Object.defineProperty(exports, 'buildUrl', {
+  enumerable: true,
+  get: function () {
+    return buildUrl;
+  }
+});
+Object.defineProperty(exports, 'classifyUrlPath', {
+  enumerable: true,
+  get: function () {
+    return classifyUrlPath;
+  }
+});
+Object.defineProperty(exports, 'defaultNavigate', {
+  enumerable: true,
+  get: function () {
+    return defaultNavigate;
+  }
+});
+Object.defineProperty(exports, 'getConfiguredLocales', {
+  enumerable: true,
+  get: function () {
+    return getConfiguredLocales;
+  }
+});
+Object.defineProperty(exports, 'getConfiguredVersions', {
+  enumerable: true,
+  get: function () {
+    return getConfiguredVersions;
+  }
+});
+Object.defineProperty(exports, 'getVersionPrefixSegments', {
+  enumerable: true,
+  get: function () {
+    return getVersionPrefixSegments;
+  }
+});
+Object.defineProperty(exports, 'getVersionSegments', {
+  enumerable: true,
+  get: function () {
+    return getVersionSegments;
+  }
+});
+Object.defineProperty(exports, 'hasBasename', {
+  enumerable: true,
+  get: function () {
+    return hasBasename;
+  }
+});
+Object.defineProperty(exports, 'hasUriScheme', {
+  enumerable: true,
+  get: function () {
+    return hasUriScheme;
+  }
+});
+Object.defineProperty(exports, 'hasUrlBase', {
+  enumerable: true,
+  get: function () {
+    return hasUrlBase;
+  }
+});
+Object.defineProperty(exports, 'isConfiguredLocale', {
+  enumerable: true,
+  get: function () {
+    return isConfiguredLocale;
+  }
+});
+Object.defineProperty(exports, 'isConfiguredVersion', {
+  enumerable: true,
+  get: function () {
+    return isConfiguredVersion;
+  }
+});
+Object.defineProperty(exports, 'matchRouteBranch', {
+  enumerable: true,
+  get: function () {
+    return matchRouteBranch;
+  }
+});
+Object.defineProperty(exports, 'matchRouteBranchWithParams', {
+  enumerable: true,
+  get: function () {
+    return matchRouteBranchWithParams;
+  }
+});
+Object.defineProperty(exports, 'normalizeBasename', {
+  enumerable: true,
+  get: function () {
+    return normalizeBasename;
+  }
+});
+Object.defineProperty(exports, 'normalizeUrlBase', {
+  enumerable: true,
+  get: function () {
+    return normalizeUrlBase;
+  }
+});
+Object.defineProperty(exports, 'normalizeUrlPath', {
+  enumerable: true,
+  get: function () {
+    return normalizeUrlPath;
+  }
+});
+Object.defineProperty(exports, 'parseUrlReference', {
+  enumerable: true,
+  get: function () {
+    return parseUrlReference;
+  }
+});
+Object.defineProperty(exports, 'resolveRouteBranch', {
+  enumerable: true,
+  get: function () {
+    return resolveRouteBranch;
+  }
+});
+Object.defineProperty(exports, 'resolveUrlReference', {
+  enumerable: true,
+  get: function () {
+    return resolveUrlReference;
+  }
+});
+Object.defineProperty(exports, 'splitUrlReference', {
+  enumerable: true,
+  get: function () {
+    return splitUrlReference;
+  }
+});
+Object.defineProperty(exports, 'stripBasename', {
+  enumerable: true,
+  get: function () {
+    return stripBasename;
+  }
+});
+Object.defineProperty(exports, 'stripSiteProtocol', {
+  enumerable: true,
+  get: function () {
+    return stripSiteProtocol;
+  }
+});
+Object.defineProperty(exports, 'stripUrlBase', {
+  enumerable: true,
+  get: function () {
+    return stripUrlBase;
+  }
+});
+Object.defineProperty(exports, 'useLoaderData', {
+  enumerable: true,
+  get: function () {
+    return useLoaderData;
+  }
+});
+Object.defineProperty(exports, 'useLocation', {
+  enumerable: true,
+  get: function () {
+    return useLocation;
+  }
+});
+Object.defineProperty(exports, 'useMatches', {
+  enumerable: true,
+  get: function () {
+    return useMatches;
+  }
+});
+Object.defineProperty(exports, 'useNavigate', {
+  enumerable: true,
+  get: function () {
+    return useNavigate;
+  }
+});
+Object.defineProperty(exports, 'usePrefetch', {
+  enumerable: true,
+  get: function () {
+    return usePrefetch;
+  }
+});
+Object.defineProperty(exports, 'useRouteData', {
+  enumerable: true,
+  get: function () {
+    return useRouteData;
+  }
+});