UNPKG

react-router/dist/production/lib/router/router.js

Version:
123 kBJavaScriptView Raw
1/**
* react-router v8.4.0
*
* Copyright (c) Remix Software Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE.md file in the root directory of this source tree.
*
* @license MIT
*/
11import { PROTOCOL_RELATIVE_URL_REGEX, normalizeProtocolRelativeUrl } from "./url.js";
12import { createBrowserURLImpl, createLocation, createPath, invariant, parsePath, warning } from "./history.js";
13import { ErrorResponseImpl, RouterContextProvider, convertRouteMatchToUiMatch, convertRoutesToDataRoutes, createDataFunctionUrl, getPathContributingMatches, getResolveToMatches, getRoutePattern, isAbsoluteUrl, isRouteErrorResponse, isUnsupportedLazyRouteFunctionKey, isUnsupportedLazyRouteObjectKey, prependBasename, removeDoubleSlashes, resolveTo, stripBasename } from "./utils.js";
14import { consumeInstrumentationClientResultMetaReceiver, getRouteInstrumentationUpdates, instrumentClientSideRouter } from "./instrumentation.js";
15import { V6RegExMatcher } from "./matcher.js";
16import { getRoutePatternMatcher } from "./matcher-route-pattern.preload.js";
17import { validateNavigationTarget } from "./navigation.js";
18//#region lib/router/router.ts
19const validMutationMethodsArr = [
"POST",
"PUT",
"PATCH",
"DELETE"
24];
25const validMutationMethods = new Set(validMutationMethodsArr);
26const validRequestMethodsArr = ["GET", ...validMutationMethodsArr];
27const validRequestMethods = new Set(validRequestMethodsArr);
28const redirectStatusCodes = new Set([
301,
302,
303,
307,
308
34]);
35const redirectPreserveMethodStatusCodes = new Set([307, 308]);
36const IDLE_NAVIGATION = {
state: "idle",
location: void 0,
matches: void 0,
historyAction: void 0,
formMethod: void 0,
formAction: void 0,
formEncType: void 0,
formData: void 0,
json: void 0,
text: void 0
47};
48const IDLE_FETCHER = {
state: "idle",
data: void 0,
formMethod: void 0,
formAction: void 0,
formEncType: void 0,
formData: void 0,
json: void 0,
text: void 0
57};
58const IDLE_BLOCKER = {
state: "unblocked",
proceed: void 0,
reset: void 0,
location: void 0
63};
64const TRANSITIONS_STORAGE_KEY = "remix-router-transitions";
65const ResetLoaderDataSymbol = Symbol("ResetLoaderData");
66function createDataRouteMatcher(future, basename) {
if (future.unstable_routePatternMatching) {
let RoutePatternMatcher = getRoutePatternMatcher();
invariant(RoutePatternMatcher, "You must call unstable_preloadRoutePattern() from \"react-router/route-pattern\" before enabling future.unstable_routePatternMatching.");
return new RoutePatternMatcher(basename);
}
return new V6RegExMatcher(basename);
73}
74/**
75* Encapsulates the stable and in-flight route trees together with their
76* pre-computed branch caches so the structures always stay in sync.
77*/
78var DataRoutes = class {
#routes;
#hmrRoutes;
#matcher;
constructor(routes, matcher) {
this.#routes = routes;
this.#matcher = matcher;
this.#matcher.update(routes);
}
/** The stable route tree */
get stableRoutes() {
return this.#routes;
}
/** The in-flight route tree if one is active, otherwise the stable tree */
get activeRoutes() {
return this.#hmrRoutes ?? this.#routes;
}
get hasHMRRoutes() {
return this.#hmrRoutes != null;
}
/** Replace the stable route tree and recompute its branches */
setRoutes(routes) {
this.#routes = routes;
if (!this.#hmrRoutes) this.#matcher.update(routes);
}
/** Set a new in-flight route tree and recompute its branches */
setHmrRoutes(routes) {
this.#hmrRoutes = routes;
this.#matcher.update(routes);
}
/** Commit in-flight routes/branches to the stable slot and clear in-flight */
commitHmrRoutes() {
if (this.#hmrRoutes) {
	this.#routes = this.#hmrRoutes;
	this.#hmrRoutes = void 0;
	this.#matcher.update(this.#routes);
}
}
116};
117/**
118* Create a router and listen to history POP navigations
119*/
120function createRouter(init) {
const routerWindow = init.window ? init.window : typeof window !== "undefined" ? window : void 0;
const isBrowser = typeof routerWindow !== "undefined" && typeof routerWindow.document !== "undefined" && typeof routerWindow.document.createElement !== "undefined";
invariant(init.routes.length > 0, "You must provide a non-empty routes array to createRouter");
let hydrationRouteProperties = init.hydrationRouteProperties || [];
let _mapRouteProperties = init.mapRouteProperties;
let mapRouteProperties = _mapRouteProperties ? _mapRouteProperties : () => ({});
if (init.instrumentations) {
let instrumentations = init.instrumentations;
mapRouteProperties = (route) => {
	return {
		..._mapRouteProperties?.(route),
		...getRouteInstrumentationUpdates(instrumentations.map((i) => i.route).filter(Boolean), route)
	};
};
}
let future = { ...init.future };
let basename = init.basename || "/";
if (!basename.startsWith("/")) basename = `/${basename}`;
let dataRouteMatcher = createDataRouteMatcher(future, basename);
let manifest = {};
let dataRoutes = new DataRoutes(convertRoutesToDataRoutes(init.routes, mapRouteProperties, void 0, manifest), dataRouteMatcher);
let dataStrategyImpl = init.dataStrategy || defaultDataStrategyWithMiddleware;
let unlistenHistory = null;
let subscribers = /* @__PURE__ */ new Set();
let bufferedInitialStateUpdate = null;
let savedScrollPositions = null;
let getScrollRestorationKey = null;
let getScrollPosition = null;
let initialScrollRestored = init.hydrationData != null;
let initialMatches = dataRouteMatcher.match(init.history.location);
let initialMatchesIsFOW = false;
let initialErrors = null;
let initialized;
let renderFallback;
if (initialMatches == null && !init.patchRoutesOnNavigation) {
let error = getInternalRouterError(404, { pathname: init.history.location.pathname });
let { matches, route } = getShortCircuitMatches(dataRoutes.activeRoutes);
initialized = true;
renderFallback = !initialized;
initialMatches = matches;
initialErrors = { [route.id]: error };
} else {
if (initialMatches && !init.hydrationData) {
	if (checkFogOfWar(initialMatches, init.history.location.pathname).active) initialMatches = null;
}
if (!initialMatches) {
	initialized = false;
	renderFallback = !initialized;
	initialMatches = [];
	let fogOfWar = checkFogOfWar(null, init.history.location.pathname);
	if (fogOfWar.active && fogOfWar.matches) {
		initialMatchesIsFOW = true;
		initialMatches = fogOfWar.matches;
	}
} else if (initialMatches.some((m) => m.route.lazy)) {
	initialized = false;
	renderFallback = !initialized;
} else if (!initialMatches.some((m) => routeHasLoaderOrMiddleware(m.route))) {
	initialized = true;
	renderFallback = !initialized;
} else {
	let loaderData = init.hydrationData ? init.hydrationData.loaderData : null;
	let errors = init.hydrationData ? init.hydrationData.errors : null;
	let relevantMatches = initialMatches;
	if (errors) {
		let idx = initialMatches.findIndex((m) => errors[m.route.id] !== void 0);
		relevantMatches = relevantMatches.slice(0, idx + 1);
	}
	renderFallback = false;
	initialized = true;
	relevantMatches.forEach((m) => {
		let status = getRouteHydrationStatus(m.route, loaderData, errors);
		renderFallback = renderFallback || status.renderFallback;
		initialized = initialized && !status.shouldLoad;
	});
}
}
let router;
let state = {
historyAction: init.history.action,
location: init.history.location,
matches: initialMatches,
initialized,
renderFallback,
navigation: IDLE_NAVIGATION,
restoreScrollPosition: init.hydrationData != null ? false : null,
preventScrollReset: false,
revalidation: "idle",
loaderData: init.hydrationData && init.hydrationData.loaderData || {},
actionData: init.hydrationData && init.hydrationData.actionData || null,
errors: init.hydrationData && init.hydrationData.errors || initialErrors,
fetchers: /* @__PURE__ */ new Map(),
blockers: /* @__PURE__ */ new Map()
};
let pendingAction = "POP";
let pendingPopstateNavigationDfd = null;
let pendingPreventScrollReset = false;
let pendingNavigationController;
let pendingViewTransitionEnabled = false;
let appliedViewTransitions = /* @__PURE__ */ new Map();
let removePageHideEventListener = null;
let isUninterruptedRevalidation = false;
let isRevalidationRequired = false;
let cancelledFetcherLoads = /* @__PURE__ */ new Set();
let fetchControllers = /* @__PURE__ */ new Map();
let incrementingLoadId = 0;
let pendingNavigationLoadId = -1;
let fetchReloadIds = /* @__PURE__ */ new Map();
let fetchRedirectIds = /* @__PURE__ */ new Set();
let fetchLoadMatches = /* @__PURE__ */ new Map();
let activeFetchers = /* @__PURE__ */ new Map();
let fetchersQueuedForDeletion = /* @__PURE__ */ new Set();
let blockerFunctions = /* @__PURE__ */ new Map();
let unblockBlockerHistoryUpdate = void 0;
let pendingRevalidationDfd = null;
function initialize() {
unlistenHistory = init.history.listen(({ action: historyAction, location, delta }) => {
	if (unblockBlockerHistoryUpdate) {
		unblockBlockerHistoryUpdate();
		unblockBlockerHistoryUpdate = void 0;
		return;
	}
	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.");
	let blockerKey = shouldBlockNavigation({
		currentLocation: state.location,
		nextLocation: location,
		historyAction
	});
	if (blockerKey && delta != null) {
		let nextHistoryUpdatePromise = new Promise((resolve) => {
			unblockBlockerHistoryUpdate = resolve;
		});
		init.history.go(delta * -1);
		updateBlocker(blockerKey, {
			state: "blocked",
			location,
			proceed() {
				updateBlocker(blockerKey, {
					state: "proceeding",
					proceed: void 0,
					reset: void 0,
					location
				});
				nextHistoryUpdatePromise.then(() => init.history.go(delta));
			},
			reset() {
				let blockers = new Map(state.blockers);
				blockers.set(blockerKey, IDLE_BLOCKER);
				updateState({ blockers });
			}
		});
		pendingPopstateNavigationDfd?.resolve();
		pendingPopstateNavigationDfd = null;
		return;
	}
	return startNavigation(historyAction, location);
});
if (isBrowser) {
	restoreAppliedTransitions(routerWindow, appliedViewTransitions);
	let _saveAppliedTransitions = () => persistAppliedTransitions(routerWindow, appliedViewTransitions);
	routerWindow.addEventListener("pagehide", _saveAppliedTransitions);
	removePageHideEventListener = () => routerWindow.removeEventListener("pagehide", _saveAppliedTransitions);
}
if (!state.initialized) startNavigation("POP", state.location, { initialHydration: true });
return router;
}
function dispose() {
if (unlistenHistory) unlistenHistory();
if (removePageHideEventListener) removePageHideEventListener();
subscribers.clear();
pendingNavigationController && pendingNavigationController.abort();
state.fetchers.forEach((_, key) => deleteFetcher(state.fetchers, key));
state.blockers.forEach((_, key) => deleteBlocker(key));
}
function subscribe(fn) {
subscribers.add(fn);
if (bufferedInitialStateUpdate) {
	let { newErrors } = bufferedInitialStateUpdate;
	bufferedInitialStateUpdate = null;
	fn(state, {
		deletedFetchers: [],
		newErrors,
		viewTransitionOpts: void 0,
		flushSync: false
	});
}
return () => subscribers.delete(fn);
}
function updateState(newState, opts = {}) {
if (newState.matches) newState.matches = newState.matches.map((m) => {
	let route = manifest[m.route.id];
	let matchRoute = m.route;
	if (matchRoute.element !== route.element || matchRoute.errorElement !== route.errorElement || matchRoute.hydrateFallbackElement !== route.hydrateFallbackElement) return {
		...m,
		route
	};
	return m;
});
state = {
	...state,
	...newState
};
let unmountedFetchers = [];
let mountedFetchers = [];
state.fetchers.forEach((fetcher, key) => {
	if (fetcher.state === "idle") if (fetchersQueuedForDeletion.has(key)) unmountedFetchers.push(key);
	else mountedFetchers.push(key);
});
fetchersQueuedForDeletion.forEach((key) => {
	if (!state.fetchers.has(key) && !fetchControllers.has(key)) unmountedFetchers.push(key);
});
if (subscribers.size === 0) bufferedInitialStateUpdate = { newErrors: newState.errors ?? null };
[...subscribers].forEach((subscriber) => subscriber(state, {
	deletedFetchers: unmountedFetchers,
	newErrors: newState.errors ?? null,
	viewTransitionOpts: opts.viewTransitionOpts,
	flushSync: opts.flushSync === true
}));
unmountedFetchers.forEach((key) => deleteFetcher(state.fetchers, key));
mountedFetchers.forEach((key) => state.fetchers.delete(key));
}
function completeNavigation(location, newState, { flushSync } = {}) {
let isActionReload = state.actionData != null && state.navigation.formMethod != null && isMutationMethod(state.navigation.formMethod) && state.navigation.state === "loading" && location.state?._isRedirect !== true;
let actionData;
if (newState.actionData) if (Object.keys(newState.actionData).length > 0) actionData = newState.actionData;
else actionData = null;
else if (isActionReload) actionData = state.actionData;
else actionData = null;
let loaderData = newState.loaderData ? mergeLoaderData(state.loaderData, newState.loaderData, newState.matches || [], newState.errors) : state.loaderData;
let blockers = state.blockers;
if (blockers.size > 0 && !isUninterruptedRevalidation) {
	blockers = new Map(blockers);
	blockers.forEach((_, k) => blockers.set(k, IDLE_BLOCKER));
}
let restoreScrollPosition = isUninterruptedRevalidation ? false : getSavedScrollPosition(location, newState.matches || state.matches);
let preventScrollReset = pendingPreventScrollReset === true || state.navigation.formMethod != null && isMutationMethod(state.navigation.formMethod) && location.state?._isRedirect !== true;
dataRoutes.commitHmrRoutes();
if (isUninterruptedRevalidation) {} else if (pendingAction === "POP") {} else if (pendingAction === "PUSH") init.history.push(location, location.state);
else if (pendingAction === "REPLACE") init.history.replace(location, location.state);
let viewTransitionOpts;
if (pendingAction === "POP" && !isUninterruptedRevalidation && location !== state.location) {
	let priorPaths = appliedViewTransitions.get(state.location.pathname);
	if (priorPaths && priorPaths.has(location.pathname)) viewTransitionOpts = {
		currentLocation: state.location,
		nextLocation: location
	};
	else if (appliedViewTransitions.has(location.pathname)) viewTransitionOpts = {
		currentLocation: location,
		nextLocation: state.location
	};
} else if (pendingViewTransitionEnabled) {
	let toPaths = appliedViewTransitions.get(state.location.pathname);
	if (toPaths) toPaths.add(location.pathname);
	else {
		toPaths = new Set([location.pathname]);
		appliedViewTransitions.set(state.location.pathname, toPaths);
	}
	viewTransitionOpts = {
		currentLocation: state.location,
		nextLocation: location
	};
}
updateState({
	...newState,
	actionData,
	loaderData,
	historyAction: pendingAction,
	location,
	initialized: true,
	renderFallback: false,
	navigation: IDLE_NAVIGATION,
	revalidation: "idle",
	restoreScrollPosition,
	preventScrollReset,
	blockers
}, {
	viewTransitionOpts,
	flushSync: flushSync === true
});
pendingAction = "POP";
pendingPreventScrollReset = false;
pendingViewTransitionEnabled = false;
isUninterruptedRevalidation = false;
isRevalidationRequired = false;
pendingPopstateNavigationDfd?.resolve();
pendingPopstateNavigationDfd = null;
pendingRevalidationDfd?.resolve();
pendingRevalidationDfd = null;
}
async function navigate(to, opts) {
pendingPopstateNavigationDfd?.resolve();
pendingPopstateNavigationDfd = null;
if (typeof to === "number") {
	if (!pendingPopstateNavigationDfd) pendingPopstateNavigationDfd = createDeferred();
	let promise = pendingPopstateNavigationDfd.promise;
	init.history.go(to);
	return promise;
}
let instrumentationNavigateMetaReceiver = consumeInstrumentationClientResultMetaReceiver(router);
let { path, submission, error } = normalizeNavigateOptions(false, normalizeTo(state.location, state.matches, basename, to, opts?.fromRouteId, opts?.relative), opts);
let maskPath;
if (opts?.mask) {
	let partialPath = typeof opts.mask === "string" ? parsePath(opts.mask) : {
		...state.location.mask,
		...opts.mask
	};
	maskPath = {
		pathname: partialPath.pathname ?? "",
		search: partialPath.search ?? "",
		hash: partialPath.hash ?? ""
	};
	if (PROTOCOL_RELATIVE_URL_REGEX.test(maskPath.pathname)) throw new Error("External navigation is not allowed");
	else if (maskPath.pathname.startsWith("\\")) maskPath.pathname = maskPath.pathname.replace(/^\\+/, "/");
	validateNavigationTarget(typeof opts.mask === "string" ? opts.mask : createPath(opts.mask), createPath(maskPath), init.history.createURL("/"), "reject");
}
let currentLocation = state.location;
let nextLocation = createLocation(currentLocation, path, opts && opts.state, void 0, maskPath);
nextLocation = {
	...nextLocation,
	...init.history.encodeLocation(nextLocation)
};
validateNavigationTarget(to == null ? init.history.createHref(state.location) : typeof to === "string" ? to : createPath(to), init.history.createHref(nextLocation.mask || nextLocation), init.history.createURL("/"), "reject");
let userReplace = opts && opts.replace != null ? opts.replace : void 0;
let historyAction = "PUSH";
if (userReplace === true) historyAction = "REPLACE";
else if (userReplace === false) {} else if (submission != null && isMutationMethod(submission.formMethod) && submission.formAction === state.location.pathname + state.location.search) historyAction = "REPLACE";
let preventScrollReset = opts && "preventScrollReset" in opts ? opts.preventScrollReset === true : void 0;
let flushSync = (opts && opts.flushSync) === true;
let blockerKey = shouldBlockNavigation({
	currentLocation,
	nextLocation,
	historyAction
});
if (blockerKey) {
	updateBlocker(blockerKey, {
		state: "blocked",
		location: nextLocation,
		proceed() {
			updateBlocker(blockerKey, {
				state: "proceeding",
				proceed: void 0,
				reset: void 0,
				location: nextLocation
			});
			navigate(to, opts);
		},
		reset() {
			let blockers = new Map(state.blockers);
			blockers.set(blockerKey, IDLE_BLOCKER);
			updateState({ blockers });
		}
	});
	return;
}
await startNavigation(historyAction, nextLocation, {
	submission,
	pendingError: error,
	preventScrollReset,
	replace: opts && opts.replace,
	enableViewTransition: opts && opts.viewTransition,
	flushSync,
	callSiteDefaultShouldRevalidate: opts && opts.defaultShouldRevalidate,
	instrumentationNavigateMetaReceiver
});
}
function revalidate() {
if (!pendingRevalidationDfd) pendingRevalidationDfd = createDeferred();
interruptActiveLoads();
updateState({ revalidation: "loading" });
let promise = pendingRevalidationDfd.promise;
if (state.navigation.state === "submitting") return promise;
if (state.navigation.state === "idle") {
	startNavigation(state.historyAction, state.location, { startUninterruptedRevalidation: true });
	return promise;
}
startNavigation(pendingAction || state.historyAction, state.navigation.location, {
	overrideNavigation: state.navigation,
	enableViewTransition: pendingViewTransitionEnabled === true
});
return promise;
}
async function startNavigation(historyAction, location, opts) {
pendingNavigationController && pendingNavigationController.abort();
pendingNavigationController = null;
pendingAction = historyAction;
isUninterruptedRevalidation = (opts && opts.startUninterruptedRevalidation) === true;
saveScrollPosition(state.location, state.matches);
pendingPreventScrollReset = (opts && opts.preventScrollReset) === true;
pendingViewTransitionEnabled = (opts && opts.enableViewTransition) === true;
let matches = opts?.initialHydration && state.matches && state.matches.length > 0 && !initialMatchesIsFOW ? state.matches : dataRouteMatcher.match(location);
let flushSync = (opts && opts.flushSync) === true;
if (matches && state.initialized && !isRevalidationRequired && isHashChangeOnly(state.location, location) && !(opts && opts.submission && isMutationMethod(opts.submission.formMethod))) {
	completeNavigation(location, { matches }, { flushSync });
	return;
}
let fogOfWar = checkFogOfWar(matches, location.pathname);
if (fogOfWar.active && fogOfWar.matches) matches = fogOfWar.matches;
if (opts?.instrumentationNavigateMetaReceiver) {
	let meta = getInstrumentationNavigateMeta(init.history, location, matches);
	opts.instrumentationNavigateMetaReceiver(meta);
}
if (!matches) {
	let { error, notFoundMatches, route } = handleNavigational404(location.pathname);
	completeNavigation(location, {
		matches: notFoundMatches,
		loaderData: {},
		errors: { [route.id]: error }
	}, { flushSync });
	return;
}
let loadingNavigation = opts && opts.overrideNavigation ? {
	...opts.overrideNavigation,
	matches,
	historyAction
} : void 0;
pendingNavigationController = new AbortController();
let request = createClientSideRequest(init.history, location, pendingNavigationController.signal, opts && opts.submission);
let scopedContext = init.getContext ? await init.getContext() : new RouterContextProvider();
let pendingActionResult;
if (opts && opts.pendingError) pendingActionResult = [findNearestBoundary(matches).route.id, {
	type: "error",
	error: opts.pendingError
}];
else if (opts && opts.submission && isMutationMethod(opts.submission.formMethod)) {
	let actionResult = await handleAction(request, location, opts.submission, matches, historyAction, scopedContext, fogOfWar.active, opts && opts.initialHydration === true, {
		replace: opts.replace,
		flushSync
	});
	if (actionResult.shortCircuited) return;
	if (actionResult.pendingActionResult) {
		let [routeId, result] = actionResult.pendingActionResult;
		if (isErrorResult(result) && isRouteErrorResponse(result.error) && result.error.status === 404) {
			pendingNavigationController = null;
			completeNavigation(location, {
				matches: actionResult.matches,
				loaderData: {},
				errors: { [routeId]: result.error }
			});
			return;
		}
	}
	matches = actionResult.matches || matches;
	pendingActionResult = actionResult.pendingActionResult;
	loadingNavigation = getLoadingNavigation(location, matches, historyAction, opts.submission);
	flushSync = false;
	fogOfWar.active = false;
	request = createClientSideRequest(init.history, request.url, request.signal);
}
let { shortCircuited, matches: updatedMatches, loaderData, errors, workingFetchers } = await handleLoaders(request, location, matches, historyAction, scopedContext, fogOfWar.active, loadingNavigation, opts && opts.submission, opts && opts.fetcherSubmission, opts && opts.replace, opts && opts.initialHydration === true, flushSync, pendingActionResult, opts && opts.callSiteDefaultShouldRevalidate);
if (shortCircuited) return;
pendingNavigationController = null;
completeNavigation(location, {
	matches: updatedMatches || matches,
	...getActionDataForCommit(pendingActionResult),
	loaderData,
	errors,
	...workingFetchers ? { fetchers: workingFetchers } : {}
});
}
async function handleAction(request, location, submission, matches, historyAction, scopedContext, isFogOfWar, initialHydration, opts = {}) {
interruptActiveLoads();
updateState({ navigation: getSubmittingNavigation(location, matches, historyAction, submission) }, { flushSync: opts.flushSync === true });
if (isFogOfWar) {
	let discoverResult = await discoverRoutes(matches, location.pathname, request.signal);
	if (discoverResult.type === "aborted") return { shortCircuited: true };
	else if (discoverResult.type === "error") {
		if (discoverResult.partialMatches.length === 0) {
			let { matches, route } = getShortCircuitMatches(dataRoutes.activeRoutes);
			return {
				matches,
				pendingActionResult: [route.id, {
					type: "error",
					error: discoverResult.error
				}]
			};
		}
		let boundaryId = findNearestBoundary(discoverResult.partialMatches).route.id;
		return {
			matches: discoverResult.partialMatches,
			pendingActionResult: [boundaryId, {
				type: "error",
				error: discoverResult.error
			}]
		};
	} else if (!discoverResult.matches) {
		let { notFoundMatches, error, route } = handleNavigational404(location.pathname);
		return {
			matches: notFoundMatches,
			pendingActionResult: [route.id, {
				type: "error",
				error
			}]
		};
	} else matches = discoverResult.matches;
}
let result;
let actionMatch = getTargetMatch(matches, location);
if (!actionMatch.route.action && !actionMatch.route.lazy) result = {
	type: "error",
	error: getInternalRouterError(405, {
		method: request.method,
		pathname: location.pathname,
		routeId: actionMatch.route.id
	})
};
else {
	let results = await callDataStrategy(request, location, getTargetedDataStrategyMatches(mapRouteProperties, manifest, request, location, matches, actionMatch, initialHydration ? [] : hydrationRouteProperties, scopedContext), scopedContext, null);
	result = results[actionMatch.route.id];
	if (!result) {
		for (let match of matches) if (results[match.route.id]) {
			result = results[match.route.id];
			break;
		}
	}
	if (request.signal.aborted) return { shortCircuited: true };
}
if (isRedirectResult(result)) {
	let replace;
	if (opts && opts.replace != null) replace = opts.replace;
	else replace = normalizeRedirectLocation(result.response.headers.get("Location"), new URL(request.url), basename, init.history) === state.location.pathname + state.location.search;
	await startRedirectNavigation(request, result, true, {
		submission,
		replace
	});
	return { shortCircuited: true };
}
if (isErrorResult(result)) {
	let boundaryMatch = findNearestBoundary(matches, actionMatch.route.id);
	if ((opts && opts.replace) !== true) pendingAction = "PUSH";
	return {
		matches,
		pendingActionResult: [
			boundaryMatch.route.id,
			result,
			actionMatch.route.id
		]
	};
}
return {
	matches,
	pendingActionResult: [actionMatch.route.id, result]
};
}
async function handleLoaders(request, location, matches, historyAction, scopedContext, isFogOfWar, overrideNavigation, submission, fetcherSubmission, replace, initialHydration, flushSync, pendingActionResult, callSiteDefaultShouldRevalidate) {
let loadingNavigation = overrideNavigation || getLoadingNavigation(location, matches, historyAction, submission);
let activeSubmission = submission || fetcherSubmission || getSubmissionFromNavigation(loadingNavigation);
let shouldUpdateNavigationState = !isUninterruptedRevalidation && !initialHydration;
if (isFogOfWar) {
	if (shouldUpdateNavigationState) {
		let actionData = getUpdatedActionData(pendingActionResult);
		updateState({
			navigation: loadingNavigation,
			...actionData !== void 0 ? { actionData } : {}
		}, { flushSync });
	}
	let discoverResult = await discoverRoutes(matches, location.pathname, request.signal);
	if (discoverResult.type === "aborted") return { shortCircuited: true };
	else if (discoverResult.type === "error") {
		if (discoverResult.partialMatches.length === 0) {
			let { matches, route } = getShortCircuitMatches(dataRoutes.activeRoutes);
			return {
				matches,
				loaderData: {},
				errors: { [route.id]: discoverResult.error }
			};
		}
		let boundaryId = findNearestBoundary(discoverResult.partialMatches).route.id;
		return {
			matches: discoverResult.partialMatches,
			loaderData: {},
			errors: { [boundaryId]: discoverResult.error }
		};
	} else if (!discoverResult.matches) {
		let { error, notFoundMatches, route } = handleNavigational404(location.pathname);
		return {
			matches: notFoundMatches,
			loaderData: {},
			errors: { [route.id]: error }
		};
	} else matches = discoverResult.matches;
}
let { dsMatches, revalidatingFetchers } = getMatchesToLoad(request, scopedContext, mapRouteProperties, manifest, init.history, state, matches, activeSubmission, location, initialHydration ? [] : hydrationRouteProperties, initialHydration === true, isRevalidationRequired, cancelledFetcherLoads, fetchersQueuedForDeletion, fetchLoadMatches, fetchRedirectIds, dataRouteMatcher, pendingActionResult, callSiteDefaultShouldRevalidate);
pendingNavigationLoadId = ++incrementingLoadId;
if (!init.dataStrategy && !dsMatches.some((m) => m.shouldLoad) && !dsMatches.some((m) => m.route.middleware && m.route.middleware.length > 0) && revalidatingFetchers.length === 0) {
	let workingFetchers = new Map(state.fetchers);
	let didUpdateFetcherRedirects = markFetchRedirectsDone(workingFetchers);
	completeNavigation(location, {
		matches,
		loaderData: {},
		errors: pendingActionResult && isErrorResult(pendingActionResult[1]) ? { [pendingActionResult[0]]: pendingActionResult[1].error } : null,
		...getActionDataForCommit(pendingActionResult),
		...didUpdateFetcherRedirects ? { fetchers: workingFetchers } : {}
	}, { flushSync });
	return { shortCircuited: true };
}
if (shouldUpdateNavigationState) {
	let updates = {};
	if (!isFogOfWar) {
		updates.navigation = loadingNavigation;
		let actionData = getUpdatedActionData(pendingActionResult);
		if (actionData !== void 0) updates.actionData = actionData;
	}
	if (revalidatingFetchers.length > 0) updates.fetchers = getUpdatedRevalidatingFetchers(revalidatingFetchers);
	updateState(updates, { flushSync });
}
revalidatingFetchers.forEach((rf) => {
	abortFetcher(rf.key);
	if (rf.controller) fetchControllers.set(rf.key, rf.controller);
});
let abortPendingFetchRevalidations = () => revalidatingFetchers.forEach((f) => abortFetcher(f.key));
if (pendingNavigationController) pendingNavigationController.signal.addEventListener("abort", abortPendingFetchRevalidations);
let { loaderResults, fetcherResults } = await callLoadersAndMaybeResolveData(dsMatches, revalidatingFetchers, request, location, scopedContext);
if (request.signal.aborted) return { shortCircuited: true };
if (pendingNavigationController) pendingNavigationController.signal.removeEventListener("abort", abortPendingFetchRevalidations);
revalidatingFetchers.forEach((rf) => fetchControllers.delete(rf.key));
let redirect = findRedirect(loaderResults);
if (redirect) {
	await startRedirectNavigation(request, redirect.result, true, { replace });
	return { shortCircuited: true };
}
redirect = findRedirect(fetcherResults);
if (redirect) {
	fetchRedirectIds.add(redirect.key);
	await startRedirectNavigation(request, redirect.result, true, { replace });
	return { shortCircuited: true };
}
let workingFetchers = new Map(state.fetchers);
let { loaderData, errors } = processLoaderData(state, matches, loaderResults, pendingActionResult, revalidatingFetchers, fetcherResults, workingFetchers);
if (initialHydration && state.errors) errors = {
	...state.errors,
	...errors
};
let didUpdateFetcherRedirects = markFetchRedirectsDone(workingFetchers);
let didAbortFetchLoads = abortStaleFetchLoads(pendingNavigationLoadId, workingFetchers);
let shouldUpdateFetchers = didUpdateFetcherRedirects || didAbortFetchLoads || revalidatingFetchers.length > 0;
return {
	matches,
	loaderData,
	errors,
	...shouldUpdateFetchers ? { workingFetchers } : {}
};
}
function getUpdatedActionData(pendingActionResult) {
if (pendingActionResult && !isErrorResult(pendingActionResult[1])) return { [pendingActionResult[0]]: pendingActionResult[1].data };
else if (state.actionData) if (Object.keys(state.actionData).length === 0) return null;
else return state.actionData;
}
function getUpdatedRevalidatingFetchers(revalidatingFetchers) {
let workingFetchers = new Map(state.fetchers);
revalidatingFetchers.forEach((rf) => {
	let fetcher = workingFetchers.get(rf.key);
	let revalidatingFetcher = getLoadingFetcher(void 0, fetcher ? fetcher.data : void 0);
	workingFetchers.set(rf.key, revalidatingFetcher);
});
return workingFetchers;
}
async function fetch(key, routeId, href, opts) {
abortFetcher(key);
let flushSync = (opts && opts.flushSync) === true;
let instrumentationResultMetaReceiver = consumeInstrumentationClientResultMetaReceiver(router);
let normalizedPath = normalizeTo(state.location, state.matches, basename, href, routeId, opts?.relative);
let matches = dataRouteMatcher.match(normalizedPath);
let fogOfWar = checkFogOfWar(matches, normalizedPath);
if (fogOfWar.active && fogOfWar.matches) matches = fogOfWar.matches;
if (instrumentationResultMetaReceiver) instrumentationResultMetaReceiver(getInstrumentationNavigateMeta(init.history, normalizedPath, matches));
if (!matches) {
	setFetcherError(key, routeId, getInternalRouterError(404, { pathname: normalizedPath }), { flushSync });
	return;
}
let { path, submission, error } = normalizeNavigateOptions(true, normalizedPath, opts);
if (error) {
	setFetcherError(key, routeId, error, { flushSync });
	return;
}
let scopedContext = init.getContext ? await init.getContext() : new RouterContextProvider();
let preventScrollReset = (opts && opts.preventScrollReset) === true;
if (submission && isMutationMethod(submission.formMethod)) {
	await handleFetcherAction(key, routeId, path, matches, scopedContext, fogOfWar.active, flushSync, preventScrollReset, submission, opts && opts.defaultShouldRevalidate);
	return;
}
let loadMatch = {
	routeId,
	path,
	isDiscovering: fogOfWar.active
};
fetchLoadMatches.set(key, loadMatch);
await handleFetcherLoader(key, loadMatch, matches, scopedContext, flushSync, preventScrollReset, submission);
}
async function handleFetcherAction(key, routeId, path, requestMatches, scopedContext, isFogOfWar, flushSync, preventScrollReset, submission, callSiteDefaultShouldRevalidate) {
interruptActiveLoads();
fetchLoadMatches.delete(key);
updateFetcherState(key, getSubmittingFetcher(submission, state.fetchers.get(key)), { flushSync });
let abortController = new AbortController();
let fetchRequest = createClientSideRequest(init.history, path, abortController.signal, submission);
if (isFogOfWar) {
	let discoverResult = await discoverRoutes(requestMatches, new URL(fetchRequest.url).pathname, fetchRequest.signal, key);
	if (discoverResult.type === "aborted") return;
	else if (discoverResult.type === "error") {
		setFetcherError(key, routeId, discoverResult.error, { flushSync });
		return;
	} else if (!discoverResult.matches) {
		setFetcherError(key, routeId, getInternalRouterError(404, { pathname: path }), { flushSync });
		return;
	} else requestMatches = discoverResult.matches;
}
let match = getTargetMatch(requestMatches, path);
if (!match.route.action && !match.route.lazy) {
	setFetcherError(key, routeId, getInternalRouterError(405, {
		method: submission.formMethod,
		pathname: path,
		routeId
	}), { flushSync });
	return;
}
fetchControllers.set(key, abortController);
let originatingLoadId = incrementingLoadId;
let fetchMatches = getTargetedDataStrategyMatches(mapRouteProperties, manifest, fetchRequest, path, requestMatches, match, hydrationRouteProperties, scopedContext);
let actionResults = await callDataStrategy(fetchRequest, path, fetchMatches, scopedContext, key);
let actionResult = actionResults[match.route.id];
if (!actionResult) {
	for (let match of fetchMatches) if (actionResults[match.route.id]) {
		actionResult = actionResults[match.route.id];
		break;
	}
}
if (fetchRequest.signal.aborted) {
	if (fetchControllers.get(key) === abortController) fetchControllers.delete(key);
	return;
}
if (fetchersQueuedForDeletion.has(key)) {
	if (isRedirectResult(actionResult) || isErrorResult(actionResult)) {
		updateFetcherState(key, getDoneFetcher(void 0));
		return;
	}
} else {
	if (isRedirectResult(actionResult)) {
		fetchControllers.delete(key);
		if (pendingNavigationLoadId > originatingLoadId) {
			updateFetcherState(key, getDoneFetcher(void 0));
			return;
		} else {
			fetchRedirectIds.add(key);
			updateFetcherState(key, getLoadingFetcher(submission));
			return startRedirectNavigation(fetchRequest, actionResult, false, {
				fetcherSubmission: submission,
				preventScrollReset
			});
		}
	}
	if (isErrorResult(actionResult)) {
		setFetcherError(key, routeId, actionResult.error);
		return;
	}
}
let nextLocation = state.navigation.location || state.location;
let revalidationRequest = createClientSideRequest(init.history, nextLocation, abortController.signal);
let matches = state.navigation.state !== "idle" ? dataRouteMatcher.match(state.navigation.location) : state.matches;
invariant(matches, "Didn't find any matches after fetcher action");
let loadId = ++incrementingLoadId;
fetchReloadIds.set(key, loadId);
let { dsMatches, revalidatingFetchers } = getMatchesToLoad(revalidationRequest, scopedContext, mapRouteProperties, manifest, init.history, state, matches, submission, nextLocation, hydrationRouteProperties, false, isRevalidationRequired, cancelledFetcherLoads, fetchersQueuedForDeletion, fetchLoadMatches, fetchRedirectIds, dataRouteMatcher, [match.route.id, actionResult], callSiteDefaultShouldRevalidate);
let loadFetcher = getLoadingFetcher(submission, actionResult.data);
let workingFetchers = new Map(state.fetchers);
workingFetchers.set(key, loadFetcher);
revalidatingFetchers.filter((rf) => rf.key !== key).forEach((rf) => {
	let staleKey = rf.key;
	let existingFetcher = workingFetchers.get(staleKey);
	let revalidatingFetcher = getLoadingFetcher(void 0, existingFetcher ? existingFetcher.data : void 0);
	workingFetchers.set(staleKey, revalidatingFetcher);
	abortFetcher(staleKey);
	if (rf.controller) fetchControllers.set(staleKey, rf.controller);
});
updateState({ fetchers: workingFetchers });
let abortPendingFetchRevalidations = () => revalidatingFetchers.forEach((rf) => abortFetcher(rf.key));
abortController.signal.addEventListener("abort", abortPendingFetchRevalidations);
let { loaderResults, fetcherResults } = await callLoadersAndMaybeResolveData(dsMatches, revalidatingFetchers, revalidationRequest, nextLocation, scopedContext);
if (abortController.signal.aborted) {
	if (fetchReloadIds.get(key) === loadId) fetchReloadIds.delete(key);
	return;
}
abortController.signal.removeEventListener("abort", abortPendingFetchRevalidations);
fetchReloadIds.delete(key);
fetchControllers.delete(key);
revalidatingFetchers.forEach((r) => fetchControllers.delete(r.key));
let fetcherIsMounted = state.fetchers.has(key);
let getRedirectStateWithDoneFetcher = (s) => {
	if (!fetcherIsMounted) return s;
	let workingFetchers = new Map(s.fetchers);
	workingFetchers.set(key, getDoneFetcher(actionResult.data));
	return {
		...s,
		fetchers: workingFetchers
	};
};
let redirect = findRedirect(loaderResults);
if (redirect) {
	state = getRedirectStateWithDoneFetcher(state);
	return startRedirectNavigation(revalidationRequest, redirect.result, false, { preventScrollReset });
}
redirect = findRedirect(fetcherResults);
if (redirect) {
	fetchRedirectIds.add(redirect.key);
	state = getRedirectStateWithDoneFetcher(state);
	return startRedirectNavigation(revalidationRequest, redirect.result, false, { preventScrollReset });
}
let finalFetchers = new Map(state.fetchers);
if (fetcherIsMounted) finalFetchers.set(key, getDoneFetcher(actionResult.data));
let { loaderData, errors } = processLoaderData(state, matches, loaderResults, void 0, revalidatingFetchers, fetcherResults, finalFetchers);
abortStaleFetchLoads(loadId, finalFetchers);
if (state.navigation.state === "loading" && loadId > pendingNavigationLoadId) {
	invariant(pendingAction, "Expected pending action");
	pendingNavigationController && pendingNavigationController.abort();
	completeNavigation(state.navigation.location, {
		matches,
		loaderData,
		errors,
		fetchers: finalFetchers
	});
} else {
	updateState({
		errors,
		loaderData: mergeLoaderData(state.loaderData, loaderData, matches, errors),
		fetchers: finalFetchers
	});
	isRevalidationRequired = false;
}
}
async function handleFetcherLoader(key, loadMatch, matches, scopedContext, flushSync, preventScrollReset, submission) {
let { routeId, path } = loadMatch;
let existingFetcher = state.fetchers.get(key);
updateFetcherState(key, getLoadingFetcher(submission, existingFetcher ? existingFetcher.data : void 0), { flushSync });
let abortController = new AbortController();
let fetchRequest = createClientSideRequest(init.history, path, abortController.signal);
if (loadMatch.isDiscovering) {
	let discoverResult = await discoverRoutes(matches, new URL(fetchRequest.url).pathname, fetchRequest.signal, key);
	if (discoverResult.type === "aborted") return;
	else if (discoverResult.type === "error") {
		setFetcherError(key, routeId, discoverResult.error, { flushSync });
		return;
	} else if (!discoverResult.matches) {
		setFetcherError(key, routeId, getInternalRouterError(404, { pathname: path }), { flushSync });
		return;
	} else {
		matches = discoverResult.matches;
		loadMatch.isDiscovering = false;
	}
}
let match = getTargetMatch(matches, path);
fetchControllers.set(key, abortController);
let originatingLoadId = incrementingLoadId;
let results = await callDataStrategy(fetchRequest, path, getTargetedDataStrategyMatches(mapRouteProperties, manifest, fetchRequest, path, matches, match, hydrationRouteProperties, scopedContext), scopedContext, key);
let result = results[match.route.id];
if (!result) {
	for (let match of matches) if (results[match.route.id]) {
		result = results[match.route.id];
		break;
	}
}
if (fetchControllers.get(key) === abortController) fetchControllers.delete(key);
if (fetchRequest.signal.aborted) return;
if (fetchersQueuedForDeletion.has(key)) {
	updateFetcherState(key, getDoneFetcher(void 0));
	return;
}
if (isRedirectResult(result)) if (pendingNavigationLoadId > originatingLoadId) {
	updateFetcherState(key, getDoneFetcher(void 0));
	return;
} else {
	fetchRedirectIds.add(key);
	await startRedirectNavigation(fetchRequest, result, false, { preventScrollReset });
	return;
}
if (isErrorResult(result)) {
	setFetcherError(key, routeId, result.error);
	return;
}
updateFetcherState(key, getDoneFetcher(result.data));
}
/**
* Utility function to handle redirects returned from an action or loader.
* Normally, a redirect "replaces" the navigation that triggered it.  So, for
* example:
*
*  - user is on /a
*  - user clicks a link to /b
*  - loader for /b redirects to /c
*
* In a non-JS app the browser would track the in-flight navigation to /b and
* then replace it with /c when it encountered the redirect response.  In
* the end it would only ever update the URL bar with /c.
*
* In client-side routing using pushState/replaceState, we aim to emulate
* this behavior and we also do not update history until the end of the
* navigation (including processed redirects).  This means that we never
* actually touch history until we've processed redirects, so we just use
* the history action from the original navigation (PUSH or REPLACE).
*/
async function startRedirectNavigation(request, redirect, isNavigation, { submission, fetcherSubmission, preventScrollReset, replace } = {}) {
if (!isNavigation) {
	pendingPopstateNavigationDfd?.resolve();
	pendingPopstateNavigationDfd = null;
}
if (redirect.response.headers.has("X-Remix-Revalidate")) isRevalidationRequired = true;
let location = redirect.response.headers.get("Location");
invariant(location, "Expected a Location header on the redirect Response");
let originalLocation = location;
let currentUrl = new URL(request.url);
location = normalizeRedirectLocation(location, currentUrl, basename, init.history);
validateNavigationTarget(originalLocation, location, currentUrl, "allow-explicit");
let redirectLocation = createLocation(state.location, location, { _isRedirect: true });
if (isBrowser) {
	let isDocumentReload = false;
	if (redirect.response.headers.has("X-Remix-Reload-Document")) isDocumentReload = true;
	else if (isAbsoluteUrl(location)) {
		const url = createBrowserURLImpl(routerWindow, location, true);
		isDocumentReload = url.origin !== routerWindow.location.origin || stripBasename(url.pathname, basename) == null;
	}
	if (isDocumentReload) {
		if (replace) routerWindow.location.replace(location);
		else routerWindow.location.assign(location);
		return;
	}
}
pendingNavigationController = null;
let redirectNavigationType = replace === true || redirect.response.headers.has("X-Remix-Replace") ? "REPLACE" : "PUSH";
let { formMethod, formAction, formEncType } = state.navigation;
if (!submission && !fetcherSubmission && formMethod && formAction && formEncType) submission = getSubmissionFromNavigation(state.navigation);
let activeSubmission = submission || fetcherSubmission;
if (redirectPreserveMethodStatusCodes.has(redirect.response.status) && activeSubmission && isMutationMethod(activeSubmission.formMethod)) await startNavigation(redirectNavigationType, redirectLocation, {
	submission: {
		...activeSubmission,
		formAction: location
	},
	preventScrollReset: preventScrollReset || pendingPreventScrollReset,
	enableViewTransition: isNavigation ? pendingViewTransitionEnabled : void 0
});
else await startNavigation(redirectNavigationType, redirectLocation, {
	overrideNavigation: getLoadingNavigation(redirectLocation, [], redirectNavigationType, submission),
	fetcherSubmission,
	preventScrollReset: preventScrollReset || pendingPreventScrollReset,
	enableViewTransition: isNavigation ? pendingViewTransitionEnabled : void 0
});
}
async function callDataStrategy(request, path, matches, scopedContext, fetcherKey) {
let results;
let dataResults = {};
try {
	results = await callDataStrategyImpl(dataStrategyImpl, request, path, matches, fetcherKey, scopedContext, false);
} catch (e) {
	matches.filter((m) => m.shouldLoad).forEach((m) => {
		dataResults[m.route.id] = {
			type: "error",
			error: e
		};
	});
	return dataResults;
}
if (request.signal.aborted) return dataResults;
if (!isMutationMethod(request.method)) for (let match of matches) {
	if (results[match.route.id]?.type === "error") break;
	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] = {
		type: "error",
		result: /* @__PURE__ */ new Error(`No result returned from dataStrategy for route ${match.route.id}`)
	};
}
for (let [routeId, result] of Object.entries(results)) if (isRedirectDataStrategyResult(result)) {
	let response = result.result;
	dataResults[routeId] = {
		type: "redirect",
		response: normalizeRelativeRoutingRedirectResponse(response, request, routeId, matches, basename)
	};
} else dataResults[routeId] = await convertDataStrategyResultToDataResult(result);
return dataResults;
}
async function callLoadersAndMaybeResolveData(matches, fetchersToLoad, request, location, scopedContext) {
let loaderResultsPromise = callDataStrategy(request, location, matches, scopedContext, null);
let fetcherResultsPromise = Promise.all(fetchersToLoad.map(async (f) => {
	if (f.matches && f.match && f.request && f.controller) {
		let result = (await callDataStrategy(f.request, f.path, f.matches, scopedContext, f.key))[f.match.route.id];
		return { [f.key]: result };
	} else return Promise.resolve({ [f.key]: {
		type: "error",
		error: getInternalRouterError(404, { pathname: f.path })
	} });
}));
return {
	loaderResults: await loaderResultsPromise,
	fetcherResults: (await fetcherResultsPromise).reduce((acc, r) => Object.assign(acc, r), {})
};
}
function interruptActiveLoads() {
isRevalidationRequired = true;
fetchLoadMatches.forEach((_, key) => {
	if (fetchControllers.has(key)) cancelledFetcherLoads.add(key);
	abortFetcher(key);
});
}
function updateFetcherState(key, fetcher, opts = {}) {
let workingFetchers = new Map(state.fetchers);
workingFetchers.set(key, fetcher);
updateState({ fetchers: workingFetchers }, { flushSync: (opts && opts.flushSync) === true });
}
function setFetcherError(key, routeId, error, opts = {}) {
let boundaryMatch = findNearestBoundary(state.matches, routeId);
let workingFetchers = new Map(state.fetchers);
deleteFetcher(workingFetchers, key);
updateState({
	errors: { [boundaryMatch.route.id]: error },
	fetchers: workingFetchers
}, { flushSync: (opts && opts.flushSync) === true });
}
function getFetcher(key) {
activeFetchers.set(key, (activeFetchers.get(key) || 0) + 1);
if (fetchersQueuedForDeletion.has(key)) fetchersQueuedForDeletion.delete(key);
return state.fetchers.get(key) || IDLE_FETCHER;
}
function resetFetcher(key, opts) {
abortFetcher(key, opts?.reason);
updateFetcherState(key, getDoneFetcher(null));
}
function deleteFetcher(fetchers, key) {
let fetcher = state.fetchers.get(key);
if (fetchControllers.has(key) && !(fetcher && fetcher.state === "loading" && fetchReloadIds.has(key))) abortFetcher(key);
fetchLoadMatches.delete(key);
fetchReloadIds.delete(key);
fetchRedirectIds.delete(key);
fetchersQueuedForDeletion.delete(key);
cancelledFetcherLoads.delete(key);
fetchers.delete(key);
}
function queueFetcherForDeletion(key) {
let count = (activeFetchers.get(key) || 0) - 1;
if (count <= 0) {
	activeFetchers.delete(key);
	fetchersQueuedForDeletion.add(key);
} else activeFetchers.set(key, count);
updateState({ fetchers: new Map(state.fetchers) });
}
function abortFetcher(key, reason) {
let controller = fetchControllers.get(key);
if (controller) {
	controller.abort(reason);
	fetchControllers.delete(key);
}
}
function markFetchersDone(keys, fetchers) {
for (let key of keys) {
	let fetcher = fetchers.get(key);
	invariant(fetcher, `Expected fetcher: ${key}`);
	let doneFetcher = getDoneFetcher(fetcher.data);
	fetchers.set(key, doneFetcher);
}
}
function markFetchRedirectsDone(fetchers) {
let doneKeys = [];
let didUpdateFetchers = false;
for (let key of fetchRedirectIds) {
	let fetcher = fetchers.get(key);
	invariant(fetcher, `Expected fetcher: ${key}`);
	if (fetcher.state === "loading") {
		fetchRedirectIds.delete(key);
		doneKeys.push(key);
		didUpdateFetchers = true;
	}
}
markFetchersDone(doneKeys, fetchers);
return didUpdateFetchers;
}
function abortStaleFetchLoads(landedId, fetchers) {
let yeetedKeys = [];
for (let [key, id] of fetchReloadIds) if (id < landedId) {
	let fetcher = fetchers.get(key);
	invariant(fetcher, `Expected fetcher: ${key}`);
	if (fetcher.state === "loading") {
		abortFetcher(key);
		fetchReloadIds.delete(key);
		yeetedKeys.push(key);
	}
}
markFetchersDone(yeetedKeys, fetchers);
return yeetedKeys.length > 0;
}
function getBlocker(key, fn) {
let blocker = state.blockers.get(key) || IDLE_BLOCKER;
if (blockerFunctions.get(key) !== fn) blockerFunctions.set(key, fn);
return blocker;
}
function deleteBlocker(key) {
state.blockers.delete(key);
blockerFunctions.delete(key);
}
function updateBlocker(key, newBlocker) {
let blocker = state.blockers.get(key) || IDLE_BLOCKER;
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}`);
let blockers = new Map(state.blockers);
blockers.set(key, newBlocker);
updateState({ blockers });
}
function shouldBlockNavigation({ currentLocation, nextLocation, historyAction }) {
if (blockerFunctions.size === 0) return;
if (blockerFunctions.size > 1) warning(false, "A router only supports one blocker at a time");
let entries = Array.from(blockerFunctions.entries());
let [blockerKey, blockerFunction] = entries[entries.length - 1];
let blocker = state.blockers.get(blockerKey);
if (blocker && blocker.state === "proceeding") return;
if (blockerFunction({
	currentLocation,
	nextLocation,
	historyAction
})) return blockerKey;
}
function handleNavigational404(pathname) {
let error = getInternalRouterError(404, { pathname });
let routesToUse = dataRoutes.activeRoutes;
let { matches, route } = getShortCircuitMatches(routesToUse);
return {
	notFoundMatches: matches,
	route,
	error
};
}
function enableScrollRestoration(positions, getPosition, getKey) {
savedScrollPositions = positions;
getScrollPosition = getPosition;
getScrollRestorationKey = getKey || null;
if (!initialScrollRestored && state.navigation === IDLE_NAVIGATION) {
	initialScrollRestored = true;
	let y = getSavedScrollPosition(state.location, state.matches);
	if (y != null) updateState({ restoreScrollPosition: y });
}
return () => {
	savedScrollPositions = null;
	getScrollPosition = null;
	getScrollRestorationKey = null;
};
}
function getScrollKey(location, matches) {
if (getScrollRestorationKey) return getScrollRestorationKey(location, matches.map((m) => convertRouteMatchToUiMatch(m, state.loaderData))) || location.key;
return location.key;
}
function saveScrollPosition(location, matches) {
if (savedScrollPositions && getScrollPosition) {
	let key = getScrollKey(location, matches);
	savedScrollPositions[key] = getScrollPosition();
}
}
function getSavedScrollPosition(location, matches) {
if (savedScrollPositions) {
	let key = getScrollKey(location, matches);
	let y = savedScrollPositions[key];
	if (typeof y === "number") return y;
}
return null;
}
function checkFogOfWar(matches, pathname) {
if (init.patchRoutesOnNavigation) {
	if (!matches) return {
		active: true,
		matches: dataRouteMatcher.match(pathname, true) || []
	};
	else if (Object.keys(matches[0].params).length > 0) return {
		active: true,
		matches: dataRouteMatcher.match(pathname, true)
	};
}
return {
	active: false,
	matches: null
};
}
async function discoverRoutes(matches, pathname, signal, fetcherKey) {
if (!init.patchRoutesOnNavigation) return {
	type: "success",
	matches
};
let partialMatches = matches;
while (true) {
	let localManifest = manifest;
	try {
		await init.patchRoutesOnNavigation({
			signal,
			path: pathname,
			matches: partialMatches,
			fetcherKey,
			patch: (routeId, children) => {
				if (signal.aborted) return;
				patchRoutesImpl(routeId, children, dataRoutes, localManifest, mapRouteProperties, false);
			}
		});
	} catch (e) {
		return {
			type: "error",
			error: e,
			partialMatches
		};
	}
	if (signal.aborted) return { type: "aborted" };
	let newMatches = dataRouteMatcher.match(pathname);
	let newPartialMatches = null;
	if (newMatches) if (Object.keys(newMatches[0].params).length === 0) return {
		type: "success",
		matches: newMatches
	};
	else {
		newPartialMatches = dataRouteMatcher.match(pathname, true);
		if (!(newPartialMatches && partialMatches.length < newPartialMatches.length && compareMatches(partialMatches, newPartialMatches.slice(0, partialMatches.length)))) return {
			type: "success",
			matches: newMatches
		};
	}
	if (!newPartialMatches) newPartialMatches = dataRouteMatcher.match(pathname, true);
	if (!newPartialMatches || compareMatches(partialMatches, newPartialMatches)) return {
		type: "success",
		matches: null
	};
	partialMatches = newPartialMatches;
}
}
function compareMatches(a, b) {
return a.length === b.length && a.every((m, i) => m.route.id === b[i].route.id);
}
function _internalSetRoutes(newRoutes) {
manifest = {};
dataRoutes.setHmrRoutes(convertRoutesToDataRoutes(newRoutes, mapRouteProperties, void 0, manifest));
}
function patchRoutes(routeId, children, unstable_allowElementMutations = false) {
patchRoutesImpl(routeId, children, dataRoutes, manifest, mapRouteProperties, unstable_allowElementMutations);
if (!dataRoutes.hasHMRRoutes) updateState({});
}
router = {
get basename() {
	return basename;
},
get future() {
	return future;
},
get state() {
	return state;
},
get routes() {
	return dataRoutes.stableRoutes;
},
match(locationArg) {
	return dataRouteMatcher.match(locationArg);
},
get manifest() {
	return manifest;
},
get window() {
	return routerWindow;
},
initialize,
subscribe,
enableScrollRestoration,
navigate,
fetch,
revalidate,
createHref: (to) => init.history.createHref(to),
createURL: (to) => init.history.createURL(to),
encodeLocation: (to) => init.history.encodeLocation(to),
getFetcher,
resetFetcher,
deleteFetcher: queueFetcherForDeletion,
dispose,
getBlocker,
deleteBlocker,
patchRoutes,
_internalFetchControllers: fetchControllers,
_internalSetRoutes,
_internalSetStateDoNotUseOrYouWillBreakYourApp(newState) {
	updateState(newState);
}
};
if (init.instrumentations) router = instrumentClientSideRouter(router, init.instrumentations.map((i) => i.router).filter(Boolean));
return router;
1396}
1397/**
1398* Create a static handler to perform server-side data loading
1399*
1400* @example
1401* export async function handleRequest(request: Request) {
1402*   let { query, dataRoutes } = createStaticHandler(routes);
1403*   let context = await query(request);
1404*
1405*   if (context instanceof Response) {
1406*     return context;
1407*   }
1408*
1409*   let router = createStaticRouter(dataRoutes, context);
1410*   return new Response(
1411*     ReactDOMServer.renderToString(<StaticRouterProvider ... />),
1412*     { headers: { "Content-Type": "text/html" } }
1413*   );
1414* }
1415*
1416* @public
1417* @category Data Routers
1418* @mode data
1419* @param routes The {@link RouteObject | route objects} to create a static
1420* handler for
1421* @param opts Options
1422* @param opts.basename The base URL for the static handler (default: `/`)
1423* @param opts.future Future flags for the static handler
1424* @returns A static handler that can be used to query data for the provided
1425* routes
1426*/
1427function createStaticHandler(routes, opts) {
invariant(routes.length > 0, "You must provide a non-empty routes array to createStaticHandler");
let manifest = {};
let basename = (opts ? opts.basename : null) || "/";
let _mapRouteProperties = opts?.mapRouteProperties;
let mapRouteProperties = _mapRouteProperties ? _mapRouteProperties : () => ({});
let dataRouteMatcher = createDataRouteMatcher({ ...opts?.future }, basename);
if (opts?.instrumentations) {
let instrumentations = opts.instrumentations;
mapRouteProperties = (route) => {
	return {
		..._mapRouteProperties?.(route),
		...getRouteInstrumentationUpdates(instrumentations.map((i) => i.route).filter(Boolean), route)
	};
};
}
let dataRoutes = convertRoutesToDataRoutes(routes, mapRouteProperties, void 0, manifest);
dataRouteMatcher.update(dataRoutes);
let match = (locationArg) => dataRouteMatcher.match(locationArg);
/**
* The query() method is intended for document requests, in which we want to
* call an optional action and potentially multiple loaders for all nested
* routes.  It returns a StaticHandlerContext object, which is very similar
* to the router state (location, loaderData, actionData, errors, etc.) and
* also adds SSR-specific information such as the statusCode and headers
* from action/loaders Responses.
*
* It _should_ never throw and should report all errors through the
* returned handlerContext.errors object, properly associating errors to
* their error boundary.  Additionally, it tracks _deepestRenderedBoundaryId
* which can be used to emulate React error boundaries during SSR by performing
* a second pass only down to the boundaryId.
*
* The one exception where we do not return a StaticHandlerContext is when a
* redirect response is returned or thrown from any action/loader.  We
* propagate that out and return the raw Response so the HTTP server can
* return it directly.
*
* - `opts.requestContext` is an optional server context that will be passed
*   to actions/loaders in the `context` parameter
* - `opts.skipLoaderErrorBubbling` is an optional parameter that will prevent
*   the bubbling of errors which allows single-fetch-type implementations
*   where the client will handle the bubbling and we may need to return data
*   for the handling route
*/
async function query(request, { requestContext, filterMatchesToLoad, skipLoaderErrorBubbling, skipRevalidation, dataStrategy, generateMiddlewareResponse, normalizePath } = {}) {
let normalizePathImpl = normalizePath || defaultNormalizePath;
let method = request.method;
let location = createLocation("", normalizePathImpl(request), null, "default");
let matches = dataRouteMatcher.match(location);
requestContext = requestContext != null ? requestContext : new RouterContextProvider();
if (!isValidMethod(method) && method !== "HEAD") {
	let error = getInternalRouterError(405, { method });
	let { matches: methodNotAllowedMatches, route } = getShortCircuitMatches(dataRoutes);
	let staticContext = {
		basename,
		location,
		matches: methodNotAllowedMatches,
		loaderData: {},
		actionData: null,
		errors: { [route.id]: error },
		statusCode: error.status,
		loaderHeaders: {},
		actionHeaders: {},
		_match: match
	};
	return generateMiddlewareResponse ? generateMiddlewareResponse(() => Promise.resolve(staticContext)) : staticContext;
} else if (!matches) {
	let error = getInternalRouterError(404, { pathname: location.pathname });
	let { matches: notFoundMatches, route } = getShortCircuitMatches(dataRoutes);
	let staticContext = {
		basename,
		location,
		matches: notFoundMatches,
		loaderData: {},
		actionData: null,
		errors: { [route.id]: error },
		statusCode: error.status,
		loaderHeaders: {},
		actionHeaders: {},
		_match: match
	};
	return generateMiddlewareResponse ? generateMiddlewareResponse(() => Promise.resolve(staticContext)) : staticContext;
}
if (generateMiddlewareResponse) {
	invariant(requestContext instanceof RouterContextProvider, "When using middleware in `staticHandler.query()`, any provided `requestContext` must be an instance of `RouterContextProvider`");
	try {
		await loadLazyMiddlewareForMatches(matches, manifest, mapRouteProperties);
		let renderedStaticContext;
		let response = await runServerMiddlewarePipeline({
			request,
			url: createDataFunctionUrl(request, location),
			pattern: getRoutePattern(matches),
			matches,
			params: matches[0].params,
			context: requestContext
		}, async () => {
			return await generateMiddlewareResponse(async (revalidationRequest, opts = {}) => {
				let result = await queryImpl(revalidationRequest, location, matches, requestContext, dataStrategy || null, skipLoaderErrorBubbling === true, null, "filterMatchesToLoad" in opts ? opts.filterMatchesToLoad ?? null : filterMatchesToLoad ?? null, skipRevalidation === true);
				if (isResponse(result)) return result;
				renderedStaticContext = {
					location,
					basename,
					...result,
					_match: match
				};
				return renderedStaticContext;
			});
		}, async (error, routeId) => {
			if (isRedirectResponse(error)) return error;
			if (isResponse(error)) try {
				error = new ErrorResponseImpl(error.status, error.statusText, await parseResponseBody(error));
			} catch (e) {
				error = e;
			}
			if (isDataWithResponseInit(error)) error = dataWithResponseInitToErrorResponse(error);
			if (renderedStaticContext) {
				if (routeId in renderedStaticContext.loaderData) renderedStaticContext.loaderData[routeId] = void 0;
				let staticContext = getStaticContextFromError(dataRoutes, renderedStaticContext, error, skipLoaderErrorBubbling ? routeId : findNearestBoundary(matches, routeId).route.id);
				return generateMiddlewareResponse(() => Promise.resolve(staticContext));
			} else {
				let staticContext = {
					matches,
					location,
					basename,
					loaderData: {},
					actionData: null,
					errors: { [skipLoaderErrorBubbling ? routeId : findNearestBoundary(matches, matches.find((m) => m.route.id === routeId || m.route.loader)?.route.id || routeId).route.id]: error },
					statusCode: isRouteErrorResponse(error) ? error.status : 500,
					actionHeaders: {},
					loaderHeaders: {},
					_match: match
				};
				return generateMiddlewareResponse(() => Promise.resolve(staticContext));
			}
		});
		invariant(isResponse(response), "Expected a response in query()");
		return response;
	} catch (e) {
		if (isResponse(e)) return e;
		throw e;
	}
}
let result = await queryImpl(request, location, matches, requestContext, dataStrategy || null, skipLoaderErrorBubbling === true, null, filterMatchesToLoad || null, skipRevalidation === true);
if (isResponse(result)) return result;
return {
	location,
	basename,
	...result,
	_match: match
};
}
/**
* The queryRoute() method is intended for targeted route requests, either
* for fetch ?_data requests or resource route requests.  In this case, we
* are only ever calling a single action or loader, and we are returning the
* returned value directly.  In most cases, this will be a Response returned
* from the action/loader, but it may be a primitive or other value as well -
* and in such cases the calling context should handle that accordingly.
*
* We do respect the throw/return differentiation, so if an action/loader
* throws, then this method will throw the value.  This is important so we
* can do proper boundary identification in Remix where a thrown Response
* must go to the Catch Boundary but a returned Response is happy-path.
*
* One thing to note is that any Router-initiated Errors that make sense
* to associate with a status code will be thrown as an ErrorResponse
* instance which include the raw Error, such that the calling context can
* serialize the error as they see fit while including the proper response
* code.  Examples here are 404 and 405 errors that occur prior to reaching
* any user-defined loaders.
*
* - `opts.routeId` allows you to specify the specific route handler to call.
*   If not provided the handler will determine the proper route by matching
*   against `request.url`
* - `opts.requestContext` is an optional server context that will be passed
*    to actions/loaders in the `context` parameter
*/
async function queryRoute(request, { routeId, requestContext, dataStrategy, generateMiddlewareResponse, normalizePath } = {}) {
let normalizePathImpl = normalizePath || defaultNormalizePath;
let method = request.method;
let location = createLocation("", normalizePathImpl(request), null, "default");
let matches = dataRouteMatcher.match(location);
requestContext = requestContext != null ? requestContext : new RouterContextProvider();
if (!isValidMethod(method) && method !== "HEAD" && method !== "OPTIONS") throw getInternalRouterError(405, { method });
else if (!matches) throw getInternalRouterError(404, { pathname: location.pathname });
let match = routeId ? matches.find((m) => m.route.id === routeId) : getTargetMatch(matches, location);
if (routeId && !match) throw getInternalRouterError(403, {
	pathname: location.pathname,
	routeId
});
else if (!match) throw getInternalRouterError(404, { pathname: location.pathname });
if (generateMiddlewareResponse) {
	invariant(requestContext instanceof RouterContextProvider, "When using middleware in `staticHandler.queryRoute()`, any provided `requestContext` must be an instance of `RouterContextProvider`");
	await loadLazyMiddlewareForMatches(matches, manifest, mapRouteProperties);
	return await runServerMiddlewarePipeline({
		request,
		url: createDataFunctionUrl(request, location),
		pattern: getRoutePattern(matches),
		matches,
		params: matches[0].params,
		context: requestContext
	}, async () => {
		return await generateMiddlewareResponse(async (innerRequest) => {
			let processed = handleQueryResult(await queryImpl(innerRequest, location, matches, requestContext, dataStrategy || null, false, match, null, false));
			return isResponse(processed) ? processed : typeof processed === "string" ? new Response(processed) : Response.json(processed);
		});
	}, (error) => {
		if (isDataWithResponseInit(error)) return Promise.resolve(dataWithResponseInitToResponse(error));
		if (isResponse(error)) return Promise.resolve(error);
		throw error;
	});
}
return handleQueryResult(await queryImpl(request, location, matches, requestContext, dataStrategy || null, false, match, null, false));
function handleQueryResult(result) {
	if (isResponse(result)) return result;
	let error = result.errors ? Object.values(result.errors)[0] : void 0;
	if (error !== void 0) throw error;
	if (result.actionData) return Object.values(result.actionData)[0];
	if (result.loaderData) return Object.values(result.loaderData)[0];
}
}
async function queryImpl(request, location, matches, requestContext, dataStrategy, skipLoaderErrorBubbling, routeMatch, filterMatchesToLoad, skipRevalidation) {
invariant(request.signal, "query()/queryRoute() requests must contain an AbortController signal");
try {
	if (isMutationMethod(request.method)) return await submit(request, location, matches, routeMatch || getTargetMatch(matches, location), requestContext, dataStrategy, skipLoaderErrorBubbling, routeMatch != null, filterMatchesToLoad, skipRevalidation);
	let result = await loadRouteData(request, location, matches, requestContext, dataStrategy, skipLoaderErrorBubbling, routeMatch, filterMatchesToLoad);
	return isResponse(result) ? result : {
		...result,
		actionData: null,
		actionHeaders: {}
	};
} catch (e) {
	if (isDataStrategyResult(e) && isResponse(e.result)) {
		if (e.type === "error") throw e.result;
		return e.result;
	}
	if (isRedirectResponse(e)) return e;
	throw e;
}
}
async function submit(request, location, matches, actionMatch, requestContext, dataStrategy, skipLoaderErrorBubbling, isRouteRequest, filterMatchesToLoad, skipRevalidation) {
let result;
if (!actionMatch.route.action && !actionMatch.route.lazy) {
	let error = getInternalRouterError(405, {
		method: request.method,
		pathname: new URL(request.url).pathname,
		routeId: actionMatch.route.id
	});
	if (isRouteRequest) throw error;
	result = {
		type: "error",
		error
	};
} else {
	result = (await callDataStrategy(request, location, getTargetedDataStrategyMatches(mapRouteProperties, manifest, request, location, matches, actionMatch, [], requestContext), isRouteRequest, requestContext, dataStrategy))[actionMatch.route.id];
	if (request.signal.aborted) throwStaticHandlerAbortedError(request, isRouteRequest);
}
if (isRedirectResult(result)) throw new Response(null, {
	status: result.response.status,
	headers: { Location: result.response.headers.get("Location") }
});
if (isRouteRequest) {
	if (isErrorResult(result)) throw result.error;
	return {
		matches: [actionMatch],
		loaderData: {},
		actionData: { [actionMatch.route.id]: result.data },
		errors: null,
		statusCode: 200,
		loaderHeaders: {},
		actionHeaders: {}
	};
}
if (skipRevalidation) if (isErrorResult(result)) {
	let boundaryMatch = skipLoaderErrorBubbling ? actionMatch : findNearestBoundary(matches, actionMatch.route.id);
	return {
		statusCode: isRouteErrorResponse(result.error) ? result.error.status : result.statusCode != null ? result.statusCode : 500,
		actionData: null,
		actionHeaders: { ...result.headers ? { [actionMatch.route.id]: result.headers } : {} },
		matches,
		loaderData: {},
		errors: { [boundaryMatch.route.id]: result.error },
		loaderHeaders: {}
	};
} else return {
	actionData: { [actionMatch.route.id]: result.data },
	actionHeaders: result.headers ? { [actionMatch.route.id]: result.headers } : {},
	matches,
	loaderData: {},
	errors: null,
	statusCode: result.statusCode || 200,
	loaderHeaders: {}
};
let loaderRequest = new Request(request.url, {
	headers: request.headers,
	redirect: request.redirect,
	signal: request.signal
});
if (isErrorResult(result)) return {
	...await loadRouteData(loaderRequest, location, matches, requestContext, dataStrategy, skipLoaderErrorBubbling, null, filterMatchesToLoad, [(skipLoaderErrorBubbling ? actionMatch : findNearestBoundary(matches, actionMatch.route.id)).route.id, result]),
	statusCode: isRouteErrorResponse(result.error) ? result.error.status : result.statusCode != null ? result.statusCode : 500,
	actionData: null,
	actionHeaders: { ...result.headers ? { [actionMatch.route.id]: result.headers } : {} }
};
return {
	...await loadRouteData(loaderRequest, location, matches, requestContext, dataStrategy, skipLoaderErrorBubbling, null, filterMatchesToLoad),
	actionData: { [actionMatch.route.id]: result.data },
	...result.statusCode ? { statusCode: result.statusCode } : {},
	actionHeaders: result.headers ? { [actionMatch.route.id]: result.headers } : {}
};
}
async function loadRouteData(request, location, matches, requestContext, dataStrategy, skipLoaderErrorBubbling, routeMatch, filterMatchesToLoad, pendingActionResult) {
let isRouteRequest = routeMatch != null;
if (isRouteRequest && !routeMatch?.route.loader && !routeMatch?.route.lazy) throw getInternalRouterError(400, {
	method: request.method,
	pathname: new URL(request.url).pathname,
	routeId: routeMatch?.route.id
});
let dsMatches;
if (routeMatch) dsMatches = getTargetedDataStrategyMatches(mapRouteProperties, manifest, request, location, matches, routeMatch, [], requestContext);
else {
	let maxIdx = pendingActionResult && isErrorResult(pendingActionResult[1]) ? matches.findIndex((m) => m.route.id === pendingActionResult[0]) - 1 : void 0;
	let pattern = getRoutePattern(matches);
	dsMatches = matches.map((match, index) => {
		if (maxIdx != null && index > maxIdx) return getDataStrategyMatch(mapRouteProperties, manifest, request, location, pattern, match, [], requestContext, false);
		return getDataStrategyMatch(mapRouteProperties, manifest, request, location, pattern, match, [], requestContext, (match.route.loader || match.route.lazy) != null && (!filterMatchesToLoad || filterMatchesToLoad(match)));
	});
}
if (!dataStrategy && !dsMatches.some((m) => m.shouldLoad)) return {
	matches,
	loaderData: {},
	errors: pendingActionResult && isErrorResult(pendingActionResult[1]) ? { [pendingActionResult[0]]: pendingActionResult[1].error } : null,
	statusCode: 200,
	loaderHeaders: {}
};
let results = await callDataStrategy(request, location, dsMatches, isRouteRequest, requestContext, dataStrategy);
if (request.signal.aborted) throwStaticHandlerAbortedError(request, isRouteRequest);
return {
	...processRouteLoaderData(matches, results, pendingActionResult, true, skipLoaderErrorBubbling),
	matches
};
}
async function callDataStrategy(request, location, matches, isRouteRequest, requestContext, dataStrategy) {
let results = await callDataStrategyImpl(dataStrategy || defaultDataStrategy, request, location, matches, null, requestContext, true);
let dataResults = {};
await Promise.all(matches.map(async (match) => {
	if (!(match.route.id in results)) return;
	let result = results[match.route.id];
	if (isRedirectDataStrategyResult(result)) {
		let response = result.result;
		throw normalizeRelativeRoutingRedirectResponse(response, request, match.route.id, matches, basename);
	}
	if (isRouteRequest) {
		if (isResponse(result.result)) throw result;
		else if (isDataWithResponseInit(result.result)) throw dataWithResponseInitToResponse(result.result);
	}
	dataResults[match.route.id] = await convertDataStrategyResultToDataResult(result);
}));
return dataResults;
}
return {
dataRoutes,
match,
query,
queryRoute
};
1794}
1795/**
1796* Given an existing StaticHandlerContext and an error thrown at render time,
1797* provide an updated StaticHandlerContext suitable for a second SSR render
1798*
1799* @category Utils
1800*/
1801function getStaticContextFromError(routes, handlerContext, error, boundaryId) {
let errorBoundaryId = boundaryId || handlerContext._deepestRenderedBoundaryId || routes[0].id;
return {
...handlerContext,
statusCode: isRouteErrorResponse(error) ? error.status : 500,
errors: { [errorBoundaryId]: error }
};
1808}
1809function throwStaticHandlerAbortedError(request, isRouteRequest) {
if (request.signal.reason !== void 0) throw request.signal.reason;
throw new Error(`${isRouteRequest ? "queryRoute" : "query"}() call aborted without an \`AbortSignal.reason\`: ${request.method} ${request.url}`);
1812}
1813function isSubmissionNavigation(opts) {
return opts != null && ("formData" in opts && opts.formData != null || "body" in opts && opts.body !== void 0);
1815}
1816function defaultNormalizePath(request) {
let url = new URL(request.url);
return {
pathname: url.pathname,
search: url.search,
hash: url.hash
};
1823}
1824function normalizeTo(location, matches, basename, to, fromRouteId, relative) {
let contextualMatches;
let activeRouteMatch;
if (fromRouteId) {
contextualMatches = [];
for (let match of matches) {
	contextualMatches.push(match);
	if (match.route.id === fromRouteId) {
		activeRouteMatch = match;
		break;
	}
}
} else {
contextualMatches = matches;
activeRouteMatch = matches[matches.length - 1];
}
let path = resolveTo(to ? to : ".", getResolveToMatches(contextualMatches), stripBasename(location.pathname, basename) || location.pathname, relative === "path");
if (to == null) {
path.search = location.search;
path.hash = location.hash;
}
if ((to == null || to === "" || to === ".") && activeRouteMatch) {
let nakedIndex = hasNakedIndexQuery(path.search);
if (activeRouteMatch.route.index && !nakedIndex) path.search = path.search ? path.search.replace(/^\?/, "?index&") : "?index";
else if (!activeRouteMatch.route.index && nakedIndex) {
	let params = new URLSearchParams(path.search);
	let indexValues = params.getAll("index");
	params.delete("index");
	indexValues.filter((v) => v).forEach((v) => params.append("index", v));
	let qs = params.toString();
	path.search = qs ? `?${qs}` : "";
}
}
if (basename !== "/") path.pathname = prependBasename({
basename,
pathname: path.pathname
});
return createPath(path);
1862}
1863function normalizeNavigateOptions(isFetcher, path, opts) {
if (!opts || !isSubmissionNavigation(opts)) return { path };
if (opts.formMethod && !isValidMethod(opts.formMethod)) return {
path,
error: getInternalRouterError(405, { method: opts.formMethod })
};
let getInvalidBodyError = () => ({
path,
error: getInternalRouterError(400, { type: "invalid-body" })
});
let formMethod = (opts.formMethod || "get").toUpperCase();
let formAction = stripHashFromPath(path);
if (opts.body !== void 0) {
if (opts.formEncType === "text/plain") {
	if (!isMutationMethod(formMethod)) return getInvalidBodyError();
	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}\n`, "") : String(opts.body);
	return {
		path,
		submission: {
			formMethod,
			formAction,
			formEncType: opts.formEncType,
			formData: void 0,
			json: void 0,
			text
		}
	};
} else if (opts.formEncType === "application/json") {
	if (!isMutationMethod(formMethod)) return getInvalidBodyError();
	try {
		let json = typeof opts.body === "string" ? JSON.parse(opts.body) : opts.body;
		return {
			path,
			submission: {
				formMethod,
				formAction,
				formEncType: opts.formEncType,
				formData: void 0,
				json,
				text: void 0
			}
		};
	} catch {
		return getInvalidBodyError();
	}
}
}
invariant(typeof FormData === "function", "FormData is not available in this environment");
let searchParams;
let formData;
if (opts.formData) {
searchParams = convertFormDataToSearchParams(opts.formData);
formData = opts.formData;
} else if (opts.body instanceof FormData) {
searchParams = convertFormDataToSearchParams(opts.body);
formData = opts.body;
} else if (opts.body instanceof URLSearchParams) {
searchParams = opts.body;
formData = convertSearchParamsToFormData(searchParams);
} else if (opts.body == null) {
searchParams = new URLSearchParams();
formData = new FormData();
} else try {
searchParams = new URLSearchParams(opts.body);
formData = convertSearchParamsToFormData(searchParams);
} catch {
return getInvalidBodyError();
}
let submission = {
formMethod,
formAction,
formEncType: opts && opts.formEncType || "application/x-www-form-urlencoded",
formData,
json: void 0,
text: void 0
};
if (isMutationMethod(submission.formMethod)) return {
path,
submission
};
let parsedPath = parsePath(path);
if (isFetcher && parsedPath.search && hasNakedIndexQuery(parsedPath.search)) searchParams.append("index", "");
parsedPath.search = `?${searchParams}`;
return {
path: createPath(parsedPath),
submission
};
1950}
1951function getMatchesToLoad(request, scopedContext, mapRouteProperties, manifest, history, state, matches, submission, location, lazyRoutePropertiesToSkip, initialHydration, isRevalidationRequired, cancelledFetcherLoads, fetchersQueuedForDeletion, fetchLoadMatches, fetchRedirectIds, dataRouteMatcher, pendingActionResult, callSiteDefaultShouldRevalidate) {
let actionResult = pendingActionResult ? isErrorResult(pendingActionResult[1]) ? pendingActionResult[1].error : pendingActionResult[1].data : void 0;
let currentUrl = history.createURL(state.location);
let nextUrl = history.createURL(location);
let maxIdx;
if (initialHydration && state.errors) {
let boundaryId = Object.keys(state.errors)[0];
maxIdx = matches.findIndex((m) => m.route.id === boundaryId);
} else if (pendingActionResult && isErrorResult(pendingActionResult[1])) {
let boundaryId = pendingActionResult[0];
maxIdx = matches.findIndex((m) => m.route.id === boundaryId) - 1;
}
let actionStatus = pendingActionResult ? pendingActionResult[1].statusCode : void 0;
let shouldSkipRevalidation = actionStatus && actionStatus >= 400;
let baseShouldRevalidateArgs = {
currentUrl,
currentParams: state.matches[0]?.params || {},
nextUrl,
nextParams: matches[0].params,
...submission,
actionResult,
actionStatus
};
let pattern = getRoutePattern(matches);
let dsMatches = matches.map((match, index) => {
let { route } = match;
let forceShouldLoad = null;
if (maxIdx != null && index > maxIdx) forceShouldLoad = false;
else if (route.lazy) forceShouldLoad = true;
else if (!routeHasLoaderOrMiddleware(route)) forceShouldLoad = false;
else if (initialHydration) {
	let { shouldLoad } = getRouteHydrationStatus(route, state.loaderData, state.errors);
	forceShouldLoad = shouldLoad;
} else if (isNewLoader(state.loaderData, state.matches[index], match)) forceShouldLoad = true;
if (forceShouldLoad !== null) return getDataStrategyMatch(mapRouteProperties, manifest, request, location, pattern, match, lazyRoutePropertiesToSkip, scopedContext, forceShouldLoad);
let defaultShouldRevalidate = false;
if (typeof callSiteDefaultShouldRevalidate === "boolean") defaultShouldRevalidate = callSiteDefaultShouldRevalidate;
else if (shouldSkipRevalidation) defaultShouldRevalidate = false;
else if (isRevalidationRequired) defaultShouldRevalidate = true;
else if (currentUrl.pathname + currentUrl.search === nextUrl.pathname + nextUrl.search) defaultShouldRevalidate = true;
else if (currentUrl.search !== nextUrl.search) defaultShouldRevalidate = true;
else if (isNewRouteInstance(state.matches[index], match)) defaultShouldRevalidate = true;
let shouldRevalidateArgs = {
	...baseShouldRevalidateArgs,
	defaultShouldRevalidate
};
return getDataStrategyMatch(mapRouteProperties, manifest, request, location, pattern, match, lazyRoutePropertiesToSkip, scopedContext, shouldRevalidateLoader(match, shouldRevalidateArgs), shouldRevalidateArgs, callSiteDefaultShouldRevalidate);
});
let revalidatingFetchers = [];
fetchLoadMatches.forEach((f, key) => {
if (initialHydration || !matches.some((m) => m.route.id === f.routeId) || fetchersQueuedForDeletion.has(key) || f.isDiscovering) return;
let fetcher = state.fetchers.get(key);
let isMidInitialLoad = fetcher && fetcher.state !== "idle" && fetcher.data === void 0;
let fetcherMatches = dataRouteMatcher.match(f.path);
if (!fetcherMatches) {
	revalidatingFetchers.push({
		key,
		routeId: f.routeId,
		path: f.path,
		matches: null,
		match: null,
		request: null,
		controller: null
	});
	return;
}
if (fetchRedirectIds.has(key)) return;
let fetcherMatch = getTargetMatch(fetcherMatches, f.path);
let fetchController = new AbortController();
let fetchRequest = createClientSideRequest(history, f.path, fetchController.signal);
let fetcherDsMatches = null;
if (cancelledFetcherLoads.has(key)) {
	cancelledFetcherLoads.delete(key);
	fetcherDsMatches = getTargetedDataStrategyMatches(mapRouteProperties, manifest, fetchRequest, f.path, fetcherMatches, fetcherMatch, lazyRoutePropertiesToSkip, scopedContext);
} else if (isMidInitialLoad) {
	if (isRevalidationRequired) fetcherDsMatches = getTargetedDataStrategyMatches(mapRouteProperties, manifest, fetchRequest, f.path, fetcherMatches, fetcherMatch, lazyRoutePropertiesToSkip, scopedContext);
} else {
	let defaultShouldRevalidate;
	if (typeof callSiteDefaultShouldRevalidate === "boolean") defaultShouldRevalidate = callSiteDefaultShouldRevalidate;
	else if (shouldSkipRevalidation) defaultShouldRevalidate = false;
	else defaultShouldRevalidate = isRevalidationRequired;
	let shouldRevalidateArgs = {
		...baseShouldRevalidateArgs,
		defaultShouldRevalidate
	};
	if (shouldRevalidateLoader(fetcherMatch, shouldRevalidateArgs)) fetcherDsMatches = getTargetedDataStrategyMatches(mapRouteProperties, manifest, fetchRequest, f.path, fetcherMatches, fetcherMatch, lazyRoutePropertiesToSkip, scopedContext, shouldRevalidateArgs);
}
if (fetcherDsMatches) revalidatingFetchers.push({
	key,
	routeId: f.routeId,
	path: f.path,
	matches: fetcherDsMatches,
	match: fetcherMatch,
	request: fetchRequest,
	controller: fetchController
});
});
return {
dsMatches,
revalidatingFetchers
};
2052}
2053function routeHasLoaderOrMiddleware(route) {
return route.loader != null || route.middleware != null && route.middleware.length > 0;
2055}
2056function getRouteHydrationStatus(route, loaderData, errors) {
if (route.lazy) return {
shouldLoad: true,
renderFallback: true
};
if (!routeHasLoaderOrMiddleware(route)) return {
shouldLoad: false,
renderFallback: false
};
let hasData = loaderData != null && route.id in loaderData;
let hasError = errors != null && errors[route.id] !== void 0;
if (!hasData && hasError) return {
shouldLoad: false,
renderFallback: false
};
if (typeof route.loader === "function" && route.loader.hydrate === true) return {
shouldLoad: true,
renderFallback: !hasData
};
let shouldLoad = !hasData && !hasError;
return {
shouldLoad,
renderFallback: shouldLoad
};
2080}
2081function isNewLoader(currentLoaderData, currentMatch, match) {
let isNew = !currentMatch || match.route.id !== currentMatch.route.id;
let isMissingData = !currentLoaderData.hasOwnProperty(match.route.id);
return isNew || isMissingData;
2085}
2086function isNewRouteInstance(currentMatch, match) {
let currentPath = currentMatch.route.path;
return currentMatch.pathname !== match.pathname || currentPath != null && currentPath.endsWith("*") && currentMatch.params["*"] !== match.params["*"];
2089}
2090function shouldRevalidateLoader(loaderMatch, arg) {
if (loaderMatch.route.shouldRevalidate) {
let routeChoice = loaderMatch.route.shouldRevalidate(arg);
if (typeof routeChoice === "boolean") return routeChoice;
}
return arg.defaultShouldRevalidate;
2096}
2097function patchRoutesImpl(routeId, children, dataRoutes, manifest, mapRouteProperties, allowElementMutations) {
let childrenToPatch;
if (routeId) {
let route = manifest[routeId];
invariant(route, `No route found to patch children into: routeId = ${routeId}`);
if (!route.children) route.children = [];
childrenToPatch = route.children;
} else childrenToPatch = dataRoutes.activeRoutes;
let uniqueChildren = [];
let existingChildren = [];
children.forEach((newRoute) => {
let existingRoute = childrenToPatch.find((existingRoute) => isSameRoute(newRoute, existingRoute));
if (existingRoute) existingChildren.push({
	existingRoute,
	newRoute
});
else uniqueChildren.push(newRoute);
});
if (uniqueChildren.length > 0) {
let newRoutes = convertRoutesToDataRoutes(uniqueChildren, mapRouteProperties, [
	routeId || "_",
	"patch",
	String(childrenToPatch?.length || "0")
], manifest);
childrenToPatch.push(...newRoutes);
}
if (allowElementMutations && existingChildren.length > 0) for (let i = 0; i < existingChildren.length; i++) {
let { existingRoute, newRoute } = existingChildren[i];
let existingRouteTyped = existingRoute;
let [newRouteTyped] = convertRoutesToDataRoutes([newRoute], mapRouteProperties, [], {}, true);
Object.assign(existingRouteTyped, {
	element: newRouteTyped.element ? newRouteTyped.element : existingRouteTyped.element,
	errorElement: newRouteTyped.errorElement ? newRouteTyped.errorElement : existingRouteTyped.errorElement,
	hydrateFallbackElement: newRouteTyped.hydrateFallbackElement ? newRouteTyped.hydrateFallbackElement : existingRouteTyped.hydrateFallbackElement
});
}
if (!dataRoutes.hasHMRRoutes) dataRoutes.setRoutes([...dataRoutes.activeRoutes]);
2134}
2135function isSameRoute(newRoute, existingRoute) {
if ("id" in newRoute && "id" in existingRoute && newRoute.id === existingRoute.id) return true;
if (!(newRoute.index === existingRoute.index && newRoute.path === existingRoute.path && newRoute.caseSensitive === existingRoute.caseSensitive)) return false;
if ((!newRoute.children || newRoute.children.length === 0) && (!existingRoute.children || existingRoute.children.length === 0)) return true;
return newRoute.children?.every((aChild, i) => existingRoute.children?.some((bChild) => isSameRoute(aChild, bChild))) ?? false;
2140}
2141const lazyRoutePropertyCache = /* @__PURE__ */ new WeakMap();
2142const loadLazyRouteProperty = ({ key, route, manifest, mapRouteProperties }) => {
let routeToUpdate = manifest[route.id];
invariant(routeToUpdate, "No route found in manifest");
if (!routeToUpdate.lazy || typeof routeToUpdate.lazy !== "object") return;
let lazyFn = routeToUpdate.lazy[key];
if (!lazyFn) return;
let cache = lazyRoutePropertyCache.get(routeToUpdate);
if (!cache) {
cache = {};
lazyRoutePropertyCache.set(routeToUpdate, cache);
}
let cachedPromise = cache[key];
if (cachedPromise) return cachedPromise;
let propertyPromise = (async () => {
let isUnsupported = isUnsupportedLazyRouteObjectKey(key);
let isStaticallyDefined = routeToUpdate[key] !== void 0;
if (isUnsupported) {
	warning(!isUnsupported, "Route property " + key + " is not a supported lazy route property. This property will be ignored.");
	cache[key] = Promise.resolve();
} else if (isStaticallyDefined) warning(false, `Route "${routeToUpdate.id}" has a static property "${key}" defined. The lazy property will be ignored.`);
else {
	let value = await lazyFn();
	if (value != null) {
		Object.assign(routeToUpdate, { [key]: value });
		Object.assign(routeToUpdate, mapRouteProperties(routeToUpdate));
	}
}
if (typeof routeToUpdate.lazy === "object") {
	routeToUpdate.lazy[key] = void 0;
	if (Object.values(routeToUpdate.lazy).every((value) => value === void 0)) routeToUpdate.lazy = void 0;
}
})();
cache[key] = propertyPromise;
return propertyPromise;
2176};
2177const lazyRouteFunctionCache = /* @__PURE__ */ new WeakMap();
2178/**
2179* Execute route.lazy functions to lazily load route modules (loader, action,
2180* shouldRevalidate) and update the routeManifest in place which shares objects
2181* with dataRoutes so those get updated as well.
2182*/
2183function loadLazyRoute(route, type, manifest, mapRouteProperties, lazyRoutePropertiesToSkip) {
let routeToUpdate = manifest[route.id];
invariant(routeToUpdate, "No route found in manifest");
if (!route.lazy) return {
lazyRoutePromise: void 0,
lazyHandlerPromise: void 0
};
if (typeof route.lazy === "function") {
let cachedPromise = lazyRouteFunctionCache.get(routeToUpdate);
if (cachedPromise) return {
	lazyRoutePromise: cachedPromise,
	lazyHandlerPromise: cachedPromise
};
let lazyRoutePromise = (async () => {
	invariant(typeof route.lazy === "function", "No lazy route function found");
	let lazyRoute = await route.lazy();
	let routeUpdates = {};
	for (let lazyRouteProperty in lazyRoute) {
		let lazyValue = lazyRoute[lazyRouteProperty];
		if (lazyValue === void 0) continue;
		let isUnsupported = isUnsupportedLazyRouteFunctionKey(lazyRouteProperty);
		let isStaticallyDefined = routeToUpdate[lazyRouteProperty] !== void 0;
		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.");
		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.`);
		else routeUpdates[lazyRouteProperty] = lazyValue;
	}
	Object.assign(routeToUpdate, routeUpdates);
	Object.assign(routeToUpdate, {
		...mapRouteProperties(routeToUpdate),
		lazy: void 0
	});
})();
lazyRouteFunctionCache.set(routeToUpdate, lazyRoutePromise);
lazyRoutePromise.catch(() => {});
return {
	lazyRoutePromise,
	lazyHandlerPromise: lazyRoutePromise
};
}
let lazyKeys = Object.keys(route.lazy);
let lazyPropertyPromises = [];
let lazyHandlerPromise = void 0;
for (let key of lazyKeys) {
if (lazyRoutePropertiesToSkip && lazyRoutePropertiesToSkip.includes(key)) continue;
let promise = loadLazyRouteProperty({
	key,
	route,
	manifest,
	mapRouteProperties
});
if (promise) {
	lazyPropertyPromises.push(promise);
	if (key === type) lazyHandlerPromise = promise;
}
}
let lazyRoutePromise = lazyPropertyPromises.length > 0 ? Promise.all(lazyPropertyPromises).then(() => {}) : void 0;
lazyRoutePromise?.catch(() => {});
lazyHandlerPromise?.catch(() => {});
return {
lazyRoutePromise,
lazyHandlerPromise
};
2245}
2246function isNonNullable(value) {
return value !== void 0;
2248}
2249function loadLazyMiddlewareForMatches(matches, manifest, mapRouteProperties) {
let promises = matches.map(({ route }) => {
if (typeof route.lazy !== "object" || !route.lazy.middleware) return;
return loadLazyRouteProperty({
	key: "middleware",
	route,
	manifest,
	mapRouteProperties
});
}).filter(isNonNullable);
return promises.length > 0 ? Promise.all(promises) : void 0;
2260}
2261async function defaultDataStrategy(args) {
let matchesToLoad = args.matches.filter((m) => m.shouldLoad);
let keyedResults = {};
(await Promise.all(matchesToLoad.map((m) => m.resolve()))).forEach((result, i) => {
keyedResults[matchesToLoad[i].route.id] = result;
});
return keyedResults;
2268}
2269async function defaultDataStrategyWithMiddleware(args) {
if (!args.matches.some((m) => m.route.middleware)) return defaultDataStrategy(args);
return runClientMiddlewarePipeline(args, () => defaultDataStrategy(args));
2272}
2273function runServerMiddlewarePipeline(args, handler, errorHandler) {
return runMiddlewarePipeline(args, handler, processResult, isResponse, errorHandler);
function processResult(result) {
return isDataWithResponseInit(result) ? dataWithResponseInitToResponse(result) : result;
}
2278}
2279function runClientMiddlewarePipeline(args, handler) {
return runMiddlewarePipeline(args, handler, (r) => {
if (isRedirectResponse(r)) throw r;
return r;
}, isDataStrategyResults, errorHandler);
async function errorHandler(error, routeId, nextResult) {
if (nextResult) return Object.assign(nextResult.value, { [routeId]: {
	type: "error",
	result: error
} });
else {
	let { matches } = args;
	let maxBoundaryIdx = Math.min(Math.max(matches.findIndex((m) => m.route.id === routeId), 0), Math.max(matches.findIndex((m) => m.shouldCallHandler()), 0));
	let deepestRouteId = matches[maxBoundaryIdx].route.id;
	for (let match of matches.slice(0, maxBoundaryIdx + 1)) try {
		await match._lazyPromises?.route;
	} catch {
		deepestRouteId = match.route.id;
		break;
	}
	return { [findNearestBoundary(matches, deepestRouteId).route.id]: {
		type: "error",
		result: error
	} };
}
}
2305}
2306async function runMiddlewarePipeline(args, handler, processResult, isResult, errorHandler) {
let { matches, ...dataFnArgs } = args;
return await callRouteMiddleware(dataFnArgs, matches.flatMap((m) => m.route.middleware ? m.route.middleware.map((fn) => [m.route.id, fn]) : []), handler, processResult, isResult, errorHandler);
2309}
2310async function callRouteMiddleware(args, middlewares, handler, processResult, isResult, errorHandler, idx = 0) {
let { request } = args;
if (request.signal.aborted) throw request.signal.reason ?? /* @__PURE__ */ new Error(`Request aborted: ${request.method} ${request.url}`);
let tuple = middlewares[idx];
if (!tuple) return await handler();
let [routeId, middleware] = tuple;
let nextResult;
let next = async () => {
if (nextResult) throw new Error("You may only call `next()` once per middleware");
try {
	nextResult = { value: await callRouteMiddleware(args, middlewares, handler, processResult, isResult, errorHandler, idx + 1) };
	return nextResult.value;
} catch (error) {
	nextResult = { value: await errorHandler(error, routeId, nextResult) };
	return nextResult.value;
}
};
try {
let value = await middleware(args, next);
let result = value != null ? processResult(value) : void 0;
if (isResult(result)) return result;
else if (nextResult) return result ?? nextResult.value;
else {
	nextResult = { value: await next() };
	return nextResult.value;
}
} catch (error) {
return await errorHandler(error, routeId, nextResult);
}
2339}
2340function getDataStrategyMatchLazyPromises(mapRouteProperties, manifest, request, match, lazyRoutePropertiesToSkip) {
let lazyMiddlewarePromise = loadLazyRouteProperty({
key: "middleware",
route: match.route,
manifest,
mapRouteProperties
});
let lazyRoutePromises = loadLazyRoute(match.route, isMutationMethod(request.method) ? "action" : "loader", manifest, mapRouteProperties, lazyRoutePropertiesToSkip);
return {
middleware: lazyMiddlewarePromise,
route: lazyRoutePromises.lazyRoutePromise,
handler: lazyRoutePromises.lazyHandlerPromise
};
2353}
2354function getDataStrategyMatch(mapRouteProperties, manifest, request, path, pattern, match, lazyRoutePropertiesToSkip, scopedContext, shouldLoad, shouldRevalidateArgs = null, callSiteDefaultShouldRevalidate) {
let isUsingNewApi = false;
let _lazyPromises = getDataStrategyMatchLazyPromises(mapRouteProperties, manifest, request, match, lazyRoutePropertiesToSkip);
return {
...match,
_lazyPromises,
shouldLoad,
shouldRevalidateArgs,
shouldCallHandler(defaultShouldRevalidate) {
	isUsingNewApi = true;
	if (!shouldRevalidateArgs) return shouldLoad;
	if (typeof callSiteDefaultShouldRevalidate === "boolean") return shouldRevalidateLoader(match, {
		...shouldRevalidateArgs,
		defaultShouldRevalidate: callSiteDefaultShouldRevalidate
	});
	if (typeof defaultShouldRevalidate === "boolean") return shouldRevalidateLoader(match, {
		...shouldRevalidateArgs,
		defaultShouldRevalidate
	});
	return shouldRevalidateLoader(match, shouldRevalidateArgs);
},
resolve(handlerOverride) {
	let { lazy, loader, middleware } = match.route;
	let callHandler = isUsingNewApi || shouldLoad || handlerOverride && !isMutationMethod(request.method) && (lazy || loader);
	let isMiddlewareOnlyRoute = middleware && middleware.length > 0 && !loader && !lazy;
	if (callHandler && (isMutationMethod(request.method) || !isMiddlewareOnlyRoute)) return callLoaderOrAction({
		request,
		path,
		pattern,
		match,
		lazyHandlerPromise: _lazyPromises?.handler,
		lazyRoutePromise: _lazyPromises?.route,
		handlerOverride,
		scopedContext
	});
	return Promise.resolve({
		type: "data",
		result: void 0
	});
}
};
2395}
2396function getTargetedDataStrategyMatches(mapRouteProperties, manifest, request, path, matches, targetMatch, lazyRoutePropertiesToSkip, scopedContext, shouldRevalidateArgs = null) {
return matches.map((match) => {
if (match.route.id !== targetMatch.route.id) return {
	...match,
	shouldLoad: false,
	shouldRevalidateArgs,
	shouldCallHandler: () => false,
	_lazyPromises: getDataStrategyMatchLazyPromises(mapRouteProperties, manifest, request, match, lazyRoutePropertiesToSkip),
	resolve: () => Promise.resolve({
		type: "data",
		result: void 0
	})
};
return getDataStrategyMatch(mapRouteProperties, manifest, request, path, getRoutePattern(matches), match, lazyRoutePropertiesToSkip, scopedContext, true, shouldRevalidateArgs);
});
2411}
2412async function callDataStrategyImpl(dataStrategyImpl, request, path, matches, fetcherKey, scopedContext, isStaticHandler) {
if (matches.some((m) => m._lazyPromises?.middleware)) await Promise.all(matches.map((m) => m._lazyPromises?.middleware));
let dataStrategyArgs = {
request,
url: createDataFunctionUrl(request, path),
pattern: getRoutePattern(matches),
params: matches[0].params,
context: scopedContext,
matches
};
let runClientMiddleware = isStaticHandler ? () => {
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`");
} : (cb) => {
let typedDataStrategyArgs = dataStrategyArgs;
return runClientMiddlewarePipeline(typedDataStrategyArgs, () => {
	return cb({
		...typedDataStrategyArgs,
		fetcherKey,
		runClientMiddleware: () => {
			throw new Error("Cannot call `runClientMiddleware()` from within an `runClientMiddleware` handler");
		}
	});
});
};
let results = await dataStrategyImpl({
...dataStrategyArgs,
fetcherKey,
runClientMiddleware
});
try {
await Promise.all(matches.flatMap((m) => [m._lazyPromises?.handler, m._lazyPromises?.route]));
} catch {}
return results;
2445}
2446async function callLoaderOrAction({ request, path, pattern, match, lazyHandlerPromise, lazyRoutePromise, handlerOverride, scopedContext }) {
let result;
let onReject;
let isAction = isMutationMethod(request.method);
let type = isAction ? "action" : "loader";
let runHandler = (handler) => {
let reject;
let abortPromise = new Promise((_, r) => reject = r);
onReject = () => reject();
request.signal.addEventListener("abort", onReject);
let actualHandler = (ctx) => {
	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}]`));
	return handler({
		request,
		url: createDataFunctionUrl(request, path),
		pattern,
		params: match.params,
		context: scopedContext
	}, ...ctx !== void 0 ? [ctx] : []);
};
let handlerPromise = (async () => {
	try {
		return {
			type: "data",
			result: await (handlerOverride ? handlerOverride((ctx) => actualHandler(ctx)) : actualHandler())
		};
	} catch (e) {
		return {
			type: "error",
			result: e
		};
	}
})();
return Promise.race([handlerPromise, abortPromise]);
};
try {
let handler = isAction ? match.route.action : match.route.loader;
if (lazyHandlerPromise || lazyRoutePromise) if (handler) {
	let handlerError;
	let [value] = await Promise.all([
		runHandler(handler).catch((e) => {
			handlerError = e;
		}),
		lazyHandlerPromise,
		lazyRoutePromise
	]);
	if (handlerError !== void 0) throw handlerError;
	result = value;
} else {
	await lazyHandlerPromise;
	let handler = isAction ? match.route.action : match.route.loader;
	if (handler) [result] = await Promise.all([runHandler(handler), lazyRoutePromise]);
	else if (type === "action") {
		let url = new URL(request.url);
		let pathname = url.pathname + url.search;
		throw getInternalRouterError(405, {
			method: request.method,
			pathname,
			routeId: match.route.id
		});
	} else return {
		type: "data",
		result: void 0
	};
}
else if (!handler) {
	let url = new URL(request.url);
	throw getInternalRouterError(404, { pathname: url.pathname + url.search });
} else result = await runHandler(handler);
} catch (e) {
return {
	type: "error",
	result: e
};
} finally {
if (onReject) request.signal.removeEventListener("abort", onReject);
}
return result;
2524}
2525async function parseResponseBody(response) {
let contentType = response.headers.get("Content-Type");
if (contentType && /\bapplication\/json\b/.test(contentType)) return response.body == null ? null : response.json();
return response.text();
2529}
2530async function convertDataStrategyResultToDataResult(dataStrategyResult) {
let { result, type } = dataStrategyResult;
if (isResponse(result)) {
let data;
try {
	data = await parseResponseBody(result);
} catch (e) {
	return {
		type: "error",
		error: e
	};
}
if (type === "error") return {
	type: "error",
	error: new ErrorResponseImpl(result.status, result.statusText, data),
	statusCode: result.status,
	headers: result.headers
};
return {
	type: "data",
	data,
	statusCode: result.status,
	headers: result.headers
};
}
if (type === "error") {
if (isDataWithResponseInit(result)) {
	if (result.data instanceof Error) return {
		type: "error",
		error: result.data,
		statusCode: result.init?.status,
		headers: result.init?.headers ? new Headers(result.init.headers) : void 0
	};
	return {
		type: "error",
		error: dataWithResponseInitToErrorResponse(result),
		statusCode: isRouteErrorResponse(result) ? result.status : void 0,
		headers: result.init?.headers ? new Headers(result.init.headers) : void 0
	};
}
return {
	type: "error",
	error: result,
	statusCode: isRouteErrorResponse(result) ? result.status : void 0
};
}
if (isDataWithResponseInit(result)) return {
type: "data",
data: result.data,
statusCode: result.init?.status,
headers: result.init?.headers ? new Headers(result.init.headers) : void 0
};
return {
type: "data",
data: result
};
2586}
2587function normalizeRelativeRoutingRedirectResponse(response, request, routeId, matches, basename) {
let location = response.headers.get("Location");
invariant(location, "Redirects returned/thrown from loaders/actions must have a Location header");
if (!isAbsoluteUrl(location)) {
let trimmedMatches = matches.slice(0, matches.findIndex((m) => m.route.id === routeId) + 1);
location = normalizeTo(new URL(request.url), trimmedMatches, basename, location);
response.headers.set("Location", location);
}
return response;
2596}
2597const invalidProtocols = [
"about:",
"blob:",
"chrome:",
"chrome-untrusted:",
"content:",
"data:",
"devtools:",
"file:",
"filesystem:",
"javascript:"
2608];
2609function hasInvalidProtocol(location) {
try {
return invalidProtocols.includes(new URL(location).protocol);
} catch {
return false;
}
2615}
2616function normalizeRedirectLocation(location, currentUrl, basename, historyInstance) {
if (isAbsoluteUrl(location)) {
let normalizedLocation = location;
let url = PROTOCOL_RELATIVE_URL_REGEX.test(normalizedLocation) ? new URL(normalizeProtocolRelativeUrl(normalizedLocation, currentUrl.protocol)) : new URL(normalizedLocation);
if (hasInvalidProtocol(url.toString())) throw new Error("Invalid redirect location");
let isSameBasename = stripBasename(url.pathname, basename) != null;
if (url.origin === currentUrl.origin && isSameBasename) return removeDoubleSlashes(url.pathname) + url.search + url.hash;
}
try {
if (hasInvalidProtocol(historyInstance.createURL(location).toString())) throw new Error("Invalid redirect location");
} catch {}
return location;
2628}
2629function createClientSideRequest(history, location, signal, submission) {
let url = history.createURL(stripHashFromPath(location)).toString();
let init = { signal };
if (submission && isMutationMethod(submission.formMethod)) {
let { formMethod, formEncType } = submission;
init.method = formMethod.toUpperCase();
if (formEncType === "application/json") {
	init.headers = new Headers({ "Content-Type": formEncType });
	init.body = JSON.stringify(submission.json);
} else if (formEncType === "text/plain") init.body = submission.text;
else if (formEncType === "application/x-www-form-urlencoded" && submission.formData) init.body = convertFormDataToSearchParams(submission.formData);
else init.body = submission.formData;
}
return new Request(url, init);
2643}
2644function convertFormDataToSearchParams(formData) {
let searchParams = new URLSearchParams();
for (let [key, value] of formData.entries()) searchParams.append(key, typeof value === "string" ? value : value.name);
return searchParams;
2648}
2649function convertSearchParamsToFormData(searchParams) {
let formData = new FormData();
for (let [key, value] of searchParams.entries()) formData.append(key, value);
return formData;
2653}
2654function processRouteLoaderData(matches, results, pendingActionResult, isStaticHandler = false, skipLoaderErrorBubbling = false) {
let loaderData = {};
let errors = null;
let statusCode;
let foundError = false;
let loaderHeaders = {};
let pendingError = pendingActionResult && isErrorResult(pendingActionResult[1]) ? pendingActionResult[1].error : void 0;
matches.forEach((match) => {
if (!(match.route.id in results)) return;
let id = match.route.id;
let result = results[id];
invariant(!isRedirectResult(result), "Cannot handle redirect results in processLoaderData");
if (isErrorResult(result)) {
	let error = result.error;
	if (pendingError !== void 0) {
		error = pendingError;
		pendingError = void 0;
	}
	errors = errors || {};
	if (skipLoaderErrorBubbling) errors[id] = error;
	else {
		let boundaryMatch = findNearestBoundary(matches, id);
		if (errors[boundaryMatch.route.id] == null) errors[boundaryMatch.route.id] = error;
	}
	if (!isStaticHandler) loaderData[id] = ResetLoaderDataSymbol;
	if (!foundError) {
		foundError = true;
		statusCode = isRouteErrorResponse(result.error) ? result.error.status : 500;
	}
	if (result.headers) loaderHeaders[id] = result.headers;
} else {
	loaderData[id] = result.data;
	if (result.statusCode && result.statusCode !== 200 && !foundError) statusCode = result.statusCode;
	if (result.headers) loaderHeaders[id] = result.headers;
}
});
if (pendingError !== void 0 && pendingActionResult) {
errors = { [pendingActionResult[0]]: pendingError };
if (pendingActionResult[2]) loaderData[pendingActionResult[2]] = void 0;
}
return {
loaderData,
errors,
statusCode: statusCode || 200,
loaderHeaders
};
2700}
2701function processLoaderData(state, matches, results, pendingActionResult, revalidatingFetchers, fetcherResults, workingFetchers) {
let { loaderData, errors } = processRouteLoaderData(matches, results, pendingActionResult);
revalidatingFetchers.filter((f) => !f.matches || f.matches.some((m) => m.shouldLoad)).forEach((rf) => {
let { key, match, controller } = rf;
if (controller && controller.signal.aborted) return;
let result = fetcherResults[key];
invariant(result, "Did not find corresponding fetcher result");
if (isErrorResult(result)) {
	let boundaryMatch = findNearestBoundary(state.matches, match?.route.id);
	if (!(errors && errors[boundaryMatch.route.id])) errors = {
		...errors,
		[boundaryMatch.route.id]: result.error
	};
	workingFetchers.delete(key);
} else if (isRedirectResult(result)) invariant(false, "Unhandled fetcher revalidation redirect");
else {
	let doneFetcher = getDoneFetcher(result.data);
	workingFetchers.set(key, doneFetcher);
}
});
return {
loaderData,
errors
};
2725}
2726function mergeLoaderData(loaderData, newLoaderData, matches, errors) {
let mergedLoaderData = Object.entries(newLoaderData).filter(([, v]) => v !== ResetLoaderDataSymbol).reduce((merged, [k, v]) => {
merged[k] = v;
return merged;
}, {});
let preservedCount = 0;
for (let match of matches) {
let id = match.route.id;
if (!newLoaderData.hasOwnProperty(id) && loaderData.hasOwnProperty(id) && match.route.loader) {
	mergedLoaderData[id] = loaderData[id];
	preservedCount++;
}
if (errors && errors.hasOwnProperty(id)) break;
}
return Object.keys(newLoaderData).length === 0 && preservedCount === Object.keys(loaderData).length ? loaderData : mergedLoaderData;
2741}
2742function getActionDataForCommit(pendingActionResult) {
if (!pendingActionResult) return {};
return isErrorResult(pendingActionResult[1]) ? { actionData: {} } : { actionData: { [pendingActionResult[0]]: pendingActionResult[1].data } };
2745}
2746function findNearestBoundary(matches, routeId) {
return (routeId ? matches.slice(0, matches.findIndex((m) => m.route.id === routeId) + 1) : [...matches]).reverse().find((m) => m.route.ErrorBoundary != null || m.route.errorElement != null) || matches[0];
2748}
2749function getShortCircuitMatches(routes) {
let route = routes.length === 1 ? routes[0] : routes.find((r) => r.index || !r.path || r.path === "/") || { id: `__shim-error-route__` };
return {
matches: [{
	params: {},
	pathname: "",
	pathnameBase: "",
	route
}],
route
};
2760}
2761function getInternalRouterError(status, { pathname, routeId, method, type, message } = {}) {
let statusText = "Unknown Server Error";
let errorMessage = "Unknown @remix-run/router error";
if (status === 400) {
statusText = "Bad Request";
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.`;
else if (type === "invalid-body") errorMessage = "Unable to encode submission body";
} else if (status === 403) {
statusText = "Forbidden";
errorMessage = `Route "${routeId}" does not match URL "${pathname}"`;
} else if (status === 404) {
statusText = "Not Found";
errorMessage = `No route matches URL "${pathname}"`;
} else if (status === 405) {
statusText = "Method Not Allowed";
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.`;
else if (method) errorMessage = `Invalid request method "${method.toUpperCase()}"`;
}
return new ErrorResponseImpl(status || 500, statusText, new Error(errorMessage), true);
2780}
2781function findRedirect(results) {
let entries = Object.entries(results);
for (let i = entries.length - 1; i >= 0; i--) {
let [key, result] = entries[i];
if (isRedirectResult(result)) return {
	key,
	result
};
}
2790}
2791function stripHashFromPath(path) {
return createPath({
...typeof path === "string" ? parsePath(path) : path,
hash: ""
});
2796}
2797function isHashChangeOnly(a, b) {
if (a.pathname !== b.pathname || a.search !== b.search) return false;
if (a.hash === "") return b.hash !== "";
else if (a.hash === b.hash) return true;
else if (b.hash !== "") return true;
return false;
2803}
2804function dataWithResponseInitToResponse(data) {
return Response.json(data.data, data.init ?? void 0);
2806}
2807function dataWithResponseInitToErrorResponse(data) {
return new ErrorResponseImpl(data.init?.status ?? 500, data.init?.statusText ?? "Internal Server Error", data.data);
2809}
2810function isDataStrategyResults(result) {
return result != null && typeof result === "object" && Object.entries(result).every(([key, value]) => typeof key === "string" && isDataStrategyResult(value));
2812}
2813function isDataStrategyResult(result) {
return result != null && typeof result === "object" && "type" in result && "result" in result && (result.type === "data" || result.type === "error");
2815}
2816function isRedirectDataStrategyResult(result) {
return isResponse(result.result) && redirectStatusCodes.has(result.result.status);
2818}
2819function isErrorResult(result) {
return result.type === "error";
2821}
2822function isRedirectResult(result) {
return (result && result.type) === "redirect";
2824}
2825function isDataWithResponseInit(value) {
return typeof value === "object" && value != null && "type" in value && "data" in value && "init" in value && value.type === "DataWithResponseInit";
2827}
2828function isResponse(value) {
return value != null && typeof value.status === "number" && typeof value.statusText === "string" && typeof value.headers === "object" && typeof value.body !== "undefined";
2830}
2831function isRedirectStatusCode(statusCode) {
return redirectStatusCodes.has(statusCode);
2833}
2834function isRedirectResponse(result) {
return isResponse(result) && isRedirectStatusCode(result.status) && result.headers.has("Location");
2836}
2837function isValidMethod(method) {
return validRequestMethods.has(method.toUpperCase());
2839}
2840function isMutationMethod(method) {
return validMutationMethods.has(method.toUpperCase());
2842}
2843function hasNakedIndexQuery(search) {
return new URLSearchParams(search).getAll("index").some((v) => v === "");
2845}
2846function getTargetMatch(matches, location) {
let search = typeof location === "string" ? parsePath(location).search : location.search;
if (matches[matches.length - 1].route.index && hasNakedIndexQuery(search || "")) return matches[matches.length - 1];
let pathMatches = getPathContributingMatches(matches);
return pathMatches[pathMatches.length - 1];
2851}
2852function getInstrumentationNavigateMeta(history, location, matches) {
return {
url: createDataFunctionUrl(history.createURL(location), location),
pattern: matches ? getRoutePattern(matches) : "",
params: matches?.[0]?.params ? { ...matches[0].params } : {}
};
2858}
2859function getSubmissionFromNavigation(navigation) {
let { formMethod, formAction, formEncType, text, formData, json } = navigation;
if (!formMethod || !formAction || !formEncType) return;
if (text != null) return {
formMethod,
formAction,
formEncType,
formData: void 0,
json: void 0,
text
};
else if (formData != null) return {
formMethod,
formAction,
formEncType,
formData,
json: void 0,
text: void 0
};
else if (json !== void 0) return {
formMethod,
formAction,
formEncType,
formData: void 0,
json,
text: void 0
};
2886}
2887function getLoadingNavigation(location, matches, historyAction, submission) {
if (submission) return {
state: "loading",
location,
matches,
historyAction,
formMethod: submission.formMethod,
formAction: submission.formAction,
formEncType: submission.formEncType,
formData: submission.formData,
json: submission.json,
text: submission.text
};
else return {
state: "loading",
location,
matches,
historyAction,
formMethod: void 0,
formAction: void 0,
formEncType: void 0,
formData: void 0,
json: void 0,
text: void 0
};
2912}
2913function getSubmittingNavigation(location, matches, historyAction, submission) {
return {
state: "submitting",
location,
matches,
historyAction,
formMethod: submission.formMethod,
formAction: submission.formAction,
formEncType: submission.formEncType,
formData: submission.formData,
json: submission.json,
text: submission.text
};
2926}
2927function getLoadingFetcher(submission, data) {
if (submission) return {
state: "loading",
formMethod: submission.formMethod,
formAction: submission.formAction,
formEncType: submission.formEncType,
formData: submission.formData,
json: submission.json,
text: submission.text,
data
};
else return {
state: "loading",
formMethod: void 0,
formAction: void 0,
formEncType: void 0,
formData: void 0,
json: void 0,
text: void 0,
data
};
2948}
2949function getSubmittingFetcher(submission, existingFetcher) {
return {
state: "submitting",
formMethod: submission.formMethod,
formAction: submission.formAction,
formEncType: submission.formEncType,
formData: submission.formData,
json: submission.json,
text: submission.text,
data: existingFetcher ? existingFetcher.data : void 0
};
2960}
2961function getDoneFetcher(data) {
return {
state: "idle",
formMethod: void 0,
formAction: void 0,
formEncType: void 0,
formData: void 0,
json: void 0,
text: void 0,
data
};
2972}
2973function restoreAppliedTransitions(_window, transitions) {
try {
let sessionPositions = _window.sessionStorage.getItem(TRANSITIONS_STORAGE_KEY);
if (sessionPositions) {
	let json = JSON.parse(sessionPositions);
	for (let [k, v] of Object.entries(json || {})) if (v && Array.isArray(v)) transitions.set(k, new Set(v || []));
}
} catch {}
2981}
2982function persistAppliedTransitions(_window, transitions) {
if (transitions.size > 0) {
let json = {};
for (let [k, v] of transitions) json[k] = [...v];
try {
	_window.sessionStorage.setItem(TRANSITIONS_STORAGE_KEY, JSON.stringify(json));
} catch (error) {
	warning(false, `Failed to save applied view transitions in sessionStorage (${error}).`);
}
}
2992}
2993function createDeferred() {
let resolve;
let reject;
let promise = new Promise((res, rej) => {
resolve = async (val) => {
	res(val);
	try {
		await promise;
	} catch {}
};
reject = async (error) => {
	rej(error);
	try {
		await promise;
	} catch {}
};
});
return {
promise,
resolve,
reject
};
3015}
3016//#endregion
3017export { IDLE_BLOCKER, IDLE_FETCHER, IDLE_NAVIGATION, createDataRouteMatcher, createRouter, createStaticHandler, getStaticContextFromError, hasInvalidProtocol, isDataWithResponseInit, isMutationMethod, isRedirectResponse, isRedirectStatusCode, isResponse };
1	`/**`
2	`* react-router v8.4.0`
3	`*`
4	`* Copyright (c) Remix Software Inc.`
5	`*`
6	`* This source code is licensed under the MIT license found in the`
7	`* LICENSE.md file in the root directory of this source tree.`
8	`*`
9	`* @license MIT`
10	`*/`
11	`import { PROTOCOL_RELATIVE_URL_REGEX, normalizeProtocolRelativeUrl } from "./url.js";`
12	`import { createBrowserURLImpl, createLocation, createPath, invariant, parsePath, warning } from "./history.js";`
13	`import { ErrorResponseImpl, RouterContextProvider, convertRouteMatchToUiMatch, convertRoutesToDataRoutes, createDataFunctionUrl, getPathContributingMatches, getResolveToMatches, getRoutePattern, isAbsoluteUrl, isRouteErrorResponse, isUnsupportedLazyRouteFunctionKey, isUnsupportedLazyRouteObjectKey, prependBasename, removeDoubleSlashes, resolveTo, stripBasename } from "./utils.js";`
14	`import { consumeInstrumentationClientResultMetaReceiver, getRouteInstrumentationUpdates, instrumentClientSideRouter } from "./instrumentation.js";`
15	`import { V6RegExMatcher } from "./matcher.js";`
16	`import { getRoutePatternMatcher } from "./matcher-route-pattern.preload.js";`
17	`import { validateNavigationTarget } from "./navigation.js";`
18	`//#region lib/router/router.ts`
19	`const validMutationMethodsArr = [`
20	`"POST",`
21	`"PUT",`
22	`"PATCH",`
23	`"DELETE"`
24	`];`
25	`const validMutationMethods = new Set(validMutationMethodsArr);`
26	`const validRequestMethodsArr = ["GET", ...validMutationMethodsArr];`
27	`const validRequestMethods = new Set(validRequestMethodsArr);`
28	`const redirectStatusCodes = new Set([`
29	`301,`
30	`302,`
31	`303,`
32	`307,`
33	`308`
34	`]);`
35	`const redirectPreserveMethodStatusCodes = new Set([307, 308]);`
36	`const IDLE_NAVIGATION = {`
37	`state: "idle",`
38	`location: void 0,`
39	`matches: void 0,`
40	`historyAction: void 0,`