Diffusion Open Access Compliance Check Tool (OACCT) (paginated-inlines) Browse

rOACCT/node_modules/react-router/dist/react-router.development.js
f646e1f695a7paginated-inlines

react-router.development.js
View Options

			/**
			* React Router v6.6.1
			*
			* Copyright (c) Remix Software Inc.
			*
			* This source code is licensed under the MIT license found in the
			* LICENSE.md file in the root directory of this source tree.
			*
			* @license MIT
			*/
			import { invariant, joinPaths, matchPath, UNSAFE_getPathContributingMatches, warning, resolveTo, parsePath, matchRoutes, Action, isRouteErrorResponse, createMemoryHistory, stripBasename, AbortedDeferredError, createRouter } from '@remix-run/router';
			export { AbortedDeferredError, Action as NavigationType, createPath, defer, generatePath, isRouteErrorResponse, json, matchPath, matchRoutes, parsePath, redirect, resolvePath } from '@remix-run/router';
			import * as React from 'react';

			/**
			* Copyright (c) Facebook, Inc. and its affiliates.
			*
			* This source code is licensed under the MIT license found in the
			* LICENSE file in the root directory of this source tree.
			*/
			/**
			* inlined Object.is polyfill to avoid requiring consumers ship their own
			* https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
			*/

			function isPolyfill(x, y) {
			return x === y && (x !== 0 \|\| 1 / x === 1 / y) \|\| x !== x && y !== y // eslint-disable-line no-self-compare
			;
			}

			const is = typeof Object.is === "function" ? Object.is : isPolyfill; // Intentionally not using named imports because Rollup uses dynamic
			// dispatch for CommonJS interop named imports.

			const {
			useState,
			useEffect,
			useLayoutEffect,
			useDebugValue
			} = React;
			let didWarnOld18Alpha = false;
			let didWarnUncachedGetSnapshot = false; // Disclaimer: This shim breaks many of the rules of React, and only works
			// because of a very particular set of implementation details and assumptions
			// -- change any one of them and it will break. The most important assumption
			// is that updates are always synchronous, because concurrent rendering is
			// only available in versions of React that also have a built-in
			// useSyncExternalStore API. And we only use this shim when the built-in API
			// does not exist.
			//
			// Do not assume that the clever hacks used by this hook also work in general.
			// The point of this shim is to replace the need for hacks by other libraries.

			function useSyncExternalStore$2(subscribe, getSnapshot, // Note: The shim does not use getServerSnapshot, because pre-18 versions of
			// React do not expose a way to check if we're hydrating. So users of the shim
			// will need to track that themselves and return the correct value
			// from `getSnapshot`.
			getServerSnapshot) {
			{
			if (!didWarnOld18Alpha) {
			if ("startTransition" in React) {
			didWarnOld18Alpha = true;
			console.error("You are using an outdated, pre-release alpha of React 18 that " + "does not support useSyncExternalStore. The " + "use-sync-external-store shim will not work correctly. Upgrade " + "to a newer pre-release.");
			}
			}
			} // Read the current snapshot from the store on every render. Again, this
			// breaks the rules of React, and only works here because of specific
			// implementation details, most importantly that updates are
			// always synchronous.


			const value = getSnapshot();

			{
			if (!didWarnUncachedGetSnapshot) {
			const cachedValue = getSnapshot();

			if (!is(value, cachedValue)) {
			console.error("The result of getSnapshot should be cached to avoid an infinite loop");
			didWarnUncachedGetSnapshot = true;
			}
			}
			} // Because updates are synchronous, we don't queue them. Instead we force a
			// re-render whenever the subscribed state changes by updating an some
			// arbitrary useState hook. Then, during render, we call getSnapshot to read
			// the current value.
			//
			// Because we don't actually use the state returned by the useState hook, we
			// can save a bit of memory by storing other stuff in that slot.
			//
			// To implement the early bailout, we need to track some things on a mutable
			// object. Usually, we would put that in a useRef hook, but we can stash it in
			// our useState hook instead.
			//
			// To force a re-render, we call forceUpdate({inst}). That works because the
			// new object always fails an equality check.


			const [{
			inst
			}, forceUpdate] = useState({
			inst: {
			value,
			getSnapshot
			}
			}); // Track the latest getSnapshot function with a ref. This needs to be updated
			// in the layout phase so we can access it during the tearing check that
			// happens on subscribe.

			useLayoutEffect(() => {
			inst.value = value;
			inst.getSnapshot = getSnapshot; // Whenever getSnapshot or subscribe changes, we need to check in the
			// commit phase if there was an interleaved mutation. In concurrent mode
			// this can happen all the time, but even in synchronous mode, an earlier
			// effect may have mutated the store.

			if (checkIfSnapshotChanged(inst)) {
			// Force a re-render.
			forceUpdate({
			inst
			});
			} // eslint-disable-next-line react-hooks/exhaustive-deps

			}, [subscribe, value, getSnapshot]);
			useEffect(() => {
			// Check for changes right before subscribing. Subsequent changes will be
			// detected in the subscription handler.
			if (checkIfSnapshotChanged(inst)) {
			// Force a re-render.
			forceUpdate({
			inst
			});
			}

			const handleStoreChange = () => {
			// TODO: Because there is no cross-renderer API for batching updates, it's
			// up to the consumer of this library to wrap their subscription event
			// with unstable_batchedUpdates. Should we try to detect when this isn't
			// the case and print a warning in development?
			// The store changed. Check if the snapshot changed since the last time we
			// read from the store.
			if (checkIfSnapshotChanged(inst)) {
			// Force a re-render.
			forceUpdate({
			inst
			});
			}
			}; // Subscribe to the store and return a clean-up function.


			return subscribe(handleStoreChange); // eslint-disable-next-line react-hooks/exhaustive-deps
			}, [subscribe]);
			useDebugValue(value);
			return value;
			}

			function checkIfSnapshotChanged(inst) {
			const latestGetSnapshot = inst.getSnapshot;
			const prevValue = inst.value;

			try {
			const nextValue = latestGetSnapshot();
			return !is(prevValue, nextValue);
			} catch (error) {
			return true;
			}
			}

			/**
			* Copyright (c) Facebook, Inc. and its affiliates.
			*
			* This source code is licensed under the MIT license found in the
			* LICENSE file in the root directory of this source tree.
			*
			* @flow
			*/
			function useSyncExternalStore$1(subscribe, getSnapshot, getServerSnapshot) {
			// Note: The shim does not use getServerSnapshot, because pre-18 versions of
			// React do not expose a way to check if we're hydrating. So users of the shim
			// will need to track that themselves and return the correct value
			// from `getSnapshot`.
			return getSnapshot();
			}

			/**
			* Inlined into the react-router repo since use-sync-external-store does not
			* provide a UMD-compatible package, so we need this to be able to distribute
			* UMD react-router bundles
			*/
			const canUseDOM = !!(typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined");
			const isServerEnvironment = !canUseDOM;
			const shim = isServerEnvironment ? useSyncExternalStore$1 : useSyncExternalStore$2;
			const useSyncExternalStore = "useSyncExternalStore" in React ? (module => module.useSyncExternalStore)(React) : shim;

			const DataStaticRouterContext = /#__PURE__/React.createContext(null);

			{
			DataStaticRouterContext.displayName = "DataStaticRouterContext";
			}

			const DataRouterContext = /#__PURE__/React.createContext(null);

			{
			DataRouterContext.displayName = "DataRouter";
			}

			const DataRouterStateContext = /#__PURE__/React.createContext(null);

			{
			DataRouterStateContext.displayName = "DataRouterState";
			}

			const AwaitContext = /#__PURE__/React.createContext(null);

			{
			AwaitContext.displayName = "Await";
			}

			const NavigationContext = /#__PURE__/React.createContext(null);

			{
			NavigationContext.displayName = "Navigation";
			}

			const LocationContext = /#__PURE__/React.createContext(null);

			{
			LocationContext.displayName = "Location";
			}

			const RouteContext = /#__PURE__/React.createContext({
			outlet: null,
			matches: []
			});

			{
			RouteContext.displayName = "Route";
			}

			const RouteErrorContext = /#__PURE__/React.createContext(null);

			{
			RouteErrorContext.displayName = "RouteError";
			}

			/**
			* Returns the full href for the given "to" value. This is useful for building
			* custom links that are also accessible and preserve right-click behavior.
			*
			* @see https://reactrouter.com/hooks/use-href
			*/

			function useHref(to, {
			relative
			} = {}) {
			!useInRouterContext() ? invariant(false, // TODO: This error is probably because they somehow have 2 versions of the
			// router loaded. We can help them understand how to avoid that.
			`useHref() may be used only in the context of a <Router> component.`) : void 0;
			let {
			basename,
			navigator
			} = React.useContext(NavigationContext);
			let {
			hash,
			pathname,
			search
			} = useResolvedPath(to, {
			relative
			});
			let joinedPathname = pathname; // If we're operating within a basename, prepend it to the pathname prior
			// to creating the href. 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 links

			if (basename !== "/") {
			joinedPathname = pathname === "/" ? basename : joinPaths([basename, pathname]);
			}

			return navigator.createHref({
			pathname: joinedPathname,
			search,
			hash
			});
			}
			/**
			* Returns true if this component is a descendant of a <Router>.
			*
			* @see https://reactrouter.com/hooks/use-in-router-context
			*/

			function useInRouterContext() {
			return React.useContext(LocationContext) != null;
			}
			/**
			* Returns the current location object, which represents the current URL in web
			* browsers.
			*
			* Note: If you're using this it may mean you're doing some of your own
			* "routing" in your app, and we'd like to know what your use case is. We may
			* be able to provide something higher-level to better suit your needs.
			*
			* @see https://reactrouter.com/hooks/use-location
			*/

			function useLocation() {
			!useInRouterContext() ? invariant(false, // TODO: This error is probably because they somehow have 2 versions of the
			// router loaded. We can help them understand how to avoid that.
			`useLocation() may be used only in the context of a <Router> component.`) : void 0;
			return React.useContext(LocationContext).location;
			}
			/**
			* Returns the current navigation action which describes how the router came to
			* the current location, either by a pop, push, or replace on the history stack.
			*
			* @see https://reactrouter.com/hooks/use-navigation-type
			*/

			function useNavigationType() {
			return React.useContext(LocationContext).navigationType;
			}
			/**
			* Returns a PathMatch object if the given pattern matches the current URL.
			* This is useful for components that need to know "active" state, e.g.
			* <NavLink>.
			*
			* @see https://reactrouter.com/hooks/use-match
			*/

			function useMatch(pattern) {
			!useInRouterContext() ? invariant(false, // TODO: This error is probably because they somehow have 2 versions of the
			// router loaded. We can help them understand how to avoid that.
			`useMatch() may be used only in the context of a <Router> component.`) : void 0;
			let {
			pathname
			} = useLocation();
			return React.useMemo(() => matchPath(pattern, pathname), [pathname, pattern]);
			}
			/**
			* Returns an imperative method for changing the location. Used by <Link>s, but
			* may also be used by other elements to change the location.
			*
			* @see https://reactrouter.com/hooks/use-navigate
			*/

			function useNavigate() {
			!useInRouterContext() ? invariant(false, // TODO: This error is probably because they somehow have 2 versions of the
			// router loaded. We can help them understand how to avoid that.
			`useNavigate() may be used only in the context of a <Router> component.`) : void 0;
			let {
			basename,
			navigator
			} = React.useContext(NavigationContext);
			let {
			matches
			} = React.useContext(RouteContext);
			let {
			pathname: locationPathname
			} = useLocation();
			let routePathnamesJson = JSON.stringify(UNSAFE_getPathContributingMatches(matches).map(match => match.pathnameBase));
			let activeRef = React.useRef(false);
			React.useEffect(() => {
			activeRef.current = true;
			});
			let navigate = React.useCallback((to, options = {}) => {
			warning(activeRef.current, `You should call navigate() in a React.useEffect(), not when ` + `your component is first rendered.`) ;
			if (!activeRef.current) return;

			if (typeof to === "number") {
			navigator.go(to);
			return;
			}

			let path = resolveTo(to, JSON.parse(routePathnamesJson), locationPathname, options.relative === "path"); // If we're operating within a basename, prepend it to the pathname prior
			// to handing off to history. If this is a root navigation, then we
			// navigate to the raw basename which allows the basename to have full
			// control over the presence of a trailing slash on root links

			if (basename !== "/") {
			path.pathname = path.pathname === "/" ? basename : joinPaths([basename, path.pathname]);
			}

			(!!options.replace ? navigator.replace : navigator.push)(path, options.state, options);
			}, [basename, navigator, routePathnamesJson, locationPathname]);
			return navigate;
			}
			const OutletContext = /#__PURE__/React.createContext(null);
			/**
			* Returns the context (if provided) for the child route at this level of the route
			* hierarchy.
			* @see https://reactrouter.com/hooks/use-outlet-context
			*/

			function useOutletContext() {
			return React.useContext(OutletContext);
			}
			/**
			* Returns the element for the child route at this level of the route
			* hierarchy. Used internally by <Outlet> to render child routes.
			*
			* @see https://reactrouter.com/hooks/use-outlet
			*/

			function useOutlet(context) {
			let outlet = React.useContext(RouteContext).outlet;

			if (outlet) {
			return /#__PURE__/React.createElement(OutletContext.Provider, {
			value: context
			}, outlet);
			}

			return outlet;
			}
			/**
			* Returns an object of key/value pairs of the dynamic params from the current
			* URL that were matched by the route path.
			*
			* @see https://reactrouter.com/hooks/use-params
			*/

			function useParams() {
			let {
			matches
			} = React.useContext(RouteContext);
			let routeMatch = matches[matches.length - 1];
			return routeMatch ? routeMatch.params : {};
			}
			/**
			* Resolves the pathname of the given `to` value against the current location.
			*
			* @see https://reactrouter.com/hooks/use-resolved-path
			*/

			function useResolvedPath(to, {
			relative
			} = {}) {
			let {
			matches
			} = React.useContext(RouteContext);
			let {
			pathname: locationPathname
			} = useLocation();
			let routePathnamesJson = JSON.stringify(UNSAFE_getPathContributingMatches(matches).map(match => match.pathnameBase));
			return React.useMemo(() => resolveTo(to, JSON.parse(routePathnamesJson), locationPathname, relative === "path"), [to, routePathnamesJson, locationPathname, relative]);
			}
			/**
			* Returns the element of the route that matched the current location, prepared
			* with the correct context to render the remainder of the route tree. Route
			* elements in the tree must render an <Outlet> to render their child route's
			* element.
			*
			* @see https://reactrouter.com/hooks/use-routes
			*/

			function useRoutes(routes, locationArg) {
			!useInRouterContext() ? invariant(false, // TODO: This error is probably because they somehow have 2 versions of the
			// router loaded. We can help them understand how to avoid that.
			`useRoutes() may be used only in the context of a <Router> component.`) : void 0;
			let {
			navigator
			} = React.useContext(NavigationContext);
			let dataRouterStateContext = React.useContext(DataRouterStateContext);
			let {
			matches: parentMatches
			} = React.useContext(RouteContext);
			let routeMatch = parentMatches[parentMatches.length - 1];
			let parentParams = routeMatch ? routeMatch.params : {};
			let parentPathname = routeMatch ? routeMatch.pathname : "/";
			let parentPathnameBase = routeMatch ? routeMatch.pathnameBase : "/";
			let parentRoute = routeMatch && routeMatch.route;

			{
			// You won't get a warning about 2 different <Routes> under a <Route>
			// without a trailing *, but this is a best-effort warning anyway since we
			// cannot even give the warning unless they land at the parent route.
			//
			// Example:
			//
			// <Routes>
			// {/* This route path MUST end with /* because otherwise
			// it will never match /blog/post/123 */}
			// <Route path="blog" element={<Blog />} />
			// <Route path="blog/feed" element={<BlogFeed />} />
			// </Routes>
			//
			// function Blog() {
			// return (
			// <Routes>
			// <Route path="post/:id" element={<Post />} />
			// </Routes>
			// );
			// }
			let parentPath = parentRoute && parentRoute.path \|\| "";
			warningOnce(parentPathname, !parentRoute \|\| parentPath.endsWith(""), `You rendered descendant <Routes> (or called \`useRoutes()\`) at ` + `"${parentPathname}" (under <Route path="${parentPath}">) but the ` + `parent route path has no trailing "". This means if you navigate ` + `deeper, the parent won't match anymore and therefore the child ` + `routes will never render.\n\n` + `Please change the parent <Route path="${parentPath}"> to <Route ` + `path="${parentPath === "/" ? "" : `${parentPath}/`}">.`);
			}

			let locationFromContext = useLocation();
			let location;

			if (locationArg) {
			let parsedLocationArg = typeof locationArg === "string" ? parsePath(locationArg) : locationArg;
			!(parentPathnameBase === "/" \|\| parsedLocationArg.pathname?.startsWith(parentPathnameBase)) ? invariant(false, `When overriding the location using \`<Routes location>\` or \`useRoutes(routes, location)\`, ` + `the location pathname must begin with the portion of the URL pathname that was ` + `matched by all parent routes. The current pathname base is "${parentPathnameBase}" ` + `but pathname "${parsedLocationArg.pathname}" was given in the \`location\` prop.`) : void 0;
			location = parsedLocationArg;
			} else {
			location = locationFromContext;
			}

			let pathname = location.pathname \|\| "/";
			let remainingPathname = parentPathnameBase === "/" ? pathname : pathname.slice(parentPathnameBase.length) \|\| "/";
			let matches = matchRoutes(routes, {
			pathname: remainingPathname
			});

			{
			warning(parentRoute \|\| matches != null, `No routes matched location "${location.pathname}${location.search}${location.hash}" `) ;
			warning(matches == null \|\| matches[matches.length - 1].route.element !== undefined, `Matched leaf route at location "${location.pathname}${location.search}${location.hash}" does not have an element. ` + `This means it will render an <Outlet /> with a null value by default resulting in an "empty" page.`) ;
			}

			let renderedMatches = _renderMatches(matches && matches.map(match => Object.assign({}, match, {
			params: Object.assign({}, parentParams, match.params),
			pathname: joinPaths([parentPathnameBase, // Re-encode pathnames that were decoded inside matchRoutes
			navigator.encodeLocation ? navigator.encodeLocation(match.pathname).pathname : match.pathname]),
			pathnameBase: match.pathnameBase === "/" ? parentPathnameBase : joinPaths([parentPathnameBase, // Re-encode pathnames that were decoded inside matchRoutes
			navigator.encodeLocation ? navigator.encodeLocation(match.pathnameBase).pathname : match.pathnameBase])
			})), parentMatches, dataRouterStateContext \|\| undefined); // When a user passes in a `locationArg`, the associated routes need to
			// be wrapped in a new `LocationContext.Provider` in order for `useLocation`
			// to use the scoped location instead of the global location.


			if (locationArg && renderedMatches) {
			return /#__PURE__/React.createElement(LocationContext.Provider, {
			value: {
			location: {
			pathname: "/",
			search: "",
			hash: "",
			state: null,
			key: "default",
			...location
			},
			navigationType: Action.Pop
			}
			}, renderedMatches);
			}

			return renderedMatches;
			}

			function DefaultErrorElement() {
			let error = useRouteError();
			let message = isRouteErrorResponse(error) ? `${error.status} ${error.statusText}` : error instanceof Error ? error.message : JSON.stringify(error);
			let stack = error instanceof Error ? error.stack : null;
			let lightgrey = "rgba(200,200,200, 0.5)";
			let preStyles = {
			padding: "0.5rem",
			backgroundColor: lightgrey
			};
			let codeStyles = {
			padding: "2px 4px",
			backgroundColor: lightgrey
			};
			return /#__PURE__/React.createElement(React.Fragment, null, /#__PURE__/React.createElement("h2", null, "Unhandled Thrown Error!"), /#__PURE__/React.createElement("h3", {
			style: {
			fontStyle: "italic"
			}
			}, message), stack ? /#__PURE__/React.createElement("pre", {
			style: preStyles
			}, stack) : null, /#__PURE__/React.createElement("p", null, "\uD83D\uDCBF Hey developer \uD83D\uDC4B"), /#__PURE__/React.createElement("p", null, "You can provide a way better UX than this when your app throws errors by providing your own\u00A0", /#__PURE__/React.createElement("code", {
			style: codeStyles
			}, "errorElement"), " props on\u00A0", /#__PURE__/React.createElement("code", {
			style: codeStyles
			}, "<Route>")));
			}

			class RenderErrorBoundary extends React.Component {
			constructor(props) {
			super(props);
			this.state = {
			location: props.location,
			error: props.error
			};
			}

			static getDerivedStateFromError(error) {
			return {
			error: error
			};
			}

			static getDerivedStateFromProps(props, state) {
			// When we get into an error state, the user will likely click "back" to the
			// previous page that didn't have an error. Because this wraps the entire
			// application, that will have no effect--the error page continues to display.
			// This gives us a mechanism to recover from the error when the location changes.
			//
			// Whether we're in an error state or not, we update the location in state
			// so that when we are in an error state, it gets reset when a new location
			// comes in and the user recovers from the error.
			if (state.location !== props.location) {
			return {
			error: props.error,
			location: props.location
			};
			} // If we're not changing locations, preserve the location but still surface
			// any new errors that may come through. We retain the existing error, we do
			// this because the error provided from the app state may be cleared without
			// the location changing.


			return {
			error: props.error \|\| state.error,
			location: state.location
			};
			}

			componentDidCatch(error, errorInfo) {
			console.error("React Router caught the following error during render", error, errorInfo);
			}

			render() {
			return this.state.error ? /#__PURE__/React.createElement(RouteContext.Provider, {
			value: this.props.routeContext
			}, /#__PURE__/React.createElement(RouteErrorContext.Provider, {
			value: this.state.error,
			children: this.props.component
			})) : this.props.children;
			}

			}

			function RenderedRoute({
			routeContext,
			match,
			children
			}) {
			let dataStaticRouterContext = React.useContext(DataStaticRouterContext); // Track how deep we got in our render pass to emulate SSR componentDidCatch
			// in a DataStaticRouter

			if (dataStaticRouterContext && match.route.errorElement) {
			dataStaticRouterContext._deepestRenderedBoundaryId = match.route.id;
			}

			return /#__PURE__/React.createElement(RouteContext.Provider, {
			value: routeContext
			}, children);
			}

			function _renderMatches(matches, parentMatches = [], dataRouterState) {
			if (matches == null) {
			if (dataRouterState?.errors) {
			// Don't bail if we have data router errors so we can render them in the
			// boundary. Use the pre-matched (or shimmed) matches
			matches = dataRouterState.matches;
			} else {
			return null;
			}
			}

			let renderedMatches = matches; // If we have data errors, trim matches to the highest error boundary

			let errors = dataRouterState?.errors;

			if (errors != null) {
			let errorIndex = renderedMatches.findIndex(m => m.route.id && errors?.[m.route.id]);
			!(errorIndex >= 0) ? invariant(false, `Could not find a matching route for the current errors: ${errors}`) : void 0;
			renderedMatches = renderedMatches.slice(0, Math.min(renderedMatches.length, errorIndex + 1));
			}

			return renderedMatches.reduceRight((outlet, match, index) => {
			let error = match.route.id ? errors?.[match.route.id] : null; // Only data routers handle errors

			let errorElement = dataRouterState ? match.route.errorElement \|\| /#__PURE__/React.createElement(DefaultErrorElement, null) : null;
			let matches = parentMatches.concat(renderedMatches.slice(0, index + 1));

			let getChildren = () => /#__PURE__/React.createElement(RenderedRoute, {
			match: match,
			routeContext: {
			outlet,
			matches
			}
			}, error ? errorElement : match.route.element !== undefined ? match.route.element : outlet); // Only wrap in an error boundary within data router usages when we have an
			// errorElement on this route. Otherwise let it bubble up to an ancestor
			// errorElement


			return dataRouterState && (match.route.errorElement \|\| index === 0) ? /#__PURE__/React.createElement(RenderErrorBoundary, {
			location: dataRouterState.location,
			component: errorElement,
			error: error,
			children: getChildren(),
			routeContext: {
			outlet: null,
			matches
			}
			}) : getChildren();
			}, null);
			}
			var DataRouterHook;

			(function (DataRouterHook) {
			DataRouterHook["UseRevalidator"] = "useRevalidator";
			})(DataRouterHook \|\| (DataRouterHook = {}));

			var DataRouterStateHook;

			(function (DataRouterStateHook) {
			DataRouterStateHook["UseLoaderData"] = "useLoaderData";
			DataRouterStateHook["UseActionData"] = "useActionData";
			DataRouterStateHook["UseRouteError"] = "useRouteError";
			DataRouterStateHook["UseNavigation"] = "useNavigation";
			DataRouterStateHook["UseRouteLoaderData"] = "useRouteLoaderData";
			DataRouterStateHook["UseMatches"] = "useMatches";
			DataRouterStateHook["UseRevalidator"] = "useRevalidator";
			})(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(DataRouterContext);
			!ctx ? invariant(false, getDataRouterConsoleError(hookName)) : void 0;
			return ctx;
			}

			function useDataRouterState(hookName) {
			let state = React.useContext(DataRouterStateContext);
			!state ? invariant(false, getDataRouterConsoleError(hookName)) : void 0;
			return state;
			}

			function useRouteContext(hookName) {
			let route = React.useContext(RouteContext);
			!route ? invariant(false, getDataRouterConsoleError(hookName)) : void 0;
			return route;
			}

			function useCurrentRouteId(hookName) {
			let route = useRouteContext(hookName);
			let thisRoute = route.matches[route.matches.length - 1];
			!thisRoute.route.id ? invariant(false, `${hookName} can only be used on routes that contain a unique "id"`) : void 0;
			return thisRoute.route.id;
			}
			/**
			* Returns the current navigation, defaulting to an "idle" navigation when
			* no navigation is in progress
			*/


			function useNavigation() {
			let state = useDataRouterState(DataRouterStateHook.UseNavigation);
			return state.navigation;
			}
			/**
			* Returns a revalidate function for manually triggering revalidation, as well
			* as the current state of any manual revalidations
			*/

			function useRevalidator() {
			let dataRouterContext = useDataRouterContext(DataRouterHook.UseRevalidator);
			let state = useDataRouterState(DataRouterStateHook.UseRevalidator);
			return {
			revalidate: dataRouterContext.router.revalidate,
			state: state.revalidation
			};
			}
			/**
			* Returns the active route matches, useful for accessing loaderData for
			* parent/child routes or the route "handle" property
			*/

			function useMatches() {
			let {
			matches,
			loaderData
			} = useDataRouterState(DataRouterStateHook.UseMatches);
			return React.useMemo(() => matches.map(match => {
			let {
			pathname,
			params
			} = match; // Note: This structure matches that created by createUseMatchesMatch
			// in the @remix-run/router , so if you change this please also change
			// that :) Eventually we'll DRY this up

			return {
			id: match.route.id,
			pathname,
			params,
			data: loaderData[match.route.id],
			handle: match.route.handle
			};
			}), [matches, loaderData]);
			}
			/**
			* Returns the loader data for the nearest ancestor Route loader
			*/

			function useLoaderData() {
			let state = useDataRouterState(DataRouterStateHook.UseLoaderData);
			let routeId = useCurrentRouteId(DataRouterStateHook.UseLoaderData);

			if (state.errors && state.errors[routeId] != null) {
			console.error(`You cannot \`useLoaderData\` in an errorElement (routeId: ${routeId})`);
			return undefined;
			}

			return state.loaderData[routeId];
			}
			/**
			* Returns the loaderData for the given routeId
			*/

			function useRouteLoaderData(routeId) {
			let state = useDataRouterState(DataRouterStateHook.UseRouteLoaderData);
			return state.loaderData[routeId];
			}
			/**
			* Returns the action data for the nearest ancestor Route action
			*/

			function useActionData() {
			let state = useDataRouterState(DataRouterStateHook.UseActionData);
			let route = React.useContext(RouteContext);
			!route ? invariant(false, `useActionData must be used inside a RouteContext`) : void 0;
			return Object.values(state?.actionData \|\| {})[0];
			}
			/**
			* Returns the nearest ancestor Route error, which could be a loader/action
			* error or a render error. This is intended to be called from your
			* errorElement to display a proper error message.
			*/

			function useRouteError() {
			let error = React.useContext(RouteErrorContext);
			let state = useDataRouterState(DataRouterStateHook.UseRouteError);
			let routeId = useCurrentRouteId(DataRouterStateHook.UseRouteError); // If this was a render error, we put it in a RouteError context inside
			// of RenderErrorBoundary

			if (error) {
			return error;
			} // Otherwise look for errors from our data router state


			return state.errors?.[routeId];
			}
			/**
			* Returns the happy-path data from the nearest ancestor <Await /> value
			*/

			function useAsyncValue() {
			let value = React.useContext(AwaitContext);
			return value?._data;
			}
			/**
			* Returns the error from the nearest ancestor <Await /> value
			*/

			function useAsyncError() {
			let value = React.useContext(AwaitContext);
			return value?._error;
			}
			const alreadyWarned = {};

			function warningOnce(key, cond, message) {
			if (!cond && !alreadyWarned[key]) {
			alreadyWarned[key] = true;
			warning(false, message) ;
			}
			}

			/**
			* Given a Remix Router instance, render the appropriate UI
			*/

			function RouterProvider({
			fallbackElement,
			router
			}) {
			// Sync router state to our component state to force re-renders
			let state = useSyncExternalStore(router.subscribe, () => router.state, // We have to provide this so React@18 doesn't complain during hydration,
			// but we pass our serialized hydration data into the router so state here
			// is already synced with what the server saw
			() => router.state);
			let navigator = React.useMemo(() => {
			return {
			createHref: router.createHref,
			encodeLocation: router.encodeLocation,
			go: n => router.navigate(n),
			push: (to, state, opts) => router.navigate(to, {
			state,
			preventScrollReset: opts?.preventScrollReset
			}),
			replace: (to, state, opts) => router.navigate(to, {
			replace: true,
			state,
			preventScrollReset: opts?.preventScrollReset
			})
			};
			}, [router]);
			let basename = router.basename \|\| "/";
			return /#__PURE__/React.createElement(DataRouterContext.Provider, {
			value: {
			router,
			navigator,
			static: false,
			// Do we need this?
			basename
			}
			}, /#__PURE__/React.createElement(DataRouterStateContext.Provider, {
			value: state
			}, /#__PURE__/React.createElement(Router, {
			basename: router.basename,
			location: router.state.location,
			navigationType: router.state.historyAction,
			navigator: navigator
			}, router.state.initialized ? /#__PURE__/React.createElement(Routes, null) : fallbackElement)));
			}
			/**
			* A <Router> that stores all entries in memory.
			*
			* @see https://reactrouter.com/router-components/memory-router
			*/

			function MemoryRouter({
			basename,
			children,
			initialEntries,
			initialIndex
			}) {
			let historyRef = React.useRef();

			if (historyRef.current == null) {
			historyRef.current = createMemoryHistory({
			initialEntries,
			initialIndex,
			v5Compat: true
			});
			}

			let history = historyRef.current;
			let [state, setState] = React.useState({
			action: history.action,
			location: history.location
			});
			React.useLayoutEffect(() => history.listen(setState), [history]);
			return /#__PURE__/React.createElement(Router, {
			basename: basename,
			children: children,
			location: state.location,
			navigationType: state.action,
			navigator: history
			});
			}
			/**
			* Changes the current location.
			*
			* Note: This API is mostly useful in React.Component subclasses that are not
			* able to use hooks. In functional components, we recommend you use the
			* `useNavigate` hook instead.
			*
			* @see https://reactrouter.com/components/navigate
			*/

			function Navigate({
			to,
			replace,
			state,
			relative
			}) {
			!useInRouterContext() ? invariant(false, // TODO: This error is probably because they somehow have 2 versions of
			// the router loaded. We can help them understand how to avoid that.
			`<Navigate> may be used only in the context of a <Router> component.`) : void 0;
			warning(!React.useContext(NavigationContext).static, `<Navigate> must not be used on the initial render in a <StaticRouter>. ` + `This is a no-op, but you should modify your code so the <Navigate> is ` + `only ever rendered in response to some user interaction or state change.`) ;
			let dataRouterState = React.useContext(DataRouterStateContext);
			let navigate = useNavigate();
			React.useEffect(() => {
			// Avoid kicking off multiple navigations if we're in the middle of a
			// data-router navigation, since components get re-rendered when we enter
			// a submitting/loading state
			if (dataRouterState && dataRouterState.navigation.state !== "idle") {
			return;
			}

			navigate(to, {
			replace,
			state,
			relative
			});
			});
			return null;
			}
			/**
			* Renders the child route's element, if there is one.
			*
			* @see https://reactrouter.com/components/outlet
			*/

			function Outlet(props) {
			return useOutlet(props.context);
			}
			/**
			* Declares an element that should be rendered at a certain URL path.
			*
			* @see https://reactrouter.com/components/route
			*/

			function Route(_props) {
			invariant(false, `A <Route> is only ever to be used as the child of <Routes> element, ` + `never rendered directly. Please wrap your <Route> in a <Routes>.`) ;
			}
			/**
			* Provides location context for the rest of the app.
			*
			* Note: You usually won't render a <Router> directly. Instead, you'll render a
			* router that is more specific to your environment such as a <BrowserRouter>
			* in web browsers or a <StaticRouter> for server rendering.
			*
			* @see https://reactrouter.com/router-components/router
			*/

			function Router({
			basename: basenameProp = "/",
			children = null,
			location: locationProp,
			navigationType = Action.Pop,
			navigator,
			static: staticProp = false
			}) {
			!!useInRouterContext() ? invariant(false, `You cannot render a <Router> inside another <Router>.` + ` You should never have more than one in your app.`) : void 0; // Preserve trailing slashes on basename, so we can let the user control
			// the enforcement of trailing slashes throughout the app

			let basename = basenameProp.replace(/^\/*/, "/");
			let navigationContext = React.useMemo(() => ({
			basename,
			navigator,
			static: staticProp
			}), [basename, navigator, staticProp]);

			if (typeof locationProp === "string") {
			locationProp = parsePath(locationProp);
			}

			let {
			pathname = "/",
			search = "",
			hash = "",
			state = null,
			key = "default"
			} = locationProp;
			let location = React.useMemo(() => {
			let trailingPathname = stripBasename(pathname, basename);

			if (trailingPathname == null) {
			return null;
			}

			return {
			pathname: trailingPathname,
			search,
			hash,
			state,
			key
			};
			}, [basename, pathname, search, hash, state, key]);
			warning(location != null, `<Router basename="${basename}"> is not able to match the URL ` + `"${pathname}${search}${hash}" because it does not start with the ` + `basename, so the <Router> won't render anything.`) ;

			if (location == null) {
			return null;
			}

			return /#__PURE__/React.createElement(NavigationContext.Provider, {
			value: navigationContext
			}, /#__PURE__/React.createElement(LocationContext.Provider, {
			children: children,
			value: {
			location,
			navigationType
			}
			}));
			}
			/**
			* A container for a nested tree of <Route> elements that renders the branch
			* that best matches the current location.
			*
			* @see https://reactrouter.com/components/routes
			*/

			function Routes({
			children,
			location
			}) {
			let dataRouterContext = React.useContext(DataRouterContext); // When in a DataRouterContext _without_ children, we use the router routes
			// directly. If we have children, then we're in a descendant tree and we
			// need to use child routes.

			let routes = dataRouterContext && !children ? dataRouterContext.router.routes : createRoutesFromChildren(children);
			return useRoutes(routes, location);
			}
			/**
			* Component to use for rendering lazily loaded data from returning defer()
			* in a loader function
			*/

			function Await({
			children,
			errorElement,
			resolve
			}) {
			return /#__PURE__/React.createElement(AwaitErrorBoundary, {
			resolve: resolve,
			errorElement: errorElement
			}, /#__PURE__/React.createElement(ResolveAwait, null, children));
			}
			var AwaitRenderStatus;

			(function (AwaitRenderStatus) {
			AwaitRenderStatus[AwaitRenderStatus["pending"] = 0] = "pending";
			AwaitRenderStatus[AwaitRenderStatus["success"] = 1] = "success";
			AwaitRenderStatus[AwaitRenderStatus["error"] = 2] = "error";
			})(AwaitRenderStatus \|\| (AwaitRenderStatus = {}));

			const neverSettledPromise = new Promise(() => {});

			class AwaitErrorBoundary extends React.Component {
			constructor(props) {
			super(props);
			this.state = {
			error: null
			};
			}

			static getDerivedStateFromError(error) {
			return {
			error
			};
			}

			componentDidCatch(error, errorInfo) {
			console.error("<Await> caught the following error during render", error, errorInfo);
			}

			render() {
			let {
			children,
			errorElement,
			resolve
			} = this.props;
			let promise = null;
			let status = AwaitRenderStatus.pending;

			if (!(resolve instanceof Promise)) {
			// Didn't get a promise - provide as a resolved promise
			status = AwaitRenderStatus.success;
			promise = Promise.resolve();
			Object.defineProperty(promise, "_tracked", {
			get: () => true
			});
			Object.defineProperty(promise, "_data", {
			get: () => resolve
			});
			} else if (this.state.error) {
			// Caught a render error, provide it as a rejected promise
			status = AwaitRenderStatus.error;
			let renderError = this.state.error;
			promise = Promise.reject().catch(() => {}); // Avoid unhandled rejection warnings

			Object.defineProperty(promise, "_tracked", {
			get: () => true
			});
			Object.defineProperty(promise, "_error", {
			get: () => renderError
			});
			} else if (resolve._tracked) {
			// Already tracked promise - check contents
			promise = resolve;
			status = promise._error !== undefined ? AwaitRenderStatus.error : promise._data !== undefined ? AwaitRenderStatus.success : AwaitRenderStatus.pending;
			} else {
			// Raw (untracked) promise - track it
			status = AwaitRenderStatus.pending;
			Object.defineProperty(resolve, "_tracked", {
			get: () => true
			});
			promise = resolve.then(data => Object.defineProperty(resolve, "_data", {
			get: () => data
			}), error => Object.defineProperty(resolve, "_error", {
			get: () => error
			}));
			}

			if (status === AwaitRenderStatus.error && promise._error instanceof AbortedDeferredError) {
			// Freeze the UI by throwing a never resolved promise
			throw neverSettledPromise;
			}

			if (status === AwaitRenderStatus.error && !errorElement) {
			// No errorElement, throw to the nearest route-level error boundary
			throw promise._error;
			}

			if (status === AwaitRenderStatus.error) {
			// Render via our errorElement
			return /#__PURE__/React.createElement(AwaitContext.Provider, {
			value: promise,
			children: errorElement
			});
			}

			if (status === AwaitRenderStatus.success) {
			// Render children with resolved value
			return /#__PURE__/React.createElement(AwaitContext.Provider, {
			value: promise,
			children: children
			});
			} // Throw to the suspense boundary


			throw promise;
			}

			}
			/**
			* @private
			* Indirection to leverage useAsyncValue for a render-prop API on <Await>
			*/


			function ResolveAwait({
			children
			}) {
			let data = useAsyncValue();

			if (typeof children === "function") {
			return children(data);
			}

			return /#__PURE__/React.createElement(React.Fragment, null, children);
			} ///////////////////////////////////////////////////////////////////////////////
			// UTILS
			///////////////////////////////////////////////////////////////////////////////

			/**
			* Creates a route config from a React "children" object, which is usually
			* either a `<Route>` element or an array of them. Used internally by
			* `<Routes>` to create a route config from its children.
			*
			* @see https://reactrouter.com/utils/create-routes-from-children
			*/


			function createRoutesFromChildren(children, parentPath = []) {
			let routes = [];
			React.Children.forEach(children, (element, index) => {
			if (! /#__PURE__/React.isValidElement(element)) {
			// Ignore non-elements. This allows people to more easily inline
			// conditionals in their route config.
			return;
			}

			if (element.type === React.Fragment) {
			// Transparently support React.Fragment and its children.
			routes.push.apply(routes, createRoutesFromChildren(element.props.children, parentPath));
			return;
			}

			!(element.type === Route) ? invariant(false, `[${typeof element.type === "string" ? element.type : element.type.name}] is not a <Route> component. All component children of <Routes> must be a <Route> or <React.Fragment>`) : void 0;
			!(!element.props.index \|\| !element.props.children) ? invariant(false, "An index route cannot have child routes.") : void 0;
			let treePath = [...parentPath, index];
			let route = {
			id: element.props.id \|\| treePath.join("-"),
			caseSensitive: element.props.caseSensitive,
			element: element.props.element,
			index: element.props.index,
			path: element.props.path,
			loader: element.props.loader,
			action: element.props.action,
			errorElement: element.props.errorElement,
			hasErrorBoundary: element.props.errorElement != null,
			shouldRevalidate: element.props.shouldRevalidate,
			handle: element.props.handle
			};

			if (element.props.children) {
			route.children = createRoutesFromChildren(element.props.children, treePath);
			}

			routes.push(route);
			});
			return routes;
			}
			/**
			* Renders the result of `matchRoutes()` into a React element.
			*/

			function renderMatches(matches) {
			return _renderMatches(matches);
			}
			/**
			* @private
			* Walk the route tree and add hasErrorBoundary if it's not provided, so that
			* users providing manual route arrays can just specify errorElement
			*/

			function enhanceManualRouteObjects(routes) {
			return routes.map(route => {
			let routeClone = { ...route
			};

			if (routeClone.hasErrorBoundary == null) {
			routeClone.hasErrorBoundary = routeClone.errorElement != null;
			}

			if (routeClone.children) {
			routeClone.children = enhanceManualRouteObjects(routeClone.children);
			}

			return routeClone;
			});
			}

			function createMemoryRouter(routes, opts) {
			return createRouter({
			basename: opts?.basename,
			history: createMemoryHistory({
			initialEntries: opts?.initialEntries,
			initialIndex: opts?.initialIndex
			}),
			hydrationData: opts?.hydrationData,
			routes: enhanceManualRouteObjects(routes)
			}).initialize();
			} ///////////////////////////////////////////////////////////////////////////////

			export { Await, MemoryRouter, Navigate, Outlet, Route, Router, RouterProvider, Routes, DataRouterContext as UNSAFE_DataRouterContext, DataRouterStateContext as UNSAFE_DataRouterStateContext, DataStaticRouterContext as UNSAFE_DataStaticRouterContext, LocationContext as UNSAFE_LocationContext, NavigationContext as UNSAFE_NavigationContext, RouteContext as UNSAFE_RouteContext, enhanceManualRouteObjects as UNSAFE_enhanceManualRouteObjects, createMemoryRouter, createRoutesFromChildren, createRoutesFromChildren as createRoutesFromElements, renderMatches, useActionData, useAsyncError, useAsyncValue, useHref, useInRouterContext, useLoaderData, useLocation, useMatch, useMatches, useNavigate, useNavigation, useNavigationType, useOutlet, useOutletContext, useParams, useResolvedPath, useRevalidator, useRouteError, useRouteLoaderData, useRoutes };
			//# sourceMappingURL=react-router.development.js.map