https://spicejunction.de/node_modules/.vite/deps/react-router-dom.js?v=46d206a1

1import { injectQuery as __vite__injectQuery } from "/@vite/client";import { createHotContext as __vite__createHotContext } from "/@vite/client";import.meta.hot = __vite__createHotContext("/node_modules/.vite/deps/react-router-dom.js?v=46d206a1");import { o as __toESM, t as __commonJSMin } from "/node_modules/.vite/deps/chunk-olfrzTEO.js?v=46d206a1";
2import { t as require_react } from "/node_modules/.vite/deps/react.js?v=46d206a1";
3import { t as require_react_dom } from "/node_modules/.vite/deps/react-dom.js?v=46d206a1";
4//#region node_modules/react-router/dist/development/chunk-UVKPFVEO.mjs
5var import_react = /* @__PURE__ */ __toESM(require_react(), 1);
6/**
7* react-router v7.13.2
8*
9* Copyright (c) Remix Software Inc.
10*
11* This source code is licensed under the MIT license found in the
12* LICENSE.md file in the root directory of this source tree.
13*
14* @license MIT
15*/
16var __typeError = (msg) => {
17	throw TypeError(msg);
18};
19var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
20var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
21var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
22var Action = /* @__PURE__ */ ((Action2) => {
23	Action2["Pop"] = "POP";
24	Action2["Push"] = "PUSH";
25	Action2["Replace"] = "REPLACE";
26	return Action2;
27})(Action || {});
28var PopStateEventType = "popstate";
29function isLocation(obj) {
30	return typeof obj === "object" && obj != null && "pathname" in obj && "search" in obj && "hash" in obj && "state" in obj && "key" in obj;
31}
32function createMemoryHistory(options = {}) {
33	let { initialEntries = ["/"], initialIndex, v5Compat = false } = options;
34	let entries;
35	entries = initialEntries.map((entry, index2) => createMemoryLocation(entry, typeof entry === "string" ? null : entry.state, index2 === 0 ? "default" : void 0, typeof entry === "string" ? void 0 : entry.unstable_mask));
36	let index = clampIndex(initialIndex == null ? entries.length - 1 : initialIndex);
37	let action = "POP";
38	let listener = null;
39	function clampIndex(n) {
40		return Math.min(Math.max(n, 0), entries.length - 1);
41	}
42	function getCurrentLocation() {
43		return entries[index];
44	}
45	function createMemoryLocation(to, state = null, key, unstable_mask) {
46		let location = createLocation(entries ? getCurrentLocation().pathname : "/", to, state, key, unstable_mask);
47		warning(location.pathname.charAt(0) === "/", `relative pathnames are not supported in memory history: ${JSON.stringify(to)}`);
48		return location;
49	}
50	function createHref2(to) {
51		return typeof to === "string" ? to : createPath(to);
52	}
53	return {
54		get index() {
55			return index;
56		},
57		get action() {
58			return action;
59		},
60		get location() {
61			return getCurrentLocation();
62		},
63		createHref: createHref2,
64		createURL(to) {
65			return new URL(createHref2(to), "http://localhost");
66		},
67		encodeLocation(to) {
68			let path = typeof to === "string" ? parsePath(to) : to;
69			return {
70				pathname: path.pathname || "",
71				search: path.search || "",
72				hash: path.hash || ""
73			};
74		},
75		push(to, state) {
76			action = "PUSH";
77			let nextLocation = isLocation(to) ? to : createMemoryLocation(to, state);
78			index += 1;
79			entries.splice(index, entries.length, nextLocation);
80			if (v5Compat && listener) listener({
81				action,
82				location: nextLocation,
83				delta: 1
84			});
85		},
86		replace(to, state) {
87			action = "REPLACE";
88			let nextLocation = isLocation(to) ? to : createMemoryLocation(to, state);
89			entries[index] = nextLocation;
90			if (v5Compat && listener) listener({
91				action,
92				location: nextLocation,
93				delta: 0
94			});
95		},
96		go(delta) {
97			action = "POP";
98			let nextIndex = clampIndex(index + delta);
99			let nextLocation = entries[nextIndex];
100			index = nextIndex;
101			if (listener) listener({
102				action,
103				location: nextLocation,
104				delta
105			});
106		},
107		listen(fn) {
108			listener = fn;
109			return () => {
110				listener = null;
111			};
112		}
113	};
114}
115function createBrowserHistory(options = {}) {
116	function createBrowserLocation(window2, globalHistory) {
117		let maskedLocation = globalHistory.state?.masked;
118		let { pathname, search, hash } = maskedLocation || window2.location;
119		return createLocation("", {
120			pathname,
121			search,
122			hash
123		}, globalHistory.state && globalHistory.state.usr || null, globalHistory.state && globalHistory.state.key || "default", maskedLocation ? {
124			pathname: window2.location.pathname,
125			search: window2.location.search,
126			hash: window2.location.hash
127		} : void 0);
128	}
129	function createBrowserHref(window2, to) {
130		return typeof to === "string" ? to : createPath(to);
131	}
132	return getUrlBasedHistory(createBrowserLocation, createBrowserHref, null, options);
133}
134function createHashHistory(options = {}) {
135	function createHashLocation(window2, globalHistory) {
136		let { pathname = "/", search = "", hash = "" } = parsePath(window2.location.hash.substring(1));
137		if (!pathname.startsWith("/") && !pathname.startsWith(".")) pathname = "/" + pathname;
138		return createLocation("", {
139			pathname,
140			search,
141			hash
142		}, globalHistory.state && globalHistory.state.usr || null, globalHistory.state && globalHistory.state.key || "default");
143	}
144	function createHashHref(window2, to) {
145		let base = window2.document.querySelector("base");
146		let href = "";
147		if (base && base.getAttribute("href")) {
148			let url = window2.location.href;
149			let hashIndex = url.indexOf("#");
150			href = hashIndex === -1 ? url : url.slice(0, hashIndex);
151		}
152		return href + "#" + (typeof to === "string" ? to : createPath(to));
153	}
154	function validateHashLocation(location, to) {
155		warning(location.pathname.charAt(0) === "/", `relative pathnames are not supported in hash history.push(${JSON.stringify(to)})`);
156	}
157	return getUrlBasedHistory(createHashLocation, createHashHref, validateHashLocation, options);
158}
159function invariant(value, message) {
160	if (value === false || value === null || typeof value === "undefined") throw new Error(message);
161}
162function warning(cond, message) {
163	if (!cond) {
164		if (typeof console !== "undefined") console.warn(message);
165		try {
166			throw new Error(message);
167		} catch (e) {}
168	}
169}
170function createKey$1() {
171	return Math.random().toString(36).substring(2, 10);
172}
173function getHistoryState(location, index) {
174	return {
175		usr: location.state,
176		key: location.key,
177		idx: index,
178		masked: location.unstable_mask ? {
179			pathname: location.pathname,
180			search: location.search,
181			hash: location.hash
182		} : void 0
183	};
184}
185function createLocation(current, to, state = null, key, unstable_mask) {
186	return {
187		pathname: typeof current === "string" ? current : current.pathname,
188		search: "",
189		hash: "",
190		...typeof to === "string" ? parsePath(to) : to,
191		state,
192		key: to && to.key || key || createKey$1(),
193		unstable_mask
194	};
195}
196function createPath({ pathname = "/", search = "", hash = "" }) {
197	if (search && search !== "?") pathname += search.charAt(0) === "?" ? search : "?" + search;
198	if (hash && hash !== "#") pathname += hash.charAt(0) === "#" ? hash : "#" + hash;
199	return pathname;
200}
201function parsePath(path) {
202	let parsedPath = {};
203	if (path) {
204		let hashIndex = path.indexOf("#");
205		if (hashIndex >= 0) {
206			parsedPath.hash = path.substring(hashIndex);
207			path = path.substring(0, hashIndex);
208		}
209		let searchIndex = path.indexOf("?");
210		if (searchIndex >= 0) {
211			parsedPath.search = path.substring(searchIndex);
212			path = path.substring(0, searchIndex);
213		}
214		if (path) parsedPath.pathname = path;
215	}
216	return parsedPath;
217}
218function getUrlBasedHistory(getLocation, createHref2, validateLocation, options = {}) {
219	let { window: window2 = document.defaultView, v5Compat = false } = options;
220	let globalHistory = window2.history;
221	let action = "POP";
222	let listener = null;
223	let index = getIndex();
224	if (index == null) {
225		index = 0;
226		globalHistory.replaceState({
227			...globalHistory.state,
228			idx: index
229		}, "");
230	}
231	function getIndex() {
232		return (globalHistory.state || { idx: null }).idx;
233	}
234	function handlePop() {
235		action = "POP";
236		let nextIndex = getIndex();
237		let delta = nextIndex == null ? null : nextIndex - index;
238		index = nextIndex;
239		if (listener) listener({
240			action,
241			location: history.location,
242			delta
243		});
244	}
245	function push(to, state) {
246		action = "PUSH";
247		let location = isLocation(to) ? to : createLocation(history.location, to, state);
248		if (validateLocation) validateLocation(location, to);
249		index = getIndex() + 1;
250		let historyState = getHistoryState(location, index);
251		let url = history.createHref(location.unstable_mask || location);
252		try {
253			globalHistory.pushState(historyState, "", url);
254		} catch (error) {

396d "${id}".  Route id's must be globally unique within Data Router usages`);
397		if (isIndexRoute(route)) {
398			let indexRoute = {
399				...route,
400				id
401			};
402			manifest[id] = mergeRouteUpdates(indexRoute, mapRouteProperties2(indexRoute));
403			return indexRoute;
404		} else {
405			let pathOrLayoutRoute = {
406				...route,
407				id,
408				children: void 0
409			};
410			manifest[id] = mergeRouteUpdates(pathOrLayoutRoute, mapRouteProperties2(pathOrLayoutRoute));
411			if (route.children) pathOrLayoutRoute.children = convertRoutesToDataRoutes(route.children, mapRouteProperties2, treePath, manifest, allowInPlaceMutations);
412			return pathOrLayoutRoute;
413		}
414	});
415}
416function mergeRouteUpdates(route, updates) {
417	return Object.assign(route, {
418		...updates,
419		...typeof updates.lazy === "object" && updates.lazy != null ? { lazy: {
420			...route.lazy,
421			...updates.lazy
422		} } : {}
423	});
424}
425function matchRoutes(routes, locationArg, basename = "/") {
426	return matchRoutesImpl(routes, locationArg, basename, false);
427}
428function matchRoutesImpl(routes, locationArg, basename, allowPartial) {
429	let pathname = stripBasename((typeof locationArg === "string" ? parsePath(locationArg) : locationArg).pathname || "/", basename);
430	if (pathname == null) return null;
431	let branches = flattenRoutes(routes);
432	rankRouteBranches(branches);
433	let matches = null;
434	for (let i = 0; matches == null && i < branches.length; ++i) {
435		let decoded = decodePath(pathname);
436		matches = matchRouteBranch(branches[i], decoded, allowPartial);
437	}
438	return matches;
439}
440function convertRouteMatchToUiMatch(match, loaderData) {
441	let { route, pathname, params } = match;
442	return {
443		id: route.id,
444		pathname,
445		params,
446		data: loaderData[route.id],
447		loaderData: loaderData[route.id],
448		handle: route.handle
449	};
450}
451function flattenRoutes(routes, branches = [], parentsMeta = [], parentPath = "", _hasParentOptionalSegments = false) {
452	let flattenRoute = (route, index, hasParentOptionalSegments = _hasParentOptionalSegments, relativePath) => {
453		let meta = {
454			relativePath: relativePath === void 0 ? route.path || "" : relativePath,
455			caseSensitive: route.caseSensitive === true,
456			childrenIndex: index,
457			route
458		};
459		if (meta.relativePath.startsWith("/")) {
460			if (!meta.relativePath.startsWith(parentPath) && hasParentOptionalSegments) return;
461			invariant(meta.relativePath.startsWith(parentPath), `Absolute route path "${meta.relativePath}" nested under path "${parentPath}" is not valid. An absolute child route path must start with the combined path of all its parent routes.`);
462			meta.relativePath = meta.relativePath.slice(parentPath.length);
463		}
464		let path = joinPaths([parentPath, meta.relativePath]);
465		let routesMeta = parentsMeta.concat(meta);
466		if (route.children && route.children.length > 0) {
467			invariant(route.index !== true, `Index routes must not have child routes. Please remove all child routes from route path "${path}".`);
468			flattenRoutes(route.children, branches, routesMeta, path, hasParentOptionalSegments);
469		}
470		if (route.path == null && !route.index) return;
471		branches.push({
472			path,
473			score: computeScore(path, route.index),
474			routesMeta
475		});
476	};
477	routes.forEach((route, index) => {
478		if (route.path === "" || !route.path?.includes("?")) flattenRoute(route, index);
479		else for (let exploded of explodeOptionalSegments(route.path)) flattenRoute(route, index, true, exploded);
480	});
481	return branches;
482}
483function explodeOptionalSegments(path) {
484	let segments = path.split("/");
485	if (segments.length === 0) return [];
486	let [first, ...rest] = segments;
487	let isOptional = first.endsWith("?");
488	let required = first.replace(/\?$/, "");
489	if (rest.length === 0) return isOptional ? [required, ""] : [required];
490	let restExploded = explodeOptionalSegments(rest.join("/"));
491	let result = [];
492	result.push(...restExploded.map((subpath) => subpath === "" ? required : [required, subpath].join("/")));
493	if (isOptional) result.push(...restExploded);
494	return result.map((exploded) => path.startsWith("/") && exploded === "" ? "/" : exploded);
495}
496function rankRouteBranches(branches) {
497	branches.sort((a, b) => a.score !== b.score ? b.score - a.score : compareIndexes(a.routesMeta.map((meta) => meta.childrenIndex), b.routesMeta.map((meta) => meta.childrenIndex)));
498}
499var paramRe = /^:[\w-]+$/;
500var dynamicSegmentValue = 3;
501var indexRouteValue = 2;
502var emptySegmentValue = 1;
503var staticSegmentValue = 10;
504var splatPenalty = -2;
505var isSplat = (s) => s === "*";
506function computeScore(path, index) {
507	let segments = path.split("/");
508	let initialScore = segments.length;
509	if (segments.some(isSplat)) initialScore += splatPenalty;
510	if (index) initialScore += indexRouteValue;
511	return segments.filter((s) => !isSplat(s)).reduce((score, segment) =>

511 score + (paramRe.test(segment) ? dynamicSegmentValue : segment === "" ? emptySegmentValue : staticSegmentValue), initialScore);
512}
513function compareIndexes(a, b) {
514	return a.length === b.length && a.slice(0, -1).every((n, i) => n === b[i]) ? a[a.length - 1] - b[b.length - 1] : 0;
515}
516function matchRouteBranch(branch, pathname, allowPartial = false) {
517	let { routesMeta } = branch;
518	let matchedParams = {};
519	let matchedPathname = "/";
520	let matches = [];
521	for (let i = 0; i < routesMeta.length; ++i) {
522		let meta = routesMeta[i];
523		let end = i === routesMeta.length - 1;
524		let remainingPathname = matchedPathname === "/" ? pathname : pathname.slice(matchedPathname.length) || "/";
525		let match = matchPath({
526			path: meta.relativePath,
527			caseSensitive: meta.caseSensitive,
528			end
529		}, remainingPathname);
530		let route = meta.route;
531		if (!match && end && allowPartial && !routesMeta[routesMeta.length - 1].route.index) match = matchPath({
532			path: meta.relativePath,
533			caseSensitive: meta.caseSensitive,
534			end: false
535		}, remainingPathname);
536		if (!match) return null;
537		Object.assign(matchedParams, match.params);
538		matches.push({
539			params: matchedParams,
540			pathname: joinPaths([matchedPathname, match.pathname]),
541			pathnameBase: normalizePathname(joinPaths([matchedPathname, match.pathnameBase])),
542			route
543		});
544		if (match.pathnameBase !== "/") matchedPathname = joinPaths([matchedPathname, match.pathnameBase]);
545	}
546	return matches;
547}
548function generatePath(originalPath, params = {}) {
549	let path = originalPath;
550	if (path.endsWith("*") && path !== "*" && !path.endsWith("/*")) {
551		warning(false, `Route path "${path}" will be treated as if it were "${path.replace(/\*$/, "/*")}" because the \`*\` character must always follow a \`/\` in the pattern. To get rid of this warning, please change the route path to "${path.replace(/\*$/, "/*")}".`);
552		path = path.replace(/\*$/, "/*");
553	}
554	const prefix = path.startsWith("/") ? "/" : "";
555	const stringify2 = (p) => p == null ? "" : typeof p === "string" ? p : String(p);
556	return prefix + path.split(/\/+/).map((segment, index, array) => {
557		if (index === array.length - 1 && segment === "*") return stringify2(params["*"]);
558		const keyMatch = segment.match(/^:([\w-]+)(\??)(.*)/);
559		if (keyMatch) {
560			const [, key, optional, suffix] = keyMatch;
561			let param = params[key];
562			invariant(optional === "?" || param != null, `Missing ":${key}" param`);
563			return encodeURIComponent(stringify2(param)) + suffix;
564		}
565		return segment.replace(/\?$/g, "");
566	}).filter((segment) => !!segment).join("/");
567}
568function matchPath(pattern, pathname) {
569	if (typeof pattern === "string") pattern = {
570		path: pattern,
571		caseSensitive: false,
572		end: true
573	};
574	let [matcher, compiledParams] = compilePath(pattern.path, pattern.caseSensitive, pattern.end);
575	let match = pathname.match(matcher);
576	if (!match) return null;
577	let matchedPathname = match[0];
578	let pathnameBase = matchedPathname.replace(/(.)\/+$/, "$1");
579	let captureGroups = match.slice(1);
580	return {
581		params: compiledParams.reduce((memo2, { paramName, isOptional }, index) => {
582			if (paramName === "*") {
583				let splatValue = captureGroups[index] || "";
584				pathnameBase = matchedPathname.slice(0, matchedPathname.length - splatValue.length).replace(/(.)\/+$/, "$1");
585			}
586			const value = captureGroups[index];
587			if (isOptional && !value) memo2[paramName] = void 0;
588			else memo2[paramName] = (value || "").replace(/%2F/g, "/");
589			return memo2;
590		}, {}),
591		pathname: matchedPathname,
592		pathnameBase,
593		pattern
594	};
595}
596function compilePath(path, caseSensitive = false, end = true) {
597	warning(path === "*" || !path.endsWith("*") || path.endsWith("/*"), `Route path "${path}" will be treated as if it were "${path.replace(/\*$/, "/*")}" because the \`*\` character must always follow a \`/\` in the pattern. To get rid of this warning, please change the route path to "${path.replace(/\*$/, "/*")}".`);
598	let params = [];
599	let regexpSource = "^" + path.replace(/\/*\*?$/, "").replace(/^\/*/, "/").replace(/[\\.*+^${}|()[\]]/g, "\\$&").replace(/\/:([\w-]+)(\?)?/g, (match, paramName, isOptional, index, str) => {
600		params.push({
601			paramName,
602			isOptional: isOptional != null
603		});
604		if (isOptional) {
605			let nextChar = str.charAt(index + match.length);
606			if (nextChar && nextChar !== "/") return "/([^\\/]*)";
607			return "(?:/([^\\/]*))?";
608		}
609		return "/([^\\/]+)";
610	}).replace(/\/([\w-]+)\?(\/|$)/g, "(/$1)?$2");
611	if (path.endsWith("*")) {
612		params.push({ paramName: "*" });
613		regexpSource += path === "*" || path === "/*" ? "(.*)$" : "(?:\\/(.+)|\\/*)$";
614	} else if (end) regexpSource += "\\/*$";
615	else if (path !== "" && path !== "/") regexpSource += "(?:(?=\\/|$))";
616	return [new RegExp(regexpSource, caseSensitive ? void 0 : "i"), params];
617}
618function decodePath(value) {
619	try {
620		return value.split("/").map((v) => decodeURIComponent(v).replace(/\//g, "%2F")).join("/");
621	} catch (error) {
622		warning(false, `The URL path "${value}" could not be decoded because it is a malformed URL segment. This is probably due to a bad percent encoding (${error}).`);
623		return value;
624	}
625}

626function stripBasename(pathname, basename) {
627	if (basename === "/") return pathname;
628	if (!pathname.toLowerCase().startsWith(basename.toLowerCase())) return null;
629	let startIndex = basename.endsWith("/") ? basename.length - 1 : basename.length;
630	let nextChar = pathname.charAt(startIndex);
631	if (nextChar && nextChar !== "/") return null;
632	return pathname.slice(startIndex) || "/";
633}
634function prependBasename({ basename, pathname }) {
635	return pathname === "/" ? basename : joinPaths([basename, pathname]);
636}
637var ABSOLUTE_URL_REGEX = /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i;
638var isAbsoluteUrl = (url) => ABSOLUTE_URL_REGEX.test(url);
639function resolvePath(to, fromPathname = "/") {
640	let { pathname: toPathname, search = "", hash = "" } = typeof to === "string" ? parsePath(to) : to;
641	let pathname;
642	if (toPathname) {
643		toPathname = toPathname.replace(/\/\/+/g, "/");
644		if (toPathname.startsWith("/")) pathname = resolvePathname(toPathname.substring(1), "/");
645		else pathname = resolvePathname(toPathname, fromPathname);
646	} else pathname = fromPathname;
647	return {
648		pathname,
649		search: normalizeSearch(search),
650		hash: normalizeHash(hash)
651	};
652}
653function resolvePathname(relativePath, fromPathname) {
654	let segments = fromPathname.replace(/\/+$/, "").split("/");
655	relativePath.split("/").forEach((segment) => {
656		if (segment === "..") {
657			if (segments.length > 1) segments.pop();
658		} else if (segment !== ".") segments.push(segment);
659	});
660	return segments.length > 1 ? segments.join("/") : "/";
661}
662function getInvalidPathError(char, field, dest, path) {
663	return `Cannot include a '${char}' character in a manually specified \`to.${field}\` field [${JSON.stringify(path)}].  Please separate it out to the \`to.${dest}\` field. Alternatively you may provide the full path as a string in <Link to="..."> and the router will parse it for you.`;
664}
665function getPathContributingMatches(matches) {
666	return matches.filter((match, index) => index === 0 || match.route.path && match.route.path.length > 0);
667}
668function getResolveToMatches(matches) {
669	let pathMatches = getPathContributingMatches(matches);
670	return pathMatches.map((match, idx) => idx === pathMatches.length - 1 ? match.pathname : match.pathnameBase);
671}
672function resolveTo(toArg, routePathnames, locationPathname, isPathRelative = false) {
673	let to;
674	if (typeof toArg === "string") to = parsePath(toArg);
675	else {
676		to = { ...toArg };
677		invariant(!to.pathname || !to.pathname.includes("?"), getInvalidPathError("?", "pathname", "search", to));
678		invariant(!to.pathname || !to.pathname.includes("#"), getInvalidPathError("#", "pathname", "hash", to));
679		invariant(!to.search || !to.search.includes("#"), getInvalidPathError("#", "search", "hash", to));
680	}
681	let isEmptyPath = toArg === "" || to.pathname === "";
682	let toPathname = isEmptyPath ? "/" : to.pathname;
683	let from;
684	if (toPathname == null) from = locationPathname;
685	else {
686		let routePathnameIndex = routePathnames.length - 1;
687		if (!isPathRelative && toPathname.startsWith("..")) {
688			let toSegments = toPathname.split("/");
689			while (toSegments[0] === "..") {
690				toSegments.shift();
691				routePathnameIndex -= 1;
692			}
693			to.pathname = toSegments.join("/");
694		}
695		from = routePathnameIndex >= 0 ? routePathnames[routePathnameIndex] : "/";
696	}
697	let path = resolvePath(to, from);
698	let hasExplicitTrailingSlash = toPathname && toPathname !== "/" && toPathname.endsWith("/");
699	let hasCurrentTrailingSlash = (isEmptyPath || toPathname === ".") && locationPathname.endsWith("/");
700	if (!path.pathname.endsWith("/") && (hasExplicitTrailingSlash || hasCurrentTrailingSlash)) path.pathname += "/";
701	return path;
702}
703var joinPaths = (paths) => paths.join("/").replace(/\/\/+/g, "/");
704var normalizePathname = (pathname) => pathname.replace(/\/+$/, "").replace(/^\/*/, "/");
705var normalizeSearch = (search) => !search || search === "?" ? "" : search.startsWith("?") ? search : "?" + search;
706var normalizeHash = (hash) => !hash || hash === "#" ? "" : hash.startsWith("#") ? hash : "#" + hash;
707var DataWithResponseInit = class {
708	constructor(data2, init) {
709		this.type = "DataWithResponseInit";
710		this.data = data2;
711		this.init = init || null;
712	}
713};
714function data(data2, init) {
715	return new DataWithResponseInit(data2, typeof init === "number" ? { status: init } : init);
716}
717var redirect = (url, init = 302) => {
718	let responseInit = init;
719	if (typeof responseInit === "number") responseInit = { status: responseInit };
720	else if (typeof responseInit.status === "undefined") responseInit.status = 302;
721	let headers = new Headers(responseInit.headers);
722	headers.set("Location", url);
723	return new Response(null, {
724		...responseInit,
725		headers
726	});
727};
728var redirectDocument = (url, init) => {
729	let response = redirect(url, init);
730	response.headers.set("X-Remix-Reload-Document", "true");
731	return response;
732};
733var replace = (url, init) => {
734	let response = redirect(url, init);
735	response.headers.set("X-Remix-Replace", "true");
736	return response;
737};
738var ErrorResponseImpl = class {
739	constructor(status, statusText, data2, internal = false) {
740		this.status = status;
741		this.statusText = statusText || "";
742		this.internal = internal;
743		if (data2 instanceof Error) {
744			this.data = data2.toString();
745			this.error = data2;
746		} else this.data = data2;
747	}
748};
749function isRouteErrorResponse(error) {

1069	let initialErrors = null;
1070	let initialized;
1071	let renderFallback;
1072	if (initialMatches == null && !init.patchRoutesOnNavigation) {
1073		let error = getInternalRouterError(404, { pathname: init.history.location.pathname });
1074		let { matches, route } = getShortCircuitMatches(dataRoutes);
1075		initialized = true;
1076		renderFallback = !initialized;
1077		initialMatches = matches;
1078		initialErrors = { [route.id]: error };
1079	} else {
1080		if (initialMatches && !init.hydrationData) {
1081			if (checkFogOfWar(initialMatches, dataRoutes, init.history.location.pathname).active) initialMatches = null;
1082		}
1083		if (!initialMatches) {
1084			initialized = false;
1085			renderFallback = !initialized;
1086			initialMatches = [];
1087			let fogOfWar = checkFogOfWar(null, dataRoutes, init.history.location.pathname);
1088			if (fogOfWar.active && fogOfWar.matches) {
1089				initialMatchesIsFOW = true;
1090				initialMatches = fogOfWar.matches;
1091			}
1092		} else if (initialMatches.some((m) => m.route.lazy)) {
1093			initialized = false;
1094			renderFallback = !initialized;
1095		} else if (!initialMatches.some((m) => routeHasLoaderOrMiddleware(m.route))) {
1096			initialized = true;
1097			renderFallback = !initialized;
1098		} else {
1099			let loaderData = init.hydrationData ? init.hydrationData.loaderData : null;
1100			let errors = init.hydrationData ? init.hydrationData.errors : null;
1101			let relevantMatches = initialMatches;
1102			if (errors) {
1103				let idx = initialMatches.findIndex((m) => errors[m.route.id] !== void 0);
1104				relevantMatches = relevantMatches.slice(0, idx + 1);
1105			}
1106			renderFallback = false;
1107			initialized = true;
1108			relevantMatches.forEach((m) => {
1109				let status = getRouteHydrationStatus(m.route, loaderData, errors);
1110				renderFallback = renderFallback || status.renderFallback;
1111				initialized = initialized && !status.shouldLoad;
1112			});
1113		}
1114	}
1115	let router;
1116	let state = {
1117		historyAction: init.history.action,
1118		location: init.history.location,
1119		matches: initialMatches,
1120		initialized,
1121		renderFallback,
1122		navigation: IDLE_NAVIGATION,
1123		restoreScrollPosition: init.hydrationData != null ? false : null,
1124		preventScrollReset: false,
1125		revalidation: "idle",
1126		loaderData: init.hydrationData && init.hydrationData.loaderData || {},
1127		actionData: init.hydrationData && init.hydrationData.actionData || null,
1128		errors: init.hydrationData && init.hydrationData.errors || initialErrors,
1129		fetchers: /* @__PURE__ */ new Map(),
1130		blockers: /* @__PURE__ */ new Map()
1131	};
1132	let pendingAction = "POP";
1133	let pendingPopstateNavigationDfd = null;
1134	let pendingPreventScrollReset = false;
1135	let pendingNavigationController;
1136	let pendingViewTransitionEnabled = false;
1137	let appliedViewTransitions = /* @__PURE__ */ new Map();
1138	let removePageHideEventListener = null;
1139	let isUninterruptedRevalidation = false;
1140	let isRevalidationRequired = false;
1141	let cancelledFetcherLoads = /* @__PURE__ */ new Set();
1142	let fetchControllers = /* @__PURE__ */ new Map();
1143	let incrementingLoadId = 0;
1144	let pendingNavigationLoadId = -1;
1145	let fetchReloadIds = /* @__PURE__ */ new Map();
1146	let fetchRedirectIds = /* @__PURE__ */ new Set();
1147	let fetchLoadMatches = /* @__PURE__ */ new Map();
1148	let activeFetchers = /* @__PURE__ */ new Map();
1149	let fetchersQueuedForDeletion = /* @__PURE__ */ new Set();
1150	let blockerFunctions = /* @__PURE__ */ new Map();
1151	let unblockBlockerHistoryUpdate = void 0;
1152	let pendingRevalidationDfd = null;
1153	function initialize() {
1154		unlistenHistory = init.history.listen(({ action: historyAction, location, delta }) => {
1155			if (unblockBlockerHistoryUpdate) {
1156				unblockBlockerHistoryUpdate();
1157				unblockBlockerHistoryUpdate = void 0;
1158				return;
1159			}
1160			warning(blockerFunctions.size === 0 || delta != null, "You are trying to use a blocker on a POP navigation to a location that was not created by @remix-run/router. This will fail silently in production. This can happen if you are navigating outside the router via `window.history.pushState`/`window.location.hash` instead of using router navigation APIs.  This can also happen if you are using createHashRouter and the user manually changes the URL.");
1161			let blockerKey = shouldBlockNavigation({
1162				currentLocation: state.location,
1163				nextLocation: location,
1164				historyAction
1165			});
1166			if (blockerKey && delta != null) {
1167				let nextHistoryUpdatePromise = new Promise((resolve) => {
1168					unblockBlockerHistoryUpdate = resolve;
1169				});
1170				init.history.go(delta * -1);
1171				updateBlocker(blockerKey, {
1172					state: "blocked",
1173					location,
1174					proceed() {
1175						updateBlocker(blockerKey, {
1176							state: "proceeding",
1177							proceed: void 0,
1178							reset: void 0,
1179							location
1180						});
1181						nextHistoryUpdatePromise.then(() => init.history.go(delta));
1182					},
1183					reset() {
1184						let blockers = new Map(state.blockers);
1185						blockers.set(blockerKey, IDLE_BLOCKER);
1186						updateState({ blockers });
1187					}
1188				});
1189				pendingPopstateNavigationDfd?.resolve();
1190				pendingPopstateNavigationDfd = null;
1191				return;
1192			}
1193			return startNavigation(historyAction, location);
1194		});
1195		if (isBrowser3) {
1196			restoreAppliedTransitions(routerWindow, appliedViewTransitions);
1197			let _saveAppliedTransitions = () => persistAppliedTransitions(routerWindow, appliedViewTransitions);
1198			routerWindow.addEventListener("pagehide", _saveAppliedTransitions);
1199			removePageHideEventListener = () => routerWindow.removeEventListener("pagehide", _saveAppliedTransitions);
1200		}
1201		if (!state.initialized) startNavigation("POP", state.location, { initialHydration: true });
1202		return router;
1203	}
1204	function dispose() {
1205		if (unlistenHistory) unlistenHistory();
1206		if (removePageHideEventListener) removePageHideEventListener();
1207		subscribers.clear();
1208		pendingNavigationController && pendingNavigationController.abort();
1209		state.fetchers.forEach((_, key) => deleteFetcher(key));
1210		state.blockers.forEach((_, key) => deleteBlocker(key));
1211	}
1212	function subscribe(fn) {
1213		subscribers.add(fn);
1214		return () => subscribers.delete(fn);
1215	}
1216	function updateState(newState, opts = {}) {
1217		if (newState.matches) newState.matches = newState.matches.map((m) => {
1218			let route = manifest[m.route.id];
1219			let matchRoute = m.route;
1220			if (matchRoute.element !== route.element || matchRoute.errorElement !== route.errorElement || matchRoute.hydrateFallbackElement !== route.hydrateFallbackElement) return {
1221				...m,
1222				route
1223			};
1224			return m;
1225		});
1226		state = {
1227			...state,
1228			...newState
1229		};
1230		let unmountedFetchers = [];
1231		let mountedFetchers = [];
1232		state.fetchers.forEach((fetcher, key) => {
1233			if (fetcher.state === "idle") if (fetchersQueuedForDeletion.has(key)) unmountedFetchers.push(key);
1234			else mountedFetchers.push(key);
1235		});
1236		fetchersQueuedForDeletion.forEach((key) => {
1237			if (!state.fetchers.has(key) && !fetchControllers.has(key)) unmountedFetchers.push(key);
1238		});
1239		[...subscribers].forEach((subscriber) => subscriber(state, {
1240			deletedFetchers: unmountedFetchers,
1241			newErrors: newState.errors ?? null,
1242			viewTransitionOpts: opts.viewTransitionOpts,
1243			flushSync: opts.flushSync === true
1244		}));
1245		unmountedFetchers.forEach((key) => deleteFetcher(key));
1246		mountedFetchers.forEach((key) => state.fetchers.delete(key));
1247	}
1248	function completeNavigation(location, newState, { flushSync } = {}) {
1249		let isActionReload = state.actionData != null && state.navigation.formMethod != null && isMutationMethod(state.navigation.formMethod) && state.navigation.state === "loading" && location.state?._isRedirect !== true;
1250		let actionData;
1251		if (newState.actionData) if (Object.keys(newState.actionData).length > 0) actionData = newState.actionData;
1252		else actionData = null;
1253		else if (isActionReload) actionData = state.actionData;
1254		else actionData = null;
1255		let loaderData = newState.loaderData ? mergeLoaderData(state.loaderData, newState.loaderData, newState.matches || [], newState.errors) : state.loaderData;
1256		let blockers = state.blockers;
1257		if (blockers.size > 0) {
1258			blockers = new Map(blockers);
1259			blockers.forEach((_, k) => blockers.set(k, IDLE_BLOCKER));
1260		}
1261		let restoreScrollPosition = isUninterruptedRevalidation ? false : getSavedScrollPosition(location, newState.matches || state.matches);
1262		let preventScrollReset = pendingPreventScrollReset === true || state.navigation.formMethod != null && isMutationMethod(state.navigation.formMethod) && location.state?._isRedirect !== true;
1263		if (inFlightDataRoutes) {
1264			dataRoutes = inFlightDataRoutes;
1265			inFlightDataRoutes = void 0;
1266		}
1267		if (isUninterruptedRevalidation) {} else if (pendingAction === "POP") {} else if (pendingAction === "PUSH") init.history.push(location, location.state);
1268		else if (pendingAction === "REPLACE") init.history.replace(location, location.state);
1269		let viewTransitionOpts;
1270		if (pendingAction === "POP") {
1271			let priorPaths = appliedViewTransitions.get(state.location.pathname);
1272			if (priorPaths && priorPaths.has(location.pathname)) viewTransitionOpts = {
1273				currentLocation: state.location,
1274				nextLocation: location
1275			};
1276			else if (appliedViewTransitions.has(location.pathname)) viewTransitionOpts = {
1277				currentLocation: location,
1278				nextLocation: state.location
1279			};
1280		} else if (pendingViewTransitionEnabled) {
1281			let toPaths = appliedViewTransitions.get(state.location.pathname);
1282			if (toPaths) toPaths.add(location.pathname);
1283			else {
1284				toPaths = /* @__PURE__ */ new Set([location.pathname]);
1285				appliedViewTransitions.set(state.location.pathname, toPaths);
1286			}
1287			viewTransitionOpts = {
1288				currentLocation: state.location,
1289				nextLocation: location
1290			};
1291		}
1292		updateState({
1293			...newState,
1294			actionData,
1295			loaderData,
1296			historyAction: pendingAction,
1297			location,
1298			initialized: true,
1299			renderFallback: false,
1300			navigation: IDLE_NAVIGATION,
1301			revalidation: "idle",
1302			restoreScrollPosition,
1303			preventScrollReset,
1304			blockers
1305		}, {
1306			viewTransitionOpts,
1307			flushSync: flushSync === true
1308		});
1309		pendingAction = "POP";
1310		pendingPreventScrollReset = false;
1311		pendingViewTransitionEnabled = false;
1312		isUninterruptedRevalidation = false;
1313		isRevalidationRequired = false;
1314		pendingPopstateNavigationDfd?.resolve();
1315		pendingPopstateNavigationDfd = null;
1316		pendingRevalidationDfd?.resolve();
1317		pendingRevalidationDfd = null;
1318	}
1319	async function navigate(to, opts) {
1320		pendingPopstateNavigationDfd?.resolve();
1321		pendingPopstateNavigationDfd = null;
1322		if (typeof to === "number") {
1323			if (!pendingPopstateNavigationDfd) pendingPopstateNavigationDfd = createDeferred();
1324			let promise = pendingPopstateNavigationDfd.promise;
1325			init.history.go(to);
1326			return promise;
1327		}
1328		let { path, submission, error } = normalizeNavigateOptions(false, normalizeTo(state.location, state.matches, basename, to, opts?.fromRouteId, opts?.relative), opts);
1329		let maskPath;
1330		if (opts?.unstable_mask) maskPath = {
1331			pathname: "",
1332			search: "",
1333			hash: "",
1334			...typeof opts.unstable_mask === "string" ? parsePath(opts.unstable_mask) : {
1335				...state.location.unstable_mask,
1336				...opts.unstable_mask
1337			}
1338		};
1339		let currentLocation = state.location;
1340		let nextLocation = createLocation(currentLocation, path, opts && opts.state, void 0, maskPath);
1341		nextLocation = {
1342			...nextLocation,
1343			...init.history.encodeLocation(nextLocation)
1344		};
1345		let userReplace = opts && opts.replace != null ? opts.replace : void 0;
1346		let historyAction = "PUSH";
1347		if (userReplace === true) historyAction = "REPLACE";
1348		else if (userReplace === false) {} else if (submission != null && isMutationMethod(submission.formMethod) && submission.formAction === state.location.pathname + state.location.search) historyAction = "REPLACE";
1349		let preventScrollReset = opts && "preventScrollReset" in opts ? opts.preventScrollReset === true : void 0;
1350		let flushSync = (opts && opts.flushSync) === true;
1351		let blockerKey = shouldBlockNavigation({
1352			currentLocation,
1353			nextLocation,
1354			historyAction
1355		});
1356		if (blockerKey) {
1357			updateBlocker(blockerKey, {
1358				state: "blocked",
1359				location: nextLocation,
1360				proceed() {
1361					updateBlocker(blockerKey, {
1362						state: "proceeding",
1363						proceed: void 0,
1364						reset: void 0,
1365						location: nextLocation
1366					});
1367					navigate(to, opts);
1368				},
1369				reset() {
1370					let blockers = new Map(state.blockers);
1371					blockers.set(blockerKey, IDLE_BLOCKER);
1372					updateState({ blockers });
1373				}
1374			});
1375			return;
1376		}
1377		await startNavigation(historyAction, nextLocation, {
1378			submission,
1379			pendingError: error,
1380			preventScrollReset,
1381			replace: opts && opts.replace,
1382			enableViewTransition: opts && opts.viewTransition,
1383			flushSync,
1384			callSiteDefaultShouldRevalidate: opts && opts.unstable_defaultShouldRevalidate
1385		});
1386	}
1387	function revalidate() {
1388		if (!pendingRevalidationDfd) pendingRevalidationDfd = createDeferred();
1389		interruptActiveLoads();
1390		updateState({ revalidation: "loading" });
1391		let promise = pendingRevalidationDfd.promise;
1392		if (state.navigation.state === "submitting") return promise;
1393		if (state.navigation.state === "idle") {
1394			startNavigation(state.historyAction, state.location, { startUninterruptedRevalidation: true });
1395			return promise;
1396		}
1397		startNavigation(pendingAction || state.historyAction, state.navigation.location, {
1398			overrideNavigation: state.navigation,
1399			enableViewTransition: pendingViewTransitionEnabled === true
1400		});
1401		return promise;
1402	}
1403	async function startNavigation(historyAction, location, opts) {
1404		pendingNavigationController && pendingNavigationController.abort();
1405		pendingNavigationController = null;
1406		pendingAction = historyAction;
1407		isUninterruptedRevalidation = (opts && opts.startUninterruptedRevalidation) === true;
1408		saveScrollPosition(state.location, state.matches);
1409		pendingPreventScrollReset = (opts && opts.preventScrollReset) === true;
1410		pendingViewTransitionEnabled = (opts && opts.enableViewTransition) === true;
1411		let routesToUse = inFlightDataRoutes || dataRoutes;
1412		let loadingNavigation = opts && opts.overrideNavigation;
1413		let matches = opts?.initialHydration && state.matches && state.matches.length > 0 && !initialMatchesIsFOW ? state.matches : matchRoutes(routesToUse, location, basename);
1414		let flushSync = (opts && opts.flushSync) === true;
1415		if (matches && state.initialized && !isRevalidationRequired && isHashChangeOnly(state.location, location) && !(opts && opts.submission && isMutationMethod(opts.submission.formMethod))) {
1416			completeNavigation(location, { matches }, { flushSync });
1417			return;
1418		}
1419		let fogOfWar = checkFogOfWar(matches, routesToUse, location.pathname);
1420		if (fogOfWar.active && fogOfWar.matches) matches = fogOfWar.matches;
1421		if (!matches) {
1422			let { error, notFoundMatches, route } = handleNavigational404(location.pathname);
1423			completeNavigation(location, {
1424				matches: notFoundMatches,
1425				loaderData: {},
1426				errors: { [route.id]: error }
1427			}, { flushSync });
1428			return;
1429		}
1430		pendingNavigationController = new AbortController();
1431		let request = createClientSideRequest(init.history, location, pendingNavigationController.signal, opts && opts.submission);
1432		let scopedContext = init.getContext ? await init.getContext() : new RouterContextProvider();
1433		let pendingActionResult;
1434		if (opts && opts.pendingError) pendingActionResult = [findNearestBoundary(matches).route.id, {
1435			type: "error",
1436			error: opts.pendingError
1437		}];
1438		else if (opts && opts.submission && isMutationMethod(opts.submission.formMethod)) {
1439			let actionResult = await handleAction(request, location, opts.submission, matches, scopedContext, fogOfWar.active, opts && opts.initialHydration === true, {
1440				replace: opts.replace,
1441				flushSync
1442			});
1443			if (actionResult.shortCircuited) return;
1444			if (actionResult.pendingActionResult) {
1445				let [routeId, result] = actionResult.pendingActionResult;
1446				if (isErrorResult(result) && isRouteErrorResponse(result.error) && result.error.status === 404) {
1447					pendingNavigationController = null;
1448					completeNavigation(location, {
1449						matches: actionResult.matches,
1450						loaderData: {},
1451						errors: { [routeId]: result.error }
1452					});
1453					return;
1454				}
1455			}
1456			matches = actionResult.matches || matches;
1457			pendingActionResult = actionResult.pendingActionResult;
1458			loadingNavigation = getLoadingNavigation(location, opts.submission);
1459			flushSync = false;
1460			fogOfWar.active = false;
1461			request = createClientSideRequest(init.history, request.url, request.signal);
1462		}
1463		let { shortCircuited, matches: updatedMatches, loaderData, errors } = await handleLoaders(request, location, matches, scopedContext, fogOfWar.active, loadingNavigation, opts && opts.submission, opts && opts.fetcherSubmission, opts && opts.replace, opts && opts.initialHydration === true, flushSync, pendingActionResult, opts && opts.callSiteDefaultShouldRevalidate);
1464		if (shortCircuited) return;
1465		pendingNavigationController = null;
1466		completeNavigation(location, {
1467			matches: updatedMatches || matches,
1468			...getActionDataForCommit(pendingActionResult),
1469			loaderData,
1470			errors
1471		});
1472	}
1473	async function handleAction(request, location, submission, matches, scopedContext, isFogOfWar, initialHydration, opts = {}) {
1474		interruptActiveLoads();
1475		updateState({ navigation: getSubmittingNavigation(location, submission) }, { flushSync: opts.flushSync === true });
1476		if (isFogOfWar) {
1477			let discoverResult = await discoverRoutes(matches, location.pathname, request.signal);
1478			if (discoverResult.type === "aborted") return { shortCircuited: true };
1479			else if (discoverResult.type === "error") {
1480				if (discoverResult.partialMatches.length === 0) {
1481					let { matches: matches2, route } = getShortCircuitMatches(dataRoutes);
1482					return {
1483						matches: matches2,
1484						pendingActionResult: [route.id, {
1485							type: "error",
1486							error: discoverResult.error
1487						}]
1488					};
1489				}
1490				let boundaryId = findNearestBoundary(discoverResult.partialMatches).route.id;
1491				return {
1492					matches: discoverResult.partialMatches,
1493					pendingActionResult: [boundaryId, {
1494						type: "error",
1495						error: discoverResult.error
1496					}]
1497				};
1498			} else if (!discoverResult.matches) {
1499				let { notFoundMatches, error, route } = handleNavigational404(location.pathname);
1500				return {
1501					matches: notFoundMatches,
1502					pendingActionResult: [route.id, {
1503						type: "error",
1504						error
1505					}]
1506				};
1507			} else matches = discoverResult.matches;
1508		}
1509		let result;
1510		let actionMatch = getTargetMatch(matches, location);
1511		if (!actionMatch.route.action && !actionMatch.route.lazy) result = {
1512			type: "error",
1513			error: getInternalRouterError(405, {
1514				method: request.method,
1515				pathname: location.pathname,
1516				routeId: actionMatch.route.id
1517			})
1518		};
1519		else {
1520			let results = await callDataStrategy(request, location, getTargetedDataStrategyMatches(mapRouteProperties2, manifest, request, location, matches, actionMatch, initialHydration ? [] : hydrationRouteProperties2, scopedContext), scopedContext, null);
1521			result = results[actionMatch.route.id];
1522			if (!result) {
1523				for (let match of matches) if (results[match.route.id]) {
1524					result = results[match.route.id];
1525					break;
1526				}
1527			}
1528			if (request.signal.aborted) return { shortCircuited: true };
1529		}
1530		if (isRedirectResult(result)) {
1531			let replace2;
1532			if (opts && opts.replace != null) replace2 = opts.replace;
1533			else replace2 = normalizeRedirectLocation(result.response.headers.get("Location"), new URL(request.url), basename, init.history) === state.location.pathname + state.location.search;
1534			await startRedirectNavigation(request, result, true, {
1535				submission,
1536				replace: replace2
1537			});
1538			return { shortCircuited: true };
1539		}
1540		if (isErrorResult(result)) {
1541			let boundaryMatch = findNearestBoundary(matches, actionMatch.route.id);
1542			if ((opts && opts.replace) !== true) pendingAction = "PUSH";
1543			return {
1544				matches,
1545				pendingActionResult: [
1546					boundaryMatch.route.id,
1547					result,
1548					actionMatch.route.id
1549				]
1550			};
1551		}
1552		return {
1553			matches,
1554			pendingActionResult: [actionMatch.route.id, result]
1555		};
1556	}
1557	async function handleLoaders(request, location, matches, scopedContext, isFogOfWar, overrideNavigation, submission, fetcherSubmission, replace2, initialHydration, flushSync, pendingActionResult, callSiteDefaultShouldRevalidate) {
1558		let loadingNavigation = overrideNavigation || getLoadingNavigation(location, submission);
1559		let activeSubmission = submission || fetcherSubmission || getSubmissionFromNavigation(loadingNavigation);
1560		let shouldUpdateNavigationState = !isUninterruptedRevalidation && !initialHydration;
1561		if (isFogOfWar) {
1562			if (shouldUpdateNavigationState) {
1563				let actionData = getUpdatedActionData(pendingActionResult);
1564				updateState({
1565					navigation: loadingNavigation,
1566					...actionData !== void 0 ? { actionData } : {}
1567				}, { flushSync });
1568			}
1569			let discoverResult = await discoverRoutes(matches, location.pathname, request.signal);
1570			if (discoverResult.type === "aborted") return { shortCircuited: true };
1571			else if (discoverResult.type === "error") {
1572				if (discoverResult.partialMatches.length === 0) {
1573					let { matches: matches2, route } = getShortCircuitMatches(dataRoutes);
1574					return {
1575						matches: matches2,
1576						loaderData: {},
1577						errors: { [route.id]: discoverResult.error }
1578					};
1579				}
1580				let boundaryId = findNearestBoundary(discoverResult.partialMatches).route.id;
1581				return {
1582					matches: discoverResult.partialMatches,
1583					loaderData: {},
1584					errors: { [boundaryId]: discoverResult.error }
1585				};
1586			} else if (!discoverResult.matches) {
1587				let { error, notFoundMatches, route } = handleNavigational404(location.pathname);
1588				return {
1589					matches: notFoundMatches,
1590					loaderData: {},
1591					errors: { [route.id]: error }
1592				};
1593			} else matches = discoverResult.matches;
1594		}
1595		let routesToUse = inFlightDataRoutes || dataRoutes;
1596		let { dsMatches, revalidatingFetchers } = getMatchesToLoad(request, scopedContext, mapRouteProperties2, manifest, init.history, state, matches, activeSubmission, location, initialHydration ? [] : hydrationRouteProperties2, initialHydration === true, isRevalidationRequired, cancelledFetcherLoads, fetchersQueuedForDeletion, fetchLoadMatches, fetchRedirectIds, routesToUse, basename, init.patchRoutesOnNavigation != null, pendingActionResult, callSiteDefaultShouldRevalidate);
1597		pendingNavigationLoadId = ++incrementingLoadId;
1598		if (!init.dataStrategy && !dsMatches.some((m) => m.shouldLoad) && !dsMatches.some((m) => m.route.middleware && m.route.middleware.length > 0) && revalidatingFetchers.length === 0) {
1599			let updatedFetchers2 = markFetchRedirectsDone();
1600			completeNavigation(location, {
1601				matches,
1602				loaderData: {},
1603				errors: pendingActionResult && isErrorResult(pendingActionResult[1]) ? { [pendingActionResult[0]]: pendingActionResult[1].error } : null,
1604				...getActionDataForCommit(pendingActionResult),
1605				...updatedFetchers2 ? { fetchers: new Map(state.fetchers) } : {}
1606			}, { flushSync });
1607			return { shortCircuited: true };
1608		}
1609		if (shouldUpdateNavigationState) {
1610			let updates = {};
1611			if (!isFogOfWar) {
1612				updates.navigation = loadingNavigation;
1613				let actionData = getUpdatedActionData(pendingActionResult);
1614				if (actionData !== void 0) updates.actionData = actionData;
1615			}
1616			if (revalidatingFetchers.length > 0) updates.fetchers = getUpdatedRevalidatingFetchers(revalidatingFetchers);
1617			updateState(updates, { flushSync });
1618		}
1619		revalidatingFetchers.forEach((rf) => {
1620			abortFetcher(rf.key);
1621			if (rf.controller) fetchControllers.set(rf.key, rf.controller);
1622		});
1623		let abortPendingFetchRevalidations = () => revalidatingFetchers.forEach((f) => abortFetcher(f.key));
1624		if (pendingNavigationController) pendingNavigationController.signal.addEventListener("abort", abortPendingFetchRevalidations);
1625		let { loaderResults, fetcherResults } = await callLoadersAndMaybeResolveData(dsMatches, revalidatingFetchers, request, location, scopedContext);
1626		if (request.signal.aborted) return { shortCircuited: true };
1627		if (pendingNavigationController) pendingNavigationController.signal.removeEventListener("abort", abortPendingFetchRevalidations);
1628		revalidatingFetchers.forEach((rf) => fetchControllers.delete(rf.key));
1629		let redirect2 = findRedirect(loaderResults);
1630		if (redirect2) {
1631			await startRedirectNavigation(request, redirect2.result, true, { replace: replace2 });
1632			return { shortCircuited: true };
1633		}
1634		redirect2 = findRedirect(fetcherResults);
1635		if (redirect2) {
1636			fetchRedirectIds.add(redirect2.key);
1637			await startRedirectNavigation(request, redirect2.result, true, { replace: replace2 });
1638			return { shortCircuited: true };
1639		}
1640		let { loaderData, errors } = processLoaderData(state, matches, loaderResults, pendingActionResult, revalidatingFetchers, fetcherResults);
1641		if (initialHydration && state.errors) errors = {
1642			...state.errors,
1643			...errors
1644		};
1645		let updatedFetchers = markFetchRedirectsDone();
1646		let didAbortFetchLoads = abortStaleFetchLoads(pendingNavigationLoadId);
1647		let shouldUpdateFetchers = updatedFetchers || didAbortFetchLoads || revalidatingFetchers.length > 0;
1648		return {
1649			matches,
1650			loaderData,
1651			errors,
1652			...shouldUpdateFetchers ? { fetchers: new Map(state.fetchers) } : {}
1653		};
1654	}
1655	function getUpdatedActionData(pendingActionResult) {
1656		if (pendingActionResult && !isErrorResult(pendingActionResult[1])) return { [pendingActionResult[0]]: pendingActionResult[1].data };
1657		else if (state.actionData) if (Object.keys(state.actionData).length === 0) return null;
1658		else return state.actionData;
1659	}
1660	function getUpdatedRevalidatingFetchers(revalidatingFetchers) {
1661		revalidatingFetchers.forEach((rf) => {
1662			let fetcher = state.fetchers.get(rf.key);
1663			let revalidatingFetcher = getLoadingFetcher(void 0, fetcher ? fetcher.data : void 0);
1664			state.fetchers.set(rf.key, revalidatingFetcher);
1665		});
1666		return new Map(state.fetchers);
1667	}
1668	async function fetch2(key, routeId, href, opts) {
1669		abortFetcher(key);
1670		let flushSync = (opts && opts.flushSync) === true;
1671		let routesToUse = inFlightDataRoutes || dataRoutes;
1672		let normalizedPath = normalizeTo(state.location, state.matches, basename, href, routeId, opts?.relative);
1673		let matches = matchRoutes(routesToUse, normalizedPath, basename);
1674		let fogOfWar = checkFogOfWar(matches, routesToUse, normalizedPath);
1675		if (fogOfWar.active && fogOfWar.matches) matches = fogOfWar.matches;
1676		if (!matches) {
1677			setFetcherError(key, routeId, getInternalRouterError(404, { pathname: normalizedPath }), { flushSync });
1678			return;
1679		}
1680		let { path, submission, error } = normalizeNavigateOptions(true, normalizedPath, opts);
1681		if (error) {
1682			setFetcherError(key, routeId, error, { flushSync });
1683			return;
1684		}
1685		let scopedContext = init.getContext ? await init.getContext() : new RouterContextProvider();
1686		let preventScrollReset = (opts && opts.preventScrollReset) === true;
1687		if (submission && isMutationMethod(submission.formMethod)) {
1688			await handleFetcherAction(key, routeId, path, matches, scopedContext, fogOfWar.active, flushSync, preventScrollReset, submission, opts && opts.unstable_defaultShouldRevalidate);
1689			return;
1690		}
1691		fetchLoadMatches.set(key, {
1692			routeId,
1693			path
1694		});
1695		await handleFetcherLoader(key, routeId, path, matches, scopedContext, fogOfWar.active, flushSync, preventScrollReset, submission);
1696	}
1697	async function handleFetcherAction(key, routeId, path, requestMatches, scopedContext, isFogOfWar, flushSync, preventScrollReset, submission, callSiteDefaultShouldRevalidate) {
1698		interruptActiveLoads();
1699		fetchLoadMatches.delete(key);
1700		updateFetcherState(key, getSubmittingFetcher(submission, state.fetchers.get(key)), { flushSync });
1701		let abortController = new AbortController();
1702		let fetchRequest = createClientSideRequest(init.history, path, abortController.signal, submission);
1703		if (isFogOfWar) {
1704			let discoverResult = await discoverRoutes(requestMatches, new URL(fetchRequest.url).pathname, fetchRequest.signal, key);
1705			if (discoverResult.type === "aborted") return;
1706			else if (discoverResult.type === "error") {
1707				setFetcherError(key, routeId, discoverResult.error, { flushSync });
1708				return;
1709			} else if (!discoverResult.matches) {
1710				setFetcherError(key, routeId, getInternalRouterError(404, { pathname: path }), { flushSync });
1711				return;
1712			} else requestMatches = discoverResult.matches;
1713		}
1714		let match = getTargetMatch(requestMatches, path);
1715		if (!match.route.action && !match.route.lazy) {
1716			setFetcherError(key, routeId, getInternalRouterError(405, {
1717				method: submission.formMethod,
1718				pathname: path,
1719				routeId
1720			}), { flushSync });
1721			return;
1722		}
1723		fetchControllers.set(key, abortController);
1724		let originatingLoadId = incrementingLoadId;
1725		let fetchMatches = getTargetedDataStrategyMatches(mapRouteProperties2, manifest, fetchRequest, path, requestMatches, match, hydrationRouteProperties2, scopedContext);
1726		let actionResults = await callDataStrategy(fetchRequest, path, fetchMatches, scopedContext, key);
1727		let actionResult = actionResults[match.route.id];
1728		if (!actionResult) {
1729			for (let match2 of fetchMatches) if (actionResults[match2.route.id]) {
1730				actionResult = actionResults[match2.route.id];
1731				break;
1732			}
1733		}
1734		if (fetchRequest.signal.aborted) {
1735			if (fetchControllers.get(key) === abortController) fetchControllers.delete(key);
1736			return;
1737		}
1738		if (fetchersQueuedForDeletion.has(key)) {
1739			if (isRedirectResult(actionResult) || isErrorResult(actionResult)) {
1740				updateFetcherState(key, getDoneFetcher(void 0));
1741				return;
1742			}
1743		} else {
1744			if (isRedirectResult(actionResult)) {
1745				fetchControllers.delete(key);
1746				if (pendingNavigationLoadId > originatingLoadId) {
1747					updateFetcherState(key, getDoneFetcher(void 0));
1748					return;
1749				} else {
1750					fetchRedirectIds.add(key);
1751					updateFetcherState(key, getLoadingFetcher(submission));
1752					return startRedirectNavigation(fetchRequest, actionResult, false, {
1753						fetcherSubmission: submission,
1754						preventScrollReset
1755					});
1756				}
1757			}
1758			if (isErrorResult(actionResult)) {
1759				setFetcherError(key, routeId, actionResult.error);
1760				return;
1761			}
1762		}
1763		let nextLocation = state.navigation.location || state.location;

1802		abortStaleFetchLoads(loadId);
1803		if (state.navigation.state === "loading" && loadId > pendingNavigationLoadId) {
1804			invariant(pendingAction, "Expected pending action");
1805			pendingNavigationController && pendingNavigationController.abort();
1806			completeNavigation(state.navigation.location, {
1807				matches,
1808				loaderData,
1809				errors,
1810				fetchers: new Map(state.fetchers)
1811			});
1812		} else {
1813			updateState({
1814				errors,
1815				loaderData: mergeLoaderData(state.loaderData, loaderData, matches, errors),
1816				fetchers: new Map(state.fetchers)
1817			});
1818			isRevalidationRequired = false;
1819		}
1820	}
1821	async function handleFetcherLoader(key, routeId, path, matches, scopedContext, isFogOfWar, flushSync, preventScrollReset, submission) {
1822		let existingFetcher = state.fetchers.get(key);
1823		updateFetcherState(key, getLoadingFetcher(submission, existingFetcher ? existingFetcher.data : void 0), { flushSync });
1824		let abortController = new AbortController();
1825		let fetchRequest = createClientSideRequest(init.history, path, abortController.signal);
1826		if (isFogOfWar) {
1827			let discoverResult = await discoverRoutes(matches, new URL(fetchRequest.url).pathname, fetchRequest.signal, key);
1828			if (discoverResult.type === "aborted") return;
1829			else if (discoverResult.type === "error") {
1830				setFetcherError(key, routeId, discoverResult.error, { flushSync });
1831				return;
1832			} else if (!discoverResult.matches) {
1833				setFetcherError(key, routeId, getInternalRouterError(404, { pathname: path }), { flushSync });
1834				return;
1835			} else matches = discoverResult.matches;
1836		}
1837		let match = getTargetMatch(matches, path);
1838		fetchControllers.set(key, abortController);
1839		let originatingLoadId = incrementingLoadId;
1840		let result = (await callDataStrategy(fetchRequest, path, getTargetedDataStrategyMatches(mapRouteProperties2, manifest, fetchRequest, path, matches, match, hydrationRouteProperties2, scopedContext), scopedContext, key))[match.route.id];
1841		if (fetchControllers.get(key) === abortController) fetchControllers.delete(key);
1842		if (fetchRequest.signal.aborted) return;
1843		if (fetchersQueuedForDeletion.has(key)) {
1844			updateFetcherState(key, getDoneFetcher(void 0));
1845			return;
1846		}
1847		if (isRedirectResult(result)) if (pendingNavigationLoadId > originatingLoadId) {
1848			updateFetcherState(key, getDoneFetcher(void 0));
1849			return;
1850		} else {
1851			fetchRedirectIds.add(key);
1852			await startRedirectNavigation(fetchRequest, result, false, { preventScrollReset });
1853			return;
1854		}
1855		if (isErrorResult(result)) {
1856			setFetcherError(key, routeId, result.error);
1857			return;
1858		}
1859		updateFetcherState(key, getDoneFetcher(result.data));
1860	}
1861	async function startRedirectNavigation(request, redirect2, isNavigation, { submission, fetcherSubmission, preventScrollReset, replace: replace2 } = {}) {
1862		if (!isNavigation) {
1863			pendingPopstateNavigationDfd?.resolve();
1864			pendingPopstateNavigationDfd = null;
1865		}
1866		if (redirect2.response.headers.has("X-Remix-Revalidate")) isRevalidationRequired = true;
1867		let location = redirect2.response.headers.get("Location");
1868		invariant(location, "Expected a Location header on the redirect Response");
1869		location = normalizeRedirectLocation(location, new URL(request.url), basename, init.history);
1870		let redirectLocation = createLocation(state.location, location, { _isRedirect: true });
1871		if (isBrowser3) {
1872			let isDocumentReload = false;
1873			if (redirect2.response.headers.has("X-Remix-Reload-Document")) isDocumentReload = true;
1874			else if (isAbsoluteUrl(location)) {
1875				const url = createBrowserURLImpl(location, true);
1876				isDocumentReload = url.origin !== routerWindow.location.origin || stripBasename(url.pathname, basename) == null;
1877			}
1878			if (isDocumentReload) {
1879				if (replace2) routerWindow.location.replace(location);
1880				else routerWindow.location.assign(location);
1881				return;
1882			}
1883		}
1884		pendingNavigationController = null;
1885		let redirectNavigationType = replace2 === true || redirect2.response.headers.has("X-Remix-Replace") ? "REPLACE" : "PUSH";
1886		let { formMethod, formAction, formEncType } = state.navigation;
1887		if (!submission && !fetcherSubmission && formMethod && formAction && formEncType) submission = getSubmissionFromNavigation(state.navigation);
1888		let activeSubmission = submission || fetcherSubmission;
1889		if (redirectPreserveMethodStatusCodes.has(redirect2.response.status) && activeSubmission && isMutationMethod(activeSubmission.formMethod)) await startNavigation(redirectNavigationType, redirectLocation, {
1890			submission: {
1891				...activeSubmission,
1892				formAction: location
1893			},
1894			preventScrollReset: preventScrollReset || pendingPreventScrollReset,
1895			enableViewTransition: isNavigation ? pendingViewTransitionEnabled : void 0
1896		});
1897		else await startNavigation(redirectNavigationType, redirectLocation, {
1898			overrideNavigation: getLoadingNavigation(redirectLocation, submission),
1899			fetcherSubmission,
1900			preventScrollReset: preventScrollReset || pendingPreventScrollReset,
1901			enableViewTransition: isNavigation ? pendingViewTransitionEnabled : void 0
1902		});
1903	}
1904	async function callDataStrategy(request, path, matches, scopedContext, fetcherKey) {
1905		let results;
1906		let dataResults = {};
1907		try {
1908			results = await callDataStrategyImpl(dataStrategyImpl, request, path, matches, fetcherKey, scopedContext, false);
1909		} catch (e) {
1910			matches.filter((m) => m.shouldLoad).forEach((m) => {
1911				dataResults[m.route.id] = {
1912					type: "error",
1913					error: e
1914				};
1915			});
1916			return dataResults;
1917		}
1918		if (request.signal.aborted) return dataResults;
1919		if (!isMutationMethod(request.method)) for (let match of matches) {
1920			if (results[match.route.id]?.type === "error") break;
1921			if (!results.hasOwnProperty(match.route.id) && !state.loaderData.hasOwnProperty(match.route.id) && (!state.errors || !state.errors.hasOwnProperty(match.route.id)) && match.shouldCallHandler()) results[match.route.id] = {
1922				type: "error",
1923				result: /* @__PURE__ */ new Error(`No result returned from dataStrategy for route ${match.route.id}`)
1924			};
1925		}
1926		for (let [routeId, result] of Object.entries(results)) if (isRedirectDataStrategyResult(result)) {
1927			let response = result.result;
1928			dataResults[routeId] = {
1929				type: "redirect",
1930				response: normalizeRelativeRoutingRedirectResponse(response, request, routeId, matches, basename)
1931			};
1932		} else dataResults[routeId] = await convertDataStrategyResultToDataResult(result);
1933		return dataResults;
1934	}
1935	async function callLoadersAndMaybeResolveData(matches, fetchersToLoad, request, location, scopedContext) {
1936		let loaderResultsPromise = callDataStrategy(request, location, matches, scopedContext, null);
1937		let fetcherResultsPromise = Promise.all(fetchersToLoad.map(async (f) => {
1938			if (f.matches && f.match && f.request && f.controller) {
1939				let result = (await callDataStrategy(f.request, f.path, f.matches, scopedContext, f.key))[f.match.route.id];
1940				return { [f.key]: result };
1941			} else return Promise.resolve({ [f.key]: {
1942				type: "error",
1943				error: getInternalRouterError(404, { pathname: f.path })
1944			} });
1945		}));
1946		return {
1947			loaderResults: await loaderResultsPromise,
1948			fetcherResults: (await fetcherResultsPromise).reduce((acc, r) => Object.assign(acc, r), {})
1949		};
1950	}
1951	function interruptActiveLoads() {
1952		isRevalidationRequired = true;
1953		fetchLoadMatches.forEach((_, key) => {
1954			if (fetchControllers.has(key)) cancelledFetcherLoads.add(key);
1955			abortFetcher(key);
1956		});
1957	}
1958	function updateFetcherState(key, fetcher, opts = {}) {
1959		state.fetchers.set(key, fetcher);
1960		updateState({ fetchers: new Map(state.fetchers) }, { flushSync: (opts && opts.flushSync) === true });
1961	}
1962	function setFetcherError(key, routeId, error, opts = {}) {
1963		let boundaryMatch = findNearestBoundary(state.matches, routeId);
1964		deleteFetcher(key);
1965		updateState({
1966			errors: { [boundaryMatch.route.id]: error },
1967			fetchers: new Map(state.fetchers)
1968		}, { flushSync: (opts && opts.flushSync) === true });
1969	}
1970	function getFetcher(key) {
1971		activeFetchers.set(key, (activeFetchers.get(key) || 0) + 1);
1972		if (fetchersQueuedForDeletion.has(key)) fetchersQueuedForDeletion.delete(key);
1973		return state.fetchers.get(key) || IDLE_FETCHER;
1974	}
1975	function resetFetcher(key, opts) {
1976		abortFetcher(key, opts?.reason);
1977		updateFetcherState(key, getDoneFetcher(null));
1978	}
1979	function deleteFetcher(key) {
1980		let fetcher = state.fetchers.get(key);
1981		if (fetchControllers.has(key) && !(fetcher && fetcher.state === "loading" && fetchReloadIds.has(key))) abortFetcher(key);
1982		fetchLoadMatches.delete(key);
1983		fetchReloadIds.delete(key);
1984		fetchRedirectIds.delete(key);
1985		fetchersQueuedForDeletion.delete(key);
1986		cancelledFetcherLoads.delete(key);
1987		state.fetchers.delete(key);
1988	}
1989	function queueFetcherForDeletion(key) {
1990		let count = (activeFetchers.get(key) || 0) - 1;
1991		if (count <= 0) {
1992			activeFetchers.delete(key);
1993			fetchersQueuedForDeletion.add(key);
1994		} else activeFetchers.set(key, count);
1995		updateState({ fetchers: new Map(state.fetchers) });
1996	}
1997	function abortFetcher(key, reason) {
1998		let controller = fetchControllers.get(key);
1999		if (controller) {
2000			controller.abort(reason);
2001			fetchControllers.delete(key);
2002		}
2003	}
2004	function markFetchersDone(keys) {
2005		for (let key of keys) {
2006			let doneFetcher = getDoneFetcher(getFetcher(key).data);
2007			state.fetchers.set(key, doneFetcher);
2008		}
2009	}
2010	function markFetchRedirectsDone() {
2011		let doneKeys = [];
2012		let updatedFetchers = false;
2013		for (let key of fetchRedirectIds) {
2014			let fetcher = state.fetchers.get(key);
2015			invariant(fetcher, `Expected fetcher: ${key}`);
2016			if (fetcher.state === "loading") {
2017				fetchRedirectIds.delete(key);
2018				doneKeys.push(key);
2019				updatedFetchers = true;
2020			}
2021		}
2022		markFetchersDone(doneKeys);
2023		return updatedFetchers;
2024	}
2025	function abortStaleFetchLoads(landedId) {
2026		let yeetedKeys = [];
2027		for (let [key, id] of fetchReloadIds) if (id < landedId) {
2028			let fetcher = state.fetchers.get(key);
2029			invariant(fetcher, `Expected fetcher: ${key}`);
2030			if (fetcher.state === "loading") {
2031				abortFetcher(key);
2032				fetchReloadIds.delete(key);
2033				yeetedKeys.push(key);
2034			}
2035		}
2036		markFetchersDone(yeetedKeys);
2037		return yeetedKeys.length > 0;
2038	}
2039	function getBlocker(key, fn) {
2040		let blocker = state.blockers.get(key) || IDLE_BLOCKER;
2041		if (blockerFunctions.get(key) !== fn) blockerFunctions.set(key, fn);
2042		return blocker;
2043	}
2044	function deleteBlocker(key) {
2045		state.blockers.delete(key);
2046		blockerFunctions.delete(key);
2047	}
2048	function updateBlocker(key, newBlocker) {
2049		let blocker = state.blockers.get(key) || IDLE_BLOCKER;
2050		invariant(blocker.state === "unblocked" && newBlocker.state === "blocked" || blocker.state === "blocked" && newBlocker.state === "blocked" || blocker.state === "blocked" && newBlocker.state === "proceeding" || blocker.state === "blocked" && newBlocker.state === "unblocked" || blocker.state === "proceeding" && newBlocker.state === "unblocked", `Invalid blocker state transition: ${blocker.state} -> ${newBlocker.state}`);
2051		let blockers = new Map(state.blockers);
2052		blockers.set(key, newBlocker);
2053		updateState({ blockers });
2054	}
2055	function shouldBlockNavigation({ currentLocation, nextLocation, historyAction }) {
2056		if (blockerFunctions.size === 0) return;
2057		if (blockerFunctions.size > 1) warning(false, "A router only supports one blocker at a time");
2058		let entries = Array.from(blockerFunctions.entries());
2059		let [blockerKey, blockerFunction] = entries[entries.length - 1];
2060		let blocker = state.blockers.get(blockerKey);
2061		if (blocker && blocker.state === "proceeding") return;
2062		if (blockerFunction({
2063			currentLocation,
2064			nextLocation,
2065			historyAction
2066		})) return blockerKey;
2067	}
2068	function handleNavigational404(pathname) {
2069		let error = getInternalRouterError(404, { pathname });
2070		let { matches, route } = getShortCircuitMatches(inFlightDataRoutes || dataRoutes);
2071		return {
2072			notFoundMatches: matches,
2073			route,
2074			error
2075		};
2076	}
2077	function enableScrollRestoration(positions, getPosition, getKey) {
2078		savedScrollPositions2 = positions;
2079		getScrollPosition = getPosition;
2080		getScrollRestorationKey2 = getKey || null;
2081		if (!initialScrollRestored && state.navigation === IDLE_NAVIGATION) {
2082			initialScrollRestored = true;
2083			let y = getSavedScrollPosition(state.location, state.matches);
2084			if (y != null) updateState({ restoreScrollPosition: y });
2085		}
2086		return () => {
2087			savedScrollPositions2 = null;
2088			getScrollPosition = null;
2089			getScrollRestorationKey2 = null;
2090		};
2091	}
2092	function getScrollKey(location, matches) {
2093		if (getScrollRestorationKey2) return getScrollRestorationKey2(location, matches.map((m) => convertRouteMatchToUiMatch(m, state.loaderData))) || location.key;
2094		return location.key;
2095	}
2096	function saveScrollPosition(location, matches) {
2097		if (savedScrollPositions2 && getScrollPosition) {
2098			let key = getScrollKey(location, matches);
2099			savedScrollPositions2[key] = getScrollPosition();
2100		}
2101	}
2102	function getSavedScrollPosition(location, matches) {
2103		if (savedScrollPositions2) {
2104			let key = getScrollKey(location, matches);

2245 i.route).filter(Boolean), route)
2246			};
2247		};
2248	}
2249	let dataRoutes = convertRoutesToDataRoutes(routes, mapRouteProperties2, void 0, manifest);
2250	async function query(request, { requestContext, filterMatchesToLoad, skipLoaderErrorBubbling, skipRevalidation, dataStrategy, generateMiddlewareResponse, unstable_normalizePath } = {}) {
2251		let normalizePath = unstable_normalizePath || defaultNormalizePath;
2252		let method = request.method;
2253		let location = createLocation("", normalizePath(request), null, "default");
2254		let matches = matchRoutes(dataRoutes, location, basename);
2255		requestContext = requestContext != null ? requestContext : new RouterContextProvider();
2256		if (!isValidMethod(method) && method !== "HEAD") {
2257			let error = getInternalRouterError(405, { method });
2258			let { matches: methodNotAllowedMatches, route } = getShortCircuitMatches(dataRoutes);
2259			let staticContext = {
2260				basename,
2261				location,
2262				matches: methodNotAllowedMatches,
2263				loaderData: {},
2264				actionData: null,
2265				errors: { [route.id]: error },
2266				statusCode: error.status,
2267				loaderHeaders: {},
2268				actionHeaders: {}
2269			};
2270			return generateMiddlewareResponse ? generateMiddlewareResponse(() => Promise.resolve(staticContext)) : staticContext;
2271		} else if (!matches) {
2272			let error = getInternalRouterError(404, { pathname: location.pathname });
2273			let { matches: notFoundMatches, route } = getShortCircuitMatches(dataRoutes);
2274			let staticContext = {
2275				basename,
2276				location,
2277				matches: notFoundMatches,
2278				loaderData: {},
2279				actionData: null,
2280				errors: { [route.id]: error },
2281				statusCode: error.status,
2282				loaderHeaders: {},
2283				actionHeaders: {}
2284			};
2285			return generateMiddlewareResponse ? generateMiddlewareResponse(() => Promise.resolve(staticContext)) : staticContext;
2286		}
2287		if (generateMiddlewareResponse) {
2288			invariant(requestContext instanceof RouterContextProvider, "When using middleware in `staticHandler.query()`, any provided `requestContext` must be an instance of `RouterContextProvider`");
2289			try {
2290				await loadLazyMiddlewareForMatches(matches, manifest, mapRouteProperties2);
2291				let renderedStaticContext;
2292				let response = await runServerMiddlewarePipeline({
2293					request,
2294					unstable_url: createDataFunctionUrl(request, location),
2295					unstable_pattern: getRoutePattern(matches),
2296					matches,
2297					params: matches[0].params,
2298					context: requestContext
2299				}, async () => {
2300					return await generateMiddlewareResponse(async (revalidationRequest, opts2 = {}) => {
2301						let result2 = await queryImpl(revalidationRequest, location, matches, requestContext, dataStrategy || null, skipLoaderErrorBubbling === true, null, "filterMatchesToLoad" in opts2 ? opts2.filterMatchesToLoad ?? null : filterMatchesToLoad ?? null, skipRevalidation === true);
2302						if (isResponse(result2)) return result2;
2303						renderedStaticContext = {
2304							location,
2305							basename,
2306							...result2
2307						};
2308						return renderedStaticContext;
2309					});
2310				}, async (error, routeId) => {
2311					if (isRedirectResponse(error)) return error;
2312					if (isResponse(error)) try {
2313						error = new ErrorResponseImpl(error.status, error.statusText, await parseResponseBody(error));
2314					} catch (e) {
2315						error = e;
2316					}
2317					if (isDataWithResponseInit(error)) error = dataWithResponseInitToErrorResponse(error);
2318					if (renderedStaticContext) {
2319						if (routeId in renderedStaticContext.loaderData) renderedStaticContext.loaderData[routeId] = void 0;
2320						let staticContext = getStaticContextFromError(dataRoutes, renderedStaticContext, error, skipLoaderErrorBubbling ? routeId : findNearestBoundary(matches, routeId).route.id);
2321						return generateMiddlewareResponse(() => Promise.resolve(staticContext));
2322					} else {
2323						let staticContext = {
2324							matches,
2325							location,
2326							basename,
2327							loaderData: {},
2328							actionData: null,
2329							errors: { [skipLoaderErrorBubbling ? routeId : findNearestBoundary(matches, matches.find((m) => m.route.id === routeId || m.route.loader)?.route.id || routeId).route.id]: error },
2330							statusCode: isRouteErrorResponse(error) ? error.status : 500,
2331							actionHeaders: {},
2332							loaderHeaders: {}
2333						};
2334						return generateMiddlewareResponse(() => Promise.resolve(staticContext));
2335					}
2336				});
2337				invariant(isResponse(response), "Expected a response in query()");
2338				return response;
2339			} catch (e) {
2340				if (isResponse(e)) return e;
2341				throw e;
2342			}
2343		}
2344		let result = await queryImpl(request, location, matches, requestContext, dataStrategy || null, skipLoaderErrorBubbling === true, null, filterMatchesToLoad || null, skipRevalidation === true);
2345		if (isResponse(result)) return result;
2346		return {
2347			location,
2348			basename,
2349			...result
2350		};
2351	}
2352	async function queryRoute(request, { routeId, requestContext, dataStrategy, generateMiddlewareResponse, unstable_normalizePath } = {}) {
2353		let normalizePath = unstable_normalizePath || defaultNormalizePath;
2354		let method = request.method;
2355		let location = createLocation("", normalizePath(request), null, "default");
2356		let matches = matchRoutes(dataRoutes, location, basename);
2357		requestContext = requestContext != null ? requestContext : new RouterContextProvider();
2358		if (!isValidMethod(method) && method !== "HEAD" && method !== "OPTIONS") throw getInternalRouterError(405, { method });
2359		else if (!matches) throw getInternalRouterError(404, { pathname: location.pathname });
2360		let match = routeId ? matches.find((m) => m.route.id === routeId) : getTargetMatch(matches, location);
2361		if (routeId && !match) throw getInternalRouterError(403, {
2362			pathname: location.pathname,
2363			routeId
2364		});
2365		else if (!match) throw getInternalRouterError(404, { pathname: location.pathname });
2366		if (generateMiddlewareResponse) {
2367			invariant(requestContext instanceof RouterContextProvider, "When using middleware in `staticHandler.queryRoute()`, any provided `requestContext` must be an instance of `RouterContextProvider`");
2368			await loadLazyMiddlewareForMatches(matches, manifest, mapRouteProperties2);
2369			return await runServerMiddlewarePipeline({
2370				request,
2371				unstable_url: createDataFunctionUrl(request, location),
2372				unstable_pattern: getRoutePattern(matches),
2373				matches,
2374				params: matches[0].params,
2375				context: requestContext
2376			}, async () => {
2377				return await generateMiddlewareResponse(async (innerRequest) => {
2378					let processed = handleQueryResult(await queryImpl(innerRequest, location, matches, requestContext, dataStrategy || null, false, match, null, false));
2379					return isResponse(processed) ? processed : typeof processed === "string" ? new Response(processed) : Response.json(processed);
2380				});
2381			}, (error) => {
2382				if (isDataWithResponseInit(error)) return Promise.resolve(dataWithResponseInitToResponse(error));
2383				if (isResponse(error)) return Promise.resolve(error);
2384				throw error;
2385			});
2386		}
2387		return handleQueryResult(await queryImpl(request, location, matches, requestContext, dataStrategy || null, false, match, null, false));
2388		function handleQueryResult(result2) {
2389			if (isResponse(result2)) return result2;
2390			let error = result2.errors ? Object.values(result2.errors)[0] : void 0;
2391			if (error !== void 0) throw error;
2392			if (result2.actionData) return Object.values(result2.actionData)[0];
2393			if (result2.loaderData) return Object.values(result2.loaderData)[0];
2394		}
2395	}
2396	async function queryImpl(request, location, matches, requestContext, dataStrategy, skipLoaderErrorBubbling, routeMatch, filterMatchesToLoad, skipRevalidation) {
2397		invariant(request.signal, "query()/queryRoute() requests must contain an AbortController signal");
2398		try {
2399			if (isMutationMethod(request.method)) return await submit(request, location, matches, routeMatch || getTargetMatch(matches, location), requestContext, dataStrategy, skipLoaderErrorBubbling, routeMatch != null, filterMatchesToLoad, skipRevalidation);
2400			let result = await loadRouteData(request, location, matches, requestContext, dataStrategy, skipLoaderErrorBubbling, routeMatch, filterMatchesToLoad);
2401			return isResponse(result) ? result : {
2402				...result,
2403				actionData: null,
2404				actionHeaders: {}
2405			};
2406		} catch (e) {
2407			if (isDataStrategyResult(e) && isResponse(e.result)) {
2408				if (e.type === "error") throw e.result;
2409				return e.result;
2410			}
2411			if (isRedirectResponse(e)) return e;
2412			throw e;
2413		}
2414	}
2415	async function submit(request, location, matches, actionMatch, requestContext, dataStrategy, skipLoaderErrorBubbling, isRouteRequest, filterMatchesToLoad, skipRevalidation) {
2416		let result;
2417		if (!actionMatch.route.action && !actionMatch.route.lazy) {
2418			let error = getInternalRouterError(405, {
2419				method: request.method,
2420				pathname: new URL(request.url).pathname,
2421				routeId: actionMatch.route.id
2422			});
2423			if (isRouteRequest) throw error;
2424			result = {
2425				type: "error",
2426				error
2427			};
2428		} else {
2429			result = (await callDataStrategy(request, location, getTargetedDataStrategyMatches(mapRouteProperties2, manifest, request, location, matches, actionMatch, [], requestContext), isRouteRequest, requestContext, dataStrategy))[actionMatch.route.id];
2430			if (request.signal.aborted) throwStaticHandlerAbortedError(request, isRouteRequest);
2431		}
2432		if (isRedirectResult(result)) throw new Response(null, {
2433			status: result.response.status,
2434			headers: { Location: result.response.headers.get("Location") }
2435		});
2436		if (isRouteRequest) {
2437			if (isErrorResult(result)) throw result.error;
2438			return {
2439				matches: [actionMatch],
2440				loaderData: {},
2441				actionData: { [actionMatch.route.id]: result.data },
2442				errors: null,
2443				statusCode: 200,
2444				loaderHeaders: {},
2445				actionHeaders: {}
2446			};
2447		}
2448		if (skipRevalidation) if (isErrorResult(result)) {

2449			let boundaryMatch = skipLoaderErrorBubbling ? actionMatch : findNearestBoundary(matches, actionMatch.route.id);
2450			return {
2451				statusCode: isRouteErrorResponse(result.error) ? result.error.status : result.statusCode != null ? result.statusCode : 500,
2452				actionData: null,
2453				actionHeaders: { ...result.headers ? { [actionMatch.route.id]: result.headers } : {} },
2454				matches,
2455				loaderData: {},
2456				errors: { [boundaryMatch.route.id]: result.error },
2457				loaderHeaders: {}
2458			};
2459		} else return {
2460			actionData: { [actionMatch.route.id]: result.data },
2461			actionHeaders: result.headers ? { [actionMatch.route.id]: result.headers } : {},
2462			matches,
2463			loaderData: {},
2464			errors: null,
2465			statusCode: result.statusCode || 200,
2466			loaderHeaders: {}
2467		};
2468		let loaderRequest = new Request(request.url, {
2469			headers: request.headers,
2470			redirect: request.redirect,
2471			signal: request.signal
2472		});
2473		if (isErrorResult(result)) return {
2474			...await loadRouteData(loaderRequest, location, matches, requestContext, dataStrategy, skipLoaderErrorBubbling, null, filterMatchesToLoad, [(skipLoaderErrorBubbling ? actionMatch : findNearestBoundary(matches, actionMatch.route.id)).route.id, result]),
2475			statusCode: isRouteErrorResponse(result.error) ? result.error.status : result.statusCode != null ? result.statusCode : 500,
2476			actionData: null,
2477			actionHeaders: { ...result.headers ? { [actionMatch.route.id]: result.headers } : {} }
2478		};
2479		return {
2480			...await loadRouteData(loaderRequest, location, matches, requestContext, dataStrategy, skipLoaderErrorBubbling, null, filterMatchesToLoad),
2481			actionData: { [actionMatch.route.id]: result.data },
2482			...result.statusCode ? { statusCode: result.statusCode } : {},
2483			actionHeaders: result.headers ? { [actionMatch.route.id]: result.headers } : {}
2484		};
2485	}
2486	async function loadRouteData(request, location, matches, requestContext, dataStrategy, skipLoaderErrorBubbling, routeMatch, filterMatchesToLoad, pendingActionResult) {
2487		let isRouteRequest = routeMatch != null;
2488		if (isRouteRequest && !routeMatch?.route.loader && !routeMatch?.route.lazy) throw getInternalRouterError(400, {
2489			method: request.method,
2490			pathname: new URL(request.url).pathname,
2491			routeId: routeMatch?.route.id
2492		});
2493		let dsMatches;
2494		if (routeMatch) dsMatches = getTargetedDataStrategyMatches(mapRouteProperties2, manifest, request, location, matches, routeMatch, [], requestContext);
2495		else {
2496			let maxIdx = pendingActionResult && isErrorResult(pendingActionResult[1]) ? matches.findIndex((m) => m.route.id === pendingActionResult[0]) - 1 : void 0;
2497			let pattern = getRoutePattern(matches);
2498			dsMatches = matches.map((match, index) => {
2499				if (maxIdx != null && index > maxIdx) return getDataStrategyMatch(mapRouteProperties2, manifest, request, location, pattern, match, [], requestContext, false);
2500				return getDataStrategyMatch(mapRouteProperties2, manifest, request, location, pattern, match, [], requestContext, (match.route.loader || match.route.lazy) != null && (!filterMatchesToLoad || filterMatchesToLoad(match)));
2501			});
2502		}
2503		if (!dataStrategy && !dsMatches.some((m) => m.shouldLoad)) return {
2504			matches,
2505			loaderData: {},
2506			errors: pendingActionResult && isErrorResult(pendingActionResult[1]) ? { [pendingActionResult[0]]: pendingActionResult[1].error } : null,
2507			statusCode: 200,
2508			loaderHeaders: {}
2509		};
2510		let results = await callDataStrategy(request, location, dsMatches, isRouteRequest, requestContext, dataStrategy);
2511		if (request.signal.aborted) throwStaticHandlerAbortedError(request, isRouteRequest);
2512		return {
2513			...processRouteLoaderData(matches, results, pendingActionResult, true, skipLoaderErrorBubbling),
2514			matches
2515		};
2516	}
2517	async function callDataStrategy(request, location, matches, isRouteRequest, requestContext, dataStrategy) {
2518		let results = await callDataStrategyImpl(dataStrategy || defaultDataStrategy, request, location, matches, null, requestContext, true);
2519		let dataResults = {};
2520		await Promise.all(matches.map(async (match) => {
2521			if (!(match.route.id in results)) return;
2522			let result = results[match.route.id];
2523			if (isRedirectDataStrategyResult(result)) {
2524				let response = result.result;
2525				throw normalizeRelativeRoutingRedirectResponse(response, request, match.route.id, matches, basename);
2526			}
2527			if (isRouteRequest) {
2528				if (isResponse(result.result)) throw result;
2529				else if (isDataWithResponseInit(result.result)) throw dataWithResponseInitToResponse(result.result);
2530			}
2531			dataResults[match.route.id] = await convertDataStrategyResultToDataResult(result);
2532		}));
2533		return dataResults;
2534	}
2535	return {
2536		dataRoutes,
2537		query,
2538		queryRoute
2539	};
2540}
2541function getStaticContextFromError(routes, handlerContext, error, boundaryId) {
2542	let errorBoundaryId = boundaryId || handlerContext._deepestRenderedBoundaryId || routes[0].id;
2543	return {
2544		...handlerContext,
2545		statusCode: isRouteErrorResponse(error) ? error.status : 500,
2546		errors: { [errorBoundaryId]: error }
2547	};
2548}
2549function throwStaticHandlerAbortedError(request, isRouteRequest) {
2550	if (request.signal.reason !== void 0) throw request.signal.reason;
2551	throw new Error(`${isRouteRequest ? "queryRoute" : "query"}() call aborted without an \`AbortSignal.reason\`: ${request.method} ${request.url}`);
2552}
2553function isSubmissionNavigation(opts) {
2554	return opts != null && ("formData" in opts && opts.formData != null || "body" in opts && opts.body !== void 0);
2555}
2556function defaultNormalizePath(request) {
2557	let url = new URL(request.url);
2558	return {
2559		pathname: url.pathname,
2560		search: url.search,
2561		hash: url.hash
2562	};
2563}
2564function normalizeTo(location, matches, basename, to, fromRouteId, relative) {
2565	let contextualMatches;
2566	let activeRouteMatch;
2567	if (fromRouteId) {
2568		contextualMatches = [];
2569		for (let match of matches) {
2570			contextualMatches.push(match);
2571			if (match.route.id === fromRouteId) {
2572				activeRouteMatch = match;
2573				break;
2574			}
2575		}
2576	} else {
2577		contextualMatches = matches;
2578		activeRouteMatch = matches[matches.length - 1];
2579	}
2580	let path = resolveTo(to ? to : ".", getResolveToMatches(contextualMatches), stripBasename(location.pathname, basename) || location.pathname, relative === "path");
2581	if (to == null) {
2582		path.search = location.search;
2583		path.hash = location.hash;
2584	}
2585	if ((to == null || to === "" || to === ".") && activeRouteMatch) {
2586		let nakedIndex = hasNakedIndexQuery(path.search);
2587		if (activeRouteMatch.route.index && !nakedIndex) path.search = path.search ? path.search.replace(/^\?/, "?index&") : "?index";
2588		else if (!activeRouteMatch.route.index && nakedIndex) {
2589			let params = new URLSearchParams(path.search);
2590			let indexValues = params.getAll("index");
2591			params.delete("index");
2592			indexValues.filter((v) => v).forEach((v) => params.append("index", v));
2593			let qs = params.toString();
2594			path.search = qs ? `?${qs}` : "";
2595		}
2596	}
2597	if (basename !== "/") path.pathname = prependBasename({
2598		basename,
2599		pathname: path.pathname
2600	});
2601	return createPath(path);
2602}
2603function normalizeNavigateOptions(isFetcher, path, opts) {
2604	if (!opts || !isSubmissionNavigation(opts)) return { path };
2605	if (opts.formMethod && !isValidMethod(opts.formMethod)) return {
2606		path,
2607		error: getInternalRouterError(405, { method: opts.formMethod })
2608	};
2609	let getInvalidBodyError = () => ({
2610		path,
2611		error: getInternalRouterError(400, { type: "invalid-body" })
2612	});
2613	let formMethod = (opts.formMethod || "get").toUpperCase();
2614	let formAction = stripHashFromPath(path);
2615	if (opts.body !== void 0) {
2616		if (opts.formEncType === "text/plain") {
2617			if (!isMutationMethod(formMethod)) return getInvalidBodyError();
2618			let text = typeof opts.body === "string" ? opts.body : opts.body instanceof FormData || opts.body instanceof URLSearchParams ? Array.from(opts.body.entries()).reduce((acc, [name, value]) => `${acc}${name}=${value}
2619`, "") : String(opts.body);
2620			return {
2621				path,
2622				submission: {
2623					formMethod,
2624					formAction,
2625					formEncType: opts.formEncType,
2626					formData: void 0,
2627					json: void 0,
2628					text
2629				}
2630			};
2631		} else if (opts.formEncType === "application/json") {
2632			if (!isMutationMethod(formMethod)) return getInvalidBodyError();
2633			try {
2634				let json = typeof opts.body === "string" ? JSON.parse(opts.body) : opts.body;
2635				return {
2636					path,
2637					submission: {
2638						formMethod,
2639						formAction,
2640						formEncType: opts.formEncType,
2641						formData: void 0,
2642						json,
2643						text: void 0
2644					}
2645				};
2646			} catch (e) {
2647				return getInvalidBodyError();
2648			}
2649		}
2650	}
2651	invariant(typeof FormData === "function", "FormData is not available in this environment");
2652	let searchParams;
2653	let formData;
2654	if (opts.formData) {
2655		searchParams = convertFormDataToSearchParams(opts.formData);
2656		formData = opts.formData;
2657	} else if (opts.body instanceof FormData) {
2658		searchParams = convertFormDataToSearchParams(opts.body);
2659		formData = opts.body;
2660	} else if (opts.body instanceof URLSearchParams) {
2661		searchParams = opts.body;
2662		formData = convertSearchParamsToFormData(searchParams);
2663	} else if (opts.body == null) {
2664		searchParams = new URLSearchParams();
2665		formData = new FormData();
2666	} else try {
2667		searchParams = new URLSearchParams(opts.body);
2668		formData = convertSearchParamsToFormData(searchParams);
2669	} catch (e) {
2670		return getInvalidBodyError();
2671	}
2672	let submission = {
2673		formMethod,
2674		formAction,
2675		formEncType: opts && opts.formEncType || "application/x-www-form-urlencoded",
2676		formData,
2677		json: void 0,
2678		text: void 0
2679	};
2680	if (isMutationMethod(submission.formMethod)) return {
2681		path,
2682		submission
2683	};
2684	let parsedPath = parsePath(path);
2685	if (isFetcher && parsedPath.search && hasNakedIndexQuery(parsedPath.search)) searchParams.append("index", "");
2686	parsedPath.search = `?${searchParams}`;
2687	return {
2688		path: createPath(parsedPath),
2689		submission
2690	};
2691}
2692function getMatchesToLoad(request, scopedContext, mapRouteProperties2, manifest, history, state, matches, submission, location, lazyRoutePropertiesToSkip, initialHydration, isRevalidationRequired, cancelledFetcherLoads, fetchersQueuedForDeletion, fetchLoadMatches, fetchRedirectIds, routesToUse, basename, hasPatchRoutesOnNavigation, pendingActionResult, callSiteDefaultShouldRevalidate) {
2693	let actionResult = pendingActionResult ? isErrorResult(pendingActionResult[1]) ? pendingActionResult[1].error : pendingActionResult[1].data : void 0;
2694	let currentUrl = history.createURL(state.location);
2695	let nextUrl = history.createURL(location);
2696	let maxIdx;
2697	if (initialHydration && state.errors) {
2698		let boundaryId = Object.keys(state.errors)[0];
2699		maxIdx = matches.findIndex((m) => m.route.id === boundaryId);
2700	} else if (pendingActionResult && isErrorResult(pendingActionResult[1])) {
2701		let boundaryId = pendingActionResult[0];
2702		maxIdx = matches.findIndex((m) => m.route.id === boundaryId) - 1;
2703	}
2704	let actionStatus = pendingActionResult ? pendingActionResult[1].statusCode : void 0;
2705	let shouldSkipRevalidation = actionStatus && actionStatus >= 400;
2706	let baseShouldRevalidateArgs = {
2707		currentUrl,
2708		currentParams: state.matches[0]?.params || {},
2709		nextUrl,
2710		nextParams: matches[0].params,
2711		...submission,
2712		actionResult,
2713		actionStatus
2714	};
2715	let pattern = getRoutePattern(matches);
2716	let dsMatches = matches.map((match, index) => {
2717		let { route } = match;
2718		let forceShouldLoad = null;
2719		if (maxIdx != null && index > maxIdx) forceShouldLoad = false;
2720		else if (route.lazy) forceShouldLoad = true;
2721		else if (!routeHasLoaderOrMiddleware(route)) forceShouldLoad = false;
2722		else if (initialHydration) {
2723			let { shouldLoad: shouldLoad2 } = getRouteHydrationStatus(route, state.loaderData, state.errors);
2724			forceShouldLoad = shouldLoad2;
2725		} else if (isNewLoader(state.loaderData, state.matches[index], match)) forceShouldLoad = true;
2726		if (forceShouldLoad !== null) return getDataStrategyMatch(mapRouteProperties2, manifest, request, location, pattern, match, lazyRoutePropertiesToSkip, scopedContext, forceShouldLoad);
2727		let defaultShouldRevalidate = false;
2728		if (typeof callSiteDefaultShouldRevalidate === "boolean") defaultShouldRevalidate = callSiteDefaultShouldRevalidate;
2729		else if (shouldSkipRevalidation) defaultShouldRevalidate = false;
2730		else if (isRevalidationRequired) defaultShouldRevalidate = true;
2731		else if (currentUrl.pathname + currentUrl.search === nextUrl.pathname + nextUrl.search) defaultShouldRevalidate = true;
2732		else if (currentUrl.search !== nextUrl.search) defaultShouldRevalidate = true;
2733		else if (isNewRouteInstance(state.matches[index], match)) defaultShouldRevalidate = true;
2734		let shouldRevalidateArgs = {
2735			...baseShouldRevalidateArgs,
2736			defaultShouldRevalidate
2737		};
2738		return getDataStrategyMatch(mapRouteProperties2, manifest, request, location, pattern, match, lazyRoutePropertiesToSkip, scopedContext, shouldRevalidateLoader(match, shouldRevalidateArgs), shouldRevalidateArgs, callSiteDefaultShouldRevalidate);
2739	});
2740	let revalidatingFetchers = [];
2741	fetchLoadMatches.forEach((f, key) => {
2742		if (initialHydration || !matches.some((m) => m.route.id === f.routeId) || fetchersQueuedForDeletion.has(key)) return;
2743		let fetcher = state.fetchers.get(key);
2744		let isMidInitialLoad = fetcher && fetcher.state !== "idle" && fetcher.data === void 0;
2745		let fetcherMatches = matchRoutes(routesToUse, f.path, basename);
2746		if (!fetcherMatches) {
2747			if (hasPatchRoutesOnNavigation && isMidInitialLoad) return;
2748			revalidatingFetchers.push({
2749				key,
2750				routeId: f.routeId,
2751				path: f.path,
2752				matches: null,
2753				match: null,
2754				request: null,
2755				controller: null
2756			});
2757			return;
2758		}
2759		if (fetchRedirectIds.has(key)) return;
2760		let fetcherMatch = getTargetMatch(fetcherMatches, f.path);
2761		let fetchController = new AbortController();
2762		let fetchRequest = createClientSideRequest(history, f.path, fetchController.signal);
2763		let fetcherDsMatches = null;
2764		if (cancelledFetcherLoads.has(key)) {
2765			cancelledFetcherLoads.delete(key);
2766			fetcherDsMatches = getTargetedDataStrategyMatches(mapRouteProperties2, manifest, fetchRequest, f.path, fetcherMatches, fetcherMatch, lazyRoutePropertiesToSkip, scopedContext);
2767		} else if (isMidInitialLoad) {
2768			if (isRevalidationRequired) fetcherDsMatches = getTargetedDataStrategyMatches(mapRouteProperties2, manifest, fetchRequest, f.path, fetcherMatches, fetcherMatch, lazyRoutePropertiesToSkip, scopedContext);
2769		} else {
2770			let defaultShouldRevalidate;
2771			if (typeof callSiteDefaultShouldRevalidate === "boolean") defaultShouldRevalidate = callSiteDefaultShouldRevalidate;
2772			else if (shouldSkipRevalidation) defaultShouldRevalidate = false;
2773			else defaultShouldRevalidate = isRevalidationRequired;
2774			let shouldRevalidateArgs = {
2775				...baseShouldRevalidateArgs,
2776				defaultShouldRevalidate
2777			};
2778			if (shouldRevalidateLoader(fetcherMatch, shouldRevalidateArgs)) fetcherDsMatches = getTargetedDataStrategyMatches(mapRouteProperties2, manifest, fetchRequest, f.path, fetcherMatches, fetcherMatch, lazyRoutePropertiesToSkip, scopedContext, shouldRevalidateArgs);
2779		}
2780		if (fetcherDsMatches) revalidatingFetchers.push({
2781			key,
2782			routeId: f.routeId,
2783			path: f.path,
2784			matches: fetcherDsMatches,
2785			match: fetcherMatch,
2786			request: fetchRequest,
2787			controller: fetchController
2788		});
2789	});
2790	return {
2791		dsMatches,
2792		revalidatingFetchers
2793	};
2794}
2795function routeHasLoaderOrMiddleware(route) {
2796	return route.loader != null || route.middleware != null && route.middleware.length > 0;
2797}
2798function getRouteHydrationStatus(route, loaderData, errors) {
2799	if (route.lazy) return {
2800		shouldLoad: true,
2801		renderFallback: true
2802	};
2803	if (!routeHasLoaderOrMiddleware(route)) return {
2804		shouldLoad: false,
2805		renderFallback: false
2806	};
2807	let hasData = loaderData != null && route.id in loaderData;
2808	let hasError = errors != null && errors[route.id] !== void 0;
2809	if (!hasData && hasError) return {
2810		shouldLoad: false,
2811		renderFallback: false
2812	};
2813	if (typeof route.loader === "function" && route.loader.hydrate === true) return {
2814		shouldLoad: true,
2815		renderFallback: !hasData
2816	};
2817	let shouldLoad = !hasData && !hasError;
2818	return {
2819		shouldLoad,
2820		renderFallback: shouldLoad
2821	};
2822}
2823function isNewLoader(currentLoaderData, currentMatch, match) {
2824	let isNew = !currentMatch || match.route.id !== currentMatch.route.id;
2825	let isMissingData = !currentLoaderData.hasOwnProperty(match.route.id);
2826	return isNew || isMissingData;
2827}
2828function isNewRouteInstance(currentMatch, match) {
2829	let currentPath = currentMatch.route.path;
2830	return currentMatch.pathname !== match.pathname || currentPath != null && currentPath.endsWith("*") && currentMatch.params["*"] !== match.params["*"];
2831}
2832function shouldRevalidateLoader(loaderMatch, arg) {
2833	if (loaderMatch.route.shouldRevalidate) {
2834		let routeChoice = loaderMatch.route.shouldRevalidate(arg);
2835		if (typeof routeChoice === "boolean") return routeChoice;
2836	}
2837	return arg.defaultShouldRevalidate;
2838}
2839function patchRoutesImpl(routeId, children, routesToUse, manifest, mapRouteProperties2, allowElementMutations) {
2840	let childrenToPatch;
2841	if (routeId) {
2842		let route = manifest[routeId];
2843		invariant(route, `No route found to patch children into: routeId = ${routeId}`);
2844		if (!route.children) route.children = [];
2845		childrenToPatch = route.children;
2846	} else childrenToPatch = routesToUse;
2847	let uniqueChildren = [];
2848	let existingChildren = [];
2849	children.forEach((newRoute) => {
2850		let existingRoute = childrenToPatch.find((existingRoute2) => isSameRoute(newRoute, existingRoute2));
2851		if (existingRoute) existingChildren.push({
2852			existingRoute,
2853			newRoute
2854		});
2855		else uniqueChildren.push(newRoute);
2856	});
2857	if (uniqueChildren.length > 0) {
2858		let newRoutes = convertRoutesToDataRoutes(uniqueChildren, mapRouteProperties2, [
2859			routeId || "_",
2860			"patch",
2861			String(childrenToPatch?.length || "0")
2862		], manifest);
2863		childrenToPatch.push(...newRoutes);
2864	}
2865	if (allowElementMutations && existingChildren.length > 0) for (let i = 0; i < existingChildren.length; i++) {
2866		let { existingRoute, newRoute } = existingChildren[i];
2867		let existingRouteTyped = existingRoute;
2868		let [newRouteTyped] = convertRoutesToDataRoutes([newRoute], mapRouteProperties2, [], {}, true);
2869		Object.assign(existingRouteTyped, {
2870			element: newRouteTyped.element ? newRouteTyped.element : existingRouteTyped.element,
2871			errorElement: newRouteTyped.errorElement ? newRouteTyped.errorElement : existingRouteTyped.errorElement,
2872			hydrateFallbackElement: newRouteTyped.hydrateFallbackElement ? newRouteTyped.hydrateFallbackElement : existingRouteTyped.hydrateFallbackElement
2873		});
2874	}
2875}
2876function isSameRoute(newRoute, existingRoute) {
2877	if ("id" in newRoute && "id" in existingRoute && newRoute.id === existingRoute.id) return true;
2878	if (!(newRoute.index === existingRoute.index && newRoute.path === existingRoute.path && newRoute.caseSensitive === existingRoute.caseSensitive)) return false;
2879	if ((!newRoute.children || newRoute.children.length === 0) && (!existingRoute.children || existingRoute.children.length === 0)) return true;
2880	return newRoute.children?.every((aChild, i) => existingRoute.children?.some((bChild) => isSameRoute(aChild, bChild))) ?? false;
2881}
2882var lazyRoutePropertyCache = /* @__PURE__ */ new WeakMap();
2883var loadLazyRouteProperty = ({ key, route, manifest, mapRouteProperties: mapRouteProperties2 }) => {
2884	let routeToUpdate = manifest[route.id];
2885	invariant(routeToUpdate, "No route found in manifest");
2886	if (!routeToUpdate.lazy || typeof routeToUpdate.lazy !== "object") return;
2887	let lazyFn = routeToUpdate.lazy[key];
2888	if (!lazyFn) return;
2889	let cache = lazyRoutePropertyCache.get(routeToUpdate);
2890	if (!cache) {
2891		cache = {};
2892		lazyRoutePropertyCache.set(routeToUpdate, cache);
2893	}
2894	let cachedPromise = cache[key];
2895	if (cachedPromise) return cachedPromise;
2896	let propertyPromise = (async () => {
2897		let isUnsupported = isUnsupportedLazyRouteObjectKey(key);
2898		let isStaticallyDefined = routeToUpdate[key] !== void 0 && key !== "hasErrorBoundary";
2899		if (isUnsupported) {
2900			warning(!isUnsupported, "Route property " + key + " is not a supported lazy route property. This property will be ignored.");
2901			cache[key] = Promise.resolve();
2902		} else if (isStaticallyDefined) warning(false, `Route "${routeToUpdate.id}" has a static property "${key}" defined. The lazy property will be ignored.`);
2903		else {
2904			let value = await lazyFn();
2905			if (value != null) {
2906				Object.assign(routeToUpdate, { [key]: value });
2907				Object.assign(routeToUpdate, mapRouteProperties2(routeToUpdate));
2908			}
2909		}
2910		if (typeof routeToUpdate.lazy === "object") {
2911			routeToUpdate.lazy[key] = void 0;
2912			if (Object.values(routeToUpdate.lazy).every((value) => value === void 0)) routeToUpdate.lazy = void 0;
2913		}
2914	})();
2915	cache[key] = propertyPromise;
2916	return propertyPromise;
2917};
2918var lazyRouteFunctionCache = /* @__PURE__ */ new WeakMap();
2919function loadLazyRoute(route, type, manifest, mapRouteProperties2, lazyRoutePropertiesToSkip) {
2920	let routeToUpdate = manifest[route.id];
2921	invariant(routeToUpdate, "No route found in manifest");
2922	if (!route.lazy) return {
2923		lazyRoutePromise: void 0,
2924		lazyHandlerPromise: void 0
2925	};
2926	if (typeof route.lazy === "function") {
2927		let cachedPromise = lazyRouteFunctionCache.get(routeToUpdate);
2928		if (cachedPromise) return {
2929			lazyRoutePromise: cachedPromise,
2930			lazyHandlerPromise: cachedPromise
2931		};
2932		let lazyRoutePromise2 = (async () => {
2933			invariant(typeof route.lazy === "function", "No lazy route function found");
2934			let lazyRoute = await route.lazy();
2935			let routeUpdates = {};
2936			for (let lazyRouteProperty in lazyRoute) {
2937				let lazyValue = lazyRoute[lazyRouteProperty];
2938				if (lazyValue === void 0) continue;
2939				let isUnsupported = isUnsupportedLazyRouteFunctionKey(lazyRouteProperty);
2940				let isStaticallyDefined = routeToUpdate[lazyRouteProperty] !== void 0 && lazyRouteProperty !== "hasErrorBoundary";
2941				if (isUnsupported) warning(!isUnsupported, "Route property " + lazyRouteProperty + " is not a supported property to be returned from a lazy route function. This property will be ignored.");
2942				else if (isStaticallyDefined) warning(!isStaticallyDefined, `Route "${routeToUpdate.id}" has a static property "${lazyRouteProperty}" defined but its lazy function is also returning a value for this property. The lazy route property "${lazyRouteProperty}" will be ignored.`);
2943				else routeUpdates[lazyRouteProperty] = lazyValue;
2944			}
2945			Object.assign(routeToUpdate, routeUpdates);
2946			Object.assign(routeToUpdate, {
2947				...mapRouteProperties2(routeToUpdate),
2948				lazy: void 0
2949			});
2950		})();
2951		lazyRouteFunctionCache.set(routeToUpdate, lazyRoutePromise2);
2952		lazyRoutePromise2.catch(() => {});
2953		return {
2954			lazyRoutePromise: lazyRoutePromise2,
2955			lazyHandlerPromise: lazyRoutePromise2
2956		};
2957	}
2958	let lazyKeys = Object.keys(route.lazy);
2959	let lazyPropertyPromises = [];
2960	let lazyHandlerPromise = void 0;
2961	for (let key of lazyKeys) {
2962		if (lazyRoutePropertiesToSkip && lazyRoutePropertiesToSkip.includes(key)) continue;
2963		let promise = loadLazyRouteProperty({
2964			key,
2965			route,
2966			manifest,
2967			mapRouteProperties: mapRouteProperties2
2968		});
2969		if (promise) {
2970			lazyPropertyPromises.push(promise);
2971			if (key === type) lazyHandlerPromise = promise;
2972		}
2973	}
2974	let lazyRoutePromise = lazyPropertyPromises.length > 0 ? Promise.all(lazyPropertyPromises).then(() => {}) : void 0;
2975	lazyRoutePromise?.catch(() => {});
2976	lazyHandlerPromise?.catch(() => {});
2977	return {
2978		lazyRoutePromise,
2979		lazyHandlerPromise
2980	};
2981}
2982function isNonNullable(value) {
2983	return value !== void 0;
2984}
2985function loadLazyMiddlewareForMatches(matches, manifest, mapRouteProperties2) {
2986	let promises = matches.map(({ route }) => {
2987		if (typeof route.lazy !== "object" || !route.lazy.middleware) return;
2988		return loadLazyRouteProperty({
2989			key: "middleware",
2990			route,
2991			manifest,
2992			mapRouteProperties: mapRouteProperties2
2993		});
2994	}).filter(isNonNullable);
2995	return promises.length > 0 ? Promise.all(promises) : void 0;
2996}
2997async function defaultDataStrategy(args) {
2998	let matchesToLoad = args.matches.filter((m) => m.shouldLoad);
2999	let keyedResults = {};
3000	(await Promise.all(matchesToLoad.map((m) => m.resolve()))).forEach((result, i) => {
3001		keyedResults[matchesToLoad[i].route.id] = result;
3002	});
3003	return keyedResults;
3004}
3005async function defaultDataStrategyWithMiddleware(args) {
3006	if (!args.matches.some((m) => m.route.middleware)) return defaultDataStrategy(args);
3007	return runClientMiddlewarePipeline(args, () => defaultDataStrategy(args));
3008}
3009function runServerMiddlewarePipeline(args, handler, errorHandler) {
3010	return runMiddlewarePipeline(args, handler, processResult, isResponse, errorHandler);
3011	function processResult(result) {
3012		return isDataWithResponseInit(result) ? dataWithResponseInitToResponse(result) : result;
3013	}
3014}
3015function runClientMiddlewarePipeline(args, handler) {
3016	return runMiddlewarePipeline(args, handler, (r) => {
3017		if (isRedirectResponse(r)) throw r;
3018		return r;
3019	}, isDataStrategyResults, errorHandler);
3020	function errorHandler(error, routeId, nextResult) {
3021		if (nextResult) return Promise.resolve(Object.assign(nextResult.value, { [routeId]: {
3022			type: "error",
3023			result: error
3024		} }));
3025		else {
3026			let { matches } = args;
3027			let boundaryRouteId = findNearestBoundary(matches, matches[Math.min(Math.max(matches.findIndex((m) => m.route.id === routeId), 0), Math.max(matches.findIndex((m) => m.shouldCallHandler()), 0))].route.id).route.id;
3028			return Promise.resolve({ [boundaryRouteId]: {
3029				type: "error",
3030				result: error
3031			} });
3032		}
3033	}
3034}
3035async function runMiddlewarePipeline(args, handler, processResult, isResult, errorHandler) {
3036	let { matches, ...dataFnArgs } = args;
3037	return await callRouteMiddleware(dataFnArgs, matches.flatMap((m) => m.route.middleware ? m.route.middleware.map((fn) => [m.route.id, fn]) : []), handler, processResult, isResult, errorHandler);
3038}
3039async function callRouteMiddleware(args, middlewares, handler, processResult, isResult, errorHandler, idx = 0) {
3040	let { request } = args;
3041	if (request.signal.aborted) throw request.signal.reason ?? /* @__PURE__ */ new Error(`Request aborted: ${request.method} ${request.url}`);
3042	let tuple = middlewares[idx];
3043	if (!tuple) return await handler();
3044	let [routeId, middleware] = tuple;
3045	let nextResult;
3046	let next = async () => {
3047		if (nextResult) throw new Error("You may only call `next()` once per middleware");
3048		try {
3049			nextResult = { value: await callRouteMiddleware(args, middlewares, handler, processResult, isResult, errorHandler, idx + 1) };
3050			return nextResult.value;
3051		} catch (error) {
3052			nextResult = { value: await errorHandler(error, routeId, nextResult) };
3053			return nextResult.value;
3054		}
3055	};
3056	try {
3057		let value = await middleware(args, next);
3058		let result = value != null ? processResult(value) : void 0;
3059		if (isResult(result)) return result;
3060		else if (nextResult) return result ?? nextResult.value;
3061		else {
3062			nextResult = { value: await next() };
3063			return nextResult.value;
3064		}
3065	} catch (error) {
3066		return await errorHandler(error, routeId, nextResult);
3067	}
3068}
3069function getDataStrategyMatchLazyPromises(mapRouteProperties2, manifest, request, match, lazyRoutePropertiesToSkip) {
3070	let lazyMiddlewarePromise = loadLazyRouteProperty({
3071		key: "middleware",
3072		route: match.route,
3073		manifest,
3074		mapRouteProperties: mapRouteProperties2
3075	});
3076	let lazyRoutePromises = loadLazyRoute(match.route, isMutationMethod(request.method) ? "action" : "loader", manifest, mapRouteProperties2, lazyRoutePropertiesToSkip);
3077	return {
3078		middleware: lazyMiddlewarePromise,
3079		route: lazyRoutePromises.lazyRoutePromise,
3080		handler: lazyRoutePromises.lazyHandlerPromise
3081	};
3082}
3083function getDataStrategyMatch(mapRouteProperties2, manifest, request, path, unstable_pattern, match, lazyRoutePropertiesToSkip, scopedContext, shouldLoad, shouldRevalidateArgs = null, callSiteDefaultShouldRevalidate) {
3084	let isUsingNewApi = false;
3085	let _lazyPromises = getDataStrategyMatchLazyPromises(mapRouteProperties2, manifest, request, match, lazyRoutePropertiesToSkip);
3086	return {
3087		...match,
3088		_lazyPromises,
3089		shouldLoad,
3090		shouldRevalidateArgs,
3091		shouldCallHandler(defaultShouldRevalidate) {
3092			isUsingNewApi = true;
3093			if (!shouldRevalidateArgs) return shouldLoad;
3094			if (typeof callSiteDefaultShouldRevalidate === "boolean") return shouldRevalidateLoader(match, {
3095				...shouldRevalidateArgs,
3096				defaultShouldRevalidate: callSiteDefaultShouldRevalidate
3097			});
3098			if (typeof defaultShouldRevalidate === "boolean") return shouldRevalidateLoader(match, {
3099				...shouldRevalidateArgs,
3100				defaultShouldRevalidate
3101			});
3102			return shouldRevalidateLoader(match, shouldRevalidateArgs);
3103		},
3104		resolve(handlerOverride) {
3105			let { lazy, loader, middleware } = match.route;
3106			let callHandler = isUsingNewApi || shouldLoad || handlerOverride && !isMutationMethod(request.method) && (lazy || loader);
3107			let isMiddlewareOnlyRoute = middleware && middleware.length > 0 && !loader && !lazy;
3108			if (callHandler && (isMutationMethod(request.method) || !isMiddlewareOnlyRoute)) return callLoaderOrAction({
3109				request,
3110				path,
3111				unstable_pattern,
3112				match,
3113				lazyHandlerPromise: _lazyPromises?.handler,
3114				lazyRoutePromise: _lazyPromises?.route,
3115				handlerOverride,
3116				scopedContext
3117			});
3118			return Promise.resolve({
3119				type: "data",
3120				result: void 0
3121			});
3122		}
3123	};
3124}
3125function getTargetedDataStrategyMatches(mapRouteProperties2, manifest, request, path, matches, targetMatch, lazyRoutePropertiesToSkip, scopedContext, shouldRevalidateArgs = null) {
3126	return matches.map((match) => {
3127		if (match.route.id !== targetMatch.route.id) return {
3128			...match,
3129			shouldLoad: false,
3130			shouldRevalidateArgs,
3131			shouldCallHandler: () => false,
3132			_lazyPromises: getDataStrategyMatchLazyPromises(mapRouteProperties2, manifest, request, match, lazyRoutePropertiesToSkip),
3133			resolve: () => Promise.resolve({
3134				type: "data",
3135				result: void 0
3136			})
3137		};
3138		return getDataStrategyMatch(mapRouteProperties2, manifest, request, path, getRoutePattern(matches), match, lazyRoutePropertiesToSkip, scopedContext, true, shouldRevalidateArgs);
3139	});
3140}
3141async function callDataStrategyImpl(dataStrategyImpl, request, path, matches, fetcherKey, scopedContext, isStaticHandler) {
3142	if (matches.some((m) => m._lazyPromises?.middleware)) await Promise.all(matches.map((m) => m._lazyPromises?.middleware));
3143	let dataStrategyArgs = {
3144		request,
3145		unstable_url: createDataFunctionUrl(request, path),
3146		unstable_pattern: getRoutePattern(matches),
3147		params: matches[0].params,
3148		context: scopedContext,
3149		matches
3150	};
3151	let runClientMiddleware = isStaticHandler ? () => {
3152		throw new Error("You cannot call `runClientMiddleware()` from a static handler `dataStrategy`. Middleware is run outside of `dataStrategy` during SSR in order to bubble up the Response.  You can enable middleware via the `respond` API in `query`/`queryRoute`");
3153	} : (cb) => {
3154		let typedDataStrategyArgs = dataStrategyArgs;
3155		return runClientMiddlewarePipeline(typedDataStrategyArgs, () => {
3156			return cb({
3157				...typedDataStrategyArgs,
3158				fetcherKey,
3159				runClientMiddleware: () => {
3160					throw new Error("Cannot call `runClientMiddleware()` from within an `runClientMiddleware` handler");
3161				}
3162			});
3163		});
3164	};
3165	let results = await dataStrategyImpl({
3166		...dataStrategyArgs,
3167		fetcherKey,
3168		runClientMiddleware
3169	});
3170	try {
3171		await Promise.all(matches.flatMap((m) => [m._lazyPromises?.handler, m._lazyPromises?.route]));
3172	} catch (e) {}
3173	return results;
3174}
3175async function callLoaderOrAction({ request, path, unstable_pattern, match, lazyHandlerPromise, lazyRoutePromise, handlerOverride, scopedContext }) {
3176	let result;
3177	let onReject;
3178	let isAction = isMutationMethod(request.method);
3179	let type = isAction ? "action" : "loader";
3180	let runHandler = (handler) => {
3181		let reject;
3182		let abortPromise = new Promise((_, r) => reject = r);
3183		onReject = () => reject();
3184		request.signal.addEventListener("abort", onReject);
3185		let actualHandler = (ctx) => {
3186			if (typeof handler !== "function") return Promise.reject(/* @__PURE__ */ new Error(`You cannot call the handler for a route which defines a boolean "${type}" [routeId: ${match.route.id}]`));
3187			return handler({
3188				request,
3189				unstable_url: createDataFunctionUrl(request, path),
3190				unstable_pattern,
3191				params: match.params,
3192				context: scopedContext
3193			}, ...ctx !== void 0 ? [ctx] : []);
3194		};
3195		let handlerPromise = (async () => {
3196			try {
3197				return {
3198					type: "data",
3199					result: await (handlerOverride ? handlerOverride((ctx) => actualHandler(ctx)) : actualHandler())
3200				};
3201			} catch (e) {
3202				return {
3203					type: "error",
3204					result: e
3205				};
3206			}
3207		})();
3208		return Promise.race([handlerPromise, abortPromise]);
3209	};
3210	try {
3211		let handler = isAction ? match.route.action : match.route.loader;
3212		if (lazyHandlerPromise || lazyRoutePromise) if (handler) {
3213			let handlerError;
3214			let [value] = await Promise.all([
3215				runHandler(handler).catch((e) => {
3216					handlerError = e;
3217				}),
3218				lazyHandlerPromise,
3219				lazyRoutePromise
3220			]);
3221			if (handlerError !== void 0) throw handlerError;
3222			result = value;
3223		} else {
3224			await lazyHandlerPromise;
3225			let handler2 = isAction ? match.route.action : match.route.loader;
3226			if (handler2) [result] = await Promise.all([runHandler(handler2), lazyRoutePromise]);
3227			else if (type === "action") {
3228				let url = new URL(request.url);
3229				let pathname = url.pathname + url.search;
3230				throw getInternalRouterError(405, {
3231					method: request.method,
3232					pathname,
3233					routeId: match.route.id
3234				});
3235			} else return {
3236				type: "data",
3237				result: void 0
3238			};
3239		}
3240		else if (!handler) {
3241			let url = new URL(request.url);
3242			throw getInternalRouterError(404, { pathname: url.pathname + url.search });
3243		} else result = await runHandler(handler);
3244	} catch (e) {
3245		return {
3246			type: "error",
3247			result: e
3248		};
3249	} finally {
3250		if (onReject) request.signal.removeEventListener("abort", onReject);
3251	}
3252	return result;
3253}
3254async function parseResponseBody(response) {
3255	let contentType = response.headers.get("Content-Type");
3256	if (contentType && /\bapplication\/json\b/.test(contentType)) return response.body == null ? null : response.json();
3257	return response.text();
3258}
3259async function convertDataStrategyResultToDataResult(dataStrategyResult) {
3260	let { result, type } = dataStrategyResult;
3261	if (isResponse(result)) {
3262		let data2;
3263		try {
3264			data2 = await parseResponseBody(result);
3265		} catch (e) {
3266			return {
3267				type: "error",
3268				error: e
3269			};
3270		}
3271		if (type === "error") return {
3272			type: "error",
3273			error: new ErrorResponseImpl(result.status, result.statusText, data2),
3274			statusCode: result.status,
3275			headers: result.headers
3276		};
3277		return {
3278			type: "data",
3279			data: data2,
3280			statusCode: result.status,
3281			headers: result.headers
3282		};
3283	}
3284	if (type === "error") {
3285		if (isDataWithResponseInit(result)) {
3286			if (result.data instanceof Error) return {
3287				type: "error",
3288				error: result.data,
3289				statusCode: result.init?.status,
3290				headers: result.init?.headers ? new Headers(result.init.headers) : void 0
3291			};
3292			return {
3293				type: "error",
3294				error: dataWithResponseInitToErrorResponse(result),
3295				statusCode: isRouteErrorResponse(result) ? result.status : void 0,
3296				headers: result.init?.headers ? new Headers(result.init.headers) : void 0
3297			};
3298		}
3299		return {
3300			type: "error",
3301			error: result,
3302			statusCode: isRouteErrorResponse(result) ? result.status : void 0
3303		};
3304	}
3305	if (isDataWithResponseInit(result)) return {
3306		type: "data",
3307		data: result.data,
3308		statusCode: result.init?.status,
3309		headers: result.init?.headers ? new Headers(result.init.headers) : void 0
3310	};
3311	return {
3312		type: "data",
3313		data: result
3314	};
3315}
3316function normalizeRelativeRoutingRedirectResponse(response, request, routeId, matches, basename) {
3317	let location = response.headers.get("Location");
3318	invariant(location, "Redirects returned/thrown from loaders/actions must have a Location header");
3319	if (!isAbsoluteUrl(location)) {
3320		let trimmedMatches = matches.slice(0, matches.findIndex((m) => m.route.id === routeId) + 1);
3321		location = normalizeTo(new URL(request.url), trimmedMatches, basename, location);
3322		response.headers.set("Location", location);
3323	}
3324	return response;
3325}
3326var invalidProtocols = [
3327	"about:",
3328	"blob:",
3329	"chrome:",
3330	"chrome-untrusted:",
3331	"content:",
3332	"data:",
3333	"devtools:",
3334	"file:",
3335	"filesystem:",
3336	"javascript:"
3337];
3338function normalizeRedirectLocation(location, currentUrl, basename, historyInstance) {
3339	if (isAbsoluteUrl(location)) {
3340		let normalizedLocation = location;
3341		let url = normalizedLocation.startsWith("//") ? new URL(currentUrl.protocol + normalizedLocation) : new URL(normalizedLocation);
3342		if (invalidProtocols.includes(url.protocol)) throw new Error("Invalid redirect location");
3343		let isSameBasename = stripBasename(url.pathname, basename) != null;
3344		if (url.origin === currentUrl.origin && isSameBasename) return url.pathname + url.search + url.hash;
3345	}
3346	try {
3347		let url = historyInstance.createURL(location);
3348		if (invalidProtocols.includes(url.protocol)) throw new Error("Invalid redirect location");
3349	} catch (e) {}
3350	return location;
3351}
3352function createClientSideRequest(history, location, signal, submission) {
3353	let url = history.createURL(stripHashFromPath(location)).toString();
3354	let init = { signal };
3355	if (submission && isMutationMethod(submission.formMethod)) {
3356		let { formMethod, formEncType } = submission;
3357		init.method = formMethod.toUpperCase();
3358		if (formEncType === "application/json") {
3359			init.headers = new Headers({ "Content-Type": formEncType });
3360			init.body = JSON.stringify(submission.json);
3361		} else if (formEncType === "text/plain") init.body = submission.text;
3362		else if (formEncType === "application/x-www-form-urlencoded" && submission.formData) init.body = convertFormDataToSearchParams(submission.formData);
3363		else init.body = submission.formData;
3364	}
3365	return new Request(url, init);
3366}
3367function createDataFunctionUrl(request, path) {
3368	let url = new URL(request.url);
3369	let parsed = typeof path === "string" ? parsePath(path) : path;
3370	url.pathname = parsed.pathname || "/";
3371	if (parsed.search) {
3372		let searchParams = new URLSearchParams(parsed.search);
3373		let indexValues = searchParams.getAll("index");
3374		searchParams.delete("index");
3375		for (let value of indexValues.filter(Boolean)) searchParams.append("index", value);
3376		url.search = searchParams.size ? `?${searchParams.toString()}` : "";
3377	} else url.search = "";
3378	url.hash = parsed.hash || "";
3379	return url;
3380}
3381function convertFormDataToSearchParams(formData) {
3382	let searchParams = new URLSearchParams();
3383	for (let [key, value] of formData.entries()) searchParams.append(key, typeof value === "string" ? value : value.name);
3384	return searchParams;
3385}
3386function convertSearchParamsToFormData(searchParams) {
3387	let formData = new FormData();
3388	for (let [key, value] of searchParams.entries()) formData.append(key, value);
3389	return formData;
3390}
3391function processRouteLoaderData(matches, results, pendingActionResult, isStaticHandler = false, skipLoaderErrorBubbling = false) {
3392	let loaderData = {};
3393	let errors = null;
3394	let statusCode;
3395	let foundError = false;
3396	let loaderHeaders = {};
3397	let pendingError = pendingActionResult && isErrorResult(pendingActionResult[1]) ? pendingActionResult[1].error : void 0;
3398	matches.forEach((match) => {
3399		if (!(match.route.id in results)) return;
3400		let id = match.route.id;
3401		let result = results[id];
3402		invariant(!isRedirectResult(result), "Cannot handle redirect results in processLoaderData");
3403		if (isErrorResult(result)) {
3404			let error = result.error;
3405			if (pendingError !== void 0) {
3406				error = pendingError;
3407				pendingError = void 0;
3408			}
3409			errors = errors || {};
3410			if (skipLoaderErrorBubbling) errors[id] = error;
3411			else {
3412				let boundaryMatch = findNearestBoundary(matches, id);
3413				if (errors[boundaryMatch.route.id] == null) errors[boundaryMatch.route.id] = error;
3414			}
3415			if (!isStaticHandler) loaderData[id] = ResetLoaderDataSymbol;
3416			if (!foundError) {
3417				foundError = true;
3418				statusCode = isRouteErrorResponse(result.error) ? result.error.status : 500;
3419			}
3420			if (result.headers) loaderHeaders[id] = result.headers;
3421		} else {
3422			loaderData[id] = result.data;
3423			if (result.statusCode && result.statusCode !== 200 && !foundError) statusCode = result.statusCode;
3424			if (result.headers) loaderHeaders[id] = result.headers;
3425		}
3426	});
3427	if (pendingError !== void 0 && pendingActionResult) {
3428		errors = { [pendingActionResult[0]]: pendingError };
3429		if (pendingActionResult[2]) loaderData[pendingActionResult[2]] = void 0;
3430	}
3431	return {
3432		loaderData,
3433		errors,
3434		statusCode: statusCode || 200,
3435		loaderHeaders
3436	};
3437}
3438function processLoaderData(state, matches, results, pendingActionResult, revalidatingFetchers, fetcherResults) {
3439	let { loaderData, errors } = processRouteLoaderData(matches, results, pendingActionResult);
3440	revalidatingFetchers.filter((f) => !f.matches || f.matches.some((m) => m.shouldLoad)).forEach((rf) => {
3441		let { key, match, controller } = rf;
3442		if (controller && controller.signal.aborted) return;
3443		let result = fetcherResults[key];
3444		invariant(result, "Did not find corresponding fetcher result");
3445		if (isErrorResult(result)) {
3446			let boundaryMatch = findNearestBoundary(state.matches, match?.route.id);
3447			if (!(errors && errors[boundaryMatch.route.id])) errors = {
3448				...errors,
3449				[boundaryMatch.route.id]: result.error
3450			};
3451			state.fetchers.delete(key);
3452		} else if (isRedirectResult(result)) invariant(false, "Unhandled fetcher revalidation redirect");
3453		else {
3454			let doneFetcher = getDoneFetcher(result.data);
3455			state.fetchers.set(key, doneFetcher);
3456		}
3457	});
3458	return {
3459		loaderData,
3460		errors
3461	};
3462}
3463function mergeLoaderData(loaderData, newLoaderData, matches, errors) {
3464	let mergedLoaderData = Object.entries(newLoaderData).filter(([, v]) => v !== ResetLoaderDataSymbol).reduce((merged, [k, v]) => {
3465		merged[k] = v;
3466		return merged;
3467	}, {});
3468	for (let match of matches) {
3469		let id = match.route.id;
3470		if (!newLoaderData.hasOwnProperty(id) && loaderData.hasOwnProperty(id) && match.route.loader) mergedLoaderData[id] = loaderData[id];
3471		if (errors && errors.hasOwnProperty(id)) break;
3472	}
3473	return mergedLoaderData;
3474}
3475function getActionDataForCommit(pendingActionResult) {
3476	if (!pendingActionResult) return {};
3477	return isErrorResult(pendingActionResult[1]) ? { actionData: {} } : { actionData: { [pendingActionResult[0]]: pendingActionResult[1].data } };
3478}
3479function findNearestBoundary(matches, routeId) {
3480	return (routeId ? matches.slice(0, matches.findIndex((m) => m.route.id === routeId) + 1) : [...matches]).reverse().find((m) => m.route.hasErrorBoundary === true) || matches[0];
3481}
3482function getShortCircuitMatches(routes) {
3483	let route = routes.length === 1 ? routes[0] : routes.find((r) => r.index || !r.path || r.path === "/") || { id: `__shim-error-route__` };
3484	return {
3485		matches: [{
3486			params: {},
3487			pathname: "",
3488			pathnameBase: "",
3489			route
3490		}],
3491		route
3492	};
3493}
3494function getInternalRouterError(status, { pathname, routeId, method, type, message } = {}) {
3495	let statusText = "Unknown Server Error";
3496	let errorMessage = "Unknown @remix-run/router error";
3497	if (status === 400) {
3498		statusText = "Bad Request";
3499		if (method && pathname && routeId) errorMessage = `You made a ${method} request to "${pathname}" but did not provide a \`loader\` for route "${routeId}", so there is no way to handle the request.`;
3500		else if (type === "invalid-body") errorMessage = "Unable to encode submission body";
3501	} else if (status === 403) {
3502		statusText = "Forbidden";
3503		errorMessage = `Route "${routeId}" does not match URL "${pathname}"`;
3504	} else if (status === 404) {
3505		statusText = "Not Found";
3506		errorMessage = `No route matches URL "${pathname}"`;
3507	} else if (status === 405) {
3508		statusText = "Method Not Allowed";
3509		if (method && pathname && routeId) errorMessage = `You made a ${method.toUpperCase()} request to "${pathname}" but did not provide an \`action\` for route "${routeId}", so there is no way to handle the request.`;
3510		else if (method) errorMessage = `Invalid request method "${method.toUpperCase()}"`;
3511	}
3512	return new ErrorResponseImpl(status || 500, statusText, new Error(errorMessage), true);
3513}
3514function findRedirect(results) {
3515	let entries = Object.entries(results);
3516	for (let i = entries.length - 1; i >= 0; i--) {
3517		let [key, result] = entries[i];
3518		if (isRedirectResult(result)) return {
3519			key,
3520			result
3521		};
3522	}
3523}
3524function stripHashFromPath(path) {
3525	return createPath({
3526		...typeof path === "string" ? parsePath(path) : path,
3527		hash: ""
3528	});
3529}
3530function isHashChangeOnly(a, b) {
3531	if (a.pathname !== b.pathname || a.search !== b.search) return false;
3532	if (a.hash === "") return b.hash !== "";
3533	else if (a.hash === b.hash) return true;
3534	else if (b.hash !== "") return true;
3535	return false;
3536}
3537function dataWithResponseInitToResponse(data2) {
3538	return Response.json(data2.data, data2.init ?? void 0);
3539}
3540function dataWithResponseInitToErrorResponse(data2) {
3541	return new ErrorResponseImpl(data2.init?.status ?? 500, data2.init?.statusText ?? "Internal Server Error", data2.data);
3542}
3543function isDataStrategyResults(result) {
3544	return result != null && typeof result === "object" && Object.entries(result).every(([key, value]) => typeof key === "string" && isDataStrategyResult(value));
3545}
3546function isDataStrategyResult(result) {
3547	return result != null && typeof result === "object" && "type" in result && "result" in result && (result.type === "data" || result.type === "error");
3548}
3549function isRedirectDataStrategyResult(result) {
3550	return isResponse(result.result) && redirectStatusCodes.has(result.result.status);
3551}
3552function isErrorResult(result) {
3553	return result.type === "error";
3554}
3555function isRedirectResult(result) {
3556	return (result && result.type) === "redirect";
3557}
3558function isDataWithResponseInit(value) {
3559	return typeof value === "object" && value != null && "type" in value && "data" in value && "init" in value && value.type === "DataWithResponseInit";
3560}
3561function isResponse(value) {
3562	return value != null && typeof value.status === "number" && typeof value.statusText === "string" && typeof value.headers === "object" && typeof value.body !== "undefined";
3563}
3564function isRedirectStatusCode(statusCode) {
3565	return redirectStatusCodes.has(statusCode);
3566}
3567function isRedirectResponse(result) {
3568	return isResponse(result) && isRedirectStatusCode(result.status) && result.headers.has("Location");
3569}
3570function isValidMethod(method) {
3571	return validRequestMethods.has(method.toUpperCase());
3572}
3573function isMutationMethod(method) {
3574	return validMutationMethods.has(method.toUpperCase());
3575}
3576function hasNakedIndexQuery(search) {
3577	return new URLSearchParams(search).getAll("index").some((v) => v === "");
3578}
3579function getTargetMatch(matches, location) {
3580	let search = typeof location === "string" ? parsePath(location).search : location.search;
3581	if (matches[matches.length - 1].route.index && hasNakedIndexQuery(search || "")) return matches[matches.length - 1];
3582	let pathMatches = getPathContributingMatches(matches);
3583	return pathMatches[pathMatches.length - 1];
3584}
3585function getSubmissionFromNavigation(navigation) {
3586	let { formMethod, formAction, formEncType, text, formData, json } = navigation;
3587	if (!formMethod || !formAction || !formEncType) return;
3588	if (text != null) return {
3589		formMethod,
3590		formAction,
3591		formEncType,
3592		formData: void 0,
3593		json: void 0,
3594		text
3595	};
3596	else if (formData != null) return {
3597		formMethod,
3598		formAction,
3599		formEncType,
3600		formData,
3601		json: void 0,
3602		text: void 0
3603	};
3604	else if (json !== void 0) return {
3605		formMethod,
3606		formAction,
3607		formEncType,
3608		formData: void 0,
3609		json,
3610		text: void 0
3611	};
3612}
3613function getLoadingNavigation(location, submission) {
3614	if (submission) return {
3615		state: "loading",
3616		location,
3617		formMethod: submission.formMethod,
3618		formAction: submission.formAction,
3619		formEncType: submission.formEncType,
3620		formData: submission.formData,
3621		json: submission.json,
3622		text: submission.text
3623	};
3624	else return {
3625		state: "loading",
3626		location,
3627		formMethod: void 0,
3628		formAction: void 0,
3629		formEncType: void 0,
3630		formData: void 0,
3631		json: void 0,
3632		text: void 0
3633	};
3634}
3635function getSubmittingNavigation(location, submission) {
3636	return {
3637		state: "submitting",
3638		location,
3639		formMethod: submission.formMethod,
3640		formAction: submission.formAction,
3641		formEncType: submission.formEncType,
3642		formData: submission.formData,
3643		json: submission.json,
3644		text: submission.text
3645	};
3646}
3647function getLoadingFetcher(submission, data2) {
3648	if (submission) return {
3649		state: "loading",
3650		formMethod: submission.formMethod,
3651		formAction: submission.formAction,
3652		formEncType: submission.formEncType,
3653		formData: submission.formData,
3654		json: submission.json,
3655		text: submission.text,
3656		data: data2
3657	};
3658	else return {
3659		state: "loading",
3660		formMethod: void 0,
3661		formAction: void 0,
3662		formEncType: void 0,
3663		formData: void 0,
3664		json: void 0,
3665		text: void 0,
3666		data: data2
3667	};
3668}
3669function getSubmittingFetcher(submission, existingFetcher) {
3670	return {
3671		state: "submitting",
3672		formMethod: submission.formMethod,
3673		formAction: submission.formAction,
3674		formEncType: submission.formEncType,
3675		formData: submission.formData,
3676		json: submission.json,
3677		text: submission.text,
3678		data: existingFetcher ? existingFetcher.data : void 0
3679	};
3680}
3681function getDoneFetcher(data2) {
3682	return {
3683		state: "idle",
3684		formMethod: void 0,
3685		formAction: void 0,
3686		formEncType: void 0,
3687		formData: void 0,
3688		json: void 0,
3689		text: void 0,
3690		data: data2
3691	};
3692}
3693function restoreAppliedTransitions(_window, transitions) {
3694	try {
3695		let sessionPositions = _window.sessionStorage.getItem(TRANSITIONS_STORAGE_KEY);
3696		if (sessionPositions) {
3697			let json = JSON.parse(sessionPositions);
3698			for (let [k, v] of Object.entries(json || {})) if (v && Array.isArray(v)) transitions.set(k, new Set(v || []));
3699		}
3700	} catch (e) {}
3701}
3702function persistAppliedTransitions(_window, transitions) {
3703	if (transitions.size > 0) {
3704		let json = {};
3705		for (let [k, v] of transitions) json[k] = [...v];
3706		try {
3707			_window.sessionStorage.setItem(TRANSITIONS_STORAGE_KEY, JSON.stringify(json));
3708		} catch (error) {
3709			warning(false, `Failed to save applied view transitions in sessionStorage (${error}).`);
3710		}
3711	}
3712}
3713function createDeferred() {
3714	let resolve;
3715	let reject;
3716	let promise = new Promise((res, rej) => {
3717		resolve = async (val) => {
3718			res(val);
3719			try {
3720				await promise;
3721			} catch (e) {}
3722		};
3723		reject = async (error) => {
3724			rej(error);
3725			try {
3726				await promise;
3727			} catch (e) {}
3728		};
3729	});
3730	return {
3731		promise,
3732		resolve,
3733		reject
3734	};
3735}
3736var DataRouterContext = import_react.createContext(null);
3737DataRouterContext.displayName = "DataRouter";
3738var DataRouterStateContext = import_react.createContext(null);
3739DataRouterStateContext.displayName = "DataRouterState";
3740var RSCRouterContext = import_react.createContext(false);
3741function useIsRSCRouterContext() {
3742	return import_react.useContext(RSCRouterContext);
3743}
3744var ViewTransitionContext = import_react.createContext({ isTransitioning: false });
3745ViewTransitionContext.displayName = "ViewTransition";
3746var FetchersContext = import_react.createContext(/* @__PURE__ */ new Map());
3747FetchersContext.displayName = "Fetchers";
3748var AwaitContext = import_react.createContext(null);
3749AwaitContext.displayName = "Await";
3750var AwaitContextProvider = (props) => import_react.createElement(AwaitContext.Provider, props);
3751var NavigationContext = import_react.createContext(null);
3752NavigationContext.displayName = "Navigation";
3753var LocationContext = import_react.createContext(null);
3754LocationContext.displayName = "Location";
3755var RouteContext = import_react.createContext({
3756	outlet: null,
3757	matches: [],
3758	isDataRoute: false
3759});
3760RouteContext.displayName = "Route";
3761var RouteErrorContext = import_react.createContext(null);
3762RouteErrorContext.displayName = "RouteError";
3763var ERROR_DIGEST_BASE = "REACT_ROUTER_ERROR";