{"version":3,"file":"static/js/28689.54b52e2c.chunk.js","mappings":"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","sources":["webpack:///./node_modules/react-router/lib/context.ts","webpack:///./node_modules/react-router/lib/hooks.tsx","webpack:///./node_modules/react-router/lib/components.tsx","webpack:///./node_modules/react-router/index.ts"],"sourcesContent":["import * as React from \"react\";\nimport type {\n  AgnosticIndexRouteObject,\n  AgnosticNonIndexRouteObject,\n  AgnosticRouteMatch,\n  History,\n  LazyRouteFunction,\n  Location,\n  Action as NavigationType,\n  RelativeRoutingType,\n  Router,\n  StaticHandlerContext,\n  To,\n  TrackedPromise,\n} from \"@remix-run/router\";\n\n// Create react-specific types from the agnostic types in @remix-run/router to\n// export from react-router\nexport interface IndexRouteObject {\n  caseSensitive?: AgnosticIndexRouteObject[\"caseSensitive\"];\n  path?: AgnosticIndexRouteObject[\"path\"];\n  id?: AgnosticIndexRouteObject[\"id\"];\n  loader?: AgnosticIndexRouteObject[\"loader\"];\n  action?: AgnosticIndexRouteObject[\"action\"];\n  hasErrorBoundary?: AgnosticIndexRouteObject[\"hasErrorBoundary\"];\n  shouldRevalidate?: AgnosticIndexRouteObject[\"shouldRevalidate\"];\n  handle?: AgnosticIndexRouteObject[\"handle\"];\n  index: true;\n  children?: undefined;\n  element?: React.ReactNode | null;\n  hydrateFallbackElement?: React.ReactNode | null;\n  errorElement?: React.ReactNode | null;\n  Component?: React.ComponentType | null;\n  HydrateFallback?: React.ComponentType | null;\n  ErrorBoundary?: React.ComponentType | null;\n  lazy?: LazyRouteFunction<RouteObject>;\n}\n\nexport interface NonIndexRouteObject {\n  caseSensitive?: AgnosticNonIndexRouteObject[\"caseSensitive\"];\n  path?: AgnosticNonIndexRouteObject[\"path\"];\n  id?: AgnosticNonIndexRouteObject[\"id\"];\n  loader?: AgnosticNonIndexRouteObject[\"loader\"];\n  action?: AgnosticNonIndexRouteObject[\"action\"];\n  hasErrorBoundary?: AgnosticNonIndexRouteObject[\"hasErrorBoundary\"];\n  shouldRevalidate?: AgnosticNonIndexRouteObject[\"shouldRevalidate\"];\n  handle?: AgnosticNonIndexRouteObject[\"handle\"];\n  index?: false;\n  children?: RouteObject[];\n  element?: React.ReactNode | null;\n  hydrateFallbackElement?: React.ReactNode | null;\n  errorElement?: React.ReactNode | null;\n  Component?: React.ComponentType | null;\n  HydrateFallback?: React.ComponentType | null;\n  ErrorBoundary?: React.ComponentType | null;\n  lazy?: LazyRouteFunction<RouteObject>;\n}\n\nexport type RouteObject = IndexRouteObject | NonIndexRouteObject;\n\nexport type DataRouteObject = RouteObject & {\n  children?: DataRouteObject[];\n  id: string;\n};\n\nexport interface RouteMatch<\n  ParamKey extends string = string,\n  RouteObjectType extends RouteObject = RouteObject\n> extends AgnosticRouteMatch<ParamKey, RouteObjectType> {}\n\nexport interface DataRouteMatch extends RouteMatch<string, DataRouteObject> {}\n\nexport interface DataRouterContextObject\n  // Omit `future` since those can be pulled from the `router`\n  // `NavigationContext` needs future since it doesn't have a `router` in all cases\n  extends Omit<NavigationContextObject, \"future\"> {\n  router: Router;\n  staticContext?: StaticHandlerContext;\n}\n\nexport const DataRouterContext =\n  React.createContext<DataRouterContextObject | null>(null);\nif (__DEV__) {\n  DataRouterContext.displayName = \"DataRouter\";\n}\n\nexport const DataRouterStateContext = React.createContext<\n  Router[\"state\"] | null\n>(null);\nif (__DEV__) {\n  DataRouterStateContext.displayName = \"DataRouterState\";\n}\n\nexport const AwaitContext = React.createContext<TrackedPromise | null>(null);\nif (__DEV__) {\n  AwaitContext.displayName = \"Await\";\n}\n\nexport interface NavigateOptions {\n  replace?: boolean;\n  state?: any;\n  preventScrollReset?: boolean;\n  relative?: RelativeRoutingType;\n  unstable_flushSync?: boolean;\n  unstable_viewTransition?: boolean;\n}\n\n/**\n * A Navigator is a \"location changer\"; it's how you get to different locations.\n *\n * Every history instance conforms to the Navigator interface, but the\n * distinction is useful primarily when it comes to the low-level `<Router>` API\n * where both the location and a navigator must be provided separately in order\n * to avoid \"tearing\" that may occur in a suspense-enabled app if the action\n * and/or location were to be read directly from the history instance.\n */\nexport interface Navigator {\n  createHref: History[\"createHref\"];\n  // Optional for backwards-compat with Router/HistoryRouter usage (edge case)\n  encodeLocation?: History[\"encodeLocation\"];\n  go: History[\"go\"];\n  push(to: To, state?: any, opts?: NavigateOptions): void;\n  replace(to: To, state?: any, opts?: NavigateOptions): void;\n}\n\ninterface NavigationContextObject {\n  basename: string;\n  navigator: Navigator;\n  static: boolean;\n  future: {\n    v7_relativeSplatPath: boolean;\n  };\n}\n\nexport const NavigationContext = React.createContext<NavigationContextObject>(\n  null!\n);\n\nif (__DEV__) {\n  NavigationContext.displayName = \"Navigation\";\n}\n\ninterface LocationContextObject {\n  location: Location;\n  navigationType: NavigationType;\n}\n\nexport const LocationContext = React.createContext<LocationContextObject>(\n  null!\n);\n\nif (__DEV__) {\n  LocationContext.displayName = \"Location\";\n}\n\nexport interface RouteContextObject {\n  outlet: React.ReactElement | null;\n  matches: RouteMatch[];\n  isDataRoute: boolean;\n}\n\nexport const RouteContext = React.createContext<RouteContextObject>({\n  outlet: null,\n  matches: [],\n  isDataRoute: false,\n});\n\nif (__DEV__) {\n  RouteContext.displayName = \"Route\";\n}\n\nexport const RouteErrorContext = React.createContext<any>(null);\n\nif (__DEV__) {\n  RouteErrorContext.displayName = \"RouteError\";\n}\n","import * as React from \"react\";\nimport type {\n  Blocker,\n  BlockerFunction,\n  Location,\n  ParamParseKey,\n  Params,\n  Path,\n  PathMatch,\n  PathPattern,\n  RelativeRoutingType,\n  Router as RemixRouter,\n  RevalidationState,\n  To,\n  UIMatch,\n} from \"@remix-run/router\";\nimport {\n  IDLE_BLOCKER,\n  Action as NavigationType,\n  UNSAFE_convertRouteMatchToUiMatch as convertRouteMatchToUiMatch,\n  UNSAFE_getResolveToMatches as getResolveToMatches,\n  UNSAFE_invariant as invariant,\n  isRouteErrorResponse,\n  joinPaths,\n  matchPath,\n  matchRoutes,\n  parsePath,\n  resolveTo,\n  stripBasename,\n  UNSAFE_warning as warning,\n} from \"@remix-run/router\";\n\nimport type {\n  DataRouteMatch,\n  NavigateOptions,\n  RouteContextObject,\n  RouteMatch,\n  RouteObject,\n} from \"./context\";\nimport {\n  AwaitContext,\n  DataRouterContext,\n  DataRouterStateContext,\n  LocationContext,\n  NavigationContext,\n  RouteContext,\n  RouteErrorContext,\n} from \"./context\";\n\n/**\n * Returns the full href for the given \"to\" value. This is useful for building\n * custom links that are also accessible and preserve right-click behavior.\n *\n * @see https://reactrouter.com/hooks/use-href\n */\nexport function useHref(\n  to: To,\n  { relative }: { relative?: RelativeRoutingType } = {}\n): string {\n  invariant(\n    useInRouterContext(),\n    // TODO: This error is probably because they somehow have 2 versions of the\n    // router loaded. We can help them understand how to avoid that.\n    `useHref() may be used only in the context of a <Router> component.`\n  );\n\n  let { basename, navigator } = React.useContext(NavigationContext);\n  let { hash, pathname, search } = useResolvedPath(to, { relative });\n\n  let joinedPathname = pathname;\n\n  // If we're operating within a basename, prepend it to the pathname prior\n  // to creating the href.  If this is a root navigation, then just use the raw\n  // basename which allows the basename to have full control over the presence\n  // of a trailing slash on root links\n  if (basename !== \"/\") {\n    joinedPathname =\n      pathname === \"/\" ? basename : joinPaths([basename, pathname]);\n  }\n\n  return navigator.createHref({ pathname: joinedPathname, search, hash });\n}\n\n/**\n * Returns true if this component is a descendant of a `<Router>`.\n *\n * @see https://reactrouter.com/hooks/use-in-router-context\n */\nexport function useInRouterContext(): boolean {\n  return React.useContext(LocationContext) != null;\n}\n\n/**\n * Returns the current location object, which represents the current URL in web\n * browsers.\n *\n * Note: If you're using this it may mean you're doing some of your own\n * \"routing\" in your app, and we'd like to know what your use case is. We may\n * be able to provide something higher-level to better suit your needs.\n *\n * @see https://reactrouter.com/hooks/use-location\n */\nexport function useLocation(): Location {\n  invariant(\n    useInRouterContext(),\n    // TODO: This error is probably because they somehow have 2 versions of the\n    // router loaded. We can help them understand how to avoid that.\n    `useLocation() may be used only in the context of a <Router> component.`\n  );\n\n  return React.useContext(LocationContext).location;\n}\n\n/**\n * Returns the current navigation action which describes how the router came to\n * the current location, either by a pop, push, or replace on the history stack.\n *\n * @see https://reactrouter.com/hooks/use-navigation-type\n */\nexport function useNavigationType(): NavigationType {\n  return React.useContext(LocationContext).navigationType;\n}\n\n/**\n * Returns a PathMatch object if the given pattern matches the current URL.\n * This is useful for components that need to know \"active\" state, e.g.\n * `<NavLink>`.\n *\n * @see https://reactrouter.com/hooks/use-match\n */\nexport function useMatch<\n  ParamKey extends ParamParseKey<Path>,\n  Path extends string\n>(pattern: PathPattern<Path> | Path): PathMatch<ParamKey> | null {\n  invariant(\n    useInRouterContext(),\n    // TODO: This error is probably because they somehow have 2 versions of the\n    // router loaded. We can help them understand how to avoid that.\n    `useMatch() may be used only in the context of a <Router> component.`\n  );\n\n  let { pathname } = useLocation();\n  return React.useMemo(\n    () => matchPath<ParamKey, Path>(pattern, pathname),\n    [pathname, pattern]\n  );\n}\n\n/**\n * The interface for the navigate() function returned from useNavigate().\n */\nexport interface NavigateFunction {\n  (to: To, options?: NavigateOptions): void;\n  (delta: number): void;\n}\n\nconst navigateEffectWarning =\n  `You should call navigate() in a React.useEffect(), not when ` +\n  `your component is first rendered.`;\n\n// Mute warnings for calls to useNavigate in SSR environments\nfunction useIsomorphicLayoutEffect(\n  cb: Parameters<typeof React.useLayoutEffect>[0]\n) {\n  let isStatic = React.useContext(NavigationContext).static;\n  if (!isStatic) {\n    // We should be able to get rid of this once react 18.3 is released\n    // See: https://github.com/facebook/react/pull/26395\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    React.useLayoutEffect(cb);\n  }\n}\n\n/**\n * Returns an imperative method for changing the location. Used by `<Link>`s, but\n * may also be used by other elements to change the location.\n *\n * @see https://reactrouter.com/hooks/use-navigate\n */\nexport function useNavigate(): NavigateFunction {\n  let { isDataRoute } = React.useContext(RouteContext);\n  // Conditional usage is OK here because the usage of a data router is static\n  // eslint-disable-next-line react-hooks/rules-of-hooks\n  return isDataRoute ? useNavigateStable() : useNavigateUnstable();\n}\n\nfunction useNavigateUnstable(): NavigateFunction {\n  invariant(\n    useInRouterContext(),\n    // TODO: This error is probably because they somehow have 2 versions of the\n    // router loaded. We can help them understand how to avoid that.\n    `useNavigate() may be used only in the context of a <Router> component.`\n  );\n\n  let dataRouterContext = React.useContext(DataRouterContext);\n  let { basename, future, navigator } = React.useContext(NavigationContext);\n  let { matches } = React.useContext(RouteContext);\n  let { pathname: locationPathname } = useLocation();\n\n  let routePathnamesJson = JSON.stringify(\n    getResolveToMatches(matches, future.v7_relativeSplatPath)\n  );\n\n  let activeRef = React.useRef(false);\n  useIsomorphicLayoutEffect(() => {\n    activeRef.current = true;\n  });\n\n  let navigate: NavigateFunction = React.useCallback(\n    (to: To | number, options: NavigateOptions = {}) => {\n      warning(activeRef.current, navigateEffectWarning);\n\n      // Short circuit here since if this happens on first render the navigate\n      // is useless because we haven't wired up our history listener yet\n      if (!activeRef.current) return;\n\n      if (typeof to === \"number\") {\n        navigator.go(to);\n        return;\n      }\n\n      let path = resolveTo(\n        to,\n        JSON.parse(routePathnamesJson),\n        locationPathname,\n        options.relative === \"path\"\n      );\n\n      // If we're operating within a basename, prepend it to the pathname prior\n      // to handing off to history (but only if we're not in a data router,\n      // otherwise it'll prepend the basename inside of the router).\n      // If this is a root navigation, then we navigate to the raw basename\n      // which allows the basename to have full control over the presence of a\n      // trailing slash on root links\n      if (dataRouterContext == null && basename !== \"/\") {\n        path.pathname =\n          path.pathname === \"/\"\n            ? basename\n            : joinPaths([basename, path.pathname]);\n      }\n\n      (!!options.replace ? navigator.replace : navigator.push)(\n        path,\n        options.state,\n        options\n      );\n    },\n    [\n      basename,\n      navigator,\n      routePathnamesJson,\n      locationPathname,\n      dataRouterContext,\n    ]\n  );\n\n  return navigate;\n}\n\nconst OutletContext = React.createContext<unknown>(null);\n\n/**\n * Returns the context (if provided) for the child route at this level of the route\n * hierarchy.\n * @see https://reactrouter.com/hooks/use-outlet-context\n */\nexport function useOutletContext<Context = unknown>(): Context {\n  return React.useContext(OutletContext) as Context;\n}\n\n/**\n * Returns the element for the child route at this level of the route\n * hierarchy. Used internally by `<Outlet>` to render child routes.\n *\n * @see https://reactrouter.com/hooks/use-outlet\n */\nexport function useOutlet(context?: unknown): React.ReactElement | null {\n  let outlet = React.useContext(RouteContext).outlet;\n  if (outlet) {\n    return (\n      <OutletContext.Provider value={context}>{outlet}</OutletContext.Provider>\n    );\n  }\n  return outlet;\n}\n\n/**\n * Returns an object of key/value pairs of the dynamic params from the current\n * URL that were matched by the route path.\n *\n * @see https://reactrouter.com/hooks/use-params\n */\nexport function useParams<\n  ParamsOrKey extends string | Record<string, string | undefined> = string\n>(): Readonly<\n  [ParamsOrKey] extends [string] ? Params<ParamsOrKey> : Partial<ParamsOrKey>\n> {\n  let { matches } = React.useContext(RouteContext);\n  let routeMatch = matches[matches.length - 1];\n  return routeMatch ? (routeMatch.params as any) : {};\n}\n\n/**\n * Resolves the pathname of the given `to` value against the current location.\n *\n * @see https://reactrouter.com/hooks/use-resolved-path\n */\nexport function useResolvedPath(\n  to: To,\n  { relative }: { relative?: RelativeRoutingType } = {}\n): Path {\n  let { future } = React.useContext(NavigationContext);\n  let { matches } = React.useContext(RouteContext);\n  let { pathname: locationPathname } = useLocation();\n  let routePathnamesJson = JSON.stringify(\n    getResolveToMatches(matches, future.v7_relativeSplatPath)\n  );\n\n  return React.useMemo(\n    () =>\n      resolveTo(\n        to,\n        JSON.parse(routePathnamesJson),\n        locationPathname,\n        relative === \"path\"\n      ),\n    [to, routePathnamesJson, locationPathname, relative]\n  );\n}\n\n/**\n * Returns the element of the route that matched the current location, prepared\n * with the correct context to render the remainder of the route tree. Route\n * elements in the tree must render an `<Outlet>` to render their child route's\n * element.\n *\n * @see https://reactrouter.com/hooks/use-routes\n */\nexport function useRoutes(\n  routes: RouteObject[],\n  locationArg?: Partial<Location> | string\n): React.ReactElement | null {\n  return useRoutesImpl(routes, locationArg);\n}\n\n// Internal implementation with accept optional param for RouterProvider usage\nexport function useRoutesImpl(\n  routes: RouteObject[],\n  locationArg?: Partial<Location> | string,\n  dataRouterState?: RemixRouter[\"state\"],\n  future?: RemixRouter[\"future\"]\n): React.ReactElement | null {\n  invariant(\n    useInRouterContext(),\n    // TODO: This error is probably because they somehow have 2 versions of the\n    // router loaded. We can help them understand how to avoid that.\n    `useRoutes() may be used only in the context of a <Router> component.`\n  );\n\n  let { navigator } = React.useContext(NavigationContext);\n  let { matches: parentMatches } = React.useContext(RouteContext);\n  let routeMatch = parentMatches[parentMatches.length - 1];\n  let parentParams = routeMatch ? routeMatch.params : {};\n  let parentPathname = routeMatch ? routeMatch.pathname : \"/\";\n  let parentPathnameBase = routeMatch ? routeMatch.pathnameBase : \"/\";\n  let parentRoute = routeMatch && routeMatch.route;\n\n  if (__DEV__) {\n    // You won't get a warning about 2 different <Routes> under a <Route>\n    // without a trailing *, but this is a best-effort warning anyway since we\n    // cannot even give the warning unless they land at the parent route.\n    //\n    // Example:\n    //\n    // <Routes>\n    //   {/* This route path MUST end with /* because otherwise\n    //       it will never match /blog/post/123 */}\n    //   <Route path=\"blog\" element={<Blog />} />\n    //   <Route path=\"blog/feed\" element={<BlogFeed />} />\n    // </Routes>\n    //\n    // function Blog() {\n    //   return (\n    //     <Routes>\n    //       <Route path=\"post/:id\" element={<Post />} />\n    //     </Routes>\n    //   );\n    // }\n    let parentPath = (parentRoute && parentRoute.path) || \"\";\n    warningOnce(\n      parentPathname,\n      !parentRoute || parentPath.endsWith(\"*\"),\n      `You rendered descendant <Routes> (or called \\`useRoutes()\\`) at ` +\n        `\"${parentPathname}\" (under <Route path=\"${parentPath}\">) but the ` +\n        `parent route path has no trailing \"*\". This means if you navigate ` +\n        `deeper, the parent won't match anymore and therefore the child ` +\n        `routes will never render.\\n\\n` +\n        `Please change the parent <Route path=\"${parentPath}\"> to <Route ` +\n        `path=\"${parentPath === \"/\" ? \"*\" : `${parentPath}/*`}\">.`\n    );\n  }\n\n  let locationFromContext = useLocation();\n\n  let location;\n  if (locationArg) {\n    let parsedLocationArg =\n      typeof locationArg === \"string\" ? parsePath(locationArg) : locationArg;\n\n    invariant(\n      parentPathnameBase === \"/\" ||\n        parsedLocationArg.pathname?.startsWith(parentPathnameBase),\n      `When overriding the location using \\`<Routes location>\\` or \\`useRoutes(routes, location)\\`, ` +\n        `the location pathname must begin with the portion of the URL pathname that was ` +\n        `matched by all parent routes. The current pathname base is \"${parentPathnameBase}\" ` +\n        `but pathname \"${parsedLocationArg.pathname}\" was given in the \\`location\\` prop.`\n    );\n\n    location = parsedLocationArg;\n  } else {\n    location = locationFromContext;\n  }\n\n  let pathname = location.pathname || \"/\";\n\n  let remainingPathname = pathname;\n  if (parentPathnameBase !== \"/\") {\n    // Determine the remaining pathname by removing the # of URL segments the\n    // parentPathnameBase has, instead of removing based on character count.\n    // This is because we can't guarantee that incoming/outgoing encodings/\n    // decodings will match exactly.\n    // We decode paths before matching on a per-segment basis with\n    // decodeURIComponent(), but we re-encode pathnames via `new URL()` so they\n    // match what `window.location.pathname` would reflect.  Those don't 100%\n    // align when it comes to encoded URI characters such as % and &.\n    //\n    // So we may end up with:\n    //   pathname:           \"/descendant/a%25b/match\"\n    //   parentPathnameBase: \"/descendant/a%b\"\n    //\n    // And the direct substring removal approach won't work :/\n    let parentSegments = parentPathnameBase.replace(/^\\//, \"\").split(\"/\");\n    let segments = pathname.replace(/^\\//, \"\").split(\"/\");\n    remainingPathname = \"/\" + segments.slice(parentSegments.length).join(\"/\");\n  }\n\n  let matches = matchRoutes(routes, { pathname: remainingPathname });\n\n  if (__DEV__) {\n    warning(\n      parentRoute || matches != null,\n      `No routes matched location \"${location.pathname}${location.search}${location.hash}\" `\n    );\n\n    warning(\n      matches == null ||\n        matches[matches.length - 1].route.element !== undefined ||\n        matches[matches.length - 1].route.Component !== undefined ||\n        matches[matches.length - 1].route.lazy !== undefined,\n      `Matched leaf route at location \"${location.pathname}${location.search}${location.hash}\" ` +\n        `does not have an element or Component. This means it will render an <Outlet /> with a ` +\n        `null value by default resulting in an \"empty\" page.`\n    );\n  }\n\n  let renderedMatches = _renderMatches(\n    matches &&\n      matches.map((match) =>\n        Object.assign({}, match, {\n          params: Object.assign({}, parentParams, match.params),\n          pathname: joinPaths([\n            parentPathnameBase,\n            // Re-encode pathnames that were decoded inside matchRoutes\n            navigator.encodeLocation\n              ? navigator.encodeLocation(match.pathname).pathname\n              : match.pathname,\n          ]),\n          pathnameBase:\n            match.pathnameBase === \"/\"\n              ? parentPathnameBase\n              : joinPaths([\n                  parentPathnameBase,\n                  // Re-encode pathnames that were decoded inside matchRoutes\n                  navigator.encodeLocation\n                    ? navigator.encodeLocation(match.pathnameBase).pathname\n                    : match.pathnameBase,\n                ]),\n        })\n      ),\n    parentMatches,\n    dataRouterState,\n    future\n  );\n\n  // When a user passes in a `locationArg`, the associated routes need to\n  // be wrapped in a new `LocationContext.Provider` in order for `useLocation`\n  // to use the scoped location instead of the global location.\n  if (locationArg && renderedMatches) {\n    return (\n      <LocationContext.Provider\n        value={{\n          location: {\n            pathname: \"/\",\n            search: \"\",\n            hash: \"\",\n            state: null,\n            key: \"default\",\n            ...location,\n          },\n          navigationType: NavigationType.Pop,\n        }}\n      >\n        {renderedMatches}\n      </LocationContext.Provider>\n    );\n  }\n\n  return renderedMatches;\n}\n\nfunction DefaultErrorComponent() {\n  let error = useRouteError();\n  let message = isRouteErrorResponse(error)\n    ? `${error.status} ${error.statusText}`\n    : error instanceof Error\n    ? error.message\n    : JSON.stringify(error);\n  let stack = error instanceof Error ? error.stack : null;\n  let lightgrey = \"rgba(200,200,200, 0.5)\";\n  let preStyles = { padding: \"0.5rem\", backgroundColor: lightgrey };\n  let codeStyles = { padding: \"2px 4px\", backgroundColor: lightgrey };\n\n  let devInfo = null;\n  if (__DEV__) {\n    console.error(\n      \"Error handled by React Router default ErrorBoundary:\",\n      error\n    );\n\n    devInfo = (\n      <>\n        <p>💿 Hey developer 👋</p>\n        <p>\n          You can provide a way better UX than this when your app throws errors\n          by providing your own <code style={codeStyles}>ErrorBoundary</code> or{\" \"}\n          <code style={codeStyles}>errorElement</code> prop on your route.\n        </p>\n      </>\n    );\n  }\n\n  return (\n    <>\n      <h2>Unexpected Application Error!</h2>\n      <h3 style={{ fontStyle: \"italic\" }}>{message}</h3>\n      {stack ? <pre style={preStyles}>{stack}</pre> : null}\n      {devInfo}\n    </>\n  );\n}\n\nconst defaultErrorElement = <DefaultErrorComponent />;\n\ntype RenderErrorBoundaryProps = React.PropsWithChildren<{\n  location: Location;\n  revalidation: RevalidationState;\n  error: any;\n  component: React.ReactNode;\n  routeContext: RouteContextObject;\n}>;\n\ntype RenderErrorBoundaryState = {\n  location: Location;\n  revalidation: RevalidationState;\n  error: any;\n};\n\nexport class RenderErrorBoundary extends React.Component<\n  RenderErrorBoundaryProps,\n  RenderErrorBoundaryState\n> {\n  constructor(props: RenderErrorBoundaryProps) {\n    super(props);\n    this.state = {\n      location: props.location,\n      revalidation: props.revalidation,\n      error: props.error,\n    };\n  }\n\n  static getDerivedStateFromError(error: any) {\n    return { error: error };\n  }\n\n  static getDerivedStateFromProps(\n    props: RenderErrorBoundaryProps,\n    state: RenderErrorBoundaryState\n  ) {\n    // When we get into an error state, the user will likely click \"back\" to the\n    // previous page that didn't have an error. Because this wraps the entire\n    // application, that will have no effect--the error page continues to display.\n    // This gives us a mechanism to recover from the error when the location changes.\n    //\n    // Whether we're in an error state or not, we update the location in state\n    // so that when we are in an error state, it gets reset when a new location\n    // comes in and the user recovers from the error.\n    if (\n      state.location !== props.location ||\n      (state.revalidation !== \"idle\" && props.revalidation === \"idle\")\n    ) {\n      return {\n        error: props.error,\n        location: props.location,\n        revalidation: props.revalidation,\n      };\n    }\n\n    // If we're not changing locations, preserve the location but still surface\n    // any new errors that may come through. We retain the existing error, we do\n    // this because the error provided from the app state may be cleared without\n    // the location changing.\n    return {\n      error: props.error !== undefined ? props.error : state.error,\n      location: state.location,\n      revalidation: props.revalidation || state.revalidation,\n    };\n  }\n\n  componentDidCatch(error: any, errorInfo: any) {\n    console.error(\n      \"React Router caught the following error during render\",\n      error,\n      errorInfo\n    );\n  }\n\n  render() {\n    return this.state.error !== undefined ? (\n      <RouteContext.Provider value={this.props.routeContext}>\n        <RouteErrorContext.Provider\n          value={this.state.error}\n          children={this.props.component}\n        />\n      </RouteContext.Provider>\n    ) : (\n      this.props.children\n    );\n  }\n}\n\ninterface RenderedRouteProps {\n  routeContext: RouteContextObject;\n  match: RouteMatch<string, RouteObject>;\n  children: React.ReactNode | null;\n}\n\nfunction RenderedRoute({ routeContext, match, children }: RenderedRouteProps) {\n  let dataRouterContext = React.useContext(DataRouterContext);\n\n  // Track how deep we got in our render pass to emulate SSR componentDidCatch\n  // in a DataStaticRouter\n  if (\n    dataRouterContext &&\n    dataRouterContext.static &&\n    dataRouterContext.staticContext &&\n    (match.route.errorElement || match.route.ErrorBoundary)\n  ) {\n    dataRouterContext.staticContext._deepestRenderedBoundaryId = match.route.id;\n  }\n\n  return (\n    <RouteContext.Provider value={routeContext}>\n      {children}\n    </RouteContext.Provider>\n  );\n}\n\nexport function _renderMatches(\n  matches: RouteMatch[] | null,\n  parentMatches: RouteMatch[] = [],\n  dataRouterState: RemixRouter[\"state\"] | null = null,\n  future: RemixRouter[\"future\"] | null = null\n): React.ReactElement | null {\n  if (matches == null) {\n    if (dataRouterState?.errors) {\n      // Don't bail if we have data router errors so we can render them in the\n      // boundary.  Use the pre-matched (or shimmed) matches\n      matches = dataRouterState.matches as DataRouteMatch[];\n    } else {\n      return null;\n    }\n  }\n\n  let renderedMatches = matches;\n\n  // If we have data errors, trim matches to the highest error boundary\n  let errors = dataRouterState?.errors;\n  if (errors != null) {\n    let errorIndex = renderedMatches.findIndex(\n      (m) => m.route.id && errors?.[m.route.id]\n    );\n    invariant(\n      errorIndex >= 0,\n      `Could not find a matching route for errors on route IDs: ${Object.keys(\n        errors\n      ).join(\",\")}`\n    );\n    renderedMatches = renderedMatches.slice(\n      0,\n      Math.min(renderedMatches.length, errorIndex + 1)\n    );\n  }\n\n  // If we're in a partial hydration mode, detect if we need to render down to\n  // a given HydrateFallback while we load the rest of the hydration data\n  let renderFallback = false;\n  let fallbackIndex = -1;\n  if (dataRouterState && future && future.v7_partialHydration) {\n    for (let i = 0; i < renderedMatches.length; i++) {\n      let match = renderedMatches[i];\n      // Track the deepest fallback up until the first route without data\n      if (match.route.HydrateFallback || match.route.hydrateFallbackElement) {\n        fallbackIndex = i;\n      }\n\n      if (match.route.id) {\n        let { loaderData, errors } = dataRouterState;\n        let needsToRunLoader =\n          match.route.loader &&\n          loaderData[match.route.id] === undefined &&\n          (!errors || errors[match.route.id] === undefined);\n        if (match.route.lazy || needsToRunLoader) {\n          // We found the first route that's not ready to render (waiting on\n          // lazy, or has a loader that hasn't run yet).  Flag that we need to\n          // render a fallback and render up until the appropriate fallback\n          renderFallback = true;\n          if (fallbackIndex >= 0) {\n            renderedMatches = renderedMatches.slice(0, fallbackIndex + 1);\n          } else {\n            renderedMatches = [renderedMatches[0]];\n          }\n          break;\n        }\n      }\n    }\n  }\n\n  return renderedMatches.reduceRight((outlet, match, index) => {\n    // Only data routers handle errors/fallbacks\n    let error: any;\n    let shouldRenderHydrateFallback = false;\n    let errorElement: React.ReactNode | null = null;\n    let hydrateFallbackElement: React.ReactNode | null = null;\n    if (dataRouterState) {\n      error = errors && match.route.id ? errors[match.route.id] : undefined;\n      errorElement = match.route.errorElement || defaultErrorElement;\n\n      if (renderFallback) {\n        if (fallbackIndex < 0 && index === 0) {\n          warningOnce(\n            \"route-fallback\",\n            false,\n            \"No `HydrateFallback` element provided to render during initial hydration\"\n          );\n          shouldRenderHydrateFallback = true;\n          hydrateFallbackElement = null;\n        } else if (fallbackIndex === index) {\n          shouldRenderHydrateFallback = true;\n          hydrateFallbackElement = match.route.hydrateFallbackElement || null;\n        }\n      }\n    }\n\n    let matches = parentMatches.concat(renderedMatches.slice(0, index + 1));\n    let getChildren = () => {\n      let children: React.ReactNode;\n      if (error) {\n        children = errorElement;\n      } else if (shouldRenderHydrateFallback) {\n        children = hydrateFallbackElement;\n      } else if (match.route.Component) {\n        // Note: This is a de-optimized path since React won't re-use the\n        // ReactElement since it's identity changes with each new\n        // React.createElement call.  We keep this so folks can use\n        // `<Route Component={...}>` in `<Routes>` but generally `Component`\n        // usage is only advised in `RouterProvider` when we can convert it to\n        // `element` ahead of time.\n        children = <match.route.Component />;\n      } else if (match.route.element) {\n        children = match.route.element;\n      } else {\n        children = outlet;\n      }\n      return (\n        <RenderedRoute\n          match={match}\n          routeContext={{\n            outlet,\n            matches,\n            isDataRoute: dataRouterState != null,\n          }}\n          children={children}\n        />\n      );\n    };\n    // Only wrap in an error boundary within data router usages when we have an\n    // ErrorBoundary/errorElement on this route.  Otherwise let it bubble up to\n    // an ancestor ErrorBoundary/errorElement\n    return dataRouterState &&\n      (match.route.ErrorBoundary || match.route.errorElement || index === 0) ? (\n      <RenderErrorBoundary\n        location={dataRouterState.location}\n        revalidation={dataRouterState.revalidation}\n        component={errorElement}\n        error={error}\n        children={getChildren()}\n        routeContext={{ outlet: null, matches, isDataRoute: true }}\n      />\n    ) : (\n      getChildren()\n    );\n  }, null as React.ReactElement | null);\n}\n\nenum DataRouterHook {\n  UseBlocker = \"useBlocker\",\n  UseRevalidator = \"useRevalidator\",\n  UseNavigateStable = \"useNavigate\",\n}\n\nenum DataRouterStateHook {\n  UseBlocker = \"useBlocker\",\n  UseLoaderData = \"useLoaderData\",\n  UseActionData = \"useActionData\",\n  UseRouteError = \"useRouteError\",\n  UseNavigation = \"useNavigation\",\n  UseRouteLoaderData = \"useRouteLoaderData\",\n  UseMatches = \"useMatches\",\n  UseRevalidator = \"useRevalidator\",\n  UseNavigateStable = \"useNavigate\",\n  UseRouteId = \"useRouteId\",\n}\n\nfunction getDataRouterConsoleError(\n  hookName: DataRouterHook | DataRouterStateHook\n) {\n  return `${hookName} must be used within a data router.  See https://reactrouter.com/routers/picking-a-router.`;\n}\n\nfunction useDataRouterContext(hookName: DataRouterHook) {\n  let ctx = React.useContext(DataRouterContext);\n  invariant(ctx, getDataRouterConsoleError(hookName));\n  return ctx;\n}\n\nfunction useDataRouterState(hookName: DataRouterStateHook) {\n  let state = React.useContext(DataRouterStateContext);\n  invariant(state, getDataRouterConsoleError(hookName));\n  return state;\n}\n\nfunction useRouteContext(hookName: DataRouterStateHook) {\n  let route = React.useContext(RouteContext);\n  invariant(route, getDataRouterConsoleError(hookName));\n  return route;\n}\n\n// Internal version with hookName-aware debugging\nfunction useCurrentRouteId(hookName: DataRouterStateHook) {\n  let route = useRouteContext(hookName);\n  let thisRoute = route.matches[route.matches.length - 1];\n  invariant(\n    thisRoute.route.id,\n    `${hookName} can only be used on routes that contain a unique \"id\"`\n  );\n  return thisRoute.route.id;\n}\n\n/**\n * Returns the ID for the nearest contextual route\n */\nexport function useRouteId() {\n  return useCurrentRouteId(DataRouterStateHook.UseRouteId);\n}\n\n/**\n * Returns the current navigation, defaulting to an \"idle\" navigation when\n * no navigation is in progress\n */\nexport function useNavigation() {\n  let state = useDataRouterState(DataRouterStateHook.UseNavigation);\n  return state.navigation;\n}\n\n/**\n * Returns a revalidate function for manually triggering revalidation, as well\n * as the current state of any manual revalidations\n */\nexport function useRevalidator() {\n  let dataRouterContext = useDataRouterContext(DataRouterHook.UseRevalidator);\n  let state = useDataRouterState(DataRouterStateHook.UseRevalidator);\n  return React.useMemo(\n    () => ({\n      revalidate: dataRouterContext.router.revalidate,\n      state: state.revalidation,\n    }),\n    [dataRouterContext.router.revalidate, state.revalidation]\n  );\n}\n\n/**\n * Returns the active route matches, useful for accessing loaderData for\n * parent/child routes or the route \"handle\" property\n */\nexport function useMatches(): UIMatch[] {\n  let { matches, loaderData } = useDataRouterState(\n    DataRouterStateHook.UseMatches\n  );\n  return React.useMemo(\n    () => matches.map((m) => convertRouteMatchToUiMatch(m, loaderData)),\n    [matches, loaderData]\n  );\n}\n\n/**\n * Returns the loader data for the nearest ancestor Route loader\n */\nexport function useLoaderData(): unknown {\n  let state = useDataRouterState(DataRouterStateHook.UseLoaderData);\n  let routeId = useCurrentRouteId(DataRouterStateHook.UseLoaderData);\n\n  if (state.errors && state.errors[routeId] != null) {\n    console.error(\n      `You cannot \\`useLoaderData\\` in an errorElement (routeId: ${routeId})`\n    );\n    return undefined;\n  }\n  return state.loaderData[routeId];\n}\n\n/**\n * Returns the loaderData for the given routeId\n */\nexport function useRouteLoaderData(routeId: string): unknown {\n  let state = useDataRouterState(DataRouterStateHook.UseRouteLoaderData);\n  return state.loaderData[routeId];\n}\n\n/**\n * Returns the action data for the nearest ancestor Route action\n */\nexport function useActionData(): unknown {\n  let state = useDataRouterState(DataRouterStateHook.UseActionData);\n  let routeId = useCurrentRouteId(DataRouterStateHook.UseLoaderData);\n  return state.actionData ? state.actionData[routeId] : undefined;\n}\n\n/**\n * Returns the nearest ancestor Route error, which could be a loader/action\n * error or a render error.  This is intended to be called from your\n * ErrorBoundary/errorElement to display a proper error message.\n */\nexport function useRouteError(): unknown {\n  let error = React.useContext(RouteErrorContext);\n  let state = useDataRouterState(DataRouterStateHook.UseRouteError);\n  let routeId = useCurrentRouteId(DataRouterStateHook.UseRouteError);\n\n  // If this was a render error, we put it in a RouteError context inside\n  // of RenderErrorBoundary\n  if (error !== undefined) {\n    return error;\n  }\n\n  // Otherwise look for errors from our data router state\n  return state.errors?.[routeId];\n}\n\n/**\n * Returns the happy-path data from the nearest ancestor `<Await />` value\n */\nexport function useAsyncValue(): unknown {\n  let value = React.useContext(AwaitContext);\n  return value?._data;\n}\n\n/**\n * Returns the error from the nearest ancestor `<Await />` value\n */\nexport function useAsyncError(): unknown {\n  let value = React.useContext(AwaitContext);\n  return value?._error;\n}\n\nlet blockerId = 0;\n\n/**\n * Allow the application to block navigations within the SPA and present the\n * user a confirmation dialog to confirm the navigation.  Mostly used to avoid\n * using half-filled form data.  This does not handle hard-reloads or\n * cross-origin navigations.\n */\nexport function useBlocker(shouldBlock: boolean | BlockerFunction): Blocker {\n  let { router, basename } = useDataRouterContext(DataRouterHook.UseBlocker);\n  let state = useDataRouterState(DataRouterStateHook.UseBlocker);\n\n  let [blockerKey, setBlockerKey] = React.useState(\"\");\n  let blockerFunction = React.useCallback<BlockerFunction>(\n    (arg) => {\n      if (typeof shouldBlock !== \"function\") {\n        return !!shouldBlock;\n      }\n      if (basename === \"/\") {\n        return shouldBlock(arg);\n      }\n\n      // If they provided us a function and we've got an active basename, strip\n      // it from the locations we expose to the user to match the behavior of\n      // useLocation\n      let { currentLocation, nextLocation, historyAction } = arg;\n      return shouldBlock({\n        currentLocation: {\n          ...currentLocation,\n          pathname:\n            stripBasename(currentLocation.pathname, basename) ||\n            currentLocation.pathname,\n        },\n        nextLocation: {\n          ...nextLocation,\n          pathname:\n            stripBasename(nextLocation.pathname, basename) ||\n            nextLocation.pathname,\n        },\n        historyAction,\n      });\n    },\n    [basename, shouldBlock]\n  );\n\n  // This effect is in charge of blocker key assignment and deletion (which is\n  // tightly coupled to the key)\n  React.useEffect(() => {\n    let key = String(++blockerId);\n    setBlockerKey(key);\n    return () => router.deleteBlocker(key);\n  }, [router]);\n\n  // This effect handles assigning the blockerFunction.  This is to handle\n  // unstable blocker function identities, and happens only after the prior\n  // effect so we don't get an orphaned blockerFunction in the router with a\n  // key of \"\".  Until then we just have the IDLE_BLOCKER.\n  React.useEffect(() => {\n    if (blockerKey !== \"\") {\n      router.getBlocker(blockerKey, blockerFunction);\n    }\n  }, [router, blockerKey, blockerFunction]);\n\n  // Prefer the blocker from `state` not `router.state` since DataRouterContext\n  // is memoized so this ensures we update on blocker state updates\n  return blockerKey && state.blockers.has(blockerKey)\n    ? state.blockers.get(blockerKey)!\n    : IDLE_BLOCKER;\n}\n\n/**\n * Stable version of useNavigate that is used when we are in the context of\n * a RouterProvider.\n */\nfunction useNavigateStable(): NavigateFunction {\n  let { router } = useDataRouterContext(DataRouterHook.UseNavigateStable);\n  let id = useCurrentRouteId(DataRouterStateHook.UseNavigateStable);\n\n  let activeRef = React.useRef(false);\n  useIsomorphicLayoutEffect(() => {\n    activeRef.current = true;\n  });\n\n  let navigate: NavigateFunction = React.useCallback(\n    (to: To | number, options: NavigateOptions = {}) => {\n      warning(activeRef.current, navigateEffectWarning);\n\n      // Short circuit here since if this happens on first render the navigate\n      // is useless because we haven't wired up our router subscriber yet\n      if (!activeRef.current) return;\n\n      if (typeof to === \"number\") {\n        router.navigate(to);\n      } else {\n        router.navigate(to, { fromRouteId: id, ...options });\n      }\n    },\n    [router, id]\n  );\n\n  return navigate;\n}\n\nconst alreadyWarned: Record<string, boolean> = {};\n\nfunction warningOnce(key: string, cond: boolean, message: string) {\n  if (!cond && !alreadyWarned[key]) {\n    alreadyWarned[key] = true;\n    warning(false, message);\n  }\n}\n","import type {\n  InitialEntry,\n  LazyRouteFunction,\n  Location,\n  MemoryHistory,\n  RelativeRoutingType,\n  Router as RemixRouter,\n  RouterState,\n  RouterSubscriber,\n  To,\n  TrackedPromise,\n} from \"@remix-run/router\";\nimport {\n  AbortedDeferredError,\n  Action as NavigationType,\n  createMemoryHistory,\n  UNSAFE_getResolveToMatches as getResolveToMatches,\n  UNSAFE_invariant as invariant,\n  parsePath,\n  resolveTo,\n  stripBasename,\n  UNSAFE_warning as warning,\n} from \"@remix-run/router\";\nimport * as React from \"react\";\n\nimport type {\n  DataRouteObject,\n  IndexRouteObject,\n  Navigator,\n  NonIndexRouteObject,\n  RouteMatch,\n  RouteObject,\n} from \"./context\";\nimport {\n  AwaitContext,\n  DataRouterContext,\n  DataRouterStateContext,\n  LocationContext,\n  NavigationContext,\n  RouteContext,\n} from \"./context\";\nimport {\n  _renderMatches,\n  useAsyncValue,\n  useInRouterContext,\n  useLocation,\n  useNavigate,\n  useOutlet,\n  useRoutes,\n  useRoutesImpl,\n} from \"./hooks\";\n\nexport interface FutureConfig {\n  v7_relativeSplatPath: boolean;\n  v7_startTransition: boolean;\n}\n\nexport interface RouterProviderProps {\n  fallbackElement?: React.ReactNode;\n  router: RemixRouter;\n  // Only accept future flags relevant to rendering behavior\n  // routing flags should be accessed via router.future\n  future?: Partial<Pick<FutureConfig, \"v7_startTransition\">>;\n}\n\n/**\n  Webpack + React 17 fails to compile on any of the following because webpack\n  complains that `startTransition` doesn't exist in `React`:\n  * import { startTransition } from \"react\"\n  * import * as React from from \"react\";\n    \"startTransition\" in React ? React.startTransition(() => setState()) : setState()\n  * import * as React from from \"react\";\n    \"startTransition\" in React ? React[\"startTransition\"](() => setState()) : setState()\n\n  Moving it to a constant such as the following solves the Webpack/React 17 issue:\n  * import * as React from from \"react\";\n    const START_TRANSITION = \"startTransition\";\n    START_TRANSITION in React ? React[START_TRANSITION](() => setState()) : setState()\n\n  However, that introduces webpack/terser minification issues in production builds\n  in React 18 where minification/obfuscation ends up removing the call of\n  React.startTransition entirely from the first half of the ternary.  Grabbing\n  this exported reference once up front resolves that issue.\n\n  See https://github.com/remix-run/react-router/issues/10579\n*/\nconst START_TRANSITION = \"startTransition\";\nconst startTransitionImpl = React[START_TRANSITION];\n\n/**\n * Given a Remix Router instance, render the appropriate UI\n */\nexport function RouterProvider({\n  fallbackElement,\n  router,\n  future,\n}: RouterProviderProps): React.ReactElement {\n  let [state, setStateImpl] = React.useState(router.state);\n  let { v7_startTransition } = future || {};\n\n  let setState = React.useCallback<RouterSubscriber>(\n    (newState: RouterState) => {\n      if (v7_startTransition && startTransitionImpl) {\n        startTransitionImpl(() => setStateImpl(newState));\n      } else {\n        setStateImpl(newState);\n      }\n    },\n    [setStateImpl, v7_startTransition]\n  );\n\n  // Need to use a layout effect here so we are subscribed early enough to\n  // pick up on any render-driven redirects/navigations (useEffect/<Navigate>)\n  React.useLayoutEffect(() => router.subscribe(setState), [router, setState]);\n\n  React.useEffect(() => {\n    warning(\n      fallbackElement == null || !router.future.v7_partialHydration,\n      \"`<RouterProvider fallbackElement>` is deprecated when using \" +\n        \"`v7_partialHydration`, use a `HydrateFallback` component instead\"\n    );\n    // Only log this once on initial mount\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, []);\n\n  let navigator = React.useMemo((): Navigator => {\n    return {\n      createHref: router.createHref,\n      encodeLocation: router.encodeLocation,\n      go: (n) => router.navigate(n),\n      push: (to, state, opts) =>\n        router.navigate(to, {\n          state,\n          preventScrollReset: opts?.preventScrollReset,\n        }),\n      replace: (to, state, opts) =>\n        router.navigate(to, {\n          replace: true,\n          state,\n          preventScrollReset: opts?.preventScrollReset,\n        }),\n    };\n  }, [router]);\n\n  let basename = router.basename || \"/\";\n\n  let dataRouterContext = React.useMemo(\n    () => ({\n      router,\n      navigator,\n      static: false,\n      basename,\n    }),\n    [router, navigator, basename]\n  );\n\n  // The fragment and {null} here are important!  We need them to keep React 18's\n  // useId happy when we are server-rendering since we may have a <script> here\n  // containing the hydrated server-side staticContext (from StaticRouterProvider).\n  // useId relies on the component tree structure to generate deterministic id's\n  // so we need to ensure it remains the same on the client even though\n  // we don't need the <script> tag\n  return (\n    <>\n      <DataRouterContext.Provider value={dataRouterContext}>\n        <DataRouterStateContext.Provider value={state}>\n          <Router\n            basename={basename}\n            location={state.location}\n            navigationType={state.historyAction}\n            navigator={navigator}\n            future={{\n              v7_relativeSplatPath: router.future.v7_relativeSplatPath,\n            }}\n          >\n            {state.initialized || router.future.v7_partialHydration ? (\n              <DataRoutes\n                routes={router.routes}\n                future={router.future}\n                state={state}\n              />\n            ) : (\n              fallbackElement\n            )}\n          </Router>\n        </DataRouterStateContext.Provider>\n      </DataRouterContext.Provider>\n      {null}\n    </>\n  );\n}\n\nfunction DataRoutes({\n  routes,\n  future,\n  state,\n}: {\n  routes: DataRouteObject[];\n  future: RemixRouter[\"future\"];\n  state: RouterState;\n}): React.ReactElement | null {\n  return useRoutesImpl(routes, undefined, state, future);\n}\n\nexport interface MemoryRouterProps {\n  basename?: string;\n  children?: React.ReactNode;\n  initialEntries?: InitialEntry[];\n  initialIndex?: number;\n  future?: Partial<FutureConfig>;\n}\n\n/**\n * A `<Router>` that stores all entries in memory.\n *\n * @see https://reactrouter.com/router-components/memory-router\n */\nexport function MemoryRouter({\n  basename,\n  children,\n  initialEntries,\n  initialIndex,\n  future,\n}: MemoryRouterProps): React.ReactElement {\n  let historyRef = React.useRef<MemoryHistory>();\n  if (historyRef.current == null) {\n    historyRef.current = createMemoryHistory({\n      initialEntries,\n      initialIndex,\n      v5Compat: true,\n    });\n  }\n\n  let history = historyRef.current;\n  let [state, setStateImpl] = React.useState({\n    action: history.action,\n    location: history.location,\n  });\n  let { v7_startTransition } = future || {};\n  let setState = React.useCallback(\n    (newState: { action: NavigationType; location: Location }) => {\n      v7_startTransition && startTransitionImpl\n        ? startTransitionImpl(() => setStateImpl(newState))\n        : setStateImpl(newState);\n    },\n    [setStateImpl, v7_startTransition]\n  );\n\n  React.useLayoutEffect(() => history.listen(setState), [history, setState]);\n\n  return (\n    <Router\n      basename={basename}\n      children={children}\n      location={state.location}\n      navigationType={state.action}\n      navigator={history}\n      future={future}\n    />\n  );\n}\n\nexport interface NavigateProps {\n  to: To;\n  replace?: boolean;\n  state?: any;\n  relative?: RelativeRoutingType;\n}\n\n/**\n * Changes the current location.\n *\n * Note: This API is mostly useful in React.Component subclasses that are not\n * able to use hooks. In functional components, we recommend you use the\n * `useNavigate` hook instead.\n *\n * @see https://reactrouter.com/components/navigate\n */\nexport function Navigate({\n  to,\n  replace,\n  state,\n  relative,\n}: NavigateProps): null {\n  invariant(\n    useInRouterContext(),\n    // TODO: This error is probably because they somehow have 2 versions of\n    // the router loaded. We can help them understand how to avoid that.\n    `<Navigate> may be used only in the context of a <Router> component.`\n  );\n\n  let { future, static: isStatic } = React.useContext(NavigationContext);\n\n  warning(\n    !isStatic,\n    `<Navigate> must not be used on the initial render in a <StaticRouter>. ` +\n      `This is a no-op, but you should modify your code so the <Navigate> is ` +\n      `only ever rendered in response to some user interaction or state change.`\n  );\n\n  let { matches } = React.useContext(RouteContext);\n  let { pathname: locationPathname } = useLocation();\n  let navigate = useNavigate();\n\n  // Resolve the path outside of the effect so that when effects run twice in\n  // StrictMode they navigate to the same place\n  let path = resolveTo(\n    to,\n    getResolveToMatches(matches, future.v7_relativeSplatPath),\n    locationPathname,\n    relative === \"path\"\n  );\n  let jsonPath = JSON.stringify(path);\n\n  React.useEffect(\n    () => navigate(JSON.parse(jsonPath), { replace, state, relative }),\n    [navigate, jsonPath, relative, replace, state]\n  );\n\n  return null;\n}\n\nexport interface OutletProps {\n  context?: unknown;\n}\n\n/**\n * Renders the child route's element, if there is one.\n *\n * @see https://reactrouter.com/components/outlet\n */\nexport function Outlet(props: OutletProps): React.ReactElement | null {\n  return useOutlet(props.context);\n}\n\nexport interface PathRouteProps {\n  caseSensitive?: NonIndexRouteObject[\"caseSensitive\"];\n  path?: NonIndexRouteObject[\"path\"];\n  id?: NonIndexRouteObject[\"id\"];\n  lazy?: LazyRouteFunction<NonIndexRouteObject>;\n  loader?: NonIndexRouteObject[\"loader\"];\n  action?: NonIndexRouteObject[\"action\"];\n  hasErrorBoundary?: NonIndexRouteObject[\"hasErrorBoundary\"];\n  shouldRevalidate?: NonIndexRouteObject[\"shouldRevalidate\"];\n  handle?: NonIndexRouteObject[\"handle\"];\n  index?: false;\n  children?: React.ReactNode;\n  element?: React.ReactNode | null;\n  hydrateFallbackElement?: React.ReactNode | null;\n  errorElement?: React.ReactNode | null;\n  Component?: React.ComponentType | null;\n  HydrateFallback?: React.ComponentType | null;\n  ErrorBoundary?: React.ComponentType | null;\n}\n\nexport interface LayoutRouteProps extends PathRouteProps {}\n\nexport interface IndexRouteProps {\n  caseSensitive?: IndexRouteObject[\"caseSensitive\"];\n  path?: IndexRouteObject[\"path\"];\n  id?: IndexRouteObject[\"id\"];\n  lazy?: LazyRouteFunction<IndexRouteObject>;\n  loader?: IndexRouteObject[\"loader\"];\n  action?: IndexRouteObject[\"action\"];\n  hasErrorBoundary?: IndexRouteObject[\"hasErrorBoundary\"];\n  shouldRevalidate?: IndexRouteObject[\"shouldRevalidate\"];\n  handle?: IndexRouteObject[\"handle\"];\n  index: true;\n  children?: undefined;\n  element?: React.ReactNode | null;\n  hydrateFallbackElement?: React.ReactNode | null;\n  errorElement?: React.ReactNode | null;\n  Component?: React.ComponentType | null;\n  HydrateFallback?: React.ComponentType | null;\n  ErrorBoundary?: React.ComponentType | null;\n}\n\nexport type RouteProps = PathRouteProps | LayoutRouteProps | IndexRouteProps;\n\n/**\n * Declares an element that should be rendered at a certain URL path.\n *\n * @see https://reactrouter.com/components/route\n */\nexport function Route(_props: RouteProps): React.ReactElement | null {\n  invariant(\n    false,\n    `A <Route> is only ever to be used as the child of <Routes> element, ` +\n      `never rendered directly. Please wrap your <Route> in a <Routes>.`\n  );\n}\n\nexport interface RouterProps {\n  basename?: string;\n  children?: React.ReactNode;\n  location: Partial<Location> | string;\n  navigationType?: NavigationType;\n  navigator: Navigator;\n  static?: boolean;\n  future?: Partial<Pick<FutureConfig, \"v7_relativeSplatPath\">>;\n}\n\n/**\n * Provides location context for the rest of the app.\n *\n * Note: You usually won't render a `<Router>` directly. Instead, you'll render a\n * router that is more specific to your environment such as a `<BrowserRouter>`\n * in web browsers or a `<StaticRouter>` for server rendering.\n *\n * @see https://reactrouter.com/router-components/router\n */\nexport function Router({\n  basename: basenameProp = \"/\",\n  children = null,\n  location: locationProp,\n  navigationType = NavigationType.Pop,\n  navigator,\n  static: staticProp = false,\n  future,\n}: RouterProps): React.ReactElement | null {\n  invariant(\n    !useInRouterContext(),\n    `You cannot render a <Router> inside another <Router>.` +\n      ` You should never have more than one in your app.`\n  );\n\n  // Preserve trailing slashes on basename, so we can let the user control\n  // the enforcement of trailing slashes throughout the app\n  let basename = basenameProp.replace(/^\\/*/, \"/\");\n  let navigationContext = React.useMemo(\n    () => ({\n      basename,\n      navigator,\n      static: staticProp,\n      future: {\n        v7_relativeSplatPath: false,\n        ...future,\n      },\n    }),\n    [basename, future, navigator, staticProp]\n  );\n\n  if (typeof locationProp === \"string\") {\n    locationProp = parsePath(locationProp);\n  }\n\n  let {\n    pathname = \"/\",\n    search = \"\",\n    hash = \"\",\n    state = null,\n    key = \"default\",\n  } = locationProp;\n\n  let locationContext = React.useMemo(() => {\n    let trailingPathname = stripBasename(pathname, basename);\n\n    if (trailingPathname == null) {\n      return null;\n    }\n\n    return {\n      location: {\n        pathname: trailingPathname,\n        search,\n        hash,\n        state,\n        key,\n      },\n      navigationType,\n    };\n  }, [basename, pathname, search, hash, state, key, navigationType]);\n\n  warning(\n    locationContext != null,\n    `<Router basename=\"${basename}\"> is not able to match the URL ` +\n      `\"${pathname}${search}${hash}\" because it does not start with the ` +\n      `basename, so the <Router> won't render anything.`\n  );\n\n  if (locationContext == null) {\n    return null;\n  }\n\n  return (\n    <NavigationContext.Provider value={navigationContext}>\n      <LocationContext.Provider children={children} value={locationContext} />\n    </NavigationContext.Provider>\n  );\n}\n\nexport interface RoutesProps {\n  children?: React.ReactNode;\n  location?: Partial<Location> | string;\n}\n\n/**\n * A container for a nested tree of `<Route>` elements that renders the branch\n * that best matches the current location.\n *\n * @see https://reactrouter.com/components/routes\n */\nexport function Routes({\n  children,\n  location,\n}: RoutesProps): React.ReactElement | null {\n  return useRoutes(createRoutesFromChildren(children), location);\n}\n\nexport interface AwaitResolveRenderFunction {\n  (data: Awaited<any>): React.ReactNode;\n}\n\nexport interface AwaitProps {\n  children: React.ReactNode | AwaitResolveRenderFunction;\n  errorElement?: React.ReactNode;\n  resolve: TrackedPromise | any;\n}\n\n/**\n * Component to use for rendering lazily loaded data from returning defer()\n * in a loader function\n */\nexport function Await({ children, errorElement, resolve }: AwaitProps) {\n  return (\n    <AwaitErrorBoundary resolve={resolve} errorElement={errorElement}>\n      <ResolveAwait>{children}</ResolveAwait>\n    </AwaitErrorBoundary>\n  );\n}\n\ntype AwaitErrorBoundaryProps = React.PropsWithChildren<{\n  errorElement?: React.ReactNode;\n  resolve: TrackedPromise | any;\n}>;\n\ntype AwaitErrorBoundaryState = {\n  error: any;\n};\n\nenum AwaitRenderStatus {\n  pending,\n  success,\n  error,\n}\n\nconst neverSettledPromise = new Promise(() => {});\n\nclass AwaitErrorBoundary extends React.Component<\n  AwaitErrorBoundaryProps,\n  AwaitErrorBoundaryState\n> {\n  constructor(props: AwaitErrorBoundaryProps) {\n    super(props);\n    this.state = { error: null };\n  }\n\n  static getDerivedStateFromError(error: any) {\n    return { error };\n  }\n\n  componentDidCatch(error: any, errorInfo: any) {\n    console.error(\n      \"<Await> caught the following error during render\",\n      error,\n      errorInfo\n    );\n  }\n\n  render() {\n    let { children, errorElement, resolve } = this.props;\n\n    let promise: TrackedPromise | null = null;\n    let status: AwaitRenderStatus = AwaitRenderStatus.pending;\n\n    if (!(resolve instanceof Promise)) {\n      // Didn't get a promise - provide as a resolved promise\n      status = AwaitRenderStatus.success;\n      promise = Promise.resolve();\n      Object.defineProperty(promise, \"_tracked\", { get: () => true });\n      Object.defineProperty(promise, \"_data\", { get: () => resolve });\n    } else if (this.state.error) {\n      // Caught a render error, provide it as a rejected promise\n      status = AwaitRenderStatus.error;\n      let renderError = this.state.error;\n      promise = Promise.reject().catch(() => {}); // Avoid unhandled rejection warnings\n      Object.defineProperty(promise, \"_tracked\", { get: () => true });\n      Object.defineProperty(promise, \"_error\", { get: () => renderError });\n    } else if ((resolve as TrackedPromise)._tracked) {\n      // Already tracked promise - check contents\n      promise = resolve;\n      status =\n        promise._error !== undefined\n          ? AwaitRenderStatus.error\n          : promise._data !== undefined\n          ? AwaitRenderStatus.success\n          : AwaitRenderStatus.pending;\n    } else {\n      // Raw (untracked) promise - track it\n      status = AwaitRenderStatus.pending;\n      Object.defineProperty(resolve, \"_tracked\", { get: () => true });\n      promise = resolve.then(\n        (data: any) =>\n          Object.defineProperty(resolve, \"_data\", { get: () => data }),\n        (error: any) =>\n          Object.defineProperty(resolve, \"_error\", { get: () => error })\n      );\n    }\n\n    if (\n      status === AwaitRenderStatus.error &&\n      promise._error instanceof AbortedDeferredError\n    ) {\n      // Freeze the UI by throwing a never resolved promise\n      throw neverSettledPromise;\n    }\n\n    if (status === AwaitRenderStatus.error && !errorElement) {\n      // No errorElement, throw to the nearest route-level error boundary\n      throw promise._error;\n    }\n\n    if (status === AwaitRenderStatus.error) {\n      // Render via our errorElement\n      return <AwaitContext.Provider value={promise} children={errorElement} />;\n    }\n\n    if (status === AwaitRenderStatus.success) {\n      // Render children with resolved value\n      return <AwaitContext.Provider value={promise} children={children} />;\n    }\n\n    // Throw to the suspense boundary\n    throw promise;\n  }\n}\n\n/**\n * @private\n * Indirection to leverage useAsyncValue for a render-prop API on `<Await>`\n */\nfunction ResolveAwait({\n  children,\n}: {\n  children: React.ReactNode | AwaitResolveRenderFunction;\n}) {\n  let data = useAsyncValue();\n  let toRender = typeof children === \"function\" ? children(data) : children;\n  return <>{toRender}</>;\n}\n\n///////////////////////////////////////////////////////////////////////////////\n// UTILS\n///////////////////////////////////////////////////////////////////////////////\n\n/**\n * Creates a route config from a React \"children\" object, which is usually\n * either a `<Route>` element or an array of them. Used internally by\n * `<Routes>` to create a route config from its children.\n *\n * @see https://reactrouter.com/utils/create-routes-from-children\n */\nexport function createRoutesFromChildren(\n  children: React.ReactNode,\n  parentPath: number[] = []\n): RouteObject[] {\n  let routes: RouteObject[] = [];\n\n  React.Children.forEach(children, (element, index) => {\n    if (!React.isValidElement(element)) {\n      // Ignore non-elements. This allows people to more easily inline\n      // conditionals in their route config.\n      return;\n    }\n\n    let treePath = [...parentPath, index];\n\n    if (element.type === React.Fragment) {\n      // Transparently support React.Fragment and its children.\n      routes.push.apply(\n        routes,\n        createRoutesFromChildren(element.props.children, treePath)\n      );\n      return;\n    }\n\n    invariant(\n      element.type === Route,\n      `[${\n        typeof element.type === \"string\" ? element.type : element.type.name\n      }] is not a <Route> component. All component children of <Routes> must be a <Route> or <React.Fragment>`\n    );\n\n    invariant(\n      !element.props.index || !element.props.children,\n      \"An index route cannot have child routes.\"\n    );\n\n    let route: RouteObject = {\n      id: element.props.id || treePath.join(\"-\"),\n      caseSensitive: element.props.caseSensitive,\n      element: element.props.element,\n      Component: element.props.Component,\n      index: element.props.index,\n      path: element.props.path,\n      loader: element.props.loader,\n      action: element.props.action,\n      errorElement: element.props.errorElement,\n      ErrorBoundary: element.props.ErrorBoundary,\n      hasErrorBoundary:\n        element.props.ErrorBoundary != null ||\n        element.props.errorElement != null,\n      shouldRevalidate: element.props.shouldRevalidate,\n      handle: element.props.handle,\n      lazy: element.props.lazy,\n    };\n\n    if (element.props.children) {\n      route.children = createRoutesFromChildren(\n        element.props.children,\n        treePath\n      );\n    }\n\n    routes.push(route);\n  });\n\n  return routes;\n}\n\n/**\n * Renders the result of `matchRoutes()` into a React element.\n */\nexport function renderMatches(\n  matches: RouteMatch[] | null\n): React.ReactElement | null {\n  return _renderMatches(matches);\n}\n","import * as React from \"react\";\nimport type {\n  ActionFunction,\n  ActionFunctionArgs,\n  Blocker,\n  BlockerFunction,\n  ErrorResponse,\n  Fetcher,\n  HydrationState,\n  InitialEntry,\n  JsonFunction,\n  LazyRouteFunction,\n  LoaderFunction,\n  LoaderFunctionArgs,\n  Location,\n  Navigation,\n  ParamParseKey,\n  Params,\n  Path,\n  PathMatch,\n  PathParam,\n  PathPattern,\n  RedirectFunction,\n  RelativeRoutingType,\n  Router as RemixRouter,\n  FutureConfig as RouterFutureConfig,\n  ShouldRevalidateFunction,\n  ShouldRevalidateFunctionArgs,\n  To,\n  UIMatch,\n} from \"@remix-run/router\";\nimport {\n  AbortedDeferredError,\n  Action as NavigationType,\n  createMemoryHistory,\n  createPath,\n  createRouter,\n  defer,\n  generatePath,\n  isRouteErrorResponse,\n  json,\n  matchPath,\n  matchRoutes,\n  parsePath,\n  redirect,\n  redirectDocument,\n  resolvePath,\n  UNSAFE_warning as warning,\n} from \"@remix-run/router\";\n\nimport type {\n  AwaitProps,\n  FutureConfig,\n  IndexRouteProps,\n  LayoutRouteProps,\n  MemoryRouterProps,\n  NavigateProps,\n  OutletProps,\n  PathRouteProps,\n  RouteProps,\n  RouterProps,\n  RouterProviderProps,\n  RoutesProps,\n} from \"./lib/components\";\nimport {\n  Await,\n  MemoryRouter,\n  Navigate,\n  Outlet,\n  Route,\n  Router,\n  RouterProvider,\n  Routes,\n  createRoutesFromChildren,\n  renderMatches,\n} from \"./lib/components\";\nimport type {\n  DataRouteMatch,\n  DataRouteObject,\n  IndexRouteObject,\n  NavigateOptions,\n  Navigator,\n  NonIndexRouteObject,\n  RouteMatch,\n  RouteObject,\n} from \"./lib/context\";\nimport {\n  DataRouterContext,\n  DataRouterStateContext,\n  LocationContext,\n  NavigationContext,\n  RouteContext,\n} from \"./lib/context\";\nimport type { NavigateFunction } from \"./lib/hooks\";\nimport {\n  useActionData,\n  useAsyncError,\n  useAsyncValue,\n  useBlocker,\n  useHref,\n  useInRouterContext,\n  useLoaderData,\n  useLocation,\n  useMatch,\n  useMatches,\n  useNavigate,\n  useNavigation,\n  useNavigationType,\n  useOutlet,\n  useOutletContext,\n  useParams,\n  useResolvedPath,\n  useRevalidator,\n  useRouteError,\n  useRouteId,\n  useRouteLoaderData,\n  useRoutes,\n  useRoutesImpl,\n} from \"./lib/hooks\";\n\n// Exported for backwards compatibility, but not being used internally anymore\ntype Hash = string;\ntype Pathname = string;\ntype Search = string;\n\n// Expose react-router public API\nexport type {\n  ActionFunction,\n  ActionFunctionArgs,\n  AwaitProps,\n  DataRouteMatch,\n  DataRouteObject,\n  ErrorResponse,\n  Fetcher,\n  FutureConfig,\n  Hash,\n  IndexRouteObject,\n  IndexRouteProps,\n  JsonFunction,\n  LayoutRouteProps,\n  LazyRouteFunction,\n  LoaderFunction,\n  LoaderFunctionArgs,\n  Location,\n  MemoryRouterProps,\n  NavigateFunction,\n  NavigateOptions,\n  NavigateProps,\n  Navigation,\n  Navigator,\n  NonIndexRouteObject,\n  OutletProps,\n  ParamParseKey,\n  Params,\n  Path,\n  PathMatch,\n  PathParam,\n  PathPattern,\n  PathRouteProps,\n  Pathname,\n  RedirectFunction,\n  RelativeRoutingType,\n  RouteMatch,\n  RouteObject,\n  RouteProps,\n  RouterProps,\n  RouterProviderProps,\n  RoutesProps,\n  Search,\n  ShouldRevalidateFunction,\n  ShouldRevalidateFunctionArgs,\n  To,\n  UIMatch,\n  Blocker,\n  BlockerFunction,\n};\nexport {\n  AbortedDeferredError,\n  Await,\n  MemoryRouter,\n  Navigate,\n  NavigationType,\n  Outlet,\n  Route,\n  Router,\n  RouterProvider,\n  Routes,\n  createPath,\n  createRoutesFromChildren,\n  createRoutesFromChildren as createRoutesFromElements,\n  defer,\n  generatePath,\n  isRouteErrorResponse,\n  json,\n  matchPath,\n  matchRoutes,\n  parsePath,\n  redirect,\n  redirectDocument,\n  renderMatches,\n  resolvePath,\n  useBlocker,\n  useActionData,\n  useAsyncError,\n  useAsyncValue,\n  useHref,\n  useInRouterContext,\n  useLoaderData,\n  useLocation,\n  useMatch,\n  useMatches,\n  useNavigate,\n  useNavigation,\n  useNavigationType,\n  useOutlet,\n  useOutletContext,\n  useParams,\n  useResolvedPath,\n  useRevalidator,\n  useRouteError,\n  useRouteLoaderData,\n  useRoutes,\n};\n\nfunction mapRouteProperties(route: RouteObject) {\n  let updates: Partial<RouteObject> & { hasErrorBoundary: boolean } = {\n    // Note: this check also occurs in createRoutesFromChildren so update\n    // there if you change this -- please and thank you!\n    hasErrorBoundary: route.ErrorBoundary != null || route.errorElement != null,\n  };\n\n  if (route.Component) {\n    if (__DEV__) {\n      if (route.element) {\n        warning(\n          false,\n          \"You should not include both `Component` and `element` on your route - \" +\n            \"`Component` will be used.\"\n        );\n      }\n    }\n    Object.assign(updates, {\n      element: React.createElement(route.Component),\n      Component: undefined,\n    });\n  }\n\n  if (route.HydrateFallback) {\n    if (__DEV__) {\n      if (route.hydrateFallbackElement) {\n        warning(\n          false,\n          \"You should not include both `HydrateFallback` and `hydrateFallbackElement` on your route - \" +\n            \"`HydrateFallback` will be used.\"\n        );\n      }\n    }\n    Object.assign(updates, {\n      hydrateFallbackElement: React.createElement(route.HydrateFallback),\n      HydrateFallback: undefined,\n    });\n  }\n\n  if (route.ErrorBoundary) {\n    if (__DEV__) {\n      if (route.errorElement) {\n        warning(\n          false,\n          \"You should not include both `ErrorBoundary` and `errorElement` on your route - \" +\n            \"`ErrorBoundary` will be used.\"\n        );\n      }\n    }\n    Object.assign(updates, {\n      errorElement: React.createElement(route.ErrorBoundary),\n      ErrorBoundary: undefined,\n    });\n  }\n\n  return updates;\n}\n\nexport function createMemoryRouter(\n  routes: RouteObject[],\n  opts?: {\n    basename?: string;\n    future?: Partial<Omit<RouterFutureConfig, \"v7_prependBasename\">>;\n    hydrationData?: HydrationState;\n    initialEntries?: InitialEntry[];\n    initialIndex?: number;\n  }\n): RemixRouter {\n  return createRouter({\n    basename: opts?.basename,\n    future: {\n      ...opts?.future,\n      v7_prependBasename: true,\n    },\n    history: createMemoryHistory({\n      initialEntries: opts?.initialEntries,\n      initialIndex: opts?.initialIndex,\n    }),\n    hydrationData: opts?.hydrationData,\n    routes,\n    mapRouteProperties,\n  }).initialize();\n}\n\n///////////////////////////////////////////////////////////////////////////////\n// DANGER! PLEASE READ ME!\n// We provide these exports as an escape hatch in the event that you need any\n// routing data that we don't provide an explicit API for. With that said, we\n// want to cover your use case if we can, so if you feel the need to use these\n// we want to hear from you. Let us know what you're building and we'll do our\n// best to make sure we can support you!\n//\n// We consider these exports an implementation detail and do not guarantee\n// against any breaking changes, regardless of the semver release. Use with\n// extreme caution and only if you understand the consequences. Godspeed.\n///////////////////////////////////////////////////////////////////////////////\n\n/** @internal */\nexport {\n  DataRouterContext as UNSAFE_DataRouterContext,\n  DataRouterStateContext as UNSAFE_DataRouterStateContext,\n  LocationContext as UNSAFE_LocationContext,\n  NavigationContext as UNSAFE_NavigationContext,\n  RouteContext as UNSAFE_RouteContext,\n  mapRouteProperties as UNSAFE_mapRouteProperties,\n  useRouteId as UNSAFE_useRouteId,\n  useRoutesImpl as UNSAFE_useRoutesImpl,\n};\n"],"names":["DataRouterContext","React","DataRouterStateContext","AwaitContext","NavigationContext","LocationContext","RouteContext","outlet","matches","isDataRoute","RouteErrorContext","useHref","to","_temp","relative","useInRouterContext","invariant","basename","navigator","hash","pathname","search","useResolvedPath","joinedPathname","joinPaths","createHref","useLocation","location","useNavigationType","navigationType","useMatch","pattern","matchPath","useIsomorphicLayoutEffect","cb","static","useNavigate","router","useDataRouterContext","DataRouterHook","UseNavigateStable","id","useCurrentRouteId","DataRouterStateHook","activeRef","current","options","navigate","_extends","fromRouteId","useNavigateStable","dataRouterContext","future","locationPathname","routePathnamesJson","JSON","stringify","getResolveToMatches","v7_relativeSplatPath","go","path","resolveTo","parse","replace","push","state","useNavigateUnstable","OutletContext","useOutletContext","useOutlet","context","Provider","value","useParams","routeMatch","length","params","_temp2","useRoutes","routes","locationArg","useRoutesImpl","dataRouterState","parentMatches","parentParams","parentPathnameBase","pathnameBase","route","locationFromContext","_parsedLocationArg$pa","parsedLocationArg","parsePath","startsWith","remainingPathname","parentSegments","split","slice","join","matchRoutes","renderedMatches","_renderMatches","map","match","Object","assign","encodeLocation","key","NavigationType","Pop","DefaultErrorComponent","error","useRouteError","message","isRouteErrorResponse","status","statusText","Error","stack","preStyles","padding","backgroundColor","style","fontStyle","defaultErrorElement","RenderErrorBoundary","constructor","props","super","this","revalidation","getDerivedStateFromError","getDerivedStateFromProps","undefined","componentDidCatch","errorInfo","console","render","routeContext","children","component","RenderedRoute","_ref","staticContext","errorElement","ErrorBoundary","_deepestRenderedBoundaryId","_dataRouterState2","_dataRouterState","errors","errorIndex","findIndex","m","Math","min","renderFallback","fallbackIndex","v7_partialHydration","i","HydrateFallback","hydrateFallbackElement","loaderData","needsToRunLoader","loader","lazy","reduceRight","index","shouldRenderHydrateFallback","alreadyWarned","concat","getChildren","Component","element","hookName","ctx","useDataRouterState","useRouteContext","thisRoute","useRouteId","UseRouteId","useNavigation","UseNavigation","navigation","useRevalidator","UseRevalidator","revalidate","useMatches","UseMatches","convertRouteMatchToUiMatch","useLoaderData","UseLoaderData","routeId","useRouteLoaderData","UseRouteLoaderData","useActionData","UseActionData","actionData","_state$errors","UseRouteError","useAsyncValue","_data","useAsyncError","_error","blockerId","useBlocker","shouldBlock","UseBlocker","blockerKey","setBlockerKey","blockerFunction","arg","currentLocation","nextLocation","historyAction","stripBasename","String","deleteBlocker","getBlocker","blockers","has","get","IDLE_BLOCKER","startTransitionImpl","RouterProvider","fallbackElement","setStateImpl","v7_startTransition","setState","newState","subscribe","n","opts","preventScrollReset","Router","initialized","DataRoutes","_ref2","MemoryRouter","_ref3","initialEntries","initialIndex","historyRef","createMemoryHistory","v5Compat","history","action","listen","Navigate","_ref4","isStatic","jsonPath","Outlet","Route","_props","_ref5","basenameProp","locationProp","staticProp","navigationContext","locationContext","trailingPathname","Routes","_ref6","createRoutesFromChildren","Await","_ref7","resolve","AwaitErrorBoundary","ResolveAwait","AwaitRenderStatus","neverSettledPromise","Promise","promise","pending","renderError","reject","catch","defineProperty","_tracked","success","then","data","AbortedDeferredError","_ref8","toRender","parentPath","forEach","treePath","type","apply","caseSensitive","hasErrorBoundary","shouldRevalidate","handle","renderMatches","mapRouteProperties","updates","createMemoryRouter","createRouter","v7_prependBasename","hydrationData","initialize"],"sourceRoot":""}