react-router 6.4.0-pre.8 → 6.4.0

package/dist/react-router.development.js

@@ -1,5 +1,5 @@
 /**
- * React Router v6.4.0-pre.8
+ * React Router v6.4.0
  *
  * Copyright (c) Remix Software Inc.
  *
@@ -8,8 +8,8 @@
  *
  * @license MIT
  */
-import { invariant, resolveTo, getToPathname, joinPaths, matchPath, warning, parsePath, matchRoutes, isRouteErrorResponse, createMemoryRouter, createMemoryHistory, stripBasename, Action } from '@remix-run/router';
-export { Action as NavigationType, createPath, generatePath, isRouteErrorResponse, json, matchPath, matchRoutes, parsePath, redirect, resolvePath } from '@remix-run/router';
+import { invariant, resolveTo, joinPaths, matchPath, warning, 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';
 
 /**
@@ -188,8 +188,13 @@ function useSyncExternalStore$1(subscribe, getSnapshot, getServerSnapshot) {
 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 ? // @ts-expect-error
-(module => module.useSyncExternalStore)(React) : shim;
+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);
 
@@ -203,6 +208,12 @@ const DataRouterStateContext = /*#__PURE__*/React.createContext(null);
   DataRouterStateContext.displayName = "DataRouterState";
 }
 
+const AwaitContext = /*#__PURE__*/React.createContext(null);
+
+{
+  AwaitContext.displayName = "Await";
+}
+
 const NavigationContext = /*#__PURE__*/React.createContext(null);
 
 {
@@ -237,7 +248,9 @@ const RouteErrorContext = /*#__PURE__*/React.createContext(null);
  * @see https://reactrouter.com/docs/en/v6/hooks/use-href
  */
 
-function useHref(to) {
+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;
@@ -249,23 +262,16 @@ function useHref(to) {
     hash,
     pathname,
     search
-  } = useResolvedPath(to);
-  let joinedPathname = pathname;
+  } = 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 !== "/") {
-    let toPathname = getToPathname(to); // Only append a trailing slash to the raw basename if the basename doesn't
-    // already have one and this wasn't specifically a route to "".  This
-    // allows folks to control the trailing slash behavior when using a basename
-
-    let appendSlash = !basename.endsWith("/") && to !== "" && to?.pathname !== "" && toPathname != null && toPathname.endsWith("/");
-
-    if (pathname !== "/") {
-      joinedPathname = joinPaths([basename, pathname]);
-    } else if (appendSlash) {
-      joinedPathname = basename + "/";
-    } else {
-      joinedPathname = basename;
-    }
+    joinedPathname = pathname === "/" ? basename : joinPaths([basename, pathname]);
   }
 
   return navigator.createHref({
@@ -388,14 +394,13 @@ function useNavigate() {
       return;
     }
 
-    let path = resolveTo(to, JSON.parse(routePathnamesJson), locationPathname);
+    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 !== "/") {
-      // If this was a blank path, just use the basename directly, this gives
-      // the user control over trailing slash behavior
-      let toPath = typeof to === "string" ? parsePath(to) : to;
-      let isBlankPath = toPath.pathname == null || toPath.pathname === "";
-      path.pathname = isBlankPath ? basename : joinPaths([basename, path.pathname]);
+      path.pathname = path.pathname === "/" ? basename : joinPaths([basename, path.pathname]);
     }
 
     (!!options.replace ? navigator.replace : navigator.push)(path, options.state, options);
@@ -450,7 +455,9 @@ function useParams() {
  * @see https://reactrouter.com/docs/en/v6/hooks/use-resolved-path
  */
 
-function useResolvedPath(to) {
+function useResolvedPath(to, {
+  relative
+} = {}) {
   let {
     matches
   } = React.useContext(RouteContext);
@@ -458,7 +465,7 @@ function useResolvedPath(to) {
     pathname: locationPathname
   } = useLocation();
   let routePathnamesJson = JSON.stringify(getPathContributingMatches(matches).map(match => match.pathnameBase));
-  return React.useMemo(() => resolveTo(to, JSON.parse(routePathnamesJson), locationPathname), [to, routePathnamesJson, locationPathname]);
+  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
@@ -530,16 +537,38 @@ function useRoutes(routes, locationArg) {
     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, {
+  let renderedMatches = _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, dataRouterStateContext || undefined);
+  })), 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) {
+    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?.message || JSON.stringify(error);
+  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",
@@ -553,9 +582,9 @@ function DefaultErrorElement() {
     style: {
       fontStyle: "italic"
     }
-  }, message), error?.stack ? /*#__PURE__*/React.createElement("pre", {
+  }, message), stack ? /*#__PURE__*/React.createElement("pre", {
     style: preStyles
-  }, 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\u00A0", /*#__PURE__*/React.createElement("code", {
+  }, 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
@@ -615,6 +644,24 @@ class RenderErrorBoundary extends React.Component {
   }
 
 }
+
+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) {
@@ -641,13 +688,13 @@ function _renderMatches(matches, parentMatches = [], dataRouterState) {
 
     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: {
+    let getChildren = () => /*#__PURE__*/React.createElement(RenderedRoute, {
+      match: match,
+      routeContext: {
         outlet,
         matches: parentMatches.concat(renderedMatches.slice(0, index + 1))
       }
-    }); // Only wrap in an error boundary within data router usages when we have an
+    }, 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
 
@@ -674,7 +721,7 @@ var DataRouterHook;
 
 function useDataRouterState(hookName) {
   let state = React.useContext(DataRouterStateContext);
-  !state ? invariant(false, `${hookName} must be used within a DataRouter`)  : void 0;
+  !state ? invariant(false, `${hookName} must be used within a DataRouterStateContext`)  : void 0;
   return state;
 }
 /**
@@ -693,11 +740,11 @@ function useNavigation() {
  */
 
 function useRevalidator() {
-  let router = React.useContext(DataRouterContext);
-  !router ? invariant(false, `useRevalidator must be used within a DataRouter`)  : void 0;
+  let dataRouterContext = React.useContext(DataRouterContext);
+  !dataRouterContext ? invariant(false, `useRevalidator must be used within a DataRouterContext`)  : void 0;
   let state = useDataRouterState(DataRouterHook.UseRevalidator);
   return {
-    revalidate: router.revalidate,
+    revalidate: dataRouterContext.router.revalidate,
     state: state.revalidation
   };
 }
@@ -715,7 +762,10 @@ function useMatches() {
     let {
       pathname,
       params
-    } = match;
+    } = 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,
@@ -777,6 +827,22 @@ function useRouteError() {
 
   return state.errors?.[thisRoute.route.id];
 }
+/**
+ * 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) {
@@ -786,80 +852,51 @@ function warningOnce(key, cond, message) {
   }
 }
 
-// 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.
-
-let routerSingleton;
 /**
- * @private
+ * Given a Remix Router instance, render the appropriate UI
  */
 
-function useRenderDataRouter({
-  children,
+function RouterProvider({
   fallbackElement,
-  routes,
-  createRouter
+  router
 }) {
-  if (!routerSingleton) {
-    routerSingleton = createRouter(routes || createRoutesFromChildren(children)).initialize();
-  }
-
-  let router = routerSingleton; // Sync router state to our component state to force re-renders
-
-  let state = useSyncExternalStore(router.subscribe, () => router.state);
+  // 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,
       go: n => router.navigate(n),
       push: (to, state, opts) => router.navigate(to, {
         state,
-        resetScroll: opts?.resetScroll
+        preventScrollReset: opts?.preventScrollReset
       }),
       replace: (to, state, opts) => router.navigate(to, {
         replace: true,
         state,
-        resetScroll: opts?.resetScroll
+        preventScrollReset: opts?.preventScrollReset
       })
     };
   }, [router]);
-
-  if (!state.initialized) {
-    return /*#__PURE__*/React.createElement(React.Fragment, null, fallbackElement);
-  }
-
+  let basename = router.basename || "/";
   return /*#__PURE__*/React.createElement(DataRouterContext.Provider, {
-    value: router
+    value: {
+      router,
+      navigator,
+      static: false,
+      // Do we need this?
+      basename
+    }
   }, /*#__PURE__*/React.createElement(DataRouterStateContext.Provider, {
     value: state
   }, /*#__PURE__*/React.createElement(Router, {
-    location: state.location,
-    navigationType: state.historyAction,
+    basename: router.basename,
+    location: router.state.location,
+    navigationType: router.state.historyAction,
     navigator: navigator
-  }, /*#__PURE__*/React.createElement(DataRoutes, {
-    routes: routes,
-    children: children
-  }))));
-}
-function DataMemoryRouter({
-  children,
-  initialEntries,
-  initialIndex,
-  hydrationData,
-  fallbackElement,
-  routes
-}) {
-  return useRenderDataRouter({
-    children,
-    fallbackElement,
-    routes,
-    createRouter: routes => createMemoryRouter({
-      initialEntries,
-      initialIndex,
-      routes,
-      hydrationData
-    })
-  });
+  }, router.state.initialized ? /*#__PURE__*/React.createElement(Routes, null) : fallbackElement)));
 }
 /**
  * A <Router> that stores all entries in memory.
@@ -910,17 +947,27 @@ function MemoryRouter({
 function Navigate({
   to,
   replace,
-  state
+  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
+      state,
+      relative
     });
   });
   return null;
@@ -1024,21 +1071,151 @@ function Routes({
   children,
   location
 }) {
-  return useRoutes(createRoutesFromChildren(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);
 }
 /**
- * @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`
+ * Component to use for rendering lazily loaded data from returning defer()
+ * in a loader function
  */
 
-function DataRoutes({
+function Await({
   children,
-  location,
-  routes
+  errorElement,
+  resolve
 }) {
-  return useRoutes(routes || createRoutesFromChildren(children), location);
+  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
 ///////////////////////////////////////////////////////////////////////////////
@@ -1078,6 +1255,7 @@ function createRoutesFromChildren(children, parentPath = []) {
       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
     };
@@ -1097,6 +1275,40 @@ function createRoutesFromChildren(children, parentPath = []) {
 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 { DataMemoryRouter, MemoryRouter, Navigate, Outlet, Route, Router, Routes, DataRouterContext as UNSAFE_DataRouterContext, DataRouterStateContext as UNSAFE_DataRouterStateContext, LocationContext as UNSAFE_LocationContext, NavigationContext as UNSAFE_NavigationContext, RouteContext as UNSAFE_RouteContext, createRoutesFromChildren, renderMatches, useActionData, useHref, useInRouterContext, useLoaderData, useLocation, useMatch, useMatches, useNavigate, useNavigation, useNavigationType, useOutlet, useOutletContext, useParams, useRenderDataRouter, useResolvedPath, useRevalidator, useRouteError, useRouteLoaderData, useRoutes };
+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