react-router 6.2.2 → 6.4.0-pre.2

package/umd/react-router.development.js

@@ -1,5 +1,5 @@
 /**
- * React Router v6.2.2
+ * React Router v6.4.0-pre.2
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -9,254 +9,250 @@
  * @license MIT
  */
 (function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react'), require('history')) :
-  typeof define === 'function' && define.amd ? define(['exports', 'react', 'history'], factory) :
-  (global = global || self, factory(global.ReactRouter = {}, global.React, global.HistoryLibrary));
-}(this, (function (exports, React, history) { 'use strict';
-
-  function invariant(cond, message) {
-    if (!cond) throw new Error(message);
-  }
-
-  function warning(cond, message) {
-    if (!cond) {
-      // eslint-disable-next-line no-console
-      if (typeof console !== "undefined") console.warn(message);
-
-      try {
-        // Welcome to debugging React Router!
-        //
-        // This error is thrown as a convenience so you can more easily
-        // find the source for a warning that appears in the console by
-        // enabling "pause on exceptions" in your JavaScript debugger.
-        throw new Error(message); // eslint-disable-next-line no-empty
-      } catch (e) {}
-    }
-  }
-
-  const alreadyWarned = {};
-
-  function warningOnce(key, cond, message) {
-    if (!cond && !alreadyWarned[key]) {
-      alreadyWarned[key] = true;
-       warning(false, message) ;
-    }
-  } ///////////////////////////////////////////////////////////////////////////////
-  // CONTEXT
-  ///////////////////////////////////////////////////////////////////////////////
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@remix-run/router'), require('react')) :
+  typeof define === 'function' && define.amd ? define(['exports', '@remix-run/router', 'react'], factory) :
+  (global = global || self, factory(global.ReactRouter = {}, global.Router, global.React));
+}(this, (function (exports, router, React) { 'use strict';
 
   /**
-   * A Navigator is a "location changer"; it's how you get to different locations.
+   * Copyright (c) Facebook, Inc. and its affiliates.
    *
-   * Every history instance conforms to the Navigator interface, but the
-   * distinction is useful primarily when it comes to the low-level <Router> API
-   * where both the location and a navigator must be provided separately in order
-   * to avoid "tearing" that may occur in a suspense-enabled app if the action
-   * and/or location were to be read directly from the history instance.
+   * 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 NavigationContext = /*#__PURE__*/React.createContext(null);
+  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(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) {
+        // @ts-expect-error
+        if (React.startTransition !== undefined) {
+          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.
 
-  {
-    NavigationContext.displayName = "Navigation";
-  }
 
-  const LocationContext = /*#__PURE__*/React.createContext(null);
+    const value = getSnapshot();
 
-  {
-    LocationContext.displayName = "Location";
-  }
+    {
+      if (!didWarnUncachedGetSnapshot) {
+        const cachedValue = getSnapshot();
 
-  const RouteContext = /*#__PURE__*/React.createContext({
-    outlet: null,
-    matches: []
-  });
+        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
+        });
+      }
 
-  {
-    RouteContext.displayName = "Route";
-  } ///////////////////////////////////////////////////////////////////////////////
-  // COMPONENTS
-  ///////////////////////////////////////////////////////////////////////////////
+      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.
 
 
-  /**
-   * A <Router> that stores all entries in memory.
-   *
-   * @see https://reactrouter.com/docs/en/v6/api#memoryrouter
-   */
-  function MemoryRouter(_ref) {
-    let {
-      basename,
-      children,
-      initialEntries,
-      initialIndex
-    } = _ref;
-    let historyRef = React.useRef();
+      return subscribe(handleStoreChange); // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [subscribe]);
+    useDebugValue(value);
+    return value;
+  }
 
-    if (historyRef.current == null) {
-      historyRef.current = history.createMemoryHistory({
-        initialEntries,
-        initialIndex
-      });
-    }
+  function checkIfSnapshotChanged(inst) {
+    const latestGetSnapshot = inst.getSnapshot;
+    const prevValue = inst.value;
 
-    let history$1 = historyRef.current;
-    let [state, setState] = React.useState({
-      action: history$1.action,
-      location: history$1.location
-    });
-    React.useLayoutEffect(() => history$1.listen(setState), [history$1]);
-    return /*#__PURE__*/React.createElement(Router, {
-      basename: basename,
-      children: children,
-      location: state.location,
-      navigationType: state.action,
-      navigator: history$1
-    });
+    try {
+      const nextValue = latestGetSnapshot();
+      return !is(prevValue, nextValue);
+    } catch (error) {
+      return true;
+    }
   }
 
   /**
-   * Changes the current location.
+   * Copyright (c) Facebook, Inc. and its affiliates.
    *
-   * 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.
+   * This source code is licensed under the MIT license found in the
+   * LICENSE file in the root directory of this source tree.
    *
-   * @see https://reactrouter.com/docs/en/v6/api#navigate
+   * @flow
    */
-  function Navigate(_ref2) {
-    let {
-      to,
-      replace,
-      state
-    } = _ref2;
-    !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 navigate = useNavigate();
-    React.useEffect(() => {
-      navigate(to, {
-        replace,
-        state
-      });
-    });
-    return null;
+  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();
   }
 
   /**
-   * Renders the child route's element, if there is one.
-   *
-   * @see https://reactrouter.com/docs/en/v6/api#outlet
+   * 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
    */
-  function Outlet(props) {
-    return useOutlet(props.context);
-  }
+  const canUseDOM = !!(typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined");
+  const isServerEnvironment = !canUseDOM;
+  const shim = isServerEnvironment ? useSyncExternalStore$1 : useSyncExternalStore;
+  const useSyncExternalStore$2 = // @ts-expect-error
+  React.useSyncExternalStore !== undefined ? React.useSyncExternalStore : shim;
 
-  /**
-   * Declares an element that should be rendered at a certain URL path.
-   *
-   * @see https://reactrouter.com/docs/en/v6/api#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>.")  ;
+  // Contexts for data routers
+  const DataRouterContext = /*#__PURE__*/React.createContext(null);
+
+  {
+    DataRouterContext.displayName = "DataRouter";
   }
 
+  const DataRouterStateContext = /*#__PURE__*/React.createContext(null);
+
+  {
+    DataRouterStateContext.displayName = "DataRouterState";
+  }
   /**
-   * 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.
+   * A Navigator is a "location changer"; it's how you get to different locations.
    *
-   * @see https://reactrouter.com/docs/en/v6/api#router
+   * Every history instance conforms to the Navigator interface, but the
+   * distinction is useful primarily when it comes to the low-level <Router> API
+   * where both the location and a navigator must be provided separately in order
+   * to avoid "tearing" that may occur in a suspense-enabled app if the action
+   * and/or location were to be read directly from the history instance.
    */
-  function Router(_ref3) {
-    let {
-      basename: basenameProp = "/",
-      children = null,
-      location: locationProp,
-      navigationType = history.Action.Pop,
-      navigator,
-      static: staticProp = false
-    } = _ref3;
-    !!useInRouterContext() ?  invariant(false, "You cannot render a <Router> inside another <Router>." + " You should never have more than one in your app.")  : void 0;
-    let basename = normalizePathname(basenameProp);
-    let navigationContext = React.useMemo(() => ({
-      basename,
-      navigator,
-      static: staticProp
-    }), [basename, navigator, staticProp]);
 
-    if (typeof locationProp === "string") {
-      locationProp = history.parsePath(locationProp);
-    }
 
-    let {
-      pathname = "/",
-      search = "",
-      hash = "",
-      state = null,
-      key = "default"
-    } = locationProp;
-    let location = React.useMemo(() => {
-      let trailingPathname = stripBasename(pathname, basename);
+  const NavigationContext = /*#__PURE__*/React.createContext(null);
 
-      if (trailingPathname == null) {
-        return null;
-      }
+  {
+    NavigationContext.displayName = "Navigation";
+  }
 
-      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.") ;
+  const LocationContext = /*#__PURE__*/React.createContext(null);
 
-    if (location == null) {
-      return null;
-    }
+  {
+    LocationContext.displayName = "Location";
+  }
 
-    return /*#__PURE__*/React.createElement(NavigationContext.Provider, {
-      value: navigationContext
-    }, /*#__PURE__*/React.createElement(LocationContext.Provider, {
-      children: children,
-      value: {
-        location,
-        navigationType
-      }
-    }));
+  const RouteContext = /*#__PURE__*/React.createContext({
+    outlet: null,
+    matches: []
+  });
+
+  {
+    RouteContext.displayName = "Route";
   }
 
-  /**
-   * A container for a nested tree of <Route> elements that renders the branch
-   * that best matches the current location.
-   *
-   * @see https://reactrouter.com/docs/en/v6/api#routes
-   */
-  function Routes(_ref4) {
-    let {
-      children,
-      location
-    } = _ref4;
-    return useRoutes(createRoutesFromChildren(children), location);
-  } ///////////////////////////////////////////////////////////////////////////////
-  // HOOKS
-  ///////////////////////////////////////////////////////////////////////////////
+  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/docs/en/v6/api#usehref
+   * @see https://reactrouter.com/docs/en/v6/hooks/use-href
    */
 
   function useHref(to) {
-    !useInRouterContext() ?  invariant(false, // TODO: This error is probably because they somehow have 2 versions of the
+    !useInRouterContext() ?  router.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 {
@@ -271,9 +267,9 @@
     let joinedPathname = pathname;
 
     if (basename !== "/") {
-      let toPathname = getToPathname(to);
+      let toPathname = router.getToPathname(to);
       let endsWithSlash = toPathname != null && toPathname.endsWith("/");
-      joinedPathname = pathname === "/" ? basename + (endsWithSlash ? "/" : "") : joinPaths([basename, pathname]);
+      joinedPathname = pathname === "/" ? basename + (endsWithSlash ? "/" : "") : router.joinPaths([basename, pathname]);
     }
 
     return navigator.createHref({
@@ -285,7 +281,7 @@
   /**
    * Returns true if this component is a descendant of a <Router>.
    *
-   * @see https://reactrouter.com/docs/en/v6/api#useinroutercontext
+   * @see https://reactrouter.com/docs/en/v6/hooks/use-in-router-context
    */
 
   function useInRouterContext() {
@@ -299,22 +295,22 @@
    * "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/docs/en/v6/api#uselocation
+   * @see https://reactrouter.com/docs/en/v6/hooks/use-location
    */
 
   function useLocation() {
-    !useInRouterContext() ?  invariant(false, // TODO: This error is probably because they somehow have 2 versions of the
+    !useInRouterContext() ?  router.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/docs/en/v6/api#usenavigationtype
+   * @see https://reactrouter.com/docs/en/v6/hooks/use-navigation-type
    */
+
   function useNavigationType() {
     return React.useContext(LocationContext).navigationType;
   }
@@ -323,17 +319,17 @@
    * This is useful for components that need to know "active" state, e.g.
    * <NavLink>.
    *
-   * @see https://reactrouter.com/docs/en/v6/api#usematch
+   * @see https://reactrouter.com/docs/en/v6/hooks/use-match
    */
 
   function useMatch(pattern) {
-    !useInRouterContext() ?  invariant(false, // TODO: This error is probably because they somehow have 2 versions of the
+    !useInRouterContext() ?  router.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]);
+    return React.useMemo(() => router.matchPath(pattern, pathname), [pathname, pattern]);
   }
   /**
    * The interface for the navigate() function returned from useNavigate().
@@ -343,10 +339,10 @@
    * 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/docs/en/v6/api#usenavigate
+   * @see https://reactrouter.com/docs/en/v6/hooks/use-navigate
    */
   function useNavigate() {
-    !useInRouterContext() ?  invariant(false, // TODO: This error is probably because they somehow have 2 versions of the
+    !useInRouterContext() ?  router.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 {
@@ -369,7 +365,7 @@
         options = {};
       }
 
-       warning(activeRef.current, "You should call navigate() in a React.useEffect(), not when " + "your component is first rendered.") ;
+       router.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") {
@@ -377,10 +373,10 @@
         return;
       }
 
-      let path = resolveTo(to, JSON.parse(routePathnamesJson), locationPathname);
+      let path = router.resolveTo(to, JSON.parse(routePathnamesJson), locationPathname);
 
       if (basename !== "/") {
-        path.pathname = joinPaths([basename, path.pathname]);
+        path.pathname = router.joinPaths([basename, path.pathname]);
       }
 
       (!!options.replace ? navigator.replace : navigator.push)(path, options.state);
@@ -391,7 +387,7 @@
   /**
    * Returns the context (if provided) for the child route at this level of the route
    * hierarchy.
-   * @see https://reactrouter.com/docs/en/v6/api#useoutletcontext
+   * @see https://reactrouter.com/docs/en/v6/hooks/use-outlet-context
    */
 
   function useOutletContext() {
@@ -401,7 +397,7 @@
    * 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/docs/en/v6/api#useoutlet
+   * @see https://reactrouter.com/docs/en/v6/hooks/use-outlet
    */
 
   function useOutlet(context) {
@@ -419,7 +415,7 @@
    * 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/docs/en/v6/api#useparams
+   * @see https://reactrouter.com/docs/en/v6/hooks/use-params
    */
 
   function useParams() {
@@ -432,7 +428,7 @@
   /**
    * Resolves the pathname of the given `to` value against the current location.
    *
-   * @see https://reactrouter.com/docs/en/v6/api#useresolvedpath
+   * @see https://reactrouter.com/docs/en/v6/hooks/use-resolved-path
    */
 
   function useResolvedPath(to) {
@@ -443,7 +439,7 @@
       pathname: locationPathname
     } = useLocation();
     let routePathnamesJson = JSON.stringify(matches.map(match => match.pathnameBase));
-    return React.useMemo(() => resolveTo(to, JSON.parse(routePathnamesJson), locationPathname), [to, routePathnamesJson, locationPathname]);
+    return React.useMemo(() => router.resolveTo(to, JSON.parse(routePathnamesJson), locationPathname), [to, routePathnamesJson, locationPathname]);
   }
   /**
    * Returns the element of the route that matched the current location, prepared
@@ -451,13 +447,14 @@
    * elements in the tree must render an <Outlet> to render their child route's
    * element.
    *
-   * @see https://reactrouter.com/docs/en/v6/api#useroutes
+   * @see https://reactrouter.com/docs/en/v6/hooks/use-routes
    */
 
   function useRoutes(routes, locationArg) {
-    !useInRouterContext() ?  invariant(false, // TODO: This error is probably because they somehow have 2 versions of the
+    !useInRouterContext() ?  router.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 dataRouterStateContext = React.useContext(DataRouterStateContext);
     let {
       matches: parentMatches
     } = React.useContext(RouteContext);
@@ -498,8 +495,8 @@
     if (locationArg) {
       var _parsedLocationArg$pa;
 
-      let parsedLocationArg = typeof locationArg === "string" ? history.parsePath(locationArg) : locationArg;
-      !(parentPathnameBase === "/" || ((_parsedLocationArg$pa = parsedLocationArg.pathname) == null ? void 0 : _parsedLocationArg$pa.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;
+      let parsedLocationArg = typeof locationArg === "string" ? router.parsePath(locationArg) : locationArg;
+      !(parentPathnameBase === "/" || ((_parsedLocationArg$pa = parsedLocationArg.pathname) == null ? void 0 : _parsedLocationArg$pa.startsWith(parentPathnameBase))) ?  router.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;
@@ -507,511 +504,683 @@
 
     let pathname = location.pathname || "/";
     let remainingPathname = parentPathnameBase === "/" ? pathname : pathname.slice(parentPathnameBase.length) || "/";
-    let matches = matchRoutes(routes, {
+    let matches = router.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.") ;
+       router.warning(parentRoute || matches != null, "No routes matched location \"" + location.pathname + location.search + location.hash + "\" ") ;
+       router.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.") ;
     }
 
     return _renderMatches(matches && matches.map(match => Object.assign({}, match, {
       params: Object.assign({}, parentParams, match.params),
-      pathname: joinPaths([parentPathnameBase, match.pathname]),
-      pathnameBase: match.pathnameBase === "/" ? parentPathnameBase : joinPaths([parentPathnameBase, match.pathnameBase])
-    })), parentMatches);
-  } ///////////////////////////////////////////////////////////////////////////////
-  // 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/docs/en/v6/api#createroutesfromchildren
-   */
+      pathname: router.joinPaths([parentPathnameBase, match.pathname]),
+      pathnameBase: match.pathnameBase === "/" ? parentPathnameBase : router.joinPaths([parentPathnameBase, match.pathnameBase])
+    })), parentMatches, dataRouterStateContext);
+  }
 
-  function createRoutesFromChildren(children) {
-    let routes = [];
-    React.Children.forEach(children, element => {
-      if (! /*#__PURE__*/React.isValidElement(element)) {
-        // Ignore non-elements. This allows people to more easily inline
-        // conditionals in their route config.
-        return;
+  function DefaultErrorElement() {
+    let error = useRouteError();
+    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("p", {
+      style: {
+        fontStyle: "italic"
       }
+    }, (error == null ? void 0 : error.message) || error), error != null && error.stack ? /*#__PURE__*/React.createElement("pre", {
+      style: preStyles
+    }, error == null ? void 0 : error.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\xA0", /*#__PURE__*/React.createElement("code", {
+      style: codeStyles
+    }, "errorElement"), " props on\xA0", /*#__PURE__*/React.createElement("code", {
+      style: codeStyles
+    }, "<Route>")));
+  }
 
-      if (element.type === React.Fragment) {
-        // Transparently support React.Fragment and its children.
-        routes.push.apply(routes, createRoutesFromChildren(element.props.children));
-        return;
-      }
+  class RenderErrorBoundary extends React.Component {
+    constructor(props) {
+      super(props);
+      this.state = {
+        location: props.location,
+        error: props.error
+      };
+    }
 
-      !(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;
-      let route = {
-        caseSensitive: element.props.caseSensitive,
-        element: element.props.element,
-        index: element.props.index,
-        path: element.props.path
+    static getDerivedStateFromError(error) {
+      return {
+        error: error
       };
+    }
 
-      if (element.props.children) {
-        route.children = createRoutesFromChildren(element.props.children);
-      }
+    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.
 
-      routes.push(route);
-    });
-    return routes;
-  }
-  /**
-   * The parameters that were parsed from the URL path.
-   */
 
-  /**
-   * Returns a path with params interpolated.
-   *
-   * @see https://reactrouter.com/docs/en/v6/api#generatepath
-   */
-  function generatePath(path, params) {
-    if (params === void 0) {
-      params = {};
+      return {
+        error: props.error || state.error,
+        location: state.location
+      };
     }
 
-    return path.replace(/:(\w+)/g, (_, key) => {
-      !(params[key] != null) ?  invariant(false, "Missing \":" + key + "\" param")  : void 0;
-      return params[key];
-    }).replace(/\/*\*$/, _ => params["*"] == null ? "" : params["*"].replace(/^\/*/, "/"));
-  }
-  /**
-   * A RouteMatch contains info about how a route matched a URL.
-   */
-
-  /**
-   * Matches the given routes to a location and returns the match data.
-   *
-   * @see https://reactrouter.com/docs/en/v6/api#matchroutes
-   */
-  function matchRoutes(routes, locationArg, basename) {
-    if (basename === void 0) {
-      basename = "/";
+    componentDidCatch(error, errorInfo) {
+      console.error("React Router caught the following error during render", error, errorInfo);
     }
 
-    let location = typeof locationArg === "string" ? history.parsePath(locationArg) : locationArg;
-    let pathname = stripBasename(location.pathname || "/", basename);
-
-    if (pathname == null) {
-      return null;
+    render() {
+      return this.state.error ? /*#__PURE__*/React.createElement(RouteErrorContext.Provider, {
+        value: this.state.error,
+        children: this.props.component
+      }) : this.props.children;
     }
 
-    let branches = flattenRoutes(routes);
-    rankRouteBranches(branches);
-    let matches = null;
-
-    for (let i = 0; matches == null && i < branches.length; ++i) {
-      matches = matchRouteBranch(branches[i], pathname);
+  }
+  function _renderMatches(matches, parentMatches, dataRouterState) {
+    if (parentMatches === void 0) {
+      parentMatches = [];
     }
 
-    return matches;
-  }
+    if (matches == null) return null;
+    let renderedMatches = matches; // If we have data errors, trim matches to the highest error boundary
 
-  function flattenRoutes(routes, branches, parentsMeta, parentPath) {
-    if (branches === void 0) {
-      branches = [];
-    }
+    let errors = dataRouterState == null ? void 0 : dataRouterState.errors;
 
-    if (parentsMeta === void 0) {
-      parentsMeta = [];
+    if (errors != null) {
+      let errorIndex = renderedMatches.findIndex(m => m.route.id && (errors == null ? void 0 : errors[m.route.id]));
+      !(errorIndex >= 0) ?  router.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));
     }
 
-    if (parentPath === void 0) {
-      parentPath = "";
-    }
-
-    routes.forEach((route, index) => {
-      let meta = {
-        relativePath: route.path || "",
-        caseSensitive: route.caseSensitive === true,
-        childrenIndex: index,
-        route
-      };
-
-      if (meta.relativePath.startsWith("/")) {
-        !meta.relativePath.startsWith(parentPath) ?  invariant(false, "Absolute route path \"" + meta.relativePath + "\" nested under path " + ("\"" + parentPath + "\" is not valid. An absolute child route path ") + "must start with the combined path of all its parent routes.")  : void 0;
-        meta.relativePath = meta.relativePath.slice(parentPath.length);
-      }
+    return renderedMatches.reduceRight((outlet, match, index) => {
+      let error = match.route.id ? errors == null ? void 0 : errors[match.route.id] : null; // Only data routers handle errors
 
-      let path = joinPaths([parentPath, meta.relativePath]);
-      let routesMeta = parentsMeta.concat(meta); // Add the children before adding this route to the array so we traverse the
-      // route tree depth-first and child routes appear before their parents in
-      // the "flattened" version.
-
-      if (route.children && route.children.length > 0) {
-        !(route.index !== true) ?  invariant(false, "Index routes must not have child routes. Please remove " + ("all child routes from route path \"" + path + "\"."))  : void 0;
-        flattenRoutes(route.children, branches, routesMeta, path);
-      } // Routes without a path shouldn't ever match by themselves unless they are
-      // index routes, so don't add them to the list of possible branches.
+      let errorElement = dataRouterState ? match.route.errorElement || /*#__PURE__*/React.createElement(DefaultErrorElement, null) : null;
 
+      let getChildren = () => /*#__PURE__*/React.createElement(RouteContext.Provider, {
+        children: error ? errorElement : match.route.element !== undefined ? match.route.element : outlet,
+        value: {
+          outlet,
+          matches: parentMatches.concat(renderedMatches.slice(0, index + 1))
+        }
+      }); // 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
 
-      if (route.path == null && !route.index) {
-        return;
-      }
 
-      branches.push({
-        path,
-        score: computeScore(path, route.index),
-        routesMeta
-      });
-    });
-    return branches;
+      return dataRouterState && (match.route.errorElement || index === 0) ? /*#__PURE__*/React.createElement(RenderErrorBoundary, {
+        location: dataRouterState.location,
+        component: errorElement,
+        error: error,
+        children: getChildren()
+      }) : getChildren();
+    }, null);
   }
-
-  function rankRouteBranches(branches) {
-    branches.sort((a, b) => a.score !== b.score ? b.score - a.score // Higher score first
-    : compareIndexes(a.routesMeta.map(meta => meta.childrenIndex), b.routesMeta.map(meta => meta.childrenIndex)));
+  var DataRouterHook;
+
+  (function (DataRouterHook) {
+    DataRouterHook["UseLoaderData"] = "useLoaderData";
+    DataRouterHook["UseActionData"] = "useActionData";
+    DataRouterHook["UseRouteError"] = "useRouteError";
+    DataRouterHook["UseNavigation"] = "useNavigation";
+    DataRouterHook["UseRouteLoaderData"] = "useRouteLoaderData";
+    DataRouterHook["UseMatches"] = "useMatches";
+    DataRouterHook["UseRevalidator"] = "useRevalidator";
+  })(DataRouterHook || (DataRouterHook = {}));
+
+  function useDataRouterState(hookName) {
+    let state = React.useContext(DataRouterStateContext);
+    !state ?  router.invariant(false, hookName + " must be used within a DataRouter")  : void 0;
+    return state;
   }
+  /**
+   * Returns the current navigation, defaulting to an "idle" navigation when
+   * no navigation is in progress
+   */
 
-  const paramRe = /^:\w+$/;
-  const dynamicSegmentValue = 3;
-  const indexRouteValue = 2;
-  const emptySegmentValue = 1;
-  const staticSegmentValue = 10;
-  const splatPenalty = -2;
-
-  const isSplat = s => s === "*";
-
-  function computeScore(path, index) {
-    let segments = path.split("/");
-    let initialScore = segments.length;
-
-    if (segments.some(isSplat)) {
-      initialScore += splatPenalty;
-    }
-
-    if (index) {
-      initialScore += indexRouteValue;
-    }
 
-    return segments.filter(s => !isSplat(s)).reduce((score, segment) => score + (paramRe.test(segment) ? dynamicSegmentValue : segment === "" ? emptySegmentValue : staticSegmentValue), initialScore);
+  function useNavigation() {
+    let state = useDataRouterState(DataRouterHook.UseNavigation);
+    return state.navigation;
   }
+  /**
+   * Returns a revalidate function for manually triggering revalidation, as well
+   * as the current state of any manual revalidations
+   */
 
-  function compareIndexes(a, b) {
-    let siblings = a.length === b.length && a.slice(0, -1).every((n, i) => n === b[i]);
-    return siblings ? // If two routes are siblings, we should try to match the earlier sibling
-    // first. This allows people to have fine-grained control over the matching
-    // behavior by simply putting routes with identical paths in the order they
-    // want them tried.
-    a[a.length - 1] - b[b.length - 1] : // Otherwise, it doesn't really make sense to rank non-siblings by index,
-    // so they sort equally.
-    0;
+  function useRevalidator() {
+    let router$1 = React.useContext(DataRouterContext);
+    !router$1 ?  router.invariant(false, "useRevalidator must be used within a DataRouter")  : void 0;
+    let state = useDataRouterState(DataRouterHook.UseRevalidator);
+    return {
+      revalidate: router$1.revalidate,
+      state: state.revalidation
+    };
   }
+  /**
+   * Returns the active route matches, useful for accessing loaderData for
+   * parent/child routes or the route "handle" property
+   */
 
-  function matchRouteBranch(branch, pathname) {
+  function useMatches() {
     let {
-      routesMeta
-    } = branch;
-    let matchedParams = {};
-    let matchedPathname = "/";
-    let matches = [];
-
-    for (let i = 0; i < routesMeta.length; ++i) {
-      let meta = routesMeta[i];
-      let end = i === routesMeta.length - 1;
-      let remainingPathname = matchedPathname === "/" ? pathname : pathname.slice(matchedPathname.length) || "/";
-      let match = matchPath({
-        path: meta.relativePath,
-        caseSensitive: meta.caseSensitive,
-        end
-      }, remainingPathname);
-      if (!match) return null;
-      Object.assign(matchedParams, match.params);
-      let route = meta.route;
-      matches.push({
-        params: matchedParams,
-        pathname: joinPaths([matchedPathname, match.pathname]),
-        pathnameBase: normalizePathname(joinPaths([matchedPathname, match.pathnameBase])),
-        route
-      });
+      matches,
+      loaderData
+    } = useDataRouterState(DataRouterHook.UseMatches);
+    return React.useMemo(() => matches.map(match => {
+      let {
+        pathname,
+        params
+      } = match;
+      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
+   */
 
-      if (match.pathnameBase !== "/") {
-        matchedPathname = joinPaths([matchedPathname, match.pathnameBase]);
-      }
-    }
+  function useLoaderData() {
+    var _state$loaderData;
 
-    return matches;
+    let state = useDataRouterState(DataRouterHook.UseLoaderData);
+    let route = React.useContext(RouteContext);
+    !route ?  router.invariant(false, "useLoaderData must be used inside a RouteContext")  : void 0;
+    let thisRoute = route.matches[route.matches.length - 1];
+    !thisRoute.route.id ?  router.invariant(false, useLoaderData + " can only be used on routes that contain a unique \"id\"")  : void 0;
+    return (_state$loaderData = state.loaderData) == null ? void 0 : _state$loaderData[thisRoute.route.id];
   }
   /**
-   * Renders the result of `matchRoutes()` into a React element.
+   * Returns the loaderData for the given routeId
    */
 
+  function useRouteLoaderData(routeId) {
+    var _state$loaderData2;
 
-  function renderMatches(matches) {
-    return _renderMatches(matches);
+    let state = useDataRouterState(DataRouterHook.UseRouteLoaderData);
+    return (_state$loaderData2 = state.loaderData) == null ? void 0 : _state$loaderData2[routeId];
   }
+  /**
+   * Returns the action data for the nearest ancestor Route action
+   */
 
-  function _renderMatches(matches, parentMatches) {
-    if (parentMatches === void 0) {
-      parentMatches = [];
-    }
-
-    if (matches == null) return null;
-    return matches.reduceRight((outlet, match, index) => {
-      return /*#__PURE__*/React.createElement(RouteContext.Provider, {
-        children: match.route.element !== undefined ? match.route.element : outlet,
-        value: {
-          outlet,
-          matches: parentMatches.concat(matches.slice(0, index + 1))
-        }
-      });
-    }, null);
+  function useActionData() {
+    let state = useDataRouterState(DataRouterHook.UseRouteError);
+    let route = React.useContext(RouteContext);
+    !route ?  router.invariant(false, "useRouteError must be used inside a RouteContext")  : void 0;
+    return Object.values((state == null ? void 0 : state.actionData) || {})[0];
   }
   /**
-   * A PathPattern is used to match on some portion of a URL pathname.
+   * 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() {
+    var _state$errors;
 
-  /**
-   * Performs pattern matching on a URL pathname and returns information about
-   * the match.
-   *
-   * @see https://reactrouter.com/docs/en/v6/api#matchpath
-   */
-  function matchPath(pattern, pathname) {
-    if (typeof pattern === "string") {
-      pattern = {
-        path: pattern,
-        caseSensitive: false,
-        end: true
-      };
+    let error = React.useContext(RouteErrorContext);
+    let state = useDataRouterState(DataRouterHook.UseRouteError);
+    let route = React.useContext(RouteContext);
+    let thisRoute = route.matches[route.matches.length - 1]; // If this was a render error, we put it in a RouteError context inside
+    // of RenderErrorBoundary
+
+    if (error) {
+      return error;
     }
 
-    let [matcher, paramNames] = compilePath(pattern.path, pattern.caseSensitive, pattern.end);
-    let match = pathname.match(matcher);
-    if (!match) return null;
-    let matchedPathname = match[0];
-    let pathnameBase = matchedPathname.replace(/(.)\/+$/, "$1");
-    let captureGroups = match.slice(1);
-    let params = paramNames.reduce((memo, paramName, index) => {
-      // We need to compute the pathnameBase here using the raw splat value
-      // instead of using params["*"] later because it will be decoded then
-      if (paramName === "*") {
-        let splatValue = captureGroups[index] || "";
-        pathnameBase = matchedPathname.slice(0, matchedPathname.length - splatValue.length).replace(/(.)\/+$/, "$1");
-      }
+    !route ?  router.invariant(false, "useRouteError must be used inside a RouteContext")  : void 0;
+    !thisRoute.route.id ?  router.invariant(false, "useRouteError can only be used on routes that contain a unique \"id\"")  : void 0; // Otherwise look for errors from our data router state
 
-      memo[paramName] = safelyDecodeURIComponent(captureGroups[index] || "", paramName);
-      return memo;
-    }, {});
-    return {
-      params,
-      pathname: matchedPathname,
-      pathnameBase,
-      pattern
-    };
+    return (_state$errors = state.errors) == null ? void 0 : _state$errors[thisRoute.route.id];
   }
+  const alreadyWarned = {};
 
-  function compilePath(path, caseSensitive, end) {
-    if (caseSensitive === void 0) {
-      caseSensitive = false;
+  function warningOnce(key, cond, message) {
+    if (!cond && !alreadyWarned[key]) {
+      alreadyWarned[key] = true;
+       router.warning(false, message) ;
     }
+  }
 
-    if (end === void 0) {
-      end = true;
-    }
+  // to avoid issues w.r.t. dual initialization fetches in concurrent rendering.
+  // Data router apps are expected to have a static route tree and are not intended
+  // to be unmounted/remounted at runtime.
 
-     warning(path === "*" || !path.endsWith("*") || path.endsWith("/*"), "Route path \"" + path + "\" will be treated as if it were " + ("\"" + path.replace(/\*$/, "/*") + "\" because the `*` character must ") + "always follow a `/` in the pattern. To get rid of this warning, " + ("please change the route path to \"" + path.replace(/\*$/, "/*") + "\".")) ;
-    let paramNames = [];
-    let regexpSource = "^" + path.replace(/\/*\*?$/, "") // Ignore trailing / and /*, we'll handle it below
-    .replace(/^\/*/, "/") // Make sure it has a leading /
-    .replace(/[\\.*+^$?{}|()[\]]/g, "\\$&") // Escape special regex chars
-    .replace(/:(\w+)/g, (_, paramName) => {
-      paramNames.push(paramName);
-      return "([^\\/]+)";
-    });
+  let routerSingleton;
+  /**
+   * @private
+   */
 
-    if (path.endsWith("*")) {
-      paramNames.push("*");
-      regexpSource += path === "*" || path === "/*" ? "(.*)$" // Already matched the initial /, just match the rest
-      : "(?:\\/(.+)|\\/*)$"; // Don't include the / in params["*"]
-    } else {
-      regexpSource += end ? "\\/*$" // When matching to the end, ignore trailing slashes
-      : // Otherwise, match a word boundary or a proceeding /. The word boundary restricts
-      // parent routes to matching only their own words and nothing more, e.g. parent
-      // route "/home" should not match "/home2".
-      // Additionally, allow paths starting with `.`, `-`, `~`, and url-encoded entities,
-      // but do not consume the character in the matched path so they can match against
-      // nested paths.
-      "(?:(?=[.~-]|%[0-9A-F]{2})|\\b|\\/|$)";
+  function useRenderDataRouter(_ref) {
+    let {
+      children,
+      fallbackElement,
+      routes,
+      createRouter
+    } = _ref;
+
+    if (!routerSingleton) {
+      routerSingleton = createRouter(routes || createRoutesFromChildren(children)).initialize();
     }
 
-    let matcher = new RegExp(regexpSource, caseSensitive ? undefined : "i");
-    return [matcher, paramNames];
-  }
+    let router = routerSingleton; // Sync router state to our component state to force re-renders
 
-  function safelyDecodeURIComponent(value, paramName) {
-    try {
-      return decodeURIComponent(value);
-    } catch (error) {
-       warning(false, "The value for the URL param \"" + paramName + "\" will not be decoded because" + (" the string \"" + value + "\" is a malformed URL segment. This is probably") + (" due to a bad percent encoding (" + error + ").")) ;
-      return value;
+    let state = useSyncExternalStore$2(router.subscribe, () => router.state);
+    let navigator = React.useMemo(() => {
+      return {
+        createHref: router.createHref,
+        go: n => router.navigate(n),
+        push: (to, state) => router.navigate(to, {
+          state
+        }),
+        replace: (to, state) => router.navigate(to, {
+          replace: true,
+          state
+        })
+      };
+    }, [router]);
+
+    if (!state.initialized) {
+      return fallbackElement || null;
     }
+
+    return /*#__PURE__*/React.createElement(DataRouterContext.Provider, {
+      value: router
+    }, /*#__PURE__*/React.createElement(DataRouterStateContext.Provider, {
+      value: state
+    }, /*#__PURE__*/React.createElement(Router, {
+      location: state.location,
+      navigationType: state.historyAction,
+      navigator: navigator
+    }, /*#__PURE__*/React.createElement(DataRoutes, {
+      routes: routes,
+      children: children
+    }))));
+  }
+  function DataMemoryRouter(_ref2) {
+    let {
+      children,
+      initialEntries,
+      initialIndex,
+      hydrationData,
+      fallbackElement,
+      routes
+    } = _ref2;
+    return useRenderDataRouter({
+      children,
+      fallbackElement,
+      routes,
+      createRouter: routes => router.createMemoryRouter({
+        initialEntries,
+        initialIndex,
+        routes,
+        hydrationData
+      })
+    });
   }
+
   /**
-   * Returns a resolved path object relative to the given pathname.
+   * A <Router> that stores all entries in memory.
    *
-   * @see https://reactrouter.com/docs/en/v6/api#resolvepath
+   * @see https://reactrouter.com/docs/en/v6/routers/memory-router
    */
+  function MemoryRouter(_ref3) {
+    let {
+      basename,
+      children,
+      initialEntries,
+      initialIndex
+    } = _ref3;
+    let historyRef = React.useRef();
 
-
-  function resolvePath(to, fromPathname) {
-    if (fromPathname === void 0) {
-      fromPathname = "/";
+    if (historyRef.current == null) {
+      historyRef.current = router.createMemoryHistory({
+        initialEntries,
+        initialIndex,
+        v5Compat: true
+      });
     }
 
-    let {
-      pathname: toPathname,
-      search = "",
-      hash = ""
-    } = typeof to === "string" ? history.parsePath(to) : to;
-    let pathname = toPathname ? toPathname.startsWith("/") ? toPathname : resolvePathname(toPathname, fromPathname) : fromPathname;
-    return {
-      pathname,
-      search: normalizeSearch(search),
-      hash: normalizeHash(hash)
-    };
+    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
+    });
   }
 
-  function resolvePathname(relativePath, fromPathname) {
-    let segments = fromPathname.replace(/\/+$/, "").split("/");
-    let relativeSegments = relativePath.split("/");
-    relativeSegments.forEach(segment => {
-      if (segment === "..") {
-        // Keep the root "" segment so the pathname starts at /
-        if (segments.length > 1) segments.pop();
-      } else if (segment !== ".") {
-        segments.push(segment);
-      }
+  /**
+   * 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/docs/en/v6/components/navigate
+   */
+  function Navigate(_ref4) {
+    let {
+      to,
+      replace,
+      state
+    } = _ref4;
+    !useInRouterContext() ?  router.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;
+     router.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 navigate = useNavigate();
+    React.useEffect(() => {
+      navigate(to, {
+        replace,
+        state
+      });
     });
-    return segments.length > 1 ? segments.join("/") : "/";
+    return null;
   }
 
-  function resolveTo(toArg, routePathnames, locationPathname) {
-    let to = typeof toArg === "string" ? history.parsePath(toArg) : toArg;
-    let toPathname = toArg === "" || to.pathname === "" ? "/" : to.pathname; // If a pathname is explicitly provided in `to`, it should be relative to the
-    // route context. This is explained in `Note on `<Link to>` values` in our
-    // migration guide from v5 as a means of disambiguation between `to` values
-    // that begin with `/` and those that do not. However, this is problematic for
-    // `to` values that do not provide a pathname. `to` can simply be a search or
-    // hash string, in which case we should assume that the navigation is relative
-    // to the current location's pathname and *not* the route pathname.
-
-    let from;
-
-    if (toPathname == null) {
-      from = locationPathname;
-    } else {
-      let routePathnameIndex = routePathnames.length - 1;
+  /**
+   * Renders the child route's element, if there is one.
+   *
+   * @see https://reactrouter.com/docs/en/v6/components/outlet
+   */
+  function Outlet(props) {
+    return useOutlet(props.context);
+  }
 
-      if (toPathname.startsWith("..")) {
-        let toSegments = toPathname.split("/"); // Each leading .. segment means "go up one route" instead of "go up one
-        // URL segment".  This is a key difference from how <a href> works and a
-        // major reason we call this a "to" value instead of a "href".
+  /**
+   * Declares an element that should be rendered at a certain URL path.
+   *
+   * @see https://reactrouter.com/docs/en/v6/components/route
+   */
+  function Route(_props) {
+      router.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>.")  ;
+  }
 
-        while (toSegments[0] === "..") {
-          toSegments.shift();
-          routePathnameIndex -= 1;
-        }
+  /**
+   * 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/docs/en/v6/routers/router
+   */
+  function Router(_ref5) {
+    let {
+      basename: basenameProp = "/",
+      children = null,
+      location: locationProp,
+      navigationType = router.Action.Pop,
+      navigator,
+      static: staticProp = false
+    } = _ref5;
+    !!useInRouterContext() ?  router.invariant(false, "You cannot render a <Router> inside another <Router>." + " You should never have more than one in your app.")  : void 0;
+    let basename = router.normalizePathname(basenameProp);
+    let navigationContext = React.useMemo(() => ({
+      basename,
+      navigator,
+      static: staticProp
+    }), [basename, navigator, staticProp]);
 
-        to.pathname = toSegments.join("/");
-      } // If there are more ".." segments than parent routes, resolve relative to
-      // the root / URL.
+    if (typeof locationProp === "string") {
+      locationProp = router.parsePath(locationProp);
+    }
 
+    let {
+      pathname = "/",
+      search = "",
+      hash = "",
+      state = null,
+      key = "default"
+    } = locationProp;
+    let location = React.useMemo(() => {
+      let trailingPathname = router.stripBasename(pathname, basename);
 
-      from = routePathnameIndex >= 0 ? routePathnames[routePathnameIndex] : "/";
-    }
+      if (trailingPathname == null) {
+        return null;
+      }
 
-    let path = resolvePath(to, from); // Ensure the pathname has a trailing slash if the original to value had one.
+      return {
+        pathname: trailingPathname,
+        search,
+        hash,
+        state,
+        key
+      };
+    }, [basename, pathname, search, hash, state, key]);
+     router.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 (toPathname && toPathname !== "/" && toPathname.endsWith("/") && !path.pathname.endsWith("/")) {
-      path.pathname += "/";
+    if (location == null) {
+      return null;
     }
 
-    return path;
+    return /*#__PURE__*/React.createElement(NavigationContext.Provider, {
+      value: navigationContext
+    }, /*#__PURE__*/React.createElement(LocationContext.Provider, {
+      children: children,
+      value: {
+        location,
+        navigationType
+      }
+    }));
   }
 
-  function getToPathname(to) {
-    // Empty strings should be treated the same as / paths
-    return to === "" || to.pathname === "" ? "/" : typeof to === "string" ? history.parsePath(to).pathname : to.pathname;
+  /**
+   * A container for a nested tree of <Route> elements that renders the branch
+   * that best matches the current location.
+   *
+   * @see https://reactrouter.com/docs/en/v6/components/routes
+   */
+  function Routes(_ref6) {
+    let {
+      children,
+      location
+    } = _ref6;
+    return useRoutes(createRoutesFromChildren(children), location);
   }
 
-  function stripBasename(pathname, basename) {
-    if (basename === "/") return pathname;
+  /**
+   * @private
+   * Used as an extension to <Routes> and accepts a manual `routes` array to be
+   * instead of using JSX children.  Extracted to it's own component to avoid
+   * conditional usage of `useRoutes` if we have to render a `fallbackElement`
+   */
+  function DataRoutes(_ref7) {
+    let {
+      children,
+      location,
+      routes
+    } = _ref7;
+    return useRoutes(routes || createRoutesFromChildren(children), location);
+  } ///////////////////////////////////////////////////////////////////////////////
+  // UTILS
+  ///////////////////////////////////////////////////////////////////////////////
 
-    if (!pathname.toLowerCase().startsWith(basename.toLowerCase())) {
-      return null;
-    }
+  /**
+   * 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/docs/en/v6/utils/create-routes-from-children
+   */
 
-    let nextChar = pathname.charAt(basename.length);
 
-    if (nextChar && nextChar !== "/") {
-      // pathname does not start with basename/
-      return null;
+  function createRoutesFromChildren(children, parentPath) {
+    if (parentPath === void 0) {
+      parentPath = [];
     }
 
-    return pathname.slice(basename.length) || "/";
-  }
+    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;
+      }
 
-  const joinPaths = paths => paths.join("/").replace(/\/\/+/g, "/");
+      if (element.type === React.Fragment) {
+        // Transparently support React.Fragment and its children.
+        routes.push.apply(routes, createRoutesFromChildren(element.props.children, parentPath));
+        return;
+      }
 
-  const normalizePathname = pathname => pathname.replace(/\/+$/, "").replace(/^\/*/, "/");
+      !(element.type === Route) ?  router.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;
+      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,
+        shouldRevalidate: element.props.shouldRevalidate,
+        handle: element.props.handle
+      };
 
-  const normalizeSearch = search => !search || search === "?" ? "" : search.startsWith("?") ? search : "?" + search;
+      if (element.props.children) {
+        route.children = createRoutesFromChildren(element.props.children, treePath);
+      }
 
-  const normalizeHash = hash => !hash || hash === "#" ? "" : hash.startsWith("#") ? hash : "#" + hash; ///////////////////////////////////////////////////////////////////////////////
+      routes.push(route);
+    });
+    return routes;
+  }
+  /**
+   * Renders the result of `matchRoutes()` into a React element.
+   */
+
+  function renderMatches(matches, dataRouterState) {
+    return _renderMatches(matches, undefined, dataRouterState);
+  }
 
   Object.defineProperty(exports, 'NavigationType', {
     enumerable: true,
     get: function () {
-      return history.Action;
+      return router.Action;
     }
   });
   Object.defineProperty(exports, 'createPath', {
     enumerable: true,
     get: function () {
-      return history.createPath;
+      return router.createPath;
+    }
+  });
+  Object.defineProperty(exports, 'generatePath', {
+    enumerable: true,
+    get: function () {
+      return router.generatePath;
+    }
+  });
+  Object.defineProperty(exports, 'isRouteErrorResponse', {
+    enumerable: true,
+    get: function () {
+      return router.isRouteErrorResponse;
+    }
+  });
+  Object.defineProperty(exports, 'json', {
+    enumerable: true,
+    get: function () {
+      return router.json;
+    }
+  });
+  Object.defineProperty(exports, 'matchPath', {
+    enumerable: true,
+    get: function () {
+      return router.matchPath;
+    }
+  });
+  Object.defineProperty(exports, 'matchRoutes', {
+    enumerable: true,
+    get: function () {
+      return router.matchRoutes;
     }
   });
   Object.defineProperty(exports, 'parsePath', {
     enumerable: true,
     get: function () {
-      return history.parsePath;
+      return router.parsePath;
+    }
+  });
+  Object.defineProperty(exports, 'redirect', {
+    enumerable: true,
+    get: function () {
+      return router.redirect;
+    }
+  });
+  Object.defineProperty(exports, 'resolvePath', {
+    enumerable: true,
+    get: function () {
+      return router.resolvePath;
     }
   });
+  exports.DataMemoryRouter = DataMemoryRouter;
   exports.MemoryRouter = MemoryRouter;
   exports.Navigate = Navigate;
   exports.Outlet = Outlet;
   exports.Route = Route;
   exports.Router = Router;
   exports.Routes = Routes;
+  exports.UNSAFE_DataRouterContext = DataRouterContext;
+  exports.UNSAFE_DataRouterStateContext = DataRouterStateContext;
   exports.UNSAFE_LocationContext = LocationContext;
   exports.UNSAFE_NavigationContext = NavigationContext;
   exports.UNSAFE_RouteContext = RouteContext;
   exports.createRoutesFromChildren = createRoutesFromChildren;
-  exports.generatePath = generatePath;
-  exports.matchPath = matchPath;
-  exports.matchRoutes = matchRoutes;
   exports.renderMatches = renderMatches;
-  exports.resolvePath = resolvePath;
+  exports.useActionData = useActionData;
   exports.useHref = useHref;
   exports.useInRouterContext = useInRouterContext;
+  exports.useLoaderData = useLoaderData;
   exports.useLocation = useLocation;
   exports.useMatch = useMatch;
+  exports.useMatches = useMatches;
   exports.useNavigate = useNavigate;
+  exports.useNavigation = useNavigation;
   exports.useNavigationType = useNavigationType;
   exports.useOutlet = useOutlet;
   exports.useOutletContext = useOutletContext;
   exports.useParams = useParams;
+  exports.useRenderDataRouter = useRenderDataRouter;
   exports.useResolvedPath = useResolvedPath;
+  exports.useRevalidator = useRevalidator;
+  exports.useRouteError = useRouteError;
+  exports.useRouteLoaderData = useRouteLoaderData;
   exports.useRoutes = useRoutes;
 
   Object.defineProperty(exports, '__esModule', { value: true });