{"version":3,"file":"js/8934.js","mappings":"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","sources":["webpack://nocodenodeweb/./node_modules/lodash/isEqual.js","webpack://nocodenodeweb/./node_modules/react-router/lib/context.ts","webpack://nocodenodeweb/./node_modules/react-router/lib/hooks.tsx","webpack://nocodenodeweb/./node_modules/react-router/lib/deprecations.ts","webpack://nocodenodeweb/./node_modules/react-router/lib/components.tsx","webpack://nocodenodeweb/./node_modules/react/index.js","webpack://nocodenodeweb/./node_modules/@loadable/component/dist/esm/loadable.esm.mjs"],"sourcesContent":["var baseIsEqual = require('./_baseIsEqual');\n\n/**\n * Performs a deep comparison between two values to determine if they are\n * equivalent.\n *\n * **Note:** This method supports comparing arrays, array buffers, booleans,\n * date objects, error objects, maps, numbers, `Object` objects, regexes,\n * sets, strings, symbols, and typed arrays. `Object` objects are compared\n * by their own, not inherited, enumerable properties. Functions and DOM\n * nodes are compared by strict equality, i.e. `===`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n *\n * var object = { 'a': 1 };\n * var other = { 'a': 1 };\n *\n * _.isEqual(object, other);\n * // => true\n *\n * object === other;\n * // => false\n */\nfunction isEqual(value, other) {\n  return baseIsEqual(value, other);\n}\n\nmodule.exports = isEqual;\n","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  flushSync?: boolean;\n  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_decodePath as decodePath,\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/v6/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/v6/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/v6/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/v6/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/v6/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, decodePath(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/v6/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/v6/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/v6/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/v6/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/v6/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/v6/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) {\n      return null;\n    }\n\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 if (\n      future?.v7_partialHydration &&\n      parentMatches.length === 0 &&\n      !dataRouterState.initialized &&\n      dataRouterState.matches.length > 0\n    ) {\n      // Don't bail if we're initializing with partial hydration and we have\n      // router matches.  That means we're actively running `patchRoutesOnNavigation`\n      // so we should render down the partial matches to the appropriate\n      // `HydrateFallback`.  We only do this if `parentMatches` is empty so it\n      // only impacts the root matches for `RouterProvider` and no descendant\n      // `<Routes>`\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] !== undefined\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/v6/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 { FutureConfig as RouterFutureConfig } from \"@remix-run/router\";\nimport type { FutureConfig as RenderFutureConfig } from \"./components\";\n\nconst alreadyWarned: { [key: string]: boolean } = {};\n\nexport function warnOnce(key: string, message: string): void {\n  if (!alreadyWarned[message]) {\n    alreadyWarned[message] = true;\n    console.warn(message);\n  }\n}\n\nconst logDeprecation = (flag: string, msg: string, link: string) =>\n  warnOnce(\n    flag,\n    `⚠️ React Router Future Flag Warning: ${msg}. ` +\n      `You can use the \\`${flag}\\` future flag to opt-in early. ` +\n      `For more information, see ${link}.`\n  );\n\nexport function logV6DeprecationWarnings(\n  renderFuture: Partial<RenderFutureConfig> | undefined,\n  routerFuture?: Omit<RouterFutureConfig, \"v7_prependBasename\">\n) {\n  if (!renderFuture?.v7_startTransition) {\n    logDeprecation(\n      \"v7_startTransition\",\n      \"React Router will begin wrapping state updates in `React.startTransition` in v7\",\n      \"https://reactrouter.com/v6/upgrading/future#v7_starttransition\"\n    );\n  }\n\n  if (\n    !renderFuture?.v7_relativeSplatPath &&\n    (!routerFuture || !routerFuture.v7_relativeSplatPath)\n  ) {\n    logDeprecation(\n      \"v7_relativeSplatPath\",\n      \"Relative route resolution within Splat routes is changing in v7\",\n      \"https://reactrouter.com/v6/upgrading/future#v7_relativesplatpath\"\n    );\n  }\n\n  if (routerFuture) {\n    if (!routerFuture.v7_fetcherPersist) {\n      logDeprecation(\n        \"v7_fetcherPersist\",\n        \"The persistence behavior of fetchers is changing in v7\",\n        \"https://reactrouter.com/v6/upgrading/future#v7_fetcherpersist\"\n      );\n    }\n\n    if (!routerFuture.v7_normalizeFormMethod) {\n      logDeprecation(\n        \"v7_normalizeFormMethod\",\n        \"Casing of `formMethod` fields is being normalized to uppercase in v7\",\n        \"https://reactrouter.com/v6/upgrading/future#v7_normalizeformmethod\"\n      );\n    }\n\n    if (!routerFuture.v7_partialHydration) {\n      logDeprecation(\n        \"v7_partialHydration\",\n        \"`RouterProvider` hydration behavior is changing in v7\",\n        \"https://reactrouter.com/v6/upgrading/future#v7_partialhydration\"\n      );\n    }\n\n    if (!routerFuture.v7_skipActionErrorRevalidation) {\n      logDeprecation(\n        \"v7_skipActionErrorRevalidation\",\n        \"The revalidation behavior after 4xx/5xx `action` responses is changing in v7\",\n        \"https://reactrouter.com/v6/upgrading/future#v7_skipactionerrorrevalidation\"\n      );\n    }\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\";\nimport { logV6DeprecationWarnings } from \"./deprecations\";\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  React.useEffect(\n    () => logV6DeprecationWarnings(future, router.future),\n    [router, future]\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/v6/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  React.useEffect(() => logV6DeprecationWarnings(future), [future]);\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/v6/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/v6/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/v6/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/v6/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/v6/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        \"_error\" in promise\n          ? AwaitRenderStatus.error\n          : \"_data\" in promise\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/v6/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","'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n  module.exports = require('./cjs/react.production.min.js');\n} else {\n  module.exports = require('./cjs/react.development.js');\n}\n","import React from 'react';\nimport _objectWithoutPropertiesLoose from '@babel/runtime/helpers/esm/objectWithoutPropertiesLoose';\nimport _extends from '@babel/runtime/helpers/esm/extends';\nimport _assertThisInitialized from '@babel/runtime/helpers/esm/assertThisInitialized';\nimport _inheritsLoose from '@babel/runtime/helpers/esm/inheritsLoose';\nimport hoistNonReactStatics from 'hoist-non-react-statics';\n\n/* eslint-disable import/prefer-default-export */\nfunction invariant(condition, message) {\n  if (condition) return;\n  var error = new Error(\"loadable: \" + message);\n  error.framesToPop = 1;\n  error.name = 'Invariant Violation';\n  throw error;\n}\nfunction warn(message) {\n  // eslint-disable-next-line no-console\n  console.warn(\"loadable: \" + message);\n}\n\nvar Context = /*#__PURE__*/\nReact.createContext();\n\nvar LOADABLE_REQUIRED_CHUNKS_KEY = '__LOADABLE_REQUIRED_CHUNKS__';\nfunction getRequiredChunkKey(namespace) {\n  return \"\" + namespace + LOADABLE_REQUIRED_CHUNKS_KEY;\n}\n\nvar sharedInternals = /*#__PURE__*/Object.freeze({\n  __proto__: null,\n  getRequiredChunkKey: getRequiredChunkKey,\n  invariant: invariant,\n  Context: Context\n});\n\nvar LOADABLE_SHARED = {\n  initialChunks: {}\n};\n\nvar STATUS_PENDING = 'PENDING';\nvar STATUS_RESOLVED = 'RESOLVED';\nvar STATUS_REJECTED = 'REJECTED';\n\nfunction resolveConstructor(ctor) {\n  if (typeof ctor === 'function') {\n    return {\n      requireAsync: ctor,\n      resolve: function resolve() {\n        return undefined;\n      },\n      chunkName: function chunkName() {\n        return undefined;\n      }\n    };\n  }\n\n  return ctor;\n}\n\nvar withChunkExtractor = function withChunkExtractor(Component) {\n  var LoadableWithChunkExtractor = function LoadableWithChunkExtractor(props) {\n    return React.createElement(Context.Consumer, null, function (extractor) {\n      return React.createElement(Component, Object.assign({\n        __chunkExtractor: extractor\n      }, props));\n    });\n  };\n\n  if (Component.displayName) {\n    LoadableWithChunkExtractor.displayName = Component.displayName + \"WithChunkExtractor\";\n  }\n\n  return LoadableWithChunkExtractor;\n};\n\nvar identity = function identity(v) {\n  return v;\n};\n\nfunction createLoadable(_ref) {\n  var _ref$defaultResolveCo = _ref.defaultResolveComponent,\n      defaultResolveComponent = _ref$defaultResolveCo === void 0 ? identity : _ref$defaultResolveCo,\n      _render = _ref.render,\n      onLoad = _ref.onLoad;\n\n  function loadable(loadableConstructor, options) {\n    if (options === void 0) {\n      options = {};\n    }\n\n    var ctor = resolveConstructor(loadableConstructor);\n    var cache = {};\n    /**\n     * Cachekey represents the component to be loaded\n     * if key changes - component has to be reloaded\n     * @param props\n     * @returns {null|Component}\n     */\n\n    function _getCacheKey(props) {\n      if (options.cacheKey) {\n        return options.cacheKey(props);\n      }\n\n      if (ctor.resolve) {\n        return ctor.resolve(props);\n      }\n\n      return 'static';\n    }\n    /**\n     * Resolves loaded `module` to a specific `Component\n     * @param module\n     * @param props\n     * @param Loadable\n     * @returns Component\n     */\n\n\n    function resolve(module, props, Loadable) {\n      var Component = options.resolveComponent ? options.resolveComponent(module, props) : defaultResolveComponent(module); // FIXME: suppressed due to https://github.com/gregberge/loadable-components/issues/990\n      // if (options.resolveComponent && !ReactIs.isValidElementType(Component)) {\n      //   throw new Error(\n      //     `resolveComponent returned something that is not a React component!`,\n      //   )\n      // }\n\n      hoistNonReactStatics(Loadable, Component, {\n        preload: true\n      });\n      return Component;\n    }\n\n    var cachedLoad = function cachedLoad(props) {\n      var cacheKey = _getCacheKey(props);\n\n      var promise = cache[cacheKey];\n\n      if (!promise || promise.status === STATUS_REJECTED) {\n        promise = ctor.requireAsync(props);\n        promise.status = STATUS_PENDING;\n        cache[cacheKey] = promise;\n        promise.then(function () {\n          promise.status = STATUS_RESOLVED;\n        }, function (error) {\n          console.error('loadable-components: failed to asynchronously load component', {\n            fileName: ctor.resolve(props),\n            chunkName: ctor.chunkName(props),\n            error: error ? error.message : error\n          });\n          promise.status = STATUS_REJECTED;\n        });\n      }\n\n      return promise;\n    };\n\n    var InnerLoadable =\n    /*#__PURE__*/\n    function (_React$Component) {\n      _inheritsLoose(InnerLoadable, _React$Component);\n\n      InnerLoadable.getDerivedStateFromProps = function getDerivedStateFromProps(props, state) {\n        var cacheKey = _getCacheKey(props);\n\n        return _extends({}, state, {\n          cacheKey: cacheKey,\n          // change of a key triggers loading state automatically\n          loading: state.loading || state.cacheKey !== cacheKey\n        });\n      };\n\n      function InnerLoadable(props) {\n        var _this;\n\n        _this = _React$Component.call(this, props) || this;\n        _this.state = {\n          result: null,\n          error: null,\n          loading: true,\n          cacheKey: _getCacheKey(props)\n        };\n        invariant(!props.__chunkExtractor || ctor.requireSync, 'SSR requires `@loadable/babel-plugin`, please install it'); // Server-side\n\n        if (props.__chunkExtractor) {\n          // This module has been marked with no SSR\n          if (options.ssr === false) {\n            return _assertThisInitialized(_this);\n          } // We run load function, we assume that it won't fail and that it\n          // triggers a synchronous loading of the module\n\n\n          ctor.requireAsync(props)[\"catch\"](function () {\n            return null;\n          }); // So we can require now the module synchronously\n\n          _this.loadSync();\n\n          props.__chunkExtractor.addChunk(ctor.chunkName(props));\n\n          return _assertThisInitialized(_this);\n        } // Client-side with `isReady` method present (SSR probably)\n        // If module is already loaded, we use a synchronous loading\n        // Only perform this synchronous loading if the component has not\n        // been marked with no SSR, else we risk hydration mismatches\n\n\n        if (options.ssr !== false && ( // is ready - was loaded in this session\n        ctor.isReady && ctor.isReady(props) || // is ready - was loaded during SSR process\n        ctor.chunkName && LOADABLE_SHARED.initialChunks[ctor.chunkName(props)])) {\n          _this.loadSync();\n        }\n\n        return _this;\n      }\n\n      var _proto = InnerLoadable.prototype;\n\n      _proto.componentDidMount = function componentDidMount() {\n        this.mounted = true; // retrieve loading promise from a global cache\n\n        var cachedPromise = this.getCache(); // if promise exists, but rejected - clear cache\n\n        if (cachedPromise && cachedPromise.status === STATUS_REJECTED) {\n          this.setCache();\n        } // component might be resolved synchronously in the constructor\n\n\n        if (this.state.loading) {\n          this.loadAsync();\n        }\n      };\n\n      _proto.componentDidUpdate = function componentDidUpdate(prevProps, prevState) {\n        // Component has to be reloaded on cacheKey change\n        if (prevState.cacheKey !== this.state.cacheKey) {\n          this.loadAsync();\n        }\n      };\n\n      _proto.componentWillUnmount = function componentWillUnmount() {\n        this.mounted = false;\n      };\n\n      _proto.safeSetState = function safeSetState(nextState, callback) {\n        if (this.mounted) {\n          this.setState(nextState, callback);\n        }\n      }\n      /**\n       * returns a cache key for the current props\n       * @returns {Component|string}\n       */\n      ;\n\n      _proto.getCacheKey = function getCacheKey() {\n        return _getCacheKey(this.props);\n      }\n      /**\n       * access the persistent cache\n       */\n      ;\n\n      _proto.getCache = function getCache() {\n        return cache[this.getCacheKey()];\n      }\n      /**\n       * sets the cache value. If called without value sets it as undefined\n       */\n      ;\n\n      _proto.setCache = function setCache(value) {\n        if (value === void 0) {\n          value = undefined;\n        }\n\n        cache[this.getCacheKey()] = value;\n      };\n\n      _proto.triggerOnLoad = function triggerOnLoad() {\n        var _this2 = this;\n\n        if (onLoad) {\n          setTimeout(function () {\n            onLoad(_this2.state.result, _this2.props);\n          });\n        }\n      }\n      /**\n       * Synchronously loads component\n       * target module is expected to already exists in the module cache\n       * or be capable to resolve synchronously (webpack target=node)\n       */\n      ;\n\n      _proto.loadSync = function loadSync() {\n        // load sync is expecting component to be in the \"loading\" state already\n        // sounds weird, but loading=true is the initial state of InnerLoadable\n        if (!this.state.loading) return;\n\n        try {\n          var loadedModule = ctor.requireSync(this.props);\n          var result = resolve(loadedModule, this.props, Loadable);\n          this.state.result = result;\n          this.state.loading = false;\n        } catch (error) {\n          console.error('loadable-components: failed to synchronously load component, which expected to be available', {\n            fileName: ctor.resolve(this.props),\n            chunkName: ctor.chunkName(this.props),\n            error: error ? error.message : error\n          });\n          this.state.error = error;\n        }\n      }\n      /**\n       * Asynchronously loads a component.\n       */\n      ;\n\n      _proto.loadAsync = function loadAsync() {\n        var _this3 = this;\n\n        var promise = this.resolveAsync();\n        promise.then(function (loadedModule) {\n          var result = resolve(loadedModule, _this3.props, Loadable);\n\n          _this3.safeSetState({\n            result: result,\n            loading: false\n          }, function () {\n            return _this3.triggerOnLoad();\n          });\n        })[\"catch\"](function (error) {\n          return _this3.safeSetState({\n            error: error,\n            loading: false\n          });\n        });\n        return promise;\n      }\n      /**\n       * Asynchronously resolves(not loads) a component.\n       * Note - this function does not change the state\n       */\n      ;\n\n      _proto.resolveAsync = function resolveAsync() {\n        var _this$props = this.props,\n            __chunkExtractor = _this$props.__chunkExtractor,\n            forwardedRef = _this$props.forwardedRef,\n            props = _objectWithoutPropertiesLoose(_this$props, [\"__chunkExtractor\", \"forwardedRef\"]);\n\n        return cachedLoad(props);\n      };\n\n      _proto.render = function render() {\n        var _this$props2 = this.props,\n            forwardedRef = _this$props2.forwardedRef,\n            propFallback = _this$props2.fallback,\n            __chunkExtractor = _this$props2.__chunkExtractor,\n            props = _objectWithoutPropertiesLoose(_this$props2, [\"forwardedRef\", \"fallback\", \"__chunkExtractor\"]);\n\n        var _this$state = this.state,\n            error = _this$state.error,\n            loading = _this$state.loading,\n            result = _this$state.result;\n\n        if (options.suspense) {\n          var cachedPromise = this.getCache() || this.loadAsync();\n\n          if (cachedPromise.status === STATUS_PENDING) {\n            throw this.loadAsync();\n          }\n        }\n\n        if (error) {\n          throw error;\n        }\n\n        var fallback = propFallback || options.fallback || null;\n\n        if (loading) {\n          return fallback;\n        }\n\n        return _render({\n          fallback: fallback,\n          result: result,\n          options: options,\n          props: _extends({}, props, {\n            ref: forwardedRef\n          })\n        });\n      };\n\n      return InnerLoadable;\n    }(React.Component);\n\n    var EnhancedInnerLoadable = withChunkExtractor(InnerLoadable);\n    var Loadable = React.forwardRef(function (props, ref) {\n      return React.createElement(EnhancedInnerLoadable, Object.assign({\n        forwardedRef: ref\n      }, props));\n    });\n    Loadable.displayName = 'Loadable'; // In future, preload could use `<link rel=\"preload\">`\n\n    Loadable.preload = function (props) {\n      Loadable.load(props);\n    };\n\n    Loadable.load = function (props) {\n      return cachedLoad(props);\n    };\n\n    return Loadable;\n  }\n\n  function lazy(ctor, options) {\n    return loadable(ctor, _extends({}, options, {\n      suspense: true\n    }));\n  }\n\n  return {\n    loadable: loadable,\n    lazy: lazy\n  };\n}\n\nfunction defaultResolveComponent(loadedModule) {\n  // eslint-disable-next-line no-underscore-dangle\n  return loadedModule.__esModule ? loadedModule[\"default\"] : loadedModule[\"default\"] || loadedModule;\n}\n\n/* eslint-disable no-use-before-define, react/no-multi-comp */\n\nvar _createLoadable =\n/*#__PURE__*/\ncreateLoadable({\n  defaultResolveComponent: defaultResolveComponent,\n  render: function render(_ref) {\n    var Component = _ref.result,\n        props = _ref.props;\n    return React.createElement(Component, props);\n  }\n}),\n    loadable = _createLoadable.loadable,\n    lazy = _createLoadable.lazy;\n\n/* eslint-disable no-use-before-define, react/no-multi-comp */\n\nvar _createLoadable$1 =\n/*#__PURE__*/\ncreateLoadable({\n  onLoad: function onLoad(result, props) {\n    if (result && props.forwardedRef) {\n      if (typeof props.forwardedRef === 'function') {\n        props.forwardedRef(result);\n      } else {\n        props.forwardedRef.current = result;\n      }\n    }\n  },\n  render: function render(_ref) {\n    var result = _ref.result,\n        props = _ref.props;\n\n    if (props.children) {\n      return props.children(result);\n    }\n\n    return null;\n  }\n}),\n    loadable$1 = _createLoadable$1.loadable,\n    lazy$1 = _createLoadable$1.lazy;\n\n/* eslint-disable no-underscore-dangle, camelcase */\nvar BROWSER = typeof window !== 'undefined';\nfunction loadableReady(done, _temp) {\n  if (done === void 0) {\n    done = function done() {};\n  }\n\n  var _ref = _temp === void 0 ? {} : _temp,\n      _ref$namespace = _ref.namespace,\n      namespace = _ref$namespace === void 0 ? '' : _ref$namespace,\n      _ref$chunkLoadingGlob = _ref.chunkLoadingGlobal,\n      chunkLoadingGlobal = _ref$chunkLoadingGlob === void 0 ? '__LOADABLE_LOADED_CHUNKS__' : _ref$chunkLoadingGlob;\n\n  if (!BROWSER) {\n    warn('`loadableReady()` must be called in browser only');\n    done();\n    return Promise.resolve();\n  }\n\n  var requiredChunks = null;\n\n  if (BROWSER) {\n    var id = getRequiredChunkKey(namespace);\n    var dataElement = document.getElementById(id);\n\n    if (dataElement) {\n      requiredChunks = JSON.parse(dataElement.textContent);\n      var extElement = document.getElementById(id + \"_ext\");\n\n      if (extElement) {\n        var _JSON$parse = JSON.parse(extElement.textContent),\n            namedChunks = _JSON$parse.namedChunks;\n\n        namedChunks.forEach(function (chunkName) {\n          LOADABLE_SHARED.initialChunks[chunkName] = true;\n        });\n      } else {\n        // version mismatch\n        throw new Error('loadable-component: @loadable/server does not match @loadable/component');\n      }\n    }\n  }\n\n  if (!requiredChunks) {\n    warn('`loadableReady()` requires state, please use `getScriptTags` or `getScriptElements` server-side');\n    done();\n    return Promise.resolve();\n  }\n\n  var resolved = false;\n  return new Promise(function (resolve) {\n    window[chunkLoadingGlobal] = window[chunkLoadingGlobal] || [];\n    var loadedChunks = window[chunkLoadingGlobal];\n    var originalPush = loadedChunks.push.bind(loadedChunks);\n\n    function checkReadyState() {\n      if (requiredChunks.every(function (chunk) {\n        return loadedChunks.some(function (_ref2) {\n          var chunks = _ref2[0];\n          return chunks.indexOf(chunk) > -1;\n        });\n      })) {\n        if (!resolved) {\n          resolved = true;\n          resolve();\n        }\n      }\n    }\n\n    loadedChunks.push = function () {\n      originalPush.apply(void 0, arguments);\n      checkReadyState();\n    };\n\n    checkReadyState();\n  }).then(done);\n}\n\n/* eslint-disable no-underscore-dangle */\nvar loadable$2 = loadable;\nloadable$2.lib = loadable$1;\nvar lazy$2 = lazy;\nlazy$2.lib = lazy$1;\nvar __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = sharedInternals;\n\nexport default loadable$2;\nexport { __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED, lazy$2 as lazy, loadableReady };\n"],"names":["baseIsEqual","module","exports","value","other","DataRouterContext","React","DataRouterStateContext","NavigationContext","LocationContext","RouteContext","outlet","matches","isDataRoute","RouteErrorContext","useInRouterContext","useLocation","invariant","location","useIsomorphicLayoutEffect","cb","static","useNavigate","router","ctx","useDataRouterContext","DataRouterHook","UseNavigateStable","id","useCurrentRouteId","DataRouterStateHook","activeRef","current","to","options","navigate","_extends","fromRouteId","useNavigateStable","dataRouterContext","basename","future","navigator","pathname","locationPathname","routePathnamesJson","JSON","stringify","getResolveToMatches","v7_relativeSplatPath","go","path","resolveTo","parse","relative","joinPaths","replace","push","state","useNavigateUnstable","useParams","routeMatch","length","params","useRoutesImpl","routes","locationArg","dataRouterState","parentMatches","parentParams","parentPathnameBase","pathnameBase","route","locationFromContext","_parsedLocationArg$pa","parsedLocationArg","parsePath","startsWith","remainingPathname","parentSegments","split","slice","join","matchRoutes","renderedMatches","_dataRouterState","_future","errors","v7_partialHydration","initialized","errorIndex","findIndex","m","undefined","Math","min","renderFallback","fallbackIndex","i","match","HydrateFallback","hydrateFallbackElement","loaderData","needsToRunLoader","loader","lazy","reduceRight","index","error","shouldRenderHydrateFallback","errorElement","key","defaultErrorElement","alreadyWarned","concat","getChildren","children","Component","element","RenderedRoute","routeContext","ErrorBoundary","RenderErrorBoundary","revalidation","component","_renderMatches","map","Object","assign","encodeLocation","Provider","search","hash","navigationType","NavigationType","Pop","DefaultErrorComponent","_state$errors","useDataRouterState","UseRouteError","routeId","useRouteError","message","isRouteErrorResponse","status","statusText","Error","stack","preStyles","padding","backgroundColor","style","fontStyle","constructor","props","super","this","getDerivedStateFromError","getDerivedStateFromProps","componentDidCatch","errorInfo","console","render","_ref","staticContext","_deepestRenderedBoundaryId","hookName","useRouteContext","thisRoute","logDeprecation","flag","msg","link","warn","logV6DeprecationWarnings","renderFuture","routerFuture","v7_startTransition","v7_fetcherPersist","v7_normalizeFormMethod","v7_skipActionErrorRevalidation","Route","_props","Router","_ref5","basenameProp","locationProp","staticProp","navigationContext","locationContext","trailingPathname","stripBasename","Routes","_ref6","createRoutesFromChildren","parentPath","forEach","treePath","type","apply","caseSensitive","action","hasErrorBoundary","shouldRevalidate","handle","Promise","Context","LOADABLE_SHARED","STATUS_PENDING","STATUS_REJECTED","identity","v","createLoadable","_ref$defaultResolveCo","defaultResolveComponent","_render","onLoad","loadable","loadableConstructor","ctor","requireAsync","resolve","chunkName","resolveConstructor","cache","_getCacheKey","cacheKey","Loadable","resolveComponent","preload","LoadableWithChunkExtractor","cachedLoad","promise","then","fileName","InnerLoadable","_React$Component","_this","call","result","loading","condition","framesToPop","name","__chunkExtractor","requireSync","ssr","loadSync","addChunk","isReady","_proto","prototype","componentDidMount","mounted","cachedPromise","getCache","setCache","loadAsync","componentDidUpdate","prevProps","prevState","componentWillUnmount","safeSetState","nextState","callback","setState","getCacheKey","triggerOnLoad","_this2","setTimeout","_this3","resolveAsync","loadedModule","_this$props","forwardedRef","_this$props2","propFallback","fallback","_this$state","suspense","ref","EnhancedInnerLoadable","Consumer","extractor","displayName","load","_createLoadable","__esModule","_createLoadable$1","loadable$1","lazy$1","loadable$2","lib"],"sourceRoot":""}