tanstack-router-cache 0.1.7 → 0.1.8

package/dist/index.js

@@ -1,1395 +1,10 @@
-import { Match, Outlet, RouterContextProvider, useChildMatches, useLocation, useMatches, useRouter, useRouterState } from "@tanstack/react-router";
-import { Activity, createContext, use, useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
-import { Fragment, jsx, jsxs } from "react/jsx-runtime";
-//#region src/pathname.ts
-const TRAILING_SLASHES_REGEX = /\/+$/u;
-function normalizeCachedRoutePathname(pathname) {
-	if (pathname === "/") return pathname;
-	return pathname.replace(TRAILING_SLASHES_REGEX, "");
-}
-//#endregion
-//#region src/contexts/router-cache.tsx
-const DEFAULT_MAX_ENTRIES = Number.POSITIVE_INFINITY;
-const EMPTY_CACHED_ROUTES = {};
-const RouterCacheContext = createContext(null);
-function shallowEqualRouteStaticData(current, next) {
-	if (current === next) return true;
-	const currentEntries = Object.entries({ ...current });
-	const nextEntries = Object.entries({ ...next });
-	if (currentEntries.length !== nextEntries.length) return false;
-	const nextValuesByKey = new Map(nextEntries);
-	for (const [key, value] of currentEntries) if (!Object.is(value, nextValuesByKey.get(key))) return false;
-	return true;
-}
-function isCacheEnabledRouteData(route) {
-	return route?.staticData.routeCache === true;
-}
-function filterRouterCacheRoutes(routes) {
-	return Object.fromEntries(Object.entries(routes).flatMap(([pathname, route]) => isCacheEnabledRouteData(route) ? [[normalizeCachedRoutePathname(pathname), route]] : []));
-}
-function isSameCachedRouteData(current, next) {
-	if (!current) return false;
-	return current.routeId === next.routeId && current.href === next.href && current.matchId === next.matchId && current.ready === next.ready && current.routerSnapshot === next.routerSnapshot && shallowEqualRouteStaticData(current.staticData, next.staticData);
-}
-function normalizeLimit(limit) {
-	if (typeof limit !== "number" || Number.isNaN(limit)) return DEFAULT_MAX_ENTRIES;
-	if (!Number.isFinite(limit)) return DEFAULT_MAX_ENTRIES;
-	return Math.max(Math.trunc(limit), 0);
-}
-function getCachedRouteTimestamp(route) {
-	return route.lastVisibleAt ?? route.createdAt ?? 0;
-}
-function sortCachedRouteEntries([leftPathname, leftRoute], [rightPathname, rightRoute]) {
-	const timestampDifference = getCachedRouteTimestamp(leftRoute) - getCachedRouteTimestamp(rightRoute);
-	if (timestampDifference !== 0) return timestampDifference;
-	return leftPathname.localeCompare(rightPathname);
-}
-function getUnmarkedCachedRouteEntries(routes, keysToDelete) {
-	return Object.entries(routes).filter(([pathname]) => !keysToDelete.has(pathname));
-}
-function getEntriesByRouteId(entries) {
-	const entriesByRouteId = /* @__PURE__ */ new Map();
-	for (const entry of entries) {
-		const routeId = entry[1].routeId;
-		if (!routeId) continue;
-		const existingEntries = entriesByRouteId.get(routeId);
-		if (existingEntries) {
-			existingEntries.push(entry);
-			continue;
-		}
-		entriesByRouteId.set(routeId, [entry]);
-	}
-	return entriesByRouteId;
-}
-function markEntriesForDeletion(entries, keysToDelete, protectedKeys, excessEntryCount) {
-	if (excessEntryCount <= 0) return;
-	const evictableEntries = entries.filter(([pathname]) => !protectedKeys.has(pathname)).sort(sortCachedRouteEntries);
-	let remainingExcess = excessEntryCount;
-	for (const [pathname] of evictableEntries) {
-		if (remainingExcess <= 0) break;
-		if (!keysToDelete.has(pathname)) {
-			keysToDelete.add(pathname);
-			remainingExcess -= 1;
-		}
-	}
-}
-function applyPerRouteEntryLimit(routes, maxEntriesPerRouteId, keysToDelete, protectedKeys) {
-	if (maxEntriesPerRouteId === DEFAULT_MAX_ENTRIES) return;
-	const entriesByRouteId = getEntriesByRouteId(getUnmarkedCachedRouteEntries(routes, keysToDelete));
-	for (const entries of entriesByRouteId.values()) markEntriesForDeletion(entries, keysToDelete, protectedKeys, entries.length - maxEntriesPerRouteId);
-}
-function applyGlobalEntryLimit(routes, maxEntries, keysToDelete, protectedKeys) {
-	if (maxEntries === DEFAULT_MAX_ENTRIES) return;
-	const remainingEntries = getUnmarkedCachedRouteEntries(routes, keysToDelete);
-	markEntriesForDeletion(remainingEntries, keysToDelete, protectedKeys, remainingEntries.length - maxEntries);
-}
-function applyCachedRouteLimits(routes, config, protectedKeys) {
-	if (config.maxEntries === DEFAULT_MAX_ENTRIES && config.maxEntriesPerRouteId === DEFAULT_MAX_ENTRIES) return routes;
-	const keysToDelete = /* @__PURE__ */ new Set();
-	applyPerRouteEntryLimit(routes, config.maxEntriesPerRouteId, keysToDelete, protectedKeys);
-	applyGlobalEntryLimit(routes, config.maxEntries, keysToDelete, protectedKeys);
-	if (keysToDelete.size === 0) return routes;
-	const nextRoutes = { ...routes };
-	for (const pathname of keysToDelete) delete nextRoutes[pathname];
-	return nextRoutes;
-}
-function createCachedRouteData(current, next) {
-	const now = Date.now();
-	return {
-		...next,
-		createdAt: current?.createdAt ?? next.createdAt ?? now,
-		lastVisibleAt: next.lastVisibleAt ?? now
-	};
-}
-function getNextCachedRoutesState(params) {
-	const normalizedKey = normalizeCachedRoutePathname(params.key);
-	if (params.cacheConfig.maxEntries === 0) return params.state === EMPTY_CACHED_ROUTES ? params.state : EMPTY_CACHED_ROUTES;
-	if (!isCacheEnabledRouteData(params.value)) {
-		if (!Object.hasOwn(params.state, normalizedKey)) return params.state;
-		const nextState = { ...params.state };
-		delete nextState[normalizedKey];
-		return nextState;
-	}
-	const nextRouteData = createCachedRouteData(params.state[normalizedKey], params.value);
-	if (isSameCachedRouteData(params.state[normalizedKey], nextRouteData)) return params.state;
-	return applyCachedRouteLimits({
-		...params.state,
-		[normalizedKey]: nextRouteData
-	}, params.cacheConfig, new Set([normalizedKey]));
-}
-function RouterCacheProvider({ cacheScopeKey = "__default__", children, defaultCachedRoutes = EMPTY_CACHED_ROUTES, maxEntries = DEFAULT_MAX_ENTRIES, maxEntriesPerRouteId = DEFAULT_MAX_ENTRIES }) {
-	return /* @__PURE__ */ jsx(RouterCacheProviderScope, {
-		defaultCachedRoutes,
-		maxEntries,
-		maxEntriesPerRouteId,
-		children
-	}, cacheScopeKey ?? "__default__");
-}
-function RouterCacheProviderScope({ children, defaultCachedRoutes = EMPTY_CACHED_ROUTES, maxEntries, maxEntriesPerRouteId }) {
-	const cacheConfigRef = useRef({
-		maxEntries: normalizeLimit(maxEntries),
-		maxEntriesPerRouteId: normalizeLimit(maxEntriesPerRouteId)
-	});
-	const initialCachedRoutesRef = useRef(null);
-	if (initialCachedRoutesRef.current === null) initialCachedRoutesRef.current = applyCachedRouteLimits(filterRouterCacheRoutes(defaultCachedRoutes), cacheConfigRef.current, /* @__PURE__ */ new Set());
-	const [cachedRoutes, setCachedRoutes] = useState(() => initialCachedRoutesRef.current ?? EMPTY_CACHED_ROUTES);
-	const [erroredRouteCounts, setErroredRouteCounts] = useState({});
-	const updateCachedRoutes = (key, value) => {
-		setCachedRoutes((state) => getNextCachedRoutesState({
-			cacheConfig: cacheConfigRef.current,
-			key,
-			state,
-			value
-		}));
-	};
-	const deleteCachedRoutes = (keys) => {
-		setCachedRoutes((state) => {
-			let changed = false;
-			const newState = { ...state };
-			for (const key of keys) {
-				const normalizedKey = normalizeCachedRoutePathname(key);
-				if (Object.hasOwn(newState, normalizedKey)) {
-					delete newState[normalizedKey];
-					changed = true;
-				}
-			}
-			return changed ? newState : state;
-		});
-	};
-	const touchCachedRoutes = (keys) => {
-		setCachedRoutes((state) => {
-			let changed = false;
-			const touchedAt = Date.now();
-			const nextState = { ...state };
-			for (const key of keys) {
-				const normalizedKey = normalizeCachedRoutePathname(key);
-				const route = nextState[normalizedKey];
-				if (!route || route.lastVisibleAt === touchedAt) continue;
-				nextState[normalizedKey] = {
-					...route,
-					lastVisibleAt: touchedAt
-				};
-				changed = true;
-			}
-			return changed ? nextState : state;
-		});
-	};
-	const retainErroredRoute = (pathname) => {
-		const normalizedPathname = normalizeCachedRoutePathname(pathname);
-		setErroredRouteCounts((state) => ({
-			...state,
-			[normalizedPathname]: (state[normalizedPathname] ?? 0) + 1
-		}));
-		setCachedRoutes((state) => {
-			if (!Object.hasOwn(state, normalizedPathname)) return state;
-			const nextState = { ...state };
-			delete nextState[normalizedPathname];
-			return nextState;
-		});
-	};
-	const releaseErroredRoute = (pathname) => {
-		const normalizedPathname = normalizeCachedRoutePathname(pathname);
-		setErroredRouteCounts((state) => {
-			const currentCount = state[normalizedPathname] ?? 0;
-			if (currentCount <= 1) {
-				if (!Object.hasOwn(state, normalizedPathname)) return state;
-				const nextState = { ...state };
-				delete nextState[normalizedPathname];
-				return nextState;
-			}
-			return {
-				...state,
-				[normalizedPathname]: currentCount - 1
-			};
-		});
-	};
-	const contextValue = {
-		cachedRoutes,
-		erroredRouteCounts,
-		setCachedRoutes: updateCachedRoutes,
-		deleteCachedRoutes,
-		touchCachedRoutes,
-		retainErroredRoute,
-		releaseErroredRoute
-	};
-	return /* @__PURE__ */ jsx(RouterCacheContext.Provider, {
-		value: contextValue,
-		children
-	});
-}
-function useRouterCacheContext() {
-	const context = use(RouterCacheContext);
-	if (!context) throw new Error("RouterCacheContext is not available");
-	return context;
-}
-function useOptionalRouterCacheContext() {
-	return use(RouterCacheContext);
-}
-//#endregion
-//#region src/hooks/use-event-listener.ts
-const EVENT_BUCKET_KEYS = ["on", "once"];
-const instance = class RouterCacheEvent {
-	static instance;
-	listeners = {
-		activeChange: /* @__PURE__ */ new Set(),
-		cachedNavigationCancel: /* @__PURE__ */ new Set(),
-		cachedNavigationComplete: /* @__PURE__ */ new Set(),
-		cachedNavigationStart: /* @__PURE__ */ new Set()
-	};
-	constructor() {}
-	static getInstance() {
-		if (!RouterCacheEvent.instance) RouterCacheEvent.instance = new RouterCacheEvent();
-		return RouterCacheEvent.instance;
-	}
-	on(eventName, handler) {
-		this.listeners[eventName].add(handler);
-		return this;
-	}
-	once(eventName, handler) {
-		const onceHandler = (...args) => {
-			this.off(eventName, onceHandler);
-			handler(...args);
-		};
-		this.listeners[eventName].add(onceHandler);
-		return this;
-	}
-	off(eventName, handler) {
-		this.listeners[eventName].delete(handler);
-		return this;
-	}
-	emit(eventName, ...args) {
-		const handlers = this.listeners[eventName];
-		for (const handler of handlers) handler(...args);
-		return handlers.size > 0;
-	}
-}.getInstance();
-function syncEventHandler(type, eventName, handler) {
-	if (type === "on") {
-		instance.on(eventName, handler);
-		return;
-	}
-	instance.off(eventName, handler);
-}
-function syncEventBucket(type, bucket) {
-	if (bucket.activeChange) syncEventHandler(type, "activeChange", bucket.activeChange);
-	if (bucket.cachedNavigationCancel) syncEventHandler(type, "cachedNavigationCancel", bucket.cachedNavigationCancel);
-	if (bucket.cachedNavigationComplete) syncEventHandler(type, "cachedNavigationComplete", bucket.cachedNavigationComplete);
-	if (bucket.cachedNavigationStart) syncEventHandler(type, "cachedNavigationStart", bucket.cachedNavigationStart);
-}
-function syncEventHandlers(type, events) {
-	if (!events) return;
-	for (const key of EVENT_BUCKET_KEYS) {
-		const bucket = events[key];
-		if (!bucket) continue;
-		syncEventBucket(type, bucket);
-	}
-}
-function useEventListener(events) {
-	useEffect(() => {
-		const registerEvent = () => {
-			syncEventHandlers("on", events);
-			return () => {
-				syncEventHandlers("off", events);
-			};
-		};
-		const unregister = registerEvent();
-		return () => {
-			unregister?.();
-		};
-	}, [events]);
-	return { eventListener: instance };
-}
-//#endregion
-//#region src/hooks/use-router-cache-debug.ts
-const DYNAMIC_SEGMENT_PATTERNS = [
-	/^\d{4,}$/u,
-	/^[0-9a-f]{8,}$/iu,
-	/^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu
-];
-function isDynamicLookingSegment(segment) {
-	for (const pattern of DYNAMIC_SEGMENT_PATTERNS) if (pattern.test(segment)) return true;
-	return false;
-}
-function isDynamicLookingPathname(pathname) {
-	return pathname.split("/").filter(Boolean).some(isDynamicLookingSegment);
-}
-function countHiddenContainers() {
-	if (typeof document === "undefined") return 0;
-	return document.querySelectorAll("[data-router-cache-container=\"true\"][data-router-cache-mode=\"hidden\"]").length;
-}
-function buildSnapshot(cachedRoutes, visiblePathname) {
-	const cachedRoutePathnames = Object.keys(cachedRoutes).sort((a, b) => a.localeCompare(b));
-	const dynamicLookingRoutePathnames = cachedRoutePathnames.filter(isDynamicLookingPathname);
-	const hiddenCachedRoutePathnames = cachedRoutePathnames.filter((pathname) => pathname !== visiblePathname);
-	return {
-		cachedRoutePathnames,
-		dynamicLookingRouteCount: dynamicLookingRoutePathnames.length,
-		dynamicLookingRoutePathnames,
-		hiddenCachedRouteCount: hiddenCachedRoutePathnames.length,
-		hiddenContainerCount: countHiddenContainers(),
-		totalCachedRouteCount: cachedRoutePathnames.length,
-		visiblePathname
-	};
-}
-function getDebugWindow() {
-	return globalThis.window;
-}
-function isProduction() {
-	return globalThis.process?.env?.NODE_ENV === "production";
-}
-function useRouterCacheDebug(cachedRoutes, visiblePathname) {
-	const warningThresholdRef = useRef(null);
-	const lastWarnedCountRef = useRef(null);
-	const lastSnapshotRef = useRef(null);
-	if (lastSnapshotRef.current === null) lastSnapshotRef.current = buildSnapshot(cachedRoutes, visiblePathname);
-	const snapshot = useMemo(() => buildSnapshot(cachedRoutes, visiblePathname), [cachedRoutes, visiblePathname]);
-	useEffect(() => {
-		if (isProduction()) return;
-		const debugWindow = getDebugWindow();
-		if (!debugWindow) return;
-		const refresh = () => {
-			lastSnapshotRef.current = buildSnapshot(cachedRoutes, visiblePathname);
-			return lastSnapshotRef.current;
-		};
-		const api = {
-			getSnapshot: () => lastSnapshotRef.current ?? snapshot,
-			lastSnapshot: snapshot,
-			refresh,
-			setWarningThreshold: (nextThreshold) => {
-				warningThresholdRef.current = typeof nextThreshold === "number" ? nextThreshold : null;
-				lastWarnedCountRef.current = null;
-			},
-			warningThreshold: warningThresholdRef.current
-		};
-		debugWindow.__TANSTACK_ROUTER_CACHE_DEBUG__ = api;
-		const rafId = globalThis.requestAnimationFrame(() => {
-			const nextSnapshot = refresh();
-			debugWindow.__TANSTACK_ROUTER_CACHE_DEBUG__ = {
-				...api,
-				lastSnapshot: nextSnapshot,
-				warningThreshold: warningThresholdRef.current
-			};
-			const warningThreshold = warningThresholdRef.current;
-			if (typeof warningThreshold === "number" && nextSnapshot.totalCachedRouteCount > warningThreshold && lastWarnedCountRef.current !== nextSnapshot.totalCachedRouteCount) lastWarnedCountRef.current = nextSnapshot.totalCachedRouteCount;
-		});
-		return () => {
-			globalThis.cancelAnimationFrame(rafId);
-			if (debugWindow.__TANSTACK_ROUTER_CACHE_DEBUG__ === api) debugWindow.__TANSTACK_ROUTER_CACHE_DEBUG__ = void 0;
-		};
-	}, [
-		cachedRoutes,
-		snapshot,
-		visiblePathname
-	]);
-}
-//#endregion
-//#region src/components/cached-outlet.tsx
-function CachedOutlet(props) {
-	const { matchId, routerSnapshot } = props;
-	return /* @__PURE__ */ jsx(RouterContextProvider, {
-		router: routerSnapshot,
-		children: /* @__PURE__ */ jsx(Match, { matchId })
-	});
-}
-//#endregion
-//#region src/dom/dismiss-transient-ui.ts
-const documentStates = /* @__PURE__ */ new WeakMap();
-const PERSISTENT_EXTERNAL_ATTRIBUTE = "data-router-cache-persistent-external";
-function isBlurTarget(element) {
-	return element instanceof HTMLElement;
-}
-function getOrCreateDocumentState(documentObject) {
-	const existingState = documentStates.get(documentObject);
-	if (existingState) return existingState;
-	const state = {
-		observer: null,
-		ownerByElement: /* @__PURE__ */ new WeakMap(),
-		routes: /* @__PURE__ */ new Map(),
-		visiblePathname: null
-	};
-	if (typeof MutationObserver !== "undefined") {
-		state.observer = new MutationObserver((mutations) => {
-			handleDomMutations(mutations, state);
-		});
-		state.observer.observe(documentObject.body ?? documentObject.documentElement, {
-			childList: true,
-			subtree: true
-		});
-	}
-	documentStates.set(documentObject, state);
-	return state;
-}
-function getOrCreateRouteState(state, pathname) {
-	const existingRouteState = state.routes.get(pathname);
-	if (existingRouteState) return existingRouteState;
-	const routeState = {
-		hiddenElements: /* @__PURE__ */ new Map(),
-		ownedElements: /* @__PURE__ */ new Set()
-	};
-	state.routes.set(pathname, routeState);
-	return routeState;
-}
-function getHoveredElements(documentObject) {
-	try {
-		return Array.from(documentObject.querySelectorAll(":hover")).reverse();
-	} catch {
-		return [];
-	}
-}
-function getOwnedExternalElements(documentObject, pathname) {
-	const routeState = getOrCreateRouteState(getOrCreateDocumentState(documentObject), pathname);
-	return Array.from(routeState.ownedElements).filter((element) => element.isConnected);
-}
-function dispatchEscapeKeyboardEvent(target, documentObject, type) {
-	const keyboardEventConstructor = documentObject.defaultView?.KeyboardEvent ?? KeyboardEvent;
-	target.dispatchEvent(new keyboardEventConstructor(type, {
-		bubbles: true,
-		cancelable: true,
-		code: "Escape",
-		key: "Escape",
-		keyCode: 27,
-		which: 27
-	}));
-}
-function dispatchHoverExitEvent(target, documentObject, type) {
-	const eventConstructor = type.startsWith("pointer") ? documentObject.defaultView?.PointerEvent ?? documentObject.defaultView?.MouseEvent ?? MouseEvent : documentObject.defaultView?.MouseEvent ?? MouseEvent;
-	target.dispatchEvent(new eventConstructor(type, {
-		bubbles: type.endsWith("out"),
-		cancelable: true,
-		composed: true,
-		relatedTarget: documentObject.body
-	}));
-}
-function dispatchHoverExitEvents(hoveredElements, documentObject) {
-	for (const hoveredElement of hoveredElements) {
-		dispatchHoverExitEvent(hoveredElement, documentObject, "pointerout");
-		dispatchHoverExitEvent(hoveredElement, documentObject, "pointerleave");
-		dispatchHoverExitEvent(hoveredElement, documentObject, "mouseout");
-		dispatchHoverExitEvent(hoveredElement, documentObject, "mouseleave");
-	}
-}
-function focusDocumentBody(documentObject) {
-	const { body } = documentObject;
-	const previousTabIndex = body.getAttribute("tabindex");
-	if (previousTabIndex === null) body.setAttribute("tabindex", "-1");
-	body.focus();
-	if (previousTabIndex === null) body.removeAttribute("tabindex");
-}
-function getRouterCacheContainerAncestor(element) {
-	const container = element?.closest("[data-router-cache-container=\"true\"]");
-	return container instanceof HTMLElement ? container : null;
-}
-function isElementInsideAnyRouterCacheContainer(element) {
-	return getRouterCacheContainerAncestor(element) !== null;
-}
-function containsRouterCacheContainer(element) {
-	return element.querySelector("[data-router-cache-container=\"true\"]") instanceof HTMLElement;
-}
-function isElementConnectedOutsideRouterCacheContainer(element) {
-	return element.isConnected && !isElementInsideAnyRouterCacheContainer(element);
-}
-function isPersistentExternalElement(element) {
-	return element.closest(`[${PERSISTENT_EXTERNAL_ATTRIBUTE}="true"]`) instanceof HTMLElement;
-}
-function getTrackableElementsFromNode(node) {
-	if (node instanceof HTMLElement) return [node];
-	if (node instanceof DocumentFragment) return Array.from(node.children).flatMap((child) => child instanceof HTMLElement ? [child] : []);
-	return [];
-}
-function forEachRemovedNode(mutations, callback) {
-	for (const mutation of mutations) for (const removedNode of mutation.removedNodes) callback(removedNode);
-}
-function forEachAddedNode(mutations, callback) {
-	for (const mutation of mutations) for (const addedNode of mutation.addedNodes) callback(addedNode);
-}
-function handleDomMutations(mutations, state) {
-	forEachRemovedNode(mutations, (removedNode) => {
-		untrackRemovedNode(removedNode, state);
-	});
-	if (!state.visiblePathname) return;
-	forEachAddedNode(mutations, (addedNode) => {
-		trackAddedNode(addedNode, state.visiblePathname, state);
-	});
-}
-function hasTrackedAncestor(element, state) {
-	let ancestor = element.parentElement;
-	while (ancestor) {
-		if (state.ownerByElement.get(ancestor)) return true;
-		ancestor = ancestor.parentElement;
-	}
-	return false;
-}
-function restoreOwnedExternalElement(routeState, element) {
-	const snapshot = routeState.hiddenElements.get(element);
-	if (!snapshot) return;
-	element.style.setProperty("display", snapshot.display, snapshot.displayPriority);
-	if (snapshot.ariaHidden === null) element.removeAttribute("aria-hidden");
-	else element.setAttribute("aria-hidden", snapshot.ariaHidden);
-	element.inert = snapshot.inert;
-	routeState.hiddenElements.delete(element);
-}
-function trackExternalElement(pathname, element, state) {
-	if (!isElementConnectedOutsideRouterCacheContainer(element) || containsRouterCacheContainer(element) || isPersistentExternalElement(element) || hasTrackedAncestor(element, state)) return;
-	const currentOwner = state.ownerByElement.get(element);
-	if (currentOwner === pathname) return;
-	if (currentOwner) {
-		const previousRouteState = state.routes.get(currentOwner);
-		if (previousRouteState) {
-			restoreOwnedExternalElement(previousRouteState, element);
-			previousRouteState.ownedElements.delete(element);
-		}
-	}
-	getOrCreateRouteState(state, pathname).ownedElements.add(element);
-	state.ownerByElement.set(element, pathname);
-}
-function trackAddedNode(node, pathname, state) {
-	const elements = getTrackableElementsFromNode(node);
-	for (const element of elements) trackExternalElement(pathname, element, state);
-}
-function untrackElement(routeState, state, element) {
-	routeState.hiddenElements.delete(element);
-	routeState.ownedElements.delete(element);
-	state.ownerByElement.delete(element);
-}
-function untrackRemovedNode(node, state) {
-	if (!(node instanceof HTMLElement)) return;
-	for (const routeState of state.routes.values()) for (const element of Array.from(routeState.ownedElements)) if (node === element || node.contains(element)) untrackElement(routeState, state, element);
-}
-function hideOwnedExternalElements(documentObject, pathname) {
-	const routeState = getOrCreateRouteState(getOrCreateDocumentState(documentObject), pathname);
-	for (const element of Array.from(routeState.ownedElements)) {
-		if (!isElementConnectedOutsideRouterCacheContainer(element)) {
-			routeState.ownedElements.delete(element);
-			routeState.hiddenElements.delete(element);
-			continue;
-		}
-		if (routeState.hiddenElements.has(element)) continue;
-		routeState.hiddenElements.set(element, {
-			ariaHidden: element.getAttribute("aria-hidden"),
-			display: element.style.getPropertyValue("display"),
-			displayPriority: element.style.getPropertyPriority("display"),
-			inert: element.inert
-		});
-		element.style.setProperty("display", "none", "important");
-		element.setAttribute("aria-hidden", "true");
-		element.inert = true;
-	}
-}
-function showOwnedExternalElements(documentObject, pathname) {
-	const routeState = getOrCreateRouteState(getOrCreateDocumentState(documentObject), pathname);
-	for (const [element] of Array.from(routeState.hiddenElements)) {
-		if (!element.isConnected) {
-			routeState.hiddenElements.delete(element);
-			routeState.ownedElements.delete(element);
-			continue;
-		}
-		restoreOwnedExternalElement(routeState, element);
-	}
-}
-function initializeTransientUiTracking(documentObject) {
-	getOrCreateDocumentState(documentObject);
-}
-function syncTransientUiRouteActivity(pathname, mode) {
-	if (typeof document === "undefined") return;
-	const documentState = getOrCreateDocumentState(document);
-	getOrCreateRouteState(documentState, pathname);
-	if (mode === "visible") {
-		documentState.visiblePathname = pathname;
-		showOwnedExternalElements(document, pathname);
-		return;
-	}
-	if (documentState.visiblePathname === pathname) documentState.visiblePathname = null;
-	dispatchHoverExitEvents(getOwnedExternalElements(document, pathname), document);
-	hideOwnedExternalElements(document, pathname);
-}
-function dismissTransientUi(container, pathname) {
-	if (typeof document === "undefined" || !container) return;
-	initializeTransientUiTracking(document);
-	const hoveredElements = getHoveredElements(document);
-	const hoverExitTargets = Array.from(new Set([...hoveredElements, ...getOwnedExternalElements(document, pathname)]));
-	const activeElement = document.activeElement;
-	const activeElementBelongsToHoveredTree = activeElement instanceof Element && hoverExitTargets.some((hoveredElement) => hoveredElement === activeElement || hoveredElement.contains(activeElement));
-	if (activeElement instanceof Element && (container.contains(activeElement) || activeElementBelongsToHoveredTree) && isBlurTarget(activeElement)) activeElement.blur();
-	dispatchHoverExitEvents(hoverExitTargets, document);
-	dispatchEscapeKeyboardEvent(document, document, "keydown");
-	dispatchEscapeKeyboardEvent(document, document, "keyup");
-	hideOwnedExternalElements(document, pathname);
-	const nextActiveElement = document.activeElement;
-	const nextActiveElementBelongsToHoveredTree = nextActiveElement instanceof Element && hoverExitTargets.some((hoveredElement) => hoveredElement === nextActiveElement || hoveredElement.contains(nextActiveElement));
-	if (nextActiveElement instanceof Element && (container.contains(nextActiveElement) || nextActiveElementBelongsToHoveredTree)) focusDocumentBody(document);
-}
-//#endregion
-//#region src/components/off-screen-in.tsx
-const windowScrollPositions = /* @__PURE__ */ new Map();
-const IMMEDIATE_SCROLL_RESTORE_DELAY = 0;
-const EARLY_SCROLL_RESTORE_DELAY = 80;
-const MIDDLE_SCROLL_RESTORE_DELAY = 240;
-const LATE_SCROLL_RESTORE_DELAY = 600;
-const FINAL_SCROLL_RESTORE_DELAY = 1e3;
-const SCROLL_TRACKING_INTERVAL_MS = 200;
-const SCROLL_KEYS = new Set([
-	" ",
-	"ArrowDown",
-	"ArrowLeft",
-	"ArrowRight",
-	"ArrowUp",
-	"End",
-	"Home",
-	"PageDown",
-	"PageUp"
-]);
-const SCROLL_RESTORE_DELAYS = [
-	IMMEDIATE_SCROLL_RESTORE_DELAY,
-	EARLY_SCROLL_RESTORE_DELAY,
-	MIDDLE_SCROLL_RESTORE_DELAY,
-	LATE_SCROLL_RESTORE_DELAY,
-	FINAL_SCROLL_RESTORE_DELAY
-];
-function OffScreenIn(props) {
-	const { mode, children, containerRef, pathname } = props;
-	const localContainerRef = useRef(null);
-	const attachContainerRef = (node) => {
-		localContainerRef.current = node;
-		if (containerRef) containerRef.current = node;
-	};
-	useLayoutEffect(() => {
-		if (typeof document === "undefined") return;
-		initializeTransientUiTracking(document);
-	}, []);
-	useLayoutEffect(() => {
-		if (!pathname) return;
-		syncTransientUiRouteActivity(pathname, mode);
-	}, [mode, pathname]);
-	useLayoutEffect(() => {
-		const visibleContainer = localContainerRef.current;
-		return () => {
-			if (!pathname || mode !== "visible") return;
-			dismissTransientUi(visibleContainer, pathname);
-		};
-	}, [mode, pathname]);
-	useLayoutEffect(() => {
-		if (typeof globalThis === "undefined" || !pathname) return;
-		const saveScrollPosition = () => {
-			windowScrollPositions.set(pathname, {
-				x: globalThis.scrollX,
-				y: globalThis.scrollY
-			});
-		};
-		if (mode === "hidden") return;
-		const savedPosition = windowScrollPositions.get(pathname);
-		let userRequestedScroll = false;
-		let scrollTrackingIntervalId;
-		const startScrollTracking = () => {
-			scrollTrackingIntervalId ??= globalThis.setInterval(saveScrollPosition, SCROLL_TRACKING_INTERVAL_MS);
-		};
-		const handleScroll = () => {
-			if (!savedPosition || userRequestedScroll) saveScrollPosition();
-		};
-		const markUserRequestedScroll = () => {
-			userRequestedScroll = true;
-		};
-		const handleKeyDown = (event) => {
-			if (SCROLL_KEYS.has(event.key)) markUserRequestedScroll();
-		};
-		globalThis.addEventListener("scroll", handleScroll, { passive: true });
-		globalThis.addEventListener("wheel", markUserRequestedScroll, { passive: true });
-		globalThis.addEventListener("touchstart", markUserRequestedScroll, { passive: true });
-		globalThis.addEventListener("pointerdown", markUserRequestedScroll, { passive: true });
-		globalThis.addEventListener("keydown", handleKeyDown);
-		if (!savedPosition) {
-			startScrollTracking();
-			saveScrollPosition();
-			return () => {
-				if (scrollTrackingIntervalId !== void 0) globalThis.clearInterval(scrollTrackingIntervalId);
-				globalThis.removeEventListener("scroll", handleScroll);
-				globalThis.removeEventListener("wheel", markUserRequestedScroll);
-				globalThis.removeEventListener("touchstart", markUserRequestedScroll);
-				globalThis.removeEventListener("pointerdown", markUserRequestedScroll);
-				globalThis.removeEventListener("keydown", handleKeyDown);
-			};
-		}
-		const restoreScrollPosition = () => {
-			if (userRequestedScroll) return;
-			globalThis.scrollTo(savedPosition.x, savedPosition.y);
-			saveScrollPosition();
-			startScrollTracking();
-		};
-		const timeoutIds = [];
-		let rafId = globalThis.requestAnimationFrame(() => {
-			rafId = globalThis.requestAnimationFrame(() => {
-				restoreScrollPosition();
-				for (const delay of SCROLL_RESTORE_DELAYS) timeoutIds.push(globalThis.setTimeout(restoreScrollPosition, delay));
-			});
-		});
-		return () => {
-			globalThis.cancelAnimationFrame(rafId);
-			for (const timeoutId of timeoutIds) globalThis.clearTimeout(timeoutId);
-			if (scrollTrackingIntervalId !== void 0) globalThis.clearInterval(scrollTrackingIntervalId);
-			globalThis.removeEventListener("scroll", handleScroll);
-			globalThis.removeEventListener("wheel", markUserRequestedScroll);
-			globalThis.removeEventListener("touchstart", markUserRequestedScroll);
-			globalThis.removeEventListener("pointerdown", markUserRequestedScroll);
-			globalThis.removeEventListener("keydown", handleKeyDown);
-		};
-	}, [mode, pathname]);
-	return /* @__PURE__ */ jsx(Activity, {
-		mode,
-		children: /* @__PURE__ */ jsx("div", {
-			className: "flex min-h-full w-full flex-1 flex-col",
-			"data-router-cache-container": "true",
-			"data-router-cache-mode": mode,
-			"data-router-cache-pathname": pathname,
-			ref: attachContainerRef,
-			children
-		})
-	});
-}
-//#endregion
-//#region src/components/off-screen.tsx
-function OffScreen(props) {
-	return /* @__PURE__ */ jsx(OffScreenIn, { ...props });
-}
-//#endregion
-//#region src/components/restore-cached-href.ts
-const FALLBACK_ORIGIN = "http://tanstack-router-cache.local";
-function parseHref(href) {
-	try {
-		const url = new URL(href, FALLBACK_ORIGIN);
-		return {
-			hasHash: url.hash.length > 0,
-			hasSearch: url.search.length > 0,
-			pathname: url.pathname
-		};
-	} catch {
-		return null;
-	}
-}
-function isBareRouteHref(href, currentPathname) {
-	const candidateHref = href ?? currentPathname;
-	const parsedHref = parseHref(candidateHref);
-	if (!parsedHref) return candidateHref === currentPathname;
-	return parsedHref.pathname === currentPathname && !parsedHref.hasSearch && !parsedHref.hasHash;
-}
-function shouldRestoreCachedHref({ cachedHref, currentHref, currentPathname, isRouteCacheEnabled, previousPathname }) {
-	if (!(isRouteCacheEnabled && cachedHref)) return false;
-	if (!previousPathname || previousPathname === currentPathname) return false;
-	if (!isBareRouteHref(currentHref, currentPathname)) return false;
-	return cachedHref !== (currentHref ?? currentPathname);
-}
-//#endregion
-//#region src/components/route-cache-manager.tsx
-const LIVE_ROUTER_METHODS = [
-	"buildLocation",
-	"commitLocation",
-	"invalidate",
-	"loadRouteChunk",
-	"navigate",
-	"preloadRoute"
-];
-const routerSnapshotUpdaters = /* @__PURE__ */ new WeakMap();
-function createSnapshotStore(value) {
-	let currentValue = value;
-	const listeners = /* @__PURE__ */ new Set();
-	return {
-		get: () => currentValue,
-		set: (nextValue) => {
-			if (Object.is(currentValue, nextValue)) return;
-			currentValue = nextValue;
-			for (const listener of listeners) listener(currentValue);
-		},
-		subscribe: (listener) => {
-			if (listener) listeners.add(listener);
-			return { unsubscribe: listener ? () => {
-				listeners.delete(listener);
-			} : () => void 0 };
-		}
-	};
-}
-function createRouterSnapshotData({ matches, router, routerLocation, routerResolvedLocation }) {
-	const snapshotMatches = matches.reduce((snapshot, match) => {
-		const nextMatch = snapshotMatch(match, routerLocation);
-		if (isRouterMatch(nextMatch)) snapshot.push(nextMatch);
-		return snapshot;
-	}, []);
-	return {
-		matches: snapshotMatches,
-		state: {
-			...router.stores.__store.get(),
-			matches: snapshotMatches,
-			location: routerLocation,
-			resolvedLocation: routerResolvedLocation
-		}
-	};
-}
-function createMatchStore(match) {
-	return Object.assign(createSnapshotStore(match), { routeId: match.routeId });
-}
-function syncRouterSnapshot(routerSnapshot, input) {
-	const update = routerSnapshotUpdaters.get(routerSnapshot);
-	if (!update) return false;
-	update(input);
-	return true;
-}
-function getLiveRouterMethodDescriptors(router) {
-	return Object.fromEntries(LIVE_ROUTER_METHODS.flatMap((methodName) => {
-		const method = router[methodName];
-		if (typeof method !== "function") return [];
-		return [[methodName, { value: method.bind(router) }]];
-	}));
-}
-function toRouterLocation(location) {
-	return { ...location };
-}
-function isReadyCachedRoute(route) {
-	return Boolean(route && isRouteCacheEnabled(route.staticData) && route.ready && route.matchId && route.routerSnapshot);
-}
-function isRouteCacheEnabled(staticData) {
-	return staticData?.routeCache === true;
-}
-function hasErroredRouteMatch(matches) {
-	return matches.some((match) => match?.status === "error");
-}
-function hasRetainedRouteError(erroredRouteCounts, pathname) {
-	return (erroredRouteCounts[pathname] ?? 0) > 0;
-}
-function hasCurrentRouterMatchError({ matches, resolvedPathname, routerPathname }) {
-	return routerPathname === resolvedPathname && hasErroredRouteMatch(matches);
-}
-function hasCurrentRouteError({ erroredRouteCounts, matches, resolvedPathname, routerPathname }) {
-	return hasRetainedRouteError(erroredRouteCounts, routerPathname) || hasCurrentRouterMatchError({
-		matches,
-		resolvedPathname,
-		routerPathname
-	});
-}
-function isRouterMatch(match) {
-	return Boolean(match?.id && match.routeId);
-}
-function snapshotMatch(match, routerLocation) {
-	if (!isRouterMatch(match)) return;
-	const isLocationMatch = match.pathname ? normalizeCachedRoutePathname(match.pathname) === normalizeCachedRoutePathname(routerLocation.pathname) : false;
-	return {
-		...match,
-		...isLocationMatch ? {
-			_strictSearch: routerLocation.search,
-			search: routerLocation.search
-		} : {},
-		_nonReactive: { ...match._nonReactive }
-	};
-}
-function isCurrentUnmanagedCachedRoute(route, routerHref) {
-	return Boolean(route && isRouteCacheEnabled(route.staticData) && route.ready && route.routerSnapshot && route.href === routerHref);
-}
-function syncReadyCachedRoute({ matchId, matches, routeId, route, routerLocation, router, routerResolvedLocation, routerHref, routerPathname, setCachedRoutes, staticData }) {
-	const routerSnapshotInput = {
-		matches,
-		router,
-		routerLocation,
-		routerResolvedLocation
-	};
-	let routerSnapshot = matchId ? route?.routerSnapshot : void 0;
-	if (routerSnapshot && !syncRouterSnapshot(routerSnapshot, routerSnapshotInput)) {
-		if (isCurrentUnmanagedCachedRoute(route, routerHref)) return;
-		routerSnapshot = void 0;
-	}
-	if (matchId && !routerSnapshot) routerSnapshot = createRouterSnapshot(routerSnapshotInput);
-	setCachedRoutes(routerPathname, {
-		href: routerHref,
-		matchId,
-		routeId,
-		ready: true,
-		routerSnapshot,
-		staticData
-	});
-}
-function syncCachedRouteState({ isCurrentMatchReady, isCurrentMatchResolved, deleteCachedRoutes, isCurrentRouteErrored, matchId, matches, route, routeId, router, routerHref, routerLocation, routerPathname, routerResolvedLocation, setCachedRoutes, staticData }) {
-	if (isCurrentRouteErrored) {
-		if (route) deleteCachedRoutes([routerPathname]);
-		return;
-	}
-	if (!isCurrentMatchResolved) return;
-	if (staticData && isRouteCacheEnabled(staticData)) {
-		if (!isCurrentMatchReady) return;
-		syncReadyCachedRoute({
-			matchId,
-			matches,
-			routeId,
-			route,
-			routerLocation,
-			router,
-			routerResolvedLocation,
-			routerHref,
-			routerPathname,
-			setCachedRoutes,
-			staticData
-		});
-		return;
-	}
-	if (route) deleteCachedRoutes([routerPathname]);
-}
-function createRouterSnapshot(input) {
-	const { router, routerLocation, routerResolvedLocation } = input;
-	const snapshotData = createRouterSnapshotData(input);
-	const snapshotMatches = snapshotData.matches;
-	const matchStores = new Map(snapshotMatches.map((match) => [match.id, createMatchStore(match)]));
-	const routeMatchStoreCache = /* @__PURE__ */ new Map();
-	const stores = {
-		...router.stores,
-		status: createSnapshotStore(router.stores.status.get()),
-		loadedAt: createSnapshotStore(router.stores.loadedAt.get()),
-		isLoading: createSnapshotStore(router.stores.isLoading.get()),
-		isTransitioning: createSnapshotStore(router.stores.isTransitioning.get()),
-		location: createSnapshotStore(routerLocation),
-		resolvedLocation: createSnapshotStore(routerResolvedLocation),
-		statusCode: createSnapshotStore(router.stores.statusCode.get()),
-		redirect: createSnapshotStore(router.stores.redirect.get()),
-		matchesId: createSnapshotStore(snapshotMatches.map((match) => match.id)),
-		pendingIds: createSnapshotStore([]),
-		cachedIds: createSnapshotStore([]),
-		matches: createSnapshotStore(snapshotMatches),
-		pendingMatches: createSnapshotStore([]),
-		cachedMatches: createSnapshotStore([]),
-		firstId: createSnapshotStore(snapshotMatches[0]?.id),
-		hasPending: createSnapshotStore(snapshotMatches.some((match) => match.status === "pending")),
-		matchRouteDeps: createSnapshotStore({
-			locationHref: routerLocation.href,
-			resolvedLocationHref: routerResolvedLocation?.href,
-			status: snapshotData.state.status
-		}),
-		__store: createSnapshotStore(snapshotData.state),
-		matchStores,
-		pendingMatchStores: /* @__PURE__ */ new Map(),
-		cachedMatchStores: /* @__PURE__ */ new Map(),
-		getRouteMatchStore: (routeId) => {
-			let cached = routeMatchStoreCache.get(routeId);
-			if (!cached) {
-				cached = createSnapshotStore(snapshotMatches.find((match) => match.routeId === routeId));
-				routeMatchStoreCache.set(routeId, cached);
-			}
-			return cached;
-		},
-		setMatches: () => void 0,
-		setPending: () => void 0,
-		setCached: () => void 0
-	};
-	const updateSnapshot = (nextInput) => {
-		const nextData = createRouterSnapshotData(nextInput);
-		const nextMatches = nextData.matches;
-		const nextMatchIds = new Set(nextMatches.map((match) => match.id));
-		const nextMatchesByRouteId = new Map(nextMatches.map((match) => [match.routeId, match]));
-		for (const match of nextMatches) {
-			const store = matchStores.get(match.id);
-			if (store) {
-				store.set(match);
-				continue;
-			}
-			matchStores.set(match.id, createMatchStore(match));
-		}
-		for (const [matchId] of matchStores) if (!nextMatchIds.has(matchId)) matchStores.delete(matchId);
-		stores.status.set(nextInput.router.stores.status.get());
-		stores.loadedAt.set(nextInput.router.stores.loadedAt.get());
-		stores.isLoading.set(nextInput.router.stores.isLoading.get());
-		stores.isTransitioning.set(nextInput.router.stores.isTransitioning.get());
-		stores.location.set(nextInput.routerLocation);
-		stores.resolvedLocation.set(nextInput.routerResolvedLocation);
-		stores.statusCode.set(nextInput.router.stores.statusCode.get());
-		stores.redirect.set(nextInput.router.stores.redirect.get());
-		stores.matchesId.set(nextMatches.map((match) => match.id));
-		stores.pendingIds.set([]);
-		stores.cachedIds.set([]);
-		stores.matches.set(nextMatches);
-		stores.pendingMatches.set([]);
-		stores.cachedMatches.set([]);
-		stores.firstId.set(nextMatches[0]?.id);
-		stores.hasPending.set(nextMatches.some((match) => match.status === "pending"));
-		stores.matchRouteDeps.set({
-			locationHref: nextInput.routerLocation.href,
-			resolvedLocationHref: nextInput.routerResolvedLocation?.href,
-			status: nextData.state.status
-		});
-		stores.__store.set(nextData.state);
-		for (const [routeId, store] of routeMatchStoreCache) store.set(nextMatchesByRouteId.get(routeId));
-	};
-	const routerSnapshot = Object.create(router);
-	Object.defineProperties(routerSnapshot, {
-		stores: { value: stores },
-		latestLocation: { get: () => stores.location.get() },
-		getMatch: { value: (matchId) => matchStores.get(matchId)?.get() },
-		updateMatch: { value: () => void 0 },
-		...getLiveRouterMethodDescriptors(router)
-	});
-	routerSnapshotUpdaters.set(routerSnapshot, updateSnapshot);
-	return routerSnapshot;
-}
-function getRouterCacheStaticData(childMatches, isCurrentMatchResolved) {
-	if (!isCurrentMatchResolved) return;
-	for (let i = childMatches.length - 1; i >= 0; i--) {
-		const match = childMatches[i];
-		if (match?.staticData && isRouteCacheEnabled(match.staticData)) return match.staticData;
-	}
-}
-function restoreCachedHref(router, href) {
-	router.navigate({
-		href,
-		replace: true,
-		resetScroll: false
-	}).catch(() => void 0);
-}
-function renderCachedRoute({ bypassCachedPathname, pathname, route, routerPathname }) {
-	if (pathname === bypassCachedPathname) return null;
-	const content = route.matchId && route.routerSnapshot ? /* @__PURE__ */ jsx(CachedOutlet, {
-		matchId: route.matchId,
-		routerSnapshot: route.routerSnapshot
-	}) : null;
-	if (!content) return null;
-	return /* @__PURE__ */ jsx(OffScreen, {
-		mode: routerPathname === pathname ? "visible" : "hidden",
-		pathname,
-		children: content
-	}, pathname);
-}
-function buildRouteCacheModes(cachedRoutes, routerPathname) {
-	const nextModes = /* @__PURE__ */ new Map();
-	for (const pathname of Object.keys(cachedRoutes)) nextModes.set(pathname, routerPathname === pathname ? "visible" : "hidden");
-	return nextModes;
-}
-function syncCachedRouteActivityEvents(params) {
-	const nextModes = buildRouteCacheModes(params.cachedRoutes, params.routerPathname);
-	for (const [pathname, mode] of nextModes) {
-		const previousMode = params.previousRouteCacheModes.get(pathname);
-		if (previousMode === void 0 && mode === "hidden") continue;
-		if (previousMode === mode) continue;
-		params.eventListener.emit("activeChange", {
-			pathname,
-			mode
-		});
-	}
-	for (const [pathname] of params.previousRouteCacheModes) {
-		if (nextModes.has(pathname)) continue;
-		params.eventListener.emit("activeChange", {
-			pathname,
-			mode: "hidden"
-		});
-	}
-	return nextModes;
-}
-function RouteCacheManager() {
-	const { cachedRoutes, deleteCachedRoutes, erroredRouteCounts, setCachedRoutes, touchCachedRoutes } = useRouterCacheContext();
-	const { eventListener } = useEventListener();
-	const pendingCachedNavigationRef = useRef(null);
-	const previousPathnameRef = useRef(void 0);
-	const previousHrefRef = useRef(void 0);
-	const previousRouteCacheModesRef = useRef(null);
-	previousRouteCacheModesRef.current ??= /* @__PURE__ */ new Map();
-	const previousVisiblePathnameRef = useRef(void 0);
-	const routerLocation = useRouterState({ select: (state) => toRouterLocation(state.location) });
-	const routerHref = routerLocation.href;
-	const routerPathname = normalizeCachedRoutePathname(routerLocation.pathname);
-	const routerResolvedLocation = useRouterState({ select: (state) => state.resolvedLocation ? toRouterLocation(state.resolvedLocation) : void 0 });
-	const resolvedPathname = normalizeCachedRoutePathname(routerResolvedLocation?.pathname ?? routerPathname);
-	const destinationRoute = cachedRoutes[routerPathname];
-	const matches = useMatches();
-	const childMatches = useChildMatches();
-	const router = useRouter();
-	const currentMatch = matches.length ? matches.at(-1) : void 0;
-	const outletRootMatch = childMatches.length ? childMatches[0] : currentMatch;
-	const isCurrentMatchResolved = (currentMatch?.pathname ? normalizeCachedRoutePathname(currentMatch.pathname) : void 0) === routerPathname;
-	const isCurrentMatchReady = isCurrentMatchResolved && currentMatch?.status === "success";
-	const staticData = getRouterCacheStaticData(childMatches, isCurrentMatchResolved);
-	const matchId = isCurrentMatchResolved && outletRootMatch ? outletRootMatch.id : void 0;
-	const routeId = isCurrentMatchResolved && outletRootMatch ? outletRootMatch.routeId : void 0;
-	const currentCachedRoute = cachedRoutes[routerPathname];
-	const isCurrentRouteErrored = hasCurrentRouteError({
-		erroredRouteCounts,
-		matches,
-		resolvedPathname,
-		routerPathname
-	});
-	const bypassCachedPathname = isCurrentRouteErrored ? routerPathname : void 0;
-	const previousPathname = previousPathnameRef.current;
-	previousHrefRef.current;
-	const shouldRestoreDestinationHref = shouldRestoreCachedHref({
-		cachedHref: destinationRoute?.href,
-		currentHref: routerHref,
-		currentPathname: routerPathname,
-		isRouteCacheEnabled: isRouteCacheEnabled(destinationRoute?.staticData),
-		previousPathname
-	});
-	useLayoutEffect(() => {
-		if (shouldRestoreDestinationHref) return;
-		syncCachedRouteState({
-			isCurrentMatchReady,
-			isCurrentMatchResolved,
-			isCurrentRouteErrored,
-			matchId,
-			matches,
-			routeId,
-			route: currentCachedRoute,
-			routerLocation,
-			router,
-			routerResolvedLocation,
-			routerHref,
-			routerPathname,
-			deleteCachedRoutes,
-			setCachedRoutes,
-			staticData
-		});
-	}, [
-		currentCachedRoute,
-		deleteCachedRoutes,
-		isCurrentRouteErrored,
-		isCurrentMatchReady,
-		isCurrentMatchResolved,
-		matchId,
-		matches,
-		routeId,
-		router,
-		routerLocation,
-		routerResolvedLocation,
-		routerHref,
-		routerPathname,
-		staticData,
-		setCachedRoutes,
-		shouldRestoreDestinationHref
-	]);
-	useLayoutEffect(() => {
-		const lastVisitedPathname = previousPathnameRef.current;
-		const pendingNavigation = pendingCachedNavigationRef.current;
-		if (pendingNavigation && pendingNavigation.pathname !== routerPathname) {
-			eventListener.emit("cachedNavigationCancel", pendingNavigation);
-			pendingCachedNavigationRef.current = null;
-		}
-		if (!lastVisitedPathname || lastVisitedPathname === routerPathname) return;
-		if (!isReadyCachedRoute(destinationRoute)) return;
-		if (pendingCachedNavigationRef.current?.pathname === routerPathname) return;
-		const nextNavigation = {
-			pathname: routerPathname,
-			startedAt: performance.now()
-		};
-		pendingCachedNavigationRef.current = nextNavigation;
-		eventListener.emit("cachedNavigationStart", nextNavigation);
-	}, [
-		destinationRoute,
-		eventListener,
-		routerPathname
-	]);
-	useLayoutEffect(() => {
-		previousRouteCacheModesRef.current ??= /* @__PURE__ */ new Map();
-		previousRouteCacheModesRef.current = syncCachedRouteActivityEvents({
-			cachedRoutes,
-			eventListener,
-			previousRouteCacheModes: previousRouteCacheModesRef.current,
-			routerPathname
-		});
-	}, [
-		cachedRoutes,
-		eventListener,
-		routerPathname
-	]);
-	useLayoutEffect(() => {
-		if (previousVisiblePathnameRef.current === routerPathname || !cachedRoutes[routerPathname]) {
-			previousVisiblePathnameRef.current = routerPathname;
-			return;
-		}
-		previousVisiblePathnameRef.current = routerPathname;
-		touchCachedRoutes([routerPathname]);
-	}, [
-		cachedRoutes,
-		touchCachedRoutes,
-		routerPathname
-	]);
-	useEffect(() => {
-		const pendingNavigation = pendingCachedNavigationRef.current;
-		if (routerPathname !== pendingNavigation?.pathname) return;
-		let firstFrameId = 0;
-		let secondFrameId = 0;
-		firstFrameId = globalThis.requestAnimationFrame(() => {
-			const visibleAt = performance.now();
-			secondFrameId = globalThis.requestAnimationFrame(() => {
-				const paintedAt = performance.now();
-				if (pendingCachedNavigationRef.current?.pathname !== pendingNavigation.pathname) return;
-				pendingCachedNavigationRef.current = null;
-				eventListener.emit("cachedNavigationComplete", {
-					...pendingNavigation,
-					duration: paintedAt - pendingNavigation.startedAt,
-					paintedAt,
-					visibleAt
-				});
-			});
-		});
-		return () => {
-			globalThis.cancelAnimationFrame(firstFrameId);
-			globalThis.cancelAnimationFrame(secondFrameId);
-		};
-	}, [eventListener, routerPathname]);
-	useLayoutEffect(() => {
-		if (!(shouldRestoreDestinationHref && destinationRoute?.href)) return;
-		restoreCachedHref(router, destinationRoute.href);
-	}, [
-		destinationRoute?.href,
-		router,
-		shouldRestoreDestinationHref
-	]);
-	useEffect(() => {
-		previousPathnameRef.current = routerPathname;
-		previousHrefRef.current = routerHref;
-	}, [routerHref, routerPathname]);
-	const shouldRenderLiveOutlet = routerPathname === bypassCachedPathname || !isReadyCachedRoute(destinationRoute);
-	useRouterCacheDebug(cachedRoutes, routerPathname);
-	return /* @__PURE__ */ jsxs(Fragment, { children: [Object.entries(cachedRoutes).map(([pathname, route]) => renderCachedRoute({
-		bypassCachedPathname,
-		pathname,
-		route,
-		routerPathname
-	})), shouldRenderLiveOutlet ? /* @__PURE__ */ jsx(Outlet, {}, `live-${routerPathname}`) : null] });
-}
-//#endregion
-//#region src/components/router-cache-outlet.tsx
-function RouterCacheOutlet(props) {
-	const { children } = props;
-	return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(RouteCacheManager, {}), children] });
-}
-//#endregion
-//#region src/hooks/use-route-cache-active.ts
-function useRoutePathname(pathname) {
-	const locationPathname = useLocation({ select: (location) => location.pathname });
-	return normalizeCachedRoutePathname(pathname ?? locationPathname);
-}
-function useRouteCacheActive(pathname) {
-	const routePathname = useRoutePathname(pathname);
-	const [isActive, setIsActive] = useState(true);
-	useEventListener({ on: { activeChange: ({ pathname: changedPathname, mode }) => {
-		if (changedPathname === routePathname) setIsActive(mode === "visible");
-	} } });
-	return isActive;
-}
-//#endregion
-//#region src/hooks/use-route-cache-activity.ts
-function useRouteCacheActivity(fn) {
-	const routePathname = useLocation({ select: (location) => location.pathname });
-	useEventListener({ on: { activeChange: ({ pathname, mode, callback }) => {
-		if (pathname === routePathname) fn(mode === "visible");
-		callback?.();
-	} } });
-}
-//#endregion
-//#region src/hooks/use-route-cache-effect.ts
-function areDependenciesEqual(previousDeps, nextDeps) {
-	if (previousDeps?.length !== nextDeps.length) return false;
-	for (let index = 0; index < nextDeps.length; index += 1) if (!Object.is(previousDeps[index], nextDeps[index])) return false;
-	return true;
-}
-function useRouteCacheEffect(activeCallback, deps = []) {
-	const returnValue = useRef(void 0);
-	const isActiveRef = useRef(false);
-	const previousCallbackRef = useRef(void 0);
-	const previousDepsRef = useRef(void 0);
-	useEffect(() => {
-		const callbackChanged = previousCallbackRef.current !== activeCallback;
-		const dependenciesChanged = !areDependenciesEqual(previousDepsRef.current, deps);
-		if (!(callbackChanged || dependenciesChanged)) return;
-		previousCallbackRef.current = activeCallback;
-		previousDepsRef.current = deps;
-		if (!isActiveRef.current) return;
-		returnValue.current?.();
-		returnValue.current = activeCallback();
-	});
-	useEffect(() => () => {
-		returnValue.current?.();
-	}, []);
-	useRouteCacheActivity((active) => {
-		if (active) {
-			isActiveRef.current = true;
-			returnValue.current = activeCallback();
-			return;
-		}
-		isActiveRef.current = false;
-		returnValue.current?.();
-	});
-}
-//#endregion
-//#region src/hooks/use-route-cache-error-boundary.ts
-function useRouteCacheErrorBoundary(pathname) {
-	const context = useOptionalRouterCacheContext();
-	const routePathname = useLocation({ select: (location) => location.pathname });
-	useEffect(() => {
-		if (!context) return;
-		const targetPathname = normalizeCachedRoutePathname(pathname ?? routePathname);
-		context.retainErroredRoute(targetPathname);
-		return () => {
-			context.releaseErroredRoute(targetPathname);
-		};
-	}, [
-		context,
-		pathname,
-		routePathname
-	]);
-}
-//#endregion
-//#region src/hooks/use-route-cache-navigation.ts
-const INITIAL_STATE = {
-	activeNavigation: null,
-	lastCompletedNavigation: null
-};
-function useRouteCacheNavigation() {
-	const [state, setState] = useState(INITIAL_STATE);
-	useEventListener({ on: {
-		cachedNavigationStart: (navigation) => {
-			setState((current) => ({
-				...current,
-				activeNavigation: navigation
-			}));
-		},
-		cachedNavigationCancel: (navigation) => {
-			setState((current) => {
-				if (current.activeNavigation?.pathname !== navigation.pathname) return current;
-				return {
-					...current,
-					activeNavigation: null
-				};
-			});
-		},
-		cachedNavigationComplete: (navigation) => {
-			setState((current) => ({
-				activeNavigation: current.activeNavigation?.pathname === navigation.pathname ? null : current.activeNavigation,
-				lastCompletedNavigation: navigation
-			}));
-		}
-	} });
-	return state;
-}
-//#endregion
-//#region src/hooks/use-update.ts
-function useUpdate() {
-	const [, setState] = useState({});
-	return useCallback(() => setState({}), []);
-}
-//#endregion
-//#region src/hooks/use-router-cache.ts
-function useRouterCache() {
-	const { cachedRoutes, deleteCachedRoutes } = useRouterCacheContext();
-	const update = useUpdate();
-	useEventListener({ on: { activeChange: () => {
-		update();
-	} } });
-	const destroy = (pathname) => {
-		deleteCachedRoutes(Array.isArray(pathname) ? pathname : [pathname]);
-	};
-	const destroyAll = () => {
-		deleteCachedRoutes(Object.keys(cachedRoutes));
-	};
-	const invalidateWhere = (predicate) => {
-		const pathnames = Object.entries(cachedRoutes).flatMap(([pathname, route]) => predicate(pathname, route) ? [pathname] : []);
-		if (pathnames.length > 0) deleteCachedRoutes(pathnames);
-		return pathnames;
-	};
-	return {
-		cachedRoutes,
-		destroy,
-		destroyAll,
-		invalidateWhere,
-		isCached: (pathname) => Object.hasOwn(cachedRoutes, normalizeCachedRoutePathname(pathname))
-	};
-}
-//#endregion
-export { RouterCacheOutlet, RouterCacheProvider, useRouteCacheActive, useRouteCacheActivity, useRouteCacheEffect, useRouteCacheErrorBoundary, useRouteCacheNavigation, useRouterCache };
+import { defineRouteCache } from "./route-cache-static-data.js";
+import { RouterCacheProvider } from "./contexts/router-cache.js";
+import { RouterCacheOutlet } from "./components/router-cache-outlet.js";
+import { useRouteCacheActive } from "./hooks/use-route-cache-active.js";
+import { useRouteCacheActivity } from "./hooks/use-route-cache-activity.js";
+import { useRouteCacheEffect } from "./hooks/use-route-cache-effect.js";
+import { useRouteCacheErrorBoundary } from "./hooks/use-route-cache-error-boundary.js";
+import { useRouteCacheNavigation } from "./hooks/use-route-cache-navigation.js";
+import { useRouterCache } from "./hooks/use-router-cache.js";
+export { RouterCacheOutlet, RouterCacheProvider, defineRouteCache, useRouteCacheActive, useRouteCacheActivity, useRouteCacheEffect, useRouteCacheErrorBoundary, useRouteCacheNavigation, useRouterCache };