		@@ -1,263 +0,2 @@
		/**
		* NOTE: If you refactor this to split up the modules into separate files,
		* you'll need to update the rollup config for react-router-dom-v5-compat.
		*/
		import * as React from "react";
		import type { FutureConfig, NavigateOptions, RelativeRoutingType, RouteObject, To } from "react-router";
		import type { Fetcher, FormEncType, FormMethod, FutureConfig as RouterFutureConfig, GetScrollRestorationKeyFunction, History, HTMLFormMethod, HydrationState, Router as RemixRouter, V7_FormMethod } from "@remix-run/router";
		import type { SubmitOptions, ParamKeyValuePair, URLSearchParamsInit, SubmitTarget } from "./dom";
		import { createSearchParams } from "./dom";
		export type { FormEncType, FormMethod, GetScrollRestorationKeyFunction, ParamKeyValuePair, SubmitOptions, URLSearchParamsInit, V7_FormMethod, };
		export { createSearchParams };
		export type { ActionFunction, ActionFunctionArgs, AwaitProps, unstable_Blocker, unstable_BlockerFunction, DataRouteMatch, DataRouteObject, Fetcher, Hash, IndexRouteObject, IndexRouteProps, JsonFunction, LazyRouteFunction, LayoutRouteProps, LoaderFunction, LoaderFunctionArgs, Location, MemoryRouterProps, NavigateFunction, NavigateOptions, NavigateProps, Navigation, Navigator, NonIndexRouteObject, OutletProps, Params, ParamParseKey, Path, PathMatch, Pathname, PathPattern, PathRouteProps, RedirectFunction, RelativeRoutingType, RouteMatch, RouteObject, RouteProps, RouterProps, RouterProviderProps, RoutesProps, Search, ShouldRevalidateFunction, ShouldRevalidateFunctionArgs, To, } from "react-router";
		export { AbortedDeferredError, Await, MemoryRouter, Navigate, NavigationType, Outlet, Route, Router, RouterProvider, Routes, createMemoryRouter, createPath, createRoutesFromChildren, createRoutesFromElements, defer, isRouteErrorResponse, generatePath, json, matchPath, matchRoutes, parsePath, redirect, redirectDocument, renderMatches, resolvePath, useActionData, useAsyncError, useAsyncValue, unstable_useBlocker, useHref, useInRouterContext, useLoaderData, useLocation, useMatch, useMatches, useNavigate, useNavigation, useNavigationType, useOutlet, useOutletContext, useParams, useResolvedPath, useRevalidator, useRouteError, useRouteLoaderData, useRoutes, } from "react-router";
		/** @internal */
		export { UNSAFE_DataRouterContext, UNSAFE_DataRouterStateContext, UNSAFE_NavigationContext, UNSAFE_LocationContext, UNSAFE_RouteContext, UNSAFE_useRouteId, } from "react-router";
		declare global {
		var __staticRouterHydrationData: HydrationState \| undefined;
		}
		interface DOMRouterOpts {
		basename?: string;
		future?: Partial<Omit<RouterFutureConfig, "v7_prependBasename">>;
		hydrationData?: HydrationState;
		window?: Window;
		}
		export declare function createBrowserRouter(routes: RouteObject[], opts?: DOMRouterOpts): RemixRouter;
		export declare function createHashRouter(routes: RouteObject[], opts?: DOMRouterOpts): RemixRouter;
		export interface BrowserRouterProps {
		basename?: string;
		children?: React.ReactNode;
		future?: FutureConfig;
		window?: Window;
		}
		/**
		* A `<Router>` for use in web browsers. Provides the cleanest URLs.
		*/
		export declare function BrowserRouter({ basename, children, future, window, }: BrowserRouterProps): React.JSX.Element;
		export interface HashRouterProps {
		basename?: string;
		children?: React.ReactNode;
		future?: FutureConfig;
		window?: Window;
		}
		/**
		* A `<Router>` for use in web browsers. Stores the location in the hash
		* portion of the URL so it is not sent to the server.
		*/
		export declare function HashRouter({ basename, children, future, window, }: HashRouterProps): React.JSX.Element;
		export interface HistoryRouterProps {
		basename?: string;
		children?: React.ReactNode;
		future?: FutureConfig;
		history: History;
		}
		/**
		* A `<Router>` that accepts a pre-instantiated history object. It's important
		* to note that using your own history object is highly discouraged and may add
		* two versions of the history library to your bundles unless you use the same
		* version of the history library that React Router uses internally.
		*/
		declare function HistoryRouter({ basename, children, future, history, }: HistoryRouterProps): React.JSX.Element;
		declare namespace HistoryRouter {
		var displayName: string;
		}
		export { HistoryRouter as unstable_HistoryRouter };
		export interface LinkProps extends Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, "href"> {
		reloadDocument?: boolean;
		replace?: boolean;
		state?: any;
		preventScrollReset?: boolean;
		relative?: RelativeRoutingType;
		to: To;
		}
		/**
		* The public API for rendering a history-aware <a>.
		*/
		export declare const Link: React.ForwardRefExoticComponent<LinkProps & React.RefAttributes<HTMLAnchorElement>>;
		export interface NavLinkProps extends Omit<LinkProps, "className" \| "style" \| "children"> {
		children?: React.ReactNode \| ((props: {
		isActive: boolean;
		isPending: boolean;
		}) => React.ReactNode);
		caseSensitive?: boolean;
		className?: string \| ((props: {
		isActive: boolean;
		isPending: boolean;
		}) => string \| undefined);
		end?: boolean;
		style?: React.CSSProperties \| ((props: {
		isActive: boolean;
		isPending: boolean;
		}) => React.CSSProperties \| undefined);
		}
		/**
		* A <Link> wrapper that knows if it's "active" or not.
		*/
		export declare const NavLink: React.ForwardRefExoticComponent<NavLinkProps & React.RefAttributes<HTMLAnchorElement>>;
		export interface FetcherFormProps extends React.FormHTMLAttributes<HTMLFormElement> {
		/**
		* The HTTP verb to use when the form is submit. Supports "get", "post",
		* "put", "delete", "patch".
		*/
		method?: HTMLFormMethod;
		/**
		* `<form encType>` - enhancing beyond the normal string type and limiting
		* to the built-in browser supported values
		*/
		encType?: "application/x-www-form-urlencoded" \| "multipart/form-data" \| "text/plain";
		/**
		* Normal `<form action>` but supports React Router's relative paths.
		*/
		action?: string;
		/**
		* Determines whether the form action is relative to the route hierarchy or
		* the pathname. Use this if you want to opt out of navigating the route
		* hierarchy and want to instead route based on /-delimited URL segments
		*/
		relative?: RelativeRoutingType;
		/**
		* Prevent the scroll position from resetting to the top of the viewport on
		* completion of the navigation when using the <ScrollRestoration> component
		*/
		preventScrollReset?: boolean;
		/**
		* A function to call when the form is submitted. If you call
		* `event.preventDefault()` then this form will not do anything.
		*/
		onSubmit?: React.FormEventHandler<HTMLFormElement>;
		}
		export interface FormProps extends FetcherFormProps {
		/**
		* Forces a full document navigation instead of a fetch.
		*/
		reloadDocument?: boolean;
		/**
		* Replaces the current entry in the browser history stack when the form
		* navigates. Use this if you don't want the user to be able to click "back"
		* to the page with the form on it.
		*/
		replace?: boolean;
		/**
		* State object to add to the history stack entry for this navigation
		*/
		state?: any;
		}
		/**
		* A `@remix-run/router`-aware `<form>`. It behaves like a normal form except
		* that the interaction with the server is with `fetch` instead of new document
		* requests, allowing components to add nicer UX to the page as the form is
		* submitted and returns with data.
		*/
		export declare const Form: React.ForwardRefExoticComponent<FormProps & React.RefAttributes<HTMLFormElement>>;
		export interface ScrollRestorationProps {
		getKey?: GetScrollRestorationKeyFunction;
		storageKey?: string;
		}
		/**
		* This component will emulate the browser's scroll restoration on location
		* changes.
		*/
		export declare function ScrollRestoration({ getKey, storageKey, }: ScrollRestorationProps): null;
		export declare namespace ScrollRestoration {
		var displayName: string;
		}
		/**
		* Handles the click behavior for router `<Link>` components. This is useful if
		* you need to create custom `<Link>` components with the same click behavior we
		* use in our exported `<Link>`.
		*/
		export declare function useLinkClickHandler<E extends Element = HTMLAnchorElement>(to: To, { target, replace: replaceProp, state, preventScrollReset, relative, }?: {
		target?: React.HTMLAttributeAnchorTarget;
		replace?: boolean;
		state?: any;
		preventScrollReset?: boolean;
		relative?: RelativeRoutingType;
		}): (event: React.MouseEvent<E, MouseEvent>) => void;
		/**
		* A convenient wrapper for reading and writing search parameters via the
		* URLSearchParams interface.
		*/
		export declare function useSearchParams(defaultInit?: URLSearchParamsInit): [URLSearchParams, SetURLSearchParams];
		export type SetURLSearchParams = (nextInit?: URLSearchParamsInit \| ((prev: URLSearchParams) => URLSearchParamsInit), navigateOpts?: NavigateOptions) => void;
		/**
		* Submits a HTML `<form>` to the server without reloading the page.
		*/
		export interface SubmitFunction {
		(
		/**
		* Specifies the `<form>` to be submitted to the server, a specific
		* `<button>` or `<input type="submit">` to use to submit the form, or some
		* arbitrary data to submit.
		*
		* Note: When using a `<button>` its `name` and `value` will also be
		* included in the form data that is submitted.
		*/
		target: SubmitTarget,
		/**
		* Options that override the `<form>`'s own attributes. Required when
		* submitting arbitrary data without a backing `<form>`.
		*/
		options?: SubmitOptions): void;
		}
		/**
		* Submits a fetcher `<form>` to the server without reloading the page.
		*/
		export interface FetcherSubmitFunction {
		(target: SubmitTarget, options?: Omit<SubmitOptions, "replace" \| "state">): void;
		}
		/**
		* Returns a function that may be used to programmatically submit a form (or
		* some arbitrary data) to the server.
		*/
		export declare function useSubmit(): SubmitFunction;
		export declare function useFormAction(action?: string, { relative }?: {
		relative?: RelativeRoutingType;
		}): string;
		declare function createFetcherForm(fetcherKey: string, routeId: string): React.ForwardRefExoticComponent<FetcherFormProps & React.RefAttributes<HTMLFormElement>>;
		export type FetcherWithComponents<TData> = Fetcher<TData> & {
		Form: ReturnType<typeof createFetcherForm>;
		submit: FetcherSubmitFunction;
		load: (href: string) => void;
		};
		/**
		* Interacts with route loaders and actions without causing a navigation. Great
		* for any interaction that stays on the same page.
		*/
		export declare function useFetcher<TData = any>(): FetcherWithComponents<TData>;
		/**
		* Provides all fetchers currently on the page. Useful for layouts and parent
		* routes that need to provide pending/optimistic UI regarding the fetch.
		*/
		export declare function useFetchers(): Fetcher[];
		/**
		* When rendered inside a RouterProvider, will restore scroll positions on navigations
		*/
		declare function useScrollRestoration({ getKey, storageKey, }?: {
		getKey?: GetScrollRestorationKeyFunction;
		storageKey?: string;
		}): void;
		export { useScrollRestoration as UNSAFE_useScrollRestoration };
		/**
		* Setup a callback to be fired on the window's `beforeunload` event. This is
		* useful for saving some data to `window.localStorage` just before the page
		* refreshes.
		*
		* Note: The `callback` argument should be a function created with
		* `React.useCallback()`.
		*/
		export declare function useBeforeUnload(callback: (event: BeforeUnloadEvent) => any, options?: {
		capture?: boolean;
		}): void;
		/**
		* Wrapper around useBlocker to show a window.confirm prompt to users instead
		* of building a custom UI with useBlocker.
		*
		* Warning: This has a lot of rough edges and behaves very differently (and
		* very incorrectly in some cases) across browsers if user click addition
		* back/forward navigations while the confirm is open. Use at your own risk.
		*/
		declare function usePrompt({ when, message }: {
		when: boolean;
		message: string;
		}): void;
		export { usePrompt as unstable_usePrompt };
		export { HydratedRouter, RouterProvider, RouterProviderProps } from 'react-router/dom';
		export * from 'react-router';

1102

dist/index.js

		/**
		* React Router DOM v0.0.0-experimental-b8437806
		* react-router-dom v0.0.0-experimental-b98209dd9
		*
		@@ -11,1074 +11,36 @@ * Copyright (c) Remix Software Inc.
		*/
		import * as React from 'react';
		import { UNSAFE_mapRouteProperties, Router, UNSAFE_NavigationContext, useHref, useResolvedPath, useLocation, UNSAFE_DataRouterStateContext, useNavigate, createPath, UNSAFE_useRouteId, UNSAFE_RouteContext, useMatches, useNavigation, unstable_useBlocker, UNSAFE_DataRouterContext } from 'react-router';
		export { AbortedDeferredError, Await, MemoryRouter, Navigate, NavigationType, Outlet, Route, Router, RouterProvider, Routes, UNSAFE_DataRouterContext, UNSAFE_DataRouterStateContext, UNSAFE_LocationContext, UNSAFE_NavigationContext, UNSAFE_RouteContext, UNSAFE_useRouteId, createMemoryRouter, createPath, createRoutesFromChildren, createRoutesFromElements, defer, generatePath, isRouteErrorResponse, json, matchPath, matchRoutes, parsePath, redirect, redirectDocument, renderMatches, resolvePath, unstable_useBlocker, useActionData, useAsyncError, useAsyncValue, useHref, useInRouterContext, useLoaderData, useLocation, useMatch, useMatches, useNavigate, useNavigation, useNavigationType, useOutlet, useOutletContext, useParams, useResolvedPath, useRevalidator, useRouteError, useRouteLoaderData, useRoutes } from 'react-router';
		import { stripBasename, UNSAFE_warning, createRouter, createBrowserHistory, createHashHistory, ErrorResponse, UNSAFE_invariant, joinPaths } from '@remix-run/router';

		function _extends() {
		_extends = Object.assign ? Object.assign.bind() : function (target) {
		for (var i = 1; i < arguments.length; i++) {
		var source = arguments[i];
		for (var key in source) {
		if (Object.prototype.hasOwnProperty.call(source, key)) {
		target[key] = source[key];
		}
		}
		}
		return target;
		};
		return _extends.apply(this, arguments);
		}
		function _objectWithoutPropertiesLoose(source, excluded) {
		if (source == null) return {};
		var target = {};
		var sourceKeys = Object.keys(source);
		var key, i;
		for (i = 0; i < sourceKeys.length; i++) {
		key = sourceKeys[i];
		if (excluded.indexOf(key) >= 0) continue;
		target[key] = source[key];
		"use strict";
		var __defProp = Object.defineProperty;
		var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
		var __getOwnPropNames = Object.getOwnPropertyNames;
		var __hasOwnProp = Object.prototype.hasOwnProperty;
		var __export = (target, all) => {
		for (var name in all)
		__defProp(target, name, { get: all[name], enumerable: true });
		};
		var __copyProps = (to, from, except, desc) => {
		if (from && typeof from === "object" \|\| typeof from === "function") {
		for (let key of __getOwnPropNames(from))
		if (!__hasOwnProp.call(to, key) && key !== except)
		__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) \|\| desc.enumerable });
		}
		return target;
		}
		return to;
		};
		var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
		var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

		const defaultMethod = "get";
		const defaultEncType = "application/x-www-form-urlencoded";
		function isHtmlElement(object) {
		return object != null && typeof object.tagName === "string";
		}
		function isButtonElement(object) {
		return isHtmlElement(object) && object.tagName.toLowerCase() === "button";
		}
		function isFormElement(object) {
		return isHtmlElement(object) && object.tagName.toLowerCase() === "form";
		}
		function isInputElement(object) {
		return isHtmlElement(object) && object.tagName.toLowerCase() === "input";
		}
		function isModifiedEvent(event) {
		return !!(event.metaKey \|\| event.altKey \|\| event.ctrlKey \|\| event.shiftKey);
		}
		function shouldProcessLinkClick(event, target) {
		return event.button === 0 && (
		// Ignore everything but left clicks
		!target \|\| target === "_self") &&
		// Let browser handle "target=_blank" etc.
		!isModifiedEvent(event) // Ignore clicks with modifier keys
		;
		}
		/**
		* Creates a URLSearchParams object using the given initializer.
		*
		* This is identical to `new URLSearchParams(init)` except it also
		* supports arrays as values in the object form of the initializer
		* instead of just strings. This is convenient when you need multiple
		* values for a given key, but don't want to use an array initializer.
		*
		* For example, instead of:
		*
		* let searchParams = new URLSearchParams([
		* ['sort', 'name'],
		* ['sort', 'price']
		* ]);
		*
		* you can do:
		*
		* let searchParams = createSearchParams({
		* sort: ['name', 'price']
		* });
		*/
		function createSearchParams(init) {
		if (init === void 0) {
		init = "";
		}
		return new URLSearchParams(typeof init === "string" \|\| Array.isArray(init) \|\| init instanceof URLSearchParams ? init : Object.keys(init).reduce((memo, key) => {
		let value = init[key];
		return memo.concat(Array.isArray(value) ? value.map(v => [key, v]) : [[key, value]]);
		}, []));
		}
		function getSearchParamsForLocation(locationSearch, defaultSearchParams) {
		let searchParams = createSearchParams(locationSearch);
		if (defaultSearchParams) {
		// Use `defaultSearchParams.forEach(...)` here instead of iterating of
		// `defaultSearchParams.keys()` to work-around a bug in Firefox related to
		// web extensions. Relevant Bugzilla tickets:
		// https://bugzilla.mozilla.org/show_bug.cgi?id=1414602
		// https://bugzilla.mozilla.org/show_bug.cgi?id=1023984
		defaultSearchParams.forEach((_, key) => {
		if (!searchParams.has(key)) {
		defaultSearchParams.getAll(key).forEach(value => {
		searchParams.append(key, value);
		});
		}
		});
		}
		return searchParams;
		}
		// One-time check for submitter support
		let _formDataSupportsSubmitter = null;
		function isFormDataSubmitterSupported() {
		if (_formDataSupportsSubmitter === null) {
		try {
		new FormData(document.createElement("form"),
		// @ts-expect-error if FormData supports the submitter parameter, this will throw
		0);
		_formDataSupportsSubmitter = false;
		} catch (e) {
		_formDataSupportsSubmitter = true;
		}
		}
		return _formDataSupportsSubmitter;
		}
		const supportedFormEncTypes = new Set(["application/x-www-form-urlencoded", "multipart/form-data", "text/plain"]);
		function getFormEncType(encType) {
		if (encType != null && !supportedFormEncTypes.has(encType)) {
		process.env.NODE_ENV !== "production" ? UNSAFE_warning(false, "\"" + encType + "\" is not a valid `encType` for `<Form>`/`<fetcher.Form>` " + ("and will default to \"" + defaultEncType + "\"")) : void 0;
		return null;
		}
		return encType;
		}
		function getFormSubmissionInfo(target, basename) {
		let method;
		let action;
		let encType;
		let formData;
		let body;
		if (isFormElement(target)) {
		// When grabbing the action from the element, it will have had the basename
		// prefixed to ensure non-JS scenarios work, so strip it since we'll
		// re-prefix in the router
		let attr = target.getAttribute("action");
		action = attr ? stripBasename(attr, basename) : null;
		method = target.getAttribute("method") \|\| defaultMethod;
		encType = getFormEncType(target.getAttribute("enctype")) \|\| defaultEncType;
		formData = new FormData(target);
		} else if (isButtonElement(target) \|\| isInputElement(target) && (target.type === "submit" \|\| target.type === "image")) {
		let form = target.form;
		if (form == null) {
		throw new Error("Cannot submit a <button> or <input type=\"submit\"> without a <form>");
		}
		// <button>/<input type="submit"> may override attributes of <form>
		// When grabbing the action from the element, it will have had the basename
		// prefixed to ensure non-JS scenarios work, so strip it since we'll
		// re-prefix in the router
		let attr = target.getAttribute("formaction") \|\| form.getAttribute("action");
		action = attr ? stripBasename(attr, basename) : null;
		method = target.getAttribute("formmethod") \|\| form.getAttribute("method") \|\| defaultMethod;
		encType = getFormEncType(target.getAttribute("formenctype")) \|\| getFormEncType(form.getAttribute("enctype")) \|\| defaultEncType;
		// Build a FormData object populated from a form and submitter
		formData = new FormData(form, target);
		// If this browser doesn't support the `FormData(el, submitter)` format,
		// then tack on the submitter value at the end. This is a lightweight
		// solution that is not 100% spec compliant. For complete support in older
		// browsers, consider using the `formdata-submitter-polyfill` package
		if (!isFormDataSubmitterSupported()) {
		let {
		name,
		type,
		value
		} = target;
		if (type === "image") {
		let prefix = name ? name + "." : "";
		formData.append(prefix + "x", "0");
		formData.append(prefix + "y", "0");
		} else if (name) {
		formData.append(name, value);
		}
		}
		} else if (isHtmlElement(target)) {
		throw new Error("Cannot submit element that is not <form>, <button>, or " + "<input type=\"submit\|image\">");
		} else {
		method = defaultMethod;
		action = null;
		encType = defaultEncType;
		body = target;
		}
		// Send body for <Form encType="text/plain" so we encode it into text
		if (formData && encType === "text/plain") {
		body = formData;
		formData = undefined;
		}
		return {
		action,
		method: method.toLowerCase(),
		encType,
		formData,
		body
		};
		}

		const _excluded = ["onClick", "relative", "reloadDocument", "replace", "state", "target", "to", "preventScrollReset"],
		_excluded2 = ["aria-current", "caseSensitive", "className", "end", "style", "to", "children"],
		_excluded3 = ["reloadDocument", "replace", "state", "method", "action", "onSubmit", "submit", "relative", "preventScrollReset"];
		function createBrowserRouter(routes, opts) {
		return createRouter({
		basename: opts == null ? void 0 : opts.basename,
		future: _extends({}, opts == null ? void 0 : opts.future, {
		v7_prependBasename: true
		}),
		history: createBrowserHistory({
		window: opts == null ? void 0 : opts.window
		}),
		hydrationData: (opts == null ? void 0 : opts.hydrationData) \|\| parseHydrationData(),
		routes,
		mapRouteProperties: UNSAFE_mapRouteProperties
		}).initialize();
		}
		function createHashRouter(routes, opts) {
		return createRouter({
		basename: opts == null ? void 0 : opts.basename,
		future: _extends({}, opts == null ? void 0 : opts.future, {
		v7_prependBasename: true
		}),
		history: createHashHistory({
		window: opts == null ? void 0 : opts.window
		}),
		hydrationData: (opts == null ? void 0 : opts.hydrationData) \|\| parseHydrationData(),
		routes,
		mapRouteProperties: UNSAFE_mapRouteProperties
		}).initialize();
		}
		function parseHydrationData() {
		var _window;
		let state = (_window = window) == null ? void 0 : _window.__staticRouterHydrationData;
		if (state && state.errors) {
		state = _extends({}, state, {
		errors: deserializeErrors(state.errors)
		});
		}
		return state;
		}
		function deserializeErrors(errors) {
		if (!errors) return null;
		let entries = Object.entries(errors);
		let serialized = {};
		for (let [key, val] of entries) {
		// Hey you! If you change this, please change the corresponding logic in
		// serializeErrors in react-router-dom/server.tsx :)
		if (val && val.__type === "RouteErrorResponse") {
		serialized[key] = new ErrorResponse(val.status, val.statusText, val.data, val.internal === true);
		} else if (val && val.__type === "Error") {
		// Attempt to reconstruct the right type of Error (i.e., ReferenceError)
		if (val.__subType) {
		let ErrorConstructor = window[val.__subType];
		if (typeof ErrorConstructor === "function") {
		try {
		// @ts-expect-error
		let error = new ErrorConstructor(val.message);
		// Wipe away the client-side stack trace. Nothing to fill it in with
		// because we don't serialize SSR stack traces for security reasons
		error.stack = "";
		serialized[key] = error;
		} catch (e) {
		// no-op - fall through and create a normal Error
		}
		}
		}
		if (serialized[key] == null) {
		let error = new Error(val.message);
		// Wipe away the client-side stack trace. Nothing to fill it in with
		// because we don't serialize SSR stack traces for security reasons
		error.stack = "";
		serialized[key] = error;
		}
		} else {
		serialized[key] = val;
		}
		}
		return serialized;
		}
		//#endregion
		////////////////////////////////////////////////////////////////////////////////
		//#region Components
		////////////////////////////////////////////////////////////////////////////////
		/**
		Webpack + React 17 fails to compile on any of the following because webpack
		complains that `startTransition` doesn't exist in `React`:
		* import { startTransition } from "react"
		* import * as React from from "react";
		"startTransition" in React ? React.startTransition(() => setState()) : setState()
		* import * as React from from "react";
		"startTransition" in React ? React["startTransition"](() => setState()) : setState()

		Moving it to a constant such as the following solves the Webpack/React 17 issue:
		* import * as React from from "react";
		const START_TRANSITION = "startTransition";
		START_TRANSITION in React ? React[START_TRANSITION](() => setState()) : setState()

		However, that introduces webpack/terser minification issues in production builds
		in React 18 where minification/obfuscation ends up removing the call of
		React.startTransition entirely from the first half of the ternary. Grabbing
		this exported reference once up front resolves that issue.

		See https://github.com/remix-run/react-router/issues/10579
		*/
		const START_TRANSITION = "startTransition";
		const startTransitionImpl = React[START_TRANSITION];
		/**
		* A `<Router>` for use in web browsers. Provides the cleanest URLs.
		*/
		function BrowserRouter(_ref) {
		let {
		basename,
		children,
		future,
		window
		} = _ref;
		let historyRef = React.useRef();
		if (historyRef.current == null) {
		historyRef.current = createBrowserHistory({
		window,
		v5Compat: true
		});
		}
		let history = historyRef.current;
		let [state, setStateImpl] = React.useState({
		action: history.action,
		location: history.location
		});
		let {
		v7_startTransition
		} = future \|\| {};
		let setState = React.useCallback(newState => {
		v7_startTransition && startTransitionImpl ? startTransitionImpl(() => setStateImpl(newState)) : setStateImpl(newState);
		}, [setStateImpl, v7_startTransition]);
		React.useLayoutEffect(() => history.listen(setState), [history, setState]);
		return /#__PURE__/React.createElement(Router, {
		basename: basename,
		children: children,
		location: state.location,
		navigationType: state.action,
		navigator: history
		});
		}
		/**
		* A `<Router>` for use in web browsers. Stores the location in the hash
		* portion of the URL so it is not sent to the server.
		*/
		function HashRouter(_ref2) {
		let {
		basename,
		children,
		future,
		window
		} = _ref2;
		let historyRef = React.useRef();
		if (historyRef.current == null) {
		historyRef.current = createHashHistory({
		window,
		v5Compat: true
		});
		}
		let history = historyRef.current;
		let [state, setStateImpl] = React.useState({
		action: history.action,
		location: history.location
		});
		let {
		v7_startTransition
		} = future \|\| {};
		let setState = React.useCallback(newState => {
		v7_startTransition && startTransitionImpl ? startTransitionImpl(() => setStateImpl(newState)) : setStateImpl(newState);
		}, [setStateImpl, v7_startTransition]);
		React.useLayoutEffect(() => history.listen(setState), [history, setState]);
		return /#__PURE__/React.createElement(Router, {
		basename: basename,
		children: children,
		location: state.location,
		navigationType: state.action,
		navigator: history
		});
		}
		/**
		* A `<Router>` that accepts a pre-instantiated history object. It's important
		* to note that using your own history object is highly discouraged and may add
		* two versions of the history library to your bundles unless you use the same
		* version of the history library that React Router uses internally.
		*/
		function HistoryRouter(_ref3) {
		let {
		basename,
		children,
		future,
		history
		} = _ref3;
		let [state, setStateImpl] = React.useState({
		action: history.action,
		location: history.location
		});
		let {
		v7_startTransition
		} = future \|\| {};
		let setState = React.useCallback(newState => {
		v7_startTransition && startTransitionImpl ? startTransitionImpl(() => setStateImpl(newState)) : setStateImpl(newState);
		}, [setStateImpl, v7_startTransition]);
		React.useLayoutEffect(() => history.listen(setState), [history, setState]);
		return /#__PURE__/React.createElement(Router, {
		basename: basename,
		children: children,
		location: state.location,
		navigationType: state.action,
		navigator: history
		});
		}
		if (process.env.NODE_ENV !== "production") {
		HistoryRouter.displayName = "unstable_HistoryRouter";
		}
		const isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined";
		const ABSOLUTE_URL_REGEX = /^(?:[a-z][a-z0-9+.-]*:\|\/\/)/i;
		/**
		* The public API for rendering a history-aware <a>.
		*/
		const Link = /#__PURE__/React.forwardRef(function LinkWithRef(_ref4, ref) {
		let {
		onClick,
		relative,
		reloadDocument,
		replace,
		state,
		target,
		to,
		preventScrollReset
		} = _ref4,
		rest = _objectWithoutPropertiesLoose(_ref4, _excluded);
		let {
		basename
		} = React.useContext(UNSAFE_NavigationContext);
		// Rendered into <a href> for absolute URLs
		let absoluteHref;
		let isExternal = false;
		if (typeof to === "string" && ABSOLUTE_URL_REGEX.test(to)) {
		// Render the absolute href server- and client-side
		absoluteHref = to;
		// Only check for external origins client-side
		if (isBrowser) {
		try {
		let currentUrl = new URL(window.location.href);
		let targetUrl = to.startsWith("//") ? new URL(currentUrl.protocol + to) : 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 (e) {
		// We can't do external URL detection without a valid URL
		process.env.NODE_ENV !== "production" ? UNSAFE_warning(false, "<Link to=\"" + to + "\"> contains an invalid URL which will probably break " + "when clicked - please update to a valid URL path.") : void 0;
		}
		}
		}
		// Rendered into <a href> for relative URLs
		let href = useHref(to, {
		relative
		});
		let internalOnClick = useLinkClickHandler(to, {
		replace,
		state,
		target,
		preventScrollReset,
		relative
		});
		function handleClick(event) {
		if (onClick) onClick(event);
		if (!event.defaultPrevented) {
		internalOnClick(event);
		}
		}
		return (
		/#__PURE__/
		// eslint-disable-next-line jsx-a11y/anchor-has-content
		React.createElement("a", _extends({}, rest, {
		href: absoluteHref \|\| href,
		onClick: isExternal \|\| reloadDocument ? onClick : handleClick,
		ref: ref,
		target: target
		}))
		);
		// index.ts
		var react_router_dom_exports = {};
		__export(react_router_dom_exports, {
		HydratedRouter: () => import_dom.HydratedRouter,
		RouterProvider: () => import_dom.RouterProvider
		});
		if (process.env.NODE_ENV !== "production") {
		Link.displayName = "Link";
		}
		/**
		* A <Link> wrapper that knows if it's "active" or not.
		*/
		const NavLink = /#__PURE__/React.forwardRef(function NavLinkWithRef(_ref5, ref) {
		let {
		"aria-current": ariaCurrentProp = "page",
		caseSensitive = false,
		className: classNameProp = "",
		end = false,
		style: styleProp,
		to,
		children
		} = _ref5,
		rest = _objectWithoutPropertiesLoose(_ref5, _excluded2);
		let path = useResolvedPath(to, {
		relative: rest.relative
		});
		let location = useLocation();
		let routerState = React.useContext(UNSAFE_DataRouterStateContext);
		let {
		navigator
		} = React.useContext(UNSAFE_NavigationContext);
		let toPathname = navigator.encodeLocation ? navigator.encodeLocation(path).pathname : path.pathname;
		let locationPathname = location.pathname;
		let nextLocationPathname = routerState && routerState.navigation && routerState.navigation.location ? routerState.navigation.location.pathname : null;
		if (!caseSensitive) {
		locationPathname = locationPathname.toLowerCase();
		nextLocationPathname = nextLocationPathname ? nextLocationPathname.toLowerCase() : null;
		toPathname = toPathname.toLowerCase();
		}
		let isActive = locationPathname === toPathname \|\| !end && locationPathname.startsWith(toPathname) && locationPathname.charAt(toPathname.length) === "/";
		let isPending = nextLocationPathname != null && (nextLocationPathname === toPathname \|\| !end && nextLocationPathname.startsWith(toPathname) && nextLocationPathname.charAt(toPathname.length) === "/");
		let ariaCurrent = isActive ? ariaCurrentProp : undefined;
		let className;
		if (typeof classNameProp === "function") {
		className = classNameProp({
		isActive,
		isPending
		});
		} else {
		// If the className prop is not a function, we use a default `active`
		// class for <NavLink />s that are active. In v5 `active` was the default
		// value for `activeClassName`, but we are removing that API and can still
		// use the old default behavior for a cleaner upgrade path and keep the
		// simple styling rules working as they currently do.
		className = [classNameProp, isActive ? "active" : null, isPending ? "pending" : null].filter(Boolean).join(" ");
		}
		let style = typeof styleProp === "function" ? styleProp({
		isActive,
		isPending
		}) : styleProp;
		return /#__PURE__/React.createElement(Link, _extends({}, rest, {
		"aria-current": ariaCurrent,
		className: className,
		ref: ref,
		style: style,
		to: to
		}), typeof children === "function" ? children({
		isActive,
		isPending
		}) : children);
		module.exports = __toCommonJS(react_router_dom_exports);
		var import_dom = require("react-router/dom");
		__reExport(react_router_dom_exports, require("react-router"), module.exports);
		// Annotate the CommonJS export names for ESM import in node:
		0 && (module.exports = {
		HydratedRouter,
		RouterProvider,
		...require("react-router")
		});
		if (process.env.NODE_ENV !== "production") {
		NavLink.displayName = "NavLink";
		}
		/**
		* A `@remix-run/router`-aware `<form>`. It behaves like a normal form except
		* that the interaction with the server is with `fetch` instead of new document
		* requests, allowing components to add nicer UX to the page as the form is
		* submitted and returns with data.
		*/
		const Form = /#__PURE__/React.forwardRef((props, ref) => {
		let submit = useSubmit();
		return /#__PURE__/React.createElement(FormImpl, _extends({}, props, {
		submit: submit,
		ref: ref
		}));
		});
		if (process.env.NODE_ENV !== "production") {
		Form.displayName = "Form";
		}
		const FormImpl = /#__PURE__/React.forwardRef((_ref6, forwardedRef) => {
		let {
		reloadDocument,
		replace,
		state,
		method = defaultMethod,
		action,
		onSubmit,
		submit,
		relative,
		preventScrollReset
		} = _ref6,
		props = _objectWithoutPropertiesLoose(_ref6, _excluded3);
		let formMethod = method.toLowerCase() === "get" ? "get" : "post";
		let formAction = useFormAction(action, {
		relative
		});
		let submitHandler = event => {
		onSubmit && onSubmit(event);
		if (event.defaultPrevented) return;
		event.preventDefault();
		let submitter = event.nativeEvent.submitter;
		let submitMethod = (submitter == null ? void 0 : submitter.getAttribute("formmethod")) \|\| method;
		submit(submitter \|\| event.currentTarget, {
		method: submitMethod,
		replace,
		state,
		relative,
		preventScrollReset
		});
		};
		return /#__PURE__/React.createElement("form", _extends({
		ref: forwardedRef,
		method: formMethod,
		action: formAction,
		onSubmit: reloadDocument ? onSubmit : submitHandler
		}, props));
		});
		if (process.env.NODE_ENV !== "production") {
		FormImpl.displayName = "FormImpl";
		}
		/**
		* This component will emulate the browser's scroll restoration on location
		* changes.
		*/
		function ScrollRestoration(_ref7) {
		let {
		getKey,
		storageKey
		} = _ref7;
		useScrollRestoration({
		getKey,
		storageKey
		});
		return null;
		}
		if (process.env.NODE_ENV !== "production") {
		ScrollRestoration.displayName = "ScrollRestoration";
		}
		//#endregion
		////////////////////////////////////////////////////////////////////////////////
		//#region Hooks
		////////////////////////////////////////////////////////////////////////////////
		var DataRouterHook;
		(function (DataRouterHook) {
		DataRouterHook["UseScrollRestoration"] = "useScrollRestoration";
		DataRouterHook["UseSubmit"] = "useSubmit";
		DataRouterHook["UseSubmitFetcher"] = "useSubmitFetcher";
		DataRouterHook["UseFetcher"] = "useFetcher";
		})(DataRouterHook \|\| (DataRouterHook = {}));
		var DataRouterStateHook;
		(function (DataRouterStateHook) {
		DataRouterStateHook["UseFetchers"] = "useFetchers";
		DataRouterStateHook["UseScrollRestoration"] = "useScrollRestoration";
		})(DataRouterStateHook \|\| (DataRouterStateHook = {}));
		function getDataRouterConsoleError(hookName) {
		return hookName + " must be used within a data router. See https://reactrouter.com/routers/picking-a-router.";
		}
		function useDataRouterContext(hookName) {
		let ctx = React.useContext(UNSAFE_DataRouterContext);
		!ctx ? process.env.NODE_ENV !== "production" ? UNSAFE_invariant(false, getDataRouterConsoleError(hookName)) : UNSAFE_invariant(false) : void 0;
		return ctx;
		}
		function useDataRouterState(hookName) {
		let state = React.useContext(UNSAFE_DataRouterStateContext);
		!state ? process.env.NODE_ENV !== "production" ? UNSAFE_invariant(false, getDataRouterConsoleError(hookName)) : UNSAFE_invariant(false) : void 0;
		return state;
		}
		/**
		* Handles the click behavior for router `<Link>` components. This is useful if
		* you need to create custom `<Link>` components with the same click behavior we
		* use in our exported `<Link>`.
		*/
		function useLinkClickHandler(to, _temp) {
		let {
		target,
		replace: replaceProp,
		state,
		preventScrollReset,
		relative
		} = _temp === void 0 ? {} : _temp;
		let navigate = useNavigate();
		let location = useLocation();
		let path = useResolvedPath(to, {
		relative
		});
		return React.useCallback(event => {
		if (shouldProcessLinkClick(event, target)) {
		event.preventDefault();
		// If the URL hasn't changed, a regular <a> will do a replace instead of
		// a push, so do the same here unless the replace prop is explicitly set
		let replace = replaceProp !== undefined ? replaceProp : createPath(location) === createPath(path);
		navigate(to, {
		replace,
		state,
		preventScrollReset,
		relative
		});
		}
		}, [location, navigate, path, replaceProp, state, target, to, preventScrollReset, relative]);
		}
		/**
		* A convenient wrapper for reading and writing search parameters via the
		* URLSearchParams interface.
		*/
		function useSearchParams(defaultInit) {
		process.env.NODE_ENV !== "production" ? UNSAFE_warning(typeof URLSearchParams !== "undefined", "You cannot use the `useSearchParams` hook in a browser that does not " + "support the URLSearchParams API. If you need to support Internet " + "Explorer 11, we recommend you load a polyfill such as " + "https://github.com/ungap/url-search-params\n\n" + "If you're unsure how to load polyfills, we recommend you check out " + "https://polyfill.io/v3/ which provides some recommendations about how " + "to load polyfills only for users that need them, instead of for every " + "user.") : void 0;
		let defaultSearchParamsRef = React.useRef(createSearchParams(defaultInit));
		let hasSetSearchParamsRef = React.useRef(false);
		let location = useLocation();
		let searchParams = React.useMemo(() =>
		// Only merge in the defaults if we haven't yet called setSearchParams.
		// Once we call that we want those to take precedence, otherwise you can't
		// remove a param with setSearchParams({}) if it has an initial value
		getSearchParamsForLocation(location.search, hasSetSearchParamsRef.current ? null : defaultSearchParamsRef.current), [location.search]);
		let navigate = useNavigate();
		let setSearchParams = React.useCallback((nextInit, navigateOptions) => {
		const newSearchParams = createSearchParams(typeof nextInit === "function" ? nextInit(searchParams) : nextInit);
		hasSetSearchParamsRef.current = true;
		navigate("?" + newSearchParams, navigateOptions);
		}, [navigate, searchParams]);
		return [searchParams, setSearchParams];
		}
		function validateClientSideSubmission() {
		if (typeof document === "undefined") {
		throw new Error("You are calling submit during the server render. " + "Try calling submit within a `useEffect` or callback instead.");
		}
		}
		/**
		* Returns a function that may be used to programmatically submit a form (or
		* some arbitrary data) to the server.
		*/
		function useSubmit() {
		let {
		router
		} = useDataRouterContext(DataRouterHook.UseSubmit);
		let {
		basename
		} = React.useContext(UNSAFE_NavigationContext);
		let currentRouteId = UNSAFE_useRouteId();
		return React.useCallback(function (target, options) {
		if (options === void 0) {
		options = {};
		}
		validateClientSideSubmission();
		let {
		action,
		method,
		encType,
		formData,
		body
		} = getFormSubmissionInfo(target, basename);
		router.navigate(options.action \|\| action, {
		preventScrollReset: options.preventScrollReset,
		formData,
		body,
		formMethod: options.method \|\| method,
		formEncType: options.encType \|\| encType,
		replace: options.replace,
		state: options.state,
		fromRouteId: currentRouteId
		});
		}, [router, basename, currentRouteId]);
		}
		/**
		* Returns the implementation for fetcher.submit
		*/
		function useSubmitFetcher(fetcherKey, fetcherRouteId) {
		let {
		router
		} = useDataRouterContext(DataRouterHook.UseSubmitFetcher);
		let {
		basename
		} = React.useContext(UNSAFE_NavigationContext);
		return React.useCallback(function (target, options) {
		if (options === void 0) {
		options = {};
		}
		validateClientSideSubmission();
		let {
		action,
		method,
		encType,
		formData,
		body
		} = getFormSubmissionInfo(target, basename);
		!(fetcherRouteId != null) ? process.env.NODE_ENV !== "production" ? UNSAFE_invariant(false, "No routeId available for useFetcher()") : UNSAFE_invariant(false) : void 0;
		router.fetch(fetcherKey, fetcherRouteId, options.action \|\| action, {
		preventScrollReset: options.preventScrollReset,
		formData,
		body,
		formMethod: options.method \|\| method,
		formEncType: options.encType \|\| encType
		});
		}, [router, basename, fetcherKey, fetcherRouteId]);
		}
		// v7: Eventually we should deprecate this entirely in favor of using the
		// router method directly?
		function useFormAction(action, _temp2) {
		let {
		relative
		} = _temp2 === void 0 ? {} : _temp2;
		let {
		basename
		} = React.useContext(UNSAFE_NavigationContext);
		let routeContext = React.useContext(UNSAFE_RouteContext);
		!routeContext ? process.env.NODE_ENV !== "production" ? UNSAFE_invariant(false, "useFormAction must be used inside a RouteContext") : UNSAFE_invariant(false) : void 0;
		let [match] = routeContext.matches.slice(-1);
		// Shallow clone path so we can modify it below, otherwise we modify the
		// object referenced by useMemo inside useResolvedPath
		let path = _extends({}, useResolvedPath(action ? action : ".", {
		relative
		}));
		// Previously we set the default action to ".". The problem with this is that
		// `useResolvedPath(".")` excludes search params of the resolved URL. This is
		// the intended behavior of when "." is specifically provided as
		// the form action, but inconsistent w/ browsers when the action is omitted.
		// https://github.com/remix-run/remix/issues/927
		let location = useLocation();
		if (action == null) {
		// Safe to write to this directly here since if action was undefined, we
		// would have called useResolvedPath(".") which will never include a search
		path.search = location.search;
		// When grabbing search params from the URL, remove the automatically
		// inserted ?index param so we match the useResolvedPath search behavior
		// which would not include ?index
		if (match.route.index) {
		let params = new URLSearchParams(path.search);
		params.delete("index");
		path.search = params.toString() ? "?" + params.toString() : "";
		}
		}
		if ((!action \|\| action === ".") && match.route.index) {
		path.search = path.search ? path.search.replace(/^\?/, "?index&") : "?index";
		}
		// If we're operating within a basename, prepend it to the pathname prior
		// to creating the form action. 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
		if (basename !== "/") {
		path.pathname = path.pathname === "/" ? basename : joinPaths([basename, path.pathname]);
		}
		return createPath(path);
		}
		function createFetcherForm(fetcherKey, routeId) {
		let FetcherForm = /#__PURE__/React.forwardRef((props, ref) => {
		let submit = useSubmitFetcher(fetcherKey, routeId);
		return /#__PURE__/React.createElement(FormImpl, _extends({}, props, {
		ref: ref,
		submit: submit
		}));
		});
		if (process.env.NODE_ENV !== "production") {
		FetcherForm.displayName = "fetcher.Form";
		}
		return FetcherForm;
		}
		let fetcherId = 0;
		/**
		* Interacts with route loaders and actions without causing a navigation. Great
		* for any interaction that stays on the same page.
		*/
		function useFetcher() {
		var _route$matches;
		let {
		router
		} = useDataRouterContext(DataRouterHook.UseFetcher);
		let route = React.useContext(UNSAFE_RouteContext);
		!route ? process.env.NODE_ENV !== "production" ? UNSAFE_invariant(false, "useFetcher must be used inside a RouteContext") : UNSAFE_invariant(false) : void 0;
		let routeId = (_route$matches = route.matches[route.matches.length - 1]) == null ? void 0 : _route$matches.route.id;
		!(routeId != null) ? process.env.NODE_ENV !== "production" ? UNSAFE_invariant(false, "useFetcher can only be used on routes that contain a unique \"id\"") : UNSAFE_invariant(false) : void 0;
		let [fetcherKey] = React.useState(() => String(++fetcherId));
		let [Form] = React.useState(() => {
		!routeId ? process.env.NODE_ENV !== "production" ? UNSAFE_invariant(false, "No routeId available for fetcher.Form()") : UNSAFE_invariant(false) : void 0;
		return createFetcherForm(fetcherKey, routeId);
		});
		let [load] = React.useState(() => href => {
		!router ? process.env.NODE_ENV !== "production" ? UNSAFE_invariant(false, "No router available for fetcher.load()") : UNSAFE_invariant(false) : void 0;
		!routeId ? process.env.NODE_ENV !== "production" ? UNSAFE_invariant(false, "No routeId available for fetcher.load()") : UNSAFE_invariant(false) : void 0;
		router.fetch(fetcherKey, routeId, href);
		});
		let submit = useSubmitFetcher(fetcherKey, routeId);
		let fetcher = router.getFetcher(fetcherKey);
		let fetcherWithComponents = React.useMemo(() => _extends({
		Form,
		submit,
		load
		}, fetcher), [fetcher, Form, submit, load]);
		React.useEffect(() => {
		// Is this busted when the React team gets real weird and calls effects
		// twice on mount? We really just need to garbage collect here when this
		// fetcher is no longer around.
		return () => {
		if (!router) {
		console.warn("No router available to clean up from useFetcher()");
		return;
		}
		router.deleteFetcher(fetcherKey);
		};
		}, [router, fetcherKey]);
		return fetcherWithComponents;
		}
		/**
		* Provides all fetchers currently on the page. Useful for layouts and parent
		* routes that need to provide pending/optimistic UI regarding the fetch.
		*/
		function useFetchers() {
		let state = useDataRouterState(DataRouterStateHook.UseFetchers);
		return [...state.fetchers.values()];
		}
		const SCROLL_RESTORATION_STORAGE_KEY = "react-router-scroll-positions";
		let savedScrollPositions = {};
		/**
		* When rendered inside a RouterProvider, will restore scroll positions on navigations
		*/
		function useScrollRestoration(_temp3) {
		let {
		getKey,
		storageKey
		} = _temp3 === void 0 ? {} : _temp3;
		let {
		router
		} = useDataRouterContext(DataRouterHook.UseScrollRestoration);
		let {
		restoreScrollPosition,
		preventScrollReset
		} = useDataRouterState(DataRouterStateHook.UseScrollRestoration);
		let {
		basename
		} = React.useContext(UNSAFE_NavigationContext);
		let location = useLocation();
		let matches = useMatches();
		let navigation = useNavigation();
		// Trigger manual scroll restoration while we're active
		React.useEffect(() => {
		window.history.scrollRestoration = "manual";
		return () => {
		window.history.scrollRestoration = "auto";
		};
		}, []);
		// Save positions on pagehide
		usePageHide(React.useCallback(() => {
		if (navigation.state === "idle") {
		let key = (getKey ? getKey(location, matches) : null) \|\| location.key;
		savedScrollPositions[key] = window.scrollY;
		}
		sessionStorage.setItem(storageKey \|\| SCROLL_RESTORATION_STORAGE_KEY, JSON.stringify(savedScrollPositions));
		window.history.scrollRestoration = "auto";
		}, [storageKey, getKey, navigation.state, location, matches]));
		// Read in any saved scroll locations
		if (typeof document !== "undefined") {
		// eslint-disable-next-line react-hooks/rules-of-hooks
		React.useLayoutEffect(() => {
		try {
		let sessionPositions = sessionStorage.getItem(storageKey \|\| SCROLL_RESTORATION_STORAGE_KEY);
		if (sessionPositions) {
		savedScrollPositions = JSON.parse(sessionPositions);
		}
		} catch (e) {
		// no-op, use default empty object
		}
		}, [storageKey]);
		// Enable scroll restoration in the router
		// eslint-disable-next-line react-hooks/rules-of-hooks
		React.useLayoutEffect(() => {
		let getKeyWithoutBasename = getKey && basename !== "/" ? (location, matches) => getKey( // Strip the basename to match useLocation()
		_extends({}, location, {
		pathname: stripBasename(location.pathname, basename) \|\| location.pathname
		}), matches) : getKey;
		let disableScrollRestoration = router == null ? void 0 : router.enableScrollRestoration(savedScrollPositions, () => window.scrollY, getKeyWithoutBasename);
		return () => disableScrollRestoration && disableScrollRestoration();
		}, [router, basename, getKey]);
		// Restore scrolling when state.restoreScrollPosition changes
		// eslint-disable-next-line react-hooks/rules-of-hooks
		React.useLayoutEffect(() => {
		// Explicit false means don't do anything (used for submissions)
		if (restoreScrollPosition === false) {
		return;
		}
		// been here before, scroll to it
		if (typeof restoreScrollPosition === "number") {
		window.scrollTo(0, restoreScrollPosition);
		return;
		}
		// try to scroll to the hash
		if (location.hash) {
		let el = document.getElementById(decodeURIComponent(location.hash.slice(1)));
		if (el) {
		el.scrollIntoView();
		return;
		}
		}
		// Don't reset if this navigation opted out
		if (preventScrollReset === true) {
		return;
		}
		// otherwise go to the top on new locations
		window.scrollTo(0, 0);
		}, [location, restoreScrollPosition, preventScrollReset]);
		}
		}
		/**
		* Setup a callback to be fired on the window's `beforeunload` event. This is
		* useful for saving some data to `window.localStorage` just before the page
		* refreshes.
		*
		* Note: The `callback` argument should be a function created with
		* `React.useCallback()`.
		*/
		function useBeforeUnload(callback, options) {
		let {
		capture
		} = options \|\| {};
		React.useEffect(() => {
		let opts = capture != null ? {
		capture
		} : undefined;
		window.addEventListener("beforeunload", callback, opts);
		return () => {
		window.removeEventListener("beforeunload", callback, opts);
		};
		}, [callback, capture]);
		}
		/**
		* Setup a callback to be fired on the window's `pagehide` event. This is
		* useful for saving some data to `window.localStorage` just before the page
		* refreshes. This event is better supported than beforeunload across browsers.
		*
		* Note: The `callback` argument should be a function created with
		* `React.useCallback()`.
		*/
		function usePageHide(callback, options) {
		let {
		capture
		} = options \|\| {};
		React.useEffect(() => {
		let opts = capture != null ? {
		capture
		} : undefined;
		window.addEventListener("pagehide", callback, opts);
		return () => {
		window.removeEventListener("pagehide", callback, opts);
		};
		}, [callback, capture]);
		}
		/**
		* Wrapper around useBlocker to show a window.confirm prompt to users instead
		* of building a custom UI with useBlocker.
		*
		* Warning: This has a lot of rough edges and behaves very differently (and
		* very incorrectly in some cases) across browsers if user click addition
		* back/forward navigations while the confirm is open. Use at your own risk.
		*/
		function usePrompt(_ref8) {
		let {
		when,
		message
		} = _ref8;
		let blocker = unstable_useBlocker(when);
		React.useEffect(() => {
		if (blocker.state === "blocked") {
		let proceed = window.confirm(message);
		if (proceed) {
		// This timeout is needed to avoid a weird "race" on POP navigations
		// between the `window.history` revert navigation and the result of
		// `window.confirm`
		setTimeout(blocker.proceed, 0);
		} else {
		blocker.reset();
		}
		}
		}, [blocker, message]);
		React.useEffect(() => {
		if (blocker.state === "blocked" && !when) {
		blocker.reset();
		}
		}, [blocker, when]);
		}
		//#endregion

		export { BrowserRouter, Form, HashRouter, Link, NavLink, ScrollRestoration, useScrollRestoration as UNSAFE_useScrollRestoration, createBrowserRouter, createHashRouter, createSearchParams, HistoryRouter as unstable_HistoryRouter, usePrompt as unstable_usePrompt, useBeforeUnload, useFetcher, useFetchers, useFormAction, useLinkClickHandler, useSearchParams, useSubmit };
		//# sourceMappingURL=index.js.map

package.json

		{
		"name": "react-router-dom",
		"version": "0.0.0-experimental-b8437806",
		"version": "0.0.0-experimental-b98209dd9",
		"description": "Declarative routing for React web applications",
		@@ -23,28 +23,60 @@ "keywords": [
		"unpkg": "./dist/umd/react-router-dom.production.min.js",
		"module": "./dist/index.js",
		"module": "./dist/index.mjs",
		"types": "./dist/index.d.ts",
		"exports": {
		".": {
		"node": {
		"types": "./dist/index.d.ts",
		"module-sync": "./dist/index.mjs",
		"default": "./dist/index.js"
		},
		"import": {
		"types": "./dist/index.d.mts",
		"default": "./dist/index.mjs"
		},
		"default": {
		"types": "./dist/index.d.ts",
		"default": "./dist/index.js"
		}
		},
		"./package.json": "./package.json"
		},
		"wireit": {
		"build": {
		"command": "tsup",
		"files": [
		"*.ts",
		"tsconfig.json",
		"package.json"
		],
		"output": [
		"dist/**"
		]
		}
		},
		"dependencies": {
		"@remix-run/router": "0.0.0-experimental-b8437806",
		"react-router": "0.0.0-experimental-b8437806"
		"react-router": "0.0.0-experimental-b98209dd9"
		},
		"devDependencies": {
		"react": "^18.2.0",
		"react-dom": "^18.2.0"
		"react-dom": "^18.2.0",
		"tsup": "^8.3.0",
		"typescript": "^5.1.6",
		"wireit": "0.14.9"
		},
		"peerDependencies": {
		"react": ">=16.8",
		"react-dom": ">=16.8"
		"react": ">=18",
		"react-dom": ">=18"
		},
		"files": [
		"dist/",
		"CHANGELOG.md",
		"LICENSE.md",
		"README.md",
		"server.d.ts",
		"server.js",
		"server.mjs"
		"README.md"
		],
		"engines": {
		"node": ">=14.0.0"
		"node": ">=20.0.0"
		},
		"scripts": {
		"build": "wireit"
		}
		}
		}

README.md

		@@ -1,5 +0,6 @@
		# React Router DOM
		This package simply re-exports everything from `react-router` to smooth the upgrade path for v6 applications. Once upgraded you can change all of your imports and remove it from your dependencies:

		The `react-router-dom` package contains bindings for using [React
		Router](https://github.com/remix-run/react-router) in web applications.
		Please see [the Getting Started guide](https://reactrouter.com/en/main/start/tutorial) for more information on how to get started with React Router.
		```diff
		-import { Routes } from "react-router-dom"
		+import { Routes } from "react-router"
		```

CHANGELOG.md

dist/dom.d.ts

dist/index.js.map

dist/main.js

dist/react-router-dom.development.js

dist/react-router-dom.development.js.map

dist/react-router-dom.production.min.js

dist/react-router-dom.production.min.js.map

dist/server.d.ts

dist/server.js

dist/server.mjs

dist/umd/react-router-dom.development.js

dist/umd/react-router-dom.development.js.map

dist/umd/react-router-dom.production.min.js

dist/umd/react-router-dom.production.min.js.map

server.d.ts

server.js

server.mjs

react-router-dom - npm Package Compare versions

New alerts

Fixed alerts

Improved metrics

Worsened metrics

Dependency changes