tanstack-router-cache 0.1.0 → 0.1.1

package/dist/index.js

@@ -1,10 +1,1281 @@
-import { RouterCacheOutlet } from "./components/router-cache-outlet.tsx";
-import { RouterCacheProvider } from "./contexts/router-cache.tsx";
-import { useRouteCacheActive } from "./hooks/use-route-cache-active.ts";
-import { useRouteCacheActivity } from "./hooks/use-route-cache-activity.ts";
-import { useRouteCacheEffect } from "./hooks/use-route-cache-effect.ts";
-import { useRouteCacheErrorBoundary } from "./hooks/use-route-cache-error-boundary.ts";
-import { useRouteCacheNavigation } from "./hooks/use-route-cache-navigation.ts";
-import { useRouterCache } from "./hooks/use-router-cache.ts";
-export * from "./types.ts";
+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 initialCachedRoutes = useRef(applyCachedRouteLimits(filterRouterCacheRoutes(defaultCachedRoutes), cacheConfigRef.current, /* @__PURE__ */ new Set()));
+	const [cachedRoutes, setCachedRoutes] = useState(() => initialCachedRoutes.current);
+	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(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,
+			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;
+				console.warn("[tanstack-router-cache] cached route count exceeded threshold", nextSnapshot);
+			}
+		});
+		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();
+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") {
+			saveScrollPosition();
+			return;
+		}
+		const savedPosition = windowScrollPositions.get(pathname);
+		const handleScroll = () => saveScrollPosition();
+		globalThis.addEventListener("scroll", handleScroll, { passive: true });
+		if (!savedPosition) {
+			saveScrollPosition();
+			return () => globalThis.removeEventListener("scroll", handleScroll);
+		}
+		let rafId = globalThis.requestAnimationFrame(() => {
+			rafId = globalThis.requestAnimationFrame(() => {
+				globalThis.scrollTo(savedPosition.x, savedPosition.y);
+				saveScrollPosition();
+			});
+		});
+		return () => {
+			globalThis.cancelAnimationFrame(rafId);
+			globalThis.removeEventListener("scroll", handleScroll);
+		};
+	}, [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"
+];
+function createStaticStore(value) {
+	return {
+		get: () => value,
+		subscribe: () => ({ unsubscribe: () => void 0 })
+	};
+}
+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 isRouterSearch(value) {
+	return typeof value === "object" && value !== null;
+}
+function toRouterLocation(location) {
+	return {
+		href: location.href,
+		pathname: location.pathname,
+		search: isRouterSearch(location.search) ? location.search : void 0
+	};
+}
+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) {
+	if (!isRouterMatch(match)) return;
+	return {
+		...match,
+		_nonReactive: { ...match._nonReactive }
+	};
+}
+function shouldRefreshCachedRoute(route, routerHref) {
+	return !(isRouteCacheEnabled(route?.staticData) && route.ready) || route.href !== routerHref;
+}
+function syncReadyCachedRoute({ matchId, matches, routeId, route, routerLocation, router, routerResolvedLocation, routerHref, routerPathname, setCachedRoutes, staticData }) {
+	if (!shouldRefreshCachedRoute(route, routerHref)) return;
+	setCachedRoutes(routerPathname, {
+		href: routerHref,
+		matchId,
+		routeId,
+		ready: true,
+		routerSnapshot: matchId ? createRouterSnapshot({
+			matches,
+			router,
+			routerLocation,
+			routerResolvedLocation
+		}) : void 0,
+		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({ matches, router, routerLocation, routerResolvedLocation }) {
+	const snapshotMatches = matches.reduce((snapshot, match) => {
+		const nextMatch = snapshotMatch(match);
+		if (isRouterMatch(nextMatch)) snapshot.push(nextMatch);
+		return snapshot;
+	}, []);
+	const matchStores = new Map(snapshotMatches.map((match) => {
+		const store = Object.assign(createStaticStore(match), { routeId: match.routeId });
+		return [match.id, store];
+	}));
+	const snapshotState = {
+		...router.stores.__store.get(),
+		matches: snapshotMatches,
+		location: routerLocation,
+		resolvedLocation: routerResolvedLocation
+	};
+	const routeMatchStoreCache = /* @__PURE__ */ new Map();
+	const stores = {
+		...router.stores,
+		status: createStaticStore(router.stores.status.get()),
+		loadedAt: createStaticStore(router.stores.loadedAt.get()),
+		isLoading: createStaticStore(router.stores.isLoading.get()),
+		isTransitioning: createStaticStore(router.stores.isTransitioning.get()),
+		location: createStaticStore(routerLocation),
+		resolvedLocation: createStaticStore(routerResolvedLocation),
+		statusCode: createStaticStore(router.stores.statusCode.get()),
+		redirect: createStaticStore(router.stores.redirect.get()),
+		matchesId: createStaticStore(snapshotMatches.map((match) => match.id)),
+		pendingIds: createStaticStore([]),
+		cachedIds: createStaticStore([]),
+		matches: createStaticStore(snapshotMatches),
+		pendingMatches: createStaticStore([]),
+		cachedMatches: createStaticStore([]),
+		firstId: createStaticStore(snapshotMatches[0]?.id),
+		hasPending: createStaticStore(snapshotMatches.some((match) => match.status === "pending")),
+		matchRouteDeps: createStaticStore({
+			locationHref: routerLocation.href,
+			resolvedLocationHref: routerResolvedLocation?.href,
+			status: snapshotState.status
+		}),
+		__store: createStaticStore(snapshotState),
+		matchStores,
+		pendingMatchStores: /* @__PURE__ */ new Map(),
+		cachedMatchStores: /* @__PURE__ */ new Map(),
+		getRouteMatchStore: (routeId) => {
+			let cached = routeMatchStoreCache.get(routeId);
+			if (!cached) {
+				cached = createStaticStore(snapshotMatches.find((match) => match.routeId === routeId));
+				routeMatchStoreCache.set(routeId, cached);
+			}
+			return cached;
+		},
+		setMatches: () => void 0,
+		setPending: () => void 0,
+		setCached: () => void 0
+	};
+	const routerSnapshot = Object.create(router);
+	Object.defineProperties(routerSnapshot, {
+		stores: { value: stores },
+		latestLocation: { value: routerLocation },
+		getMatch: { value: (matchId) => matchStores.get(matchId)?.get() },
+		updateMatch: { value: () => void 0 },
+		...getLiveRouterMethodDescriptors(router)
+	});
+	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 isAncestorPathname(ancestorPathname, pathname) {
+	if (ancestorPathname === pathname) return false;
+	if (ancestorPathname === "/") return pathname.startsWith("/");
+	return pathname.startsWith(`${ancestorPathname}/`);
+}
+function getShouldRenderLiveOutlet({ cachedRoutes, bypassCachedPathname, visiblePathname }) {
+	if (visiblePathname === bypassCachedPathname) return true;
+	const visibleRoute = cachedRoutes[visiblePathname];
+	return !isReadyCachedRoute(visibleRoute);
+}
+function renderCachedRoute({ bypassCachedPathname, pathname, route, visiblePathname }) {
+	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: visiblePathname === pathname ? "visible" : "hidden",
+		pathname,
+		children: content
+	}, pathname);
+}
+function buildRouteCacheModes(cachedRoutes, visiblePathname) {
+	const nextModes = /* @__PURE__ */ new Map();
+	for (const pathname of Object.keys(cachedRoutes)) nextModes.set(pathname, visiblePathname === pathname ? "visible" : "hidden");
+	return nextModes;
+}
+function syncCachedRouteActivityEvents(params) {
+	const nextModes = buildRouteCacheModes(params.cachedRoutes, params.visiblePathname);
+	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(/* @__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 visiblePathname = routerPathname !== resolvedPathname && (isReadyCachedRoute(destinationRoute) || isAncestorPathname(routerPathname, resolvedPathname)) ? routerPathname : resolvedPathname;
+	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 && visiblePathname !== pendingNavigation.pathname) {
+			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,
+		visiblePathname
+	]);
+	useLayoutEffect(() => {
+		previousRouteCacheModesRef.current = syncCachedRouteActivityEvents({
+			cachedRoutes,
+			eventListener,
+			previousRouteCacheModes: previousRouteCacheModesRef.current,
+			visiblePathname
+		});
+	}, [
+		cachedRoutes,
+		eventListener,
+		visiblePathname
+	]);
+	useLayoutEffect(() => {
+		if (previousVisiblePathnameRef.current === visiblePathname || !cachedRoutes[visiblePathname]) {
+			previousVisiblePathnameRef.current = visiblePathname;
+			return;
+		}
+		previousVisiblePathnameRef.current = visiblePathname;
+		touchCachedRoutes([visiblePathname]);
+	}, [
+		cachedRoutes,
+		touchCachedRoutes,
+		visiblePathname
+	]);
+	useEffect(() => {
+		const pendingNavigation = pendingCachedNavigationRef.current;
+		if (visiblePathname !== 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, visiblePathname]);
+	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 = getShouldRenderLiveOutlet({
+		cachedRoutes,
+		bypassCachedPathname,
+		visiblePathname
+	});
+	useRouterCacheDebug(cachedRoutes, visiblePathname);
+	return /* @__PURE__ */ jsxs(Fragment, { children: [Object.entries(cachedRoutes).map(([pathname, route]) => renderCachedRoute({
+		bypassCachedPathname,
+		pathname,
+		route,
+		visiblePathname
+	})), 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 };