{"version":3,"file":"react-router-2ea04720.js","sources":["../../../node_modules/react-router/dist/index.js"],"sourcesContent":["/**\n * React Router v6.22.0\n *\n * Copyright (c) Remix Software Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE.md file in the root directory of this source tree.\n *\n * @license MIT\n */\nimport * as React from 'react';\nimport { UNSAFE_invariant, joinPaths, matchPath, UNSAFE_getResolveToMatches, UNSAFE_warning, resolveTo, parsePath, matchRoutes, Action, UNSAFE_convertRouteMatchToUiMatch, stripBasename, IDLE_BLOCKER, isRouteErrorResponse, createMemoryHistory, AbortedDeferredError, createRouter } from '@remix-run/router';\nexport { AbortedDeferredError, Action as NavigationType, createPath, defer, generatePath, isRouteErrorResponse, json, matchPath, matchRoutes, parsePath, redirect, redirectDocument, resolvePath } from '@remix-run/router';\n\nfunction _extends() {\n  _extends = Object.assign ? Object.assign.bind() : function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n    return target;\n  };\n  return _extends.apply(this, arguments);\n}\n\n// Create react-specific types from the agnostic types in @remix-run/router to\n// export from react-router\nconst DataRouterContext = /*#__PURE__*/React.createContext(null);\nif (process.env.NODE_ENV !== \"production\") {\n  DataRouterContext.displayName = \"DataRouter\";\n}\nconst DataRouterStateContext = /*#__PURE__*/React.createContext(null);\nif (process.env.NODE_ENV !== \"production\") {\n  DataRouterStateContext.displayName = \"DataRouterState\";\n}\nconst AwaitContext = /*#__PURE__*/React.createContext(null);\nif (process.env.NODE_ENV !== \"production\") {\n  AwaitContext.displayName = \"Await\";\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 */\n\nconst NavigationContext = /*#__PURE__*/React.createContext(null);\nif (process.env.NODE_ENV !== \"production\") {\n  NavigationContext.displayName = \"Navigation\";\n}\nconst LocationContext = /*#__PURE__*/React.createContext(null);\nif (process.env.NODE_ENV !== \"production\") {\n  LocationContext.displayName = \"Location\";\n}\nconst RouteContext = /*#__PURE__*/React.createContext({\n  outlet: null,\n  matches: [],\n  isDataRoute: false\n});\nif (process.env.NODE_ENV !== \"production\") {\n  RouteContext.displayName = \"Route\";\n}\nconst RouteErrorContext = /*#__PURE__*/React.createContext(null);\nif (process.env.NODE_ENV !== \"production\") {\n  RouteErrorContext.displayName = \"RouteError\";\n}\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 */\nfunction useHref(to, _temp) {\n  let {\n    relative\n  } = _temp === void 0 ? {} : _temp;\n  !useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, // 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.\") : UNSAFE_invariant(false) : void 0;\n  let {\n    basename,\n    navigator\n  } = React.useContext(NavigationContext);\n  let {\n    hash,\n    pathname,\n    search\n  } = useResolvedPath(to, {\n    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 = pathname === \"/\" ? basename : joinPaths([basename, pathname]);\n  }\n  return navigator.createHref({\n    pathname: joinedPathname,\n    search,\n    hash\n  });\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 */\nfunction useInRouterContext() {\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 */\nfunction useLocation() {\n  !useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, // 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.\") : UNSAFE_invariant(false) : void 0;\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 */\nfunction useNavigationType() {\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 */\nfunction useMatch(pattern) {\n  !useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, // 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.\") : UNSAFE_invariant(false) : void 0;\n  let {\n    pathname\n  } = useLocation();\n  return React.useMemo(() => matchPath(pattern, pathname), [pathname, pattern]);\n}\n\n/**\n * The interface for the navigate() function returned from useNavigate().\n */\n\nconst navigateEffectWarning = \"You should call navigate() in a React.useEffect(), not when \" + \"your component is first rendered.\";\n\n// Mute warnings for calls to useNavigate in SSR environments\nfunction useIsomorphicLayoutEffect(cb) {\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 */\nfunction useNavigate() {\n  let {\n    isDataRoute\n  } = 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}\nfunction useNavigateUnstable() {\n  !useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, // 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.\") : UNSAFE_invariant(false) : void 0;\n  let dataRouterContext = React.useContext(DataRouterContext);\n  let {\n    basename,\n    future,\n    navigator\n  } = React.useContext(NavigationContext);\n  let {\n    matches\n  } = React.useContext(RouteContext);\n  let {\n    pathname: locationPathname\n  } = useLocation();\n  let routePathnamesJson = JSON.stringify(UNSAFE_getResolveToMatches(matches, future.v7_relativeSplatPath));\n  let activeRef = React.useRef(false);\n  useIsomorphicLayoutEffect(() => {\n    activeRef.current = true;\n  });\n  let navigate = React.useCallback(function (to, options) {\n    if (options === void 0) {\n      options = {};\n    }\n    process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(activeRef.current, navigateEffectWarning) : void 0;\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    if (typeof to === \"number\") {\n      navigator.go(to);\n      return;\n    }\n    let path = resolveTo(to, JSON.parse(routePathnamesJson), locationPathname, options.relative === \"path\");\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 = path.pathname === \"/\" ? basename : joinPaths([basename, path.pathname]);\n    }\n    (!!options.replace ? navigator.replace : navigator.push)(path, options.state, options);\n  }, [basename, navigator, routePathnamesJson, locationPathname, dataRouterContext]);\n  return navigate;\n}\nconst OutletContext = /*#__PURE__*/React.createContext(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 */\nfunction useOutletContext() {\n  return React.useContext(OutletContext);\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 */\nfunction useOutlet(context) {\n  let outlet = React.useContext(RouteContext).outlet;\n  if (outlet) {\n    return /*#__PURE__*/React.createElement(OutletContext.Provider, {\n      value: context\n    }, outlet);\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 */\nfunction useParams() {\n  let {\n    matches\n  } = React.useContext(RouteContext);\n  let routeMatch = matches[matches.length - 1];\n  return routeMatch ? routeMatch.params : {};\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 */\nfunction useResolvedPath(to, _temp2) {\n  let {\n    relative\n  } = _temp2 === void 0 ? {} : _temp2;\n  let {\n    future\n  } = React.useContext(NavigationContext);\n  let {\n    matches\n  } = React.useContext(RouteContext);\n  let {\n    pathname: locationPathname\n  } = useLocation();\n  let routePathnamesJson = JSON.stringify(UNSAFE_getResolveToMatches(matches, future.v7_relativeSplatPath));\n  return React.useMemo(() => resolveTo(to, JSON.parse(routePathnamesJson), locationPathname, relative === \"path\"), [to, routePathnamesJson, locationPathname, relative]);\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 */\nfunction useRoutes(routes, locationArg) {\n  return useRoutesImpl(routes, locationArg);\n}\n\n// Internal implementation with accept optional param for RouterProvider usage\nfunction useRoutesImpl(routes, locationArg, dataRouterState, future) {\n  !useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, // 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.\") : UNSAFE_invariant(false) : void 0;\n  let {\n    navigator\n  } = React.useContext(NavigationContext);\n  let {\n    matches: parentMatches\n  } = 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  if (process.env.NODE_ENV !== \"production\") {\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(parentPathname, !parentRoute || parentPath.endsWith(\"*\"), \"You rendered descendant <Routes> (or called `useRoutes()`) at \" + (\"\\\"\" + parentPathname + \"\\\" (under <Route path=\\\"\" + parentPath + \"\\\">) but the \") + \"parent route path has no trailing \\\"*\\\". This means if you navigate \" + \"deeper, the parent won't match anymore and therefore the child \" + \"routes will never render.\\n\\n\" + (\"Please change the parent <Route path=\\\"\" + parentPath + \"\\\"> to <Route \") + (\"path=\\\"\" + (parentPath === \"/\" ? \"*\" : parentPath + \"/*\") + \"\\\">.\"));\n  }\n  let locationFromContext = useLocation();\n  let location;\n  if (locationArg) {\n    var _parsedLocationArg$pa;\n    let parsedLocationArg = typeof locationArg === \"string\" ? parsePath(locationArg) : locationArg;\n    !(parentPathnameBase === \"/\" || ((_parsedLocationArg$pa = parsedLocationArg.pathname) == null ? void 0 : _parsedLocationArg$pa.startsWith(parentPathnameBase))) ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"When overriding the location using `<Routes location>` or `useRoutes(routes, location)`, \" + \"the location pathname must begin with the portion of the URL pathname that was \" + (\"matched by all parent routes. The current pathname base is \\\"\" + parentPathnameBase + \"\\\" \") + (\"but pathname \\\"\" + parsedLocationArg.pathname + \"\\\" was given in the `location` prop.\")) : UNSAFE_invariant(false) : void 0;\n    location = parsedLocationArg;\n  } else {\n    location = locationFromContext;\n  }\n  let pathname = location.pathname || \"/\";\n  let remainingPathname = parentPathnameBase === \"/\" ? pathname : pathname.slice(parentPathnameBase.length) || \"/\";\n  let matches = matchRoutes(routes, {\n    pathname: remainingPathname\n  });\n  if (process.env.NODE_ENV !== \"production\") {\n    process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(parentRoute || matches != null, \"No routes matched location \\\"\" + location.pathname + location.search + location.hash + \"\\\" \") : void 0;\n    process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(matches == null || matches[matches.length - 1].route.element !== undefined || matches[matches.length - 1].route.Component !== undefined || matches[matches.length - 1].route.lazy !== undefined, \"Matched leaf route at location \\\"\" + location.pathname + location.search + location.hash + \"\\\" \" + \"does not have an element or Component. This means it will render an <Outlet /> with a \" + \"null value by default resulting in an \\\"empty\\\" page.\") : void 0;\n  }\n  let renderedMatches = _renderMatches(matches && matches.map(match => Object.assign({}, match, {\n    params: Object.assign({}, parentParams, match.params),\n    pathname: joinPaths([parentPathnameBase,\n    // Re-encode pathnames that were decoded inside matchRoutes\n    navigator.encodeLocation ? navigator.encodeLocation(match.pathname).pathname : match.pathname]),\n    pathnameBase: match.pathnameBase === \"/\" ? parentPathnameBase : joinPaths([parentPathnameBase,\n    // Re-encode pathnames that were decoded inside matchRoutes\n    navigator.encodeLocation ? navigator.encodeLocation(match.pathnameBase).pathname : match.pathnameBase])\n  })), parentMatches, dataRouterState, future);\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 /*#__PURE__*/React.createElement(LocationContext.Provider, {\n      value: {\n        location: _extends({\n          pathname: \"/\",\n          search: \"\",\n          hash: \"\",\n          state: null,\n          key: \"default\"\n        }, location),\n        navigationType: Action.Pop\n      }\n    }, renderedMatches);\n  }\n  return renderedMatches;\n}\nfunction DefaultErrorComponent() {\n  let error = useRouteError();\n  let message = isRouteErrorResponse(error) ? error.status + \" \" + error.statusText : error instanceof Error ? error.message : JSON.stringify(error);\n  let stack = error instanceof Error ? error.stack : null;\n  let lightgrey = \"rgba(200,200,200, 0.5)\";\n  let preStyles = {\n    padding: \"0.5rem\",\n    backgroundColor: lightgrey\n  };\n  let codeStyles = {\n    padding: \"2px 4px\",\n    backgroundColor: lightgrey\n  };\n  let devInfo = null;\n  if (process.env.NODE_ENV !== \"production\") {\n    console.error(\"Error handled by React Router default ErrorBoundary:\", error);\n    devInfo = /*#__PURE__*/React.createElement(React.Fragment, 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 \", /*#__PURE__*/React.createElement(\"code\", {\n      style: codeStyles\n    }, \"ErrorBoundary\"), \" or\", \" \", /*#__PURE__*/React.createElement(\"code\", {\n      style: codeStyles\n    }, \"errorElement\"), \" prop on your route.\"));\n  }\n  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(\"h2\", null, \"Unexpected Application Error!\"), /*#__PURE__*/React.createElement(\"h3\", {\n    style: {\n      fontStyle: \"italic\"\n    }\n  }, message), stack ? /*#__PURE__*/React.createElement(\"pre\", {\n    style: preStyles\n  }, stack) : null, devInfo);\n}\nconst defaultErrorElement = /*#__PURE__*/React.createElement(DefaultErrorComponent, null);\nclass RenderErrorBoundary extends React.Component {\n  constructor(props) {\n    super(props);\n    this.state = {\n      location: props.location,\n      revalidation: props.revalidation,\n      error: props.error\n    };\n  }\n  static getDerivedStateFromError(error) {\n    return {\n      error: error\n    };\n  }\n  static getDerivedStateFromProps(props, state) {\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 (state.location !== props.location || state.revalidation !== \"idle\" && props.revalidation === \"idle\") {\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  componentDidCatch(error, errorInfo) {\n    console.error(\"React Router caught the following error during render\", error, errorInfo);\n  }\n  render() {\n    return this.state.error !== undefined ? /*#__PURE__*/React.createElement(RouteContext.Provider, {\n      value: this.props.routeContext\n    }, /*#__PURE__*/React.createElement(RouteErrorContext.Provider, {\n      value: this.state.error,\n      children: this.props.component\n    })) : this.props.children;\n  }\n}\nfunction RenderedRoute(_ref) {\n  let {\n    routeContext,\n    match,\n    children\n  } = _ref;\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 (dataRouterContext && dataRouterContext.static && dataRouterContext.staticContext && (match.route.errorElement || match.route.ErrorBoundary)) {\n    dataRouterContext.staticContext._deepestRenderedBoundaryId = match.route.id;\n  }\n  return /*#__PURE__*/React.createElement(RouteContext.Provider, {\n    value: routeContext\n  }, children);\n}\nfunction _renderMatches(matches, parentMatches, dataRouterState, future) {\n  var _dataRouterState2;\n  if (parentMatches === void 0) {\n    parentMatches = [];\n  }\n  if (dataRouterState === void 0) {\n    dataRouterState = null;\n  }\n  if (future === void 0) {\n    future = null;\n  }\n  if (matches == null) {\n    var _dataRouterState;\n    if ((_dataRouterState = dataRouterState) != null && _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;\n    } else {\n      return null;\n    }\n  }\n  let renderedMatches = matches;\n\n  // If we have data errors, trim matches to the highest error boundary\n  let errors = (_dataRouterState2 = dataRouterState) == null ? void 0 : _dataRouterState2.errors;\n  if (errors != null) {\n    let errorIndex = renderedMatches.findIndex(m => m.route.id && (errors == null ? void 0 : errors[m.route.id]));\n    !(errorIndex >= 0) ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"Could not find a matching route for errors on route IDs: \" + Object.keys(errors).join(\",\")) : UNSAFE_invariant(false) : void 0;\n    renderedMatches = renderedMatches.slice(0, Math.min(renderedMatches.length, errorIndex + 1));\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      if (match.route.id) {\n        let {\n          loaderData,\n          errors\n        } = dataRouterState;\n        let needsToRunLoader = match.route.loader && loaderData[match.route.id] === undefined && (!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  return renderedMatches.reduceRight((outlet, match, index) => {\n    // Only data routers handle errors/fallbacks\n    let error;\n    let shouldRenderHydrateFallback = false;\n    let errorElement = null;\n    let hydrateFallbackElement = null;\n    if (dataRouterState) {\n      error = errors && match.route.id ? errors[match.route.id] : undefined;\n      errorElement = match.route.errorElement || defaultErrorElement;\n      if (renderFallback) {\n        if (fallbackIndex < 0 && index === 0) {\n          warningOnce(\"route-fallback\", false, \"No `HydrateFallback` element provided to render during initial hydration\");\n          shouldRenderHydrateFallback = true;\n          hydrateFallbackElement = null;\n        } else if (fallbackIndex === index) {\n          shouldRenderHydrateFallback = true;\n          hydrateFallbackElement = match.route.hydrateFallbackElement || null;\n        }\n      }\n    }\n    let matches = parentMatches.concat(renderedMatches.slice(0, index + 1));\n    let getChildren = () => {\n      let children;\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 = /*#__PURE__*/React.createElement(match.route.Component, null);\n      } else if (match.route.element) {\n        children = match.route.element;\n      } else {\n        children = outlet;\n      }\n      return /*#__PURE__*/React.createElement(RenderedRoute, {\n        match: match,\n        routeContext: {\n          outlet,\n          matches,\n          isDataRoute: dataRouterState != null\n        },\n        children: children\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 && (match.route.ErrorBoundary || match.route.errorElement || index === 0) ? /*#__PURE__*/React.createElement(RenderErrorBoundary, {\n      location: dataRouterState.location,\n      revalidation: dataRouterState.revalidation,\n      component: errorElement,\n      error: error,\n      children: getChildren(),\n      routeContext: {\n        outlet: null,\n        matches,\n        isDataRoute: true\n      }\n    }) : getChildren();\n  }, null);\n}\nvar DataRouterHook = /*#__PURE__*/function (DataRouterHook) {\n  DataRouterHook[\"UseBlocker\"] = \"useBlocker\";\n  DataRouterHook[\"UseRevalidator\"] = \"useRevalidator\";\n  DataRouterHook[\"UseNavigateStable\"] = \"useNavigate\";\n  return DataRouterHook;\n}(DataRouterHook || {});\nvar DataRouterStateHook = /*#__PURE__*/function (DataRouterStateHook) {\n  DataRouterStateHook[\"UseBlocker\"] = \"useBlocker\";\n  DataRouterStateHook[\"UseLoaderData\"] = \"useLoaderData\";\n  DataRouterStateHook[\"UseActionData\"] = \"useActionData\";\n  DataRouterStateHook[\"UseRouteError\"] = \"useRouteError\";\n  DataRouterStateHook[\"UseNavigation\"] = \"useNavigation\";\n  DataRouterStateHook[\"UseRouteLoaderData\"] = \"useRouteLoaderData\";\n  DataRouterStateHook[\"UseMatches\"] = \"useMatches\";\n  DataRouterStateHook[\"UseRevalidator\"] = \"useRevalidator\";\n  DataRouterStateHook[\"UseNavigateStable\"] = \"useNavigate\";\n  DataRouterStateHook[\"UseRouteId\"] = \"useRouteId\";\n  return DataRouterStateHook;\n}(DataRouterStateHook || {});\nfunction getDataRouterConsoleError(hookName) {\n  return hookName + \" must be used within a data router.  See https://reactrouter.com/routers/picking-a-router.\";\n}\nfunction useDataRouterContext(hookName) {\n  let ctx = React.useContext(DataRouterContext);\n  !ctx ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, getDataRouterConsoleError(hookName)) : UNSAFE_invariant(false) : void 0;\n  return ctx;\n}\nfunction useDataRouterState(hookName) {\n  let state = React.useContext(DataRouterStateContext);\n  !state ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, getDataRouterConsoleError(hookName)) : UNSAFE_invariant(false) : void 0;\n  return state;\n}\nfunction useRouteContext(hookName) {\n  let route = React.useContext(RouteContext);\n  !route ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, getDataRouterConsoleError(hookName)) : UNSAFE_invariant(false) : void 0;\n  return route;\n}\n\n// Internal version with hookName-aware debugging\nfunction useCurrentRouteId(hookName) {\n  let route = useRouteContext(hookName);\n  let thisRoute = route.matches[route.matches.length - 1];\n  !thisRoute.route.id ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, hookName + \" can only be used on routes that contain a unique \\\"id\\\"\") : UNSAFE_invariant(false) : void 0;\n  return thisRoute.route.id;\n}\n\n/**\n * Returns the ID for the nearest contextual route\n */\nfunction 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 */\nfunction 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 */\nfunction useRevalidator() {\n  let dataRouterContext = useDataRouterContext(DataRouterHook.UseRevalidator);\n  let state = useDataRouterState(DataRouterStateHook.UseRevalidator);\n  return React.useMemo(() => ({\n    revalidate: dataRouterContext.router.revalidate,\n    state: state.revalidation\n  }), [dataRouterContext.router.revalidate, state.revalidation]);\n}\n\n/**\n * Returns the active route matches, useful for accessing loaderData for\n * parent/child routes or the route \"handle\" property\n */\nfunction useMatches() {\n  let {\n    matches,\n    loaderData\n  } = useDataRouterState(DataRouterStateHook.UseMatches);\n  return React.useMemo(() => matches.map(m => UNSAFE_convertRouteMatchToUiMatch(m, loaderData)), [matches, loaderData]);\n}\n\n/**\n * Returns the loader data for the nearest ancestor Route loader\n */\nfunction useLoaderData() {\n  let state = useDataRouterState(DataRouterStateHook.UseLoaderData);\n  let routeId = useCurrentRouteId(DataRouterStateHook.UseLoaderData);\n  if (state.errors && state.errors[routeId] != null) {\n    console.error(\"You cannot `useLoaderData` in an errorElement (routeId: \" + routeId + \")\");\n    return undefined;\n  }\n  return state.loaderData[routeId];\n}\n\n/**\n * Returns the loaderData for the given routeId\n */\nfunction useRouteLoaderData(routeId) {\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 */\nfunction useActionData() {\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 */\nfunction useRouteError() {\n  var _state$errors;\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 = state.errors) == null ? void 0 : _state$errors[routeId];\n}\n\n/**\n * Returns the happy-path data from the nearest ancestor `<Await />` value\n */\nfunction useAsyncValue() {\n  let value = React.useContext(AwaitContext);\n  return value == null ? void 0 : value._data;\n}\n\n/**\n * Returns the error from the nearest ancestor `<Await />` value\n */\nfunction useAsyncError() {\n  let value = React.useContext(AwaitContext);\n  return value == null ? void 0 : value._error;\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 */\nfunction useBlocker(shouldBlock) {\n  let {\n    router,\n    basename\n  } = useDataRouterContext(DataRouterHook.UseBlocker);\n  let state = useDataRouterState(DataRouterStateHook.UseBlocker);\n  let [blockerKey, setBlockerKey] = React.useState(\"\");\n  let blockerFunction = React.useCallback(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 {\n      currentLocation,\n      nextLocation,\n      historyAction\n    } = arg;\n    return shouldBlock({\n      currentLocation: _extends({}, currentLocation, {\n        pathname: stripBasename(currentLocation.pathname, basename) || currentLocation.pathname\n      }),\n      nextLocation: _extends({}, nextLocation, {\n        pathname: stripBasename(nextLocation.pathname, basename) || nextLocation.pathname\n      }),\n      historyAction\n    });\n  }, [basename, shouldBlock]);\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) ? state.blockers.get(blockerKey) : 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() {\n  let {\n    router\n  } = useDataRouterContext(DataRouterHook.UseNavigateStable);\n  let id = useCurrentRouteId(DataRouterStateHook.UseNavigateStable);\n  let activeRef = React.useRef(false);\n  useIsomorphicLayoutEffect(() => {\n    activeRef.current = true;\n  });\n  let navigate = React.useCallback(function (to, options) {\n    if (options === void 0) {\n      options = {};\n    }\n    process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(activeRef.current, navigateEffectWarning) : void 0;\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    if (typeof to === \"number\") {\n      router.navigate(to);\n    } else {\n      router.navigate(to, _extends({\n        fromRouteId: id\n      }, options));\n    }\n  }, [router, id]);\n  return navigate;\n}\nconst alreadyWarned = {};\nfunction warningOnce(key, cond, message) {\n  if (!cond && !alreadyWarned[key]) {\n    alreadyWarned[key] = true;\n    process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(false, message) : void 0;\n  }\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 */\nfunction RouterProvider(_ref) {\n  let {\n    fallbackElement,\n    router,\n    future\n  } = _ref;\n  let [state, setStateImpl] = React.useState(router.state);\n  let {\n    v7_startTransition\n  } = future || {};\n  let setState = React.useCallback(newState => {\n    if (v7_startTransition && startTransitionImpl) {\n      startTransitionImpl(() => setStateImpl(newState));\n    } else {\n      setStateImpl(newState);\n    }\n  }, [setStateImpl, v7_startTransition]);\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  React.useEffect(() => {\n    process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(fallbackElement == null || !router.future.v7_partialHydration, \"`<RouterProvider fallbackElement>` is deprecated when using \" + \"`v7_partialHydration`, use a `HydrateFallback` component instead\") : void 0;\n    // Only log this once on initial mount\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, []);\n  let navigator = React.useMemo(() => {\n    return {\n      createHref: router.createHref,\n      encodeLocation: router.encodeLocation,\n      go: n => router.navigate(n),\n      push: (to, state, opts) => router.navigate(to, {\n        state,\n        preventScrollReset: opts == null ? void 0 : opts.preventScrollReset\n      }),\n      replace: (to, state, opts) => router.navigate(to, {\n        replace: true,\n        state,\n        preventScrollReset: opts == null ? void 0 : opts.preventScrollReset\n      })\n    };\n  }, [router]);\n  let basename = router.basename || \"/\";\n  let dataRouterContext = React.useMemo(() => ({\n    router,\n    navigator,\n    static: false,\n    basename\n  }), [router, navigator, basename]);\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 /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(DataRouterContext.Provider, {\n    value: dataRouterContext\n  }, /*#__PURE__*/React.createElement(DataRouterStateContext.Provider, {\n    value: state\n  }, /*#__PURE__*/React.createElement(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  }, state.initialized || router.future.v7_partialHydration ? /*#__PURE__*/React.createElement(DataRoutes, {\n    routes: router.routes,\n    future: router.future,\n    state: state\n  }) : fallbackElement))), null);\n}\nfunction DataRoutes(_ref2) {\n  let {\n    routes,\n    future,\n    state\n  } = _ref2;\n  return useRoutesImpl(routes, undefined, state, future);\n}\n/**\n * A `<Router>` that stores all entries in memory.\n *\n * @see https://reactrouter.com/router-components/memory-router\n */\nfunction MemoryRouter(_ref3) {\n  let {\n    basename,\n    children,\n    initialEntries,\n    initialIndex,\n    future\n  } = _ref3;\n  let historyRef = React.useRef();\n  if (historyRef.current == null) {\n    historyRef.current = createMemoryHistory({\n      initialEntries,\n      initialIndex,\n      v5Compat: true\n    });\n  }\n  let history = historyRef.current;\n  let [state, setStateImpl] = React.useState({\n    action: history.action,\n    location: history.location\n  });\n  let {\n    v7_startTransition\n  } = future || {};\n  let setState = React.useCallback(newState => {\n    v7_startTransition && startTransitionImpl ? startTransitionImpl(() => setStateImpl(newState)) : setStateImpl(newState);\n  }, [setStateImpl, v7_startTransition]);\n  React.useLayoutEffect(() => history.listen(setState), [history, setState]);\n  return /*#__PURE__*/React.createElement(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 * 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 */\nfunction Navigate(_ref4) {\n  let {\n    to,\n    replace,\n    state,\n    relative\n  } = _ref4;\n  !useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, // 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.\") : UNSAFE_invariant(false) : void 0;\n  let {\n    future,\n    static: isStatic\n  } = React.useContext(NavigationContext);\n  process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(!isStatic, \"<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.\") : void 0;\n  let {\n    matches\n  } = React.useContext(RouteContext);\n  let {\n    pathname: locationPathname\n  } = 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(to, UNSAFE_getResolveToMatches(matches, future.v7_relativeSplatPath), locationPathname, relative === \"path\");\n  let jsonPath = JSON.stringify(path);\n  React.useEffect(() => navigate(JSON.parse(jsonPath), {\n    replace,\n    state,\n    relative\n  }), [navigate, jsonPath, relative, replace, state]);\n  return null;\n}\n/**\n * Renders the child route's element, if there is one.\n *\n * @see https://reactrouter.com/components/outlet\n */\nfunction Outlet(props) {\n  return useOutlet(props.context);\n}\n/**\n * Declares an element that should be rendered at a certain URL path.\n *\n * @see https://reactrouter.com/components/route\n */\nfunction Route(_props) {\n  process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"A <Route> is only ever to be used as the child of <Routes> element, \" + \"never rendered directly. Please wrap your <Route> in a <Routes>.\") : UNSAFE_invariant(false) ;\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 */\nfunction Router(_ref5) {\n  let {\n    basename: basenameProp = \"/\",\n    children = null,\n    location: locationProp,\n    navigationType = Action.Pop,\n    navigator,\n    static: staticProp = false,\n    future\n  } = _ref5;\n  !!useInRouterContext() ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"You cannot render a <Router> inside another <Router>.\" + \" You should never have more than one in your app.\") : UNSAFE_invariant(false) : void 0;\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    basename,\n    navigator,\n    static: staticProp,\n    future: _extends({\n      v7_relativeSplatPath: false\n    }, future)\n  }), [basename, future, navigator, staticProp]);\n  if (typeof locationProp === \"string\") {\n    locationProp = parsePath(locationProp);\n  }\n  let {\n    pathname = \"/\",\n    search = \"\",\n    hash = \"\",\n    state = null,\n    key = \"default\"\n  } = locationProp;\n  let locationContext = React.useMemo(() => {\n    let trailingPathname = stripBasename(pathname, basename);\n    if (trailingPathname == null) {\n      return null;\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  process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(locationContext != null, \"<Router basename=\\\"\" + basename + \"\\\"> is not able to match the URL \" + (\"\\\"\" + pathname + search + hash + \"\\\" because it does not start with the \") + \"basename, so the <Router> won't render anything.\") : void 0;\n  if (locationContext == null) {\n    return null;\n  }\n  return /*#__PURE__*/React.createElement(NavigationContext.Provider, {\n    value: navigationContext\n  }, /*#__PURE__*/React.createElement(LocationContext.Provider, {\n    children: children,\n    value: locationContext\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 */\nfunction Routes(_ref6) {\n  let {\n    children,\n    location\n  } = _ref6;\n  return useRoutes(createRoutesFromChildren(children), location);\n}\n/**\n * Component to use for rendering lazily loaded data from returning defer()\n * in a loader function\n */\nfunction Await(_ref7) {\n  let {\n    children,\n    errorElement,\n    resolve\n  } = _ref7;\n  return /*#__PURE__*/React.createElement(AwaitErrorBoundary, {\n    resolve: resolve,\n    errorElement: errorElement\n  }, /*#__PURE__*/React.createElement(ResolveAwait, null, children));\n}\nvar AwaitRenderStatus = /*#__PURE__*/function (AwaitRenderStatus) {\n  AwaitRenderStatus[AwaitRenderStatus[\"pending\"] = 0] = \"pending\";\n  AwaitRenderStatus[AwaitRenderStatus[\"success\"] = 1] = \"success\";\n  AwaitRenderStatus[AwaitRenderStatus[\"error\"] = 2] = \"error\";\n  return AwaitRenderStatus;\n}(AwaitRenderStatus || {});\nconst neverSettledPromise = new Promise(() => {});\nclass AwaitErrorBoundary extends React.Component {\n  constructor(props) {\n    super(props);\n    this.state = {\n      error: null\n    };\n  }\n  static getDerivedStateFromError(error) {\n    return {\n      error\n    };\n  }\n  componentDidCatch(error, errorInfo) {\n    console.error(\"<Await> caught the following error during render\", error, errorInfo);\n  }\n  render() {\n    let {\n      children,\n      errorElement,\n      resolve\n    } = this.props;\n    let promise = null;\n    let status = AwaitRenderStatus.pending;\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\", {\n        get: () => true\n      });\n      Object.defineProperty(promise, \"_data\", {\n        get: () => resolve\n      });\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\", {\n        get: () => true\n      });\n      Object.defineProperty(promise, \"_error\", {\n        get: () => renderError\n      });\n    } else if (resolve._tracked) {\n      // Already tracked promise - check contents\n      promise = resolve;\n      status = promise._error !== undefined ? AwaitRenderStatus.error : promise._data !== undefined ? AwaitRenderStatus.success : AwaitRenderStatus.pending;\n    } else {\n      // Raw (untracked) promise - track it\n      status = AwaitRenderStatus.pending;\n      Object.defineProperty(resolve, \"_tracked\", {\n        get: () => true\n      });\n      promise = resolve.then(data => Object.defineProperty(resolve, \"_data\", {\n        get: () => data\n      }), error => Object.defineProperty(resolve, \"_error\", {\n        get: () => error\n      }));\n    }\n    if (status === AwaitRenderStatus.error && promise._error instanceof AbortedDeferredError) {\n      // Freeze the UI by throwing a never resolved promise\n      throw neverSettledPromise;\n    }\n    if (status === AwaitRenderStatus.error && !errorElement) {\n      // No errorElement, throw to the nearest route-level error boundary\n      throw promise._error;\n    }\n    if (status === AwaitRenderStatus.error) {\n      // Render via our errorElement\n      return /*#__PURE__*/React.createElement(AwaitContext.Provider, {\n        value: promise,\n        children: errorElement\n      });\n    }\n    if (status === AwaitRenderStatus.success) {\n      // Render children with resolved value\n      return /*#__PURE__*/React.createElement(AwaitContext.Provider, {\n        value: promise,\n        children: children\n      });\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(_ref8) {\n  let {\n    children\n  } = _ref8;\n  let data = useAsyncValue();\n  let toRender = typeof children === \"function\" ? children(data) : children;\n  return /*#__PURE__*/React.createElement(React.Fragment, null, 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 */\nfunction createRoutesFromChildren(children, parentPath) {\n  if (parentPath === void 0) {\n    parentPath = [];\n  }\n  let routes = [];\n  React.Children.forEach(children, (element, index) => {\n    if (! /*#__PURE__*/React.isValidElement(element)) {\n      // Ignore non-elements. This allows people to more easily inline\n      // conditionals in their route config.\n      return;\n    }\n    let treePath = [...parentPath, index];\n    if (element.type === React.Fragment) {\n      // Transparently support React.Fragment and its children.\n      routes.push.apply(routes, createRoutesFromChildren(element.props.children, treePath));\n      return;\n    }\n    !(element.type === Route) ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"[\" + (typeof element.type === \"string\" ? element.type : element.type.name) + \"] is not a <Route> component. All component children of <Routes> must be a <Route> or <React.Fragment>\") : UNSAFE_invariant(false) : void 0;\n    !(!element.props.index || !element.props.children) ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"An index route cannot have child routes.\") : UNSAFE_invariant(false) : void 0;\n    let route = {\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: element.props.ErrorBoundary != null || element.props.errorElement != null,\n      shouldRevalidate: element.props.shouldRevalidate,\n      handle: element.props.handle,\n      lazy: element.props.lazy\n    };\n    if (element.props.children) {\n      route.children = createRoutesFromChildren(element.props.children, treePath);\n    }\n    routes.push(route);\n  });\n  return routes;\n}\n\n/**\n * Renders the result of `matchRoutes()` into a React element.\n */\nfunction renderMatches(matches) {\n  return _renderMatches(matches);\n}\n\nfunction mapRouteProperties(route) {\n  let updates = {\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  if (route.Component) {\n    if (process.env.NODE_ENV !== \"production\") {\n      if (route.element) {\n        process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(false, \"You should not include both `Component` and `element` on your route - \" + \"`Component` will be used.\") : void 0;\n      }\n    }\n    Object.assign(updates, {\n      element: /*#__PURE__*/React.createElement(route.Component),\n      Component: undefined\n    });\n  }\n  if (route.HydrateFallback) {\n    if (process.env.NODE_ENV !== \"production\") {\n      if (route.hydrateFallbackElement) {\n        process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(false, \"You should not include both `HydrateFallback` and `hydrateFallbackElement` on your route - \" + \"`HydrateFallback` will be used.\") : void 0;\n      }\n    }\n    Object.assign(updates, {\n      hydrateFallbackElement: /*#__PURE__*/React.createElement(route.HydrateFallback),\n      HydrateFallback: undefined\n    });\n  }\n  if (route.ErrorBoundary) {\n    if (process.env.NODE_ENV !== \"production\") {\n      if (route.errorElement) {\n        process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(false, \"You should not include both `ErrorBoundary` and `errorElement` on your route - \" + \"`ErrorBoundary` will be used.\") : void 0;\n      }\n    }\n    Object.assign(updates, {\n      errorElement: /*#__PURE__*/React.createElement(route.ErrorBoundary),\n      ErrorBoundary: undefined\n    });\n  }\n  return updates;\n}\nfunction createMemoryRouter(routes, opts) {\n  return createRouter({\n    basename: opts == null ? void 0 : opts.basename,\n    future: _extends({}, opts == null ? void 0 : opts.future, {\n      v7_prependBasename: true\n    }),\n    history: createMemoryHistory({\n      initialEntries: opts == null ? void 0 : opts.initialEntries,\n      initialIndex: opts == null ? void 0 : opts.initialIndex\n    }),\n    hydrationData: opts == null ? void 0 : opts.hydrationData,\n    routes,\n    mapRouteProperties\n  }).initialize();\n}\n\nexport { Await, MemoryRouter, Navigate, Outlet, Route, Router, RouterProvider, Routes, DataRouterContext as UNSAFE_DataRouterContext, DataRouterStateContext as UNSAFE_DataRouterStateContext, LocationContext as UNSAFE_LocationContext, NavigationContext as UNSAFE_NavigationContext, RouteContext as UNSAFE_RouteContext, mapRouteProperties as UNSAFE_mapRouteProperties, useRouteId as UNSAFE_useRouteId, useRoutesImpl as UNSAFE_useRoutesImpl, createMemoryRouter, createRoutesFromChildren, createRoutesFromChildren as createRoutesFromElements, renderMatches, useActionData, useAsyncError, useAsyncValue, useBlocker, useHref, useInRouterContext, useLoaderData, useLocation, useMatch, useMatches, useNavigate, useNavigation, useNavigationType, useOutlet, useOutletContext, useParams, useResolvedPath, useRevalidator, useRouteError, useRouteLoaderData, useRoutes };\n//# sourceMappingURL=index.js.map\n"],"names":["_extends","target","i","source","key","DataRouterContext","React.createContext","DataRouterStateContext","NavigationContext","LocationContext","RouteContext","RouteErrorContext","useHref","to","_temp","relative","useInRouterContext","UNSAFE_invariant","basename","navigator","React.useContext","hash","pathname","search","useResolvedPath","joinedPathname","joinPaths","useLocation","useIsomorphicLayoutEffect","cb","React.useLayoutEffect","useNavigate","isDataRoute","useNavigateStable","useNavigateUnstable","dataRouterContext","future","matches","locationPathname","routePathnamesJson","UNSAFE_getResolveToMatches","activeRef","React.useRef","React.useCallback","options","path","resolveTo","OutletContext","useOutlet","context","outlet","React.createElement","_temp2","React.useMemo","useRoutes","routes","locationArg","useRoutesImpl","dataRouterState","parentMatches","routeMatch","parentParams","parentPathnameBase","locationFromContext","location","_parsedLocationArg$pa","parsedLocationArg","parsePath","remainingPathname","matchRoutes","renderedMatches","_renderMatches","match","Action","DefaultErrorComponent","error","useRouteError","message","isRouteErrorResponse","stack","preStyles","devInfo","React.Fragment","defaultErrorElement","RenderErrorBoundary","React.Component","props","state","errorInfo","RenderedRoute","_ref","routeContext","children","_dataRouterState2","_dataRouterState","errors","errorIndex","m","renderFallback","fallbackIndex","loaderData","needsToRunLoader","index","shouldRenderHydrateFallback","errorElement","hydrateFallbackElement","warningOnce","getChildren","DataRouterHook","DataRouterStateHook","useDataRouterContext","hookName","ctx","useDataRouterState","useRouteContext","route","useCurrentRouteId","thisRoute","_state$errors","routeId","router","id","alreadyWarned","cond","Navigate","_ref4","replace","isStatic","navigate","jsonPath","React.useEffect","Outlet","Route","_props","Router","_ref5","basenameProp","locationProp","navigationType","staticProp","navigationContext","locationContext","trailingPathname","stripBasename","Routes","_ref6","createRoutesFromChildren","parentPath","React.Children","element","React.isValidElement","treePath"],"mappings":"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","x_google_ignoreList":[0]}