react-router 8.3.0 → 8.4.0

package/dist/production/lib/hooks.js

@@ -1,5 +1,5 @@
 /**
- * react-router v8.3.0
+ * react-router v8.4.0
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -8,10 +8,11 @@
  *
  * @license MIT
  */
-import { invariant, parsePath, warning } from "./router/history.js";
+import { createPath, invariant, parsePath, warning } from "./router/history.js";
 import { convertRouteMatchToUiMatch, decodePath, getResolveToMatches, getRoutePattern, isBrowser, isRouteErrorResponse, joinPaths, matchPath, matchRoutes, parseToInfo, resolveTo, stripBasename } from "./router/utils.js";
+import { getNavigatorCurrentUrl, validateNavigationTarget } from "./router/navigation.js";
 import { IDLE_BLOCKER, hasInvalidProtocol } from "./router/router.js";
-import { AwaitContext, DataRouterContext, DataRouterStateContext, LocationContext, NavigationContext, RSCRouterContext, RouteContext, RouteErrorContext } from "./context.js";
+import { AwaitContext, DataRouterContext, DataRouterDataContext, DataRouterNavigationContext, DataRouterStateContext, FetchersContext, IsDataRouteContext, LocationContext, NavigationContext, RSCRouterContext, RouteContext, RouteErrorContext, RouteIdContext } from "./context.js";
 import { decodeRedirectErrorDigest, decodeRouteErrorResponseDigest } from "./errors.js";
 import * as React$1 from "react";
 //#region lib/hooks.tsx
@@ -268,8 +269,7 @@ const navigateEffectWarning = "You should call navigate() in a React.useEffect()
 * @returns A navigate function for programmatic navigation
 */
 function useNavigate() {
-	let { isDataRoute } = React$1.useContext(RouteContext);
-	return isDataRoute ? useNavigateStable() : useNavigateUnstable();
+	return React$1.useContext(IsDataRouteContext) ? useNavigateStable() : useNavigateUnstable();
 }
 function useNavigateUnstable() {
 	invariant(useInRouterContext(), `useNavigate() may be used only in the context of a <Router> component.`);
@@ -291,6 +291,7 @@ function useNavigateUnstable() {
 		}
 		let path = resolveTo(to, JSON.parse(routePathnamesJson), locationPathname, options.relative === "path");
 		if (dataRouterContext == null && basename !== "/") path.pathname = path.pathname === "/" ? basename : joinPaths([basename, path.pathname]);
+		validateNavigationTarget(typeof to === "string" ? to : createPath(to), navigator.createHref(path), getNavigatorCurrentUrl(navigator), "reject");
 		(!!options.replace ? navigator.replace : navigator.push)(path, options.state, options);
 	}, [
 		basename,
@@ -597,7 +598,10 @@ function useRoutesImpl(routes, locationArg, dataRouterOpts) {
 		let parentSegments = parentPathnameBase.replace(/^\//, "").split("/");
 		remainingPathname = "/" + pathname.replace(/^\//, "").split("/").slice(parentSegments.length).join("/");
 	}
-	let matches = dataRouterOpts && dataRouterOpts.state.matches.length ? dataRouterOpts.state.matches.map((m) => Object.assign(m, { route: dataRouterOpts.manifest[m.route.id] || m.route })) : matchRoutes(routes, { pathname: remainingPathname });
+	let matches;
+	if (dataRouterOpts) if (dataRouterOpts.state.matches.length) matches = dataRouterOpts.state.matches.map((m) => Object.assign(m, { route: dataRouterOpts.manifest[m.route.id] || m.route }));
+	else matches = dataRouterOpts.router.match(dataRouterOpts.state.location);
+	else matches = matchRoutes(routes, { pathname: remainingPathname });
 	let renderedMatches = _renderMatches(matches && matches.map((match) => Object.assign({}, match, {
 		params: Object.assign({}, parentParams, match.params),
 		pathname: joinPaths([parentPathnameBase, navigator.encodeLocation ? navigator.encodeLocation(match.pathname.replace(/%/g, "%25").replace(/\?/g, "%3F").replace(/#/g, "%23")).pathname : match.pathname]),
@@ -662,17 +666,17 @@ var RenderErrorBoundary = class extends React$1.Component {
 			const decoded = decodeRouteErrorResponseDigest(error.digest);
 			if (decoded) error = decoded;
 		}
-		let result = error !== void 0 ? /* @__PURE__ */ React$1.createElement(RouteContext.Provider, { value: this.props.routeContext }, /* @__PURE__ */ React$1.createElement(RouteErrorContext.Provider, {
+		let result = error !== void 0 ? /* @__PURE__ */ React$1.createElement(RouteContext.Provider, { value: this.props.routeContext }, /* @__PURE__ */ React$1.createElement(IsDataRouteContext.Provider, { value: this.props.routeContext.isDataRoute }, /* @__PURE__ */ React$1.createElement(RouteIdContext.Provider, { value: this.props.routeContext.matches[this.props.routeContext.matches.length - 1]?.route.id }, /* @__PURE__ */ React$1.createElement(RouteErrorContext.Provider, {
 			value: error,
 			children: this.props.component
-		})) : this.props.children;
+		})))) : this.props.children;
 		if (this.context) return /* @__PURE__ */ React$1.createElement(RSCErrorHandler, { error }, result);
 		return result;
 	}
 };
 const errorRedirectHandledMap = /* @__PURE__ */ new WeakMap();
 function RSCErrorHandler({ children, error }) {
-	let { basename } = React$1.useContext(NavigationContext);
+	let { basename, navigator } = React$1.useContext(NavigationContext);
 	if (typeof error === "object" && error && "digest" in error && typeof error.digest === "string") {
 		let redirect = decodeRedirectErrorDigest(error.digest);
 		if (redirect) {
@@ -680,6 +684,7 @@ function RSCErrorHandler({ children, error }) {
 			if (existingRedirect) throw existingRedirect;
 			let parsed = parseToInfo(redirect.location, basename);
 			let target = parsed.absoluteURL || parsed.to;
+			validateNavigationTarget(redirect.location, target, getNavigatorCurrentUrl(navigator), "allow-explicit");
 			if (hasInvalidProtocol(target)) throw new Error("Invalid redirect location");
 			if (isBrowser && !errorRedirectHandledMap.get(error)) if (parsed.isExternal || redirect.reloadDocument) window.location.href = target;
 			else {
@@ -698,7 +703,7 @@ function RSCErrorHandler({ children, error }) {
 function RenderedRoute({ routeContext, match, children }) {
 	let dataRouterContext = React$1.useContext(DataRouterContext);
 	if (dataRouterContext && dataRouterContext.static && dataRouterContext.staticContext && (match.route.errorElement || match.route.ErrorBoundary)) dataRouterContext.staticContext._deepestRenderedBoundaryId = match.route.id;
-	return /* @__PURE__ */ React$1.createElement(RouteContext.Provider, { value: routeContext }, children);
+	return /* @__PURE__ */ React$1.createElement(RouteContext.Provider, { value: routeContext }, /* @__PURE__ */ React$1.createElement(IsDataRouteContext.Provider, { value: routeContext.isDataRoute }, /* @__PURE__ */ React$1.createElement(RouteIdContext.Provider, { value: match.route.id }, children)));
 }
 function _renderMatches(matches, parentMatches = [], dataRouterOpts) {
 	let dataRouterState = dataRouterOpts?.state;
@@ -808,25 +813,25 @@ function useDataRouterState(hookName) {
 	invariant(state, getDataRouterConsoleError(hookName));
 	return state;
 }
-function useRouteContext(hookName) {
-	let route = React$1.useContext(RouteContext);
-	invariant(route, getDataRouterConsoleError(hookName));
-	return route;
+function useDataRouterFetchers(hookName) {
+	let fetchers = React$1.useContext(FetchersContext);
+	invariant(fetchers, getDataRouterConsoleError(hookName));
+	return fetchers;
 }
-function useCurrentRouteId(hookName) {
-	let route = useRouteContext(hookName);
-	let thisRoute = route.matches[route.matches.length - 1];
-	invariant(thisRoute.route.id, `${hookName} can only be used on routes that contain a unique "id"`);
-	return thisRoute.route.id;
+function useDataRouterData(hookName) {
+	let data = React$1.useContext(DataRouterDataContext);
+	invariant(data, getDataRouterConsoleError(hookName));
+	return data;
 }
-/**
-* Returns the ID for the nearest contextual route
-*
-* @category Hooks
-* @returns The ID of the nearest contextual route
-*/
-function useRouteId() {
-	return useCurrentRouteId("useRouteId");
+function useDataRouterNavigation(hookName) {
+	let navigation = React$1.useContext(DataRouterNavigationContext);
+	invariant(navigation, getDataRouterConsoleError(hookName));
+	return navigation;
+}
+function useCurrentRouteId(hookName) {
+	let routeId = React$1.useContext(RouteIdContext);
+	invariant(routeId, `${hookName} can only be used on routes that contain a unique "id"`);
+	return routeId;
 }
 /**
 * Returns the current {@link Navigation}, defaulting to an "idle" navigation
@@ -851,11 +856,11 @@ function useRouteId() {
 * @returns The current {@link Navigation} object
 */
 function useNavigation() {
-	let state = useDataRouterState("useNavigation");
+	let { navigation } = useDataRouterNavigation("useNavigation");
 	return React$1.useMemo(() => {
-		let { matches, historyAction, ...rest } = state.navigation;
+		let { matches, historyAction, ...rest } = navigation;
 		return rest;
-	}, [state.navigation]);
+	}, [navigation]);
 }
 /**
 * Revalidate the data on the page for reasons outside of normal data mutations
@@ -894,14 +899,14 @@ function useNavigation() {
 */
 function useRevalidator() {
 	let dataRouterContext = useDataRouterContext("useRevalidator");
-	let state = useDataRouterState("useRevalidator");
+	let { revalidation } = useDataRouterNavigation("useRevalidator");
 	let revalidate = React$1.useCallback(async () => {
 		await dataRouterContext.router.revalidate();
 	}, [dataRouterContext.router]);
 	return React$1.useMemo(() => ({
 		revalidate,
-		state: state.revalidation
-	}), [revalidate, state.revalidation]);
+		state: revalidation
+	}), [revalidate, revalidation]);
 }
 /**
 * Returns the active route matches, useful for accessing `loaderData` for
@@ -938,7 +943,8 @@ function useRevalidator() {
 * @returns An array of {@link UIMatch | UI matches} for the current route hierarchy
 */
 function useMatches() {
-	let { matches, loaderData } = useDataRouterState("useMatches");
+	let { matches } = useDataRouterState("useMatches");
+	let { loaderData } = useDataRouterData("useMatches");
 	return React$1.useMemo(() => matches.map((m) => convertRouteMatchToUiMatch(m, loaderData)), [matches, loaderData]);
 }
 /**
@@ -965,9 +971,9 @@ function useMatches() {
 * @returns The data returned from the route's [`loader`](../../start/framework/route-module#loader) or [`clientLoader`](../../start/framework/route-module#clientloader) function
 */
 function useLoaderData() {
-	let state = useDataRouterState("useLoaderData");
+	let data = useDataRouterData("useLoaderData");
 	let routeId = useCurrentRouteId("useLoaderData");
-	return state.loaderData[routeId];
+	return data.loaderData[routeId];
 }
 /**
 * Returns the [`loader`](../../start/framework/route-module#loader) data for a
@@ -1002,7 +1008,7 @@ function useLoaderData() {
 * function, or `undefined` if not found
 */
 function useRouteLoaderData(routeId) {
-	return useDataRouterState("useRouteLoaderData").loaderData[routeId];
+	return useDataRouterData("useRouteLoaderData").loaderData[routeId];
 }
 /**
 * Returns the [`action`](../../start/framework/route-module#action) data from
@@ -1037,9 +1043,9 @@ function useRouteLoaderData(routeId) {
 * has been called
 */
 function useActionData() {
-	let state = useDataRouterState("useActionData");
-	let routeId = useCurrentRouteId("useLoaderData");
-	return state.actionData ? state.actionData[routeId] : void 0;
+	let data = useDataRouterData("useActionData");
+	let routeId = useCurrentRouteId("useActionData");
+	return data.actionData ? data.actionData[routeId] : void 0;
 }
 /**
 * Accesses the error thrown during an
@@ -1063,10 +1069,10 @@ function useActionData() {
 */
 function useRouteError() {
 	let error = React$1.useContext(RouteErrorContext);
-	let state = useDataRouterState("useRouteError");
+	let data = useDataRouterData("useRouteError");
 	let routeId = useCurrentRouteId("useRouteError");
 	if (error !== void 0) return error;
-	return state.errors?.[routeId];
+	return data.errors?.[routeId];
 }
 /**
 * Returns the resolved promise value from the closest {@link Await | `<Await>`}.
@@ -1291,12 +1297,13 @@ function useRoute(...args) {
 	const currentRouteId = useCurrentRouteId("useRoute");
 	const id = args[0] ?? currentRouteId;
 	const state = useDataRouterState("useRoute");
+	const data = useDataRouterData("useRoute");
 	const route = state.matches.find(({ route }) => route.id === id);
 	if (route === void 0) return void 0;
 	return {
 		handle: route.route.handle,
-		loaderData: state.loaderData[id],
-		actionData: state.actionData?.[id]
+		loaderData: data.loaderData[id],
+		actionData: data.actionData?.[id]
 	};
 }
 function toRouterStateMatch(match) {
@@ -1350,7 +1357,8 @@ function toRouterStateMatch(match) {
 * @returns The current router state with `active` and `pending` variants
 */
 function useRouterState() {
-	let { location, historyAction: type, matches, navigation } = useDataRouterState("unstable_useRouterState");
+	let { location, historyAction: type, matches } = useDataRouterState("unstable_useRouterState");
+	let { navigation } = useDataRouterNavigation("unstable_useRouterState");
 	let active = React$1.useMemo(() => ({
 		type,
 		location,
@@ -1397,4 +1405,4 @@ function useRouterState() {
 	}), [active, pending]);
 }
 //#endregion
-export { _renderMatches, useActionData, useAsyncError, useAsyncValue, useBlocker, useHref, useInRouterContext, useLoaderData, useLocation, useMatch, useMatches, useNavigate, useNavigation, useNavigationType, useOutlet, useOutletContext, useParams, useResolvedPath, useRevalidator, useRoute, useRouteError, useRouteId, useRouteLoaderData, useRouterState, useRoutes, useRoutesImpl };
+export { _renderMatches, useActionData, useAsyncError, useAsyncValue, useBlocker, useCurrentRouteId, useDataRouterContext, useDataRouterData, useDataRouterFetchers, useDataRouterState, useHref, useInRouterContext, useLoaderData, useLocation, useMatch, useMatches, useNavigate, useNavigation, useNavigationType, useOutlet, useOutletContext, useParams, useResolvedPath, useRevalidator, useRoute, useRouteError, useRouteLoaderData, useRouterState, useRoutes, useRoutesImpl };

package/dist/production/lib/href.js

@@ -1,5 +1,5 @@
 /**
- * react-router v8.3.0
+ * react-router v8.4.0
  *
  * Copyright (c) Remix Software Inc.
  *

package/dist/production/lib/router/history.js

@@ -1,5 +1,5 @@
 /**
- * react-router v8.3.0
+ * react-router v8.4.0
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -193,7 +193,7 @@ function warning(cond, message) {
 		if (typeof console !== "undefined") console.warn(message);
 		try {
 			throw new Error(message);
-		} catch (e) {}
+		} catch {}
 	}
 }
 function createKey() {

package/dist/production/lib/router/instrumentation.js

@@ -1,5 +1,5 @@
 /**
- * react-router v8.3.0
+ * react-router v8.4.0
  *
  * Copyright (c) Remix Software Inc.
  *

package/dist/production/lib/router/matcher-route-pattern.d.ts

@@ -0,0 +1,2 @@
+
+export { };

package/dist/production/lib/router/matcher-route-pattern.js

@@ -0,0 +1,216 @@
+/**
+ * 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
+ */
+import { invariant, parsePath, warning } from "./history.js";
+import { decodePath, explodeOptionalSegments, joinPaths, matchPath, normalizePathname, stripBasename } from "./utils.js";
+import { createMultiMatcher } from "@remix-run/route-pattern/match";
+import { descending } from "@remix-run/route-pattern/specificity";
+//#region lib/router/matcher-route-pattern.ts
+var RoutePatternDataRouteMatcher = class {
+	#state;
+	#basename;
+	constructor(basename) {
+		this.#basename = basename;
+	}
+	update(routes) {
+		let branches = flattenRoutes(routes);
+		let matcher = createMultiMatcher({ ignoreCase: true });
+		let partialMatcher = createMultiMatcher({ ignoreCase: true });
+		for (let branch of branches) {
+			let routePattern = convertReactRouterPathToRoutePattern(branch.path);
+			validateRoutePatternSplat(branch.path, routePattern);
+			routePattern = addOptionalTrailingSlash(routePattern);
+			matcher.add(routePattern, branch);
+			if (!branch.routesMeta[branch.routesMeta.length - 1].route.index) partialMatcher.add(routePattern === "/" ? `/*__rr_partial` : `${routePattern}(/*__rr_partial)`, branch);
+		}
+		this.#state = {
+			branches,
+			matcher,
+			partialMatcher
+		};
+		return branches;
+	}
+	match(locationArg, allowPartial = false) {
+		let pathname = stripBasename((typeof locationArg === "string" ? parsePath(locationArg) : locationArg).pathname || "/", this.#basename);
+		if (pathname == null) return null;
+		let decoded = decodePath(pathname);
+		let url = new URL("http://reactrouter.local");
+		url.pathname = pathname.endsWith("/") ? pathname : `${pathname}/`;
+		invariant(this.#state, "Route pattern routes must be initialized before matching.");
+		let matches = this.#state.matcher.matchAll(url);
+		if (allowPartial) matches.push(...this.#state.partialMatcher.matchAll(url));
+		for (let match of prioritizeValidatedMatches(matches)) {
+			let routeMatches = convertRoutePatternMatchToRouteMatches(match, decoded, allowPartial);
+			if (routeMatches && validateRouteMatchParams(routeMatches)) return routeMatches;
+		}
+		return null;
+	}
+};
+function validateRoutePatternSplat(routePath, routePattern) {
+	invariant(getRoutePatternSplatIndexes(routePattern).length <= 1 && isTerminalRoutePatternSplat(routePattern), `Route path "${routePath}" is not supported with \`future.unstable_routePatternMatching\` because React Router only supports a single splat at the end of a route path.`);
+}
+function getRoutePatternSplatIndexes(routePattern) {
+	let splatIndexes = [];
+	for (let i = 0; i < routePattern.length; i++) {
+		let char = routePattern[i];
+		if (char === "\\") {
+			i++;
+			continue;
+		}
+		if (char === "*") splatIndexes.push(i);
+	}
+	return splatIndexes;
+}
+function isTerminalRoutePatternSplat(routePattern) {
+	for (let i = 0; i < routePattern.length; i++) {
+		let char = routePattern[i];
+		if (char === "\\") {
+			i++;
+			continue;
+		}
+		if (char !== "*") continue;
+		let suffix = routePattern.slice(i + 1);
+		return /^[a-zA-Z_$][a-zA-Z_$0-9]*$/.test(suffix) || suffix === "";
+	}
+	return true;
+}
+function addOptionalTrailingSlash(routePattern) {
+	return routePattern === "/" ? routePattern : `${routePattern.replace(/\/+$/, "")}(/)`;
+}
+function flattenRoutes(routes, branches = [], parentsMeta = [], parentPath = "") {
+	routes.forEach((route, index) => {
+		invariant(route.caseSensitive !== true, "`caseSensitive` routes are not supported with `future.unstable_routePatternMatching`.");
+		let meta = {
+			relativePath: route.path || "",
+			caseSensitive: false,
+			childrenIndex: index,
+			route
+		};
+		let absolutePath;
+		if (meta.relativePath.startsWith("/")) {
+			absolutePath = meta.relativePath;
+			let parentPathMatch = explodeOptionalSegments(parentPath).find((path) => meta.relativePath.startsWith(path));
+			invariant(parentPathMatch != null, `Absolute route path "${meta.relativePath}" nested under path "${parentPath}" is not valid. An absolute child route path must start with the combined path of all its parent routes.`);
+			meta.relativePath = meta.relativePath.slice(parentPathMatch.length);
+		}
+		let routesMeta = parentsMeta.concat(meta);
+		let path = absolutePath ?? (meta.relativePath ? joinPaths([parentPath, meta.relativePath]) : parentPath);
+		if (route.children && route.children.length > 0) {
+			invariant(route.index !== true, `Index routes must not have child routes. Please remove all child routes from route path "${path}".`);
+			flattenRoutes(route.children, branches, routesMeta, path);
+			if (route.children?.some((child) => child.index)) return;
+		}
+		if (route.path != null || route.index) branches.push({
+			path,
+			score: 0,
+			routesMeta
+		});
+	});
+	return branches;
+}
+function convertReactRouterPathToRoutePattern(path) {
+	warning(path === "*" || !path.endsWith("*") || path.endsWith("/*"), `Route path "${path}" will be treated as if it were "${path.replace(/\*$/, "/*")}" because the \`*\` character must always follow a \`/\` in the pattern. To get rid of this warning, please change the route path to "${path.replace(/\*$/, "/*")}".`);
+	if (path.endsWith("*") && path !== "*" && !path.endsWith("/*")) path = path.replace(/\*$/, "/*");
+	path = path.replace(/^\/*/, "/");
+	if (path === "") return "/";
+	let segments = path.split("/");
+	let pattern = segments.shift() || "";
+	for (let i = 0; i < segments.length;) {
+		let optionalRun = [];
+		while (i < segments.length && isOptionalRouteSegment(segments[i])) {
+			optionalRun.push(convertRouteSegment(segments[i].slice(0, -1)));
+			i++;
+		}
+		if (optionalRun.length > 0) {
+			let nested = optionalRun.reduceRight((child, segment) => `/${segment}${child ? `(${child})` : ""}`, "");
+			pattern += `(${nested})`;
+			continue;
+		}
+		pattern += `/${convertRouteSegment(segments[i])}`;
+		i++;
+	}
+	return pattern || "/";
+}
+function isOptionalRouteSegment(segment) {
+	return segment.endsWith("?");
+}
+function convertRouteSegment(segment) {
+	if (segment === "*") return "*__rr_splat";
+	let paramMatch = segment.match(/^:([\w-]+)(\?)?(.*)$/);
+	if (paramMatch) {
+		let [, paramName, optional, suffix] = paramMatch;
+		let converted = `:${paramName}${escapeRoutePatternLiteral(suffix)}`;
+		return optional ? `(:${paramName})${escapeRoutePatternLiteral(suffix)}` : converted;
+	}
+	return escapeRoutePatternLiteral(segment);
+}
+function escapeRoutePatternLiteral(value) {
+	return value.replace(/[\\():*]/g, "\\$&");
+}
+function validateRouteMatchParams(matches) {
+	return matches.every(({ route, params }) => route.unstable_validateParams == null || Object.keys(route.unstable_validateParams).length === 0 || Object.entries(route.unstable_validateParams).every(([param, re]) => params[param] != null ? new RegExp(re.source, re.flags).test(params[param]) : true));
+}
+function prioritizeValidatedMatches(matches) {
+	return matches.sort((a, b) => {
+		let specificity = descending(a, b);
+		if (specificity !== 0) return specificity;
+		return Number(hasParamValidators(b)) - Number(hasParamValidators(a));
+	});
+}
+function hasParamValidators(match) {
+	return match.data.routesMeta.some((meta) => meta.route.unstable_validateParams != null && Object.keys(meta.route.unstable_validateParams).length > 0);
+}
+function convertRoutePatternMatchToRouteMatches(match, pathname, allowPartial) {
+	let result = matchRoutePatternBranch(match.data, pathname, allowPartial, 0, "/", {});
+	if (result == null) return null;
+	for (let routeMatch of result.matches) routeMatch.params = result.params;
+	return result.matches;
+}
+function matchRoutePatternBranch(branch, pathname, allowPartial, metaIndex, matchedPathname, matchedParams) {
+	let meta = branch.routesMeta[metaIndex];
+	let end = metaIndex === branch.routesMeta.length - 1;
+	let remainingPathname = matchedPathname === "/" ? pathname : pathname.slice(matchedPathname.length) || "/";
+	for (let relativePath of explodeOptionalSegments(meta.relativePath)) {
+		let pattern = {
+			path: relativePath,
+			caseSensitive: false,
+			end
+		};
+		let pathMatch = matchPath(pattern, remainingPathname);
+		if (!pathMatch && end && allowPartial && !meta.route.index) pathMatch = matchPath({
+			...pattern,
+			end: false
+		}, remainingPathname);
+		if (!pathMatch) continue;
+		let params = {
+			...matchedParams,
+			...pathMatch.params
+		};
+		let routeMatch = {
+			params,
+			pathname: joinPaths([matchedPathname, pathMatch.pathname]),
+			pathnameBase: normalizePathname(joinPaths([matchedPathname, pathMatch.pathnameBase])),
+			route: meta.route
+		};
+		let nextMatchedPathname = pathMatch.pathnameBase === "/" ? matchedPathname : joinPaths([matchedPathname, pathMatch.pathnameBase]);
+		if (end) return {
+			matches: [routeMatch],
+			params
+		};
+		let childResult = matchRoutePatternBranch(branch, pathname, allowPartial, metaIndex + 1, nextMatchedPathname, params);
+		if (childResult) return {
+			matches: [routeMatch, ...childResult.matches],
+			params: childResult.params
+		};
+	}
+	return null;
+}
+//#endregion
+export { RoutePatternDataRouteMatcher };

package/dist/production/lib/router/matcher-route-pattern.preload.d.ts

@@ -0,0 +1,20 @@
+
+//#region lib/router/matcher-route-pattern.preload.d.ts
+/**
+ * Initialize the route-pattern matcher before creating a Data Router or static
+ * handler with `future.unstable_routePatternMatching` enabled. Import from
+ * `react-router/route-pattern` and call this once during application startup.
+ * Server and browser applications must each preload their own matcher.
+ *
+ * The matcher is statically imported by this module. Tree-shaking bundlers can
+ * remove it from applications that do not use this function. Initialization is
+ * synchronous, and repeated calls are safe.
+ *
+ * @public
+ * @category Data Routers
+ * @mode data
+ * @returns {void}
+ */
+declare function unstable_preloadRoutePattern(): void;
+//#endregion
+export { unstable_preloadRoutePattern };

package/dist/production/lib/router/matcher-route-pattern.preload.js

@@ -0,0 +1,36 @@
+/**
+ * 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
+ */
+import { RoutePatternDataRouteMatcher } from "./matcher-route-pattern.js";
+//#region lib/router/matcher-route-pattern.preload.ts
+let RoutePatternMatcher;
+function getRoutePatternMatcher() {
+	return RoutePatternMatcher;
+}
+/**
+* Initialize the route-pattern matcher before creating a Data Router or static
+* handler with `future.unstable_routePatternMatching` enabled. Import from
+* `react-router/route-pattern` and call this once during application startup.
+* Server and browser applications must each preload their own matcher.
+*
+* The matcher is statically imported by this module. Tree-shaking bundlers can
+* remove it from applications that do not use this function. Initialization is
+* synchronous, and repeated calls are safe.
+*
+* @public
+* @category Data Routers
+* @mode data
+* @returns {void}
+*/
+function unstable_preloadRoutePattern() {
+	RoutePatternMatcher = RoutePatternDataRouteMatcher;
+}
+//#endregion
+export { getRoutePatternMatcher, unstable_preloadRoutePattern };

package/dist/production/lib/router/matcher.d.ts

@@ -0,0 +1,2 @@
+
+export { };

package/dist/production/lib/router/matcher.js

@@ -0,0 +1,29 @@
+/**
+ * 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
+ */
+import { flattenAndRankRoutes, matchRoutesImpl } from "./utils.js";
+//#region lib/router/matcher.ts
+var V6RegExMatcher = class {
+	#routes = [];
+	#branches = [];
+	#basename;
+	constructor(basename) {
+		this.#basename = basename;
+	}
+	update(routes) {
+		this.#routes = routes;
+		this.#branches = flattenAndRankRoutes(routes);
+	}
+	match(locationArg, allowPartial = false) {
+		return matchRoutesImpl(this.#routes, locationArg, this.#basename, allowPartial, this.#branches);
+	}
+};
+//#endregion
+export { V6RegExMatcher };

package/dist/production/lib/router/navigation.js

@@ -0,0 +1,45 @@
+/**
+ * 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
+ */
+//#region lib/router/navigation.ts
+const DEFAULT_NAVIGATION_URL = new URL("http://localhost");
+function getNavigatorCurrentUrl(navigator) {
+	if (navigator.createURL) return navigator.createURL("/");
+	try {
+		return new URL(navigator.createHref("/"), DEFAULT_NAVIGATION_URL);
+	} catch {
+		return DEFAULT_NAVIGATION_URL;
+	}
+}
+function isSameOrigin(a, b) {
+	return a.origin === b.origin && (a.origin !== "null" || a.protocol === b.protocol && a.host === b.host);
+}
+function isExplicitUrl(destination, target) {
+	if (destination.startsWith("//")) return true;
+	let protocol = target.protocol.toLowerCase();
+	if (!destination.toLowerCase().startsWith(protocol)) return false;
+	return target.host === "" || destination.slice(protocol.length).startsWith("//");
+}
+function validateNavigationTarget(original, resolved, currentUrl, externalPolicy) {
+	let originalUrl = null;
+	try {
+		originalUrl = original == null ? null : new URL(original, currentUrl);
+	} catch {}
+	let resolvedUrl = new URL(resolved, currentUrl);
+	let originalIsExternal = originalUrl != null && !isSameOrigin(originalUrl, currentUrl);
+	let resolvedIsExternal = !isSameOrigin(resolvedUrl, currentUrl);
+	if (externalPolicy === "reject") {
+		if (originalIsExternal || resolvedIsExternal) throw new Error("External navigation is not allowed");
+	} else if (resolvedIsExternal) {
+		if (originalUrl == null || !isExplicitUrl(original, originalUrl) || !isSameOrigin(originalUrl, resolvedUrl)) throw new Error("External navigation is not allowed");
+	}
+}
+//#endregion
+export { getNavigatorCurrentUrl, validateNavigationTarget };