docs-i18n 0.7.4 → 0.8.0

package/admin/dist/server/assets/routes-CMOVc2RM.js

@@ -0,0 +1,2132 @@
+import { i as __toESM } from "./chunk-CNvmzFzq.js";
+import { G as useIntersectionObserver, H as replaceEqualDeep$1, I as functionalUpdate$1, J as require_react, L as isDangerousProtocol, N as deepEqual, O as invariant, R as isModuleNotFoundError, U as reactUse, W as useForwardedRef, _ as removeTrailingSlash, a as useRouter, b as trimPathLeft, c as useHydrated, g as joinPaths, i as matchContext, l as require_jsx_runtime, m as exactPathTest, n as useStore, r as dummyMatchContext, t as require_react_dom, u as rootRouteId, x as trimPathRight } from "./react-dom-BryASgrS.js";
+import { i as redirect } from "./redirect-BHRifpCK.js";
+//#region ../../node_modules/.bun/@tanstack+router-core@1.168.2/node_modules/@tanstack/router-core/dist/esm/link.js
+var preloadWarning = "Error preloading route! ☝️";
+//#endregion
+//#region ../../node_modules/.bun/@tanstack+router-core@1.168.2/node_modules/@tanstack/router-core/dist/esm/route.js
+var BaseRoute = class {
+	get to() {
+		return this._to;
+	}
+	get id() {
+		return this._id;
+	}
+	get path() {
+		return this._path;
+	}
+	get fullPath() {
+		return this._fullPath;
+	}
+	constructor(options) {
+		this.init = (opts) => {
+			this.originalIndex = opts.originalIndex;
+			const options = this.options;
+			const isRoot = !options?.path && !options?.id;
+			this.parentRoute = this.options.getParentRoute?.();
+			if (isRoot) this._path = rootRouteId;
+			else if (!this.parentRoute) invariant();
+			let path = isRoot ? rootRouteId : options?.path;
+			if (path && path !== "/") path = trimPathLeft(path);
+			const customId = options?.id || path;
+			let id = isRoot ? rootRouteId : joinPaths([this.parentRoute.id === "__root__" ? "" : this.parentRoute.id, customId]);
+			if (path === "__root__") path = "/";
+			if (id !== "__root__") id = joinPaths(["/", id]);
+			const fullPath = id === "__root__" ? "/" : joinPaths([this.parentRoute.fullPath, path]);
+			this._path = path;
+			this._id = id;
+			this._fullPath = fullPath;
+			this._to = trimPathRight(fullPath);
+		};
+		this.addChildren = (children) => {
+			return this._addFileChildren(children);
+		};
+		this._addFileChildren = (children) => {
+			if (Array.isArray(children)) this.children = children;
+			if (typeof children === "object" && children !== null) this.children = Object.values(children);
+			return this;
+		};
+		this._addFileTypes = () => {
+			return this;
+		};
+		this.updateLoader = (options) => {
+			Object.assign(this.options, options);
+			return this;
+		};
+		this.update = (options) => {
+			Object.assign(this.options, options);
+			return this;
+		};
+		this.lazy = (lazyFn) => {
+			this.lazyFn = lazyFn;
+			return this;
+		};
+		this.redirect = (opts) => redirect({
+			from: this.fullPath,
+			...opts
+		});
+		this.options = options || {};
+		this.isRoot = !options?.getParentRoute;
+		if (options?.id && options?.path) throw new Error(`Route cannot have both an 'id' and a 'path' option.`);
+	}
+};
+var BaseRootRoute = class extends BaseRoute {
+	constructor(options) {
+		super(options);
+	}
+};
+//#endregion
+//#region ../../node_modules/.bun/@tanstack+react-router@1.168.2+bf16f8eded5e12ee/node_modules/@tanstack/react-router/dist/esm/useMatch.js
+var import_react = /* @__PURE__ */ __toESM(require_react(), 1);
+var dummyStore = {
+	state: void 0,
+	get: () => void 0,
+	subscribe: () => () => {}
+};
+/**
+* Read and select the nearest or targeted route match.
+* @link https://tanstack.com/router/latest/docs/framework/react/api/router/useMatchHook
+*/
+function useMatch(opts) {
+	const router = useRouter();
+	const nearestMatchId = import_react.useContext(opts.from ? dummyMatchContext : matchContext);
+	const key = opts.from ?? nearestMatchId;
+	const matchStore = key ? opts.from ? router.stores.getMatchStoreByRouteId(key) : router.stores.activeMatchStoresById.get(key) : void 0;
+	{
+		const match = matchStore?.state;
+		if ((opts.shouldThrow ?? true) && !match) invariant();
+		if (match === void 0) return;
+		return opts.select ? opts.select(match) : match;
+	}
+	const previousResult = import_react.useRef(void 0);
+	return useStore(matchStore ?? dummyStore, (match) => {
+		if ((opts.shouldThrow ?? true) && !match) invariant();
+		if (match === void 0) return;
+		const selected = opts.select ? opts.select(match) : match;
+		if (opts.structuralSharing ?? router.options.defaultStructuralSharing) {
+			const shared = replaceEqualDeep$1(previousResult.current, selected);
+			previousResult.current = shared;
+			return shared;
+		}
+		return selected;
+	});
+}
+//#endregion
+//#region ../../node_modules/.bun/@tanstack+react-router@1.168.2+bf16f8eded5e12ee/node_modules/@tanstack/react-router/dist/esm/useLoaderData.js
+/**
+* Read and select the current route's loader data with type‑safety.
+*
+* Options:
+* - `from`/`strict`: Choose which route's data to read and strictness
+* - `select`: Map the loader data to a derived value
+* - `structuralSharing`: Enable structural sharing for stable references
+*
+* @returns The loader data (or selected value) for the matched route.
+* @link https://tanstack.com/router/latest/docs/framework/react/api/router/useLoaderDataHook
+*/
+function useLoaderData(opts) {
+	return useMatch({
+		from: opts.from,
+		strict: opts.strict,
+		structuralSharing: opts.structuralSharing,
+		select: (s) => {
+			return opts.select ? opts.select(s.loaderData) : s.loaderData;
+		}
+	});
+}
+//#endregion
+//#region ../../node_modules/.bun/@tanstack+react-router@1.168.2+bf16f8eded5e12ee/node_modules/@tanstack/react-router/dist/esm/useLoaderDeps.js
+/**
+* Read and select the current route's loader dependencies object.
+*
+* Options:
+* - `from`: Choose which route's loader deps to read
+* - `select`: Map the deps to a derived value
+* - `structuralSharing`: Enable structural sharing for stable references
+*
+* @returns The loader deps (or selected value) for the matched route.
+* @link https://tanstack.com/router/latest/docs/framework/react/api/router/useLoaderDepsHook
+*/
+function useLoaderDeps(opts) {
+	const { select, ...rest } = opts;
+	return useMatch({
+		...rest,
+		select: (s) => {
+			return select ? select(s.loaderDeps) : s.loaderDeps;
+		}
+	});
+}
+//#endregion
+//#region ../../node_modules/.bun/@tanstack+react-router@1.168.2+bf16f8eded5e12ee/node_modules/@tanstack/react-router/dist/esm/useParams.js
+/**
+* Access the current route's path parameters with type-safety.
+*
+* Options:
+* - `from`/`strict`: Specify the matched route and whether to enforce strict typing
+* - `select`: Project the params object to a derived value for memoized renders
+* - `structuralSharing`: Enable structural sharing for stable references
+* - `shouldThrow`: Throw if the route is not found in strict contexts
+*
+* @returns The params object (or selected value) for the matched route.
+* @link https://tanstack.com/router/latest/docs/framework/react/api/router/useParamsHook
+*/
+function useParams(opts) {
+	return useMatch({
+		from: opts.from,
+		shouldThrow: opts.shouldThrow,
+		structuralSharing: opts.structuralSharing,
+		strict: opts.strict,
+		select: (match) => {
+			const params = opts.strict === false ? match.params : match._strictParams;
+			return opts.select ? opts.select(params) : params;
+		}
+	});
+}
+//#endregion
+//#region ../../node_modules/.bun/@tanstack+react-router@1.168.2+bf16f8eded5e12ee/node_modules/@tanstack/react-router/dist/esm/useSearch.js
+/**
+* Read and select the current route's search parameters with type-safety.
+*
+* Options:
+* - `from`/`strict`: Control which route's search is read and how strictly it's typed
+* - `select`: Map the search object to a derived value for render optimization
+* - `structuralSharing`: Enable structural sharing for stable references
+* - `shouldThrow`: Throw when the route is not found (strict contexts)
+*
+* @returns The search object (or selected value) for the matched route.
+* @link https://tanstack.com/router/latest/docs/framework/react/api/router/useSearchHook
+*/
+function useSearch(opts) {
+	return useMatch({
+		from: opts.from,
+		strict: opts.strict,
+		shouldThrow: opts.shouldThrow,
+		structuralSharing: opts.structuralSharing,
+		select: (match) => {
+			return opts.select ? opts.select(match.search) : match.search;
+		}
+	});
+}
+//#endregion
+//#region ../../node_modules/.bun/@tanstack+react-router@1.168.2+bf16f8eded5e12ee/node_modules/@tanstack/react-router/dist/esm/useNavigate.js
+/**
+* Imperative navigation hook.
+*
+* Returns a stable `navigate(options)` function to change the current location
+* programmatically. Prefer the `Link` component for user-initiated navigation,
+* and use this hook from effects, callbacks, or handlers where imperative
+* navigation is required.
+*
+* Options:
+* - `from`: Optional route base used to resolve relative `to` paths.
+*
+* @returns A function that accepts `NavigateOptions`.
+* @link https://tanstack.com/router/latest/docs/framework/react/api/router/useNavigateHook
+*/
+function useNavigate(_defaultOpts) {
+	const router = useRouter();
+	return import_react.useCallback((options) => {
+		return router.navigate({
+			...options,
+			from: options.from ?? _defaultOpts?.from
+		});
+	}, [_defaultOpts?.from, router]);
+}
+//#endregion
+//#region ../../node_modules/.bun/@tanstack+react-router@1.168.2+bf16f8eded5e12ee/node_modules/@tanstack/react-router/dist/esm/useRouteContext.js
+function useRouteContext(opts) {
+	return useMatch({
+		...opts,
+		select: (match) => opts.select ? opts.select(match.context) : match.context
+	});
+}
+//#endregion
+//#region ../../node_modules/.bun/@tanstack+react-router@1.168.2+bf16f8eded5e12ee/node_modules/@tanstack/react-router/dist/esm/link.js
+var import_jsx_runtime = require_jsx_runtime();
+var import_react_dom = require_react_dom();
+/**
+* Build anchor-like props for declarative navigation and preloading.
+*
+* Returns stable `href`, event handlers and accessibility props derived from
+* router options and active state. Used internally by `Link` and custom links.
+*
+* Options cover `to`, `params`, `search`, `hash`, `state`, `preload`,
+* `activeProps`, `inactiveProps`, and more.
+*
+* @returns React anchor props suitable for `<a>` or custom components.
+* @link https://tanstack.com/router/latest/docs/framework/react/api/router/useLinkPropsHook
+*/
+function useLinkProps(options, forwardedRef) {
+	const router = useRouter();
+	const innerRef = useForwardedRef(forwardedRef);
+	const { activeProps, inactiveProps, activeOptions, to, preload: userPreload, preloadDelay: userPreloadDelay, hashScrollIntoView, replace, startTransition, resetScroll, viewTransition, children, target, disabled, style, className, onClick, onBlur, onFocus, onMouseEnter, onMouseLeave, onTouchStart, ignoreBlocker, params: _params, search: _search, hash: _hash, state: _state, mask: _mask, reloadDocument: _reloadDocument, unsafeRelative: _unsafeRelative, from: _from, _fromLocation, ...propsSafeToSpread } = options;
+	{
+		const safeInternal = isSafeInternal(to);
+		if (typeof to === "string" && !safeInternal && to.indexOf(":") > -1) try {
+			new URL(to);
+			if (isDangerousProtocol(to, router.protocolAllowlist)) return {
+				...propsSafeToSpread,
+				ref: innerRef,
+				href: void 0,
+				...children && { children },
+				...target && { target },
+				...disabled && { disabled },
+				...style && { style },
+				...className && { className }
+			};
+			return {
+				...propsSafeToSpread,
+				ref: innerRef,
+				href: to,
+				...children && { children },
+				...target && { target },
+				...disabled && { disabled },
+				...style && { style },
+				...className && { className }
+			};
+		} catch {}
+		const next = router.buildLocation({
+			...options,
+			from: options.from
+		});
+		const hrefOption = getHrefOption(next.maskedLocation ? next.maskedLocation.publicHref : next.publicHref, next.maskedLocation ? next.maskedLocation.external : next.external, router.history, disabled);
+		const externalLink = (() => {
+			if (hrefOption?.external) {
+				if (isDangerousProtocol(hrefOption.href, router.protocolAllowlist)) return;
+				return hrefOption.href;
+			}
+			if (safeInternal) return void 0;
+			if (typeof to === "string" && to.indexOf(":") > -1) try {
+				new URL(to);
+				if (isDangerousProtocol(to, router.protocolAllowlist)) return;
+				return to;
+			} catch {}
+		})();
+		const isActive = (() => {
+			if (externalLink) return false;
+			const currentLocation = router.stores.location.state;
+			const exact = activeOptions?.exact ?? false;
+			if (exact) {
+				if (!exactPathTest(currentLocation.pathname, next.pathname, router.basepath)) return false;
+			} else {
+				const currentPathSplit = removeTrailingSlash(currentLocation.pathname, router.basepath);
+				const nextPathSplit = removeTrailingSlash(next.pathname, router.basepath);
+				if (!(currentPathSplit.startsWith(nextPathSplit) && (currentPathSplit.length === nextPathSplit.length || currentPathSplit[nextPathSplit.length] === "/"))) return false;
+			}
+			if (activeOptions?.includeSearch ?? true) {
+				if (currentLocation.search !== next.search) {
+					const currentSearchEmpty = !currentLocation.search || typeof currentLocation.search === "object" && Object.keys(currentLocation.search).length === 0;
+					const nextSearchEmpty = !next.search || typeof next.search === "object" && Object.keys(next.search).length === 0;
+					if (!(currentSearchEmpty && nextSearchEmpty)) {
+						if (!deepEqual(currentLocation.search, next.search, {
+							partial: !exact,
+							ignoreUndefined: !activeOptions?.explicitUndefined
+						})) return false;
+					}
+				}
+			}
+			if (activeOptions?.includeHash) return false;
+			return true;
+		})();
+		if (externalLink) return {
+			...propsSafeToSpread,
+			ref: innerRef,
+			href: externalLink,
+			...children && { children },
+			...target && { target },
+			...disabled && { disabled },
+			...style && { style },
+			...className && { className }
+		};
+		const resolvedActiveProps = isActive ? functionalUpdate$1(activeProps, {}) ?? STATIC_ACTIVE_OBJECT : STATIC_EMPTY_OBJECT;
+		const resolvedInactiveProps = isActive ? STATIC_EMPTY_OBJECT : functionalUpdate$1(inactiveProps, {}) ?? STATIC_EMPTY_OBJECT;
+		const resolvedStyle = (() => {
+			const baseStyle = style;
+			const activeStyle = resolvedActiveProps.style;
+			const inactiveStyle = resolvedInactiveProps.style;
+			if (!baseStyle && !activeStyle && !inactiveStyle) return;
+			if (baseStyle && !activeStyle && !inactiveStyle) return baseStyle;
+			if (!baseStyle && activeStyle && !inactiveStyle) return activeStyle;
+			if (!baseStyle && !activeStyle && inactiveStyle) return inactiveStyle;
+			return {
+				...baseStyle,
+				...activeStyle,
+				...inactiveStyle
+			};
+		})();
+		const resolvedClassName = (() => {
+			const baseClassName = className;
+			const activeClassName = resolvedActiveProps.className;
+			const inactiveClassName = resolvedInactiveProps.className;
+			if (!baseClassName && !activeClassName && !inactiveClassName) return "";
+			let out = "";
+			if (baseClassName) out = baseClassName;
+			if (activeClassName) out = out ? `${out} ${activeClassName}` : activeClassName;
+			if (inactiveClassName) out = out ? `${out} ${inactiveClassName}` : inactiveClassName;
+			return out;
+		})();
+		return {
+			...propsSafeToSpread,
+			...resolvedActiveProps,
+			...resolvedInactiveProps,
+			href: hrefOption?.href,
+			ref: innerRef,
+			disabled: !!disabled,
+			target,
+			...resolvedStyle && { style: resolvedStyle },
+			...resolvedClassName && { className: resolvedClassName },
+			...disabled && STATIC_DISABLED_PROPS,
+			...isActive && STATIC_ACTIVE_PROPS
+		};
+	}
+	const isHydrated = useHydrated();
+	const _options = import_react.useMemo(() => options, [
+		router,
+		options.from,
+		options._fromLocation,
+		options.hash,
+		options.to,
+		options.search,
+		options.params,
+		options.state,
+		options.mask,
+		options.unsafeRelative
+	]);
+	const currentLocation = useStore(router.stores.location, (l) => l, (prev, next) => prev.href === next.href);
+	const next = import_react.useMemo(() => {
+		const opts = {
+			_fromLocation: currentLocation,
+			..._options
+		};
+		return router.buildLocation(opts);
+	}, [
+		router,
+		currentLocation,
+		_options
+	]);
+	const hrefOptionPublicHref = next.maskedLocation ? next.maskedLocation.publicHref : next.publicHref;
+	const hrefOptionExternal = next.maskedLocation ? next.maskedLocation.external : next.external;
+	const hrefOption = import_react.useMemo(() => getHrefOption(hrefOptionPublicHref, hrefOptionExternal, router.history, disabled), [
+		disabled,
+		hrefOptionExternal,
+		hrefOptionPublicHref,
+		router.history
+	]);
+	const externalLink = import_react.useMemo(() => {
+		if (hrefOption?.external) {
+			if (isDangerousProtocol(hrefOption.href, router.protocolAllowlist)) return;
+			return hrefOption.href;
+		}
+		if (isSafeInternal(to)) return void 0;
+		if (typeof to !== "string" || to.indexOf(":") === -1) return void 0;
+		try {
+			new URL(to);
+			if (isDangerousProtocol(to, router.protocolAllowlist)) return;
+			return to;
+		} catch {}
+	}, [
+		to,
+		hrefOption,
+		router.protocolAllowlist
+	]);
+	const isActive = import_react.useMemo(() => {
+		if (externalLink) return false;
+		if (activeOptions?.exact) {
+			if (!exactPathTest(currentLocation.pathname, next.pathname, router.basepath)) return false;
+		} else {
+			const currentPathSplit = removeTrailingSlash(currentLocation.pathname, router.basepath);
+			const nextPathSplit = removeTrailingSlash(next.pathname, router.basepath);
+			if (!(currentPathSplit.startsWith(nextPathSplit) && (currentPathSplit.length === nextPathSplit.length || currentPathSplit[nextPathSplit.length] === "/"))) return false;
+		}
+		if (activeOptions?.includeSearch ?? true) {
+			if (!deepEqual(currentLocation.search, next.search, {
+				partial: !activeOptions?.exact,
+				ignoreUndefined: !activeOptions?.explicitUndefined
+			})) return false;
+		}
+		if (activeOptions?.includeHash) return isHydrated && currentLocation.hash === next.hash;
+		return true;
+	}, [
+		activeOptions?.exact,
+		activeOptions?.explicitUndefined,
+		activeOptions?.includeHash,
+		activeOptions?.includeSearch,
+		currentLocation,
+		externalLink,
+		isHydrated,
+		next.hash,
+		next.pathname,
+		next.search,
+		router.basepath
+	]);
+	const resolvedActiveProps = isActive ? functionalUpdate$1(activeProps, {}) ?? STATIC_ACTIVE_OBJECT : STATIC_EMPTY_OBJECT;
+	const resolvedInactiveProps = isActive ? STATIC_EMPTY_OBJECT : functionalUpdate$1(inactiveProps, {}) ?? STATIC_EMPTY_OBJECT;
+	const resolvedClassName = [
+		className,
+		resolvedActiveProps.className,
+		resolvedInactiveProps.className
+	].filter(Boolean).join(" ");
+	const resolvedStyle = (style || resolvedActiveProps.style || resolvedInactiveProps.style) && {
+		...style,
+		...resolvedActiveProps.style,
+		...resolvedInactiveProps.style
+	};
+	const [isTransitioning, setIsTransitioning] = import_react.useState(false);
+	const hasRenderFetched = import_react.useRef(false);
+	const preload = options.reloadDocument || externalLink ? false : userPreload ?? router.options.defaultPreload;
+	const preloadDelay = userPreloadDelay ?? router.options.defaultPreloadDelay ?? 0;
+	const doPreload = import_react.useCallback(() => {
+		router.preloadRoute({
+			..._options,
+			_builtLocation: next
+		}).catch((err) => {
+			console.warn(err);
+			console.warn(preloadWarning);
+		});
+	}, [
+		router,
+		_options,
+		next
+	]);
+	useIntersectionObserver(innerRef, import_react.useCallback((entry) => {
+		if (entry?.isIntersecting) doPreload();
+	}, [doPreload]), intersectionObserverOptions, { disabled: !!disabled || !(preload === "viewport") });
+	import_react.useEffect(() => {
+		if (hasRenderFetched.current) return;
+		if (!disabled && preload === "render") {
+			doPreload();
+			hasRenderFetched.current = true;
+		}
+	}, [
+		disabled,
+		doPreload,
+		preload
+	]);
+	const handleClick = (e) => {
+		const elementTarget = e.currentTarget.getAttribute("target");
+		const effectiveTarget = target !== void 0 ? target : elementTarget;
+		if (!disabled && !isCtrlEvent(e) && !e.defaultPrevented && (!effectiveTarget || effectiveTarget === "_self") && e.button === 0) {
+			e.preventDefault();
+			(0, import_react_dom.flushSync)(() => {
+				setIsTransitioning(true);
+			});
+			const unsub = router.subscribe("onResolved", () => {
+				unsub();
+				setIsTransitioning(false);
+			});
+			router.navigate({
+				..._options,
+				replace,
+				resetScroll,
+				hashScrollIntoView,
+				startTransition,
+				viewTransition,
+				ignoreBlocker
+			});
+		}
+	};
+	if (externalLink) return {
+		...propsSafeToSpread,
+		ref: innerRef,
+		href: externalLink,
+		...children && { children },
+		...target && { target },
+		...disabled && { disabled },
+		...style && { style },
+		...className && { className },
+		...onClick && { onClick },
+		...onBlur && { onBlur },
+		...onFocus && { onFocus },
+		...onMouseEnter && { onMouseEnter },
+		...onMouseLeave && { onMouseLeave },
+		...onTouchStart && { onTouchStart }
+	};
+	const enqueueIntentPreload = (e) => {
+		if (disabled || preload !== "intent") return;
+		if (!preloadDelay) {
+			doPreload();
+			return;
+		}
+		const eventTarget = e.currentTarget;
+		if (timeoutMap.has(eventTarget)) return;
+		const id = setTimeout(() => {
+			timeoutMap.delete(eventTarget);
+			doPreload();
+		}, preloadDelay);
+		timeoutMap.set(eventTarget, id);
+	};
+	const handleTouchStart = (_) => {
+		if (disabled || preload !== "intent") return;
+		doPreload();
+	};
+	const handleLeave = (e) => {
+		if (disabled || !preload || !preloadDelay) return;
+		const eventTarget = e.currentTarget;
+		const id = timeoutMap.get(eventTarget);
+		if (id) {
+			clearTimeout(id);
+			timeoutMap.delete(eventTarget);
+		}
+	};
+	return {
+		...propsSafeToSpread,
+		...resolvedActiveProps,
+		...resolvedInactiveProps,
+		href: hrefOption?.href,
+		ref: innerRef,
+		onClick: composeHandlers([onClick, handleClick]),
+		onBlur: composeHandlers([onBlur, handleLeave]),
+		onFocus: composeHandlers([onFocus, enqueueIntentPreload]),
+		onMouseEnter: composeHandlers([onMouseEnter, enqueueIntentPreload]),
+		onMouseLeave: composeHandlers([onMouseLeave, handleLeave]),
+		onTouchStart: composeHandlers([onTouchStart, handleTouchStart]),
+		disabled: !!disabled,
+		target,
+		...resolvedStyle && { style: resolvedStyle },
+		...resolvedClassName && { className: resolvedClassName },
+		...disabled && STATIC_DISABLED_PROPS,
+		...isActive && STATIC_ACTIVE_PROPS,
+		...isHydrated && isTransitioning && STATIC_TRANSITIONING_PROPS
+	};
+}
+var STATIC_EMPTY_OBJECT = {};
+var STATIC_ACTIVE_OBJECT = { className: "active" };
+var STATIC_DISABLED_PROPS = {
+	role: "link",
+	"aria-disabled": true
+};
+var STATIC_ACTIVE_PROPS = {
+	"data-status": "active",
+	"aria-current": "page"
+};
+var STATIC_TRANSITIONING_PROPS = { "data-transitioning": "transitioning" };
+var timeoutMap = /* @__PURE__ */ new WeakMap();
+var intersectionObserverOptions = { rootMargin: "100px" };
+var composeHandlers = (handlers) => (e) => {
+	for (const handler of handlers) {
+		if (!handler) continue;
+		if (e.defaultPrevented) return;
+		handler(e);
+	}
+};
+function getHrefOption(publicHref, external, history, disabled) {
+	if (disabled) return void 0;
+	if (external) return {
+		href: publicHref,
+		external: true
+	};
+	return {
+		href: history.createHref(publicHref) || "/",
+		external: false
+	};
+}
+function isSafeInternal(to) {
+	if (typeof to !== "string") return false;
+	const zero = to.charCodeAt(0);
+	if (zero === 47) return to.charCodeAt(1) !== 47;
+	return zero === 46;
+}
+/**
+* A strongly-typed anchor component for declarative navigation.
+* Handles path, search, hash and state updates with optional route preloading
+* and active-state styling.
+*
+* Props:
+* - `preload`: Controls route preloading (eg. 'intent', 'render', 'viewport', true/false)
+* - `preloadDelay`: Delay in ms before preloading on hover
+* - `activeProps`/`inactiveProps`: Additional props merged when link is active/inactive
+* - `resetScroll`/`hashScrollIntoView`: Control scroll behavior on navigation
+* - `viewTransition`/`startTransition`: Use View Transitions/React transitions for navigation
+* - `ignoreBlocker`: Bypass registered blockers
+*
+* @returns An anchor-like element that navigates without full page reloads.
+* @link https://tanstack.com/router/latest/docs/framework/react/api/router/linkComponent
+*/
+var Link = import_react.forwardRef((props, ref) => {
+	const { _asChild, ...rest } = props;
+	const { type: _type, ...linkProps } = useLinkProps(rest, ref);
+	const children = typeof rest.children === "function" ? rest.children({ isActive: linkProps["data-status"] === "active" }) : rest.children;
+	if (!_asChild) {
+		const { disabled: _, ...rest } = linkProps;
+		return import_react.createElement("a", rest, children);
+	}
+	return import_react.createElement(_asChild, linkProps, children);
+});
+function isCtrlEvent(e) {
+	return !!(e.metaKey || e.altKey || e.ctrlKey || e.shiftKey);
+}
+//#endregion
+//#region ../../node_modules/.bun/@tanstack+react-router@1.168.2+bf16f8eded5e12ee/node_modules/@tanstack/react-router/dist/esm/route.js
+var Route$1 = class extends BaseRoute {
+	/**
+	* @deprecated Use the `createRoute` function instead.
+	*/
+	constructor(options) {
+		super(options);
+		this.useMatch = (opts) => {
+			return useMatch({
+				select: opts?.select,
+				from: this.id,
+				structuralSharing: opts?.structuralSharing
+			});
+		};
+		this.useRouteContext = (opts) => {
+			return useRouteContext({
+				...opts,
+				from: this.id
+			});
+		};
+		this.useSearch = (opts) => {
+			return useSearch({
+				select: opts?.select,
+				structuralSharing: opts?.structuralSharing,
+				from: this.id
+			});
+		};
+		this.useParams = (opts) => {
+			return useParams({
+				select: opts?.select,
+				structuralSharing: opts?.structuralSharing,
+				from: this.id
+			});
+		};
+		this.useLoaderDeps = (opts) => {
+			return useLoaderDeps({
+				...opts,
+				from: this.id
+			});
+		};
+		this.useLoaderData = (opts) => {
+			return useLoaderData({
+				...opts,
+				from: this.id
+			});
+		};
+		this.useNavigate = () => {
+			return useNavigate({ from: this.fullPath });
+		};
+		this.Link = import_react.forwardRef((props, ref) => {
+			return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Link, {
+				ref,
+				from: this.fullPath,
+				...props
+			});
+		});
+	}
+};
+/**
+* Creates a non-root Route instance for code-based routing.
+*
+* Use this to define a route that will be composed into a route tree
+* (typically via a parent route's `addChildren`). If you're using file-based
+* routing, prefer `createFileRoute`.
+*
+* @param options Route options (path, component, loader, context, etc.).
+* @returns A Route instance to be attached to the route tree.
+* @link https://tanstack.com/router/latest/docs/framework/react/api/router/createRouteFunction
+*/
+function createRoute(options) {
+	return new Route$1(options);
+}
+/**
+* Creates a root route factory that requires a router context type.
+*
+* Use when your root route expects `context` to be provided to `createRouter`.
+* The returned function behaves like `createRootRoute` but enforces a context type.
+*
+* @returns A factory function to configure and return a root route.
+* @link https://tanstack.com/router/latest/docs/framework/react/api/router/createRootRouteWithContextFunction
+*/
+function createRootRouteWithContext() {
+	return (options) => {
+		return createRootRoute(options);
+	};
+}
+var RootRoute = class extends BaseRootRoute {
+	/**
+	* @deprecated `RootRoute` is now an internal implementation detail. Use `createRootRoute()` instead.
+	*/
+	constructor(options) {
+		super(options);
+		this.useMatch = (opts) => {
+			return useMatch({
+				select: opts?.select,
+				from: this.id,
+				structuralSharing: opts?.structuralSharing
+			});
+		};
+		this.useRouteContext = (opts) => {
+			return useRouteContext({
+				...opts,
+				from: this.id
+			});
+		};
+		this.useSearch = (opts) => {
+			return useSearch({
+				select: opts?.select,
+				structuralSharing: opts?.structuralSharing,
+				from: this.id
+			});
+		};
+		this.useParams = (opts) => {
+			return useParams({
+				select: opts?.select,
+				structuralSharing: opts?.structuralSharing,
+				from: this.id
+			});
+		};
+		this.useLoaderDeps = (opts) => {
+			return useLoaderDeps({
+				...opts,
+				from: this.id
+			});
+		};
+		this.useLoaderData = (opts) => {
+			return useLoaderData({
+				...opts,
+				from: this.id
+			});
+		};
+		this.useNavigate = () => {
+			return useNavigate({ from: this.fullPath });
+		};
+		this.Link = import_react.forwardRef((props, ref) => {
+			return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Link, {
+				ref,
+				from: this.fullPath,
+				...props
+			});
+		});
+	}
+};
+/**
+* Creates a root Route instance used to build your route tree.
+*
+* Typically paired with `createRouter({ routeTree })`. If you need to require
+* a typed router context, use `createRootRouteWithContext` instead.
+*
+* @param options Root route options (component, error, pending, etc.).
+* @returns A root route instance.
+* @link https://tanstack.com/router/latest/docs/framework/react/api/router/createRootRouteFunction
+*/
+function createRootRoute(options) {
+	return new RootRoute(options);
+}
+//#endregion
+//#region ../../node_modules/.bun/@tanstack+react-router@1.168.2+bf16f8eded5e12ee/node_modules/@tanstack/react-router/dist/esm/fileRoute.js
+/**
+* Creates a file-based Route factory for a given path.
+*
+* Used by TanStack Router's file-based routing to associate a file with a
+* route. The returned function accepts standard route options. In normal usage
+* the `path` string is inserted and maintained by the `tsr` generator.
+*
+* @param path File path literal for the route (usually auto-generated).
+* @returns A function that accepts Route options and returns a Route instance.
+* @link https://tanstack.com/router/latest/docs/framework/react/api/router/createFileRouteFunction
+*/
+function createFileRoute(path) {
+	if (typeof path === "object") return new FileRoute(path, { silent: true }).createRoute(path);
+	return new FileRoute(path, { silent: true }).createRoute;
+}
+/** 
+@deprecated It's no longer recommended to use the `FileRoute` class directly.
+Instead, use `createFileRoute('/path/to/file')(options)` to create a file route.
+*/
+var FileRoute = class {
+	constructor(path, _opts) {
+		this.path = path;
+		this.createRoute = (options) => {
+			const route = createRoute(options);
+			route.isRoot = false;
+			return route;
+		};
+		this.silent = _opts?.silent;
+	}
+};
+var LazyRoute = class {
+	constructor(opts) {
+		this.useMatch = (opts) => {
+			return useMatch({
+				select: opts?.select,
+				from: this.options.id,
+				structuralSharing: opts?.structuralSharing
+			});
+		};
+		this.useRouteContext = (opts) => {
+			return useRouteContext({
+				...opts,
+				from: this.options.id
+			});
+		};
+		this.useSearch = (opts) => {
+			return useSearch({
+				select: opts?.select,
+				structuralSharing: opts?.structuralSharing,
+				from: this.options.id
+			});
+		};
+		this.useParams = (opts) => {
+			return useParams({
+				select: opts?.select,
+				structuralSharing: opts?.structuralSharing,
+				from: this.options.id
+			});
+		};
+		this.useLoaderDeps = (opts) => {
+			return useLoaderDeps({
+				...opts,
+				from: this.options.id
+			});
+		};
+		this.useLoaderData = (opts) => {
+			return useLoaderData({
+				...opts,
+				from: this.options.id
+			});
+		};
+		this.useNavigate = () => {
+			return useNavigate({ from: useRouter().routesById[this.options.id].fullPath });
+		};
+		this.options = opts;
+	}
+};
+/**
+* Creates a lazily-configurable file-based route stub by file path.
+*
+* Use this for code-splitting with file-based routes (eg. `.lazy.tsx` files).
+* The returned function accepts only non-critical route options like
+* `component`, `pendingComponent`, `errorComponent`, and `notFoundComponent`.
+*
+* @param id File path literal for the route file.
+* @returns A function that accepts lazy route options and returns a `LazyRoute`.
+* @link https://tanstack.com/router/latest/docs/framework/react/api/router/createLazyFileRouteFunction
+*/
+function createLazyFileRoute(id) {
+	if (typeof id === "object") return new LazyRoute(id);
+	return (opts) => new LazyRoute({
+		id,
+		...opts
+	});
+}
+//#endregion
+//#region ../../node_modules/.bun/@tanstack+react-router@1.168.2+bf16f8eded5e12ee/node_modules/@tanstack/react-router/dist/esm/lazyRouteComponent.js
+/**
+* Wrap a dynamic import to create a route component that supports
+* `.preload()` and friendly reload-on-module-missing behavior.
+*
+* @param importer Function returning a module promise
+* @param exportName Named export to use (default: `default`)
+* @returns A lazy route component compatible with TanStack Router
+* @link https://tanstack.com/router/latest/docs/framework/react/api/router/lazyRouteComponentFunction
+*/
+function lazyRouteComponent(importer, exportName) {
+	let loadPromise;
+	let comp;
+	let error;
+	let reload;
+	const load = () => {
+		if (!loadPromise) loadPromise = importer().then((res) => {
+			loadPromise = void 0;
+			comp = res[exportName ?? "default"];
+		}).catch((err) => {
+			error = err;
+			if (isModuleNotFoundError(error)) {
+				if (error instanceof Error && typeof window !== "undefined" && typeof sessionStorage !== "undefined") {
+					const storageKey = `tanstack_router_reload:${error.message}`;
+					if (!sessionStorage.getItem(storageKey)) {
+						sessionStorage.setItem(storageKey, "1");
+						reload = true;
+					}
+				}
+			}
+		});
+		return loadPromise;
+	};
+	const lazyComp = function Lazy(props) {
+		if (reload) {
+			window.location.reload();
+			throw new Promise(() => {});
+		}
+		if (error) throw error;
+		if (!comp) if (reactUse) reactUse(load());
+		else throw load();
+		return import_react.createElement(comp, props);
+	};
+	lazyComp.preload = load;
+	return lazyComp;
+}
+//#endregion
+//#region ../../node_modules/.bun/@tanstack+query-core@5.95.0/node_modules/@tanstack/query-core/build/modern/subscribable.js
+var Subscribable = class {
+	constructor() {
+		this.listeners = /* @__PURE__ */ new Set();
+		this.subscribe = this.subscribe.bind(this);
+	}
+	subscribe(listener) {
+		this.listeners.add(listener);
+		this.onSubscribe();
+		return () => {
+			this.listeners.delete(listener);
+			this.onUnsubscribe();
+		};
+	}
+	hasListeners() {
+		return this.listeners.size > 0;
+	}
+	onSubscribe() {}
+	onUnsubscribe() {}
+};
+//#endregion
+//#region ../../node_modules/.bun/@tanstack+query-core@5.95.0/node_modules/@tanstack/query-core/build/modern/focusManager.js
+var FocusManager = class extends Subscribable {
+	#focused;
+	#cleanup;
+	#setup;
+	constructor() {
+		super();
+		this.#setup = (onFocus) => {
+			if (typeof window !== "undefined" && window.addEventListener) {
+				const listener = () => onFocus();
+				window.addEventListener("visibilitychange", listener, false);
+				return () => {
+					window.removeEventListener("visibilitychange", listener);
+				};
+			}
+		};
+	}
+	onSubscribe() {
+		if (!this.#cleanup) this.setEventListener(this.#setup);
+	}
+	onUnsubscribe() {
+		if (!this.hasListeners()) {
+			this.#cleanup?.();
+			this.#cleanup = void 0;
+		}
+	}
+	setEventListener(setup) {
+		this.#setup = setup;
+		this.#cleanup?.();
+		this.#cleanup = setup((focused) => {
+			if (typeof focused === "boolean") this.setFocused(focused);
+			else this.onFocus();
+		});
+	}
+	setFocused(focused) {
+		if (this.#focused !== focused) {
+			this.#focused = focused;
+			this.onFocus();
+		}
+	}
+	onFocus() {
+		const isFocused = this.isFocused();
+		this.listeners.forEach((listener) => {
+			listener(isFocused);
+		});
+	}
+	isFocused() {
+		if (typeof this.#focused === "boolean") return this.#focused;
+		return globalThis.document?.visibilityState !== "hidden";
+	}
+};
+var focusManager = new FocusManager();
+//#endregion
+//#region ../../node_modules/.bun/@tanstack+query-core@5.95.0/node_modules/@tanstack/query-core/build/modern/timeoutManager.js
+var defaultTimeoutProvider = {
+	setTimeout: (callback, delay) => setTimeout(callback, delay),
+	clearTimeout: (timeoutId) => clearTimeout(timeoutId),
+	setInterval: (callback, delay) => setInterval(callback, delay),
+	clearInterval: (intervalId) => clearInterval(intervalId)
+};
+var TimeoutManager = class {
+	#provider = defaultTimeoutProvider;
+	#providerCalled = false;
+	setTimeoutProvider(provider) {
+		this.#provider = provider;
+	}
+	setTimeout(callback, delay) {
+		return this.#provider.setTimeout(callback, delay);
+	}
+	clearTimeout(timeoutId) {
+		this.#provider.clearTimeout(timeoutId);
+	}
+	setInterval(callback, delay) {
+		return this.#provider.setInterval(callback, delay);
+	}
+	clearInterval(intervalId) {
+		this.#provider.clearInterval(intervalId);
+	}
+};
+var timeoutManager = new TimeoutManager();
+function systemSetTimeoutZero(callback) {
+	setTimeout(callback, 0);
+}
+//#endregion
+//#region ../../node_modules/.bun/@tanstack+query-core@5.95.0/node_modules/@tanstack/query-core/build/modern/utils.js
+var isServer = typeof window === "undefined" || "Deno" in globalThis;
+function noop() {}
+function functionalUpdate(updater, input) {
+	return typeof updater === "function" ? updater(input) : updater;
+}
+function isValidTimeout(value) {
+	return typeof value === "number" && value >= 0 && value !== Infinity;
+}
+function timeUntilStale(updatedAt, staleTime) {
+	return Math.max(updatedAt + (staleTime || 0) - Date.now(), 0);
+}
+function resolveStaleTime(staleTime, query) {
+	return typeof staleTime === "function" ? staleTime(query) : staleTime;
+}
+function resolveEnabled(enabled, query) {
+	return typeof enabled === "function" ? enabled(query) : enabled;
+}
+function matchQuery(filters, query) {
+	const { type = "all", exact, fetchStatus, predicate, queryKey, stale } = filters;
+	if (queryKey) {
+		if (exact) {
+			if (query.queryHash !== hashQueryKeyByOptions(queryKey, query.options)) return false;
+		} else if (!partialMatchKey(query.queryKey, queryKey)) return false;
+	}
+	if (type !== "all") {
+		const isActive = query.isActive();
+		if (type === "active" && !isActive) return false;
+		if (type === "inactive" && isActive) return false;
+	}
+	if (typeof stale === "boolean" && query.isStale() !== stale) return false;
+	if (fetchStatus && fetchStatus !== query.state.fetchStatus) return false;
+	if (predicate && !predicate(query)) return false;
+	return true;
+}
+function matchMutation(filters, mutation) {
+	const { exact, status, predicate, mutationKey } = filters;
+	if (mutationKey) {
+		if (!mutation.options.mutationKey) return false;
+		if (exact) {
+			if (hashKey(mutation.options.mutationKey) !== hashKey(mutationKey)) return false;
+		} else if (!partialMatchKey(mutation.options.mutationKey, mutationKey)) return false;
+	}
+	if (status && mutation.state.status !== status) return false;
+	if (predicate && !predicate(mutation)) return false;
+	return true;
+}
+function hashQueryKeyByOptions(queryKey, options) {
+	return (options?.queryKeyHashFn || hashKey)(queryKey);
+}
+function hashKey(queryKey) {
+	return JSON.stringify(queryKey, (_, val) => isPlainObject(val) ? Object.keys(val).sort().reduce((result, key) => {
+		result[key] = val[key];
+		return result;
+	}, {}) : val);
+}
+function partialMatchKey(a, b) {
+	if (a === b) return true;
+	if (typeof a !== typeof b) return false;
+	if (a && b && typeof a === "object" && typeof b === "object") return Object.keys(b).every((key) => partialMatchKey(a[key], b[key]));
+	return false;
+}
+var hasOwn = Object.prototype.hasOwnProperty;
+function replaceEqualDeep(a, b, depth = 0) {
+	if (a === b) return a;
+	if (depth > 500) return b;
+	const array = isPlainArray(a) && isPlainArray(b);
+	if (!array && !(isPlainObject(a) && isPlainObject(b))) return b;
+	const aSize = (array ? a : Object.keys(a)).length;
+	const bItems = array ? b : Object.keys(b);
+	const bSize = bItems.length;
+	const copy = array ? new Array(bSize) : {};
+	let equalItems = 0;
+	for (let i = 0; i < bSize; i++) {
+		const key = array ? i : bItems[i];
+		const aItem = a[key];
+		const bItem = b[key];
+		if (aItem === bItem) {
+			copy[key] = aItem;
+			if (array ? i < aSize : hasOwn.call(a, key)) equalItems++;
+			continue;
+		}
+		if (aItem === null || bItem === null || typeof aItem !== "object" || typeof bItem !== "object") {
+			copy[key] = bItem;
+			continue;
+		}
+		const v = replaceEqualDeep(aItem, bItem, depth + 1);
+		copy[key] = v;
+		if (v === aItem) equalItems++;
+	}
+	return aSize === bSize && equalItems === aSize ? a : copy;
+}
+function shallowEqualObjects(a, b) {
+	if (!b || Object.keys(a).length !== Object.keys(b).length) return false;
+	for (const key in a) if (a[key] !== b[key]) return false;
+	return true;
+}
+function isPlainArray(value) {
+	return Array.isArray(value) && value.length === Object.keys(value).length;
+}
+function isPlainObject(o) {
+	if (!hasObjectPrototype(o)) return false;
+	const ctor = o.constructor;
+	if (ctor === void 0) return true;
+	const prot = ctor.prototype;
+	if (!hasObjectPrototype(prot)) return false;
+	if (!prot.hasOwnProperty("isPrototypeOf")) return false;
+	if (Object.getPrototypeOf(o) !== Object.prototype) return false;
+	return true;
+}
+function hasObjectPrototype(o) {
+	return Object.prototype.toString.call(o) === "[object Object]";
+}
+function sleep(timeout) {
+	return new Promise((resolve) => {
+		timeoutManager.setTimeout(resolve, timeout);
+	});
+}
+function replaceData(prevData, data, options) {
+	if (typeof options.structuralSharing === "function") return options.structuralSharing(prevData, data);
+	else if (options.structuralSharing !== false) return replaceEqualDeep(prevData, data);
+	return data;
+}
+function addToEnd(items, item, max = 0) {
+	const newItems = [...items, item];
+	return max && newItems.length > max ? newItems.slice(1) : newItems;
+}
+function addToStart(items, item, max = 0) {
+	const newItems = [item, ...items];
+	return max && newItems.length > max ? newItems.slice(0, -1) : newItems;
+}
+var skipToken = /* @__PURE__ */ Symbol();
+function ensureQueryFn(options, fetchOptions) {
+	if (!options.queryFn && fetchOptions?.initialPromise) return () => fetchOptions.initialPromise;
+	if (!options.queryFn || options.queryFn === skipToken) return () => Promise.reject(/* @__PURE__ */ new Error(`Missing queryFn: '${options.queryHash}'`));
+	return options.queryFn;
+}
+function shouldThrowError(throwOnError, params) {
+	if (typeof throwOnError === "function") return throwOnError(...params);
+	return !!throwOnError;
+}
+function addConsumeAwareSignal(object, getSignal, onCancelled) {
+	let consumed = false;
+	let signal;
+	Object.defineProperty(object, "signal", {
+		enumerable: true,
+		get: () => {
+			signal ??= getSignal();
+			if (consumed) return signal;
+			consumed = true;
+			if (signal.aborted) onCancelled();
+			else signal.addEventListener("abort", onCancelled, { once: true });
+			return signal;
+		}
+	});
+	return object;
+}
+//#endregion
+//#region ../../node_modules/.bun/@tanstack+query-core@5.95.0/node_modules/@tanstack/query-core/build/modern/environmentManager.js
+var environmentManager = /* @__PURE__ */ (() => {
+	let isServerFn = () => isServer;
+	return {
+		isServer() {
+			return isServerFn();
+		},
+		setIsServer(isServerValue) {
+			isServerFn = isServerValue;
+		}
+	};
+})();
+//#endregion
+//#region ../../node_modules/.bun/@tanstack+query-core@5.95.0/node_modules/@tanstack/query-core/build/modern/thenable.js
+function pendingThenable() {
+	let resolve;
+	let reject;
+	const thenable = new Promise((_resolve, _reject) => {
+		resolve = _resolve;
+		reject = _reject;
+	});
+	thenable.status = "pending";
+	thenable.catch(() => {});
+	function finalize(data) {
+		Object.assign(thenable, data);
+		delete thenable.resolve;
+		delete thenable.reject;
+	}
+	thenable.resolve = (value) => {
+		finalize({
+			status: "fulfilled",
+			value
+		});
+		resolve(value);
+	};
+	thenable.reject = (reason) => {
+		finalize({
+			status: "rejected",
+			reason
+		});
+		reject(reason);
+	};
+	return thenable;
+}
+//#endregion
+//#region ../../node_modules/.bun/@tanstack+query-core@5.95.0/node_modules/@tanstack/query-core/build/modern/notifyManager.js
+var defaultScheduler = systemSetTimeoutZero;
+function createNotifyManager() {
+	let queue = [];
+	let transactions = 0;
+	let notifyFn = (callback) => {
+		callback();
+	};
+	let batchNotifyFn = (callback) => {
+		callback();
+	};
+	let scheduleFn = defaultScheduler;
+	const schedule = (callback) => {
+		if (transactions) queue.push(callback);
+		else scheduleFn(() => {
+			notifyFn(callback);
+		});
+	};
+	const flush = () => {
+		const originalQueue = queue;
+		queue = [];
+		if (originalQueue.length) scheduleFn(() => {
+			batchNotifyFn(() => {
+				originalQueue.forEach((callback) => {
+					notifyFn(callback);
+				});
+			});
+		});
+	};
+	return {
+		batch: (callback) => {
+			let result;
+			transactions++;
+			try {
+				result = callback();
+			} finally {
+				transactions--;
+				if (!transactions) flush();
+			}
+			return result;
+		},
+		batchCalls: (callback) => {
+			return (...args) => {
+				schedule(() => {
+					callback(...args);
+				});
+			};
+		},
+		schedule,
+		setNotifyFunction: (fn) => {
+			notifyFn = fn;
+		},
+		setBatchNotifyFunction: (fn) => {
+			batchNotifyFn = fn;
+		},
+		setScheduler: (fn) => {
+			scheduleFn = fn;
+		}
+	};
+}
+var notifyManager = createNotifyManager();
+//#endregion
+//#region ../../node_modules/.bun/@tanstack+query-core@5.95.0/node_modules/@tanstack/query-core/build/modern/onlineManager.js
+var OnlineManager = class extends Subscribable {
+	#online = true;
+	#cleanup;
+	#setup;
+	constructor() {
+		super();
+		this.#setup = (onOnline) => {
+			if (typeof window !== "undefined" && window.addEventListener) {
+				const onlineListener = () => onOnline(true);
+				const offlineListener = () => onOnline(false);
+				window.addEventListener("online", onlineListener, false);
+				window.addEventListener("offline", offlineListener, false);
+				return () => {
+					window.removeEventListener("online", onlineListener);
+					window.removeEventListener("offline", offlineListener);
+				};
+			}
+		};
+	}
+	onSubscribe() {
+		if (!this.#cleanup) this.setEventListener(this.#setup);
+	}
+	onUnsubscribe() {
+		if (!this.hasListeners()) {
+			this.#cleanup?.();
+			this.#cleanup = void 0;
+		}
+	}
+	setEventListener(setup) {
+		this.#setup = setup;
+		this.#cleanup?.();
+		this.#cleanup = setup(this.setOnline.bind(this));
+	}
+	setOnline(online) {
+		if (this.#online !== online) {
+			this.#online = online;
+			this.listeners.forEach((listener) => {
+				listener(online);
+			});
+		}
+	}
+	isOnline() {
+		return this.#online;
+	}
+};
+var onlineManager = new OnlineManager();
+//#endregion
+//#region ../../node_modules/.bun/@tanstack+query-core@5.95.0/node_modules/@tanstack/query-core/build/modern/retryer.js
+function defaultRetryDelay(failureCount) {
+	return Math.min(1e3 * 2 ** failureCount, 3e4);
+}
+function canFetch(networkMode) {
+	return (networkMode ?? "online") === "online" ? onlineManager.isOnline() : true;
+}
+var CancelledError = class extends Error {
+	constructor(options) {
+		super("CancelledError");
+		this.revert = options?.revert;
+		this.silent = options?.silent;
+	}
+};
+function createRetryer(config) {
+	let isRetryCancelled = false;
+	let failureCount = 0;
+	let continueFn;
+	const thenable = pendingThenable();
+	const isResolved = () => thenable.status !== "pending";
+	const cancel = (cancelOptions) => {
+		if (!isResolved()) {
+			const error = new CancelledError(cancelOptions);
+			reject(error);
+			config.onCancel?.(error);
+		}
+	};
+	const cancelRetry = () => {
+		isRetryCancelled = true;
+	};
+	const continueRetry = () => {
+		isRetryCancelled = false;
+	};
+	const canContinue = () => focusManager.isFocused() && (config.networkMode === "always" || onlineManager.isOnline()) && config.canRun();
+	const canStart = () => canFetch(config.networkMode) && config.canRun();
+	const resolve = (value) => {
+		if (!isResolved()) {
+			continueFn?.();
+			thenable.resolve(value);
+		}
+	};
+	const reject = (value) => {
+		if (!isResolved()) {
+			continueFn?.();
+			thenable.reject(value);
+		}
+	};
+	const pause = () => {
+		return new Promise((continueResolve) => {
+			continueFn = (value) => {
+				if (isResolved() || canContinue()) continueResolve(value);
+			};
+			config.onPause?.();
+		}).then(() => {
+			continueFn = void 0;
+			if (!isResolved()) config.onContinue?.();
+		});
+	};
+	const run = () => {
+		if (isResolved()) return;
+		let promiseOrValue;
+		const initialPromise = failureCount === 0 ? config.initialPromise : void 0;
+		try {
+			promiseOrValue = initialPromise ?? config.fn();
+		} catch (error) {
+			promiseOrValue = Promise.reject(error);
+		}
+		Promise.resolve(promiseOrValue).then(resolve).catch((error) => {
+			if (isResolved()) return;
+			const retry = config.retry ?? (environmentManager.isServer() ? 0 : 3);
+			const retryDelay = config.retryDelay ?? defaultRetryDelay;
+			const delay = typeof retryDelay === "function" ? retryDelay(failureCount, error) : retryDelay;
+			const shouldRetry = retry === true || typeof retry === "number" && failureCount < retry || typeof retry === "function" && retry(failureCount, error);
+			if (isRetryCancelled || !shouldRetry) {
+				reject(error);
+				return;
+			}
+			failureCount++;
+			config.onFail?.(failureCount, error);
+			sleep(delay).then(() => {
+				return canContinue() ? void 0 : pause();
+			}).then(() => {
+				if (isRetryCancelled) reject(error);
+				else run();
+			});
+		});
+	};
+	return {
+		promise: thenable,
+		status: () => thenable.status,
+		cancel,
+		continue: () => {
+			continueFn?.();
+			return thenable;
+		},
+		cancelRetry,
+		continueRetry,
+		canStart,
+		start: () => {
+			if (canStart()) run();
+			else pause().then(run);
+			return thenable;
+		}
+	};
+}
+//#endregion
+//#region ../../node_modules/.bun/@tanstack+query-core@5.95.0/node_modules/@tanstack/query-core/build/modern/removable.js
+var Removable = class {
+	#gcTimeout;
+	destroy() {
+		this.clearGcTimeout();
+	}
+	scheduleGc() {
+		this.clearGcTimeout();
+		if (isValidTimeout(this.gcTime)) this.#gcTimeout = timeoutManager.setTimeout(() => {
+			this.optionalRemove();
+		}, this.gcTime);
+	}
+	updateGcTime(newGcTime) {
+		this.gcTime = Math.max(this.gcTime || 0, newGcTime ?? (environmentManager.isServer() ? Infinity : 300 * 1e3));
+	}
+	clearGcTimeout() {
+		if (this.#gcTimeout) {
+			timeoutManager.clearTimeout(this.#gcTimeout);
+			this.#gcTimeout = void 0;
+		}
+	}
+};
+//#endregion
+//#region ../../node_modules/.bun/@tanstack+query-core@5.95.0/node_modules/@tanstack/query-core/build/modern/query.js
+var Query = class extends Removable {
+	#initialState;
+	#revertState;
+	#cache;
+	#client;
+	#retryer;
+	#defaultOptions;
+	#abortSignalConsumed;
+	constructor(config) {
+		super();
+		this.#abortSignalConsumed = false;
+		this.#defaultOptions = config.defaultOptions;
+		this.setOptions(config.options);
+		this.observers = [];
+		this.#client = config.client;
+		this.#cache = this.#client.getQueryCache();
+		this.queryKey = config.queryKey;
+		this.queryHash = config.queryHash;
+		this.#initialState = getDefaultState$1(this.options);
+		this.state = config.state ?? this.#initialState;
+		this.scheduleGc();
+	}
+	get meta() {
+		return this.options.meta;
+	}
+	get promise() {
+		return this.#retryer?.promise;
+	}
+	setOptions(options) {
+		this.options = {
+			...this.#defaultOptions,
+			...options
+		};
+		this.updateGcTime(this.options.gcTime);
+		if (this.state && this.state.data === void 0) {
+			const defaultState = getDefaultState$1(this.options);
+			if (defaultState.data !== void 0) {
+				this.setState(successState(defaultState.data, defaultState.dataUpdatedAt));
+				this.#initialState = defaultState;
+			}
+		}
+	}
+	optionalRemove() {
+		if (!this.observers.length && this.state.fetchStatus === "idle") this.#cache.remove(this);
+	}
+	setData(newData, options) {
+		const data = replaceData(this.state.data, newData, this.options);
+		this.#dispatch({
+			data,
+			type: "success",
+			dataUpdatedAt: options?.updatedAt,
+			manual: options?.manual
+		});
+		return data;
+	}
+	setState(state, setStateOptions) {
+		this.#dispatch({
+			type: "setState",
+			state,
+			setStateOptions
+		});
+	}
+	cancel(options) {
+		const promise = this.#retryer?.promise;
+		this.#retryer?.cancel(options);
+		return promise ? promise.then(noop).catch(noop) : Promise.resolve();
+	}
+	destroy() {
+		super.destroy();
+		this.cancel({ silent: true });
+	}
+	get resetState() {
+		return this.#initialState;
+	}
+	reset() {
+		this.destroy();
+		this.setState(this.resetState);
+	}
+	isActive() {
+		return this.observers.some((observer) => resolveEnabled(observer.options.enabled, this) !== false);
+	}
+	isDisabled() {
+		if (this.getObserversCount() > 0) return !this.isActive();
+		return this.options.queryFn === skipToken || !this.isFetched();
+	}
+	isFetched() {
+		return this.state.dataUpdateCount + this.state.errorUpdateCount > 0;
+	}
+	isStatic() {
+		if (this.getObserversCount() > 0) return this.observers.some((observer) => resolveStaleTime(observer.options.staleTime, this) === "static");
+		return false;
+	}
+	isStale() {
+		if (this.getObserversCount() > 0) return this.observers.some((observer) => observer.getCurrentResult().isStale);
+		return this.state.data === void 0 || this.state.isInvalidated;
+	}
+	isStaleByTime(staleTime = 0) {
+		if (this.state.data === void 0) return true;
+		if (staleTime === "static") return false;
+		if (this.state.isInvalidated) return true;
+		return !timeUntilStale(this.state.dataUpdatedAt, staleTime);
+	}
+	onFocus() {
+		this.observers.find((x) => x.shouldFetchOnWindowFocus())?.refetch({ cancelRefetch: false });
+		this.#retryer?.continue();
+	}
+	onOnline() {
+		this.observers.find((x) => x.shouldFetchOnReconnect())?.refetch({ cancelRefetch: false });
+		this.#retryer?.continue();
+	}
+	addObserver(observer) {
+		if (!this.observers.includes(observer)) {
+			this.observers.push(observer);
+			this.clearGcTimeout();
+			this.#cache.notify({
+				type: "observerAdded",
+				query: this,
+				observer
+			});
+		}
+	}
+	removeObserver(observer) {
+		if (this.observers.includes(observer)) {
+			this.observers = this.observers.filter((x) => x !== observer);
+			if (!this.observers.length) {
+				if (this.#retryer) if (this.#abortSignalConsumed || this.#isInitialPausedFetch()) this.#retryer.cancel({ revert: true });
+				else this.#retryer.cancelRetry();
+				this.scheduleGc();
+			}
+			this.#cache.notify({
+				type: "observerRemoved",
+				query: this,
+				observer
+			});
+		}
+	}
+	getObserversCount() {
+		return this.observers.length;
+	}
+	#isInitialPausedFetch() {
+		return this.state.fetchStatus === "paused" && this.state.status === "pending";
+	}
+	invalidate() {
+		if (!this.state.isInvalidated) this.#dispatch({ type: "invalidate" });
+	}
+	async fetch(options, fetchOptions) {
+		if (this.state.fetchStatus !== "idle" && this.#retryer?.status() !== "rejected") {
+			if (this.state.data !== void 0 && fetchOptions?.cancelRefetch) this.cancel({ silent: true });
+			else if (this.#retryer) {
+				this.#retryer.continueRetry();
+				return this.#retryer.promise;
+			}
+		}
+		if (options) this.setOptions(options);
+		if (!this.options.queryFn) {
+			const observer = this.observers.find((x) => x.options.queryFn);
+			if (observer) this.setOptions(observer.options);
+		}
+		const abortController = new AbortController();
+		const addSignalProperty = (object) => {
+			Object.defineProperty(object, "signal", {
+				enumerable: true,
+				get: () => {
+					this.#abortSignalConsumed = true;
+					return abortController.signal;
+				}
+			});
+		};
+		const fetchFn = () => {
+			const queryFn = ensureQueryFn(this.options, fetchOptions);
+			const createQueryFnContext = () => {
+				const queryFnContext2 = {
+					client: this.#client,
+					queryKey: this.queryKey,
+					meta: this.meta
+				};
+				addSignalProperty(queryFnContext2);
+				return queryFnContext2;
+			};
+			const queryFnContext = createQueryFnContext();
+			this.#abortSignalConsumed = false;
+			if (this.options.persister) return this.options.persister(queryFn, queryFnContext, this);
+			return queryFn(queryFnContext);
+		};
+		const createFetchContext = () => {
+			const context2 = {
+				fetchOptions,
+				options: this.options,
+				queryKey: this.queryKey,
+				client: this.#client,
+				state: this.state,
+				fetchFn
+			};
+			addSignalProperty(context2);
+			return context2;
+		};
+		const context = createFetchContext();
+		this.options.behavior?.onFetch(context, this);
+		this.#revertState = this.state;
+		if (this.state.fetchStatus === "idle" || this.state.fetchMeta !== context.fetchOptions?.meta) this.#dispatch({
+			type: "fetch",
+			meta: context.fetchOptions?.meta
+		});
+		this.#retryer = createRetryer({
+			initialPromise: fetchOptions?.initialPromise,
+			fn: context.fetchFn,
+			onCancel: (error) => {
+				if (error instanceof CancelledError && error.revert) this.setState({
+					...this.#revertState,
+					fetchStatus: "idle"
+				});
+				abortController.abort();
+			},
+			onFail: (failureCount, error) => {
+				this.#dispatch({
+					type: "failed",
+					failureCount,
+					error
+				});
+			},
+			onPause: () => {
+				this.#dispatch({ type: "pause" });
+			},
+			onContinue: () => {
+				this.#dispatch({ type: "continue" });
+			},
+			retry: context.options.retry,
+			retryDelay: context.options.retryDelay,
+			networkMode: context.options.networkMode,
+			canRun: () => true
+		});
+		try {
+			const data = await this.#retryer.start();
+			if (data === void 0) throw new Error(`${this.queryHash} data is undefined`);
+			this.setData(data);
+			this.#cache.config.onSuccess?.(data, this);
+			this.#cache.config.onSettled?.(data, this.state.error, this);
+			return data;
+		} catch (error) {
+			if (error instanceof CancelledError) {
+				if (error.silent) return this.#retryer.promise;
+				else if (error.revert) {
+					if (this.state.data === void 0) throw error;
+					return this.state.data;
+				}
+			}
+			this.#dispatch({
+				type: "error",
+				error
+			});
+			this.#cache.config.onError?.(error, this);
+			this.#cache.config.onSettled?.(this.state.data, error, this);
+			throw error;
+		} finally {
+			this.scheduleGc();
+		}
+	}
+	#dispatch(action) {
+		const reducer = (state) => {
+			switch (action.type) {
+				case "failed": return {
+					...state,
+					fetchFailureCount: action.failureCount,
+					fetchFailureReason: action.error
+				};
+				case "pause": return {
+					...state,
+					fetchStatus: "paused"
+				};
+				case "continue": return {
+					...state,
+					fetchStatus: "fetching"
+				};
+				case "fetch": return {
+					...state,
+					...fetchState(state.data, this.options),
+					fetchMeta: action.meta ?? null
+				};
+				case "success":
+					const newState = {
+						...state,
+						...successState(action.data, action.dataUpdatedAt),
+						dataUpdateCount: state.dataUpdateCount + 1,
+						...!action.manual && {
+							fetchStatus: "idle",
+							fetchFailureCount: 0,
+							fetchFailureReason: null
+						}
+					};
+					this.#revertState = action.manual ? newState : void 0;
+					return newState;
+				case "error":
+					const error = action.error;
+					return {
+						...state,
+						error,
+						errorUpdateCount: state.errorUpdateCount + 1,
+						errorUpdatedAt: Date.now(),
+						fetchFailureCount: state.fetchFailureCount + 1,
+						fetchFailureReason: error,
+						fetchStatus: "idle",
+						status: "error",
+						isInvalidated: true
+					};
+				case "invalidate": return {
+					...state,
+					isInvalidated: true
+				};
+				case "setState": return {
+					...state,
+					...action.state
+				};
+			}
+		};
+		this.state = reducer(this.state);
+		notifyManager.batch(() => {
+			this.observers.forEach((observer) => {
+				observer.onQueryUpdate();
+			});
+			this.#cache.notify({
+				query: this,
+				type: "updated",
+				action
+			});
+		});
+	}
+};
+function fetchState(data, options) {
+	return {
+		fetchFailureCount: 0,
+		fetchFailureReason: null,
+		fetchStatus: canFetch(options.networkMode) ? "fetching" : "paused",
+		...data === void 0 && {
+			error: null,
+			status: "pending"
+		}
+	};
+}
+function successState(data, dataUpdatedAt) {
+	return {
+		data,
+		dataUpdatedAt: dataUpdatedAt ?? Date.now(),
+		error: null,
+		isInvalidated: false,
+		status: "success"
+	};
+}
+function getDefaultState$1(options) {
+	const data = typeof options.initialData === "function" ? options.initialData() : options.initialData;
+	const hasData = data !== void 0;
+	const initialDataUpdatedAt = hasData ? typeof options.initialDataUpdatedAt === "function" ? options.initialDataUpdatedAt() : options.initialDataUpdatedAt : 0;
+	return {
+		data,
+		dataUpdateCount: 0,
+		dataUpdatedAt: hasData ? initialDataUpdatedAt ?? Date.now() : 0,
+		error: null,
+		errorUpdateCount: 0,
+		errorUpdatedAt: 0,
+		fetchFailureCount: 0,
+		fetchFailureReason: null,
+		fetchMeta: null,
+		isInvalidated: false,
+		status: hasData ? "success" : "pending",
+		fetchStatus: "idle"
+	};
+}
+//#endregion
+//#region ../../node_modules/.bun/@tanstack+query-core@5.95.0/node_modules/@tanstack/query-core/build/modern/mutation.js
+var Mutation = class extends Removable {
+	#client;
+	#observers;
+	#mutationCache;
+	#retryer;
+	constructor(config) {
+		super();
+		this.#client = config.client;
+		this.mutationId = config.mutationId;
+		this.#mutationCache = config.mutationCache;
+		this.#observers = [];
+		this.state = config.state || getDefaultState();
+		this.setOptions(config.options);
+		this.scheduleGc();
+	}
+	setOptions(options) {
+		this.options = options;
+		this.updateGcTime(this.options.gcTime);
+	}
+	get meta() {
+		return this.options.meta;
+	}
+	addObserver(observer) {
+		if (!this.#observers.includes(observer)) {
+			this.#observers.push(observer);
+			this.clearGcTimeout();
+			this.#mutationCache.notify({
+				type: "observerAdded",
+				mutation: this,
+				observer
+			});
+		}
+	}
+	removeObserver(observer) {
+		this.#observers = this.#observers.filter((x) => x !== observer);
+		this.scheduleGc();
+		this.#mutationCache.notify({
+			type: "observerRemoved",
+			mutation: this,
+			observer
+		});
+	}
+	optionalRemove() {
+		if (!this.#observers.length) if (this.state.status === "pending") this.scheduleGc();
+		else this.#mutationCache.remove(this);
+	}
+	continue() {
+		return this.#retryer?.continue() ?? this.execute(this.state.variables);
+	}
+	async execute(variables) {
+		const onContinue = () => {
+			this.#dispatch({ type: "continue" });
+		};
+		const mutationFnContext = {
+			client: this.#client,
+			meta: this.options.meta,
+			mutationKey: this.options.mutationKey
+		};
+		this.#retryer = createRetryer({
+			fn: () => {
+				if (!this.options.mutationFn) return Promise.reject(/* @__PURE__ */ new Error("No mutationFn found"));
+				return this.options.mutationFn(variables, mutationFnContext);
+			},
+			onFail: (failureCount, error) => {
+				this.#dispatch({
+					type: "failed",
+					failureCount,
+					error
+				});
+			},
+			onPause: () => {
+				this.#dispatch({ type: "pause" });
+			},
+			onContinue,
+			retry: this.options.retry ?? 0,
+			retryDelay: this.options.retryDelay,
+			networkMode: this.options.networkMode,
+			canRun: () => this.#mutationCache.canRun(this)
+		});
+		const restored = this.state.status === "pending";
+		const isPaused = !this.#retryer.canStart();
+		try {
+			if (restored) onContinue();
+			else {
+				this.#dispatch({
+					type: "pending",
+					variables,
+					isPaused
+				});
+				if (this.#mutationCache.config.onMutate) await this.#mutationCache.config.onMutate(variables, this, mutationFnContext);
+				const context = await this.options.onMutate?.(variables, mutationFnContext);
+				if (context !== this.state.context) this.#dispatch({
+					type: "pending",
+					context,
+					variables,
+					isPaused
+				});
+			}
+			const data = await this.#retryer.start();
+			await this.#mutationCache.config.onSuccess?.(data, variables, this.state.context, this, mutationFnContext);
+			await this.options.onSuccess?.(data, variables, this.state.context, mutationFnContext);
+			await this.#mutationCache.config.onSettled?.(data, null, this.state.variables, this.state.context, this, mutationFnContext);
+			await this.options.onSettled?.(data, null, variables, this.state.context, mutationFnContext);
+			this.#dispatch({
+				type: "success",
+				data
+			});
+			return data;
+		} catch (error) {
+			try {
+				await this.#mutationCache.config.onError?.(error, variables, this.state.context, this, mutationFnContext);
+			} catch (e) {
+				Promise.reject(e);
+			}
+			try {
+				await this.options.onError?.(error, variables, this.state.context, mutationFnContext);
+			} catch (e) {
+				Promise.reject(e);
+			}
+			try {
+				await this.#mutationCache.config.onSettled?.(void 0, error, this.state.variables, this.state.context, this, mutationFnContext);
+			} catch (e) {
+				Promise.reject(e);
+			}
+			try {
+				await this.options.onSettled?.(void 0, error, variables, this.state.context, mutationFnContext);
+			} catch (e) {
+				Promise.reject(e);
+			}
+			this.#dispatch({
+				type: "error",
+				error
+			});
+			throw error;
+		} finally {
+			this.#mutationCache.runNext(this);
+		}
+	}
+	#dispatch(action) {
+		const reducer = (state) => {
+			switch (action.type) {
+				case "failed": return {
+					...state,
+					failureCount: action.failureCount,
+					failureReason: action.error
+				};
+				case "pause": return {
+					...state,
+					isPaused: true
+				};
+				case "continue": return {
+					...state,
+					isPaused: false
+				};
+				case "pending": return {
+					...state,
+					context: action.context,
+					data: void 0,
+					failureCount: 0,
+					failureReason: null,
+					error: null,
+					isPaused: action.isPaused,
+					status: "pending",
+					variables: action.variables,
+					submittedAt: Date.now()
+				};
+				case "success": return {
+					...state,
+					data: action.data,
+					failureCount: 0,
+					failureReason: null,
+					error: null,
+					status: "success",
+					isPaused: false
+				};
+				case "error": return {
+					...state,
+					data: void 0,
+					error: action.error,
+					failureCount: state.failureCount + 1,
+					failureReason: action.error,
+					isPaused: false,
+					status: "error"
+				};
+			}
+		};
+		this.state = reducer(this.state);
+		notifyManager.batch(() => {
+			this.#observers.forEach((observer) => {
+				observer.onMutationUpdate(action);
+			});
+			this.#mutationCache.notify({
+				mutation: this,
+				type: "updated",
+				action
+			});
+		});
+	}
+};
+function getDefaultState() {
+	return {
+		context: void 0,
+		data: void 0,
+		error: null,
+		failureCount: 0,
+		failureReason: null,
+		isPaused: false,
+		status: "idle",
+		variables: void 0,
+		submittedAt: 0
+	};
+}
+//#endregion
+//#region ../../node_modules/.bun/@tanstack+react-query@5.95.0+b1ab299f0a400331/node_modules/@tanstack/react-query/build/modern/QueryClientProvider.js
+var QueryClientContext = import_react.createContext(void 0);
+var useQueryClient = (queryClient) => {
+	const client = import_react.useContext(QueryClientContext);
+	if (queryClient) return queryClient;
+	if (!client) throw new Error("No QueryClient set, use QueryClientProvider to set one");
+	return client;
+};
+var QueryClientProvider = ({ client, children }) => {
+	import_react.useEffect(() => {
+		client.mount();
+		return () => {
+			client.unmount();
+		};
+	}, [client]);
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(QueryClientContext.Provider, {
+		value: client,
+		children
+	});
+};
+//#endregion
+//#region app/routes/index.tsx
+var $$splitComponentImporter = () => import("./routes-Bk6XCM2I.js");
+/**
+* Parse version keys into project/version structure.
+* Multi-project keys look like "query/v5", single-project keys look like "v5".
+*/
+var Route = createFileRoute("/")({
+	validateSearch: (search) => ({
+		project: search.project || void 0,
+		v: search.v || void 0,
+		lang: search.lang || void 0,
+		file: search.file || void 0,
+		files: search.files || void 0,
+		view: search.view || void 0,
+		toc: search.toc || void 0,
+		nodes: search.nodes || void 0,
+		status: search.status || void 0,
+		section: search.section || void 0
+	}),
+	component: lazyRouteComponent($$splitComponentImporter, "component")
+});
+//#endregion
+export { timeUntilStale as A, partialMatchKey as C, shallowEqualObjects as D, resolveStaleTime as E, createLazyFileRoute as F, createRootRouteWithContext as I, useNavigate as L, focusManager as M, Subscribable as N, shouldThrowError as O, createFileRoute as P, noop as S, resolveEnabled as T, hashKey as _, getDefaultState as a, matchMutation as b, onlineManager as c, environmentManager as d, addConsumeAwareSignal as f, functionalUpdate as g, ensureQueryFn as h, Mutation as i, timeoutManager as j, skipToken as k, notifyManager as l, addToStart as m, QueryClientProvider as n, Query as o, addToEnd as p, useQueryClient as r, fetchState as s, Route as t, pendingThenable as u, hashQueryKeyByOptions as v, replaceData as w, matchQuery as x, isValidTimeout as y };