@cartanova/qgrid-cli 2.7.0 → 2.7.2

package/bundle/web-dist/server/assets/lazyRouteComponent-0y-znAfz.js

@@ -0,0 +1,1856 @@
+import { H as __toESM, S as require_react, x as require_jsx_runtime, z as __commonJSMin } from "./services.generated-DyPeBI00.js";
+import { n as require_shim, t as require_react_dom } from "./react-dom-zmEq8BVp.js";
+//#region ../../node_modules/.pnpm/@tanstack+router-core@1.143.6/node_modules/@tanstack/router-core/dist/esm/utils.js
+function last(arr) {
+	return arr[arr.length - 1];
+}
+function isFunction(d) {
+	return typeof d === "function";
+}
+function functionalUpdate(updater, previous) {
+	if (isFunction(updater)) return updater(previous);
+	return updater;
+}
+var hasOwn = Object.prototype.hasOwnProperty;
+function replaceEqualDeep(prev, _next) {
+	if (prev === _next) return prev;
+	const next = _next;
+	const array = isPlainArray(prev) && isPlainArray(next);
+	if (!array && !(isPlainObject(prev) && isPlainObject(next))) return next;
+	const prevItems = array ? prev : getEnumerableOwnKeys(prev);
+	if (!prevItems) return next;
+	const nextItems = array ? next : getEnumerableOwnKeys(next);
+	if (!nextItems) return next;
+	const prevSize = prevItems.length;
+	const nextSize = nextItems.length;
+	const copy = array ? new Array(nextSize) : {};
+	let equalItems = 0;
+	for (let i = 0; i < nextSize; i++) {
+		const key = array ? i : nextItems[i];
+		const p = prev[key];
+		const n = next[key];
+		if (p === n) {
+			copy[key] = p;
+			if (array ? i < prevSize : hasOwn.call(prev, key)) equalItems++;
+			continue;
+		}
+		if (p === null || n === null || typeof p !== "object" || typeof n !== "object") {
+			copy[key] = n;
+			continue;
+		}
+		const v = replaceEqualDeep(p, n);
+		copy[key] = v;
+		if (v === p) equalItems++;
+	}
+	return prevSize === nextSize && equalItems === prevSize ? prev : copy;
+}
+function getEnumerableOwnKeys(o) {
+	const keys = [];
+	const names = Object.getOwnPropertyNames(o);
+	for (const name of names) {
+		if (!Object.prototype.propertyIsEnumerable.call(o, name)) return false;
+		keys.push(name);
+	}
+	const symbols = Object.getOwnPropertySymbols(o);
+	for (const symbol of symbols) {
+		if (!Object.prototype.propertyIsEnumerable.call(o, symbol)) return false;
+		keys.push(symbol);
+	}
+	return keys;
+}
+function isPlainObject(o) {
+	if (!hasObjectPrototype(o)) return false;
+	const ctor = o.constructor;
+	if (typeof ctor === "undefined") return true;
+	const prot = ctor.prototype;
+	if (!hasObjectPrototype(prot)) return false;
+	if (!prot.hasOwnProperty("isPrototypeOf")) return false;
+	return true;
+}
+function hasObjectPrototype(o) {
+	return Object.prototype.toString.call(o) === "[object Object]";
+}
+function isPlainArray(value) {
+	return Array.isArray(value) && value.length === Object.keys(value).length;
+}
+function deepEqual(a, b, opts) {
+	if (a === b) return true;
+	if (typeof a !== typeof b) return false;
+	if (Array.isArray(a) && Array.isArray(b)) {
+		if (a.length !== b.length) return false;
+		for (let i = 0, l = a.length; i < l; i++) if (!deepEqual(a[i], b[i], opts)) return false;
+		return true;
+	}
+	if (isPlainObject(a) && isPlainObject(b)) {
+		const ignoreUndefined = opts?.ignoreUndefined ?? true;
+		if (opts?.partial) {
+			for (const k in b) if (!ignoreUndefined || b[k] !== void 0) {
+				if (!deepEqual(a[k], b[k], opts)) return false;
+			}
+			return true;
+		}
+		let aCount = 0;
+		if (!ignoreUndefined) aCount = Object.keys(a).length;
+		else for (const k in a) if (a[k] !== void 0) aCount++;
+		let bCount = 0;
+		for (const k in b) if (!ignoreUndefined || b[k] !== void 0) {
+			bCount++;
+			if (bCount > aCount || !deepEqual(a[k], b[k], opts)) return false;
+		}
+		return aCount === bCount;
+	}
+	return false;
+}
+function createControlledPromise(onResolve) {
+	let resolveLoadPromise;
+	let rejectLoadPromise;
+	const controlledPromise = new Promise((resolve, reject) => {
+		resolveLoadPromise = resolve;
+		rejectLoadPromise = reject;
+	});
+	controlledPromise.status = "pending";
+	controlledPromise.resolve = (value) => {
+		controlledPromise.status = "resolved";
+		controlledPromise.value = value;
+		resolveLoadPromise(value);
+		onResolve?.(value);
+	};
+	controlledPromise.reject = (e) => {
+		controlledPromise.status = "rejected";
+		rejectLoadPromise(e);
+	};
+	return controlledPromise;
+}
+function isModuleNotFoundError(error) {
+	if (typeof error?.message !== "string") return false;
+	return error.message.startsWith("Failed to fetch dynamically imported module") || error.message.startsWith("error loading dynamically imported module") || error.message.startsWith("Importing a module script failed");
+}
+function isPromise(value) {
+	return Boolean(value && typeof value === "object" && typeof value.then === "function");
+}
+function findLast(array, predicate) {
+	for (let i = array.length - 1; i >= 0; i--) {
+		const item = array[i];
+		if (predicate(item)) return item;
+	}
+}
+function decodeSegment(segment) {
+	try {
+		return decodeURI(segment);
+	} catch {
+		return segment.replaceAll(/%[0-9A-F]{2}/gi, (match) => {
+			try {
+				return decodeURI(match);
+			} catch {
+				return match;
+			}
+		});
+	}
+}
+function decodePath(path, decodeIgnore) {
+	if (!path) return path;
+	const re = decodeIgnore ? new RegExp(`${decodeIgnore.join("|")}`, "gi") : /%25|%5C/gi;
+	let cursor = 0;
+	let result = "";
+	let match;
+	while (null !== (match = re.exec(path))) {
+		result += decodeSegment(path.slice(cursor, match.index)) + match[0];
+		cursor = re.lastIndex;
+	}
+	return result + decodeSegment(cursor ? path.slice(cursor) : path);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/tiny-invariant@1.3.3/node_modules/tiny-invariant/dist/esm/tiny-invariant.js
+var isProduction$1 = process.env.NODE_ENV === "production";
+var prefix = "Invariant failed";
+function invariant(condition, message) {
+	if (condition) return;
+	if (isProduction$1) throw new Error(prefix);
+	var provided = typeof message === "function" ? message() : message;
+	var value = provided ? "".concat(prefix, ": ").concat(provided) : prefix;
+	throw new Error(value);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+router-core@1.143.6/node_modules/@tanstack/router-core/dist/esm/lru-cache.js
+function createLRUCache(max) {
+	const cache = /* @__PURE__ */ new Map();
+	let oldest;
+	let newest;
+	const touch = (entry) => {
+		if (!entry.next) return;
+		if (!entry.prev) {
+			entry.next.prev = void 0;
+			oldest = entry.next;
+			entry.next = void 0;
+			if (newest) {
+				entry.prev = newest;
+				newest.next = entry;
+			}
+		} else {
+			entry.prev.next = entry.next;
+			entry.next.prev = entry.prev;
+			entry.next = void 0;
+			if (newest) {
+				newest.next = entry;
+				entry.prev = newest;
+			}
+		}
+		newest = entry;
+	};
+	return {
+		get(key) {
+			const entry = cache.get(key);
+			if (!entry) return void 0;
+			touch(entry);
+			return entry.value;
+		},
+		set(key, value) {
+			if (cache.size >= max && oldest) {
+				const toDelete = oldest;
+				cache.delete(toDelete.key);
+				if (toDelete.next) {
+					oldest = toDelete.next;
+					toDelete.next.prev = void 0;
+				}
+				if (toDelete === newest) newest = void 0;
+			}
+			const existing = cache.get(key);
+			if (existing) {
+				existing.value = value;
+				touch(existing);
+			} else {
+				const entry = {
+					key,
+					value,
+					prev: newest
+				};
+				if (newest) newest.next = entry;
+				newest = entry;
+				if (!oldest) oldest = entry;
+				cache.set(key, entry);
+			}
+		},
+		clear() {
+			cache.clear();
+			oldest = void 0;
+			newest = void 0;
+		}
+	};
+}
+var SEGMENT_TYPE_INDEX = 4;
+var PARAM_W_CURLY_BRACES_RE = /^([^{]*)\{\$([a-zA-Z_$][a-zA-Z0-9_$]*)\}([^}]*)$/;
+var OPTIONAL_PARAM_W_CURLY_BRACES_RE = /^([^{]*)\{-\$([a-zA-Z_$][a-zA-Z0-9_$]*)\}([^}]*)$/;
+var WILDCARD_W_CURLY_BRACES_RE = /^([^{]*)\{\$\}([^}]*)$/;
+function parseSegment(path, start, output = new Uint16Array(6)) {
+	const next = path.indexOf("/", start);
+	const end = next === -1 ? path.length : next;
+	const part = path.substring(start, end);
+	if (!part || !part.includes("$")) {
+		output[0] = 0;
+		output[1] = start;
+		output[2] = start;
+		output[3] = end;
+		output[4] = end;
+		output[5] = end;
+		return output;
+	}
+	if (part === "$") {
+		const total = path.length;
+		output[0] = 2;
+		output[1] = start;
+		output[2] = start;
+		output[3] = total;
+		output[4] = total;
+		output[5] = total;
+		return output;
+	}
+	if (part.charCodeAt(0) === 36) {
+		output[0] = 1;
+		output[1] = start;
+		output[2] = start + 1;
+		output[3] = end;
+		output[4] = end;
+		output[5] = end;
+		return output;
+	}
+	const wildcardBracesMatch = part.match(WILDCARD_W_CURLY_BRACES_RE);
+	if (wildcardBracesMatch) {
+		const pLength = wildcardBracesMatch[1].length;
+		output[0] = 2;
+		output[1] = start + pLength;
+		output[2] = start + pLength + 1;
+		output[3] = start + pLength + 2;
+		output[4] = start + pLength + 3;
+		output[5] = path.length;
+		return output;
+	}
+	const optionalParamBracesMatch = part.match(OPTIONAL_PARAM_W_CURLY_BRACES_RE);
+	if (optionalParamBracesMatch) {
+		const prefix = optionalParamBracesMatch[1];
+		const paramName = optionalParamBracesMatch[2];
+		const suffix = optionalParamBracesMatch[3];
+		const pLength = prefix.length;
+		output[0] = 3;
+		output[1] = start + pLength;
+		output[2] = start + pLength + 3;
+		output[3] = start + pLength + 3 + paramName.length;
+		output[4] = end - suffix.length;
+		output[5] = end;
+		return output;
+	}
+	const paramBracesMatch = part.match(PARAM_W_CURLY_BRACES_RE);
+	if (paramBracesMatch) {
+		const prefix = paramBracesMatch[1];
+		const paramName = paramBracesMatch[2];
+		const suffix = paramBracesMatch[3];
+		const pLength = prefix.length;
+		output[0] = 1;
+		output[1] = start + pLength;
+		output[2] = start + pLength + 2;
+		output[3] = start + pLength + 2 + paramName.length;
+		output[4] = end - suffix.length;
+		output[5] = end;
+		return output;
+	}
+	output[0] = 0;
+	output[1] = start;
+	output[2] = start;
+	output[3] = end;
+	output[4] = end;
+	output[5] = end;
+	return output;
+}
+function parseSegments(defaultCaseSensitive, data, route, start, node, depth, onRoute) {
+	onRoute?.(route);
+	let cursor = start;
+	{
+		const path = route.fullPath ?? route.from;
+		const length = path.length;
+		const caseSensitive = route.options?.caseSensitive ?? defaultCaseSensitive;
+		while (cursor < length) {
+			const segment = parseSegment(path, cursor, data);
+			let nextNode;
+			const start2 = cursor;
+			const end = segment[5];
+			cursor = end + 1;
+			depth++;
+			switch (segment[0]) {
+				case 0: {
+					const value = path.substring(segment[2], segment[3]);
+					if (caseSensitive) {
+						const existingNode = node.static?.get(value);
+						if (existingNode) nextNode = existingNode;
+						else {
+							node.static ??= /* @__PURE__ */ new Map();
+							const next = createStaticNode(route.fullPath ?? route.from);
+							next.parent = node;
+							next.depth = depth;
+							nextNode = next;
+							node.static.set(value, next);
+						}
+					} else {
+						const name = value.toLowerCase();
+						const existingNode = node.staticInsensitive?.get(name);
+						if (existingNode) nextNode = existingNode;
+						else {
+							node.staticInsensitive ??= /* @__PURE__ */ new Map();
+							const next = createStaticNode(route.fullPath ?? route.from);
+							next.parent = node;
+							next.depth = depth;
+							nextNode = next;
+							node.staticInsensitive.set(name, next);
+						}
+					}
+					break;
+				}
+				case 1: {
+					const prefix_raw = path.substring(start2, segment[1]);
+					const suffix_raw = path.substring(segment[4], end);
+					const actuallyCaseSensitive = caseSensitive && !!(prefix_raw || suffix_raw);
+					const prefix = !prefix_raw ? void 0 : actuallyCaseSensitive ? prefix_raw : prefix_raw.toLowerCase();
+					const suffix = !suffix_raw ? void 0 : actuallyCaseSensitive ? suffix_raw : suffix_raw.toLowerCase();
+					const existingNode = node.dynamic?.find((s) => s.caseSensitive === actuallyCaseSensitive && s.prefix === prefix && s.suffix === suffix);
+					if (existingNode) nextNode = existingNode;
+					else {
+						const next = createDynamicNode(1, route.fullPath ?? route.from, actuallyCaseSensitive, prefix, suffix);
+						nextNode = next;
+						next.depth = depth;
+						next.parent = node;
+						node.dynamic ??= [];
+						node.dynamic.push(next);
+					}
+					break;
+				}
+				case 3: {
+					const prefix_raw = path.substring(start2, segment[1]);
+					const suffix_raw = path.substring(segment[4], end);
+					const actuallyCaseSensitive = caseSensitive && !!(prefix_raw || suffix_raw);
+					const prefix = !prefix_raw ? void 0 : actuallyCaseSensitive ? prefix_raw : prefix_raw.toLowerCase();
+					const suffix = !suffix_raw ? void 0 : actuallyCaseSensitive ? suffix_raw : suffix_raw.toLowerCase();
+					const existingNode = node.optional?.find((s) => s.caseSensitive === actuallyCaseSensitive && s.prefix === prefix && s.suffix === suffix);
+					if (existingNode) nextNode = existingNode;
+					else {
+						const next = createDynamicNode(3, route.fullPath ?? route.from, actuallyCaseSensitive, prefix, suffix);
+						nextNode = next;
+						next.parent = node;
+						next.depth = depth;
+						node.optional ??= [];
+						node.optional.push(next);
+					}
+					break;
+				}
+				case 2: {
+					const prefix_raw = path.substring(start2, segment[1]);
+					const suffix_raw = path.substring(segment[4], end);
+					const actuallyCaseSensitive = caseSensitive && !!(prefix_raw || suffix_raw);
+					const prefix = !prefix_raw ? void 0 : actuallyCaseSensitive ? prefix_raw : prefix_raw.toLowerCase();
+					const suffix = !suffix_raw ? void 0 : actuallyCaseSensitive ? suffix_raw : suffix_raw.toLowerCase();
+					const next = createDynamicNode(2, route.fullPath ?? route.from, actuallyCaseSensitive, prefix, suffix);
+					nextNode = next;
+					next.parent = node;
+					next.depth = depth;
+					node.wildcard ??= [];
+					node.wildcard.push(next);
+				}
+			}
+			node = nextNode;
+		}
+		const isLeaf = (route.path || !route.children) && !route.isRoot;
+		if (isLeaf && path.endsWith("/")) {
+			const indexNode = createStaticNode(route.fullPath ?? route.from);
+			indexNode.kind = SEGMENT_TYPE_INDEX;
+			indexNode.parent = node;
+			depth++;
+			indexNode.depth = depth;
+			node.index = indexNode;
+			node = indexNode;
+		}
+		if (isLeaf && !node.route) {
+			node.route = route;
+			node.fullPath = route.fullPath ?? route.from;
+		}
+	}
+	if (route.children) for (const child of route.children) parseSegments(defaultCaseSensitive, data, child, cursor, node, depth, onRoute);
+}
+function sortDynamic(a, b) {
+	if (a.prefix && b.prefix && a.prefix !== b.prefix) {
+		if (a.prefix.startsWith(b.prefix)) return -1;
+		if (b.prefix.startsWith(a.prefix)) return 1;
+	}
+	if (a.suffix && b.suffix && a.suffix !== b.suffix) {
+		if (a.suffix.endsWith(b.suffix)) return -1;
+		if (b.suffix.endsWith(a.suffix)) return 1;
+	}
+	if (a.prefix && !b.prefix) return -1;
+	if (!a.prefix && b.prefix) return 1;
+	if (a.suffix && !b.suffix) return -1;
+	if (!a.suffix && b.suffix) return 1;
+	if (a.caseSensitive && !b.caseSensitive) return -1;
+	if (!a.caseSensitive && b.caseSensitive) return 1;
+	return 0;
+}
+function sortTreeNodes(node) {
+	if (node.static) for (const child of node.static.values()) sortTreeNodes(child);
+	if (node.staticInsensitive) for (const child of node.staticInsensitive.values()) sortTreeNodes(child);
+	if (node.dynamic?.length) {
+		node.dynamic.sort(sortDynamic);
+		for (const child of node.dynamic) sortTreeNodes(child);
+	}
+	if (node.optional?.length) {
+		node.optional.sort(sortDynamic);
+		for (const child of node.optional) sortTreeNodes(child);
+	}
+	if (node.wildcard?.length) {
+		node.wildcard.sort(sortDynamic);
+		for (const child of node.wildcard) sortTreeNodes(child);
+	}
+}
+function createStaticNode(fullPath) {
+	return {
+		kind: 0,
+		depth: 0,
+		index: null,
+		static: null,
+		staticInsensitive: null,
+		dynamic: null,
+		optional: null,
+		wildcard: null,
+		route: null,
+		fullPath,
+		parent: null
+	};
+}
+function createDynamicNode(kind, fullPath, caseSensitive, prefix, suffix) {
+	return {
+		kind,
+		depth: 0,
+		index: null,
+		static: null,
+		staticInsensitive: null,
+		dynamic: null,
+		optional: null,
+		wildcard: null,
+		route: null,
+		fullPath,
+		parent: null,
+		caseSensitive,
+		prefix,
+		suffix
+	};
+}
+function processRouteMasks(routeList, processedTree) {
+	const segmentTree = createStaticNode("/");
+	const data = new Uint16Array(6);
+	for (const route of routeList) parseSegments(false, data, route, 1, segmentTree, 0);
+	sortTreeNodes(segmentTree);
+	processedTree.masksTree = segmentTree;
+	processedTree.flatCache = createLRUCache(1e3);
+}
+function findFlatMatch(path, processedTree) {
+	path ||= "/";
+	const cached = processedTree.flatCache.get(path);
+	if (cached) return cached;
+	const result = findMatch(path, processedTree.masksTree);
+	processedTree.flatCache.set(path, result);
+	return result;
+}
+function findSingleMatch(from, caseSensitive, fuzzy, path, processedTree) {
+	from ||= "/";
+	path ||= "/";
+	const key = caseSensitive ? `case\0${from}` : from;
+	let tree = processedTree.singleCache.get(key);
+	if (!tree) {
+		tree = createStaticNode("/");
+		parseSegments(caseSensitive, new Uint16Array(6), { from }, 1, tree, 0);
+		processedTree.singleCache.set(key, tree);
+	}
+	return findMatch(path, tree, fuzzy);
+}
+function findRouteMatch(path, processedTree, fuzzy = false) {
+	const key = fuzzy ? path : `nofuzz\0${path}`;
+	const cached = processedTree.matchCache.get(key);
+	if (cached !== void 0) return cached;
+	path ||= "/";
+	const result = findMatch(path, processedTree.segmentTree, fuzzy);
+	if (result) result.branch = buildRouteBranch(result.route);
+	processedTree.matchCache.set(key, result);
+	return result;
+}
+function trimPathRight$1(path) {
+	return path === "/" ? path : path.replace(/\/{1,}$/, "");
+}
+function processRouteTree(routeTree, caseSensitive = false, initRoute) {
+	const segmentTree = createStaticNode(routeTree.fullPath);
+	const data = new Uint16Array(6);
+	const routesById = {};
+	const routesByPath = {};
+	let index = 0;
+	parseSegments(caseSensitive, data, routeTree, 1, segmentTree, 0, (route) => {
+		initRoute?.(route, index);
+		invariant(!(route.id in routesById), `Duplicate routes found with id: ${String(route.id)}`);
+		routesById[route.id] = route;
+		if (index !== 0 && route.path) {
+			const trimmedFullPath = trimPathRight$1(route.fullPath);
+			if (!routesByPath[trimmedFullPath] || route.fullPath.endsWith("/")) routesByPath[trimmedFullPath] = route;
+		}
+		index++;
+	});
+	sortTreeNodes(segmentTree);
+	return {
+		processedTree: {
+			segmentTree,
+			singleCache: createLRUCache(1e3),
+			matchCache: createLRUCache(1e3),
+			flatCache: null,
+			masksTree: null
+		},
+		routesById,
+		routesByPath
+	};
+}
+function findMatch(path, segmentTree, fuzzy = false) {
+	const parts = path.split("/");
+	const leaf = getNodeMatch(path, parts, segmentTree, fuzzy);
+	if (!leaf) return null;
+	const params = extractParams(path, parts, leaf);
+	if ("**" in leaf) params["**"] = leaf["**"];
+	return {
+		route: leaf.node.route,
+		params
+	};
+}
+function extractParams(path, parts, leaf) {
+	const list = buildBranch(leaf.node);
+	let nodeParts = null;
+	const params = {};
+	for (let partIndex = 0, nodeIndex = 0, pathIndex = 0; nodeIndex < list.length; partIndex++, nodeIndex++, pathIndex++) {
+		const node = list[nodeIndex];
+		const part = parts[partIndex];
+		const currentPathIndex = pathIndex;
+		if (part) pathIndex += part.length;
+		if (node.kind === 1) {
+			nodeParts ??= leaf.node.fullPath.split("/");
+			const nodePart = nodeParts[nodeIndex];
+			const preLength = node.prefix?.length ?? 0;
+			if (nodePart.charCodeAt(preLength) === 123) {
+				const sufLength = node.suffix?.length ?? 0;
+				const name = nodePart.substring(preLength + 2, nodePart.length - sufLength - 1);
+				const value = part.substring(preLength, part.length - sufLength);
+				params[name] = decodeURIComponent(value);
+			} else {
+				const name = nodePart.substring(1);
+				params[name] = decodeURIComponent(part);
+			}
+		} else if (node.kind === 3) {
+			if (leaf.skipped & 1 << nodeIndex) {
+				partIndex--;
+				continue;
+			}
+			nodeParts ??= leaf.node.fullPath.split("/");
+			const nodePart = nodeParts[nodeIndex];
+			const preLength = node.prefix?.length ?? 0;
+			const sufLength = node.suffix?.length ?? 0;
+			const name = nodePart.substring(preLength + 3, nodePart.length - sufLength - 1);
+			const value = node.suffix || node.prefix ? part.substring(preLength, part.length - sufLength) : part;
+			if (value) params[name] = decodeURIComponent(value);
+		} else if (node.kind === 2) {
+			const n = node;
+			const value = path.substring(currentPathIndex + (n.prefix?.length ?? 0), path.length - (n.suffix?.length ?? 0));
+			const splat = decodeURIComponent(value);
+			params["*"] = splat;
+			params._splat = splat;
+			break;
+		}
+	}
+	return params;
+}
+function buildRouteBranch(route) {
+	const list = [route];
+	while (route.parentRoute) {
+		route = route.parentRoute;
+		list.push(route);
+	}
+	list.reverse();
+	return list;
+}
+function buildBranch(node) {
+	const list = Array(node.depth + 1);
+	do {
+		list[node.depth] = node;
+		node = node.parent;
+	} while (node);
+	return list;
+}
+function getNodeMatch(path, parts, segmentTree, fuzzy) {
+	if (path === "/" && segmentTree.index) return {
+		node: segmentTree.index,
+		skipped: 0
+	};
+	const trailingSlash = !last(parts);
+	const pathIsIndex = trailingSlash && path !== "/";
+	const partsLength = parts.length - (trailingSlash ? 1 : 0);
+	const stack = [{
+		node: segmentTree,
+		index: 1,
+		skipped: 0,
+		depth: 1,
+		statics: 1,
+		dynamics: 0,
+		optionals: 0
+	}];
+	let wildcardMatch = null;
+	let bestFuzzy = null;
+	let bestMatch = null;
+	while (stack.length) {
+		const frame = stack.pop();
+		let { node, index, skipped, depth, statics, dynamics, optionals } = frame;
+		if (fuzzy && node.route && node.kind !== SEGMENT_TYPE_INDEX && isFrameMoreSpecific(bestFuzzy, frame)) bestFuzzy = frame;
+		const isBeyondPath = index === partsLength;
+		if (isBeyondPath) {
+			if (node.route && !pathIsIndex && isFrameMoreSpecific(bestMatch, frame)) bestMatch = frame;
+			if (!node.optional && !node.wildcard && !node.index) continue;
+		}
+		const part = isBeyondPath ? void 0 : parts[index];
+		let lowerPart;
+		if (isBeyondPath && node.index) {
+			const indexFrame = {
+				node: node.index,
+				index,
+				skipped,
+				depth: depth + 1,
+				statics,
+				dynamics,
+				optionals
+			};
+			if (statics === partsLength && !dynamics && !optionals && !skipped) return indexFrame;
+			if (isFrameMoreSpecific(bestMatch, indexFrame)) bestMatch = indexFrame;
+		}
+		if (node.wildcard && isFrameMoreSpecific(wildcardMatch, frame)) for (const segment of node.wildcard) {
+			const { prefix, suffix } = segment;
+			if (prefix) {
+				if (isBeyondPath) continue;
+				if (!(segment.caseSensitive ? part : lowerPart ??= part.toLowerCase()).startsWith(prefix)) continue;
+			}
+			if (suffix) {
+				if (isBeyondPath) continue;
+				const end = parts.slice(index).join("/").slice(-suffix.length);
+				if ((segment.caseSensitive ? end : end.toLowerCase()) !== suffix) continue;
+			}
+			wildcardMatch = {
+				node: segment,
+				index: partsLength,
+				skipped,
+				depth,
+				statics,
+				dynamics,
+				optionals
+			};
+			break;
+		}
+		if (node.optional) {
+			const nextSkipped = skipped | 1 << depth;
+			const nextDepth = depth + 1;
+			for (let i = node.optional.length - 1; i >= 0; i--) {
+				const segment = node.optional[i];
+				stack.push({
+					node: segment,
+					index,
+					skipped: nextSkipped,
+					depth: nextDepth,
+					statics,
+					dynamics,
+					optionals
+				});
+			}
+			if (!isBeyondPath) for (let i = node.optional.length - 1; i >= 0; i--) {
+				const segment = node.optional[i];
+				const { prefix, suffix } = segment;
+				if (prefix || suffix) {
+					const casePart = segment.caseSensitive ? part : lowerPart ??= part.toLowerCase();
+					if (prefix && !casePart.startsWith(prefix)) continue;
+					if (suffix && !casePart.endsWith(suffix)) continue;
+				}
+				stack.push({
+					node: segment,
+					index: index + 1,
+					skipped,
+					depth: nextDepth,
+					statics,
+					dynamics,
+					optionals: optionals + 1
+				});
+			}
+		}
+		if (!isBeyondPath && node.dynamic && part) for (let i = node.dynamic.length - 1; i >= 0; i--) {
+			const segment = node.dynamic[i];
+			const { prefix, suffix } = segment;
+			if (prefix || suffix) {
+				const casePart = segment.caseSensitive ? part : lowerPart ??= part.toLowerCase();
+				if (prefix && !casePart.startsWith(prefix)) continue;
+				if (suffix && !casePart.endsWith(suffix)) continue;
+			}
+			stack.push({
+				node: segment,
+				index: index + 1,
+				skipped,
+				depth: depth + 1,
+				statics,
+				dynamics: dynamics + 1,
+				optionals
+			});
+		}
+		if (!isBeyondPath && node.staticInsensitive) {
+			const match = node.staticInsensitive.get(lowerPart ??= part.toLowerCase());
+			if (match) stack.push({
+				node: match,
+				index: index + 1,
+				skipped,
+				depth: depth + 1,
+				statics: statics + 1,
+				dynamics,
+				optionals
+			});
+		}
+		if (!isBeyondPath && node.static) {
+			const match = node.static.get(part);
+			if (match) stack.push({
+				node: match,
+				index: index + 1,
+				skipped,
+				depth: depth + 1,
+				statics: statics + 1,
+				dynamics,
+				optionals
+			});
+		}
+	}
+	if (bestMatch && wildcardMatch) return isFrameMoreSpecific(wildcardMatch, bestMatch) ? bestMatch : wildcardMatch;
+	if (bestMatch) return bestMatch;
+	if (wildcardMatch) return wildcardMatch;
+	if (fuzzy && bestFuzzy) {
+		let sliceIndex = bestFuzzy.index;
+		for (let i = 0; i < bestFuzzy.index; i++) sliceIndex += parts[i].length;
+		const splat = sliceIndex === path.length ? "/" : path.slice(sliceIndex);
+		return {
+			node: bestFuzzy.node,
+			skipped: bestFuzzy.skipped,
+			"**": decodeURIComponent(splat)
+		};
+	}
+	return null;
+}
+function isFrameMoreSpecific(prev, next) {
+	if (!prev) return true;
+	return next.statics > prev.statics || next.statics === prev.statics && (next.dynamics > prev.dynamics || next.dynamics === prev.dynamics && (next.optionals > prev.optionals || next.optionals === prev.optionals && ((next.node.kind === SEGMENT_TYPE_INDEX) > (prev.node.kind === SEGMENT_TYPE_INDEX) || next.node.kind === SEGMENT_TYPE_INDEX === (prev.node.kind === SEGMENT_TYPE_INDEX) && next.depth > prev.depth)));
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+router-core@1.143.6/node_modules/@tanstack/router-core/dist/esm/path.js
+function joinPaths(paths) {
+	return cleanPath(paths.filter((val) => {
+		return val !== void 0;
+	}).join("/"));
+}
+function cleanPath(path) {
+	return path.replace(/\/{2,}/g, "/");
+}
+function trimPathLeft(path) {
+	return path === "/" ? path : path.replace(/^\/{1,}/, "");
+}
+function trimPathRight(path) {
+	const len = path.length;
+	return len > 1 && path[len - 1] === "/" ? path.replace(/\/{1,}$/, "") : path;
+}
+function trimPath(path) {
+	return trimPathRight(trimPathLeft(path));
+}
+function removeTrailingSlash(value, basepath) {
+	if (value?.endsWith("/") && value !== "/" && value !== `${basepath}/`) return value.slice(0, -1);
+	return value;
+}
+function exactPathTest(pathName1, pathName2, basepath) {
+	return removeTrailingSlash(pathName1, basepath) === removeTrailingSlash(pathName2, basepath);
+}
+function resolvePath({ base, to, trailingSlash = "never", cache }) {
+	const isAbsolute = to.startsWith("/");
+	const isBase = !isAbsolute && to === ".";
+	let key;
+	if (cache) {
+		key = isAbsolute ? to : isBase ? base : base + "\0" + to;
+		const cached = cache.get(key);
+		if (cached) return cached;
+	}
+	let baseSegments;
+	if (isBase) baseSegments = base.split("/");
+	else if (isAbsolute) baseSegments = to.split("/");
+	else {
+		baseSegments = base.split("/");
+		while (baseSegments.length > 1 && last(baseSegments) === "") baseSegments.pop();
+		const toSegments = to.split("/");
+		for (let index = 0, length = toSegments.length; index < length; index++) {
+			const value = toSegments[index];
+			if (value === "") {
+				if (!index) baseSegments = [value];
+				else if (index === length - 1) baseSegments.push(value);
+			} else if (value === "..") baseSegments.pop();
+			else if (value === ".");
+			else baseSegments.push(value);
+		}
+	}
+	if (baseSegments.length > 1) {
+		if (last(baseSegments) === "") {
+			if (trailingSlash === "never") baseSegments.pop();
+		} else if (trailingSlash === "always") baseSegments.push("");
+	}
+	let segment;
+	let joined = "";
+	for (let i = 0; i < baseSegments.length; i++) {
+		if (i > 0) joined += "/";
+		const part = baseSegments[i];
+		if (!part) continue;
+		segment = parseSegment(part, 0, segment);
+		const kind = segment[0];
+		if (kind === 0) {
+			joined += part;
+			continue;
+		}
+		const end = segment[5];
+		const prefix = part.substring(0, segment[1]);
+		const suffix = part.substring(segment[4], end);
+		const value = part.substring(segment[2], segment[3]);
+		if (kind === 1) joined += prefix || suffix ? `${prefix}{$${value}}${suffix}` : `$${value}`;
+		else if (kind === 2) joined += prefix || suffix ? `${prefix}{$}${suffix}` : "$";
+		else joined += `${prefix}{-$${value}}${suffix}`;
+	}
+	joined = cleanPath(joined);
+	const result = joined || "/";
+	if (key && cache) cache.set(key, result);
+	return result;
+}
+function encodeParam(key, params, decodeCharMap) {
+	const value = params[key];
+	if (typeof value !== "string") return value;
+	if (key === "_splat") return encodeURI(value);
+	else return encodePathParam(value, decodeCharMap);
+}
+function interpolatePath({ path, params, decodeCharMap }) {
+	let isMissingParams = false;
+	const usedParams = {};
+	if (!path || path === "/") return {
+		interpolatedPath: "/",
+		usedParams,
+		isMissingParams
+	};
+	if (!path.includes("$")) return {
+		interpolatedPath: path,
+		usedParams,
+		isMissingParams
+	};
+	const length = path.length;
+	let cursor = 0;
+	let segment;
+	let joined = "";
+	while (cursor < length) {
+		const start = cursor;
+		segment = parseSegment(path, start, segment);
+		const end = segment[5];
+		cursor = end + 1;
+		if (start === end) continue;
+		const kind = segment[0];
+		if (kind === 0) {
+			joined += "/" + path.substring(start, end);
+			continue;
+		}
+		if (kind === 2) {
+			const splat = params._splat;
+			usedParams._splat = splat;
+			usedParams["*"] = splat;
+			const prefix = path.substring(start, segment[1]);
+			const suffix = path.substring(segment[4], end);
+			if (!splat) {
+				isMissingParams = true;
+				if (prefix || suffix) joined += "/" + prefix + suffix;
+				continue;
+			}
+			const value = encodeParam("_splat", params, decodeCharMap);
+			joined += "/" + prefix + value + suffix;
+			continue;
+		}
+		if (kind === 1) {
+			const key = path.substring(segment[2], segment[3]);
+			if (!isMissingParams && !(key in params)) isMissingParams = true;
+			usedParams[key] = params[key];
+			const prefix = path.substring(start, segment[1]);
+			const suffix = path.substring(segment[4], end);
+			const value = encodeParam(key, params, decodeCharMap) ?? "undefined";
+			joined += "/" + prefix + value + suffix;
+			continue;
+		}
+		if (kind === 3) {
+			const key = path.substring(segment[2], segment[3]);
+			const valueRaw = params[key];
+			if (valueRaw == null) continue;
+			usedParams[key] = valueRaw;
+			const prefix = path.substring(start, segment[1]);
+			const suffix = path.substring(segment[4], end);
+			const value = encodeParam(key, params, decodeCharMap) ?? "";
+			joined += "/" + prefix + value + suffix;
+			continue;
+		}
+	}
+	if (path.endsWith("/")) joined += "/";
+	return {
+		usedParams,
+		interpolatedPath: joined || "/",
+		isMissingParams
+	};
+}
+function encodePathParam(value, decodeCharMap) {
+	let encoded = encodeURIComponent(value);
+	if (decodeCharMap) for (const [encodedChar, char] of decodeCharMap) encoded = encoded.replaceAll(encodedChar, char);
+	return encoded;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+router-core@1.143.6/node_modules/@tanstack/router-core/dist/esm/not-found.js
+function isNotFound(obj) {
+	return !!obj?.isNotFound;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+router-core@1.143.6/node_modules/@tanstack/router-core/dist/esm/root.js
+var rootRouteId = "__root__";
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+router-core@1.143.6/node_modules/@tanstack/router-core/dist/esm/link.js
+var preloadWarning = "Error preloading route! ☝️";
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+router-core@1.143.6/node_modules/@tanstack/router-core/dist/esm/route.js
+var BaseRoute = class {
+	constructor(options) {
+		this.init = (opts) => {
+			this.originalIndex = opts.originalIndex;
+			const options2 = this.options;
+			const isRoot = !options2?.path && !options2?.id;
+			this.parentRoute = this.options.getParentRoute?.();
+			if (isRoot) this._path = rootRouteId;
+			else if (!this.parentRoute) invariant(false, `Child Route instances must pass a 'getParentRoute: () => ParentRoute' option that returns a Route instance.`);
+			let path = isRoot ? rootRouteId : options2?.path;
+			if (path && path !== "/") path = trimPathLeft(path);
+			const customId = options2?.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 = 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 = (options2) => {
+			Object.assign(this.options, options2);
+			return this;
+		};
+		this.update = (options2) => {
+			Object.assign(this.options, options2);
+			return this;
+		};
+		this.lazy = (lazyFn) => {
+			this.lazyFn = lazyFn;
+			return this;
+		};
+		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.`);
+	}
+	get to() {
+		return this._to;
+	}
+	get id() {
+		return this._id;
+	}
+	get path() {
+		return this._path;
+	}
+	get fullPath() {
+		return this._fullPath;
+	}
+};
+var BaseRootRoute = class extends BaseRoute {
+	constructor(options) {
+		super(options);
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/tiny-warning@1.0.3/node_modules/tiny-warning/dist/tiny-warning.esm.js
+var isProduction = process.env.NODE_ENV === "production";
+function warning(condition, message) {
+	if (!isProduction) {
+		if (condition) return;
+		var text = "Warning: " + message;
+		if (typeof console !== "undefined") console.warn(text);
+		try {
+			throw Error(text);
+		} catch (x) {}
+	}
+}
+//#endregion
+//#region ../../node_modules/.pnpm/use-sync-external-store@1.6.0_react@19.2.4/node_modules/use-sync-external-store/cjs/use-sync-external-store-shim/with-selector.production.js
+/**
+* @license React
+* use-sync-external-store-shim/with-selector.production.js
+*
+* Copyright (c) Meta Platforms, Inc. and affiliates.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+var require_with_selector_production = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var React = require_react(), shim = require_shim();
+	function is(x, y) {
+		return x === y && (0 !== x || 1 / x === 1 / y) || x !== x && y !== y;
+	}
+	var objectIs = "function" === typeof Object.is ? Object.is : is, useSyncExternalStore = shim.useSyncExternalStore, useRef = React.useRef, useEffect = React.useEffect, useMemo = React.useMemo, useDebugValue = React.useDebugValue;
+	exports.useSyncExternalStoreWithSelector = function(subscribe, getSnapshot, getServerSnapshot, selector, isEqual) {
+		var instRef = useRef(null);
+		if (null === instRef.current) {
+			var inst = {
+				hasValue: !1,
+				value: null
+			};
+			instRef.current = inst;
+		} else inst = instRef.current;
+		instRef = useMemo(function() {
+			function memoizedSelector(nextSnapshot) {
+				if (!hasMemo) {
+					hasMemo = !0;
+					memoizedSnapshot = nextSnapshot;
+					nextSnapshot = selector(nextSnapshot);
+					if (void 0 !== isEqual && inst.hasValue) {
+						var currentSelection = inst.value;
+						if (isEqual(currentSelection, nextSnapshot)) return memoizedSelection = currentSelection;
+					}
+					return memoizedSelection = nextSnapshot;
+				}
+				currentSelection = memoizedSelection;
+				if (objectIs(memoizedSnapshot, nextSnapshot)) return currentSelection;
+				var nextSelection = selector(nextSnapshot);
+				if (void 0 !== isEqual && isEqual(currentSelection, nextSelection)) return memoizedSnapshot = nextSnapshot, currentSelection;
+				memoizedSnapshot = nextSnapshot;
+				return memoizedSelection = nextSelection;
+			}
+			var hasMemo = !1, memoizedSnapshot, memoizedSelection, maybeGetServerSnapshot = void 0 === getServerSnapshot ? null : getServerSnapshot;
+			return [function() {
+				return memoizedSelector(getSnapshot());
+			}, null === maybeGetServerSnapshot ? void 0 : function() {
+				return memoizedSelector(maybeGetServerSnapshot());
+			}];
+		}, [
+			getSnapshot,
+			getServerSnapshot,
+			selector,
+			isEqual
+		]);
+		var value = useSyncExternalStore(subscribe, instRef[0], instRef[1]);
+		useEffect(function() {
+			inst.hasValue = !0;
+			inst.value = value;
+		}, [value]);
+		useDebugValue(value);
+		return value;
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/use-sync-external-store@1.6.0_react@19.2.4/node_modules/use-sync-external-store/cjs/use-sync-external-store-shim/with-selector.development.js
+/**
+* @license React
+* use-sync-external-store-shim/with-selector.development.js
+*
+* Copyright (c) Meta Platforms, Inc. and affiliates.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+var require_with_selector_development = /* @__PURE__ */ __commonJSMin(((exports) => {
+	"production" !== process.env.NODE_ENV && (function() {
+		function is(x, y) {
+			return x === y && (0 !== x || 1 / x === 1 / y) || x !== x && y !== y;
+		}
+		"undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+		var React = require_react(), shim = require_shim(), objectIs = "function" === typeof Object.is ? Object.is : is, useSyncExternalStore = shim.useSyncExternalStore, useRef = React.useRef, useEffect = React.useEffect, useMemo = React.useMemo, useDebugValue = React.useDebugValue;
+		exports.useSyncExternalStoreWithSelector = function(subscribe, getSnapshot, getServerSnapshot, selector, isEqual) {
+			var instRef = useRef(null);
+			if (null === instRef.current) {
+				var inst = {
+					hasValue: !1,
+					value: null
+				};
+				instRef.current = inst;
+			} else inst = instRef.current;
+			instRef = useMemo(function() {
+				function memoizedSelector(nextSnapshot) {
+					if (!hasMemo) {
+						hasMemo = !0;
+						memoizedSnapshot = nextSnapshot;
+						nextSnapshot = selector(nextSnapshot);
+						if (void 0 !== isEqual && inst.hasValue) {
+							var currentSelection = inst.value;
+							if (isEqual(currentSelection, nextSnapshot)) return memoizedSelection = currentSelection;
+						}
+						return memoizedSelection = nextSnapshot;
+					}
+					currentSelection = memoizedSelection;
+					if (objectIs(memoizedSnapshot, nextSnapshot)) return currentSelection;
+					var nextSelection = selector(nextSnapshot);
+					if (void 0 !== isEqual && isEqual(currentSelection, nextSelection)) return memoizedSnapshot = nextSnapshot, currentSelection;
+					memoizedSnapshot = nextSnapshot;
+					return memoizedSelection = nextSelection;
+				}
+				var hasMemo = !1, memoizedSnapshot, memoizedSelection, maybeGetServerSnapshot = void 0 === getServerSnapshot ? null : getServerSnapshot;
+				return [function() {
+					return memoizedSelector(getSnapshot());
+				}, null === maybeGetServerSnapshot ? void 0 : function() {
+					return memoizedSelector(maybeGetServerSnapshot());
+				}];
+			}, [
+				getSnapshot,
+				getServerSnapshot,
+				selector,
+				isEqual
+			]);
+			var value = useSyncExternalStore(subscribe, instRef[0], instRef[1]);
+			useEffect(function() {
+				inst.hasValue = !0;
+				inst.value = value;
+			}, [value]);
+			useDebugValue(value);
+			return value;
+		};
+		"undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+	})();
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+react-store@0.8.1_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@tanstack/react-store/dist/esm/index.js
+var import_with_selector = (/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	if (process.env.NODE_ENV === "production") module.exports = require_with_selector_production();
+	else module.exports = require_with_selector_development();
+})))();
+function useStore(store, selector = (d) => d, options = {}) {
+	const equal = options.equal ?? shallow;
+	return (0, import_with_selector.useSyncExternalStoreWithSelector)(store.subscribe, () => store.state, () => store.state, selector, equal);
+}
+function shallow(objA, objB) {
+	if (Object.is(objA, objB)) return true;
+	if (typeof objA !== "object" || objA === null || typeof objB !== "object" || objB === null) return false;
+	if (objA instanceof Map && objB instanceof Map) {
+		if (objA.size !== objB.size) return false;
+		for (const [k, v] of objA) if (!objB.has(k) || !Object.is(v, objB.get(k))) return false;
+		return true;
+	}
+	if (objA instanceof Set && objB instanceof Set) {
+		if (objA.size !== objB.size) return false;
+		for (const v of objA) if (!objB.has(v)) return false;
+		return true;
+	}
+	if (objA instanceof Date && objB instanceof Date) {
+		if (objA.getTime() !== objB.getTime()) return false;
+		return true;
+	}
+	const keysA = getOwnKeys(objA);
+	if (keysA.length !== getOwnKeys(objB).length) return false;
+	for (let i = 0; i < keysA.length; i++) if (!Object.prototype.hasOwnProperty.call(objB, keysA[i]) || !Object.is(objA[keysA[i]], objB[keysA[i]])) return false;
+	return true;
+}
+function getOwnKeys(obj) {
+	return Object.keys(obj).concat(Object.getOwnPropertySymbols(obj));
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+react-router@1.143.11_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@tanstack/react-router/dist/esm/routerContext.js
+var import_react = /* @__PURE__ */ __toESM(require_react(), 1);
+var routerContext = import_react.createContext(null);
+function getRouterContext() {
+	if (typeof document === "undefined") return routerContext;
+	if (window.__TSR_ROUTER_CONTEXT__) return window.__TSR_ROUTER_CONTEXT__;
+	window.__TSR_ROUTER_CONTEXT__ = routerContext;
+	return routerContext;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+react-router@1.143.11_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@tanstack/react-router/dist/esm/useRouter.js
+function useRouter(opts) {
+	const value = import_react.useContext(getRouterContext());
+	warning(!((opts?.warn ?? true) && !value), "useRouter must be used inside a <RouterProvider> component!");
+	return value;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+react-router@1.143.11_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@tanstack/react-router/dist/esm/useRouterState.js
+function useRouterState(opts) {
+	const contextRouter = useRouter({ warn: opts?.router === void 0 });
+	const router = opts?.router || contextRouter;
+	const previousResult = (0, import_react.useRef)(void 0);
+	return useStore(router.__store, (state) => {
+		if (opts?.select) {
+			if (opts.structuralSharing ?? router.options.defaultStructuralSharing) {
+				const newSlice = replaceEqualDeep(previousResult.current, opts.select(state));
+				previousResult.current = newSlice;
+				return newSlice;
+			}
+			return opts.select(state);
+		}
+		return state;
+	});
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+react-router@1.143.11_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@tanstack/react-router/dist/esm/matchContext.js
+var matchContext = import_react.createContext(void 0);
+var dummyMatchContext = import_react.createContext(void 0);
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+react-router@1.143.11_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@tanstack/react-router/dist/esm/useMatch.js
+function useMatch(opts) {
+	const nearestMatchId = import_react.useContext(opts.from ? dummyMatchContext : matchContext);
+	return useRouterState({
+		select: (state) => {
+			const match = state.matches.find((d) => opts.from ? opts.from === d.routeId : d.id === nearestMatchId);
+			invariant(!((opts.shouldThrow ?? true) && !match), `Could not find ${opts.from ? `an active match from "${opts.from}"` : "a nearest match!"}`);
+			if (match === void 0) return;
+			return opts.select ? opts.select(match) : match;
+		},
+		structuralSharing: opts.structuralSharing
+	});
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+react-router@1.143.11_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@tanstack/react-router/dist/esm/useLoaderData.js
+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/.pnpm/@tanstack+react-router@1.143.11_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@tanstack/react-router/dist/esm/useLoaderDeps.js
+function useLoaderDeps(opts) {
+	const { select, ...rest } = opts;
+	return useMatch({
+		...rest,
+		select: (s) => {
+			return select ? select(s.loaderDeps) : s.loaderDeps;
+		}
+	});
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+react-router@1.143.11_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@tanstack/react-router/dist/esm/useParams.js
+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/.pnpm/@tanstack+react-router@1.143.11_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@tanstack/react-router/dist/esm/useSearch.js
+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/.pnpm/@tanstack+react-router@1.143.11_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@tanstack/react-router/dist/esm/utils.js
+var useLayoutEffect = typeof window !== "undefined" ? import_react.useLayoutEffect : import_react.useEffect;
+function usePrevious(value) {
+	const ref = import_react.useRef({
+		value,
+		prev: null
+	});
+	const current = ref.current.value;
+	if (value !== current) ref.current = {
+		value,
+		prev: current
+	};
+	return ref.current.prev;
+}
+function useIntersectionObserver(ref, callback, intersectionObserverOptions = {}, options = {}) {
+	import_react.useEffect(() => {
+		if (!ref.current || options.disabled || typeof IntersectionObserver !== "function") return;
+		const observer = new IntersectionObserver(([entry]) => {
+			callback(entry);
+		}, intersectionObserverOptions);
+		observer.observe(ref.current);
+		return () => {
+			observer.disconnect();
+		};
+	}, [
+		callback,
+		intersectionObserverOptions,
+		options.disabled,
+		ref
+	]);
+}
+function useForwardedRef(ref) {
+	const innerRef = import_react.useRef(null);
+	import_react.useImperativeHandle(ref, () => innerRef.current, []);
+	return innerRef;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+react-router@1.143.11_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@tanstack/react-router/dist/esm/useNavigate.js
+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/.pnpm/@tanstack+react-router@1.143.11_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@tanstack/react-router/dist/esm/link.js
+var import_jsx_runtime = require_jsx_runtime();
+var import_react_dom = /* @__PURE__ */ __toESM(require_react_dom(), 1);
+function useLinkProps(options, forwardedRef) {
+	const router = useRouter();
+	const [isTransitioning, setIsTransitioning] = import_react.useState(false);
+	const hasRenderFetched = import_react.useRef(false);
+	const innerRef = useForwardedRef(forwardedRef);
+	const { activeProps, inactiveProps, activeOptions, to, preload: userPreload, preloadDelay: userPreloadDelay, hashScrollIntoView, replace, startTransition, resetScroll, viewTransition, children, target, disabled, style, className, onClick, 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 currentSearch = useRouterState({
+		select: (s) => s.location.search,
+		structuralSharing: true
+	});
+	const from = options.from;
+	const _options = import_react.useMemo(() => {
+		return {
+			...options,
+			from
+		};
+	}, [
+		router,
+		currentSearch,
+		from,
+		options._fromLocation,
+		options.hash,
+		options.to,
+		options.search,
+		options.params,
+		options.state,
+		options.mask,
+		options.unsafeRelative
+	]);
+	const next = import_react.useMemo(() => router.buildLocation({ ..._options }), [router, _options]);
+	const hrefOption = import_react.useMemo(() => {
+		if (disabled) return;
+		let href = next.maskedLocation ? next.maskedLocation.url.href : next.url.href;
+		let external = false;
+		if (router.origin) if (href.startsWith(router.origin)) href = router.history.createHref(href.replace(router.origin, "")) || "/";
+		else external = true;
+		return {
+			href,
+			external
+		};
+	}, [
+		disabled,
+		next.maskedLocation,
+		next.url,
+		router.origin,
+		router.history
+	]);
+	const externalLink = import_react.useMemo(() => {
+		if (hrefOption?.external) return hrefOption.href;
+		try {
+			new URL(to);
+			return to;
+		} catch {}
+	}, [to, hrefOption]);
+	const preload = options.reloadDocument || externalLink ? false : userPreload ?? router.options.defaultPreload;
+	const preloadDelay = userPreloadDelay ?? router.options.defaultPreloadDelay ?? 0;
+	const isActive = useRouterState({ select: (s) => {
+		if (externalLink) return false;
+		if (activeOptions?.exact) {
+			if (!exactPathTest(s.location.pathname, next.pathname, router.basepath)) return false;
+		} else {
+			const currentPathSplit = removeTrailingSlash(s.location.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(s.location.search, next.search, {
+				partial: !activeOptions?.exact,
+				ignoreUndefined: !activeOptions?.explicitUndefined
+			})) return false;
+		}
+		if (activeOptions?.includeHash) return s.location.hash === next.hash;
+		return true;
+	} });
+	const doPreload = import_react.useCallback(() => {
+		router.preloadRoute({ ..._options }).catch((err) => {
+			console.warn(err);
+			console.warn(preloadWarning);
+		});
+	}, [router, _options]);
+	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 },
+		...onFocus && { onFocus },
+		...onMouseEnter && { onMouseEnter },
+		...onMouseLeave && { onMouseLeave },
+		...onTouchStart && { onTouchStart }
+	};
+	const handleFocus = (_) => {
+		if (disabled) return;
+		if (preload) doPreload();
+	};
+	const handleTouchStart = handleFocus;
+	const handleEnter = (e) => {
+		if (disabled || !preload) return;
+		if (!preloadDelay) doPreload();
+		else {
+			const eventTarget = e.target;
+			if (timeoutMap.has(eventTarget)) return;
+			const id = setTimeout(() => {
+				timeoutMap.delete(eventTarget);
+				doPreload();
+			}, preloadDelay);
+			timeoutMap.set(eventTarget, id);
+		}
+	};
+	const handleLeave = (e) => {
+		if (disabled || !preload || !preloadDelay) return;
+		const eventTarget = e.target;
+		const id = timeoutMap.get(eventTarget);
+		if (id) {
+			clearTimeout(id);
+			timeoutMap.delete(eventTarget);
+		}
+	};
+	const resolvedActiveProps = isActive ? functionalUpdate(activeProps, {}) ?? STATIC_ACTIVE_OBJECT : STATIC_EMPTY_OBJECT;
+	const resolvedInactiveProps = isActive ? STATIC_EMPTY_OBJECT : functionalUpdate(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
+	};
+	return {
+		...propsSafeToSpread,
+		...resolvedActiveProps,
+		...resolvedInactiveProps,
+		href: hrefOption?.href,
+		ref: innerRef,
+		onClick: composeHandlers([onClick, handleClick]),
+		onFocus: composeHandlers([onFocus, handleFocus]),
+		onMouseEnter: composeHandlers([onMouseEnter, handleEnter]),
+		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,
+		...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);
+	}
+};
+var Link = import_react.forwardRef((props, ref) => {
+	const { _asChild, ...rest } = props;
+	const { type: _type, ref: innerRef, ...linkProps } = useLinkProps(rest, ref);
+	const children = typeof rest.children === "function" ? rest.children({ isActive: linkProps["data-status"] === "active" }) : rest.children;
+	if (_asChild === void 0) delete linkProps.disabled;
+	return import_react.createElement(_asChild ? _asChild : "a", {
+		...linkProps,
+		ref: innerRef
+	}, children);
+});
+function isCtrlEvent(e) {
+	return !!(e.metaKey || e.altKey || e.ctrlKey || e.shiftKey);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+react-router@1.143.11_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@tanstack/react-router/dist/esm/route.js
+var Route = 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 useMatch({
+				...opts,
+				from: this.id,
+				select: (d) => opts?.select ? opts.select(d.context) : d.context
+			});
+		};
+		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
+			});
+		});
+		this.$$typeof = Symbol.for("react.memo");
+	}
+};
+function createRoute(options) {
+	return new Route(options);
+}
+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 useMatch({
+				...opts,
+				from: this.id,
+				select: (d) => opts?.select ? opts.select(d.context) : d.context
+			});
+		};
+		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
+			});
+		});
+		this.$$typeof = Symbol.for("react.memo");
+	}
+};
+function createRootRoute(options) {
+	return new RootRoute(options);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+react-router@1.143.11_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@tanstack/react-router/dist/esm/fileRoute.js
+function createFileRoute(path) {
+	if (typeof path === "object") return new FileRoute(path, { silent: true }).createRoute(path);
+	return new FileRoute(path, { silent: true }).createRoute;
+}
+var FileRoute = class {
+	constructor(path, _opts) {
+		this.path = path;
+		this.createRoute = (options) => {
+			warning(this.silent, "FileRoute is deprecated and will be removed in the next major version. Use the createFileRoute(path)(options) function instead.");
+			const route = createRoute(options);
+			route.isRoot = false;
+			return route;
+		};
+		this.silent = _opts?.silent;
+	}
+};
+var LazyRoute = class {
+	constructor(opts) {
+		this.useMatch = (opts2) => {
+			return useMatch({
+				select: opts2?.select,
+				from: this.options.id,
+				structuralSharing: opts2?.structuralSharing
+			});
+		};
+		this.useRouteContext = (opts2) => {
+			return useMatch({
+				from: this.options.id,
+				select: (d) => opts2?.select ? opts2.select(d.context) : d.context
+			});
+		};
+		this.useSearch = (opts2) => {
+			return useSearch({
+				select: opts2?.select,
+				structuralSharing: opts2?.structuralSharing,
+				from: this.options.id
+			});
+		};
+		this.useParams = (opts2) => {
+			return useParams({
+				select: opts2?.select,
+				structuralSharing: opts2?.structuralSharing,
+				from: this.options.id
+			});
+		};
+		this.useLoaderDeps = (opts2) => {
+			return useLoaderDeps({
+				...opts2,
+				from: this.options.id
+			});
+		};
+		this.useLoaderData = (opts2) => {
+			return useLoaderData({
+				...opts2,
+				from: this.options.id
+			});
+		};
+		this.useNavigate = () => {
+			return useNavigate({ from: useRouter().routesById[this.options.id].fullPath });
+		};
+		this.options = opts;
+		this.$$typeof = Symbol.for("react.memo");
+	}
+};
+function createLazyFileRoute(id) {
+	if (typeof id === "object") return new LazyRoute(id);
+	return (opts) => new LazyRoute({
+		id,
+		...opts
+	});
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+react-router@1.143.11_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@tanstack/react-router/dist/esm/lazyRouteComponent.js
+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 (import_react.use) import_react.use(load());
+		else throw load();
+		return import_react.createElement(comp, props);
+	};
+	lazyComp.preload = load;
+	return lazyComp;
+}
+//#endregion
+export { decodePath as A, findRouteMatch as C, createLRUCache as D, processRouteTree as E, last as F, replaceEqualDeep as I, findLast as M, functionalUpdate as N, invariant as O, isPromise as P, findFlatMatch as S, processRouteMasks as T, interpolatePath as _, Link as a, trimPath as b, usePrevious as c, useRouter as d, getRouterContext as f, cleanPath as g, isNotFound as h, createRootRouteWithContext as i, deepEqual as j, createControlledPromise as k, matchContext as l, rootRouteId as m, createFileRoute as n, useNavigate as o, warning as p, createLazyFileRoute as r, useLayoutEffect as s, lazyRouteComponent as t, useRouterState as u, joinPaths as v, findSingleMatch as w, trimPathRight as x, resolvePath as y };