react-router 7.15.1 → 8.3.0

package/dist/development/lib/router/utils.js

@@ -0,0 +1,881 @@
+/**
+ * react-router v8.3.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 { ABSOLUTE_URL_REGEX, PROTOCOL_RELATIVE_URL_REGEX, normalizeProtocolRelativeUrl } from "./url.js";
+import { invariant, parsePath, warning } from "./history.js";
+import * as React$1 from "react";
+//#region lib/router/utils.ts
+/**
+* Creates a type-safe {@link RouterContext} object that can be used to
+* store and retrieve arbitrary values in [`action`](../../start/framework/route-module#action)s,
+* [`loader`](../../start/framework/route-module#loader)s, and [middleware](../../how-to/middleware).
+* Similar to React's [`createContext`](https://react.dev/reference/react/createContext),
+* but specifically designed for React Router's request/response lifecycle.
+*
+* If a `defaultValue` is provided, it will be returned from `context.get()`
+* when no value has been set for the context. Otherwise, reading this context
+* when no value has been set will throw an error.
+*
+* ```tsx filename=app/context.ts
+* import { createContext } from "react-router";
+*
+* // Create a context for user data
+* export const userContext =
+*   createContext<User | null>(null);
+* ```
+*
+* ```tsx filename=app/middleware/auth.ts
+* import { getUserFromSession } from "~/auth.server";
+* import { userContext } from "~/context";
+*
+* export const authMiddleware = async ({
+*   context,
+*   request,
+* }) => {
+*   const user = await getUserFromSession(request);
+*   context.set(userContext, user);
+* };
+* ```
+*
+* ```tsx filename=app/routes/profile.tsx
+* import { userContext } from "~/context";
+*
+* export async function loader({
+*   context,
+* }: Route.LoaderArgs) {
+*   const user = context.get(userContext);
+*
+*   if (!user) {
+*     throw new Response("Unauthorized", { status: 401 });
+*   }
+*
+*   return { user };
+* }
+* ```
+*
+* @public
+* @category Utils
+* @mode framework
+* @mode data
+* @param defaultValue An optional default value for the context. This value
+* will be returned if no value has been set for this context.
+* @returns A {@link RouterContext} object that can be used with
+* `context.get()` and `context.set()` in [`action`](../../start/framework/route-module#action)s,
+* [`loader`](../../start/framework/route-module#loader)s, and [middleware](../../how-to/middleware).
+*/
+function createContext(defaultValue) {
+	return { defaultValue };
+}
+/**
+* Provides methods for writing/reading values in application context in a
+* type-safe way. Primarily for usage with [middleware](../../how-to/middleware).
+*
+* @example
+* import {
+*   createContext,
+*   RouterContextProvider
+* } from "react-router";
+*
+* const userContext = createContext<User | null>(null);
+* const contextProvider = new RouterContextProvider();
+* contextProvider.set(userContext, getUser());
+* //                               ^ Type-safe
+* const user = contextProvider.get(userContext);
+* //    ^ User
+*
+* @public
+* @category Utils
+* @mode framework
+* @mode data
+*/
+var RouterContextProvider = class {
+	#map = /* @__PURE__ */ new Map();
+	/**
+	* Create a new `RouterContextProvider` instance
+	* @param init An optional initial context map to populate the provider with
+	*/
+	constructor(init) {
+		if (init) for (let [context, value] of init) this.set(context, value);
+	}
+	/**
+	* Access a value from the context. If no value has been set for the context,
+	* it will return the context's `defaultValue` if provided, or throw an error
+	* if no `defaultValue` was set.
+	* @param context The context to get the value for
+	* @returns The value for the context, or the context's `defaultValue` if no
+	* value was set
+	*/
+	get(context) {
+		if (this.#map.has(context)) return this.#map.get(context);
+		if (context.defaultValue !== void 0) return context.defaultValue;
+		throw new Error("No value found for context");
+	}
+	/**
+	* Set a value for the context. If the context already has a value set, this
+	* will overwrite it.
+	*
+	* @param context The context to set the value for
+	* @param value The value to set for the context
+	* @returns {void}
+	*/
+	set(context, value) {
+		this.#map.set(context, value);
+	}
+};
+const unsupportedLazyRouteObjectKeys = new Set([
+	"lazy",
+	"caseSensitive",
+	"path",
+	"id",
+	"index",
+	"children"
+]);
+function isUnsupportedLazyRouteObjectKey(key) {
+	return unsupportedLazyRouteObjectKeys.has(key);
+}
+const unsupportedLazyRouteFunctionKeys = new Set([
+	"lazy",
+	"caseSensitive",
+	"path",
+	"id",
+	"index",
+	"middleware",
+	"children"
+]);
+function isUnsupportedLazyRouteFunctionKey(key) {
+	return unsupportedLazyRouteFunctionKeys.has(key);
+}
+function isIndexRoute(route) {
+	return route.index === true;
+}
+function defaultMapRouteProperties(route) {
+	let updates = {};
+	if (route.Component) {
+		if (route.element) warning(false, "You should not include both `Component` and `element` on your route - `Component` will be used.");
+		Object.assign(updates, {
+			element: React$1.createElement(route.Component),
+			Component: void 0
+		});
+	}
+	if (route.HydrateFallback) {
+		if (route.hydrateFallbackElement) warning(false, "You should not include both `HydrateFallback` and `hydrateFallbackElement` on your route - `HydrateFallback` will be used.");
+		Object.assign(updates, {
+			hydrateFallbackElement: React$1.createElement(route.HydrateFallback),
+			HydrateFallback: void 0
+		});
+	}
+	if (route.ErrorBoundary) {
+		if (route.errorElement) warning(false, "You should not include both `ErrorBoundary` and `errorElement` on your route - `ErrorBoundary` will be used.");
+		Object.assign(updates, {
+			errorElement: React$1.createElement(route.ErrorBoundary),
+			ErrorBoundary: void 0
+		});
+	}
+	return updates;
+}
+function convertRoutesToDataRoutes(routes, mapRouteProperties = defaultMapRouteProperties, parentPath = [], manifest = {}, allowInPlaceMutations = false) {
+	return routes.map((route, index) => {
+		let treePath = [...parentPath, String(index)];
+		let id = typeof route.id === "string" ? route.id : treePath.join("-");
+		invariant(route.index !== true || !route.children, `Cannot specify children on an index route`);
+		invariant(allowInPlaceMutations || !manifest[id], `Found a route id collision on id "${id}".  Route id's must be globally unique within Data Router usages`);
+		if (isIndexRoute(route)) {
+			let indexRoute = {
+				...route,
+				id
+			};
+			manifest[id] = mergeRouteUpdates(indexRoute, mapRouteProperties(indexRoute));
+			return indexRoute;
+		} else {
+			let pathOrLayoutRoute = {
+				...route,
+				id,
+				children: void 0
+			};
+			manifest[id] = mergeRouteUpdates(pathOrLayoutRoute, mapRouteProperties(pathOrLayoutRoute));
+			if (route.children) pathOrLayoutRoute.children = convertRoutesToDataRoutes(route.children, mapRouteProperties, treePath, manifest, allowInPlaceMutations);
+			return pathOrLayoutRoute;
+		}
+	});
+}
+function mergeRouteUpdates(route, updates) {
+	return Object.assign(route, {
+		...updates,
+		...typeof updates.lazy === "object" && updates.lazy != null ? { lazy: {
+			...route.lazy,
+			...updates.lazy
+		} } : {}
+	});
+}
+/**
+* Matches the given routes to a location and returns the match data.
+*
+* @example
+* import { matchRoutes } from "react-router";
+*
+* let routes = [{
+*   path: "/",
+*   Component: Root,
+*   children: [{
+*     path: "dashboard",
+*     Component: Dashboard,
+*   }]
+* }];
+*
+* matchRoutes(routes, "/dashboard"); // [rootMatch, dashboardMatch]
+*
+* @public
+* @category Utils
+* @param routes The array of route objects to match against.
+* @param locationArg The location to match against, either a string path or a
+* partial {@link Location} object
+* @param basename Optional base path to strip from the location before matching.
+* Defaults to `/`.
+* @returns An array of matched routes, or `null` if no matches were found.
+*/
+function matchRoutes(routes, locationArg, basename = "/") {
+	return matchRoutesImpl(routes, locationArg, basename, false);
+}
+function matchRoutesImpl(routes, locationArg, basename, allowPartial, precomputedBranches) {
+	let pathname = stripBasename((typeof locationArg === "string" ? parsePath(locationArg) : locationArg).pathname || "/", basename);
+	if (pathname == null) return null;
+	let branches = precomputedBranches ?? flattenAndRankRoutes(routes);
+	let matches = null;
+	let decoded = decodePath(pathname);
+	for (let i = 0; matches == null && i < branches.length; ++i) matches = matchRouteBranch(branches[i], decoded, allowPartial);
+	return matches;
+}
+function convertRouteMatchToUiMatch(match, loaderData) {
+	let { route, pathname, params } = match;
+	return {
+		id: route.id,
+		pathname,
+		params,
+		loaderData: loaderData[route.id],
+		handle: route.handle
+	};
+}
+function flattenAndRankRoutes(routes) {
+	let branches = flattenRoutes(routes);
+	rankRouteBranches(branches);
+	return branches;
+}
+function flattenRoutes(routes, branches = [], parentsMeta = [], parentPath = "", _hasParentOptionalSegments = false) {
+	let flattenRoute = (route, index, hasParentOptionalSegments = _hasParentOptionalSegments, relativePath) => {
+		let meta = {
+			relativePath: relativePath === void 0 ? route.path || "" : relativePath,
+			caseSensitive: route.caseSensitive === true,
+			childrenIndex: index,
+			route
+		};
+		if (meta.relativePath.startsWith("/")) {
+			if (!meta.relativePath.startsWith(parentPath) && hasParentOptionalSegments) return;
+			invariant(meta.relativePath.startsWith(parentPath), `Absolute route path "${meta.relativePath}" nested under path "${parentPath}" is not valid. An absolute child route path must start with the combined path of all its parent routes.`);
+			meta.relativePath = meta.relativePath.slice(parentPath.length);
+		}
+		let path = joinPaths([parentPath, meta.relativePath]);
+		let routesMeta = parentsMeta.concat(meta);
+		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, hasParentOptionalSegments);
+		}
+		if (route.path == null && !route.index) return;
+		branches.push({
+			path,
+			score: computeScore(path, route.index),
+			routesMeta: routesMeta.map((meta, i) => {
+				let [matcher, params] = compilePath(meta.relativePath, meta.caseSensitive, i === routesMeta.length - 1);
+				return {
+					...meta,
+					matcher,
+					compiledParams: params
+				};
+			})
+		});
+	};
+	routes.forEach((route, index) => {
+		if (route.path === "" || !route.path?.includes("?")) flattenRoute(route, index);
+		else for (let exploded of explodeOptionalSegments(route.path)) flattenRoute(route, index, true, exploded);
+	});
+	return branches;
+}
+function explodeOptionalSegments(path) {
+	let segments = path.split("/");
+	if (segments.length === 0) return [];
+	let [first, ...rest] = segments;
+	let isOptional = first.endsWith("?");
+	let required = first.replace(/\?$/, "");
+	if (rest.length === 0) return isOptional ? [required, ""] : [required];
+	let restExploded = explodeOptionalSegments(rest.join("/"));
+	let result = [];
+	result.push(...restExploded.map((subpath) => subpath === "" ? required : [required, subpath].join("/")));
+	if (isOptional) result.push(...restExploded);
+	return result.map((exploded) => path.startsWith("/") && exploded === "" ? "/" : exploded);
+}
+function rankRouteBranches(branches) {
+	branches.sort((a, b) => a.score !== b.score ? b.score - a.score : compareIndexes(a.routesMeta.map((meta) => meta.childrenIndex), b.routesMeta.map((meta) => meta.childrenIndex)));
+}
+const paramRe = /^:[\w-]+$/;
+const partialParamRe = /^:[\w-]+/;
+const partialDynamicSegmentValue = 3.5;
+const dynamicSegmentValue = 3;
+const indexRouteValue = 2;
+const emptySegmentValue = 1;
+const staticSegmentValue = 10;
+const splatPenalty = -2;
+const isSplat = (s) => s === "*";
+function computeScore(path, index) {
+	let segments = path.split("/");
+	let initialScore = segments.length;
+	if (segments.some(isSplat)) initialScore += splatPenalty;
+	if (index) initialScore += indexRouteValue;
+	return segments.filter((s) => !isSplat(s)).reduce((score, segment) => score + (paramRe.test(segment) ? dynamicSegmentValue : partialParamRe.test(segment) ? partialDynamicSegmentValue : segment === "" ? emptySegmentValue : staticSegmentValue), initialScore);
+}
+function compareIndexes(a, b) {
+	return a.length === b.length && a.slice(0, -1).every((n, i) => n === b[i]) ? a[a.length - 1] - b[b.length - 1] : 0;
+}
+function matchRouteBranch(branch, pathname, allowPartial = false) {
+	let { routesMeta } = branch;
+	let matchedParams = {};
+	let matchedPathname = "/";
+	let matches = [];
+	for (let i = 0; i < routesMeta.length; ++i) {
+		let meta = routesMeta[i];
+		let end = i === routesMeta.length - 1;
+		let remainingPathname = matchedPathname === "/" ? pathname : pathname.slice(matchedPathname.length) || "/";
+		let pattern = {
+			path: meta.relativePath,
+			caseSensitive: meta.caseSensitive,
+			end
+		};
+		let match = meta.matcher && meta.compiledParams ? matchPathImpl(pattern, remainingPathname, meta.matcher, meta.compiledParams) : matchPath(pattern, remainingPathname);
+		let route = meta.route;
+		if (!match && end && allowPartial && !routesMeta[routesMeta.length - 1].route.index) match = matchPath({
+			path: meta.relativePath,
+			caseSensitive: meta.caseSensitive,
+			end: false
+		}, remainingPathname);
+		if (!match) return null;
+		Object.assign(matchedParams, match.params);
+		matches.push({
+			params: matchedParams,
+			pathname: joinPaths([matchedPathname, match.pathname]),
+			pathnameBase: normalizePathname(joinPaths([matchedPathname, match.pathnameBase])),
+			route
+		});
+		if (match.pathnameBase !== "/") matchedPathname = joinPaths([matchedPathname, match.pathnameBase]);
+	}
+	return matches;
+}
+/**
+* Characters that `encodeURIComponent` escapes but that are valid literally in
+* a URL path segment. Per RFC 3986 §3.3, a path segment is made of `pchar`:
+*
+* ```
+* pchar = unreserved / pct-encoded / sub-delims / ":" / "@"
+* sub-delims = "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "," / ";" / "="
+* ```
+*
+* `encodeURIComponent` targets query-string values, where `$ & + , ; = : @`
+* are delimiters and must be escaped — but in a path segment they carry no
+* special meaning, and browsers keep them literal in `location.pathname`.
+* (`! ' ( ) *` and the unreserved set are already left alone by
+* `encodeURIComponent`, so they need no restoring.)
+*/
+const PATH_PARAM_OVERESCAPED = {
+	"%24": "$",
+	"%26": "&",
+	"%2B": "+",
+	"%2C": ",",
+	"%3A": ":",
+	"%3B": ";",
+	"%3D": "=",
+	"%40": "@"
+};
+/**
+* Encodes a param value for interpolation into a single URL path segment.
+*
+* Escapes characters that would break the path (`/ ? # %`, whitespace,
+* non-ASCII, …) while leaving characters that RFC 3986 permits literally in a
+* path segment untouched. Escaping those would needlessly rewrite URLs — e.g.
+*  a semver build param `1.0.0+1` would become `1.0.0%2B1` even though browsers
+* display and match the `+` literally in `location.pathname`.
+*
+* See [RFC 3986 §3.3](https://datatracker.ietf.org/doc/html/rfc3986#section-3.3))
+*
+* @param value The param value to encode.
+* @returns The encoded value, safe for use as a single path segment.
+*/
+function encodePathParam(value) {
+	return encodeURIComponent(value).replace(/%(?:24|26|2B|2C|3A|3B|3D|40)/g, (match) => PATH_PARAM_OVERESCAPED[match]);
+}
+/**
+* Returns a path with params interpolated.
+*
+* Param values are percent-encoded for use in a path segment: characters that
+* would change the URL structure (`/`, `?`, `#`, `%`, whitespace, non-ASCII)
+* are escaped, while characters that RFC 3986 allows literally in a path
+* segment (`$ & + , ; = : @`) are kept as-is. Note this differs from query-string
+* encoding (`encodeURIComponent`/`URLSearchParams`), where those characters are
+* delimiters and must be escaped. Splat (`*`) values are encoded per segment,
+* preserving `/` separators.
+*
+* See [RFC 3986 §3.3](https://datatracker.ietf.org/doc/html/rfc3986#section-3.3)
+*
+* @example
+* import { generatePath } from "react-router";
+*
+* generatePath("/users/:id", { id: "123" }); // "/users/123"
+* generatePath("/files/:name", { name: "a b" }); // "/files/a%20b"
+* generatePath("/releases/:v", { v: "1.0.0+1" }); // "/releases/1.0.0+1"
+*
+* @public
+* @category Utils
+* @param originalPath The original path to generate.
+* @param params The parameters to interpolate into the path.
+* @returns The generated path with parameters interpolated.
+*/
+function generatePath(originalPath, params = {}) {
+	let path = originalPath;
+	if (path.endsWith("*") && path !== "*" && !path.endsWith("/*")) {
+		warning(false, `Route path "${path}" will be treated as if it were "${path.replace(/\*$/, "/*")}" because the \`*\` character must always follow a \`/\` in the pattern. To get rid of this warning, please change the route path to "${path.replace(/\*$/, "/*")}".`);
+		path = path.replace(/\*$/, "/*");
+	}
+	const prefix = path.startsWith("/") ? "/" : "";
+	const stringify = (p) => p == null ? "" : typeof p === "string" ? p : String(p);
+	return prefix + path.split(/\/+/).map((segment, index, array) => {
+		if (index === array.length - 1 && segment === "*") return stringify(params["*"]);
+		const keyMatch = segment.match(/^:([\w-]+)(\??)(.*)/);
+		if (keyMatch) {
+			const [, key, optional, suffix] = keyMatch;
+			let param = params[key];
+			invariant(optional === "?" || param != null, `Missing ":${key}" param`);
+			return encodePathParam(stringify(param)) + suffix;
+		}
+		return segment.replace(/\?$/g, "");
+	}).filter((segment) => !!segment).join("/");
+}
+/**
+* Performs pattern matching on a URL pathname and returns information about
+* the match.
+*
+* @public
+* @category Utils
+* @param pattern The pattern to match against the URL pathname. This can be a
+* string or a {@link PathPattern} object. If a string is provided, it will be
+* treated as a pattern with `caseSensitive` set to `false` and `end` set to
+* `true`.
+* @param pathname The URL pathname to match against the pattern.
+* @returns A path match object if the pattern matches the pathname,
+* or `null` if it does not match.
+*/
+function matchPath(pattern, pathname) {
+	if (typeof pattern === "string") pattern = {
+		path: pattern,
+		caseSensitive: false,
+		end: true
+	};
+	let [matcher, compiledParams] = compilePath(pattern.path, pattern.caseSensitive, pattern.end);
+	return matchPathImpl(pattern, pathname, matcher, compiledParams);
+}
+function matchPathImpl(pattern, pathname, matcher, compiledParams) {
+	let match = pathname.match(matcher);
+	if (!match) return null;
+	let matchedPathname = match[0];
+	let pathnameBase = matchedPathname.replace(/(.)\/+$/, "$1");
+	let captureGroups = match.slice(1);
+	return {
+		params: compiledParams.reduce((memo, { paramName, isOptional }, index) => {
+			if (paramName === "*") {
+				let splatValue = captureGroups[index] || "";
+				pathnameBase = matchedPathname.slice(0, matchedPathname.length - splatValue.length).replace(/(.)\/+$/, "$1");
+			}
+			const value = captureGroups[index];
+			if (isOptional && !value) memo[paramName] = void 0;
+			else memo[paramName] = (value || "").replace(/%2F/g, "/");
+			return memo;
+		}, {}),
+		pathname: matchedPathname,
+		pathnameBase,
+		pattern
+	};
+}
+function compilePath(path, caseSensitive = false, end = true) {
+	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(/\*$/, "/*")}".`);
+	let params = [];
+	let regexpSource = "^" + path.replace(/\/*\*?$/, "").replace(/^\/*/, "/").replace(/[\\.*+^${}|()[\]]/g, "\\$&").replace(/\/:([\w-]+)(\?)?/g, (match, paramName, isOptional, index, str) => {
+		params.push({
+			paramName,
+			isOptional: isOptional != null
+		});
+		if (isOptional) {
+			let nextChar = str.charAt(index + match.length);
+			if (nextChar && nextChar !== "/") return "/([^\\/]*)";
+			return "(?:/([^\\/]*))?";
+		}
+		return "/([^\\/]+)";
+	}).replace(/\/([\w-]+)\?(?=\/|$|\()/g, "(?:/$1)?");
+	if (path.endsWith("*")) {
+		params.push({ paramName: "*" });
+		regexpSource += path === "*" || path === "/*" ? "(.*)$" : "(?:\\/(.+)|\\/*)$";
+	} else if (end) regexpSource += "\\/*$";
+	else if (path !== "" && path !== "/") regexpSource += "(?:(?=\\/|$))";
+	return [new RegExp(regexpSource, caseSensitive ? void 0 : "i"), params];
+}
+function decodePath(value) {
+	try {
+		return value.split("/").map((v) => decodeURIComponent(v).replace(/\//g, "%2F")).join("/");
+	} catch (error) {
+		warning(false, `The URL path "${value}" could not be decoded because it is a malformed URL segment. This is probably due to a bad percent encoding (${error}).`);
+		return value;
+	}
+}
+function stripBasename(pathname, basename) {
+	if (basename === "/") return pathname;
+	if (!pathname.toLowerCase().startsWith(basename.toLowerCase())) return null;
+	let startIndex = basename.endsWith("/") ? basename.length - 1 : basename.length;
+	let nextChar = pathname.charAt(startIndex);
+	if (nextChar && nextChar !== "/") return null;
+	return pathname.slice(startIndex) || "/";
+}
+function prependBasename({ basename, pathname }) {
+	return pathname === "/" ? basename : joinPaths([basename, pathname]);
+}
+const isAbsoluteUrl = (url) => ABSOLUTE_URL_REGEX.test(url);
+/**
+* Returns a resolved {@link Path} object relative to the given pathname.
+*
+* @public
+* @category Utils
+* @param to The path to resolve, either a string or a partial {@link Path}
+* object.
+* @param fromPathname The pathname to resolve the path from. Defaults to `/`.
+* @returns A {@link Path} object with the resolved pathname, search, and hash.
+*/
+function resolvePath(to, fromPathname = "/") {
+	let { pathname: toPathname, search = "", hash = "" } = typeof to === "string" ? parsePath(to) : to;
+	let pathname;
+	if (toPathname) {
+		toPathname = removeDoubleSlashes(toPathname);
+		if (toPathname.startsWith("/")) pathname = resolvePathname(toPathname.substring(1), "/");
+		else pathname = resolvePathname(toPathname, fromPathname);
+	} else pathname = fromPathname;
+	return {
+		pathname,
+		search: normalizeSearch(search),
+		hash: normalizeHash(hash)
+	};
+}
+function resolvePathname(relativePath, fromPathname) {
+	let segments = removeTrailingSlash(fromPathname).split("/");
+	relativePath.split("/").forEach((segment) => {
+		if (segment === "..") {
+			if (segments.length > 1) segments.pop();
+		} else if (segment !== ".") segments.push(segment);
+	});
+	return segments.length > 1 ? segments.join("/") : "/";
+}
+function getInvalidPathError(char, field, dest, path) {
+	return `Cannot include a '${char}' character in a manually specified \`to.${field}\` field [${JSON.stringify(path)}].  Please separate it out to the \`to.${dest}\` field. Alternatively you may provide the full path as a string in <Link to="..."> and the router will parse it for you.`;
+}
+function getPathContributingMatches(matches) {
+	return matches.filter((match, index) => index === 0 || match.route.path && match.route.path.length > 0);
+}
+function getResolveToMatches(matches) {
+	let pathMatches = getPathContributingMatches(matches);
+	return pathMatches.map((match, idx) => idx === pathMatches.length - 1 ? match.pathname : match.pathnameBase);
+}
+function resolveTo(toArg, routePathnames, locationPathname, isPathRelative = false) {
+	let to;
+	if (typeof toArg === "string") to = parsePath(toArg);
+	else {
+		to = { ...toArg };
+		invariant(!to.pathname || !to.pathname.includes("?"), getInvalidPathError("?", "pathname", "search", to));
+		invariant(!to.pathname || !to.pathname.includes("#"), getInvalidPathError("#", "pathname", "hash", to));
+		invariant(!to.search || !to.search.includes("#"), getInvalidPathError("#", "search", "hash", to));
+	}
+	let isEmptyPath = toArg === "" || to.pathname === "";
+	let toPathname = isEmptyPath ? "/" : to.pathname;
+	let from;
+	if (toPathname == null) from = locationPathname;
+	else {
+		let routePathnameIndex = routePathnames.length - 1;
+		if (!isPathRelative && toPathname.startsWith("..")) {
+			let toSegments = toPathname.split("/");
+			while (toSegments[0] === "..") {
+				toSegments.shift();
+				routePathnameIndex -= 1;
+			}
+			to.pathname = toSegments.join("/");
+		}
+		from = routePathnameIndex >= 0 ? routePathnames[routePathnameIndex] : "/";
+	}
+	let path = resolvePath(to, from);
+	let hasExplicitTrailingSlash = toPathname && toPathname !== "/" && toPathname.endsWith("/");
+	let hasCurrentTrailingSlash = (isEmptyPath || toPathname === ".") && locationPathname.endsWith("/");
+	if (!path.pathname.endsWith("/") && (hasExplicitTrailingSlash || hasCurrentTrailingSlash)) path.pathname += "/";
+	return path;
+}
+const removeDoubleSlashes = (path) => path.replace(/[\\/]{2,}/g, "/");
+const joinPaths = (paths) => removeDoubleSlashes(paths.join("/"));
+const removeTrailingSlash = (path) => path.replace(/\/+$/, "");
+const normalizePathname = (pathname) => removeTrailingSlash(pathname).replace(/^\/*/, "/");
+const normalizeSearch = (search) => !search || search === "?" ? "" : search.startsWith("?") ? search : "?" + search;
+const normalizeHash = (hash) => !hash || hash === "#" ? "" : hash.startsWith("#") ? hash : "#" + hash;
+var DataWithResponseInit = class {
+	type = "DataWithResponseInit";
+	data;
+	init;
+	constructor(data, init) {
+		this.data = data;
+		this.init = init || null;
+	}
+};
+/**
+* Create "responses" that contain `headers`/`status` without forcing
+* serialization into an actual [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response)
+*
+* @example
+* import { data } from "react-router";
+*
+* export async function action({ request }: Route.ActionArgs) {
+*   let formData = await request.formData();
+*   let item = await createItem(formData);
+*   return data(item, {
+*     headers: { "X-Custom-Header": "value" }
+*     status: 201,
+*   });
+* }
+*
+* @public
+* @category Utils
+* @mode framework
+* @mode data
+* @param data The data to be included in the response.
+* @param init The status code or a `ResponseInit` object to be included in the
+* response.
+* @returns A {@link DataWithResponseInit} instance containing the data and
+* response init.
+*/
+function data(data, init) {
+	return new DataWithResponseInit(data, typeof init === "number" ? { status: init } : init);
+}
+/**
+* A redirect [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response).
+* Sets the status code and the [`Location`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Location)
+* header. Defaults to [`302 Found`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/302).
+*
+* This utility accepts absolute URLs and can navigate to external domains, so
+* the application should validate any user-supplied inputs to redirects.
+*
+* @example
+* import { redirect } from "react-router";
+*
+* export async function loader({ request }: Route.LoaderArgs) {
+*   if (!isLoggedIn(request))
+*     throw redirect("/login");
+*   }
+*
+*   // ...
+* }
+*
+* @public
+* @category Utils
+* @mode framework
+* @mode data
+* @param url The URL to redirect to.
+* @param init The status code or a `ResponseInit` object to be included in the
+* response.
+* @returns A [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response)
+* object with the redirect status and [`Location`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Location)
+* header.
+*/
+const redirect = (url, init = 302) => {
+	let responseInit = init;
+	if (typeof responseInit === "number") responseInit = { status: responseInit };
+	else if (typeof responseInit.status === "undefined") responseInit.status = 302;
+	let headers = new Headers(responseInit.headers);
+	headers.set("Location", url);
+	return new Response(null, {
+		...responseInit,
+		headers
+	});
+};
+/**
+* A redirect [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response)
+* that will force a document reload to the new location. Sets the status code
+* and the [`Location`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Location)
+* header. Defaults to [`302 Found`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/302).
+*
+* This utility accepts absolute URLs and can navigate to external domains, so
+* the application should validate any user-supplied inputs to redirects.
+*
+* ```tsx filename=routes/logout.tsx
+* import { redirectDocument } from "react-router";
+*
+* import { destroySession } from "../sessions.server";
+*
+* export async function action({ request }: Route.ActionArgs) {
+*   let session = await getSession(request.headers.get("Cookie"));
+*   return redirectDocument("/", {
+*     headers: { "Set-Cookie": await destroySession(session) }
+*   });
+* }
+* ```
+*
+* @public
+* @category Utils
+* @mode framework
+* @mode data
+* @param url The URL to redirect to.
+* @param init The status code or a `ResponseInit` object to be included in the
+* response.
+* @returns A [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response)
+* object with the redirect status and [`Location`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Location)
+* header.
+*/
+const redirectDocument = (url, init) => {
+	let response = redirect(url, init);
+	response.headers.set("X-Remix-Reload-Document", "true");
+	return response;
+};
+/**
+* A redirect [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response)
+* that will perform a [`history.replaceState`](https://developer.mozilla.org/en-US/docs/Web/API/History/replaceState)
+* instead of a [`history.pushState`](https://developer.mozilla.org/en-US/docs/Web/API/History/pushState)
+* for client-side navigation redirects. Sets the status code and the [`Location`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Location)
+* header. Defaults to [`302 Found`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/302).
+*
+* @example
+* import { replace } from "react-router";
+*
+* export async function loader() {
+*   return replace("/new-location");
+* }
+*
+* @public
+* @category Utils
+* @mode framework
+* @mode data
+* @param url The URL to redirect to.
+* @param init The status code or a `ResponseInit` object to be included in the
+* response.
+* @returns A [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response)
+* object with the redirect status and [`Location`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Location)
+* header.
+*/
+const replace = (url, init) => {
+	let response = redirect(url, init);
+	response.headers.set("X-Remix-Replace", "true");
+	return response;
+};
+const SUPPORTED_ERROR_TYPES = [
+	"EvalError",
+	"RangeError",
+	"ReferenceError",
+	"SyntaxError",
+	"TypeError",
+	"URIError"
+];
+var ErrorResponseImpl = class {
+	status;
+	statusText;
+	data;
+	error;
+	internal;
+	constructor(status, statusText, data, internal = false) {
+		this.status = status;
+		this.statusText = statusText || "";
+		this.internal = internal;
+		if (data instanceof Error) {
+			this.data = data.toString();
+			this.error = data;
+		} else this.data = data;
+	}
+};
+/**
+* Check if the given error is an {@link ErrorResponse} generated from a 4xx/5xx
+* [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response)
+* thrown from an [`action`](../../start/framework/route-module#action) or
+* [`loader`](../../start/framework/route-module#loader) function.
+*
+* @example
+* import { isRouteErrorResponse } from "react-router";
+*
+* export function ErrorBoundary({ error }: Route.ErrorBoundaryProps) {
+*   if (isRouteErrorResponse(error)) {
+*     return (
+*       <>
+*         <p>Error: `${error.status}: ${error.statusText}`</p>
+*         <p>{error.data}</p>
+*       </>
+*     );
+*   }
+*
+*   return (
+*     <p>Error: {error instanceof Error ? error.message : "Unknown Error"}</p>
+*   );
+* }
+*
+* @public
+* @category Utils
+* @mode framework
+* @mode data
+* @param error The error to check.
+* @returns `true` if the error is an {@link ErrorResponse}, `false` otherwise.
+*/
+function isRouteErrorResponse(error) {
+	return error != null && typeof error.status === "number" && typeof error.statusText === "string" && typeof error.internal === "boolean" && "data" in error;
+}
+function getRoutePattern(matches) {
+	return joinPaths(matches.map((m) => m.route.path).filter(Boolean)) || "/";
+}
+function createDataFunctionUrl(request, path) {
+	let url = new URL(typeof request === "string" || request instanceof URL ? request : request.url);
+	let parsed = typeof path === "string" ? parsePath(path) : path;
+	url.pathname = parsed.pathname || "/";
+	if (parsed.search) {
+		let searchParams = new URLSearchParams(parsed.search);
+		let indexValues = searchParams.getAll("index");
+		searchParams.delete("index");
+		for (let value of indexValues.filter(Boolean)) searchParams.append("index", value);
+		let search = searchParams.toString();
+		url.search = search ? `?${search}` : "";
+	} else url.search = "";
+	url.hash = parsed.hash || "";
+	return url;
+}
+const isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined";
+function parseToInfo(_to, basename) {
+	let to = _to;
+	if (typeof to !== "string" || !ABSOLUTE_URL_REGEX.test(to)) return {
+		absoluteURL: void 0,
+		isExternal: false,
+		to
+	};
+	let absoluteURL = to;
+	let isExternal = false;
+	if (isBrowser) try {
+		let currentUrl = new URL(window.location.href);
+		let targetUrl = PROTOCOL_RELATIVE_URL_REGEX.test(to) ? new URL(normalizeProtocolRelativeUrl(to, currentUrl.protocol)) : new URL(to);
+		let path = stripBasename(targetUrl.pathname, basename);
+		if (targetUrl.origin === currentUrl.origin && path != null) to = path + targetUrl.search + targetUrl.hash;
+		else isExternal = true;
+	} catch (e) {
+		warning(false, `<Link to="${to}"> contains an invalid URL which will probably break when clicked - please update to a valid URL path.`);
+	}
+	return {
+		absoluteURL,
+		isExternal,
+		to
+	};
+}
+//#endregion
+export { ErrorResponseImpl, RouterContextProvider, SUPPORTED_ERROR_TYPES, compilePath, convertRouteMatchToUiMatch, convertRoutesToDataRoutes, createContext, createDataFunctionUrl, data, decodePath, defaultMapRouteProperties, encodePathParam, flattenAndRankRoutes, generatePath, getPathContributingMatches, getResolveToMatches, getRoutePattern, isAbsoluteUrl, isBrowser, isRouteErrorResponse, isUnsupportedLazyRouteFunctionKey, isUnsupportedLazyRouteObjectKey, joinPaths, matchPath, matchRoutes, matchRoutesImpl, parseToInfo, prependBasename, redirect, redirectDocument, removeDoubleSlashes, removeTrailingSlash, replace, resolvePath, resolveTo, stripBasename };