docs-i18n 0.12.0 → 0.13.0

package/admin/dist/server/assets/Match-BeWrYoSG.js

@@ -0,0 +1,3236 @@
+import { i as __toESM } from "./chunk-CNvmzFzq.js";
+import { l as require_react, r as require_jsx_runtime, t as useRouter } from "./useRouter-BXJvr8to.js";
+import { A as decodePath, B as replaceEqualDeep, C as processRouteMasks, D as DEFAULT_PROTOCOL_ALLOWLIST, E as invariant, F as isDangerousProtocol, L as isPromise, M as encodePathLikeUrl, N as escapeHtml, O as arraysEqual, P as functionalUpdate, R as last, S as findSingleMatch, T as createLRUCache, _ as trimPath, a as matchContext, b as findFlatMatch, c as rootRouteId, d as compileDecodeCharMap, g as resolvePath, j as deepEqual, k as createControlledPromise, l as isNotFound, m as joinPaths, o as ClientOnly, p as interpolatePath, r as useStore, u as cleanPath, w as processRouteTree, x as findRouteMatch, y as trimPathRight, z as nullReplaceEqualDeep } from "./__tanstack-start-server-fn-resolver-SG4WUVWE.js";
+import { g as redirect, m as isRedirect } from "./createServerFn-CAF9Kl7K.js";
+//#region ../../node_modules/.bun/@tanstack+router-core@1.168.3/node_modules/@tanstack/router-core/dist/esm/scroll-restoration.js
+function getSafeSessionStorage() {
+	try {
+		if (typeof window !== "undefined" && typeof window.sessionStorage === "object") return window.sessionStorage;
+	} catch {}
+}
+/** SessionStorage key used to persist scroll restoration state. */
+/** SessionStorage key used to store scroll positions across navigations. */
+/** SessionStorage key used to store scroll positions across navigations. */
+var storageKey = "tsr-scroll-restoration-v1_3";
+function createScrollRestorationCache() {
+	const safeSessionStorage = getSafeSessionStorage();
+	if (!safeSessionStorage) return null;
+	const persistedState = safeSessionStorage.getItem(storageKey);
+	let state = persistedState ? JSON.parse(persistedState) : {};
+	return {
+		state,
+		set: (updater) => {
+			state = functionalUpdate(updater, state) || state;
+			try {
+				safeSessionStorage.setItem(storageKey, JSON.stringify(state));
+			} catch {
+				console.warn("[ts-router] Could not persist scroll restoration state to sessionStorage.");
+			}
+		}
+	};
+}
+createScrollRestorationCache();
+/**
+* The default `getKey` function for `useScrollRestoration`.
+* It returns the `key` from the location state or the `href` of the location.
+*
+* The `location.href` is used as a fallback to support the use case where the location state is not available like the initial render.
+*/
+/**
+* Default scroll restoration cache key: location state key or full href.
+*/
+var defaultGetScrollRestorationKey = (location) => {
+	return location.state.__TSR_key || location.href;
+};
+function restoreScroll({ storageKey, key, behavior, shouldScrollRestoration, scrollToTopSelectors, location }) {
+	let byKey;
+	try {
+		byKey = JSON.parse(sessionStorage.getItem(storageKey) || "{}");
+	} catch (error) {
+		console.error(error);
+		return;
+	}
+	const resolvedKey = key || window.history.state?.__TSR_key;
+	const elementEntries = byKey[resolvedKey];
+	scroll: {
+		if (shouldScrollRestoration && elementEntries && Object.keys(elementEntries).length > 0) {
+			for (const elementSelector in elementEntries) {
+				const entry = elementEntries[elementSelector];
+				if (elementSelector === "window") window.scrollTo({
+					top: entry.scrollY,
+					left: entry.scrollX,
+					behavior
+				});
+				else if (elementSelector) {
+					const element = document.querySelector(elementSelector);
+					if (element) {
+						element.scrollLeft = entry.scrollX;
+						element.scrollTop = entry.scrollY;
+					}
+				}
+			}
+			break scroll;
+		}
+		const hash = (location ?? window.location).hash.split("#", 2)[1];
+		if (hash) {
+			const hashScrollIntoViewOptions = window.history.state?.__hashScrollIntoViewOptions ?? true;
+			if (hashScrollIntoViewOptions) {
+				const el = document.getElementById(hash);
+				if (el) el.scrollIntoView(hashScrollIntoViewOptions);
+			}
+			break scroll;
+		}
+		const scrollOptions = {
+			top: 0,
+			left: 0,
+			behavior
+		};
+		window.scrollTo(scrollOptions);
+		if (scrollToTopSelectors) for (const selector of scrollToTopSelectors) {
+			if (selector === "window") continue;
+			const element = typeof selector === "function" ? selector() : document.querySelector(selector);
+			if (element) element.scrollTo(scrollOptions);
+		}
+	}
+}
+/**
+* @private
+* Handles hash-based scrolling after navigation completes.
+* To be used in framework-specific <Transitioner> components during the onResolved event.
+*
+* Provides hash scrolling for programmatic navigation when default browser handling is prevented.
+* @param router The router instance containing current location and state
+*/
+/**
+* @private
+* Handles hash-based scrolling after navigation completes.
+* To be used in framework-specific Transitioners.
+*/
+function handleHashScroll(router) {
+	if (typeof document !== "undefined" && document.querySelector) {
+		const location = router.stores.location.state;
+		const hashScrollIntoViewOptions = location.state.__hashScrollIntoViewOptions ?? true;
+		if (hashScrollIntoViewOptions && location.hash !== "") {
+			const el = document.getElementById(location.hash);
+			if (el) el.scrollIntoView(hashScrollIntoViewOptions);
+		}
+	}
+}
+//#endregion
+//#region ../../node_modules/.bun/@tanstack+router-core@1.168.3/node_modules/@tanstack/router-core/dist/esm/qss.js
+/**
+* Program is a reimplementation of the `qss` package:
+* Copyright (c) Luke Edwards luke.edwards05@gmail.com, MIT License
+* https://github.com/lukeed/qss/blob/master/license.md
+*
+* This reimplementation uses modern browser APIs
+* (namely URLSearchParams) and TypeScript while still
+* maintaining the original functionality and interface.
+*
+* Update: this implementation has also been mangled to
+* fit exactly our use-case (single value per key in encoding).
+*/
+/**
+* Encodes an object into a query string.
+* @param obj - The object to encode into a query string.
+* @param stringify - An optional custom stringify function.
+* @returns The encoded query string.
+* @example
+* ```
+* // Example input: encode({ token: 'foo', key: 'value' })
+* // Expected output: "token=foo&key=value"
+* ```
+*/
+function encode(obj, stringify = String) {
+	const result = new URLSearchParams();
+	for (const key in obj) {
+		const val = obj[key];
+		if (val !== void 0) result.set(key, stringify(val));
+	}
+	return result.toString();
+}
+/**
+* Converts a string value to its appropriate type (string, number, boolean).
+* @param mix - The string value to convert.
+* @returns The converted value.
+* @example
+* // Example input: toValue("123")
+* // Expected output: 123
+*/
+function toValue(str) {
+	if (!str) return "";
+	if (str === "false") return false;
+	if (str === "true") return true;
+	return +str * 0 === 0 && +str + "" === str ? +str : str;
+}
+/**
+* Decodes a query string into an object.
+* @param str - The query string to decode.
+* @returns The decoded key-value pairs in an object format.
+* @example
+* // Example input: decode("token=foo&key=value")
+* // Expected output: { "token": "foo", "key": "value" }
+*/
+function decode(str) {
+	const searchParams = new URLSearchParams(str);
+	const result = Object.create(null);
+	for (const [key, value] of searchParams.entries()) {
+		const previousValue = result[key];
+		if (previousValue == null) result[key] = toValue(value);
+		else if (Array.isArray(previousValue)) previousValue.push(toValue(value));
+		else result[key] = [previousValue, toValue(value)];
+	}
+	return result;
+}
+//#endregion
+//#region ../../node_modules/.bun/@tanstack+router-core@1.168.3/node_modules/@tanstack/router-core/dist/esm/searchParams.js
+/** Default `parseSearch` that strips leading '?' and JSON-parses values. */
+var defaultParseSearch = parseSearchWith(JSON.parse);
+/** Default `stringifySearch` using JSON.stringify for complex values. */
+var defaultStringifySearch = stringifySearchWith(JSON.stringify, JSON.parse);
+/**
+* Build a `parseSearch` function using a provided JSON-like parser.
+*
+* The returned function strips a leading `?`, decodes values, and attempts to
+* JSON-parse string values using the given `parser`.
+*
+* @param parser Function to parse a string value (e.g. `JSON.parse`).
+* @returns A `parseSearch` function compatible with `Router` options.
+* @link https://tanstack.com/router/latest/docs/framework/react/guide/custom-search-param-serialization
+*/
+function parseSearchWith(parser) {
+	return (searchStr) => {
+		if (searchStr[0] === "?") searchStr = searchStr.substring(1);
+		const query = decode(searchStr);
+		for (const key in query) {
+			const value = query[key];
+			if (typeof value === "string") try {
+				query[key] = parser(value);
+			} catch (_err) {}
+		}
+		return query;
+	};
+}
+/**
+* Build a `stringifySearch` function using a provided serializer.
+*
+* Non-primitive values are serialized with `stringify`. If a `parser` is
+* supplied, string values that are parseable are re-serialized to ensure
+* symmetry with `parseSearch`.
+*
+* @param stringify Function to serialize a value (e.g. `JSON.stringify`).
+* @param parser Optional parser to detect parseable strings.
+* @returns A `stringifySearch` function compatible with `Router` options.
+* @link https://tanstack.com/router/latest/docs/framework/react/guide/custom-search-param-serialization
+*/
+function stringifySearchWith(stringify, parser) {
+	const hasParser = typeof parser === "function";
+	function stringifyValue(val) {
+		if (typeof val === "object" && val !== null) try {
+			return stringify(val);
+		} catch (_err) {}
+		else if (hasParser && typeof val === "string") try {
+			parser(val);
+			return stringify(val);
+		} catch (_err) {}
+		return val;
+	}
+	return (search) => {
+		const searchStr = encode(search, stringifyValue);
+		return searchStr ? `?${searchStr}` : "";
+	};
+}
+//#endregion
+//#region ../../node_modules/.bun/@tanstack+router-core@1.168.3/node_modules/@tanstack/router-core/dist/esm/rewrite.js
+/** Compose multiple rewrite pairs into a single in/out rewrite. */
+/** Compose multiple rewrite pairs into a single in/out rewrite. */
+function composeRewrites(rewrites) {
+	return {
+		input: ({ url }) => {
+			for (const rewrite of rewrites) url = executeRewriteInput(rewrite, url);
+			return url;
+		},
+		output: ({ url }) => {
+			for (let i = rewrites.length - 1; i >= 0; i--) url = executeRewriteOutput(rewrites[i], url);
+			return url;
+		}
+	};
+}
+/** Create a rewrite pair that strips/adds a basepath on input/output. */
+/** Create a rewrite pair that strips/adds a basepath on input/output. */
+function rewriteBasepath(opts) {
+	const trimmedBasepath = trimPath(opts.basepath);
+	const normalizedBasepath = `/${trimmedBasepath}`;
+	const normalizedBasepathWithSlash = `${normalizedBasepath}/`;
+	const checkBasepath = opts.caseSensitive ? normalizedBasepath : normalizedBasepath.toLowerCase();
+	const checkBasepathWithSlash = opts.caseSensitive ? normalizedBasepathWithSlash : normalizedBasepathWithSlash.toLowerCase();
+	return {
+		input: ({ url }) => {
+			const pathname = opts.caseSensitive ? url.pathname : url.pathname.toLowerCase();
+			if (pathname === checkBasepath) url.pathname = "/";
+			else if (pathname.startsWith(checkBasepathWithSlash)) url.pathname = url.pathname.slice(normalizedBasepath.length);
+			return url;
+		},
+		output: ({ url }) => {
+			url.pathname = joinPaths([
+				"/",
+				trimmedBasepath,
+				url.pathname
+			]);
+			return url;
+		}
+	};
+}
+/** Execute a location input rewrite if provided. */
+/** Execute a location input rewrite if provided. */
+function executeRewriteInput(rewrite, url) {
+	const res = rewrite?.input?.({ url });
+	if (res) {
+		if (typeof res === "string") return new URL(res);
+		else if (res instanceof URL) return res;
+	}
+	return url;
+}
+/** Execute a location output rewrite if provided. */
+/** Execute a location output rewrite if provided. */
+function executeRewriteOutput(rewrite, url) {
+	const res = rewrite?.output?.({ url });
+	if (res) {
+		if (typeof res === "string") return new URL(res);
+		else if (res instanceof URL) return res;
+	}
+	return url;
+}
+//#endregion
+//#region ../../node_modules/.bun/@tanstack+router-core@1.168.3/node_modules/@tanstack/router-core/dist/esm/stores.js
+/** SSR non-reactive createMutableStore */
+function createNonReactiveMutableStore(initialValue) {
+	let value = initialValue;
+	return {
+		get state() {
+			return value;
+		},
+		setState(updater) {
+			value = updater(value);
+		}
+	};
+}
+/** SSR non-reactive createReadonlyStore */
+function createNonReactiveReadonlyStore(read) {
+	return { get state() {
+		return read();
+	} };
+}
+function createRouterStores(initialState, config) {
+	const { createMutableStore, createReadonlyStore, batch, init } = config;
+	const activeMatchStoresById = /* @__PURE__ */ new Map();
+	const pendingMatchStoresById = /* @__PURE__ */ new Map();
+	const cachedMatchStoresById = /* @__PURE__ */ new Map();
+	const status = createMutableStore(initialState.status);
+	const loadedAt = createMutableStore(initialState.loadedAt);
+	const isLoading = createMutableStore(initialState.isLoading);
+	const isTransitioning = createMutableStore(initialState.isTransitioning);
+	const location = createMutableStore(initialState.location);
+	const resolvedLocation = createMutableStore(initialState.resolvedLocation);
+	const statusCode = createMutableStore(initialState.statusCode);
+	const redirect = createMutableStore(initialState.redirect);
+	const matchesId = createMutableStore([]);
+	const pendingMatchesId = createMutableStore([]);
+	const cachedMatchesId = createMutableStore([]);
+	const activeMatchesSnapshot = createReadonlyStore(() => readPoolMatches(activeMatchStoresById, matchesId.state));
+	const pendingMatchesSnapshot = createReadonlyStore(() => readPoolMatches(pendingMatchStoresById, pendingMatchesId.state));
+	const cachedMatchesSnapshot = createReadonlyStore(() => readPoolMatches(cachedMatchStoresById, cachedMatchesId.state));
+	const firstMatchId = createReadonlyStore(() => matchesId.state[0]);
+	const hasPendingMatches = createReadonlyStore(() => matchesId.state.some((matchId) => {
+		return activeMatchStoresById.get(matchId)?.state.status === "pending";
+	}));
+	const matchRouteReactivity = createReadonlyStore(() => ({
+		locationHref: location.state.href,
+		resolvedLocationHref: resolvedLocation.state?.href,
+		status: status.state
+	}));
+	const __store = createReadonlyStore(() => ({
+		status: status.state,
+		loadedAt: loadedAt.state,
+		isLoading: isLoading.state,
+		isTransitioning: isTransitioning.state,
+		matches: activeMatchesSnapshot.state,
+		location: location.state,
+		resolvedLocation: resolvedLocation.state,
+		statusCode: statusCode.state,
+		redirect: redirect.state
+	}));
+	const matchStoreByRouteIdCache = createLRUCache(64);
+	function getMatchStoreByRouteId(routeId) {
+		let cached = matchStoreByRouteIdCache.get(routeId);
+		if (!cached) {
+			cached = createReadonlyStore(() => {
+				const ids = matchesId.state;
+				for (const id of ids) {
+					const matchStore = activeMatchStoresById.get(id);
+					if (matchStore && matchStore.routeId === routeId) return matchStore.state;
+				}
+			});
+			matchStoreByRouteIdCache.set(routeId, cached);
+		}
+		return cached;
+	}
+	const store = {
+		status,
+		loadedAt,
+		isLoading,
+		isTransitioning,
+		location,
+		resolvedLocation,
+		statusCode,
+		redirect,
+		matchesId,
+		pendingMatchesId,
+		cachedMatchesId,
+		activeMatchesSnapshot,
+		pendingMatchesSnapshot,
+		cachedMatchesSnapshot,
+		firstMatchId,
+		hasPendingMatches,
+		matchRouteReactivity,
+		activeMatchStoresById,
+		pendingMatchStoresById,
+		cachedMatchStoresById,
+		__store,
+		getMatchStoreByRouteId,
+		setActiveMatches,
+		setPendingMatches,
+		setCachedMatches
+	};
+	setActiveMatches(initialState.matches);
+	init?.(store);
+	function setActiveMatches(nextMatches) {
+		reconcileMatchPool(nextMatches, activeMatchStoresById, matchesId, createMutableStore, batch);
+	}
+	function setPendingMatches(nextMatches) {
+		reconcileMatchPool(nextMatches, pendingMatchStoresById, pendingMatchesId, createMutableStore, batch);
+	}
+	function setCachedMatches(nextMatches) {
+		reconcileMatchPool(nextMatches, cachedMatchStoresById, cachedMatchesId, createMutableStore, batch);
+	}
+	return store;
+}
+function readPoolMatches(pool, ids) {
+	const matches = [];
+	for (const id of ids) {
+		const matchStore = pool.get(id);
+		if (matchStore) matches.push(matchStore.state);
+	}
+	return matches;
+}
+function reconcileMatchPool(nextMatches, pool, idStore, createMutableStore, batch) {
+	const nextIds = nextMatches.map((d) => d.id);
+	const nextIdSet = new Set(nextIds);
+	batch(() => {
+		for (const id of pool.keys()) if (!nextIdSet.has(id)) pool.delete(id);
+		for (const nextMatch of nextMatches) {
+			const existing = pool.get(nextMatch.id);
+			if (!existing) {
+				const matchStore = createMutableStore(nextMatch);
+				matchStore.routeId = nextMatch.routeId;
+				pool.set(nextMatch.id, matchStore);
+				continue;
+			}
+			existing.routeId = nextMatch.routeId;
+			if (existing.state !== nextMatch) existing.setState(() => nextMatch);
+		}
+		if (!arraysEqual(idStore.state, nextIds)) idStore.setState(() => nextIds);
+	});
+}
+//#endregion
+//#region ../../node_modules/.bun/@tanstack+router-core@1.168.3/node_modules/@tanstack/router-core/dist/esm/load-matches.js
+var triggerOnReady = (inner) => {
+	if (!inner.rendered) {
+		inner.rendered = true;
+		return inner.onReady?.();
+	}
+};
+var resolvePreload = (inner, matchId) => {
+	return !!(inner.preload && !inner.router.stores.activeMatchStoresById.has(matchId));
+};
+/**
+* Builds the accumulated context from router options and all matches up to (and optionally including) the given index.
+* Merges __routeContext and __beforeLoadContext from each match.
+*/
+var buildMatchContext = (inner, index, includeCurrentMatch = true) => {
+	const context = { ...inner.router.options.context ?? {} };
+	const end = includeCurrentMatch ? index : index - 1;
+	for (let i = 0; i <= end; i++) {
+		const innerMatch = inner.matches[i];
+		if (!innerMatch) continue;
+		const m = inner.router.getMatch(innerMatch.id);
+		if (!m) continue;
+		Object.assign(context, m.__routeContext, m.__beforeLoadContext);
+	}
+	return context;
+};
+var getNotFoundBoundaryIndex = (inner, err) => {
+	if (!inner.matches.length) return;
+	const requestedRouteId = err.routeId;
+	const matchedRootIndex = inner.matches.findIndex((m) => m.routeId === inner.router.routeTree.id);
+	const rootIndex = matchedRootIndex >= 0 ? matchedRootIndex : 0;
+	let startIndex = requestedRouteId ? inner.matches.findIndex((match) => match.routeId === requestedRouteId) : inner.firstBadMatchIndex ?? inner.matches.length - 1;
+	if (startIndex < 0) startIndex = rootIndex;
+	for (let i = startIndex; i >= 0; i--) {
+		const match = inner.matches[i];
+		if (inner.router.looseRoutesById[match.routeId].options.notFoundComponent) return i;
+	}
+	return requestedRouteId ? startIndex : rootIndex;
+};
+var handleRedirectAndNotFound = (inner, match, err) => {
+	if (!isRedirect(err) && !isNotFound(err)) return;
+	if (isRedirect(err) && err.redirectHandled && !err.options.reloadDocument) throw err;
+	if (match) {
+		match._nonReactive.beforeLoadPromise?.resolve();
+		match._nonReactive.loaderPromise?.resolve();
+		match._nonReactive.beforeLoadPromise = void 0;
+		match._nonReactive.loaderPromise = void 0;
+		match._nonReactive.error = err;
+		inner.updateMatch(match.id, (prev) => ({
+			...prev,
+			status: isRedirect(err) ? "redirected" : prev.status === "pending" ? "success" : prev.status,
+			context: buildMatchContext(inner, match.index),
+			isFetching: false,
+			error: err
+		}));
+		if (isNotFound(err) && !err.routeId) err.routeId = match.routeId;
+		match._nonReactive.loadPromise?.resolve();
+	}
+	if (isRedirect(err)) {
+		inner.rendered = true;
+		err.options._fromLocation = inner.location;
+		err.redirectHandled = true;
+		err = inner.router.resolveRedirect(err);
+	}
+	throw err;
+};
+var shouldSkipLoader = (inner, matchId) => {
+	const match = inner.router.getMatch(matchId);
+	if (!match) return true;
+	if (match.ssr === false) return true;
+	return false;
+};
+var syncMatchContext = (inner, matchId, index) => {
+	const nextContext = buildMatchContext(inner, index);
+	inner.updateMatch(matchId, (prev) => {
+		return {
+			...prev,
+			context: nextContext
+		};
+	});
+};
+var handleSerialError = (inner, index, err, routerCode) => {
+	const { id: matchId, routeId } = inner.matches[index];
+	const route = inner.router.looseRoutesById[routeId];
+	if (err instanceof Promise) throw err;
+	err.routerCode = routerCode;
+	inner.firstBadMatchIndex ??= index;
+	handleRedirectAndNotFound(inner, inner.router.getMatch(matchId), err);
+	try {
+		route.options.onError?.(err);
+	} catch (errorHandlerErr) {
+		err = errorHandlerErr;
+		handleRedirectAndNotFound(inner, inner.router.getMatch(matchId), err);
+	}
+	inner.updateMatch(matchId, (prev) => {
+		prev._nonReactive.beforeLoadPromise?.resolve();
+		prev._nonReactive.beforeLoadPromise = void 0;
+		prev._nonReactive.loadPromise?.resolve();
+		return {
+			...prev,
+			error: err,
+			status: "error",
+			isFetching: false,
+			updatedAt: Date.now(),
+			abortController: new AbortController()
+		};
+	});
+	if (!inner.preload && !isRedirect(err) && !isNotFound(err)) inner.serialError ??= err;
+};
+var isBeforeLoadSsr = (inner, matchId, index, route) => {
+	const existingMatch = inner.router.getMatch(matchId);
+	const parentMatchId = inner.matches[index - 1]?.id;
+	const parentMatch = parentMatchId ? inner.router.getMatch(parentMatchId) : void 0;
+	if (inner.router.isShell()) {
+		existingMatch.ssr = route.id === rootRouteId;
+		return;
+	}
+	if (parentMatch?.ssr === false) {
+		existingMatch.ssr = false;
+		return;
+	}
+	const parentOverride = (tempSsr) => {
+		if (tempSsr === true && parentMatch?.ssr === "data-only") return "data-only";
+		return tempSsr;
+	};
+	const defaultSsr = inner.router.options.defaultSsr ?? true;
+	if (route.options.ssr === void 0) {
+		existingMatch.ssr = parentOverride(defaultSsr);
+		return;
+	}
+	if (typeof route.options.ssr !== "function") {
+		existingMatch.ssr = parentOverride(route.options.ssr);
+		return;
+	}
+	const { search, params } = existingMatch;
+	const ssrFnContext = {
+		search: makeMaybe(search, existingMatch.searchError),
+		params: makeMaybe(params, existingMatch.paramsError),
+		location: inner.location,
+		matches: inner.matches.map((match) => ({
+			index: match.index,
+			pathname: match.pathname,
+			fullPath: match.fullPath,
+			staticData: match.staticData,
+			id: match.id,
+			routeId: match.routeId,
+			search: makeMaybe(match.search, match.searchError),
+			params: makeMaybe(match.params, match.paramsError),
+			ssr: match.ssr
+		}))
+	};
+	const tempSsr = route.options.ssr(ssrFnContext);
+	if (isPromise(tempSsr)) return tempSsr.then((ssr) => {
+		existingMatch.ssr = parentOverride(ssr ?? defaultSsr);
+	});
+	existingMatch.ssr = parentOverride(tempSsr ?? defaultSsr);
+};
+var setupPendingTimeout = (inner, matchId, route, match) => {
+	if (match._nonReactive.pendingTimeout !== void 0) return;
+	route.options.pendingMs ?? inner.router.options.defaultPendingMs;
+	if (!!(inner.onReady && false));
+};
+var preBeforeLoadSetup = (inner, matchId, route) => {
+	const existingMatch = inner.router.getMatch(matchId);
+	if (!existingMatch._nonReactive.beforeLoadPromise && !existingMatch._nonReactive.loaderPromise) return;
+	setupPendingTimeout(inner, matchId, route, existingMatch);
+	const then = () => {
+		const match = inner.router.getMatch(matchId);
+		if (match.preload && (match.status === "redirected" || match.status === "notFound")) handleRedirectAndNotFound(inner, match, match.error);
+	};
+	return existingMatch._nonReactive.beforeLoadPromise ? existingMatch._nonReactive.beforeLoadPromise.then(then) : then();
+};
+var executeBeforeLoad = (inner, matchId, index, route) => {
+	const match = inner.router.getMatch(matchId);
+	let prevLoadPromise = match._nonReactive.loadPromise;
+	match._nonReactive.loadPromise = createControlledPromise(() => {
+		prevLoadPromise?.resolve();
+		prevLoadPromise = void 0;
+	});
+	const { paramsError, searchError } = match;
+	if (paramsError) handleSerialError(inner, index, paramsError, "PARSE_PARAMS");
+	if (searchError) handleSerialError(inner, index, searchError, "VALIDATE_SEARCH");
+	setupPendingTimeout(inner, matchId, route, match);
+	const abortController = new AbortController();
+	let isPending = false;
+	const pending = () => {
+		if (isPending) return;
+		isPending = true;
+		inner.updateMatch(matchId, (prev) => ({
+			...prev,
+			isFetching: "beforeLoad",
+			fetchCount: prev.fetchCount + 1,
+			abortController
+		}));
+	};
+	const resolve = () => {
+		match._nonReactive.beforeLoadPromise?.resolve();
+		match._nonReactive.beforeLoadPromise = void 0;
+		inner.updateMatch(matchId, (prev) => ({
+			...prev,
+			isFetching: false
+		}));
+	};
+	if (!route.options.beforeLoad) {
+		inner.router.batch(() => {
+			pending();
+			resolve();
+		});
+		return;
+	}
+	match._nonReactive.beforeLoadPromise = createControlledPromise();
+	const context = {
+		...buildMatchContext(inner, index, false),
+		...match.__routeContext
+	};
+	const { search, params, cause } = match;
+	const preload = resolvePreload(inner, matchId);
+	const beforeLoadFnContext = {
+		search,
+		abortController,
+		params,
+		preload,
+		context,
+		location: inner.location,
+		navigate: (opts) => inner.router.navigate({
+			...opts,
+			_fromLocation: inner.location
+		}),
+		buildLocation: inner.router.buildLocation,
+		cause: preload ? "preload" : cause,
+		matches: inner.matches,
+		routeId: route.id,
+		...inner.router.options.additionalContext
+	};
+	const updateContext = (beforeLoadContext) => {
+		if (beforeLoadContext === void 0) {
+			inner.router.batch(() => {
+				pending();
+				resolve();
+			});
+			return;
+		}
+		if (isRedirect(beforeLoadContext) || isNotFound(beforeLoadContext)) {
+			pending();
+			handleSerialError(inner, index, beforeLoadContext, "BEFORE_LOAD");
+		}
+		inner.router.batch(() => {
+			pending();
+			inner.updateMatch(matchId, (prev) => ({
+				...prev,
+				__beforeLoadContext: beforeLoadContext
+			}));
+			resolve();
+		});
+	};
+	let beforeLoadContext;
+	try {
+		beforeLoadContext = route.options.beforeLoad(beforeLoadFnContext);
+		if (isPromise(beforeLoadContext)) {
+			pending();
+			return beforeLoadContext.catch((err) => {
+				handleSerialError(inner, index, err, "BEFORE_LOAD");
+			}).then(updateContext);
+		}
+	} catch (err) {
+		pending();
+		handleSerialError(inner, index, err, "BEFORE_LOAD");
+	}
+	updateContext(beforeLoadContext);
+};
+var handleBeforeLoad = (inner, index) => {
+	const { id: matchId, routeId } = inner.matches[index];
+	const route = inner.router.looseRoutesById[routeId];
+	const serverSsr = () => {
+		{
+			const maybePromise = isBeforeLoadSsr(inner, matchId, index, route);
+			if (isPromise(maybePromise)) return maybePromise.then(queueExecution);
+		}
+		return queueExecution();
+	};
+	const execute = () => executeBeforeLoad(inner, matchId, index, route);
+	const queueExecution = () => {
+		if (shouldSkipLoader(inner, matchId)) return;
+		const result = preBeforeLoadSetup(inner, matchId, route);
+		return isPromise(result) ? result.then(execute) : execute();
+	};
+	return serverSsr();
+};
+var executeHead = (inner, matchId, route) => {
+	const match = inner.router.getMatch(matchId);
+	if (!match) return;
+	if (!route.options.head && !route.options.scripts && !route.options.headers) return;
+	const assetContext = {
+		ssr: inner.router.options.ssr,
+		matches: inner.matches,
+		match,
+		params: match.params,
+		loaderData: match.loaderData
+	};
+	return Promise.all([
+		route.options.head?.(assetContext),
+		route.options.scripts?.(assetContext),
+		route.options.headers?.(assetContext)
+	]).then(([headFnContent, scripts, headers]) => {
+		return {
+			meta: headFnContent?.meta,
+			links: headFnContent?.links,
+			headScripts: headFnContent?.scripts,
+			headers,
+			scripts,
+			styles: headFnContent?.styles
+		};
+	});
+};
+var getLoaderContext = (inner, matchPromises, matchId, index, route) => {
+	const parentMatchPromise = matchPromises[index - 1];
+	const { params, loaderDeps, abortController, cause } = inner.router.getMatch(matchId);
+	const context = buildMatchContext(inner, index);
+	const preload = resolvePreload(inner, matchId);
+	return {
+		params,
+		deps: loaderDeps,
+		preload: !!preload,
+		parentMatchPromise,
+		abortController,
+		context,
+		location: inner.location,
+		navigate: (opts) => inner.router.navigate({
+			...opts,
+			_fromLocation: inner.location
+		}),
+		cause: preload ? "preload" : cause,
+		route,
+		...inner.router.options.additionalContext
+	};
+};
+var runLoader = async (inner, matchPromises, matchId, index, route) => {
+	try {
+		const match = inner.router.getMatch(matchId);
+		try {
+			if (match.ssr === true) loadRouteChunk(route);
+			const routeLoader = route.options.loader;
+			const loader = typeof routeLoader === "function" ? routeLoader : routeLoader?.handler;
+			const loaderResult = loader?.(getLoaderContext(inner, matchPromises, matchId, index, route));
+			const loaderResultIsPromise = !!loader && isPromise(loaderResult);
+			if (!!(loaderResultIsPromise || route._lazyPromise || route._componentsPromise || route.options.head || route.options.scripts || route.options.headers || match._nonReactive.minPendingPromise)) inner.updateMatch(matchId, (prev) => ({
+				...prev,
+				isFetching: "loader"
+			}));
+			if (loader) {
+				const loaderData = loaderResultIsPromise ? await loaderResult : loaderResult;
+				handleRedirectAndNotFound(inner, inner.router.getMatch(matchId), loaderData);
+				if (loaderData !== void 0) inner.updateMatch(matchId, (prev) => ({
+					...prev,
+					loaderData
+				}));
+			}
+			if (route._lazyPromise) await route._lazyPromise;
+			const pendingPromise = match._nonReactive.minPendingPromise;
+			if (pendingPromise) await pendingPromise;
+			if (route._componentsPromise) await route._componentsPromise;
+			inner.updateMatch(matchId, (prev) => ({
+				...prev,
+				error: void 0,
+				context: buildMatchContext(inner, index),
+				status: "success",
+				isFetching: false,
+				updatedAt: Date.now()
+			}));
+		} catch (e) {
+			let error = e;
+			if (error?.name === "AbortError") {
+				if (match.abortController.signal.aborted) {
+					match._nonReactive.loaderPromise?.resolve();
+					match._nonReactive.loaderPromise = void 0;
+					return;
+				}
+				inner.updateMatch(matchId, (prev) => ({
+					...prev,
+					status: prev.status === "pending" ? "success" : prev.status,
+					isFetching: false,
+					context: buildMatchContext(inner, index)
+				}));
+				return;
+			}
+			const pendingPromise = match._nonReactive.minPendingPromise;
+			if (pendingPromise) await pendingPromise;
+			if (isNotFound(e)) await route.options.notFoundComponent?.preload?.();
+			handleRedirectAndNotFound(inner, inner.router.getMatch(matchId), e);
+			try {
+				route.options.onError?.(e);
+			} catch (onErrorError) {
+				error = onErrorError;
+				handleRedirectAndNotFound(inner, inner.router.getMatch(matchId), onErrorError);
+			}
+			if (!isRedirect(error) && !isNotFound(error)) await loadRouteChunk(route, ["errorComponent"]);
+			inner.updateMatch(matchId, (prev) => ({
+				...prev,
+				error,
+				context: buildMatchContext(inner, index),
+				status: "error",
+				isFetching: false
+			}));
+		}
+	} catch (err) {
+		const match = inner.router.getMatch(matchId);
+		if (match) match._nonReactive.loaderPromise = void 0;
+		handleRedirectAndNotFound(inner, match, err);
+	}
+};
+var loadRouteMatch = async (inner, matchPromises, index) => {
+	async function handleLoader(preload, prevMatch, previousRouteMatchId, match, route) {
+		const age = Date.now() - prevMatch.updatedAt;
+		const staleAge = preload ? route.options.preloadStaleTime ?? inner.router.options.defaultPreloadStaleTime ?? 3e4 : route.options.staleTime ?? inner.router.options.defaultStaleTime ?? 0;
+		const shouldReloadOption = route.options.shouldReload;
+		const shouldReload = typeof shouldReloadOption === "function" ? shouldReloadOption(getLoaderContext(inner, matchPromises, matchId, index, route)) : shouldReloadOption;
+		const { status, invalid } = match;
+		const staleMatchShouldReload = age >= staleAge && (!!inner.forceStaleReload || match.cause === "enter" || previousRouteMatchId !== void 0 && previousRouteMatchId !== match.id);
+		loaderShouldRunAsync = status === "success" && (invalid || (shouldReload ?? staleMatchShouldReload));
+		if (preload && route.options.preload === false) {} else if (loaderShouldRunAsync && !inner.sync && shouldReloadInBackground) {
+			loaderIsRunningAsync = true;
+			(async () => {
+				try {
+					await runLoader(inner, matchPromises, matchId, index, route);
+					const match = inner.router.getMatch(matchId);
+					match._nonReactive.loaderPromise?.resolve();
+					match._nonReactive.loadPromise?.resolve();
+					match._nonReactive.loaderPromise = void 0;
+					match._nonReactive.loadPromise = void 0;
+				} catch (err) {
+					if (isRedirect(err)) await inner.router.navigate(err.options);
+				}
+			})();
+		} else if (status !== "success" || loaderShouldRunAsync) await runLoader(inner, matchPromises, matchId, index, route);
+		else syncMatchContext(inner, matchId, index);
+	}
+	const { id: matchId, routeId } = inner.matches[index];
+	let loaderShouldRunAsync = false;
+	let loaderIsRunningAsync = false;
+	const route = inner.router.looseRoutesById[routeId];
+	const routeLoader = route.options.loader;
+	const shouldReloadInBackground = ((typeof routeLoader === "function" ? void 0 : routeLoader?.staleReloadMode) ?? inner.router.options.defaultStaleReloadMode) !== "blocking";
+	if (shouldSkipLoader(inner, matchId)) {
+		if (!inner.router.getMatch(matchId)) return inner.matches[index];
+		syncMatchContext(inner, matchId, index);
+		return inner.router.getMatch(matchId);
+	} else {
+		const prevMatch = inner.router.getMatch(matchId);
+		const activeIdAtIndex = inner.router.stores.matchesId.state[index];
+		const previousRouteMatchId = (activeIdAtIndex && inner.router.stores.activeMatchStoresById.get(activeIdAtIndex) || null)?.routeId === routeId ? activeIdAtIndex : inner.router.stores.activeMatchesSnapshot.state.find((d) => d.routeId === routeId)?.id;
+		const preload = resolvePreload(inner, matchId);
+		if (prevMatch._nonReactive.loaderPromise) {
+			if (prevMatch.status === "success" && !inner.sync && !prevMatch.preload && shouldReloadInBackground) return prevMatch;
+			await prevMatch._nonReactive.loaderPromise;
+			const match = inner.router.getMatch(matchId);
+			const error = match._nonReactive.error || match.error;
+			if (error) handleRedirectAndNotFound(inner, match, error);
+			if (match.status === "pending") await handleLoader(preload, prevMatch, previousRouteMatchId, match, route);
+		} else {
+			const nextPreload = preload && !inner.router.stores.activeMatchStoresById.has(matchId);
+			const match = inner.router.getMatch(matchId);
+			match._nonReactive.loaderPromise = createControlledPromise();
+			if (nextPreload !== match.preload) inner.updateMatch(matchId, (prev) => ({
+				...prev,
+				preload: nextPreload
+			}));
+			await handleLoader(preload, prevMatch, previousRouteMatchId, match, route);
+		}
+	}
+	const match = inner.router.getMatch(matchId);
+	if (!loaderIsRunningAsync) {
+		match._nonReactive.loaderPromise?.resolve();
+		match._nonReactive.loadPromise?.resolve();
+		match._nonReactive.loadPromise = void 0;
+	}
+	clearTimeout(match._nonReactive.pendingTimeout);
+	match._nonReactive.pendingTimeout = void 0;
+	if (!loaderIsRunningAsync) match._nonReactive.loaderPromise = void 0;
+	match._nonReactive.dehydrated = void 0;
+	const nextIsFetching = loaderIsRunningAsync ? match.isFetching : false;
+	if (nextIsFetching !== match.isFetching || match.invalid !== false) {
+		inner.updateMatch(matchId, (prev) => ({
+			...prev,
+			isFetching: nextIsFetching,
+			invalid: false
+		}));
+		return inner.router.getMatch(matchId);
+	} else return match;
+};
+async function loadMatches(arg) {
+	const inner = arg;
+	const matchPromises = [];
+	let beforeLoadNotFound;
+	for (let i = 0; i < inner.matches.length; i++) {
+		try {
+			const beforeLoad = handleBeforeLoad(inner, i);
+			if (isPromise(beforeLoad)) await beforeLoad;
+		} catch (err) {
+			if (isRedirect(err)) throw err;
+			if (isNotFound(err)) beforeLoadNotFound = err;
+			else if (!inner.preload) throw err;
+			break;
+		}
+		if (inner.serialError) break;
+	}
+	const baseMaxIndexExclusive = inner.firstBadMatchIndex ?? inner.matches.length;
+	const boundaryIndex = beforeLoadNotFound && !inner.preload ? getNotFoundBoundaryIndex(inner, beforeLoadNotFound) : void 0;
+	const maxIndexExclusive = beforeLoadNotFound && inner.preload ? 0 : boundaryIndex !== void 0 ? Math.min(boundaryIndex + 1, baseMaxIndexExclusive) : baseMaxIndexExclusive;
+	let firstNotFound;
+	let firstUnhandledRejection;
+	for (let i = 0; i < maxIndexExclusive; i++) matchPromises.push(loadRouteMatch(inner, matchPromises, i));
+	try {
+		await Promise.all(matchPromises);
+	} catch {
+		const settled = await Promise.allSettled(matchPromises);
+		for (const result of settled) {
+			if (result.status !== "rejected") continue;
+			const reason = result.reason;
+			if (isRedirect(reason)) throw reason;
+			if (isNotFound(reason)) firstNotFound ??= reason;
+			else firstUnhandledRejection ??= reason;
+		}
+		if (firstUnhandledRejection !== void 0) throw firstUnhandledRejection;
+	}
+	const notFoundToThrow = firstNotFound ?? (beforeLoadNotFound && !inner.preload ? beforeLoadNotFound : void 0);
+	let headMaxIndex = inner.serialError ? inner.firstBadMatchIndex ?? 0 : inner.matches.length - 1;
+	if (!notFoundToThrow && beforeLoadNotFound && inner.preload) return inner.matches;
+	if (notFoundToThrow) {
+		const renderedBoundaryIndex = getNotFoundBoundaryIndex(inner, notFoundToThrow);
+		if (renderedBoundaryIndex === void 0) invariant();
+		const boundaryMatch = inner.matches[renderedBoundaryIndex];
+		const boundaryRoute = inner.router.looseRoutesById[boundaryMatch.routeId];
+		const defaultNotFoundComponent = inner.router.options?.defaultNotFoundComponent;
+		if (!boundaryRoute.options.notFoundComponent && defaultNotFoundComponent) boundaryRoute.options.notFoundComponent = defaultNotFoundComponent;
+		notFoundToThrow.routeId = boundaryMatch.routeId;
+		const boundaryIsRoot = boundaryMatch.routeId === inner.router.routeTree.id;
+		inner.updateMatch(boundaryMatch.id, (prev) => ({
+			...prev,
+			...boundaryIsRoot ? {
+				status: "success",
+				globalNotFound: true,
+				error: void 0
+			} : {
+				status: "notFound",
+				error: notFoundToThrow
+			},
+			isFetching: false
+		}));
+		headMaxIndex = renderedBoundaryIndex;
+		await loadRouteChunk(boundaryRoute, ["notFoundComponent"]);
+	} else if (!inner.preload) {
+		const rootMatch = inner.matches[0];
+		if (!rootMatch.globalNotFound) {
+			if (inner.router.getMatch(rootMatch.id)?.globalNotFound) inner.updateMatch(rootMatch.id, (prev) => ({
+				...prev,
+				globalNotFound: false,
+				error: void 0
+			}));
+		}
+	}
+	if (inner.serialError && inner.firstBadMatchIndex !== void 0) {
+		const errorRoute = inner.router.looseRoutesById[inner.matches[inner.firstBadMatchIndex].routeId];
+		await loadRouteChunk(errorRoute, ["errorComponent"]);
+	}
+	for (let i = 0; i <= headMaxIndex; i++) {
+		const { id: matchId, routeId } = inner.matches[i];
+		const route = inner.router.looseRoutesById[routeId];
+		try {
+			const headResult = executeHead(inner, matchId, route);
+			if (headResult) {
+				const head = await headResult;
+				inner.updateMatch(matchId, (prev) => ({
+					...prev,
+					...head
+				}));
+			}
+		} catch (err) {
+			console.error(`Error executing head for route ${routeId}:`, err);
+		}
+	}
+	const readyPromise = triggerOnReady(inner);
+	if (isPromise(readyPromise)) await readyPromise;
+	if (notFoundToThrow) throw notFoundToThrow;
+	if (inner.serialError && !inner.preload && !inner.onReady) throw inner.serialError;
+	return inner.matches;
+}
+function preloadRouteComponents(route, componentTypesToLoad) {
+	const preloads = componentTypesToLoad.map((type) => route.options[type]?.preload?.()).filter(Boolean);
+	if (preloads.length === 0) return void 0;
+	return Promise.all(preloads);
+}
+function loadRouteChunk(route, componentTypesToLoad = componentTypes) {
+	if (!route._lazyLoaded && route._lazyPromise === void 0) if (route.lazyFn) route._lazyPromise = route.lazyFn().then((lazyRoute) => {
+		const { id: _id, ...options } = lazyRoute.options;
+		Object.assign(route.options, options);
+		route._lazyLoaded = true;
+		route._lazyPromise = void 0;
+	});
+	else route._lazyLoaded = true;
+	const runAfterLazy = () => route._componentsLoaded ? void 0 : componentTypesToLoad === componentTypes ? (() => {
+		if (route._componentsPromise === void 0) {
+			const componentsPromise = preloadRouteComponents(route, componentTypes);
+			if (componentsPromise) route._componentsPromise = componentsPromise.then(() => {
+				route._componentsLoaded = true;
+				route._componentsPromise = void 0;
+			});
+			else route._componentsLoaded = true;
+		}
+		return route._componentsPromise;
+	})() : preloadRouteComponents(route, componentTypesToLoad);
+	return route._lazyPromise ? route._lazyPromise.then(runAfterLazy) : runAfterLazy();
+}
+function makeMaybe(value, error) {
+	if (error) return {
+		status: "error",
+		error
+	};
+	return {
+		status: "success",
+		value
+	};
+}
+function routeNeedsPreload(route) {
+	for (const componentType of componentTypes) if (route.options[componentType]?.preload) return true;
+	return false;
+}
+var componentTypes = [
+	"component",
+	"errorComponent",
+	"pendingComponent",
+	"notFoundComponent"
+];
+//#endregion
+//#region ../../node_modules/.bun/@tanstack+history@1.161.6/node_modules/@tanstack/history/dist/esm/index.js
+var stateIndexKey = "__TSR_index";
+function createHistory(opts) {
+	let location = opts.getLocation();
+	const subscribers = /* @__PURE__ */ new Set();
+	const notify = (action) => {
+		location = opts.getLocation();
+		subscribers.forEach((subscriber) => subscriber({
+			location,
+			action
+		}));
+	};
+	const handleIndexChange = (action) => {
+		if (opts.notifyOnIndexChange ?? true) notify(action);
+		else location = opts.getLocation();
+	};
+	const tryNavigation = async ({ task, navigateOpts, ...actionInfo }) => {
+		if (navigateOpts?.ignoreBlocker ?? false) {
+			task();
+			return;
+		}
+		const blockers = opts.getBlockers?.() ?? [];
+		const isPushOrReplace = actionInfo.type === "PUSH" || actionInfo.type === "REPLACE";
+		if (typeof document !== "undefined" && blockers.length && isPushOrReplace) for (const blocker of blockers) {
+			const nextLocation = parseHref(actionInfo.path, actionInfo.state);
+			if (await blocker.blockerFn({
+				currentLocation: location,
+				nextLocation,
+				action: actionInfo.type
+			})) {
+				opts.onBlocked?.();
+				return;
+			}
+		}
+		task();
+	};
+	return {
+		get location() {
+			return location;
+		},
+		get length() {
+			return opts.getLength();
+		},
+		subscribers,
+		subscribe: (cb) => {
+			subscribers.add(cb);
+			return () => {
+				subscribers.delete(cb);
+			};
+		},
+		push: (path, state, navigateOpts) => {
+			const currentIndex = location.state[stateIndexKey];
+			state = assignKeyAndIndex(currentIndex + 1, state);
+			tryNavigation({
+				task: () => {
+					opts.pushState(path, state);
+					notify({ type: "PUSH" });
+				},
+				navigateOpts,
+				type: "PUSH",
+				path,
+				state
+			});
+		},
+		replace: (path, state, navigateOpts) => {
+			const currentIndex = location.state[stateIndexKey];
+			state = assignKeyAndIndex(currentIndex, state);
+			tryNavigation({
+				task: () => {
+					opts.replaceState(path, state);
+					notify({ type: "REPLACE" });
+				},
+				navigateOpts,
+				type: "REPLACE",
+				path,
+				state
+			});
+		},
+		go: (index, navigateOpts) => {
+			tryNavigation({
+				task: () => {
+					opts.go(index);
+					handleIndexChange({
+						type: "GO",
+						index
+					});
+				},
+				navigateOpts,
+				type: "GO"
+			});
+		},
+		back: (navigateOpts) => {
+			tryNavigation({
+				task: () => {
+					opts.back(navigateOpts?.ignoreBlocker ?? false);
+					handleIndexChange({ type: "BACK" });
+				},
+				navigateOpts,
+				type: "BACK"
+			});
+		},
+		forward: (navigateOpts) => {
+			tryNavigation({
+				task: () => {
+					opts.forward(navigateOpts?.ignoreBlocker ?? false);
+					handleIndexChange({ type: "FORWARD" });
+				},
+				navigateOpts,
+				type: "FORWARD"
+			});
+		},
+		canGoBack: () => location.state[stateIndexKey] !== 0,
+		createHref: (str) => opts.createHref(str),
+		block: (blocker) => {
+			if (!opts.setBlockers) return () => {};
+			const blockers = opts.getBlockers?.() ?? [];
+			opts.setBlockers([...blockers, blocker]);
+			return () => {
+				const blockers = opts.getBlockers?.() ?? [];
+				opts.setBlockers?.(blockers.filter((b) => b !== blocker));
+			};
+		},
+		flush: () => opts.flush?.(),
+		destroy: () => opts.destroy?.(),
+		notify
+	};
+}
+function assignKeyAndIndex(index, state) {
+	if (!state) state = {};
+	const key = createRandomKey();
+	return {
+		...state,
+		key,
+		__TSR_key: key,
+		[stateIndexKey]: index
+	};
+}
+/**
+* Create an in-memory history implementation.
+* Ideal for server rendering, tests, and non-DOM environments.
+* @link https://tanstack.com/router/latest/docs/framework/react/guide/history-types
+*/
+function createMemoryHistory(opts = { initialEntries: ["/"] }) {
+	const entries = opts.initialEntries;
+	let index = opts.initialIndex ? Math.min(Math.max(opts.initialIndex, 0), entries.length - 1) : entries.length - 1;
+	const states = entries.map((_entry, index) => assignKeyAndIndex(index, void 0));
+	const getLocation = () => parseHref(entries[index], states[index]);
+	let blockers = [];
+	const _getBlockers = () => blockers;
+	const _setBlockers = (newBlockers) => blockers = newBlockers;
+	return createHistory({
+		getLocation,
+		getLength: () => entries.length,
+		pushState: (path, state) => {
+			if (index < entries.length - 1) {
+				entries.splice(index + 1);
+				states.splice(index + 1);
+			}
+			states.push(state);
+			entries.push(path);
+			index = Math.max(entries.length - 1, 0);
+		},
+		replaceState: (path, state) => {
+			states[index] = state;
+			entries[index] = path;
+		},
+		back: () => {
+			index = Math.max(index - 1, 0);
+		},
+		forward: () => {
+			index = Math.min(index + 1, entries.length - 1);
+		},
+		go: (n) => {
+			index = Math.min(Math.max(index + n, 0), entries.length - 1);
+		},
+		createHref: (path) => path,
+		getBlockers: _getBlockers,
+		setBlockers: _setBlockers
+	});
+}
+/**
+* Sanitize a path to prevent open redirect vulnerabilities.
+* Removes control characters and collapses leading double slashes.
+*/
+function sanitizePath(path) {
+	let sanitized = path.replace(/[\x00-\x1f\x7f]/g, "");
+	if (sanitized.startsWith("//")) sanitized = "/" + sanitized.replace(/^\/+/, "");
+	return sanitized;
+}
+function parseHref(href, state) {
+	const sanitizedHref = sanitizePath(href);
+	const hashIndex = sanitizedHref.indexOf("#");
+	const searchIndex = sanitizedHref.indexOf("?");
+	const addedKey = createRandomKey();
+	return {
+		href: sanitizedHref,
+		pathname: sanitizedHref.substring(0, hashIndex > 0 ? searchIndex > 0 ? Math.min(hashIndex, searchIndex) : hashIndex : searchIndex > 0 ? searchIndex : sanitizedHref.length),
+		hash: hashIndex > -1 ? sanitizedHref.substring(hashIndex) : "",
+		search: searchIndex > -1 ? sanitizedHref.slice(searchIndex, hashIndex === -1 ? void 0 : hashIndex) : "",
+		state: state || {
+			[stateIndexKey]: 0,
+			key: addedKey,
+			__TSR_key: addedKey
+		}
+	};
+}
+function createRandomKey() {
+	return (Math.random() + 1).toString(36).substring(7);
+}
+//#endregion
+//#region ../../node_modules/.bun/@tanstack+router-core@1.168.3/node_modules/@tanstack/router-core/dist/esm/router.js
+/**
+* Compute whether path, href or hash changed between previous and current
+* resolved locations.
+*/
+function getLocationChangeInfo(location, resolvedLocation) {
+	const fromLocation = resolvedLocation;
+	const toLocation = location;
+	return {
+		fromLocation,
+		toLocation,
+		pathChanged: fromLocation?.pathname !== toLocation.pathname,
+		hrefChanged: fromLocation?.href !== toLocation.href,
+		hashChanged: fromLocation?.hash !== toLocation.hash
+	};
+}
+/**
+* Core, framework-agnostic router engine that powers TanStack Router.
+*
+* Provides navigation, matching, loading, preloading, caching and event APIs
+* used by framework adapters (React/Solid). Prefer framework helpers like
+* `createRouter` in app code.
+*
+* @link https://tanstack.com/router/latest/docs/framework/react/api/router/RouterType
+*/
+var RouterCore = class {
+	/**
+	* @deprecated Use the `createRouter` function instead
+	*/
+	constructor(options, getStoreConfig) {
+		this.tempLocationKey = `${Math.round(Math.random() * 1e7)}`;
+		this.resetNextScroll = true;
+		this.shouldViewTransition = void 0;
+		this.isViewTransitionTypesSupported = void 0;
+		this.subscribers = /* @__PURE__ */ new Set();
+		this.isScrollRestoring = false;
+		this.isScrollRestorationSetup = false;
+		this.startTransition = (fn) => fn();
+		this.update = (newOptions) => {
+			const prevOptions = this.options;
+			const prevBasepath = this.basepath ?? prevOptions?.basepath ?? "/";
+			const basepathWasUnset = this.basepath === void 0;
+			const prevRewriteOption = prevOptions?.rewrite;
+			this.options = {
+				...prevOptions,
+				...newOptions
+			};
+			this.isServer = this.options.isServer ?? typeof document === "undefined";
+			this.protocolAllowlist = new Set(this.options.protocolAllowlist);
+			if (this.options.pathParamsAllowedCharacters) this.pathParamsDecoder = compileDecodeCharMap(this.options.pathParamsAllowedCharacters);
+			if (!this.history || this.options.history && this.options.history !== this.history) if (!this.options.history) {} else this.history = this.options.history;
+			this.origin = this.options.origin;
+			if (!this.origin) this.origin = "http://localhost";
+			if (this.history) this.updateLatestLocation();
+			if (this.options.routeTree !== this.routeTree) {
+				this.routeTree = this.options.routeTree;
+				let processRouteTreeResult;
+				if (globalThis.__TSR_CACHE__ && globalThis.__TSR_CACHE__.routeTree === this.routeTree) {
+					const cached = globalThis.__TSR_CACHE__;
+					this.resolvePathCache = cached.resolvePathCache;
+					processRouteTreeResult = cached.processRouteTreeResult;
+				} else {
+					this.resolvePathCache = createLRUCache(1e3);
+					processRouteTreeResult = this.buildRouteTree();
+					if (globalThis.__TSR_CACHE__ === void 0) globalThis.__TSR_CACHE__ = {
+						routeTree: this.routeTree,
+						processRouteTreeResult,
+						resolvePathCache: this.resolvePathCache
+					};
+				}
+				this.setRoutes(processRouteTreeResult);
+			}
+			if (!this.stores && this.latestLocation) {
+				const config = this.getStoreConfig(this);
+				this.batch = config.batch;
+				this.stores = createRouterStores(getInitialRouterState(this.latestLocation), config);
+			}
+			let needsLocationUpdate = false;
+			const nextBasepath = this.options.basepath ?? "/";
+			const nextRewriteOption = this.options.rewrite;
+			if (basepathWasUnset || prevBasepath !== nextBasepath || prevRewriteOption !== nextRewriteOption) {
+				this.basepath = nextBasepath;
+				const rewrites = [];
+				const trimmed = trimPath(nextBasepath);
+				if (trimmed && trimmed !== "/") rewrites.push(rewriteBasepath({ basepath: nextBasepath }));
+				if (nextRewriteOption) rewrites.push(nextRewriteOption);
+				this.rewrite = rewrites.length === 0 ? void 0 : rewrites.length === 1 ? rewrites[0] : composeRewrites(rewrites);
+				if (this.history) this.updateLatestLocation();
+				needsLocationUpdate = true;
+			}
+			if (needsLocationUpdate && this.stores) this.stores.location.setState(() => this.latestLocation);
+			if (typeof window !== "undefined" && "CSS" in window && typeof window.CSS?.supports === "function") this.isViewTransitionTypesSupported = window.CSS.supports("selector(:active-view-transition-type(a)");
+		};
+		this.updateLatestLocation = () => {
+			this.latestLocation = this.parseLocation(this.history.location, this.latestLocation);
+		};
+		this.buildRouteTree = () => {
+			const result = processRouteTree(this.routeTree, this.options.caseSensitive, (route, i) => {
+				route.init({ originalIndex: i });
+			});
+			if (this.options.routeMasks) processRouteMasks(this.options.routeMasks, result.processedTree);
+			return result;
+		};
+		this.subscribe = (eventType, fn) => {
+			const listener = {
+				eventType,
+				fn
+			};
+			this.subscribers.add(listener);
+			return () => {
+				this.subscribers.delete(listener);
+			};
+		};
+		this.emit = (routerEvent) => {
+			this.subscribers.forEach((listener) => {
+				if (listener.eventType === routerEvent.type) listener.fn(routerEvent);
+			});
+		};
+		this.parseLocation = (locationToParse, previousLocation) => {
+			const parse = ({ pathname, search, hash, href, state }) => {
+				if (!this.rewrite && !/[ \x00-\x1f\x7f\u0080-\uffff]/.test(pathname)) {
+					const parsedSearch = this.options.parseSearch(search);
+					const searchStr = this.options.stringifySearch(parsedSearch);
+					return {
+						href: pathname + searchStr + hash,
+						publicHref: href,
+						pathname: decodePath(pathname).path,
+						external: false,
+						searchStr,
+						search: nullReplaceEqualDeep(previousLocation?.search, parsedSearch),
+						hash: decodePath(hash.slice(1)).path,
+						state: replaceEqualDeep(previousLocation?.state, state)
+					};
+				}
+				const fullUrl = new URL(href, this.origin);
+				const url = executeRewriteInput(this.rewrite, fullUrl);
+				const parsedSearch = this.options.parseSearch(url.search);
+				const searchStr = this.options.stringifySearch(parsedSearch);
+				url.search = searchStr;
+				return {
+					href: url.href.replace(url.origin, ""),
+					publicHref: href,
+					pathname: decodePath(url.pathname).path,
+					external: !!this.rewrite && url.origin !== this.origin,
+					searchStr,
+					search: nullReplaceEqualDeep(previousLocation?.search, parsedSearch),
+					hash: decodePath(url.hash.slice(1)).path,
+					state: replaceEqualDeep(previousLocation?.state, state)
+				};
+			};
+			const location = parse(locationToParse);
+			const { __tempLocation, __tempKey } = location.state;
+			if (__tempLocation && (!__tempKey || __tempKey === this.tempLocationKey)) {
+				const parsedTempLocation = parse(__tempLocation);
+				parsedTempLocation.state.key = location.state.key;
+				parsedTempLocation.state.__TSR_key = location.state.__TSR_key;
+				delete parsedTempLocation.state.__tempLocation;
+				return {
+					...parsedTempLocation,
+					maskedLocation: location
+				};
+			}
+			return location;
+		};
+		this.resolvePathWithBase = (from, path) => {
+			return resolvePath({
+				base: from,
+				to: cleanPath(path),
+				trailingSlash: this.options.trailingSlash,
+				cache: this.resolvePathCache
+			});
+		};
+		this.matchRoutes = (pathnameOrNext, locationSearchOrOpts, opts) => {
+			if (typeof pathnameOrNext === "string") return this.matchRoutesInternal({
+				pathname: pathnameOrNext,
+				search: locationSearchOrOpts
+			}, opts);
+			return this.matchRoutesInternal(pathnameOrNext, locationSearchOrOpts);
+		};
+		this.getMatchedRoutes = (pathname) => {
+			return getMatchedRoutes({
+				pathname,
+				routesById: this.routesById,
+				processedTree: this.processedTree
+			});
+		};
+		this.cancelMatch = (id) => {
+			const match = this.getMatch(id);
+			if (!match) return;
+			match.abortController.abort();
+			clearTimeout(match._nonReactive.pendingTimeout);
+			match._nonReactive.pendingTimeout = void 0;
+		};
+		this.cancelMatches = () => {
+			this.stores.pendingMatchesId.state.forEach((matchId) => {
+				this.cancelMatch(matchId);
+			});
+			this.stores.matchesId.state.forEach((matchId) => {
+				if (this.stores.pendingMatchStoresById.has(matchId)) return;
+				const match = this.stores.activeMatchStoresById.get(matchId)?.state;
+				if (!match) return;
+				if (match.status === "pending" || match.isFetching === "loader") this.cancelMatch(matchId);
+			});
+		};
+		this.buildLocation = (opts) => {
+			const build = (dest = {}) => {
+				const currentLocation = dest._fromLocation || this.pendingBuiltLocation || this.latestLocation;
+				const lightweightResult = this.matchRoutesLightweight(currentLocation);
+				if (dest.from && false);
+				const defaultedFromPath = dest.unsafeRelative === "path" ? currentLocation.pathname : dest.from ?? lightweightResult.fullPath;
+				const fromPath = this.resolvePathWithBase(defaultedFromPath, ".");
+				const fromSearch = lightweightResult.search;
+				const fromParams = Object.assign(Object.create(null), lightweightResult.params);
+				const nextTo = dest.to ? this.resolvePathWithBase(fromPath, `${dest.to}`) : this.resolvePathWithBase(fromPath, ".");
+				const nextParams = dest.params === false || dest.params === null ? Object.create(null) : (dest.params ?? true) === true ? fromParams : Object.assign(fromParams, functionalUpdate(dest.params, fromParams));
+				const destMatchResult = this.getMatchedRoutes(nextTo);
+				let destRoutes = destMatchResult.matchedRoutes;
+				if ((!destMatchResult.foundRoute || destMatchResult.foundRoute.path !== "/" && destMatchResult.routeParams["**"]) && this.options.notFoundRoute) destRoutes = [...destRoutes, this.options.notFoundRoute];
+				if (Object.keys(nextParams).length > 0) for (const route of destRoutes) {
+					const fn = route.options.params?.stringify ?? route.options.stringifyParams;
+					if (fn) try {
+						Object.assign(nextParams, fn(nextParams));
+					} catch {}
+				}
+				const nextPathname = opts.leaveParams ? nextTo : decodePath(interpolatePath({
+					path: nextTo,
+					params: nextParams,
+					decoder: this.pathParamsDecoder,
+					server: this.isServer
+				}).interpolatedPath).path;
+				let nextSearch = fromSearch;
+				if (opts._includeValidateSearch && this.options.search?.strict) {
+					const validatedSearch = {};
+					destRoutes.forEach((route) => {
+						if (route.options.validateSearch) try {
+							Object.assign(validatedSearch, validateSearch(route.options.validateSearch, {
+								...validatedSearch,
+								...nextSearch
+							}));
+						} catch {}
+					});
+					nextSearch = validatedSearch;
+				}
+				nextSearch = applySearchMiddleware({
+					search: nextSearch,
+					dest,
+					destRoutes,
+					_includeValidateSearch: opts._includeValidateSearch
+				});
+				nextSearch = nullReplaceEqualDeep(fromSearch, nextSearch);
+				const searchStr = this.options.stringifySearch(nextSearch);
+				const hash = dest.hash === true ? currentLocation.hash : dest.hash ? functionalUpdate(dest.hash, currentLocation.hash) : void 0;
+				const hashStr = hash ? `#${hash}` : "";
+				let nextState = dest.state === true ? currentLocation.state : dest.state ? functionalUpdate(dest.state, currentLocation.state) : {};
+				nextState = replaceEqualDeep(currentLocation.state, nextState);
+				const fullPath = `${nextPathname}${searchStr}${hashStr}`;
+				let href;
+				let publicHref;
+				let external = false;
+				if (this.rewrite) {
+					const url = new URL(fullPath, this.origin);
+					const rewrittenUrl = executeRewriteOutput(this.rewrite, url);
+					href = url.href.replace(url.origin, "");
+					if (rewrittenUrl.origin !== this.origin) {
+						publicHref = rewrittenUrl.href;
+						external = true;
+					} else publicHref = rewrittenUrl.pathname + rewrittenUrl.search + rewrittenUrl.hash;
+				} else {
+					href = encodePathLikeUrl(fullPath);
+					publicHref = href;
+				}
+				return {
+					publicHref,
+					href,
+					pathname: nextPathname,
+					search: nextSearch,
+					searchStr,
+					state: nextState,
+					hash: hash ?? "",
+					external,
+					unmaskOnReload: dest.unmaskOnReload
+				};
+			};
+			const buildWithMatches = (dest = {}, maskedDest) => {
+				const next = build(dest);
+				let maskedNext = maskedDest ? build(maskedDest) : void 0;
+				if (!maskedNext) {
+					const params = Object.create(null);
+					if (this.options.routeMasks) {
+						const match = findFlatMatch(next.pathname, this.processedTree);
+						if (match) {
+							Object.assign(params, match.rawParams);
+							const { from: _from, params: maskParams, ...maskProps } = match.route;
+							const nextParams = maskParams === false || maskParams === null ? Object.create(null) : (maskParams ?? true) === true ? params : Object.assign(params, functionalUpdate(maskParams, params));
+							maskedDest = {
+								from: opts.from,
+								...maskProps,
+								params: nextParams
+							};
+							maskedNext = build(maskedDest);
+						}
+					}
+				}
+				if (maskedNext) next.maskedLocation = maskedNext;
+				return next;
+			};
+			if (opts.mask) return buildWithMatches(opts, {
+				from: opts.from,
+				...opts.mask
+			});
+			return buildWithMatches(opts);
+		};
+		this.commitLocation = async ({ viewTransition, ignoreBlocker, ...next }) => {
+			const isSameState = () => {
+				const ignoredProps = [
+					"key",
+					"__TSR_key",
+					"__TSR_index",
+					"__hashScrollIntoViewOptions"
+				];
+				ignoredProps.forEach((prop) => {
+					next.state[prop] = this.latestLocation.state[prop];
+				});
+				const isEqual = deepEqual(next.state, this.latestLocation.state);
+				ignoredProps.forEach((prop) => {
+					delete next.state[prop];
+				});
+				return isEqual;
+			};
+			const isSameUrl = trimPathRight(this.latestLocation.href) === trimPathRight(next.href);
+			let previousCommitPromise = this.commitLocationPromise;
+			this.commitLocationPromise = createControlledPromise(() => {
+				previousCommitPromise?.resolve();
+				previousCommitPromise = void 0;
+			});
+			if (isSameUrl && isSameState()) this.load();
+			else {
+				let { maskedLocation, hashScrollIntoView, ...nextHistory } = next;
+				if (maskedLocation) {
+					nextHistory = {
+						...maskedLocation,
+						state: {
+							...maskedLocation.state,
+							__tempKey: void 0,
+							__tempLocation: {
+								...nextHistory,
+								search: nextHistory.searchStr,
+								state: {
+									...nextHistory.state,
+									__tempKey: void 0,
+									__tempLocation: void 0,
+									__TSR_key: void 0,
+									key: void 0
+								}
+							}
+						}
+					};
+					if (nextHistory.unmaskOnReload ?? this.options.unmaskOnReload ?? false) nextHistory.state.__tempKey = this.tempLocationKey;
+				}
+				nextHistory.state.__hashScrollIntoViewOptions = hashScrollIntoView ?? this.options.defaultHashScrollIntoView ?? true;
+				this.shouldViewTransition = viewTransition;
+				this.history[next.replace ? "replace" : "push"](nextHistory.publicHref, nextHistory.state, { ignoreBlocker });
+			}
+			this.resetNextScroll = next.resetScroll ?? true;
+			if (!this.history.subscribers.size) this.load();
+			return this.commitLocationPromise;
+		};
+		this.buildAndCommitLocation = ({ replace, resetScroll, hashScrollIntoView, viewTransition, ignoreBlocker, href, ...rest } = {}) => {
+			if (href) {
+				const currentIndex = this.history.location.state.__TSR_index;
+				const parsed = parseHref(href, { __TSR_index: replace ? currentIndex : currentIndex + 1 });
+				const hrefUrl = new URL(parsed.pathname, this.origin);
+				rest.to = executeRewriteInput(this.rewrite, hrefUrl).pathname;
+				rest.search = this.options.parseSearch(parsed.search);
+				rest.hash = parsed.hash.slice(1);
+			}
+			const location = this.buildLocation({
+				...rest,
+				_includeValidateSearch: true
+			});
+			this.pendingBuiltLocation = location;
+			const commitPromise = this.commitLocation({
+				...location,
+				viewTransition,
+				replace,
+				resetScroll,
+				hashScrollIntoView,
+				ignoreBlocker
+			});
+			Promise.resolve().then(() => {
+				if (this.pendingBuiltLocation === location) this.pendingBuiltLocation = void 0;
+			});
+			return commitPromise;
+		};
+		this.navigate = async ({ to, reloadDocument, href, publicHref, ...rest }) => {
+			let hrefIsUrl = false;
+			if (href) try {
+				new URL(`${href}`);
+				hrefIsUrl = true;
+			} catch {}
+			if (hrefIsUrl && !reloadDocument) reloadDocument = true;
+			if (reloadDocument) {
+				if (to !== void 0 || !href) {
+					const location = this.buildLocation({
+						to,
+						...rest
+					});
+					href = href ?? location.publicHref;
+					publicHref = publicHref ?? location.publicHref;
+				}
+				const reloadHref = !hrefIsUrl && publicHref ? publicHref : href;
+				if (isDangerousProtocol(reloadHref, this.protocolAllowlist)) return Promise.resolve();
+				if (!rest.ignoreBlocker) {
+					const blockers = this.history.getBlockers?.() ?? [];
+					for (const blocker of blockers) if (blocker?.blockerFn) {
+						if (await blocker.blockerFn({
+							currentLocation: this.latestLocation,
+							nextLocation: this.latestLocation,
+							action: "PUSH"
+						})) return Promise.resolve();
+					}
+				}
+				if (rest.replace) window.location.replace(reloadHref);
+				else window.location.href = reloadHref;
+				return Promise.resolve();
+			}
+			return this.buildAndCommitLocation({
+				...rest,
+				href,
+				to,
+				_isNavigate: true
+			});
+		};
+		this.beforeLoad = () => {
+			this.cancelMatches();
+			this.updateLatestLocation();
+			{
+				const nextLocation = this.buildLocation({
+					to: this.latestLocation.pathname,
+					search: true,
+					params: true,
+					hash: true,
+					state: true,
+					_includeValidateSearch: true
+				});
+				if (this.latestLocation.publicHref !== nextLocation.publicHref) {
+					const href = this.getParsedLocationHref(nextLocation);
+					if (nextLocation.external) throw redirect({ href });
+					else throw redirect({
+						href,
+						_builtLocation: nextLocation
+					});
+				}
+			}
+			const pendingMatches = this.matchRoutes(this.latestLocation);
+			const nextCachedMatches = this.stores.cachedMatchesSnapshot.state.filter((d) => !pendingMatches.some((e) => e.id === d.id));
+			this.batch(() => {
+				this.stores.status.setState(() => "pending");
+				this.stores.statusCode.setState(() => 200);
+				this.stores.isLoading.setState(() => true);
+				this.stores.location.setState(() => this.latestLocation);
+				this.stores.setPendingMatches(pendingMatches);
+				this.stores.setCachedMatches(nextCachedMatches);
+			});
+		};
+		this.load = async (opts) => {
+			let redirect;
+			let notFound;
+			let loadPromise;
+			const previousLocation = this.stores.resolvedLocation.state ?? this.stores.location.state;
+			loadPromise = new Promise((resolve) => {
+				this.startTransition(async () => {
+					try {
+						this.beforeLoad();
+						const next = this.latestLocation;
+						const prevLocation = this.stores.resolvedLocation.state;
+						const locationChangeInfo = getLocationChangeInfo(next, prevLocation);
+						if (!this.stores.redirect.state) this.emit({
+							type: "onBeforeNavigate",
+							...locationChangeInfo
+						});
+						this.emit({
+							type: "onBeforeLoad",
+							...locationChangeInfo
+						});
+						await loadMatches({
+							router: this,
+							sync: opts?.sync,
+							forceStaleReload: previousLocation.href === next.href,
+							matches: this.stores.pendingMatchesSnapshot.state,
+							location: next,
+							updateMatch: this.updateMatch,
+							onReady: async () => {
+								this.startTransition(() => {
+									this.startViewTransition(async () => {
+										let exitingMatches = null;
+										let hookExitingMatches = null;
+										let hookEnteringMatches = null;
+										let hookStayingMatches = null;
+										this.batch(() => {
+											const pendingMatches = this.stores.pendingMatchesSnapshot.state;
+											const mountPending = pendingMatches.length;
+											const currentMatches = this.stores.activeMatchesSnapshot.state;
+											exitingMatches = mountPending ? currentMatches.filter((match) => !this.stores.pendingMatchStoresById.has(match.id)) : null;
+											const pendingRouteIds = /* @__PURE__ */ new Set();
+											for (const s of this.stores.pendingMatchStoresById.values()) if (s.routeId) pendingRouteIds.add(s.routeId);
+											const activeRouteIds = /* @__PURE__ */ new Set();
+											for (const s of this.stores.activeMatchStoresById.values()) if (s.routeId) activeRouteIds.add(s.routeId);
+											hookExitingMatches = mountPending ? currentMatches.filter((match) => !pendingRouteIds.has(match.routeId)) : null;
+											hookEnteringMatches = mountPending ? pendingMatches.filter((match) => !activeRouteIds.has(match.routeId)) : null;
+											hookStayingMatches = mountPending ? pendingMatches.filter((match) => activeRouteIds.has(match.routeId)) : currentMatches;
+											this.stores.isLoading.setState(() => false);
+											this.stores.loadedAt.setState(() => Date.now());
+											/**
+											* When committing new matches, cache any exiting matches that are still usable.
+											* Routes that resolved with `status: 'error'` or `status: 'notFound'` are
+											* deliberately excluded from `cachedMatches` so that subsequent invalidations
+											* or reloads re-run their loaders instead of reusing the failed/not-found data.
+											*/
+											if (mountPending) {
+												this.stores.setActiveMatches(pendingMatches);
+												this.stores.setPendingMatches([]);
+												this.stores.setCachedMatches([...this.stores.cachedMatchesSnapshot.state, ...exitingMatches.filter((d) => d.status !== "error" && d.status !== "notFound" && d.status !== "redirected")]);
+												this.clearExpiredCache();
+											}
+										});
+										for (const [matches, hook] of [
+											[hookExitingMatches, "onLeave"],
+											[hookEnteringMatches, "onEnter"],
+											[hookStayingMatches, "onStay"]
+										]) {
+											if (!matches) continue;
+											for (const match of matches) this.looseRoutesById[match.routeId].options[hook]?.(match);
+										}
+									});
+								});
+							}
+						});
+					} catch (err) {
+						if (isRedirect(err)) redirect = err;
+						else if (isNotFound(err)) notFound = err;
+						const nextStatusCode = redirect ? redirect.status : notFound ? 404 : this.stores.activeMatchesSnapshot.state.some((d) => d.status === "error") ? 500 : 200;
+						this.batch(() => {
+							this.stores.statusCode.setState(() => nextStatusCode);
+							this.stores.redirect.setState(() => redirect);
+						});
+					}
+					if (this.latestLoadPromise === loadPromise) {
+						this.commitLocationPromise?.resolve();
+						this.latestLoadPromise = void 0;
+						this.commitLocationPromise = void 0;
+					}
+					resolve();
+				});
+			});
+			this.latestLoadPromise = loadPromise;
+			await loadPromise;
+			while (this.latestLoadPromise && loadPromise !== this.latestLoadPromise) await this.latestLoadPromise;
+			let newStatusCode = void 0;
+			if (this.hasNotFoundMatch()) newStatusCode = 404;
+			else if (this.stores.activeMatchesSnapshot.state.some((d) => d.status === "error")) newStatusCode = 500;
+			if (newStatusCode !== void 0) this.stores.statusCode.setState(() => newStatusCode);
+		};
+		this.startViewTransition = (fn) => {
+			const shouldViewTransition = this.shouldViewTransition ?? this.options.defaultViewTransition;
+			this.shouldViewTransition = void 0;
+			if (shouldViewTransition && typeof document !== "undefined" && "startViewTransition" in document && typeof document.startViewTransition === "function") {
+				let startViewTransitionParams;
+				if (typeof shouldViewTransition === "object" && this.isViewTransitionTypesSupported) {
+					const next = this.latestLocation;
+					const prevLocation = this.stores.resolvedLocation.state;
+					const resolvedViewTransitionTypes = typeof shouldViewTransition.types === "function" ? shouldViewTransition.types(getLocationChangeInfo(next, prevLocation)) : shouldViewTransition.types;
+					if (resolvedViewTransitionTypes === false) {
+						fn();
+						return;
+					}
+					startViewTransitionParams = {
+						update: fn,
+						types: resolvedViewTransitionTypes
+					};
+				} else startViewTransitionParams = fn;
+				document.startViewTransition(startViewTransitionParams);
+			} else fn();
+		};
+		this.updateMatch = (id, updater) => {
+			this.startTransition(() => {
+				const pendingMatch = this.stores.pendingMatchStoresById.get(id);
+				if (pendingMatch) {
+					pendingMatch.setState(updater);
+					return;
+				}
+				const activeMatch = this.stores.activeMatchStoresById.get(id);
+				if (activeMatch) {
+					activeMatch.setState(updater);
+					return;
+				}
+				const cachedMatch = this.stores.cachedMatchStoresById.get(id);
+				if (cachedMatch) {
+					const next = updater(cachedMatch.state);
+					if (next.status === "redirected") {
+						if (this.stores.cachedMatchStoresById.delete(id)) this.stores.cachedMatchesId.setState((prev) => prev.filter((matchId) => matchId !== id));
+					} else cachedMatch.setState(() => next);
+				}
+			});
+		};
+		this.getMatch = (matchId) => {
+			return this.stores.cachedMatchStoresById.get(matchId)?.state ?? this.stores.pendingMatchStoresById.get(matchId)?.state ?? this.stores.activeMatchStoresById.get(matchId)?.state;
+		};
+		this.invalidate = (opts) => {
+			const invalidate = (d) => {
+				if (opts?.filter?.(d) ?? true) return {
+					...d,
+					invalid: true,
+					...opts?.forcePending || d.status === "error" || d.status === "notFound" ? {
+						status: "pending",
+						error: void 0
+					} : void 0
+				};
+				return d;
+			};
+			this.batch(() => {
+				this.stores.setActiveMatches(this.stores.activeMatchesSnapshot.state.map(invalidate));
+				this.stores.setCachedMatches(this.stores.cachedMatchesSnapshot.state.map(invalidate));
+				this.stores.setPendingMatches(this.stores.pendingMatchesSnapshot.state.map(invalidate));
+			});
+			this.shouldViewTransition = false;
+			return this.load({ sync: opts?.sync });
+		};
+		this.getParsedLocationHref = (location) => {
+			return location.publicHref || "/";
+		};
+		this.resolveRedirect = (redirect) => {
+			const locationHeader = redirect.headers.get("Location");
+			if (!redirect.options.href || redirect.options._builtLocation) {
+				const location = redirect.options._builtLocation ?? this.buildLocation(redirect.options);
+				const href = this.getParsedLocationHref(location);
+				redirect.options.href = href;
+				redirect.headers.set("Location", href);
+			} else if (locationHeader) try {
+				const url = new URL(locationHeader);
+				if (this.origin && url.origin === this.origin) {
+					const href = url.pathname + url.search + url.hash;
+					redirect.options.href = href;
+					redirect.headers.set("Location", href);
+				}
+			} catch {}
+			if (redirect.options.href && !redirect.options._builtLocation && isDangerousProtocol(redirect.options.href, this.protocolAllowlist)) throw new Error("Redirect blocked: unsafe protocol");
+			if (!redirect.headers.get("Location")) redirect.headers.set("Location", redirect.options.href);
+			return redirect;
+		};
+		this.clearCache = (opts) => {
+			const filter = opts?.filter;
+			if (filter !== void 0) this.stores.setCachedMatches(this.stores.cachedMatchesSnapshot.state.filter((m) => !filter(m)));
+			else this.stores.setCachedMatches([]);
+		};
+		this.clearExpiredCache = () => {
+			const now = Date.now();
+			const filter = (d) => {
+				const route = this.looseRoutesById[d.routeId];
+				if (!route.options.loader) return true;
+				const gcTime = (d.preload ? route.options.preloadGcTime ?? this.options.defaultPreloadGcTime : route.options.gcTime ?? this.options.defaultGcTime) ?? 300 * 1e3;
+				if (d.status === "error") return true;
+				return now - d.updatedAt >= gcTime;
+			};
+			this.clearCache({ filter });
+		};
+		this.loadRouteChunk = loadRouteChunk;
+		this.preloadRoute = async (opts) => {
+			const next = opts._builtLocation ?? this.buildLocation(opts);
+			let matches = this.matchRoutes(next, {
+				throwOnError: true,
+				preload: true,
+				dest: opts
+			});
+			const activeMatchIds = new Set([...this.stores.matchesId.state, ...this.stores.pendingMatchesId.state]);
+			const loadedMatchIds = new Set([...activeMatchIds, ...this.stores.cachedMatchesId.state]);
+			const matchesToCache = matches.filter((match) => !loadedMatchIds.has(match.id));
+			if (matchesToCache.length) {
+				const cachedMatches = this.stores.cachedMatchesSnapshot.state;
+				this.stores.setCachedMatches([...cachedMatches, ...matchesToCache]);
+			}
+			try {
+				matches = await loadMatches({
+					router: this,
+					matches,
+					location: next,
+					preload: true,
+					updateMatch: (id, updater) => {
+						if (activeMatchIds.has(id)) matches = matches.map((d) => d.id === id ? updater(d) : d);
+						else this.updateMatch(id, updater);
+					}
+				});
+				return matches;
+			} catch (err) {
+				if (isRedirect(err)) {
+					if (err.options.reloadDocument) return;
+					return await this.preloadRoute({
+						...err.options,
+						_fromLocation: next
+					});
+				}
+				if (!isNotFound(err)) console.error(err);
+				return;
+			}
+		};
+		this.matchRoute = (location, opts) => {
+			const matchLocation = {
+				...location,
+				to: location.to ? this.resolvePathWithBase(location.from || "", location.to) : void 0,
+				params: location.params || {},
+				leaveParams: true
+			};
+			const next = this.buildLocation(matchLocation);
+			if (opts?.pending && this.stores.status.state !== "pending") return false;
+			const baseLocation = (opts?.pending === void 0 ? !this.stores.isLoading.state : opts.pending) ? this.latestLocation : this.stores.resolvedLocation.state || this.stores.location.state;
+			const match = findSingleMatch(next.pathname, opts?.caseSensitive ?? false, opts?.fuzzy ?? false, baseLocation.pathname, this.processedTree);
+			if (!match) return false;
+			if (location.params) {
+				if (!deepEqual(match.rawParams, location.params, { partial: true })) return false;
+			}
+			if (opts?.includeSearch ?? true) return deepEqual(baseLocation.search, next.search, { partial: true }) ? match.rawParams : false;
+			return match.rawParams;
+		};
+		this.hasNotFoundMatch = () => {
+			return this.stores.activeMatchesSnapshot.state.some((d) => d.status === "notFound" || d.globalNotFound);
+		};
+		this.getStoreConfig = getStoreConfig;
+		this.update({
+			defaultPreloadDelay: 50,
+			defaultPendingMs: 1e3,
+			defaultPendingMinMs: 500,
+			context: void 0,
+			...options,
+			caseSensitive: options.caseSensitive ?? false,
+			notFoundMode: options.notFoundMode ?? "fuzzy",
+			stringifySearch: options.stringifySearch ?? defaultStringifySearch,
+			parseSearch: options.parseSearch ?? defaultParseSearch,
+			protocolAllowlist: options.protocolAllowlist ?? DEFAULT_PROTOCOL_ALLOWLIST
+		});
+		if (typeof document !== "undefined") self.__TSR_ROUTER__ = this;
+	}
+	isShell() {
+		return !!this.options.isShell;
+	}
+	isPrerendering() {
+		return !!this.options.isPrerendering;
+	}
+	get state() {
+		return this.stores.__store.state;
+	}
+	setRoutes({ routesById, routesByPath, processedTree }) {
+		this.routesById = routesById;
+		this.routesByPath = routesByPath;
+		this.processedTree = processedTree;
+		const notFoundRoute = this.options.notFoundRoute;
+		if (notFoundRoute) {
+			notFoundRoute.init({ originalIndex: 99999999999 });
+			this.routesById[notFoundRoute.id] = notFoundRoute;
+		}
+	}
+	get looseRoutesById() {
+		return this.routesById;
+	}
+	getParentContext(parentMatch) {
+		return !parentMatch?.id ? this.options.context ?? void 0 : parentMatch.context ?? this.options.context ?? void 0;
+	}
+	matchRoutesInternal(next, opts) {
+		const matchedRoutesResult = this.getMatchedRoutes(next.pathname);
+		const { foundRoute, routeParams, parsedParams } = matchedRoutesResult;
+		let { matchedRoutes } = matchedRoutesResult;
+		let isGlobalNotFound = false;
+		if (foundRoute ? foundRoute.path !== "/" && routeParams["**"] : trimPathRight(next.pathname)) if (this.options.notFoundRoute) matchedRoutes = [...matchedRoutes, this.options.notFoundRoute];
+		else isGlobalNotFound = true;
+		const globalNotFoundRouteId = isGlobalNotFound ? findGlobalNotFoundRouteId(this.options.notFoundMode, matchedRoutes) : void 0;
+		const matches = new Array(matchedRoutes.length);
+		const previousActiveMatchesByRouteId = /* @__PURE__ */ new Map();
+		for (const store of this.stores.activeMatchStoresById.values()) if (store.routeId) previousActiveMatchesByRouteId.set(store.routeId, store.state);
+		for (let index = 0; index < matchedRoutes.length; index++) {
+			const route = matchedRoutes[index];
+			const parentMatch = matches[index - 1];
+			let preMatchSearch;
+			let strictMatchSearch;
+			let searchError;
+			{
+				const parentSearch = parentMatch?.search ?? next.search;
+				const parentStrictSearch = parentMatch?._strictSearch ?? void 0;
+				try {
+					const strictSearch = validateSearch(route.options.validateSearch, { ...parentSearch }) ?? void 0;
+					preMatchSearch = {
+						...parentSearch,
+						...strictSearch
+					};
+					strictMatchSearch = {
+						...parentStrictSearch,
+						...strictSearch
+					};
+					searchError = void 0;
+				} catch (err) {
+					let searchParamError = err;
+					if (!(err instanceof SearchParamError)) searchParamError = new SearchParamError(err.message, { cause: err });
+					if (opts?.throwOnError) throw searchParamError;
+					preMatchSearch = parentSearch;
+					strictMatchSearch = {};
+					searchError = searchParamError;
+				}
+			}
+			const loaderDeps = route.options.loaderDeps?.({ search: preMatchSearch }) ?? "";
+			const loaderDepsHash = loaderDeps ? JSON.stringify(loaderDeps) : "";
+			const { interpolatedPath, usedParams } = interpolatePath({
+				path: route.fullPath,
+				params: routeParams,
+				decoder: this.pathParamsDecoder,
+				server: this.isServer
+			});
+			const matchId = route.id + interpolatedPath + loaderDepsHash;
+			const existingMatch = this.getMatch(matchId);
+			const previousMatch = previousActiveMatchesByRouteId.get(route.id);
+			const strictParams = existingMatch?._strictParams ?? usedParams;
+			let paramsError = void 0;
+			if (!existingMatch) try {
+				extractStrictParams(route, usedParams, parsedParams, strictParams);
+			} catch (err) {
+				if (isNotFound(err) || isRedirect(err)) paramsError = err;
+				else paramsError = new PathParamError(err.message, { cause: err });
+				if (opts?.throwOnError) throw paramsError;
+			}
+			Object.assign(routeParams, strictParams);
+			const cause = previousMatch ? "stay" : "enter";
+			let match;
+			if (existingMatch) match = {
+				...existingMatch,
+				cause,
+				params: previousMatch?.params ?? routeParams,
+				_strictParams: strictParams,
+				search: previousMatch ? nullReplaceEqualDeep(previousMatch.search, preMatchSearch) : nullReplaceEqualDeep(existingMatch.search, preMatchSearch),
+				_strictSearch: strictMatchSearch
+			};
+			else {
+				const status = route.options.loader || route.options.beforeLoad || route.lazyFn || routeNeedsPreload(route) ? "pending" : "success";
+				match = {
+					id: matchId,
+					ssr: void 0,
+					index,
+					routeId: route.id,
+					params: previousMatch?.params ?? routeParams,
+					_strictParams: strictParams,
+					pathname: interpolatedPath,
+					updatedAt: Date.now(),
+					search: previousMatch ? nullReplaceEqualDeep(previousMatch.search, preMatchSearch) : preMatchSearch,
+					_strictSearch: strictMatchSearch,
+					searchError: void 0,
+					status,
+					isFetching: false,
+					error: void 0,
+					paramsError,
+					__routeContext: void 0,
+					_nonReactive: { loadPromise: createControlledPromise() },
+					__beforeLoadContext: void 0,
+					context: {},
+					abortController: new AbortController(),
+					fetchCount: 0,
+					cause,
+					loaderDeps: previousMatch ? replaceEqualDeep(previousMatch.loaderDeps, loaderDeps) : loaderDeps,
+					invalid: false,
+					preload: false,
+					links: void 0,
+					scripts: void 0,
+					headScripts: void 0,
+					meta: void 0,
+					staticData: route.options.staticData || {},
+					fullPath: route.fullPath
+				};
+			}
+			if (!opts?.preload) match.globalNotFound = globalNotFoundRouteId === route.id;
+			match.searchError = searchError;
+			const parentContext = this.getParentContext(parentMatch);
+			match.context = {
+				...parentContext,
+				...match.__routeContext,
+				...match.__beforeLoadContext
+			};
+			matches[index] = match;
+		}
+		for (let index = 0; index < matches.length; index++) {
+			const match = matches[index];
+			const route = this.looseRoutesById[match.routeId];
+			const existingMatch = this.getMatch(match.id);
+			const previousMatch = previousActiveMatchesByRouteId.get(match.routeId);
+			match.params = previousMatch ? nullReplaceEqualDeep(previousMatch.params, routeParams) : routeParams;
+			if (!existingMatch) {
+				const parentMatch = matches[index - 1];
+				const parentContext = this.getParentContext(parentMatch);
+				if (route.options.context) {
+					const contextFnContext = {
+						deps: match.loaderDeps,
+						params: match.params,
+						context: parentContext ?? {},
+						location: next,
+						navigate: (opts) => this.navigate({
+							...opts,
+							_fromLocation: next
+						}),
+						buildLocation: this.buildLocation,
+						cause: match.cause,
+						abortController: match.abortController,
+						preload: !!match.preload,
+						matches,
+						routeId: route.id
+					};
+					match.__routeContext = route.options.context(contextFnContext) ?? void 0;
+				}
+				match.context = {
+					...parentContext,
+					...match.__routeContext,
+					...match.__beforeLoadContext
+				};
+			}
+		}
+		return matches;
+	}
+	/**
+	* Lightweight route matching for buildLocation.
+	* Only computes fullPath, accumulated search, and params - skipping expensive
+	* operations like AbortController, ControlledPromise, loaderDeps, and full match objects.
+	*/
+	matchRoutesLightweight(location) {
+		const { matchedRoutes, routeParams, parsedParams } = this.getMatchedRoutes(location.pathname);
+		const lastRoute = last(matchedRoutes);
+		const accumulatedSearch = { ...location.search };
+		for (const route of matchedRoutes) try {
+			Object.assign(accumulatedSearch, validateSearch(route.options.validateSearch, accumulatedSearch));
+		} catch {}
+		const lastStateMatchId = last(this.stores.matchesId.state);
+		const lastStateMatch = lastStateMatchId && this.stores.activeMatchStoresById.get(lastStateMatchId)?.state;
+		const canReuseParams = lastStateMatch && lastStateMatch.routeId === lastRoute.id && lastStateMatch.pathname === location.pathname;
+		let params;
+		if (canReuseParams) params = lastStateMatch.params;
+		else {
+			const strictParams = Object.assign(Object.create(null), routeParams);
+			for (const route of matchedRoutes) try {
+				extractStrictParams(route, routeParams, parsedParams ?? {}, strictParams);
+			} catch {}
+			params = strictParams;
+		}
+		return {
+			matchedRoutes,
+			fullPath: lastRoute.fullPath,
+			search: accumulatedSearch,
+			params
+		};
+	}
+};
+/** Error thrown when search parameter validation fails. */
+var SearchParamError = class extends Error {};
+/** Error thrown when path parameter parsing/validation fails. */
+var PathParamError = class extends Error {};
+/** Create an initial RouterState from a parsed location. */
+function getInitialRouterState(location) {
+	return {
+		loadedAt: 0,
+		isLoading: false,
+		isTransitioning: false,
+		status: "idle",
+		resolvedLocation: void 0,
+		location,
+		matches: [],
+		statusCode: 200
+	};
+}
+function validateSearch(validateSearch, input) {
+	if (validateSearch == null) return {};
+	if ("~standard" in validateSearch) {
+		const result = validateSearch["~standard"].validate(input);
+		if (result instanceof Promise) throw new SearchParamError("Async validation not supported");
+		if (result.issues) throw new SearchParamError(JSON.stringify(result.issues, void 0, 2), { cause: result });
+		return result.value;
+	}
+	if ("parse" in validateSearch) return validateSearch.parse(input);
+	if (typeof validateSearch === "function") return validateSearch(input);
+	return {};
+}
+/**
+* Build the matched route chain and extract params for a pathname.
+* Falls back to the root route if no specific route is found.
+*/
+function getMatchedRoutes({ pathname, routesById, processedTree }) {
+	const routeParams = Object.create(null);
+	const trimmedPath = trimPathRight(pathname);
+	let foundRoute = void 0;
+	let parsedParams = void 0;
+	const match = findRouteMatch(trimmedPath, processedTree, true);
+	if (match) {
+		foundRoute = match.route;
+		Object.assign(routeParams, match.rawParams);
+		parsedParams = Object.assign(Object.create(null), match.parsedParams);
+	}
+	return {
+		matchedRoutes: match?.branch || [routesById["__root__"]],
+		routeParams,
+		foundRoute,
+		parsedParams
+	};
+}
+/**
+* TODO: once caches are persisted across requests on the server,
+* we can cache the built middleware chain using `last(destRoutes)` as the key
+*/
+function applySearchMiddleware({ search, dest, destRoutes, _includeValidateSearch }) {
+	return buildMiddlewareChain(destRoutes)(search, dest, _includeValidateSearch ?? false);
+}
+function buildMiddlewareChain(destRoutes) {
+	const context = {
+		dest: null,
+		_includeValidateSearch: false,
+		middlewares: []
+	};
+	for (const route of destRoutes) {
+		if ("search" in route.options) {
+			if (route.options.search?.middlewares) context.middlewares.push(...route.options.search.middlewares);
+		} else if (route.options.preSearchFilters || route.options.postSearchFilters) {
+			const legacyMiddleware = ({ search, next }) => {
+				let nextSearch = search;
+				if ("preSearchFilters" in route.options && route.options.preSearchFilters) nextSearch = route.options.preSearchFilters.reduce((prev, next) => next(prev), search);
+				const result = next(nextSearch);
+				if ("postSearchFilters" in route.options && route.options.postSearchFilters) return route.options.postSearchFilters.reduce((prev, next) => next(prev), result);
+				return result;
+			};
+			context.middlewares.push(legacyMiddleware);
+		}
+		if (route.options.validateSearch) {
+			const validate = ({ search, next }) => {
+				const result = next(search);
+				if (!context._includeValidateSearch) return result;
+				try {
+					return {
+						...result,
+						...validateSearch(route.options.validateSearch, result) ?? void 0
+					};
+				} catch {
+					return result;
+				}
+			};
+			context.middlewares.push(validate);
+		}
+	}
+	const final = ({ search }) => {
+		const dest = context.dest;
+		if (!dest.search) return {};
+		if (dest.search === true) return search;
+		return functionalUpdate(dest.search, search);
+	};
+	context.middlewares.push(final);
+	const applyNext = (index, currentSearch, middlewares) => {
+		if (index >= middlewares.length) return currentSearch;
+		const middleware = middlewares[index];
+		const next = (newSearch) => {
+			return applyNext(index + 1, newSearch, middlewares);
+		};
+		return middleware({
+			search: currentSearch,
+			next
+		});
+	};
+	return function middleware(search, dest, _includeValidateSearch) {
+		context.dest = dest;
+		context._includeValidateSearch = _includeValidateSearch;
+		return applyNext(0, search, context.middlewares);
+	};
+}
+function findGlobalNotFoundRouteId(notFoundMode, routes) {
+	if (notFoundMode !== "root") for (let i = routes.length - 1; i >= 0; i--) {
+		const route = routes[i];
+		if (route.children) return route.id;
+	}
+	return rootRouteId;
+}
+function extractStrictParams(route, referenceParams, parsedParams, accumulatedParams) {
+	const parseParams = route.options.params?.parse ?? route.options.parseParams;
+	if (parseParams) if (route.options.skipRouteOnParseError) {
+		for (const key in referenceParams) if (key in parsedParams) accumulatedParams[key] = parsedParams[key];
+	} else {
+		const result = parseParams(accumulatedParams);
+		Object.assign(accumulatedParams, result);
+	}
+}
+//#endregion
+//#region ../../node_modules/.bun/@tanstack+router-core@1.168.3/node_modules/@tanstack/router-core/dist/esm/manifest.js
+function getAssetCrossOrigin(assetCrossOrigin, kind) {
+	if (!assetCrossOrigin) return;
+	if (typeof assetCrossOrigin === "string") return assetCrossOrigin;
+	return assetCrossOrigin[kind];
+}
+function resolveManifestAssetLink(link) {
+	if (typeof link === "string") return {
+		href: link,
+		crossOrigin: void 0
+	};
+	return link;
+}
+//#endregion
+//#region ../../node_modules/.bun/@tanstack+react-router@1.168.3+bf16f8eded5e12ee/node_modules/@tanstack/react-router/dist/esm/CatchBoundary.js
+var import_react = /* @__PURE__ */ __toESM(require_react(), 1);
+var import_jsx_runtime = require_jsx_runtime();
+function CatchBoundary(props) {
+	const errorComponent = props.errorComponent ?? ErrorComponent;
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(CatchBoundaryImpl, {
+		getResetKey: props.getResetKey,
+		onCatch: props.onCatch,
+		children: ({ error, reset }) => {
+			if (error) return import_react.createElement(errorComponent, {
+				error,
+				reset
+			});
+			return props.children;
+		}
+	});
+}
+var CatchBoundaryImpl = class extends import_react.Component {
+	constructor(..._args) {
+		super(..._args);
+		this.state = { error: null };
+	}
+	static getDerivedStateFromProps(props) {
+		return { resetKey: props.getResetKey() };
+	}
+	static getDerivedStateFromError(error) {
+		return { error };
+	}
+	reset() {
+		this.setState({ error: null });
+	}
+	componentDidUpdate(prevProps, prevState) {
+		if (prevState.error && prevState.resetKey !== this.state.resetKey) this.reset();
+	}
+	componentDidCatch(error, errorInfo) {
+		if (this.props.onCatch) this.props.onCatch(error, errorInfo);
+	}
+	render() {
+		return this.props.children({
+			error: this.state.resetKey !== this.props.getResetKey() ? null : this.state.error,
+			reset: () => {
+				this.reset();
+			}
+		});
+	}
+};
+function ErrorComponent({ error }) {
+	const [show, setShow] = import_react.useState(false);
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", {
+		style: {
+			padding: ".5rem",
+			maxWidth: "100%"
+		},
+		children: [
+			/* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", {
+				style: {
+					display: "flex",
+					alignItems: "center",
+					gap: ".5rem"
+				},
+				children: [/* @__PURE__ */ (0, import_jsx_runtime.jsx)("strong", {
+					style: { fontSize: "1rem" },
+					children: "Something went wrong!"
+				}), /* @__PURE__ */ (0, import_jsx_runtime.jsx)("button", {
+					style: {
+						appearance: "none",
+						fontSize: ".6em",
+						border: "1px solid currentColor",
+						padding: ".1rem .2rem",
+						fontWeight: "bold",
+						borderRadius: ".25rem"
+					},
+					onClick: () => setShow((d) => !d),
+					children: show ? "Hide Error" : "Show Error"
+				})]
+			}),
+			/* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { style: { height: ".25rem" } }),
+			show ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("pre", {
+				style: {
+					fontSize: ".7em",
+					border: "1px solid red",
+					borderRadius: ".25rem",
+					padding: ".3rem",
+					color: "red",
+					overflow: "auto"
+				},
+				children: error.message ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)("code", { children: error.message }) : null
+			}) }) : null
+		]
+	});
+}
+//#endregion
+//#region ../../node_modules/.bun/@tanstack+store@0.9.2/node_modules/@tanstack/store/dist/esm/alien.js
+var ReactiveFlags = /* @__PURE__ */ ((ReactiveFlags2) => {
+	ReactiveFlags2[ReactiveFlags2["None"] = 0] = "None";
+	ReactiveFlags2[ReactiveFlags2["Mutable"] = 1] = "Mutable";
+	ReactiveFlags2[ReactiveFlags2["Watching"] = 2] = "Watching";
+	ReactiveFlags2[ReactiveFlags2["RecursedCheck"] = 4] = "RecursedCheck";
+	ReactiveFlags2[ReactiveFlags2["Recursed"] = 8] = "Recursed";
+	ReactiveFlags2[ReactiveFlags2["Dirty"] = 16] = "Dirty";
+	ReactiveFlags2[ReactiveFlags2["Pending"] = 32] = "Pending";
+	return ReactiveFlags2;
+})(ReactiveFlags || {});
+function createReactiveSystem({ update, notify, unwatched }) {
+	return {
+		link: link2,
+		unlink: unlink2,
+		propagate: propagate2,
+		checkDirty: checkDirty2,
+		shallowPropagate: shallowPropagate2
+	};
+	function link2(dep, sub, version) {
+		const prevDep = sub.depsTail;
+		if (prevDep !== void 0 && prevDep.dep === dep) return;
+		const nextDep = prevDep !== void 0 ? prevDep.nextDep : sub.deps;
+		if (nextDep !== void 0 && nextDep.dep === dep) {
+			nextDep.version = version;
+			sub.depsTail = nextDep;
+			return;
+		}
+		const prevSub = dep.subsTail;
+		if (prevSub !== void 0 && prevSub.version === version && prevSub.sub === sub) return;
+		const newLink = sub.depsTail = dep.subsTail = {
+			version,
+			dep,
+			sub,
+			prevDep,
+			nextDep,
+			prevSub,
+			nextSub: void 0
+		};
+		if (nextDep !== void 0) nextDep.prevDep = newLink;
+		if (prevDep !== void 0) prevDep.nextDep = newLink;
+		else sub.deps = newLink;
+		if (prevSub !== void 0) prevSub.nextSub = newLink;
+		else dep.subs = newLink;
+	}
+	function unlink2(link3, sub = link3.sub) {
+		const dep = link3.dep;
+		const prevDep = link3.prevDep;
+		const nextDep = link3.nextDep;
+		const nextSub = link3.nextSub;
+		const prevSub = link3.prevSub;
+		if (nextDep !== void 0) nextDep.prevDep = prevDep;
+		else sub.depsTail = prevDep;
+		if (prevDep !== void 0) prevDep.nextDep = nextDep;
+		else sub.deps = nextDep;
+		if (nextSub !== void 0) nextSub.prevSub = prevSub;
+		else dep.subsTail = prevSub;
+		if (prevSub !== void 0) prevSub.nextSub = nextSub;
+		else if ((dep.subs = nextSub) === void 0) unwatched(dep);
+		return nextDep;
+	}
+	function propagate2(link3) {
+		let next = link3.nextSub;
+		let stack;
+		top: do {
+			const sub = link3.sub;
+			let flags = sub.flags;
+			if (!(flags & 60)) sub.flags = flags | 32;
+			else if (!(flags & 12)) flags = 0;
+			else if (!(flags & 4)) sub.flags = flags & -9 | 32;
+			else if (!(flags & 48) && isValidLink(link3, sub)) {
+				sub.flags = flags | 40;
+				flags &= 1;
+			} else flags = 0;
+			if (flags & 2) notify(sub);
+			if (flags & 1) {
+				const subSubs = sub.subs;
+				if (subSubs !== void 0) {
+					const nextSub = (link3 = subSubs).nextSub;
+					if (nextSub !== void 0) {
+						stack = {
+							value: next,
+							prev: stack
+						};
+						next = nextSub;
+					}
+					continue;
+				}
+			}
+			if ((link3 = next) !== void 0) {
+				next = link3.nextSub;
+				continue;
+			}
+			while (stack !== void 0) {
+				link3 = stack.value;
+				stack = stack.prev;
+				if (link3 !== void 0) {
+					next = link3.nextSub;
+					continue top;
+				}
+			}
+			break;
+		} while (true);
+	}
+	function checkDirty2(link3, sub) {
+		let stack;
+		let checkDepth = 0;
+		let dirty = false;
+		top: do {
+			const dep = link3.dep;
+			const flags = dep.flags;
+			if (sub.flags & 16) dirty = true;
+			else if ((flags & 17) === 17) {
+				if (update(dep)) {
+					const subs = dep.subs;
+					if (subs.nextSub !== void 0) shallowPropagate2(subs);
+					dirty = true;
+				}
+			} else if ((flags & 33) === 33) {
+				if (link3.nextSub !== void 0 || link3.prevSub !== void 0) stack = {
+					value: link3,
+					prev: stack
+				};
+				link3 = dep.deps;
+				sub = dep;
+				++checkDepth;
+				continue;
+			}
+			if (!dirty) {
+				const nextDep = link3.nextDep;
+				if (nextDep !== void 0) {
+					link3 = nextDep;
+					continue;
+				}
+			}
+			while (checkDepth--) {
+				const firstSub = sub.subs;
+				const hasMultipleSubs = firstSub.nextSub !== void 0;
+				if (hasMultipleSubs) {
+					link3 = stack.value;
+					stack = stack.prev;
+				} else link3 = firstSub;
+				if (dirty) {
+					if (update(sub)) {
+						if (hasMultipleSubs) shallowPropagate2(firstSub);
+						sub = link3.sub;
+						continue;
+					}
+					dirty = false;
+				} else sub.flags &= -33;
+				sub = link3.sub;
+				const nextDep = link3.nextDep;
+				if (nextDep !== void 0) {
+					link3 = nextDep;
+					continue top;
+				}
+			}
+			return dirty;
+		} while (true);
+	}
+	function shallowPropagate2(link3) {
+		do {
+			const sub = link3.sub;
+			const flags = sub.flags;
+			if ((flags & 48) === 32) {
+				sub.flags = flags | 16;
+				if ((flags & 6) === 2) notify(sub);
+			}
+		} while ((link3 = link3.nextSub) !== void 0);
+	}
+	function isValidLink(checkLink, sub) {
+		let link3 = sub.depsTail;
+		while (link3 !== void 0) {
+			if (link3 === checkLink) return true;
+			link3 = link3.prevDep;
+		}
+		return false;
+	}
+}
+var batchDepth = 0;
+var notifyIndex$1 = 0;
+var queuedLength = 0;
+var queued = [];
+var { link: link$1, unlink: unlink$1, propagate: propagate$1, checkDirty: checkDirty$1, shallowPropagate: shallowPropagate$1 } = createReactiveSystem({
+	update(node) {
+		if (node.depsTail !== void 0) return updateComputed(node);
+		else return updateSignal(node);
+	},
+	notify(effect2) {
+		let insertIndex = queuedLength;
+		let firstInsertedIndex = insertIndex;
+		do {
+			queued[insertIndex++] = effect2;
+			effect2.flags &= -3;
+			effect2 = effect2.subs?.sub;
+			if (effect2 === void 0 || !(effect2.flags & 2)) break;
+		} while (true);
+		queuedLength = insertIndex;
+		while (firstInsertedIndex < --insertIndex) {
+			const left = queued[firstInsertedIndex];
+			queued[firstInsertedIndex++] = queued[insertIndex];
+			queued[insertIndex] = left;
+		}
+	},
+	unwatched(node) {
+		if (!(node.flags & 1)) effectScopeOper.call(node);
+		else if (node.depsTail !== void 0) {
+			node.depsTail = void 0;
+			node.flags = 17;
+			purgeDeps$1(node);
+		}
+	}
+});
+function getBatchDepth() {
+	return batchDepth;
+}
+function startBatch() {
+	++batchDepth;
+}
+function endBatch() {
+	if (!--batchDepth) flush$1();
+}
+function updateComputed(c) {
+	c.depsTail = void 0;
+	c.flags = 5;
+	try {
+		const oldValue = c.value;
+		return oldValue !== (c.value = c.getter(oldValue));
+	} finally {
+		c.flags &= -5;
+		purgeDeps$1(c);
+	}
+}
+function updateSignal(s) {
+	s.flags = 1;
+	return s.currentValue !== (s.currentValue = s.pendingValue);
+}
+function run(e) {
+	const flags = e.flags;
+	if (flags & 16 || flags & 32 && checkDirty$1(e.deps, e)) {
+		e.depsTail = void 0;
+		e.flags = 6;
+		try {
+			e.fn();
+		} finally {
+			e.flags &= -5;
+			purgeDeps$1(e);
+		}
+	} else e.flags = 2;
+}
+function flush$1() {
+	try {
+		while (notifyIndex$1 < queuedLength) {
+			const effect2 = queued[notifyIndex$1];
+			queued[notifyIndex$1++] = void 0;
+			run(effect2);
+		}
+	} finally {
+		while (notifyIndex$1 < queuedLength) {
+			const effect2 = queued[notifyIndex$1];
+			queued[notifyIndex$1++] = void 0;
+			effect2.flags |= 10;
+		}
+		notifyIndex$1 = 0;
+		queuedLength = 0;
+	}
+}
+function effectScopeOper() {
+	this.depsTail = void 0;
+	this.flags = 0;
+	purgeDeps$1(this);
+	const sub = this.subs;
+	if (sub !== void 0) unlink$1(sub);
+}
+function purgeDeps$1(sub) {
+	const depsTail = sub.depsTail;
+	let dep = depsTail !== void 0 ? depsTail.nextDep : sub.deps;
+	while (dep !== void 0) dep = unlink$1(dep, sub);
+}
+//#endregion
+//#region ../../node_modules/.bun/@tanstack+store@0.9.2/node_modules/@tanstack/store/dist/esm/atom.js
+function toObserver(nextHandler, errorHandler, completionHandler) {
+	const isObserver = typeof nextHandler === "object";
+	const self = isObserver ? nextHandler : void 0;
+	return {
+		next: (isObserver ? nextHandler.next : nextHandler)?.bind(self),
+		error: (isObserver ? nextHandler.error : errorHandler)?.bind(self),
+		complete: (isObserver ? nextHandler.complete : completionHandler)?.bind(self)
+	};
+}
+var queuedEffects = [];
+var cycle = 0;
+var { link, unlink, propagate, checkDirty, shallowPropagate } = createReactiveSystem({
+	update(atom) {
+		return atom._update();
+	},
+	notify(effect2) {
+		queuedEffects[queuedEffectsLength++] = effect2;
+		effect2.flags &= ~ReactiveFlags.Watching;
+	},
+	unwatched(atom) {
+		if (atom.depsTail !== void 0) {
+			atom.depsTail = void 0;
+			atom.flags = ReactiveFlags.Mutable | ReactiveFlags.Dirty;
+			purgeDeps(atom);
+		}
+	}
+});
+var notifyIndex = 0;
+var queuedEffectsLength = 0;
+var activeSub;
+function purgeDeps(sub) {
+	const depsTail = sub.depsTail;
+	let dep = depsTail !== void 0 ? depsTail.nextDep : sub.deps;
+	while (dep !== void 0) dep = unlink(dep, sub);
+}
+function flush() {
+	if (getBatchDepth() > 0) return;
+	while (notifyIndex < queuedEffectsLength) {
+		const effect2 = queuedEffects[notifyIndex];
+		queuedEffects[notifyIndex++] = void 0;
+		effect2.notify();
+	}
+	notifyIndex = 0;
+	queuedEffectsLength = 0;
+}
+function createAtom(valueOrFn, options) {
+	const isComputed = typeof valueOrFn === "function";
+	const getter = valueOrFn;
+	const atom = {
+		_snapshot: isComputed ? void 0 : valueOrFn,
+		subs: void 0,
+		subsTail: void 0,
+		deps: void 0,
+		depsTail: void 0,
+		flags: isComputed ? ReactiveFlags.None : ReactiveFlags.Mutable,
+		get() {
+			if (activeSub !== void 0) link(atom, activeSub, cycle);
+			return atom._snapshot;
+		},
+		subscribe(observerOrFn) {
+			const obs = toObserver(observerOrFn);
+			const observed = { current: false };
+			const e = effect(() => {
+				atom.get();
+				if (!observed.current) observed.current = true;
+				else obs.next?.(atom._snapshot);
+			});
+			return { unsubscribe: () => {
+				e.stop();
+			} };
+		},
+		_update(getValue) {
+			const prevSub = activeSub;
+			const compare = options?.compare ?? Object.is;
+			if (isComputed) {
+				activeSub = atom;
+				++cycle;
+				atom.depsTail = void 0;
+			} else if (getValue === void 0) return false;
+			if (isComputed) atom.flags = ReactiveFlags.Mutable | ReactiveFlags.RecursedCheck;
+			try {
+				const oldValue = atom._snapshot;
+				const newValue = typeof getValue === "function" ? getValue(oldValue) : getValue === void 0 && isComputed ? getter(oldValue) : getValue;
+				if (oldValue === void 0 || !compare(oldValue, newValue)) {
+					atom._snapshot = newValue;
+					return true;
+				}
+				return false;
+			} finally {
+				activeSub = prevSub;
+				if (isComputed) atom.flags &= ~ReactiveFlags.RecursedCheck;
+				purgeDeps(atom);
+			}
+		}
+	};
+	if (isComputed) {
+		atom.flags = ReactiveFlags.Mutable | ReactiveFlags.Dirty;
+		atom.get = function() {
+			const flags = atom.flags;
+			if (flags & ReactiveFlags.Dirty || flags & ReactiveFlags.Pending && checkDirty(atom.deps, atom)) {
+				if (atom._update()) {
+					const subs = atom.subs;
+					if (subs !== void 0) shallowPropagate(subs);
+				}
+			} else if (flags & ReactiveFlags.Pending) atom.flags = flags & ~ReactiveFlags.Pending;
+			if (activeSub !== void 0) link(atom, activeSub, cycle);
+			return atom._snapshot;
+		};
+	} else atom.set = function(valueOrFn2) {
+		if (atom._update(valueOrFn2)) {
+			const subs = atom.subs;
+			if (subs !== void 0) {
+				propagate(subs);
+				shallowPropagate(subs);
+				flush();
+			}
+		}
+	};
+	return atom;
+}
+function effect(fn) {
+	const run = () => {
+		const prevSub = activeSub;
+		activeSub = effectObj;
+		++cycle;
+		effectObj.depsTail = void 0;
+		effectObj.flags = ReactiveFlags.Watching | ReactiveFlags.RecursedCheck;
+		try {
+			return fn();
+		} finally {
+			activeSub = prevSub;
+			effectObj.flags &= ~ReactiveFlags.RecursedCheck;
+			purgeDeps(effectObj);
+		}
+	};
+	const effectObj = {
+		deps: void 0,
+		depsTail: void 0,
+		subs: void 0,
+		subsTail: void 0,
+		flags: ReactiveFlags.Watching | ReactiveFlags.RecursedCheck,
+		notify() {
+			const flags = this.flags;
+			if (flags & ReactiveFlags.Dirty || flags & ReactiveFlags.Pending && checkDirty(this.deps, this)) run();
+			else this.flags = ReactiveFlags.Watching;
+		},
+		stop() {
+			this.flags = ReactiveFlags.None;
+			this.depsTail = void 0;
+			purgeDeps(this);
+		}
+	};
+	run();
+	return effectObj;
+}
+//#endregion
+//#region ../../node_modules/.bun/@tanstack+store@0.9.2/node_modules/@tanstack/store/dist/esm/batch.js
+function batch(fn) {
+	try {
+		startBatch();
+		fn();
+	} finally {
+		endBatch();
+		flush();
+	}
+}
+//#endregion
+//#region ../../node_modules/.bun/@tanstack+react-router@1.168.3+bf16f8eded5e12ee/node_modules/@tanstack/react-router/dist/esm/not-found.js
+function CatchNotFound(props) {
+	const router = useRouter();
+	{
+		const resetKey = `not-found-${router.stores.location.state.pathname}-${router.stores.status.state}`;
+		return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(CatchBoundary, {
+			getResetKey: () => resetKey,
+			onCatch: (error, errorInfo) => {
+				if (isNotFound(error)) props.onCatch?.(error, errorInfo);
+				else throw error;
+			},
+			errorComponent: ({ error }) => {
+				if (isNotFound(error)) return props.fallback?.(error);
+				else throw error;
+			},
+			children: props.children
+		});
+	}
+	const resetKey = `not-found-${useStore(router.stores.location, (location) => location.pathname)}-${useStore(router.stores.status, (status) => status)}`;
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(CatchBoundary, {
+		getResetKey: () => resetKey,
+		onCatch: (error, errorInfo) => {
+			if (isNotFound(error)) props.onCatch?.(error, errorInfo);
+			else throw error;
+		},
+		errorComponent: ({ error }) => {
+			if (isNotFound(error)) return props.fallback?.(error);
+			else throw error;
+		},
+		children: props.children
+	});
+}
+function DefaultGlobalNotFound() {
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("p", { children: "Not Found" });
+}
+//#endregion
+//#region ../../node_modules/.bun/@tanstack+react-router@1.168.3+bf16f8eded5e12ee/node_modules/@tanstack/react-router/dist/esm/ScriptOnce.js
+/**
+* Server-only helper to emit a script tag exactly once during SSR.
+*/
+function ScriptOnce({ children }) {
+	const router = useRouter();
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("script", {
+		nonce: router.options.ssr?.nonce,
+		dangerouslySetInnerHTML: { __html: children + ";document.currentScript.remove()" }
+	});
+}
+//#endregion
+//#region ../../node_modules/.bun/@tanstack+react-router@1.168.3+bf16f8eded5e12ee/node_modules/@tanstack/react-router/dist/esm/SafeFragment.js
+function SafeFragment(props) {
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, { children: props.children });
+}
+//#endregion
+//#region ../../node_modules/.bun/@tanstack+react-router@1.168.3+bf16f8eded5e12ee/node_modules/@tanstack/react-router/dist/esm/renderRouteNotFound.js
+/**
+* Renders a not found component for a route when no matching route is found.
+*
+* @param router - The router instance containing the route configuration
+* @param route - The route that triggered the not found state
+* @param data - Additional data to pass to the not found component
+* @returns The rendered not found component or a default fallback component
+*/
+function renderRouteNotFound(router, route, data) {
+	if (!route.options.notFoundComponent) {
+		if (router.options.defaultNotFoundComponent) return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(router.options.defaultNotFoundComponent, { ...data });
+		return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(DefaultGlobalNotFound, {});
+	}
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(route.options.notFoundComponent, { ...data });
+}
+//#endregion
+//#region ../../node_modules/.bun/@tanstack+react-router@1.168.3+bf16f8eded5e12ee/node_modules/@tanstack/react-router/dist/esm/scroll-restoration.js
+function ScrollRestoration() {
+	const router = useRouter();
+	if (!router.isScrollRestoring || false) return null;
+	if (typeof router.options.scrollRestoration === "function") {
+		if (!router.options.scrollRestoration({ location: router.latestLocation })) return null;
+	}
+	const userKey = (router.options.getScrollRestorationKey || defaultGetScrollRestorationKey)(router.latestLocation);
+	const resolvedKey = userKey !== defaultGetScrollRestorationKey(router.latestLocation) ? userKey : void 0;
+	const restoreScrollOptions = {
+		storageKey,
+		shouldScrollRestoration: true
+	};
+	if (resolvedKey) restoreScrollOptions.key = resolvedKey;
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ScriptOnce, { children: `(${restoreScroll.toString()})(${escapeHtml(JSON.stringify(restoreScrollOptions))})` });
+}
+//#endregion
+//#region ../../node_modules/.bun/@tanstack+react-router@1.168.3+bf16f8eded5e12ee/node_modules/@tanstack/react-router/dist/esm/Match.js
+var Match = import_react.memo(function MatchImpl({ matchId }) {
+	const router = useRouter();
+	{
+		const match = router.stores.activeMatchStoresById.get(matchId)?.state;
+		if (!match) invariant();
+		const routeId = match.routeId;
+		const parentRouteId = router.routesById[routeId].parentRoute?.id;
+		return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(MatchView, {
+			router,
+			matchId,
+			resetKey: router.stores.loadedAt.state,
+			matchState: {
+				routeId,
+				ssr: match.ssr,
+				_displayPending: match._displayPending,
+				parentRouteId
+			}
+		});
+	}
+	const matchStore = router.stores.activeMatchStoresById.get(matchId);
+	if (!matchStore) invariant();
+	const resetKey = useStore(router.stores.loadedAt, (loadedAt) => loadedAt);
+	const match = useStore(matchStore, (value) => value);
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(MatchView, {
+		router,
+		matchId,
+		resetKey,
+		matchState: import_react.useMemo(() => {
+			const routeId = match.routeId;
+			const parentRouteId = router.routesById[routeId].parentRoute?.id;
+			return {
+				routeId,
+				ssr: match.ssr,
+				_displayPending: match._displayPending,
+				parentRouteId
+			};
+		}, [
+			match._displayPending,
+			match.routeId,
+			match.ssr,
+			router.routesById
+		])
+	});
+});
+function MatchView({ router, matchId, resetKey, matchState }) {
+	const route = router.routesById[matchState.routeId];
+	const PendingComponent = route.options.pendingComponent ?? router.options.defaultPendingComponent;
+	const pendingElement = PendingComponent ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(PendingComponent, {}) : null;
+	const routeErrorComponent = route.options.errorComponent ?? router.options.defaultErrorComponent;
+	const routeOnCatch = route.options.onCatch ?? router.options.defaultOnCatch;
+	const routeNotFoundComponent = route.isRoot ? route.options.notFoundComponent ?? router.options.notFoundRoute?.options.component : route.options.notFoundComponent;
+	const resolvedNoSsr = matchState.ssr === false || matchState.ssr === "data-only";
+	const ResolvedSuspenseBoundary = (!route.isRoot || route.options.wrapInSuspense || resolvedNoSsr) && (route.options.wrapInSuspense ?? PendingComponent ?? (route.options.errorComponent?.preload || resolvedNoSsr)) ? import_react.Suspense : SafeFragment;
+	const ResolvedCatchBoundary = routeErrorComponent ? CatchBoundary : SafeFragment;
+	const ResolvedNotFoundBoundary = routeNotFoundComponent ? CatchNotFound : SafeFragment;
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(route.isRoot ? route.options.shellComponent ?? SafeFragment : SafeFragment, { children: [/* @__PURE__ */ (0, import_jsx_runtime.jsx)(matchContext.Provider, {
+		value: matchId,
+		children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ResolvedSuspenseBoundary, {
+			fallback: pendingElement,
+			children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ResolvedCatchBoundary, {
+				getResetKey: () => resetKey,
+				errorComponent: routeErrorComponent || ErrorComponent,
+				onCatch: (error, errorInfo) => {
+					if (isNotFound(error)) throw error;
+					routeOnCatch?.(error, errorInfo);
+				},
+				children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ResolvedNotFoundBoundary, {
+					fallback: (error) => {
+						if (!routeNotFoundComponent || error.routeId && error.routeId !== matchState.routeId || !error.routeId && !route.isRoot) throw error;
+						return import_react.createElement(routeNotFoundComponent, error);
+					},
+					children: resolvedNoSsr || matchState._displayPending ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ClientOnly, {
+						fallback: pendingElement,
+						children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(MatchInner, { matchId })
+					}) : /* @__PURE__ */ (0, import_jsx_runtime.jsx)(MatchInner, { matchId })
+				})
+			})
+		})
+	}), matchState.parentRouteId === "__root__" && router.options.scrollRestoration ? /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_jsx_runtime.Fragment, { children: [/* @__PURE__ */ (0, import_jsx_runtime.jsx)(OnRendered, {}), /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ScrollRestoration, {})] }) : null] });
+}
+function OnRendered() {
+	const router = useRouter();
+	const prevLocationRef = import_react.useRef(void 0);
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("script", {
+		suppressHydrationWarning: true,
+		ref: (el) => {
+			if (el && (prevLocationRef.current === void 0 || prevLocationRef.current.href !== router.latestLocation.href)) {
+				router.emit({
+					type: "onRendered",
+					...getLocationChangeInfo(router.stores.location.state, router.stores.resolvedLocation.state)
+				});
+				prevLocationRef.current = router.latestLocation;
+			}
+		}
+	}, router.latestLocation.state.__TSR_key);
+}
+var MatchInner = import_react.memo(function MatchInnerImpl({ matchId }) {
+	const router = useRouter();
+	{
+		const match = router.stores.activeMatchStoresById.get(matchId)?.state;
+		if (!match) invariant();
+		const routeId = match.routeId;
+		const route = router.routesById[routeId];
+		const remountDeps = (router.routesById[routeId].options.remountDeps ?? router.options.defaultRemountDeps)?.({
+			routeId,
+			loaderDeps: match.loaderDeps,
+			params: match._strictParams,
+			search: match._strictSearch
+		});
+		const key = remountDeps ? JSON.stringify(remountDeps) : void 0;
+		const Comp = route.options.component ?? router.options.defaultComponent;
+		const out = Comp ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Comp, {}, key) : /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Outlet, {});
+		if (match._displayPending) throw router.getMatch(match.id)?._nonReactive.displayPendingPromise;
+		if (match._forcePending) throw router.getMatch(match.id)?._nonReactive.minPendingPromise;
+		if (match.status === "pending") throw router.getMatch(match.id)?._nonReactive.loadPromise;
+		if (match.status === "notFound") {
+			if (!isNotFound(match.error)) invariant();
+			return renderRouteNotFound(router, route, match.error);
+		}
+		if (match.status === "redirected") {
+			if (!isRedirect(match.error)) invariant();
+			throw router.getMatch(match.id)?._nonReactive.loadPromise;
+		}
+		if (match.status === "error") return /* @__PURE__ */ (0, import_jsx_runtime.jsx)((route.options.errorComponent ?? router.options.defaultErrorComponent) || ErrorComponent, {
+			error: match.error,
+			reset: void 0,
+			info: { componentStack: "" }
+		});
+		return out;
+	}
+	const matchStore = router.stores.activeMatchStoresById.get(matchId);
+	if (!matchStore) invariant();
+	const match = useStore(matchStore, (value) => value);
+	const routeId = match.routeId;
+	const route = router.routesById[routeId];
+	const key = import_react.useMemo(() => {
+		const remountDeps = (router.routesById[routeId].options.remountDeps ?? router.options.defaultRemountDeps)?.({
+			routeId,
+			loaderDeps: match.loaderDeps,
+			params: match._strictParams,
+			search: match._strictSearch
+		});
+		return remountDeps ? JSON.stringify(remountDeps) : void 0;
+	}, [
+		routeId,
+		match.loaderDeps,
+		match._strictParams,
+		match._strictSearch,
+		router.options.defaultRemountDeps,
+		router.routesById
+	]);
+	const out = import_react.useMemo(() => {
+		const Comp = route.options.component ?? router.options.defaultComponent;
+		if (Comp) return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Comp, {}, key);
+		return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Outlet, {});
+	}, [
+		key,
+		route.options.component,
+		router.options.defaultComponent
+	]);
+	if (match._displayPending) throw router.getMatch(match.id)?._nonReactive.displayPendingPromise;
+	if (match._forcePending) throw router.getMatch(match.id)?._nonReactive.minPendingPromise;
+	if (match.status === "pending") {
+		if (route.options.pendingMinMs ?? router.options.defaultPendingMinMs) {
+			const routerMatch = router.getMatch(match.id);
+			if (routerMatch && !routerMatch._nonReactive.minPendingPromise) {}
+		}
+		throw router.getMatch(match.id)?._nonReactive.loadPromise;
+	}
+	if (match.status === "notFound") {
+		if (!isNotFound(match.error)) invariant();
+		return renderRouteNotFound(router, route, match.error);
+	}
+	if (match.status === "redirected") {
+		if (!isRedirect(match.error)) invariant();
+		throw router.getMatch(match.id)?._nonReactive.loadPromise;
+	}
+	if (match.status === "error") return /* @__PURE__ */ (0, import_jsx_runtime.jsx)((route.options.errorComponent ?? router.options.defaultErrorComponent) || ErrorComponent, {
+		error: match.error,
+		reset: void 0,
+		info: { componentStack: "" }
+	});
+	return out;
+});
+/**
+* Render the next child match in the route tree. Typically used inside
+* a route component to render nested routes.
+*
+* @link https://tanstack.com/router/latest/docs/framework/react/api/router/outletComponent
+*/
+var Outlet = import_react.memo(function OutletImpl() {
+	const router = useRouter();
+	const matchId = import_react.useContext(matchContext);
+	let routeId;
+	let parentGlobalNotFound = false;
+	let childMatchId;
+	{
+		const matches = router.stores.activeMatchesSnapshot.state;
+		const parentIndex = matchId ? matches.findIndex((match) => match.id === matchId) : -1;
+		const parentMatch = parentIndex >= 0 ? matches[parentIndex] : void 0;
+		routeId = parentMatch?.routeId;
+		parentGlobalNotFound = parentMatch?.globalNotFound ?? false;
+		childMatchId = parentIndex >= 0 ? matches[parentIndex + 1]?.id : void 0;
+	}
+	const route = routeId ? router.routesById[routeId] : void 0;
+	const pendingElement = router.options.defaultPendingComponent ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(router.options.defaultPendingComponent, {}) : null;
+	if (parentGlobalNotFound) {
+		if (!route) invariant();
+		return renderRouteNotFound(router, route, void 0);
+	}
+	if (!childMatchId) return null;
+	const nextMatch = /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Match, { matchId: childMatchId });
+	if (routeId === "__root__") return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react.Suspense, {
+		fallback: pendingElement,
+		children: nextMatch
+	});
+	return nextMatch;
+});
+//#endregion
+export { handleHashScroll as _, createAtom as a, ErrorComponent as c, RouterCore as d, getLocationChangeInfo as f, executeRewriteInput as g, createNonReactiveReadonlyStore as h, batch as i, getAssetCrossOrigin as l, createNonReactiveMutableStore as m, Outlet as n, toObserver as o, createMemoryHistory as p, SafeFragment as r, CatchBoundary as s, Match as t, resolveManifestAssetLink as u };