@octanejs/remix-router 0.1.0

package/src/lib/router/utils.ts

@@ -0,0 +1,2179 @@
+// Vendored from react-router@7.18.1 packages/react-router/lib/router/utils.ts — unmodified except: type-only react import → local ../react-types shim.
+// Re-vendor with `node scripts/vendor-remix-router.mjs`; never hand-edit.
+import type * as React from '../react-types';
+import type { MiddlewareEnabled } from '../types/future';
+import type { Equal, Expect } from '../types/utils';
+import type { Location, Path, To } from './history';
+import { invariant, parsePath, warning } from './history';
+import {
+	ABSOLUTE_URL_REGEX,
+	normalizeProtocolRelativeUrl,
+	PROTOCOL_RELATIVE_URL_REGEX,
+} from './url';
+
+export type MaybePromise<T> = T | Promise<T>;
+
+/**
+ * Map of routeId -> data returned from a loader/action/error
+ */
+export interface RouteData {
+	[routeId: string]: any;
+}
+
+export enum ResultType {
+	data = 'data',
+	redirect = 'redirect',
+	error = 'error',
+}
+
+/**
+ * Successful result from a loader or action
+ */
+export interface SuccessResult {
+	type: ResultType.data;
+	data: unknown;
+	statusCode?: number;
+	headers?: Headers;
+}
+
+/**
+ * Redirect result from a loader or action
+ */
+export interface RedirectResult {
+	type: ResultType.redirect;
+	// We keep the raw Response for redirects so we can return it verbatim
+	response: Response;
+}
+
+/**
+ * Unsuccessful result from a loader or action
+ */
+export interface ErrorResult {
+	type: ResultType.error;
+	error: unknown;
+	statusCode?: number;
+	headers?: Headers;
+}
+
+/**
+ * Result from a loader or action - potentially successful or unsuccessful
+ */
+export type DataResult = SuccessResult | RedirectResult | ErrorResult;
+
+export type LowerCaseFormMethod = 'get' | 'post' | 'put' | 'patch' | 'delete';
+export type UpperCaseFormMethod = Uppercase<LowerCaseFormMethod>;
+
+/**
+ * Users can specify either lowercase or uppercase form methods on `<Form>`,
+ * useSubmit(), `<fetcher.Form>`, etc.
+ */
+export type HTMLFormMethod = LowerCaseFormMethod | UpperCaseFormMethod;
+
+/**
+ * Active navigation/fetcher form methods are exposed in uppercase on the
+ * RouterState. This is to align with the normalization done via fetch().
+ */
+export type FormMethod = UpperCaseFormMethod;
+export type MutationFormMethod = Exclude<FormMethod, 'GET'>;
+
+export type FormEncType =
+	| 'application/x-www-form-urlencoded'
+	| 'multipart/form-data'
+	| 'application/json'
+	| 'text/plain';
+
+// Thanks https://github.com/sindresorhus/type-fest!
+type JsonObject = { [Key in string]: JsonValue } & {
+	[Key in string]?: JsonValue | undefined;
+};
+type JsonArray = JsonValue[] | readonly JsonValue[];
+type JsonPrimitive = string | number | boolean | null;
+type JsonValue = JsonPrimitive | JsonObject | JsonArray;
+
+/**
+ * @private
+ * Internal interface to pass around for action submissions, not intended for
+ * external consumption
+ */
+export type Submission =
+	| {
+			formMethod: FormMethod;
+			formAction: string;
+			formEncType: FormEncType;
+			formData: FormData;
+			json: undefined;
+			text: undefined;
+	  }
+	| {
+			formMethod: FormMethod;
+			formAction: string;
+			formEncType: FormEncType;
+			formData: undefined;
+			json: JsonValue;
+			text: undefined;
+	  }
+	| {
+			formMethod: FormMethod;
+			formAction: string;
+			formEncType: FormEncType;
+			formData: undefined;
+			json: undefined;
+			text: string;
+	  };
+
+/**
+ * A context instance used as the key for the `get`/`set` methods of a
+ * {@link RouterContextProvider}. Accepts an optional default
+ * value to be returned if no value has been set.
+ */
+export interface RouterContext<T = unknown> {
+	defaultValue?: T;
+}
+
+/**
+ * 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).
+ */
+export function createContext<T>(defaultValue?: T): RouterContext<T> {
+	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
+ */
+export class RouterContextProvider {
+	#map = new Map<RouterContext, unknown>();
+
+	/**
+	 * Create a new `RouterContextProvider` instance
+	 * @param init An optional initial context map to populate the provider with
+	 */
+	constructor(init?: Map<RouterContext, unknown>) {
+		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<T>(context: RouterContext<T>): T {
+		if (this.#map.has(context)) {
+			return this.#map.get(context) as T;
+		}
+
+		if (context.defaultValue !== undefined) {
+			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<C extends RouterContext>(
+		context: C,
+		value: C extends RouterContext<infer T> ? T : never,
+	): void {
+		this.#map.set(context, value);
+	}
+}
+
+type DefaultContext = MiddlewareEnabled extends true ? Readonly<RouterContextProvider> : any;
+
+/**
+ * @private
+ * Arguments passed to route loader/action functions.  Same for now but we keep
+ * this as a private implementation detail in case they diverge in the future.
+ */
+interface DataFunctionArgs<Context> {
+	/** A {@link https://developer.mozilla.org/en-US/docs/Web/API/Request Fetch Request instance} which you can use to read headers (like cookies, and {@link https://developer.mozilla.org/en-US/docs/Web/API/URLSearchParams URLSearchParams} from the request. */
+	request: Request;
+	/**
+	 * A URL instance representing the application location being navigated to or
+	 * fetched. By default, this matches `request.url`.
+	 *
+	 * In Framework mode with `future.v8_passThroughRequests` enabled, this is a
+	 * normalized URL with React-Router-specific implementation details removed
+	 * (`.data` suffixes, `index`/`_routes` search params).
+	 */
+	url: URL;
+	/**
+	 * Matched un-interpolated route pattern for the current path (i.e., /blog/:slug).
+	 * Mostly useful as a identifier to aggregate on for logging/tracing/etc.
+	 */
+	pattern: string;
+	/**
+	 * {@link https://reactrouter.com/start/framework/routing#dynamic-segments Dynamic route params} for the current route.
+	 * @example
+	 * // app/routes.ts
+	 * route("teams/:teamId", "./team.tsx"),
+	 *
+	 * // app/team.tsx
+	 * export function loader({
+	 *   params,
+	 * }: Route.LoaderArgs) {
+	 *   params.teamId;
+	 *   //        ^ string
+	 * }
+	 */
+	params: Params;
+	/**
+	 * This is the context passed in to your server adapter's getLoadContext() function.
+	 * It's a way to bridge the gap between the adapter's request/response API with your React Router app.
+	 * It is only applicable if you are using a custom server adapter.
+	 */
+	context: Context;
+}
+
+/**
+ * Route middleware `next` function to call downstream handlers and then complete
+ * middlewares from the bottom-up
+ */
+export interface MiddlewareNextFunction<Result = unknown> {
+	(): Promise<Result>;
+}
+
+/**
+ * Route middleware function signature.  Receives the same "data" arguments as a
+ * `loader`/`action` (`request`, `params`, `context`) as the first parameter and
+ * a `next` function as the second parameter which will call downstream handlers
+ * and then complete middlewares from the bottom-up
+ */
+export type MiddlewareFunction<Result = unknown> = (
+	args: DataFunctionArgs<Readonly<RouterContextProvider>>,
+	next: MiddlewareNextFunction<Result>,
+) => MaybePromise<Result | void>;
+
+/**
+ * Arguments passed to loader functions
+ */
+export interface LoaderFunctionArgs<Context = DefaultContext> extends DataFunctionArgs<Context> {}
+
+/**
+ * Arguments passed to action functions
+ */
+export interface ActionFunctionArgs<Context = DefaultContext> extends DataFunctionArgs<Context> {}
+
+/**
+ * Loaders and actions can return anything
+ */
+type DataFunctionValue = unknown;
+
+type DataFunctionReturnValue = MaybePromise<DataFunctionValue>;
+
+/**
+ * Route loader function signature
+ */
+export type LoaderFunction<Context = DefaultContext> = {
+	(args: LoaderFunctionArgs<Context>, handlerCtx?: unknown): DataFunctionReturnValue;
+} & { hydrate?: boolean };
+
+/**
+ * Route action function signature
+ */
+export interface ActionFunction<Context = DefaultContext> {
+	(args: ActionFunctionArgs<Context>, handlerCtx?: unknown): DataFunctionReturnValue;
+}
+
+/**
+ * Arguments passed to shouldRevalidate function
+ */
+export interface ShouldRevalidateFunctionArgs {
+	/** This is the url the navigation started from. You can compare it with `nextUrl` to decide if you need to revalidate this route's data. */
+	currentUrl: URL;
+	/** These are the {@link https://reactrouter.com/start/framework/routing#dynamic-segments dynamic route params} from the URL that can be compared to the `nextParams` to decide if you need to reload or not. Perhaps you're using only a partial piece of the param for data loading, you don't need to revalidate if a superfluous part of the param changed. */
+	currentParams: DataRouteMatch['params'];
+	/** In the case of navigation, this the URL the user is requesting. Some revalidations are not navigation, so it will simply be the same as currentUrl. */
+	nextUrl: URL;
+	/** In the case of navigation, these are the {@link https://reactrouter.com/start/framework/routing#dynamic-segments dynamic route params}  from the next location the user is requesting. Some revalidations are not navigation, so it will simply be the same as currentParams. */
+	nextParams: DataRouteMatch['params'];
+	/** The method (probably `"GET"` or `"POST"`) used in the form submission that triggered the revalidation. */
+	formMethod?: Submission['formMethod'];
+	/** The form action (`<Form action="/somewhere">`) that triggered the revalidation. */
+	formAction?: Submission['formAction'];
+	/** The form encType (`<Form encType="application/x-www-form-urlencoded">) used in the form submission that triggered the revalidation*/
+	formEncType?: Submission['formEncType'];
+	/** The form submission data when the form's encType is `text/plain` */
+	text?: Submission['text'];
+	/** The form submission data when the form's encType is `application/x-www-form-urlencoded` or `multipart/form-data` */
+	formData?: Submission['formData'];
+	/** The form submission data when the form's encType is `application/json` */
+	json?: Submission['json'];
+	/** The status code of the action response */
+	actionStatus?: number;
+	/**
+	 * When a submission causes the revalidation this will be the result of the action—either action data or an error if the action failed. It's common to include some information in the action result to instruct shouldRevalidate to revalidate or not.
+	 *
+	 * @example
+	 * export async function action() {
+	 *   await saveSomeStuff();
+	 *   return { ok: true };
+	 * }
+	 *
+	 * export function shouldRevalidate({
+	 *   actionResult,
+	 * }) {
+	 *   if (actionResult?.ok) {
+	 *     return false;
+	 *   }
+	 *   return true;
+	 * }
+	 */
+	actionResult?: any;
+	/**
+	 * By default, React Router doesn't call every loader all the time. There are reliable optimizations it can make by default. For example, only loaders with changing params are called. Consider navigating from the following URL to the one below it:
+	 *
+	 * /projects/123/tasks/abc
+	 * /projects/123/tasks/def
+	 * React Router will only call the loader for tasks/def because the param for projects/123 didn't change.
+	 *
+	 * It's safest to always return defaultShouldRevalidate after you've done your specific optimizations that return false, otherwise your UI might get out of sync with your data on the server.
+	 */
+	defaultShouldRevalidate: boolean;
+}
+
+/**
+ * Route shouldRevalidate function signature.  This runs after any submission
+ * (navigation or fetcher), so we flatten the navigation/fetcher submission
+ * onto the arguments.  It shouldn't matter whether it came from a navigation
+ * or a fetcher, what really matters is the URLs and the formData since loaders
+ * have to re-run based on the data models that were potentially mutated.
+ */
+export interface ShouldRevalidateFunction {
+	(args: ShouldRevalidateFunctionArgs): boolean;
+}
+
+export interface DataStrategyMatch extends RouteMatch<string, DataRouteObject> {
+	/**
+	 * @private
+	 */
+	_lazyPromises?: {
+		middleware: Promise<void> | undefined;
+		handler: Promise<void> | undefined;
+		route: Promise<void> | undefined;
+	};
+	/**
+	 * @deprecated Deprecated in favor of `shouldCallHandler`
+	 *
+	 * A boolean value indicating whether this route handler should be called in
+	 * this pass.
+	 *
+	 * The `matches` array always includes _all_ matched routes even when only
+	 * _some_ route handlers need to be called so that things like middleware can
+	 * be implemented.
+	 *
+	 * `shouldLoad` is usually only interesting if you are skipping the route
+	 * handler entirely and implementing custom handler logic - since it lets you
+	 * determine if that custom logic should run for this route or not.
+	 *
+	 * For example:
+	 *  - If you are on `/parent/child/a` and you navigate to `/parent/child/b` -
+	 *    you'll get an array of three matches (`[parent, child, b]`), but only `b`
+	 *    will have `shouldLoad=true` because the data for `parent` and `child` is
+	 *    already loaded
+	 *  - If you are on `/parent/child/a` and you submit to `a`'s [`action`](https://reactrouter.com/docs/start/data/route-object#action),
+	 *    then only `a` will have `shouldLoad=true` for the action execution of
+	 *    `dataStrategy`
+	 *  - After the [`action`](https://reactrouter.com/docs/start/data/route-object#action),
+	 *    `dataStrategy` will be called again for the [`loader`](https://reactrouter.com/docs/start/data/route-object#loader)
+	 *    revalidation, and all matches will have `shouldLoad=true` (assuming no
+	 *    custom `shouldRevalidate` implementations)
+	 */
+	shouldLoad: boolean;
+	/**
+	 * Arguments passed to the `shouldRevalidate` function for this `loader` execution.
+	 * Will be `null` if this is not a revalidating loader {@link DataStrategyMatch}.
+	 */
+	shouldRevalidateArgs: ShouldRevalidateFunctionArgs | null;
+	/**
+	 * Determine if this route's handler should be called during this `dataStrategy`
+	 * execution. Calling it with no arguments will leverage the default revalidation
+	 * behavior. You can pass your own `defaultShouldRevalidate` value if you wish
+	 * to change the default revalidation behavior with your `dataStrategy`.
+	 *
+	 * @param defaultShouldRevalidate `defaultShouldRevalidate` override value (optional)
+	 */
+	shouldCallHandler(defaultShouldRevalidate?: boolean): boolean;
+	/**
+	 * An async function that will resolve any `route.lazy` implementations and
+	 * execute the route's handler (if necessary), returning a {@link DataStrategyResult}
+	 *
+	 * - Calling `match.resolve` does not mean you're calling the
+	 *   [`action`](https://reactrouter.com/docs/start/data/route-object#action)/[`loader`](https://reactrouter.com/docs/start/data/route-object#loader)
+	 *   (the "handler") - `resolve` will only call the `handler` internally if
+	 *   needed _and_ if you don't pass your own `handlerOverride` function parameter
+	 * - It is safe to call `match.resolve` for all matches, even if they have
+	 *   `shouldLoad=false`, and it will no-op if no loading is required
+	 * - You should generally always call `match.resolve()` for `shouldLoad:true`
+	 *   routes to ensure that any `route.lazy` implementations are processed
+	 * - See the examples below for how to implement custom handler execution via
+	 *   `match.resolve`
+	 */
+	resolve: (
+		handlerOverride?: (
+			handler: (ctx?: unknown) => DataFunctionReturnValue,
+		) => DataFunctionReturnValue,
+	) => Promise<DataStrategyResult>;
+}
+
+export interface DataStrategyFunctionArgs<
+	Context = DefaultContext,
+> extends DataFunctionArgs<Context> {
+	/**
+	 * Matches for this route extended with Data strategy APIs
+	 */
+	matches: DataStrategyMatch[];
+	runClientMiddleware: (
+		cb: DataStrategyFunction<Context>,
+	) => Promise<Record<string, DataStrategyResult>>;
+	/**
+	 * The key of the fetcher we are calling `dataStrategy` for, otherwise `null`
+	 * for navigational executions
+	 */
+	fetcherKey: string | null;
+}
+
+/**
+ * Result from a loader or action called via dataStrategy
+ */
+export interface DataStrategyResult {
+	type: 'data' | 'error';
+	result: unknown; // data, Error, Response, DeferredData, DataWithResponseInit
+}
+
+export interface DataStrategyFunction<Context = DefaultContext> {
+	(args: DataStrategyFunctionArgs<Context>): Promise<Record<string, DataStrategyResult>>;
+}
+
+export type PatchRoutesOnNavigationFunctionArgs = {
+	signal: AbortSignal;
+	path: string;
+	matches: RouteMatch[];
+	fetcherKey: string | undefined;
+	patch: (routeId: string | null, children: RouteObject[]) => void;
+};
+
+export type PatchRoutesOnNavigationFunction = (
+	opts: PatchRoutesOnNavigationFunctionArgs,
+) => MaybePromise<void>;
+
+/**
+ * Function provided to set route-specific properties from route objects
+ */
+export interface MapRoutePropertiesFunction {
+	(route: DataRouteObject): {
+		hasErrorBoundary: boolean;
+	} & Record<string, any>;
+}
+
+/**
+ * Keys we cannot change from within a lazy object. We spread all other keys
+ * onto the route. Either they're meaningful to the router, or they'll get
+ * ignored.
+ */
+type UnsupportedLazyRouteObjectKey =
+	| 'lazy'
+	| 'caseSensitive'
+	| 'path'
+	| 'id'
+	| 'index'
+	| 'children';
+const unsupportedLazyRouteObjectKeys = new Set<UnsupportedLazyRouteObjectKey>([
+	'lazy',
+	'caseSensitive',
+	'path',
+	'id',
+	'index',
+	'children',
+]);
+export function isUnsupportedLazyRouteObjectKey(key: string): key is UnsupportedLazyRouteObjectKey {
+	return unsupportedLazyRouteObjectKeys.has(key as UnsupportedLazyRouteObjectKey);
+}
+
+/**
+ * Keys we cannot change from within a lazy() function. We spread all other keys
+ * onto the route. Either they're meaningful to the router, or they'll get
+ * ignored.
+ */
+type UnsupportedLazyRouteFunctionKey = UnsupportedLazyRouteObjectKey | 'middleware';
+const unsupportedLazyRouteFunctionKeys = new Set<UnsupportedLazyRouteFunctionKey>([
+	'lazy',
+	'caseSensitive',
+	'path',
+	'id',
+	'index',
+	'middleware',
+	'children',
+]);
+export function isUnsupportedLazyRouteFunctionKey(
+	key: string,
+): key is UnsupportedLazyRouteFunctionKey {
+	return unsupportedLazyRouteFunctionKeys.has(key as UnsupportedLazyRouteFunctionKey);
+}
+
+/**
+ * lazy object to load route properties, which can add non-matching
+ * related properties to a route
+ */
+export type LazyRouteObject<R extends RouteObject> = {
+	[K in keyof R as K extends UnsupportedLazyRouteObjectKey ? never : K]?: () => Promise<
+		R[K] | null | undefined
+	>;
+};
+
+/**
+ * lazy() function to load a route definition, which can add non-matching
+ * related properties to a route
+ */
+export interface LazyRouteFunction<R extends RouteObject> {
+	(): Promise<
+		Omit<R, UnsupportedLazyRouteFunctionKey> &
+			Partial<Record<UnsupportedLazyRouteFunctionKey, never>>
+	>;
+}
+
+export type LazyRouteDefinition<R extends RouteObject> = LazyRouteObject<R> | LazyRouteFunction<R>;
+
+/**
+ * Base RouteObject with common props shared by all types of routes
+ * @internal
+ */
+export type BaseRouteObject = {
+	/**
+	 * Whether the path should be case-sensitive. Defaults to `false`.
+	 */
+	caseSensitive?: boolean;
+	/**
+	 * The path pattern to match. If unspecified or empty, then this becomes a
+	 * layout route.
+	 */
+	path?: string;
+	/**
+	 * The unique identifier for this route (for use with {@link DataRouter}s)
+	 */
+	id?: string;
+	/**
+	 * The route middleware.
+	 * See [`middleware`](../../start/data/route-object#middleware).
+	 */
+	middleware?: MiddlewareFunction[];
+	/**
+	 * The route loader.
+	 * See [`loader`](../../start/data/route-object#loader).
+	 */
+	loader?: LoaderFunction | boolean;
+	/**
+	 * The route action.
+	 * See [`action`](../../start/data/route-object#action).
+	 */
+	action?: ActionFunction | boolean;
+	// TODO(v8): deprecate/remove
+	hasErrorBoundary?: boolean;
+	/**
+	 * The route shouldRevalidate function.
+	 * See [`shouldRevalidate`](../../start/data/route-object#shouldRevalidate).
+	 */
+	shouldRevalidate?: ShouldRevalidateFunction;
+	/**
+	 * The route handle.
+	 */
+	handle?: any;
+	/**
+	 * A function that returns a promise that resolves to the route object.
+	 * Used for code-splitting routes.
+	 * See [`lazy`](../../start/data/route-object#lazy).
+	 */
+	lazy?: LazyRouteDefinition<BaseRouteObject>;
+	/**
+	 * The React Component to render when this route matches.
+	 * Mutually exclusive with `element`.
+	 */
+	Component?: React.ComponentType | null;
+	/**
+	 * The React element to render when this Route matches.
+	 * Mutually exclusive with `Component`.
+	 */
+	element?: React.ReactNode | null;
+	/**
+	 * The React Component to render at this route if an error occurs.
+	 * Mutually exclusive with `errorElement`.
+	 */
+	ErrorBoundary?: React.ComponentType | null;
+	/**
+	 * The React element to render at this route if an error occurs.
+	 * Mutually exclusive with `ErrorBoundary`.
+	 */
+	errorElement?: React.ReactNode | null;
+	/**
+	 * The React Component to render while this router is loading data.
+	 * Mutually exclusive with `hydrateFallbackElement`.
+	 */
+	HydrateFallback?: React.ComponentType | null;
+	/**
+	 * The React element to render while this router is loading data.
+	 * Mutually exclusive with `HydrateFallback`.
+	 */
+	hydrateFallbackElement?: React.ReactNode | null;
+};
+
+/**
+ * Index routes must not have children
+ */
+export type IndexRouteObject = BaseRouteObject & {
+	/**
+	 * Child Route objects - not valid on index routes.
+	 */
+	children?: undefined;
+	/**
+	 * Whether this is an index route.
+	 */
+	index: true;
+};
+
+/**
+ * Non-index routes may have children, but cannot have `index` set to `true`.
+ */
+export type NonIndexRouteObject = BaseRouteObject & {
+	/**
+	 * Child Route objects.
+	 */
+	children?: RouteObject[];
+	/**
+	 * Whether this is an index route - must be `false` or undefined on non-index routes.
+	 */
+	index?: false;
+};
+
+/**
+ * A route object represents a logical route, with (optionally) its child
+ * routes organized in a tree-like structure.
+ */
+export type RouteObject = IndexRouteObject | NonIndexRouteObject;
+
+export type DataIndexRouteObject = IndexRouteObject & {
+	id: string;
+};
+
+export type DataNonIndexRouteObject = NonIndexRouteObject & {
+	children?: DataRouteObject[];
+	id: string;
+};
+
+/**
+ * A data route object, which is just a RouteObject with a required unique ID
+ */
+export type DataRouteObject = DataIndexRouteObject | DataNonIndexRouteObject;
+
+export type RouteManifest<R = DataRouteObject> = Record<string, R | undefined>;
+
+// prettier-ignore
+type Regex_az = "a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" | "j" | "k" | "l" | "m" | "n" | "o" | "p" | "q" | "r" | "s" | "t" | "u" | "v" | "w" | "x" | "y" | "z"
+type Regex_AZ = Uppercase<Regex_az>;
+type Regex_09 = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9';
+type Regex_w = Regex_az | Regex_AZ | Regex_09 | '_';
+
+// prettier-ignore
+/** Emulates Regex `+` operator */
+type RegexMatchPlus<char extends string, T extends string> =
+  _RegexMatchPlus<char, T> extends infer result extends string ?
+    result extends '' ? never : result
+  :
+  never
+
+// prettier-ignore
+type _RegexMatchPlus<char extends string, T extends string> =
+  T extends `${infer head extends char}${infer rest}` ?
+    `${head}${_RegexMatchPlus<char, rest>}`
+  :
+  ''
+
+type ParamNameChar = Regex_w | '-';
+
+type Simplify<T> = { [K in keyof T]: T[K] } & {};
+
+// prettier-ignore
+type GeneratePathParams<path extends string> = Simplify<
+  & ParseParams<path>
+  & { [key in string]: string | null | undefined }
+>
+
+// prettier-ignore
+type ParseParams<path extends string> =
+  // check if path is just a wildcard
+  path extends '*' ? { '*': string } :
+  // look for wildcard at the end of the path
+  path extends `${infer rest}/*` ? { '*': string } & ParseParams<rest> :
+  // look for params in the absence of wildcards
+  _ParseParams<path>;
+
+// prettier-ignore
+type _ParseParams<path extends string> =
+  // split path into individual path segments
+  path extends `${infer left}/${infer right}` ?
+    _ParseParams<left> & _ParseParams<right> :
+  // look for optional param in segment
+  path extends `:${infer param}?${string}` ?
+    { [key in RegexMatchPlus<ParamNameChar, param>]?: string | null | undefined } :
+  // look for required param in segment
+  path extends `:${infer param}` ?
+    { [key in RegexMatchPlus<ParamNameChar, param>]: string } :
+  {};
+
+// prettier-ignore
+export type PathParam<path extends string> = (keyof ParseParams<path>) & string;
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+type _tests = [
+	// PathParam
+	Expect<Equal<PathParam<'/a/b/*'>, '*'>>,
+	Expect<Equal<PathParam<':a'>, 'a'>>,
+	Expect<Equal<PathParam<'/a/:b'>, 'b'>>,
+	Expect<Equal<PathParam<'/a/blahblahblah:b'>, never>>,
+	Expect<Equal<PathParam<'/:a/:b'>, 'a' | 'b'>>,
+	Expect<Equal<PathParam<'/:a/b/:c/*'>, 'a' | 'c' | '*'>>,
+	Expect<Equal<PathParam<'/:lang.xml'>, 'lang'>>,
+	Expect<Equal<PathParam<'/:lang?.xml'>, 'lang'>>,
+
+	// ParseParams
+	Expect<Equal<ParseParams<'/a/b/*'>, { '*': string }>>,
+	Expect<Equal<ParseParams<':a'>, { a: string }>>,
+	Expect<Equal<ParseParams<'/a/:b'>, { b: string }>>,
+	Expect<Equal<ParseParams<'/a/blahblahblah:b'>, {}>>,
+	Expect<Equal<Simplify<ParseParams<'/:a/:b'>>, { a: string; b: string }>>,
+	Expect<Equal<Simplify<ParseParams<'/:a/b/:c/*'>>, { a: string; c: string; '*': string }>>,
+	Expect<Equal<ParseParams<'/:lang.xml'>, { lang: string }>>,
+	Expect<Equal<ParseParams<'/:lang?.xml'>, { lang?: string | null | undefined }>>,
+	Expect<Equal<Simplify<ParseParams<'/:a/:a'>>, { a: string }>>,
+	Expect<Equal<Simplify<ParseParams<'/:a/:a?'>>, { a: string }>>,
+	Expect<Equal<Simplify<ParseParams<'/:a?/:a?'>>, { a?: string | null | undefined }>>,
+];
+
+// Attempt to parse the given string segment. If it fails, then just return the
+// plain string type as a default fallback. Otherwise, return the union of the
+// parsed string literals that were referenced as dynamic segments in the route.
+export type ParamParseKey<Segment extends string> =
+	// if you could not find path params, fallback to `string`
+	[PathParam<Segment>] extends [never] ? string : PathParam<Segment>;
+
+/**
+ * The parameters that were parsed from the URL path.
+ */
+export type Params<Key extends string = string> = {
+	readonly [key in Key]: string | undefined;
+};
+
+/**
+ * A RouteMatch contains info about how a route matched a URL.
+ */
+export interface RouteMatch<
+	ParamKey extends string = string,
+	RouteObjectType extends RouteObject = RouteObject,
+> {
+	/**
+	 * The names and values of dynamic parameters in the URL.
+	 */
+	params: Params<ParamKey>;
+	/**
+	 * The portion of the URL pathname that was matched.
+	 */
+	pathname: string;
+	/**
+	 * The portion of the URL pathname that was matched before child routes.
+	 */
+	pathnameBase: string;
+	/**
+	 * The route object that was used to match.
+	 */
+	route: RouteObjectType;
+}
+
+export interface DataRouteMatch extends RouteMatch<string, DataRouteObject> {}
+
+function isIndexRoute(route: RouteObject): route is IndexRouteObject {
+	return route.index === true;
+}
+
+// Walk the route tree generating unique IDs where necessary, so we are working
+// solely with DataRouteObject's within the Router
+export function convertRoutesToDataRoutes(
+	routes: RouteObject[],
+	mapRouteProperties: MapRoutePropertiesFunction,
+	parentPath: string[] = [],
+	manifest: RouteManifest = {},
+	allowInPlaceMutations = false,
+): DataRouteObject[] {
+	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: DataIndexRouteObject = {
+				...route,
+				id,
+			};
+			manifest[id] = mergeRouteUpdates(indexRoute, mapRouteProperties(indexRoute));
+			return indexRoute;
+		} else {
+			let pathOrLayoutRoute: DataNonIndexRouteObject = {
+				...route,
+				id,
+				children: undefined,
+			};
+			manifest[id] = mergeRouteUpdates(pathOrLayoutRoute, mapRouteProperties(pathOrLayoutRoute));
+
+			if (route.children) {
+				pathOrLayoutRoute.children = convertRoutesToDataRoutes(
+					route.children,
+					mapRouteProperties,
+					treePath,
+					manifest,
+					allowInPlaceMutations,
+				);
+			}
+
+			return pathOrLayoutRoute;
+		}
+	});
+}
+
+function mergeRouteUpdates<T extends DataRouteObject>(
+	route: T,
+	updates: ReturnType<MapRoutePropertiesFunction>,
+): T {
+	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.
+ */
+export function matchRoutes<RouteObjectType extends RouteObject = RouteObject>(
+	routes: RouteObjectType[],
+	locationArg: Partial<Location> | string,
+	basename = '/',
+): RouteMatch<string, RouteObjectType>[] | null {
+	return matchRoutesImpl(routes, locationArg, basename, false);
+}
+
+export function matchRoutesImpl<RouteObjectType extends RouteObject = RouteObject>(
+	routes: RouteObjectType[],
+	locationArg: Partial<Location> | string,
+	basename: string,
+	allowPartial: boolean,
+	precomputedBranches?: RouteBranch<RouteObjectType>[],
+): RouteMatch<string, RouteObjectType>[] | null {
+	let location = typeof locationArg === 'string' ? parsePath(locationArg) : locationArg;
+
+	let pathname = stripBasename(location.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) {
+		// Incoming pathnames are generally encoded from either window.location
+		// or from router.navigate, but we want to match against the unencoded
+		// paths in the route definitions.  Memory router locations won't be
+		// encoded here but there also shouldn't be anything to decode so this
+		// should be a safe operation.  This avoids needing matchRoutes to be
+		// history-aware.
+		matches = matchRouteBranch<string, RouteObjectType>(branches[i], decoded, allowPartial);
+	}
+
+	return matches;
+}
+
+export interface UIMatch<Data = unknown, Handle = unknown> {
+	id: string;
+	pathname: string;
+	/**
+	 * {@link https://reactrouter.com/start/framework/routing#dynamic-segments Dynamic route params} for the matched route.
+	 */
+	params: RouteMatch['params'];
+	/**
+	 * The return value from the matched route's loader or clientLoader. This might
+	 * be `undefined` if this route's `loader` (or a deeper route's `loader`) threw
+	 * an error and we're currently displaying an `ErrorBoundary`.
+	 *
+	 * @deprecated Use `UIMatch.loaderData` instead
+	 */
+	data: Data | undefined;
+	/**
+	 * The return value from the matched route's loader or clientLoader. This might
+	 * be `undefined` if this route's `loader` (or a deeper route's `loader`) threw
+	 * an error and we're currently displaying an `ErrorBoundary`.
+	 */
+	loaderData: Data | undefined;
+	/**
+	 * The {@link https://reactrouter.com/start/framework/route-module#handle handle object}
+	 * exported from the matched route module
+	 */
+	handle: Handle;
+}
+
+export function convertRouteMatchToUiMatch(match: DataRouteMatch, loaderData: RouteData): UIMatch {
+	let { route, pathname, params } = match;
+	return {
+		id: route.id,
+		pathname,
+		params,
+		data: loaderData[route.id],
+		loaderData: loaderData[route.id],
+		handle: route.handle,
+	};
+}
+
+interface RouteMeta<RouteObjectType extends RouteObject = RouteObject> {
+	relativePath: string;
+	caseSensitive: boolean;
+	childrenIndex: number;
+	route: RouteObjectType;
+	matcher?: RegExp;
+	compiledParams?: CompiledPathParam[];
+}
+
+/**
+ * @private
+ * PRIVATE - DO NOT USE
+ *
+ * A "branch" of routes that match a given route pattern.
+ * This is an internal interface not intended for direct external usage.
+ */
+export interface RouteBranch<RouteObjectType extends RouteObject = RouteObject> {
+	path: string;
+	score: number;
+	routesMeta: RouteMeta<RouteObjectType>[];
+}
+
+export function flattenAndRankRoutes<RouteObjectType extends RouteObject = RouteObject>(
+	routes: RouteObjectType[],
+): RouteBranch<RouteObjectType>[] {
+	let branches = flattenRoutes(routes);
+	rankRouteBranches(branches);
+	return branches;
+}
+
+function flattenRoutes<RouteObjectType extends RouteObject = RouteObject>(
+	routes: RouteObjectType[],
+	branches: RouteBranch<RouteObjectType>[] = [],
+	parentsMeta: RouteMeta<RouteObjectType>[] = [],
+	parentPath = '',
+	_hasParentOptionalSegments = false,
+): RouteBranch<RouteObjectType>[] {
+	let flattenRoute = (
+		route: RouteObjectType,
+		index: number,
+		hasParentOptionalSegments = _hasParentOptionalSegments,
+		relativePath?: string,
+	) => {
+		let meta: RouteMeta<RouteObjectType> = {
+			relativePath: relativePath === undefined ? route.path || '' : relativePath,
+			caseSensitive: route.caseSensitive === true,
+			childrenIndex: index,
+			route,
+		};
+
+		if (meta.relativePath.startsWith('/')) {
+			if (!meta.relativePath.startsWith(parentPath) && hasParentOptionalSegments) {
+				// If we're inside of a parent route that has optional segments, we don't
+				// want to throw a hard error here because due to the route exploding
+				// approach, some of the routes won't match by design and we can just
+				// discard them instead.
+				// https://github.com/remix-run/react-router/issues/9925#issuecomment-1387252214
+				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);
+
+		// Add the children before adding this route to the array, so we traverse the
+		// route tree depth-first and child routes appear before their parents in
+		// the "flattened" version.
+		if (route.children && route.children.length > 0) {
+			invariant(
+				// Our types know better, but runtime JS may not!
+				// @ts-expect-error
+				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);
+		}
+
+		// Routes without a path shouldn't ever match by themselves unless they are
+		// index routes, so don't add them to the list of possible branches.
+		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,
+				} satisfies RouteMeta<RouteObjectType>;
+			}),
+		});
+	};
+
+	routes.forEach((route, index) => {
+		// coarse-grain check for optional params
+		if (route.path === '' || !route.path?.includes('?')) {
+			flattenRoute(route, index);
+		} else {
+			for (let exploded of explodeOptionalSegments(route.path)) {
+				flattenRoute(route, index, true, exploded);
+			}
+		}
+	});
+
+	return branches;
+}
+
+/*
+ * Computes all combinations of optional path segments for a given path,
+ * excluding combinations that are ambiguous and of lower priority.
+ *
+ * For example, `/one/:two?/three/:four?/:five?` explodes to:
+ * - `/one/three`
+ * - `/one/:two/three`
+ * - `/one/three/:four`
+ * - `/one/three/:five`
+ * - `/one/:two/three/:four`
+ * - `/one/:two/three/:five`
+ * - `/one/three/:four/:five`
+ * - `/one/:two/three/:four/:five`
+ */
+function explodeOptionalSegments(path: string): string[] {
+	let segments = path.split('/');
+	if (segments.length === 0) return [];
+
+	let [first, ...rest] = segments;
+
+	// Optional path segments are denoted by a trailing `?`
+	let isOptional = first.endsWith('?');
+	// Compute the corresponding required segment: `foo?` -> `foo`
+	let required = first.replace(/\?$/, '');
+
+	if (rest.length === 0) {
+		// Interpret empty string as omitting an optional segment
+		// `["one", "", "three"]` corresponds to omitting `:two` from `/one/:two?/three` -> `/one/three`
+		return isOptional ? [required, ''] : [required];
+	}
+
+	let restExploded = explodeOptionalSegments(rest.join('/'));
+
+	let result: string[] = [];
+
+	// All child paths with the prefix.  Do this for all children before the
+	// optional version for all children, so we get consistent ordering where the
+	// parent optional aspect is preferred as required.  Otherwise, we can get
+	// child sections interspersed where deeper optional segments are higher than
+	// parent optional segments, where for example, /:two would explode _earlier_
+	// then /:one.  By always including the parent as required _for all children_
+	// first, we avoid this issue
+	result.push(
+		...restExploded.map((subpath) => (subpath === '' ? required : [required, subpath].join('/'))),
+	);
+
+	// Then, if this is an optional value, add all child versions without
+	if (isOptional) {
+		result.push(...restExploded);
+	}
+
+	// for absolute paths, ensure `/` instead of empty segment
+	return result.map((exploded) => (path.startsWith('/') && exploded === '' ? '/' : exploded));
+}
+
+function rankRouteBranches(branches: RouteBranch[]): void {
+	branches.sort((a, b) =>
+		a.score !== b.score
+			? b.score - a.score // Higher score first
+			: compareIndexes(
+					a.routesMeta.map((meta) => meta.childrenIndex),
+					b.routesMeta.map((meta) => meta.childrenIndex),
+				),
+	);
+}
+
+const paramRe = /^:[\w-]+$/;
+const dynamicSegmentValue = 3;
+const indexRouteValue = 2;
+const emptySegmentValue = 1;
+const staticSegmentValue = 10;
+const splatPenalty = -2;
+const isSplat = (s: string) => s === '*';
+
+function computeScore(path: string, index: boolean | undefined): number {
+	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
+					: segment === ''
+						? emptySegmentValue
+						: staticSegmentValue),
+			initialScore,
+		);
+}
+
+function compareIndexes(a: number[], b: number[]): number {
+	let siblings = a.length === b.length && a.slice(0, -1).every((n, i) => n === b[i]);
+
+	return siblings
+		? // If two routes are siblings, we should try to match the earlier sibling
+			// first. This allows people to have fine-grained control over the matching
+			// behavior by simply putting routes with identical paths in the order they
+			// want them tried.
+			a[a.length - 1] - b[b.length - 1]
+		: // Otherwise, it doesn't really make sense to rank non-siblings by index,
+			// so they sort equally.
+			0;
+}
+
+function matchRouteBranch<
+	ParamKey extends string = string,
+	RouteObjectType extends RouteObject = RouteObject,
+>(
+	branch: RouteBranch<RouteObjectType>,
+	pathname: string,
+	allowPartial = false,
+): RouteMatch<ParamKey, RouteObjectType>[] | null {
+	let { routesMeta } = branch;
+
+	let matchedParams = {};
+	let matchedPathname = '/';
+	let matches: RouteMatch<ParamKey, RouteObjectType>[] = [];
+	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 =
+			// Use precomputed matcher if it exists
+			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({
+			// TODO: Can this as be avoided?
+			params: matchedParams as Params<ParamKey>,
+			pathname: joinPaths([matchedPathname, match.pathname]),
+			pathnameBase: normalizePathname(joinPaths([matchedPathname, match.pathnameBase])),
+			route,
+		});
+
+		if (match.pathnameBase !== '/') {
+			matchedPathname = joinPaths([matchedPathname, match.pathnameBase]);
+		}
+	}
+
+	return matches;
+}
+
+/**
+ * Returns a path with params interpolated.
+ *
+ * @example
+ * import { generatePath } from "react-router";
+ *
+ * generatePath("/users/:id", { id: "123" }); // "/users/123"
+ *
+ * @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.
+ */
+export function generatePath<Path extends string>(
+	originalPath: Path,
+	params: GeneratePathParams<Path> = {} as any,
+): string {
+	let path: string = 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(/\*$/, '/*') as Path;
+	}
+
+	// ensure `/` is added at the beginning if the path is absolute
+	const prefix = path.startsWith('/') ? '/' : '';
+
+	const stringify = (p: any) => (p == null ? '' : typeof p === 'string' ? p : String(p));
+
+	const segments = path
+		.split(/\/+/)
+		.map((segment, index, array) => {
+			const isLastSegment = index === array.length - 1;
+
+			// only apply the splat if it's the last segment
+			if (isLastSegment && segment === '*') {
+				// Apply the splat
+				return stringify(params['*' as keyof typeof params]);
+			}
+
+			const keyMatch = segment.match(/^:([\w-]+)(\??)(.*)/);
+			if (keyMatch) {
+				const [, key, optional, suffix] = keyMatch;
+				let param = params[key as keyof typeof params];
+				invariant(optional === '?' || param != null, `Missing ":${key}" param`);
+				return encodeURIComponent(stringify(param)) + suffix;
+			}
+
+			// Remove any optional markers from optional static segments
+			return segment.replace(/\?$/g, '');
+		})
+		// Remove empty segments
+		.filter((segment) => !!segment);
+
+	return prefix + segments.join('/');
+}
+
+/**
+ * Used to match on some portion of a URL pathname.
+ */
+export interface PathPattern<Path extends string = string> {
+	/**
+	 * A string to match against a URL pathname. May contain `:id`-style segments
+	 * to indicate placeholders for dynamic parameters. It May also end with `/*`
+	 * to indicate matching the rest of the URL pathname.
+	 */
+	path: Path;
+	/**
+	 * Should be `true` if the static portions of the `path` should be matched in
+	 * the same case.
+	 */
+	caseSensitive?: boolean;
+	/**
+	 * Should be `true` if this pattern should match the entire URL pathname.
+	 */
+	end?: boolean;
+}
+
+/**
+ * Contains info about how a {@link PathPattern} matched on a URL pathname.
+ */
+export interface PathMatch<ParamKey extends string = string> {
+	/**
+	 * The names and values of dynamic parameters in the URL.
+	 */
+	params: Params<ParamKey>;
+	/**
+	 * The portion of the URL pathname that was matched.
+	 */
+	pathname: string;
+	/**
+	 * The portion of the URL pathname that was matched before child routes.
+	 */
+	pathnameBase: string;
+	/**
+	 * The pattern that was used to match.
+	 */
+	pattern: PathPattern;
+}
+
+type Mutable<T> = {
+	-readonly [P in keyof T]: T[P];
+};
+
+/**
+ * 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.
+ */
+export function matchPath<Path extends string>(
+	pattern: PathPattern<Path> | Path,
+	pathname: string,
+): PathMatch<ParamParseKey<Path>> | null {
+	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<Path extends string>(
+	pattern: PathPattern<Path>,
+	pathname: string,
+	matcher: RegExp,
+	compiledParams: CompiledPathParam[],
+): PathMatch<ParamParseKey<Path>> | null {
+	let match = pathname.match(matcher);
+	if (!match) return null;
+
+	let matchedPathname = match[0];
+	let pathnameBase = matchedPathname.replace(/(.)\/+$/, '$1');
+	let captureGroups = match.slice(1);
+	let params: Params = compiledParams.reduce<Mutable<Params>>(
+		(memo, { paramName, isOptional }, index) => {
+			// We need to compute the pathnameBase here using the raw splat value
+			// instead of using params["*"] later because it will be decoded then
+			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] = undefined;
+			} else {
+				memo[paramName] = (value || '').replace(/%2F/g, '/');
+			}
+			return memo;
+		},
+		{},
+	);
+
+	return {
+		params,
+		pathname: matchedPathname,
+		pathnameBase,
+		pattern,
+	};
+}
+
+type CompiledPathParam = { paramName: string; isOptional?: boolean };
+
+export function compilePath(
+	path: string,
+	caseSensitive = false,
+	end = true,
+): [RegExp, CompiledPathParam[]] {
+	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: CompiledPathParam[] = [];
+	let regexpSource =
+		'^' +
+		path
+			.replace(/\/*\*?$/, '') // Ignore trailing / and /*, we'll handle it below
+			.replace(/^\/*/, '/') // Make sure it has a leading /
+			.replace(/[\\.*+^${}|()[\]]/g, '\\$&') // Escape special regex chars
+			.replace(
+				/\/:([\w-]+)(\?)?/g,
+				(
+					match: string,
+					paramName: string,
+					isOptional: string | undefined,
+					index: number,
+					str: string,
+				) => {
+					params.push({ paramName, isOptional: isOptional != null });
+
+					if (isOptional) {
+						let nextChar = str.charAt(index + match.length);
+						if (nextChar && nextChar !== '/') {
+							return '/([^\\/]*)';
+						}
+
+						return '(?:/([^\\/]*))?';
+					}
+
+					return '/([^\\/]+)';
+				},
+			) // Dynamic segment
+			.replace(/\/([\w-]+)\?(\/|$)/g, '(/$1)?$2'); // Optional static segment
+
+	if (path.endsWith('*')) {
+		params.push({ paramName: '*' });
+		regexpSource +=
+			path === '*' || path === '/*'
+				? '(.*)$' // Already matched the initial /, just match the rest
+				: '(?:\\/(.+)|\\/*)$'; // Don't include the / in params["*"]
+	} else if (end) {
+		// When matching to the end, ignore trailing slashes
+		regexpSource += '\\/*$';
+	} else if (path !== '' && path !== '/') {
+		// If our path is non-empty and contains anything beyond an initial slash,
+		// then we have _some_ form of path in our regex, so we should expect to
+		// match only if we find the end of this path segment.  Look for an optional
+		// non-captured trailing slash (to match a portion of the URL) or the end
+		// of the path (if we've matched to the end).  We used to do this with a
+		// word boundary but that gives false positives on routes like
+		// /user-preferences since `-` counts as a word boundary.
+		regexpSource += '(?:(?=\\/|$))';
+	} else {
+		// Nothing to match for "" or "/"
+	}
+
+	let matcher = new RegExp(regexpSource, caseSensitive ? undefined : 'i');
+
+	return [matcher, params];
+}
+
+export function decodePath(value: string) {
+	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;
+	}
+}
+
+export function stripBasename(pathname: string, basename: string): string | null {
+	if (basename === '/') return pathname;
+
+	if (!pathname.toLowerCase().startsWith(basename.toLowerCase())) {
+		return null;
+	}
+
+	// We want to leave trailing slash behavior in the user's control, so if they
+	// specify a basename with a trailing slash, we should support it
+	let startIndex = basename.endsWith('/') ? basename.length - 1 : basename.length;
+	let nextChar = pathname.charAt(startIndex);
+	if (nextChar && nextChar !== '/') {
+		// pathname does not start with basename/
+		return null;
+	}
+
+	return pathname.slice(startIndex) || '/';
+}
+
+export function prependBasename({
+	basename,
+	pathname,
+}: {
+	basename: string;
+	pathname: string;
+}): string {
+	// If this is a root navigation, then just use the raw basename which allows
+	// the basename to have full control over the presence of a trailing slash on
+	// root actions
+	return pathname === '/' ? basename : joinPaths([basename, pathname]);
+}
+
+export const isAbsoluteUrl = (url: string) => 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.
+ */
+export function resolvePath(to: To, fromPathname = '/'): Path {
+	let {
+		pathname: toPathname,
+		search = '',
+		hash = '',
+	} = typeof to === 'string' ? parsePath(to) : to;
+
+	let pathname: string;
+	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: string, fromPathname: string): string {
+	let segments = removeTrailingSlash(fromPathname).split('/');
+	let relativeSegments = relativePath.split('/');
+
+	relativeSegments.forEach((segment) => {
+		if (segment === '..') {
+			// Keep the root "" segment so the pathname starts at /
+			if (segments.length > 1) segments.pop();
+		} else if (segment !== '.') {
+			segments.push(segment);
+		}
+	});
+
+	return segments.length > 1 ? segments.join('/') : '/';
+}
+
+function getInvalidPathError(char: string, field: string, dest: string, path: Partial<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.`
+	);
+}
+
+// When processing relative navigation we want to ignore ancestor routes that
+// do not contribute to the path, such that index/pathless layout routes don't
+// interfere.
+//
+// For example, when moving a route element into an index route and/or a
+// pathless layout route, relative link behavior contained within should stay
+// the same.  Both of the following examples should link back to the root:
+//
+// <Route path="/">
+//   <Route path="accounts" element={<Link to=".."}>
+// </Route>
+//
+// <Route path="/">
+//   <Route path="accounts">
+//     <Route element={<AccountsLayout />}>       // <-- Does not contribute
+//       <Route index element={<Link to=".."} />  // <-- Does not contribute
+//     </Route
+//   </Route>
+// </Route>
+export function getPathContributingMatches<T extends RouteMatch = RouteMatch>(matches: T[]) {
+	return matches.filter(
+		(match, index) => index === 0 || (match.route.path && match.route.path.length > 0),
+	);
+}
+
+// Return the array of pathnames for the current route matches - used to
+// generate the routePathnames input for resolveTo()
+export function getResolveToMatches<T extends RouteMatch = RouteMatch>(matches: T[]) {
+	let pathMatches = getPathContributingMatches(matches);
+
+	// Use the full pathname for the leaf match so we include splat values for "." links
+	// https://github.com/remix-run/react-router/issues/11052#issuecomment-1836589329
+	return pathMatches.map((match, idx) =>
+		idx === pathMatches.length - 1 ? match.pathname : match.pathnameBase,
+	);
+}
+
+export function resolveTo(
+	toArg: To,
+	routePathnames: string[],
+	locationPathname: string,
+	isPathRelative = false,
+): Path {
+	let to: Partial<Path>;
+	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: string;
+
+	// Routing is relative to the current pathname if explicitly requested.
+	//
+	// If a pathname is explicitly provided in `to`, it should be relative to the
+	// route context. This is explained in `Note on `<Link to>` values` in our
+	// migration guide from v5 as a means of disambiguation between `to` values
+	// that begin with `/` and those that do not. However, this is problematic for
+	// `to` values that do not provide a pathname. `to` can simply be a search or
+	// hash string, in which case we should assume that the navigation is relative
+	// to the current location's pathname and *not* the route pathname.
+	if (toPathname == null) {
+		from = locationPathname;
+	} else {
+		let routePathnameIndex = routePathnames.length - 1;
+
+		// With relative="route" (the default), each leading .. segment means
+		// "go up one route" instead of "go up one URL segment".  This is a key
+		// difference from how <a href> works and a major reason we call this a
+		// "to" value instead of a "href".
+		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);
+
+	// Ensure the pathname has a trailing slash if the original "to" had one
+	let hasExplicitTrailingSlash = toPathname && toPathname !== '/' && toPathname.endsWith('/');
+	// Or if this was a link to the current path which has a trailing slash
+	let hasCurrentTrailingSlash =
+		(isEmptyPath || toPathname === '.') && locationPathname.endsWith('/');
+	if (!path.pathname.endsWith('/') && (hasExplicitTrailingSlash || hasCurrentTrailingSlash)) {
+		path.pathname += '/';
+	}
+
+	return path;
+}
+
+export const removeDoubleSlashes = (path: string): string => path.replace(/[\\/]{2,}/g, '/');
+
+export const joinPaths = (paths: string[]): string => removeDoubleSlashes(paths.join('/'));
+
+export const removeTrailingSlash = (path: string): string => path.replace(/\/+$/, '');
+
+export const normalizePathname = (pathname: string): string =>
+	removeTrailingSlash(pathname).replace(/^\/*/, '/');
+
+/*
+lol - this comment is needed because the JSDoc parser for docs.ts gets confused
+by the star-slash in the normalizePathname regex and messes up the parsed comment
+for data() below.  This comment seems to reset the parser.
+*/
+
+export const normalizeSearch = (search: string): string =>
+	!search || search === '?' ? '' : search.startsWith('?') ? search : '?' + search;
+
+export const normalizeHash = (hash: string): string =>
+	!hash || hash === '#' ? '' : hash.startsWith('#') ? hash : '#' + hash;
+
+export class DataWithResponseInit<D> {
+	type: string = 'DataWithResponseInit';
+	data: D;
+	init: ResponseInit | null;
+
+	constructor(data: D, init?: ResponseInit) {
+		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.
+ */
+export function data<D>(data: D, init?: number | ResponseInit) {
+	return new DataWithResponseInit(data, typeof init === 'number' ? { status: init } : init);
+}
+
+// This is now only used by the Await component and will eventually probably
+// go away in favor of the format used by `React.use`
+export interface TrackedPromise extends Promise<any> {
+	_tracked?: boolean;
+	_data?: any;
+	_error?: any;
+}
+
+export type RedirectFunction = (url: string, init?: number | ResponseInit) => Response;
+
+/**
+ * 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.
+ */
+export const redirect: RedirectFunction = (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.
+ */
+export const redirectDocument: RedirectFunction = (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.
+ */
+export const replace: RedirectFunction = (url, init) => {
+	let response = redirect(url, init);
+	response.headers.set('X-Remix-Replace', 'true');
+	return response;
+};
+
+export type ErrorResponse = {
+	status: number;
+	statusText: string;
+	data: any;
+};
+
+export const SUPPORTED_ERROR_TYPES = [
+	'EvalError',
+	'RangeError',
+	'ReferenceError',
+	'SyntaxError',
+	'TypeError',
+	'URIError',
+];
+
+/*
+ * Utility class we use to hold auto-unwrapped 4xx/5xx Response bodies
+ *
+ * We don't export the class for public use since it's an implementation
+ * detail, but we export the interface above so folks can build their own
+ * abstractions around instances via isRouteErrorResponse()
+ */
+export class ErrorResponseImpl implements ErrorResponse {
+	status: number;
+	statusText: string;
+	data: any;
+	private error?: Error;
+	private internal: boolean;
+
+	constructor(status: number, statusText: string | undefined, data: any, 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.
+ */
+export function isRouteErrorResponse(error: any): error is ErrorResponse {
+	return (
+		error != null &&
+		typeof error.status === 'number' &&
+		typeof error.statusText === 'string' &&
+		typeof error.internal === 'boolean' &&
+		'data' in error
+	);
+}
+
+/*
+lol - this comment is needed because the JSDoc parser for `docs.ts` gets confused
+by the star-slash in the `getRoutePattern` regex and messes up the parsed comment
+for `isRouteErrorResponse` above.  This comment seems to reset the parser.
+*/
+
+export function getRoutePattern(matches: RouteMatch[]) {
+	let parts = matches.map((m) => m.route.path).filter(Boolean) as string[];
+	return joinPaths(parts) || '/';
+}
+
+export const isBrowser =
+	typeof window !== 'undefined' &&
+	typeof window.document !== 'undefined' &&
+	typeof window.document.createElement !== 'undefined';
+
+export type ParsedLocationInfo<T extends To> =
+	| {
+			absoluteURL: string;
+			isExternal: boolean;
+			to: string;
+	  }
+	| {
+			absoluteURL: undefined;
+			isExternal: false;
+			to: T;
+	  };
+export function parseToInfo<T extends To | string>(
+	_to: T,
+	basename: string,
+): ParsedLocationInfo<T | string> {
+	let to = _to as string;
+	if (typeof to !== 'string' || !ABSOLUTE_URL_REGEX.test(to)) {
+		return {
+			absoluteURL: undefined,
+			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) {
+				// Strip the protocol/origin/basename for same-origin absolute URLs
+				to = path + targetUrl.search + targetUrl.hash;
+			} else {
+				isExternal = true;
+			}
+		} catch (
+			// eslint-disable-next-line @typescript-eslint/no-unused-vars
+			e
+		) {
+			// We can't do external URL detection without a valid URL
+			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,
+	};
+}