{"version":3,"file":"index-BRm2Fm2P.js","sources":["../../Client/node_modules/react-router-dom-v5-compat/node_modules/react-router/dist/index.js","../../Client/node_modules/react-router-dom-v5-compat/dist/index.js"],"sourcesContent":["/**\n * React Router v6.20.1\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_getPathContributingMatches, 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 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_getPathContributingMatches(matches).map(match => match.pathnameBase));\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 matches\n } = React.useContext(RouteContext);\n let {\n pathname: locationPathname\n } = useLocation();\n let routePathnamesJson = JSON.stringify(UNSAFE_getPathContributingMatches(matches).map(match => match.pathnameBase));\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) {\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, \"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);\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 || 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 ? /*#__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) {\n var _dataRouterState2;\n if (parentMatches === void 0) {\n parentMatches = [];\n }\n if (dataRouterState === void 0) {\n dataRouterState = 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 return renderedMatches.reduceRight((outlet, match, index) => {\n let error = match.route.id ? errors == null ? void 0 : errors[match.route.id] : null;\n // Only data routers handle errors\n let errorElement = null;\n if (dataRouterState) {\n errorElement = match.route.errorElement || defaultErrorElement;\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 (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) {\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 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 }, state.initialized ? /*#__PURE__*/React.createElement(DataRoutes, {\n routes: router.routes,\n state: state\n }) : fallbackElement))), null);\n}\nfunction DataRoutes(_ref2) {\n let {\n routes,\n state\n } = _ref2;\n return useRoutesImpl(routes, undefined, state);\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 });\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 process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(!React.useContext(NavigationContext).static, \"<Navigate> must not be used on the initial render in a <StaticRouter>. \" + \"This is a no-op, but you should modify your code so the <Navigate> is \" + \"only ever rendered in response to some user interaction or state change.\") : 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_getPathContributingMatches(matches).map(match => match.pathnameBase), 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 } = _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 }), [basename, 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.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","/**\n * React Router DOM v5 Compat v6.20.1\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 * as ReactDOM from 'react-dom';\nimport { UNSAFE_mapRouteProperties, UNSAFE_DataRouterContext, UNSAFE_DataRouterStateContext, Router, UNSAFE_useRoutesImpl, UNSAFE_NavigationContext, useHref, useResolvedPath, useLocation, useNavigate, createPath, UNSAFE_useRouteId, UNSAFE_RouteContext, useMatches, useNavigation, useBlocker, Routes, Route } from 'react-router';\nexport { AbortedDeferredError, Await, MemoryRouter, Navigate, NavigationType, Outlet, Route, Router, Routes, UNSAFE_DataRouterContext, UNSAFE_DataRouterStateContext, UNSAFE_LocationContext, UNSAFE_NavigationContext, UNSAFE_RouteContext, UNSAFE_useRouteId, createMemoryRouter, createPath, createRoutesFromChildren, createRoutesFromElements, defer, generatePath, isRouteErrorResponse, json, matchPath, matchRoutes, parsePath, redirect, redirectDocument, renderMatches, resolvePath, useActionData, useAsyncError, useAsyncValue, useBlocker, useHref, useInRouterContext, useLoaderData, useLocation, useMatch, useMatches, useNavigate, useNavigation, useNavigationType, useOutlet, useOutletContext, useParams, useResolvedPath, useRevalidator, useRouteError, useRouteLoaderData, useRoutes } from 'react-router';\nimport { stripBasename, UNSAFE_warning, createRouter, createBrowserHistory, createHashHistory, UNSAFE_ErrorResponseImpl, UNSAFE_invariant, joinPaths, IDLE_FETCHER, matchPath } from '@remix-run/router';\nimport { parsePath, Action, createPath as createPath$1 } from 'history';\nimport { Route as Route$1, useHistory } from 'react-router-dom';\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}\nfunction _objectWithoutPropertiesLoose(source, excluded) {\n if (source == null) return {};\n var target = {};\n var sourceKeys = Object.keys(source);\n var key, i;\n for (i = 0; i < sourceKeys.length; i++) {\n key = sourceKeys[i];\n if (excluded.indexOf(key) >= 0) continue;\n target[key] = source[key];\n }\n return target;\n}\n\nconst defaultMethod = \"get\";\nconst defaultEncType = \"application/x-www-form-urlencoded\";\nfunction isHtmlElement(object) {\n return object != null && typeof object.tagName === \"string\";\n}\nfunction isButtonElement(object) {\n return isHtmlElement(object) && object.tagName.toLowerCase() === \"button\";\n}\nfunction isFormElement(object) {\n return isHtmlElement(object) && object.tagName.toLowerCase() === \"form\";\n}\nfunction isInputElement(object) {\n return isHtmlElement(object) && object.tagName.toLowerCase() === \"input\";\n}\nfunction isModifiedEvent(event) {\n return !!(event.metaKey || event.altKey || event.ctrlKey || event.shiftKey);\n}\nfunction shouldProcessLinkClick(event, target) {\n return event.button === 0 && (\n // Ignore everything but left clicks\n !target || target === \"_self\") &&\n // Let browser handle \"target=_blank\" etc.\n !isModifiedEvent(event) // Ignore clicks with modifier keys\n ;\n}\n/**\n * Creates a URLSearchParams object using the given initializer.\n *\n * This is identical to `new URLSearchParams(init)` except it also\n * supports arrays as values in the object form of the initializer\n * instead of just strings. This is convenient when you need multiple\n * values for a given key, but don't want to use an array initializer.\n *\n * For example, instead of:\n *\n * let searchParams = new URLSearchParams([\n * ['sort', 'name'],\n * ['sort', 'price']\n * ]);\n *\n * you can do:\n *\n * let searchParams = createSearchParams({\n * sort: ['name', 'price']\n * });\n */\nfunction createSearchParams(init) {\n if (init === void 0) {\n init = \"\";\n }\n return new URLSearchParams(typeof init === \"string\" || Array.isArray(init) || init instanceof URLSearchParams ? init : Object.keys(init).reduce((memo, key) => {\n let value = init[key];\n return memo.concat(Array.isArray(value) ? value.map(v => [key, v]) : [[key, value]]);\n }, []));\n}\nfunction getSearchParamsForLocation(locationSearch, defaultSearchParams) {\n let searchParams = createSearchParams(locationSearch);\n if (defaultSearchParams) {\n // Use `defaultSearchParams.forEach(...)` here instead of iterating of\n // `defaultSearchParams.keys()` to work-around a bug in Firefox related to\n // web extensions. Relevant Bugzilla tickets:\n // https://bugzilla.mozilla.org/show_bug.cgi?id=1414602\n // https://bugzilla.mozilla.org/show_bug.cgi?id=1023984\n defaultSearchParams.forEach((_, key) => {\n if (!searchParams.has(key)) {\n defaultSearchParams.getAll(key).forEach(value => {\n searchParams.append(key, value);\n });\n }\n });\n }\n return searchParams;\n}\n// One-time check for submitter support\nlet _formDataSupportsSubmitter = null;\nfunction isFormDataSubmitterSupported() {\n if (_formDataSupportsSubmitter === null) {\n try {\n new FormData(document.createElement(\"form\"),\n // @ts-expect-error if FormData supports the submitter parameter, this will throw\n 0);\n _formDataSupportsSubmitter = false;\n } catch (e) {\n _formDataSupportsSubmitter = true;\n }\n }\n return _formDataSupportsSubmitter;\n}\nconst supportedFormEncTypes = new Set([\"application/x-www-form-urlencoded\", \"multipart/form-data\", \"text/plain\"]);\nfunction getFormEncType(encType) {\n if (encType != null && !supportedFormEncTypes.has(encType)) {\n process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(false, \"\\\"\" + encType + \"\\\" is not a valid `encType` for `<Form>`/`<fetcher.Form>` \" + (\"and will default to \\\"\" + defaultEncType + \"\\\"\")) : void 0;\n return null;\n }\n return encType;\n}\nfunction getFormSubmissionInfo(target, basename) {\n let method;\n let action;\n let encType;\n let formData;\n let body;\n if (isFormElement(target)) {\n // When grabbing the action from the element, it will have had the basename\n // prefixed to ensure non-JS scenarios work, so strip it since we'll\n // re-prefix in the router\n let attr = target.getAttribute(\"action\");\n action = attr ? stripBasename(attr, basename) : null;\n method = target.getAttribute(\"method\") || defaultMethod;\n encType = getFormEncType(target.getAttribute(\"enctype\")) || defaultEncType;\n formData = new FormData(target);\n } else if (isButtonElement(target) || isInputElement(target) && (target.type === \"submit\" || target.type === \"image\")) {\n let form = target.form;\n if (form == null) {\n throw new Error(\"Cannot submit a <button> or <input type=\\\"submit\\\"> without a <form>\");\n }\n // <button>/<input type=\"submit\"> may override attributes of <form>\n // When grabbing the action from the element, it will have had the basename\n // prefixed to ensure non-JS scenarios work, so strip it since we'll\n // re-prefix in the router\n let attr = target.getAttribute(\"formaction\") || form.getAttribute(\"action\");\n action = attr ? stripBasename(attr, basename) : null;\n method = target.getAttribute(\"formmethod\") || form.getAttribute(\"method\") || defaultMethod;\n encType = getFormEncType(target.getAttribute(\"formenctype\")) || getFormEncType(form.getAttribute(\"enctype\")) || defaultEncType;\n // Build a FormData object populated from a form and submitter\n formData = new FormData(form, target);\n // If this browser doesn't support the `FormData(el, submitter)` format,\n // then tack on the submitter value at the end. This is a lightweight\n // solution that is not 100% spec compliant. For complete support in older\n // browsers, consider using the `formdata-submitter-polyfill` package\n if (!isFormDataSubmitterSupported()) {\n let {\n name,\n type,\n value\n } = target;\n if (type === \"image\") {\n let prefix = name ? name + \".\" : \"\";\n formData.append(prefix + \"x\", \"0\");\n formData.append(prefix + \"y\", \"0\");\n } else if (name) {\n formData.append(name, value);\n }\n }\n } else if (isHtmlElement(target)) {\n throw new Error(\"Cannot submit element that is not <form>, <button>, or \" + \"<input type=\\\"submit|image\\\">\");\n } else {\n method = defaultMethod;\n action = null;\n encType = defaultEncType;\n body = target;\n }\n // Send body for <Form encType=\"text/plain\" so we encode it into text\n if (formData && encType === \"text/plain\") {\n body = formData;\n formData = undefined;\n }\n return {\n action,\n method: method.toLowerCase(),\n encType,\n formData,\n body\n };\n}\n\nconst _excluded = [\"onClick\", \"relative\", \"reloadDocument\", \"replace\", \"state\", \"target\", \"to\", \"preventScrollReset\", \"unstable_viewTransition\"],\n _excluded2 = [\"aria-current\", \"caseSensitive\", \"className\", \"end\", \"style\", \"to\", \"unstable_viewTransition\", \"children\"],\n _excluded3 = [\"fetcherKey\", \"navigate\", \"reloadDocument\", \"replace\", \"state\", \"method\", \"action\", \"onSubmit\", \"relative\", \"preventScrollReset\", \"unstable_viewTransition\"];\nfunction createBrowserRouter(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: createBrowserHistory({\n window: opts == null ? void 0 : opts.window\n }),\n hydrationData: (opts == null ? void 0 : opts.hydrationData) || parseHydrationData(),\n routes,\n mapRouteProperties: UNSAFE_mapRouteProperties,\n window: opts == null ? void 0 : opts.window\n }).initialize();\n}\nfunction createHashRouter(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: createHashHistory({\n window: opts == null ? void 0 : opts.window\n }),\n hydrationData: (opts == null ? void 0 : opts.hydrationData) || parseHydrationData(),\n routes,\n mapRouteProperties: UNSAFE_mapRouteProperties,\n window: opts == null ? void 0 : opts.window\n }).initialize();\n}\nfunction parseHydrationData() {\n var _window;\n let state = (_window = window) == null ? void 0 : _window.__staticRouterHydrationData;\n if (state && state.errors) {\n state = _extends({}, state, {\n errors: deserializeErrors(state.errors)\n });\n }\n return state;\n}\nfunction deserializeErrors(errors) {\n if (!errors) return null;\n let entries = Object.entries(errors);\n let serialized = {};\n for (let [key, val] of entries) {\n // Hey you! If you change this, please change the corresponding logic in\n // serializeErrors in react-router-dom/server.tsx :)\n if (val && val.__type === \"RouteErrorResponse\") {\n serialized[key] = new UNSAFE_ErrorResponseImpl(val.status, val.statusText, val.data, val.internal === true);\n } else if (val && val.__type === \"Error\") {\n // Attempt to reconstruct the right type of Error (i.e., ReferenceError)\n if (val.__subType) {\n let ErrorConstructor = window[val.__subType];\n if (typeof ErrorConstructor === \"function\") {\n try {\n // @ts-expect-error\n let error = new ErrorConstructor(val.message);\n // Wipe away the client-side stack trace. Nothing to fill it in with\n // because we don't serialize SSR stack traces for security reasons\n error.stack = \"\";\n serialized[key] = error;\n } catch (e) {\n // no-op - fall through and create a normal Error\n }\n }\n }\n if (serialized[key] == null) {\n let error = new Error(val.message);\n // Wipe away the client-side stack trace. Nothing to fill it in with\n // because we don't serialize SSR stack traces for security reasons\n error.stack = \"\";\n serialized[key] = error;\n }\n } else {\n serialized[key] = val;\n }\n }\n return serialized;\n}\nconst ViewTransitionContext = /*#__PURE__*/React.createContext({\n isTransitioning: false\n});\nif (process.env.NODE_ENV !== \"production\") {\n ViewTransitionContext.displayName = \"ViewTransition\";\n}\nconst FetchersContext = /*#__PURE__*/React.createContext(new Map());\nif (process.env.NODE_ENV !== \"production\") {\n FetchersContext.displayName = \"Fetchers\";\n}\n//#endregion\n////////////////////////////////////////////////////////////////////////////////\n//#region Components\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];\nconst FLUSH_SYNC = \"flushSync\";\nconst flushSyncImpl = ReactDOM[FLUSH_SYNC];\nfunction startTransitionSafe(cb) {\n if (startTransitionImpl) {\n startTransitionImpl(cb);\n } else {\n cb();\n }\n}\nfunction flushSyncSafe(cb) {\n if (flushSyncImpl) {\n flushSyncImpl(cb);\n } else {\n cb();\n }\n}\nclass Deferred {\n constructor() {\n this.status = \"pending\";\n this.promise = new Promise((resolve, reject) => {\n this.resolve = value => {\n if (this.status === \"pending\") {\n this.status = \"resolved\";\n resolve(value);\n }\n };\n this.reject = reason => {\n if (this.status === \"pending\") {\n this.status = \"rejected\";\n reject(reason);\n }\n };\n });\n }\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 [pendingState, setPendingState] = React.useState();\n let [vtContext, setVtContext] = React.useState({\n isTransitioning: false\n });\n let [renderDfd, setRenderDfd] = React.useState();\n let [transition, setTransition] = React.useState();\n let [interruption, setInterruption] = React.useState();\n let fetcherData = React.useRef(new Map());\n let {\n v7_startTransition\n } = future || {};\n let optInStartTransition = React.useCallback(cb => {\n if (v7_startTransition) {\n startTransitionSafe(cb);\n } else {\n cb();\n }\n }, [v7_startTransition]);\n let setState = React.useCallback((newState, _ref2) => {\n let {\n deletedFetchers,\n unstable_flushSync: flushSync,\n unstable_viewTransitionOpts: viewTransitionOpts\n } = _ref2;\n deletedFetchers.forEach(key => fetcherData.current.delete(key));\n newState.fetchers.forEach((fetcher, key) => {\n if (fetcher.data !== undefined) {\n fetcherData.current.set(key, fetcher.data);\n }\n });\n let isViewTransitionUnavailable = router.window == null || typeof router.window.document.startViewTransition !== \"function\";\n // If this isn't a view transition or it's not available in this browser,\n // just update and be done with it\n if (!viewTransitionOpts || isViewTransitionUnavailable) {\n if (flushSync) {\n flushSyncSafe(() => setStateImpl(newState));\n } else {\n optInStartTransition(() => setStateImpl(newState));\n }\n return;\n }\n // flushSync + startViewTransition\n if (flushSync) {\n // Flush through the context to mark DOM elements as transition=ing\n flushSyncSafe(() => {\n // Cancel any pending transitions\n if (transition) {\n renderDfd && renderDfd.resolve();\n transition.skipTransition();\n }\n setVtContext({\n isTransitioning: true,\n flushSync: true,\n currentLocation: viewTransitionOpts.currentLocation,\n nextLocation: viewTransitionOpts.nextLocation\n });\n });\n // Update the DOM\n let t = router.window.document.startViewTransition(() => {\n flushSyncSafe(() => setStateImpl(newState));\n });\n // Clean up after the animation completes\n t.finished.finally(() => {\n flushSyncSafe(() => {\n setRenderDfd(undefined);\n setTransition(undefined);\n setPendingState(undefined);\n setVtContext({\n isTransitioning: false\n });\n });\n });\n flushSyncSafe(() => setTransition(t));\n return;\n }\n // startTransition + startViewTransition\n if (transition) {\n // Interrupting an in-progress transition, cancel and let everything flush\n // out, and then kick off a new transition from the interruption state\n renderDfd && renderDfd.resolve();\n transition.skipTransition();\n setInterruption({\n state: newState,\n currentLocation: viewTransitionOpts.currentLocation,\n nextLocation: viewTransitionOpts.nextLocation\n });\n } else {\n // Completed navigation update with opted-in view transitions, let 'er rip\n setPendingState(newState);\n setVtContext({\n isTransitioning: true,\n flushSync: false,\n currentLocation: viewTransitionOpts.currentLocation,\n nextLocation: viewTransitionOpts.nextLocation\n });\n }\n }, [router.window, transition, renderDfd, fetcherData, optInStartTransition]);\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 // When we start a view transition, create a Deferred we can use for the\n // eventual \"completed\" render\n React.useEffect(() => {\n if (vtContext.isTransitioning && !vtContext.flushSync) {\n setRenderDfd(new Deferred());\n }\n }, [vtContext]);\n // Once the deferred is created, kick off startViewTransition() to update the\n // DOM and then wait on the Deferred to resolve (indicating the DOM update has\n // happened)\n React.useEffect(() => {\n if (renderDfd && pendingState && router.window) {\n let newState = pendingState;\n let renderPromise = renderDfd.promise;\n let transition = router.window.document.startViewTransition(async () => {\n optInStartTransition(() => setStateImpl(newState));\n await renderPromise;\n });\n transition.finished.finally(() => {\n setRenderDfd(undefined);\n setTransition(undefined);\n setPendingState(undefined);\n setVtContext({\n isTransitioning: false\n });\n });\n setTransition(transition);\n }\n }, [optInStartTransition, pendingState, renderDfd, router.window]);\n // When the new location finally renders and is committed to the DOM, this\n // effect will run to resolve the transition\n React.useEffect(() => {\n if (renderDfd && pendingState && state.location.key === pendingState.location.key) {\n renderDfd.resolve();\n }\n }, [renderDfd, transition, state.location, pendingState]);\n // If we get interrupted with a new navigation during a transition, we skip\n // the active transition, let it cleanup, then kick it off again here\n React.useEffect(() => {\n if (!vtContext.isTransitioning && interruption) {\n setPendingState(interruption.state);\n setVtContext({\n isTransitioning: true,\n flushSync: false,\n currentLocation: interruption.currentLocation,\n nextLocation: interruption.nextLocation\n });\n setInterruption(undefined);\n }\n }, [vtContext.isTransitioning, interruption]);\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 // 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(UNSAFE_DataRouterContext.Provider, {\n value: dataRouterContext\n }, /*#__PURE__*/React.createElement(UNSAFE_DataRouterStateContext.Provider, {\n value: state\n }, /*#__PURE__*/React.createElement(FetchersContext.Provider, {\n value: fetcherData.current\n }, /*#__PURE__*/React.createElement(ViewTransitionContext.Provider, {\n value: vtContext\n }, /*#__PURE__*/React.createElement(Router, {\n basename: basename,\n location: state.location,\n navigationType: state.historyAction,\n navigator: navigator\n }, state.initialized ? /*#__PURE__*/React.createElement(DataRoutes, {\n routes: router.routes,\n state: state\n }) : fallbackElement))))), null);\n}\nfunction DataRoutes(_ref3) {\n let {\n routes,\n state\n } = _ref3;\n return UNSAFE_useRoutesImpl(routes, undefined, state);\n}\n/**\n * A `<Router>` for use in web browsers. Provides the cleanest URLs.\n */\nfunction BrowserRouter(_ref4) {\n let {\n basename,\n children,\n future,\n window\n } = _ref4;\n let historyRef = React.useRef();\n if (historyRef.current == null) {\n historyRef.current = createBrowserHistory({\n window,\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 });\n}\n/**\n * A `<Router>` for use in web browsers. Stores the location in the hash\n * portion of the URL so it is not sent to the server.\n */\nfunction HashRouter(_ref5) {\n let {\n basename,\n children,\n future,\n window\n } = _ref5;\n let historyRef = React.useRef();\n if (historyRef.current == null) {\n historyRef.current = createHashHistory({\n window,\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 });\n}\n/**\n * A `<Router>` that accepts a pre-instantiated history object. It's important\n * to note that using your own history object is highly discouraged and may add\n * two versions of the history library to your bundles unless you use the same\n * version of the history library that React Router uses internally.\n */\nfunction HistoryRouter(_ref6) {\n let {\n basename,\n children,\n future,\n history\n } = _ref6;\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 });\n}\nif (process.env.NODE_ENV !== \"production\") {\n HistoryRouter.displayName = \"unstable_HistoryRouter\";\n}\nconst isBrowser = typeof window !== \"undefined\" && typeof window.document !== \"undefined\" && typeof window.document.createElement !== \"undefined\";\nconst ABSOLUTE_URL_REGEX$1 = /^(?:[a-z][a-z0-9+.-]*:|\\/\\/)/i;\n/**\n * The public API for rendering a history-aware `<a>`.\n */\nconst Link = /*#__PURE__*/React.forwardRef(function LinkWithRef(_ref7, ref) {\n let {\n onClick,\n relative,\n reloadDocument,\n replace,\n state,\n target,\n to,\n preventScrollReset,\n unstable_viewTransition\n } = _ref7,\n rest = _objectWithoutPropertiesLoose(_ref7, _excluded);\n let {\n basename\n } = React.useContext(UNSAFE_NavigationContext);\n // Rendered into <a href> for absolute URLs\n let absoluteHref;\n let isExternal = false;\n if (typeof to === \"string\" && ABSOLUTE_URL_REGEX$1.test(to)) {\n // Render the absolute href server- and client-side\n absoluteHref = to;\n // Only check for external origins client-side\n if (isBrowser) {\n try {\n let currentUrl = new URL(window.location.href);\n let targetUrl = to.startsWith(\"//\") ? new URL(currentUrl.protocol + to) : new URL(to);\n let path = stripBasename(targetUrl.pathname, basename);\n if (targetUrl.origin === currentUrl.origin && path != null) {\n // Strip the protocol/origin/basename for same-origin absolute URLs\n to = path + targetUrl.search + targetUrl.hash;\n } else {\n isExternal = true;\n }\n } catch (e) {\n // We can't do external URL detection without a valid URL\n process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(false, \"<Link to=\\\"\" + to + \"\\\"> contains an invalid URL which will probably break \" + \"when clicked - please update to a valid URL path.\") : void 0;\n }\n }\n }\n // Rendered into <a href> for relative URLs\n let href = useHref(to, {\n relative\n });\n let internalOnClick = useLinkClickHandler(to, {\n replace,\n state,\n target,\n preventScrollReset,\n relative,\n unstable_viewTransition\n });\n function handleClick(event) {\n if (onClick) onClick(event);\n if (!event.defaultPrevented) {\n internalOnClick(event);\n }\n }\n return (\n /*#__PURE__*/\n // eslint-disable-next-line jsx-a11y/anchor-has-content\n React.createElement(\"a\", _extends({}, rest, {\n href: absoluteHref || href,\n onClick: isExternal || reloadDocument ? onClick : handleClick,\n ref: ref,\n target: target\n }))\n );\n});\nif (process.env.NODE_ENV !== \"production\") {\n Link.displayName = \"Link\";\n}\n/**\n * A `<Link>` wrapper that knows if it's \"active\" or not.\n */\nconst NavLink = /*#__PURE__*/React.forwardRef(function NavLinkWithRef(_ref8, ref) {\n let {\n \"aria-current\": ariaCurrentProp = \"page\",\n caseSensitive = false,\n className: classNameProp = \"\",\n end = false,\n style: styleProp,\n to,\n unstable_viewTransition,\n children\n } = _ref8,\n rest = _objectWithoutPropertiesLoose(_ref8, _excluded2);\n let path = useResolvedPath(to, {\n relative: rest.relative\n });\n let location = useLocation();\n let routerState = React.useContext(UNSAFE_DataRouterStateContext);\n let {\n navigator\n } = React.useContext(UNSAFE_NavigationContext);\n let isTransitioning = routerState != null &&\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 useViewTransitionState(path) && unstable_viewTransition === true;\n let toPathname = navigator.encodeLocation ? navigator.encodeLocation(path).pathname : path.pathname;\n let locationPathname = location.pathname;\n let nextLocationPathname = routerState && routerState.navigation && routerState.navigation.location ? routerState.navigation.location.pathname : null;\n if (!caseSensitive) {\n locationPathname = locationPathname.toLowerCase();\n nextLocationPathname = nextLocationPathname ? nextLocationPathname.toLowerCase() : null;\n toPathname = toPathname.toLowerCase();\n }\n // If the `to` has a trailing slash, look at that exact spot. Otherwise,\n // we're looking for a slash _after_ what's in `to`. For example:\n //\n // <NavLink to=\"/users\"> and <NavLink to=\"/users/\">\n // both want to look for a / at index 6 to match URL `/users/matt`\n const endSlashPosition = toPathname !== \"/\" && toPathname.endsWith(\"/\") ? toPathname.length - 1 : toPathname.length;\n let isActive = locationPathname === toPathname || !end && locationPathname.startsWith(toPathname) && locationPathname.charAt(endSlashPosition) === \"/\";\n let isPending = nextLocationPathname != null && (nextLocationPathname === toPathname || !end && nextLocationPathname.startsWith(toPathname) && nextLocationPathname.charAt(toPathname.length) === \"/\");\n let renderProps = {\n isActive,\n isPending,\n isTransitioning\n };\n let ariaCurrent = isActive ? ariaCurrentProp : undefined;\n let className;\n if (typeof classNameProp === \"function\") {\n className = classNameProp(renderProps);\n } else {\n // If the className prop is not a function, we use a default `active`\n // class for <NavLink />s that are active. In v5 `active` was the default\n // value for `activeClassName`, but we are removing that API and can still\n // use the old default behavior for a cleaner upgrade path and keep the\n // simple styling rules working as they currently do.\n className = [classNameProp, isActive ? \"active\" : null, isPending ? \"pending\" : null, isTransitioning ? \"transitioning\" : null].filter(Boolean).join(\" \");\n }\n let style = typeof styleProp === \"function\" ? styleProp(renderProps) : styleProp;\n return /*#__PURE__*/React.createElement(Link, _extends({}, rest, {\n \"aria-current\": ariaCurrent,\n className: className,\n ref: ref,\n style: style,\n to: to,\n unstable_viewTransition: unstable_viewTransition\n }), typeof children === \"function\" ? children(renderProps) : children);\n});\nif (process.env.NODE_ENV !== \"production\") {\n NavLink.displayName = \"NavLink\";\n}\n/**\n * A `@remix-run/router`-aware `<form>`. It behaves like a normal form except\n * that the interaction with the server is with `fetch` instead of new document\n * requests, allowing components to add nicer UX to the page as the form is\n * submitted and returns with data.\n */\nconst Form = /*#__PURE__*/React.forwardRef((_ref9, forwardedRef) => {\n let {\n fetcherKey,\n navigate,\n reloadDocument,\n replace,\n state,\n method = defaultMethod,\n action,\n onSubmit,\n relative,\n preventScrollReset,\n unstable_viewTransition\n } = _ref9,\n props = _objectWithoutPropertiesLoose(_ref9, _excluded3);\n let submit = useSubmit();\n let formAction = useFormAction(action, {\n relative\n });\n let formMethod = method.toLowerCase() === \"get\" ? \"get\" : \"post\";\n let submitHandler = event => {\n onSubmit && onSubmit(event);\n if (event.defaultPrevented) return;\n event.preventDefault();\n let submitter = event.nativeEvent.submitter;\n let submitMethod = (submitter == null ? void 0 : submitter.getAttribute(\"formmethod\")) || method;\n submit(submitter || event.currentTarget, {\n fetcherKey,\n method: submitMethod,\n navigate,\n replace,\n state,\n relative,\n preventScrollReset,\n unstable_viewTransition\n });\n };\n return /*#__PURE__*/React.createElement(\"form\", _extends({\n ref: forwardedRef,\n method: formMethod,\n action: formAction,\n onSubmit: reloadDocument ? onSubmit : submitHandler\n }, props));\n});\nif (process.env.NODE_ENV !== \"production\") {\n Form.displayName = \"Form\";\n}\n/**\n * This component will emulate the browser's scroll restoration on location\n * changes.\n */\nfunction ScrollRestoration(_ref10) {\n let {\n getKey,\n storageKey\n } = _ref10;\n useScrollRestoration({\n getKey,\n storageKey\n });\n return null;\n}\nif (process.env.NODE_ENV !== \"production\") {\n ScrollRestoration.displayName = \"ScrollRestoration\";\n}\n//#endregion\n////////////////////////////////////////////////////////////////////////////////\n//#region Hooks\n////////////////////////////////////////////////////////////////////////////////\nvar DataRouterHook;\n(function (DataRouterHook) {\n DataRouterHook[\"UseScrollRestoration\"] = \"useScrollRestoration\";\n DataRouterHook[\"UseSubmit\"] = \"useSubmit\";\n DataRouterHook[\"UseSubmitFetcher\"] = \"useSubmitFetcher\";\n DataRouterHook[\"UseFetcher\"] = \"useFetcher\";\n DataRouterHook[\"useViewTransitionState\"] = \"useViewTransitionState\";\n})(DataRouterHook || (DataRouterHook = {}));\nvar DataRouterStateHook;\n(function (DataRouterStateHook) {\n DataRouterStateHook[\"UseFetcher\"] = \"useFetcher\";\n DataRouterStateHook[\"UseFetchers\"] = \"useFetchers\";\n DataRouterStateHook[\"UseScrollRestoration\"] = \"useScrollRestoration\";\n})(DataRouterStateHook || (DataRouterStateHook = {}));\n// Internal hooks\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(UNSAFE_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(UNSAFE_DataRouterStateContext);\n !state ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, getDataRouterConsoleError(hookName)) : UNSAFE_invariant(false) : void 0;\n return state;\n}\n// External hooks\n/**\n * Handles the click behavior for router `<Link>` components. This is useful if\n * you need to create custom `<Link>` components with the same click behavior we\n * use in our exported `<Link>`.\n */\nfunction useLinkClickHandler(to, _temp) {\n let {\n target,\n replace: replaceProp,\n state,\n preventScrollReset,\n relative,\n unstable_viewTransition\n } = _temp === void 0 ? {} : _temp;\n let navigate = useNavigate();\n let location = useLocation();\n let path = useResolvedPath(to, {\n relative\n });\n return React.useCallback(event => {\n if (shouldProcessLinkClick(event, target)) {\n event.preventDefault();\n // If the URL hasn't changed, a regular <a> will do a replace instead of\n // a push, so do the same here unless the replace prop is explicitly set\n let replace = replaceProp !== undefined ? replaceProp : createPath(location) === createPath(path);\n navigate(to, {\n replace,\n state,\n preventScrollReset,\n relative,\n unstable_viewTransition\n });\n }\n }, [location, navigate, path, replaceProp, state, target, to, preventScrollReset, relative, unstable_viewTransition]);\n}\n/**\n * A convenient wrapper for reading and writing search parameters via the\n * URLSearchParams interface.\n */\nfunction useSearchParams(defaultInit) {\n process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(typeof URLSearchParams !== \"undefined\", \"You cannot use the `useSearchParams` hook in a browser that does not \" + \"support the URLSearchParams API. If you need to support Internet \" + \"Explorer 11, we recommend you load a polyfill such as \" + \"https://github.com/ungap/url-search-params\\n\\n\" + \"If you're unsure how to load polyfills, we recommend you check out \" + \"https://polyfill.io/v3/ which provides some recommendations about how \" + \"to load polyfills only for users that need them, instead of for every \" + \"user.\") : void 0;\n let defaultSearchParamsRef = React.useRef(createSearchParams(defaultInit));\n let hasSetSearchParamsRef = React.useRef(false);\n let location = useLocation();\n let searchParams = React.useMemo(() =>\n // Only merge in the defaults if we haven't yet called setSearchParams.\n // Once we call that we want those to take precedence, otherwise you can't\n // remove a param with setSearchParams({}) if it has an initial value\n getSearchParamsForLocation(location.search, hasSetSearchParamsRef.current ? null : defaultSearchParamsRef.current), [location.search]);\n let navigate = useNavigate();\n let setSearchParams = React.useCallback((nextInit, navigateOptions) => {\n const newSearchParams = createSearchParams(typeof nextInit === \"function\" ? nextInit(searchParams) : nextInit);\n hasSetSearchParamsRef.current = true;\n navigate(\"?\" + newSearchParams, navigateOptions);\n }, [navigate, searchParams]);\n return [searchParams, setSearchParams];\n}\nfunction validateClientSideSubmission() {\n if (typeof document === \"undefined\") {\n throw new Error(\"You are calling submit during the server render. \" + \"Try calling submit within a `useEffect` or callback instead.\");\n }\n}\nlet fetcherId = 0;\nlet getUniqueFetcherId = () => \"__\" + String(++fetcherId) + \"__\";\n/**\n * Returns a function that may be used to programmatically submit a form (or\n * some arbitrary data) to the server.\n */\nfunction useSubmit() {\n let {\n router\n } = useDataRouterContext(DataRouterHook.UseSubmit);\n let {\n basename\n } = React.useContext(UNSAFE_NavigationContext);\n let currentRouteId = UNSAFE_useRouteId();\n return React.useCallback(function (target, options) {\n if (options === void 0) {\n options = {};\n }\n validateClientSideSubmission();\n let {\n action,\n method,\n encType,\n formData,\n body\n } = getFormSubmissionInfo(target, basename);\n if (options.navigate === false) {\n let key = options.fetcherKey || getUniqueFetcherId();\n router.fetch(key, currentRouteId, options.action || action, {\n preventScrollReset: options.preventScrollReset,\n formData,\n body,\n formMethod: options.method || method,\n formEncType: options.encType || encType,\n unstable_flushSync: options.unstable_flushSync\n });\n } else {\n router.navigate(options.action || action, {\n preventScrollReset: options.preventScrollReset,\n formData,\n body,\n formMethod: options.method || method,\n formEncType: options.encType || encType,\n replace: options.replace,\n state: options.state,\n fromRouteId: currentRouteId,\n unstable_flushSync: options.unstable_flushSync,\n unstable_viewTransition: options.unstable_viewTransition\n });\n }\n }, [router, basename, currentRouteId]);\n}\n// v7: Eventually we should deprecate this entirely in favor of using the\n// router method directly?\nfunction useFormAction(action, _temp2) {\n let {\n relative\n } = _temp2 === void 0 ? {} : _temp2;\n let {\n basename\n } = React.useContext(UNSAFE_NavigationContext);\n let routeContext = React.useContext(UNSAFE_RouteContext);\n !routeContext ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"useFormAction must be used inside a RouteContext\") : UNSAFE_invariant(false) : void 0;\n let [match] = routeContext.matches.slice(-1);\n // Shallow clone path so we can modify it below, otherwise we modify the\n // object referenced by useMemo inside useResolvedPath\n let path = _extends({}, useResolvedPath(action ? action : \".\", {\n relative\n }));\n // Previously we set the default action to \".\". The problem with this is that\n // `useResolvedPath(\".\")` excludes search params of the resolved URL. This is\n // the intended behavior of when \".\" is specifically provided as\n // the form action, but inconsistent w/ browsers when the action is omitted.\n // https://github.com/remix-run/remix/issues/927\n let location = useLocation();\n if (action == null) {\n // Safe to write to this directly here since if action was undefined, we\n // would have called useResolvedPath(\".\") which will never include a search\n path.search = location.search;\n // When grabbing search params from the URL, remove any included ?index param\n // since it might not apply to our contextual route. We add it back based\n // on match.route.index below\n let params = new URLSearchParams(path.search);\n if (params.has(\"index\") && params.get(\"index\") === \"\") {\n params.delete(\"index\");\n path.search = params.toString() ? \"?\" + params.toString() : \"\";\n }\n }\n if ((!action || action === \".\") && match.route.index) {\n path.search = path.search ? path.search.replace(/^\\?/, \"?index&\") : \"?index\";\n }\n // If we're operating within a basename, prepend it to the pathname prior\n // to creating the form action. If this is a root navigation, then just use\n // the raw basename which allows the basename to have full control over the\n // presence of a trailing slash on root actions\n if (basename !== \"/\") {\n path.pathname = path.pathname === \"/\" ? basename : joinPaths([basename, path.pathname]);\n }\n return createPath(path);\n}\n// TODO: (v7) Change the useFetcher generic default from `any` to `unknown`\n/**\n * Interacts with route loaders and actions without causing a navigation. Great\n * for any interaction that stays on the same page.\n */\nfunction useFetcher(_temp3) {\n var _route$matches;\n let {\n key\n } = _temp3 === void 0 ? {} : _temp3;\n let {\n router\n } = useDataRouterContext(DataRouterHook.UseFetcher);\n let state = useDataRouterState(DataRouterStateHook.UseFetcher);\n let fetcherData = React.useContext(FetchersContext);\n let route = React.useContext(UNSAFE_RouteContext);\n let routeId = (_route$matches = route.matches[route.matches.length - 1]) == null ? void 0 : _route$matches.route.id;\n !fetcherData ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"useFetcher must be used inside a FetchersContext\") : UNSAFE_invariant(false) : void 0;\n !route ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"useFetcher must be used inside a RouteContext\") : UNSAFE_invariant(false) : void 0;\n !(routeId != null) ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"useFetcher can only be used on routes that contain a unique \\\"id\\\"\") : UNSAFE_invariant(false) : void 0;\n // Fetcher key handling\n let [fetcherKey, setFetcherKey] = React.useState(key || \"\");\n if (key && key !== fetcherKey) {\n setFetcherKey(key);\n } else if (!fetcherKey) {\n setFetcherKey(getUniqueFetcherId());\n }\n // Registration/cleanup\n React.useEffect(() => {\n router.getFetcher(fetcherKey);\n return () => {\n // Tell the router we've unmounted - if v7_fetcherPersist is enabled this\n // will not delete immediately but instead queue up a delete after the\n // fetcher returns to an `idle` state\n router.deleteFetcher(fetcherKey);\n };\n }, [router, fetcherKey]);\n // Fetcher additions\n let load = React.useCallback((href, opts) => {\n !routeId ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"No routeId available for fetcher.load()\") : UNSAFE_invariant(false) : void 0;\n router.fetch(fetcherKey, routeId, href, opts);\n }, [fetcherKey, routeId, router]);\n let submitImpl = useSubmit();\n let submit = React.useCallback((target, opts) => {\n submitImpl(target, _extends({}, opts, {\n navigate: false,\n fetcherKey\n }));\n }, [fetcherKey, submitImpl]);\n let FetcherForm = React.useMemo(() => {\n let FetcherForm = /*#__PURE__*/React.forwardRef((props, ref) => {\n return /*#__PURE__*/React.createElement(Form, _extends({}, props, {\n navigate: false,\n fetcherKey: fetcherKey,\n ref: ref\n }));\n });\n if (process.env.NODE_ENV !== \"production\") {\n FetcherForm.displayName = \"fetcher.Form\";\n }\n return FetcherForm;\n }, [fetcherKey]);\n // Exposed FetcherWithComponents\n let fetcher = state.fetchers.get(fetcherKey) || IDLE_FETCHER;\n let data = fetcherData.get(fetcherKey);\n let fetcherWithComponents = React.useMemo(() => _extends({\n Form: FetcherForm,\n submit,\n load\n }, fetcher, {\n data\n }), [FetcherForm, submit, load, fetcher, data]);\n return fetcherWithComponents;\n}\n/**\n * Provides all fetchers currently on the page. Useful for layouts and parent\n * routes that need to provide pending/optimistic UI regarding the fetch.\n */\nfunction useFetchers() {\n let state = useDataRouterState(DataRouterStateHook.UseFetchers);\n return Array.from(state.fetchers.entries()).map(_ref11 => {\n let [key, fetcher] = _ref11;\n return _extends({}, fetcher, {\n key\n });\n });\n}\nconst SCROLL_RESTORATION_STORAGE_KEY = \"react-router-scroll-positions\";\nlet savedScrollPositions = {};\n/**\n * When rendered inside a RouterProvider, will restore scroll positions on navigations\n */\nfunction useScrollRestoration(_temp4) {\n let {\n getKey,\n storageKey\n } = _temp4 === void 0 ? {} : _temp4;\n let {\n router\n } = useDataRouterContext(DataRouterHook.UseScrollRestoration);\n let {\n restoreScrollPosition,\n preventScrollReset\n } = useDataRouterState(DataRouterStateHook.UseScrollRestoration);\n let {\n basename\n } = React.useContext(UNSAFE_NavigationContext);\n let location = useLocation();\n let matches = useMatches();\n let navigation = useNavigation();\n // Trigger manual scroll restoration while we're active\n React.useEffect(() => {\n window.history.scrollRestoration = \"manual\";\n return () => {\n window.history.scrollRestoration = \"auto\";\n };\n }, []);\n // Save positions on pagehide\n usePageHide(React.useCallback(() => {\n if (navigation.state === \"idle\") {\n let key = (getKey ? getKey(location, matches) : null) || location.key;\n savedScrollPositions[key] = window.scrollY;\n }\n try {\n sessionStorage.setItem(storageKey || SCROLL_RESTORATION_STORAGE_KEY, JSON.stringify(savedScrollPositions));\n } catch (error) {\n process.env.NODE_ENV !== \"production\" ? UNSAFE_warning(false, \"Failed to save scroll positions in sessionStorage, <ScrollRestoration /> will not work properly (\" + error + \").\") : void 0;\n }\n window.history.scrollRestoration = \"auto\";\n }, [storageKey, getKey, navigation.state, location, matches]));\n // Read in any saved scroll locations\n if (typeof document !== \"undefined\") {\n // eslint-disable-next-line react-hooks/rules-of-hooks\n React.useLayoutEffect(() => {\n try {\n let sessionPositions = sessionStorage.getItem(storageKey || SCROLL_RESTORATION_STORAGE_KEY);\n if (sessionPositions) {\n savedScrollPositions = JSON.parse(sessionPositions);\n }\n } catch (e) {\n // no-op, use default empty object\n }\n }, [storageKey]);\n // Enable scroll restoration in the router\n // eslint-disable-next-line react-hooks/rules-of-hooks\n React.useLayoutEffect(() => {\n let getKeyWithoutBasename = getKey && basename !== \"/\" ? (location, matches) => getKey( // Strip the basename to match useLocation()\n _extends({}, location, {\n pathname: stripBasename(location.pathname, basename) || location.pathname\n }), matches) : getKey;\n let disableScrollRestoration = router == null ? void 0 : router.enableScrollRestoration(savedScrollPositions, () => window.scrollY, getKeyWithoutBasename);\n return () => disableScrollRestoration && disableScrollRestoration();\n }, [router, basename, getKey]);\n // Restore scrolling when state.restoreScrollPosition changes\n // eslint-disable-next-line react-hooks/rules-of-hooks\n React.useLayoutEffect(() => {\n // Explicit false means don't do anything (used for submissions)\n if (restoreScrollPosition === false) {\n return;\n }\n // been here before, scroll to it\n if (typeof restoreScrollPosition === \"number\") {\n window.scrollTo(0, restoreScrollPosition);\n return;\n }\n // try to scroll to the hash\n if (location.hash) {\n let el = document.getElementById(decodeURIComponent(location.hash.slice(1)));\n if (el) {\n el.scrollIntoView();\n return;\n }\n }\n // Don't reset if this navigation opted out\n if (preventScrollReset === true) {\n return;\n }\n // otherwise go to the top on new locations\n window.scrollTo(0, 0);\n }, [location, restoreScrollPosition, preventScrollReset]);\n }\n}\n/**\n * Setup a callback to be fired on the window's `beforeunload` event. This is\n * useful for saving some data to `window.localStorage` just before the page\n * refreshes.\n *\n * Note: The `callback` argument should be a function created with\n * `React.useCallback()`.\n */\nfunction useBeforeUnload(callback, options) {\n let {\n capture\n } = options || {};\n React.useEffect(() => {\n let opts = capture != null ? {\n capture\n } : undefined;\n window.addEventListener(\"beforeunload\", callback, opts);\n return () => {\n window.removeEventListener(\"beforeunload\", callback, opts);\n };\n }, [callback, capture]);\n}\n/**\n * Setup a callback to be fired on the window's `pagehide` event. This is\n * useful for saving some data to `window.localStorage` just before the page\n * refreshes. This event is better supported than beforeunload across browsers.\n *\n * Note: The `callback` argument should be a function created with\n * `React.useCallback()`.\n */\nfunction usePageHide(callback, options) {\n let {\n capture\n } = options || {};\n React.useEffect(() => {\n let opts = capture != null ? {\n capture\n } : undefined;\n window.addEventListener(\"pagehide\", callback, opts);\n return () => {\n window.removeEventListener(\"pagehide\", callback, opts);\n };\n }, [callback, capture]);\n}\n/**\n * Wrapper around useBlocker to show a window.confirm prompt to users instead\n * of building a custom UI with useBlocker.\n *\n * Warning: This has *a lot of rough edges* and behaves very differently (and\n * very incorrectly in some cases) across browsers if user click addition\n * back/forward navigations while the confirm is open. Use at your own risk.\n */\nfunction usePrompt(_ref12) {\n let {\n when,\n message\n } = _ref12;\n let blocker = useBlocker(when);\n React.useEffect(() => {\n if (blocker.state === \"blocked\") {\n let proceed = window.confirm(message);\n if (proceed) {\n // This timeout is needed to avoid a weird \"race\" on POP navigations\n // between the `window.history` revert navigation and the result of\n // `window.confirm`\n setTimeout(blocker.proceed, 0);\n } else {\n blocker.reset();\n }\n }\n }, [blocker, message]);\n React.useEffect(() => {\n if (blocker.state === \"blocked\" && !when) {\n blocker.reset();\n }\n }, [blocker, when]);\n}\n/**\n * Return a boolean indicating if there is an active view transition to the\n * given href. You can use this value to render CSS classes or viewTransitionName\n * styles onto your elements\n *\n * @param href The destination href\n * @param [opts.relative] Relative routing type (\"route\" | \"path\")\n */\nfunction useViewTransitionState(to, opts) {\n if (opts === void 0) {\n opts = {};\n }\n let vtContext = React.useContext(ViewTransitionContext);\n !(vtContext != null) ? process.env.NODE_ENV !== \"production\" ? UNSAFE_invariant(false, \"`unstable_useViewTransitionState` must be used within `react-router-dom`'s `RouterProvider`. \" + \"Did you accidentally import `RouterProvider` from `react-router`?\") : UNSAFE_invariant(false) : void 0;\n let {\n basename\n } = useDataRouterContext(DataRouterHook.useViewTransitionState);\n let path = useResolvedPath(to, {\n relative: opts.relative\n });\n if (!vtContext.isTransitioning) {\n return false;\n }\n let currentPath = stripBasename(vtContext.currentLocation.pathname, basename) || vtContext.currentLocation.pathname;\n let nextPath = stripBasename(vtContext.nextLocation.pathname, basename) || vtContext.nextLocation.pathname;\n // Transition is active if we're going to or coming from the indicated\n // destination. This ensures that other PUSH navigations that reverse\n // an indicated transition apply. I.e., on the list view you have:\n //\n // <NavLink to=\"/details/1\" unstable_viewTransition>\n //\n // If you click the breadcrumb back to the list view:\n //\n // <NavLink to=\"/list\" unstable_viewTransition>\n //\n // We should apply the transition because it's indicated as active going\n // from /list -> /details/1 and therefore should be active on the reverse\n // (even though this isn't strictly a POP reverse)\n return matchPath(path.pathname, nextPath) != null || matchPath(path.pathname, currentPath) != null;\n}\n//#endregion\n\n// v5 isn't in TypeScript, they'll also lose the @types/react-router with this\n// but not worried about that for now.\nfunction CompatRoute(props) {\n let {\n location,\n path\n } = props;\n if (!props.exact) path += \"/*\";\n return /*#__PURE__*/React.createElement(Routes, {\n location: location\n }, /*#__PURE__*/React.createElement(Route, {\n path: path,\n element: /*#__PURE__*/React.createElement(Route$1, _extends({}, props))\n }));\n}\n// Copied with 💜 from https://github.com/bvaughn/react-resizable-panels/blob/main/packages/react-resizable-panels/src/hooks/useIsomorphicEffect.ts\nconst canUseEffectHooks = !!(typeof window !== \"undefined\" && typeof window.document !== \"undefined\" && typeof window.document.createElement !== \"undefined\");\nconst useIsomorphicLayoutEffect = canUseEffectHooks ? React.useLayoutEffect : () => {};\nfunction CompatRouter(_ref) {\n let {\n children\n } = _ref;\n let history = useHistory();\n let [state, setState] = React.useState(() => ({\n location: history.location,\n action: history.action\n }));\n useIsomorphicLayoutEffect(() => {\n history.listen((location, action) => setState({\n location,\n action\n }));\n }, [history]);\n return /*#__PURE__*/React.createElement(Router, {\n navigationType: state.action,\n location: state.location,\n navigator: history\n }, /*#__PURE__*/React.createElement(Routes, null, /*#__PURE__*/React.createElement(Route, {\n path: \"*\",\n element: children\n })));\n}\nconst ABSOLUTE_URL_REGEX = /^(?:[a-z][a-z0-9+.-]*:|\\/\\/)/i;\n/**\n * A `<Router>` that may not navigate to any other location. This is useful\n * on the server where there is no stateful UI.\n */\nfunction StaticRouter(_ref2) {\n let {\n basename,\n children,\n location: locationProp = \"/\"\n } = _ref2;\n if (typeof locationProp === \"string\") {\n locationProp = parsePath(locationProp);\n }\n let action = Action.Pop;\n let location = {\n pathname: locationProp.pathname || \"/\",\n search: locationProp.search || \"\",\n hash: locationProp.hash || \"\",\n state: locationProp.state || null,\n key: locationProp.key || \"default\"\n };\n let staticNavigator = {\n createHref(to) {\n return typeof to === \"string\" ? to : createPath$1(to);\n },\n encodeLocation(to) {\n let href = typeof to === \"string\" ? to : createPath$1(to);\n let encoded = ABSOLUTE_URL_REGEX.test(href) ? new URL(href) : new URL(href, \"http://localhost\");\n return {\n pathname: encoded.pathname,\n search: encoded.search,\n hash: encoded.hash\n };\n },\n push(to) {\n throw new Error(\"You cannot use navigator.push() on the server because it is a stateless \" + \"environment. This error was probably triggered when you did a \" + (\"`navigate(\" + JSON.stringify(to) + \")` somewhere in your app.\"));\n },\n replace(to) {\n throw new Error(\"You cannot use navigator.replace() on the server because it is a stateless \" + \"environment. This error was probably triggered when you did a \" + (\"`navigate(\" + JSON.stringify(to) + \", { replace: true })` somewhere \") + \"in your app.\");\n },\n go(delta) {\n throw new Error(\"You cannot use navigator.go() on the server because it is a stateless \" + \"environment. This error was probably triggered when you did a \" + (\"`navigate(\" + delta + \")` somewhere in your app.\"));\n },\n back() {\n throw new Error(\"You cannot use navigator.back() on the server because it is a stateless \" + \"environment.\");\n },\n forward() {\n throw new Error(\"You cannot use navigator.forward() on the server because it is a stateless \" + \"environment.\");\n }\n };\n return /*#__PURE__*/React.createElement(Router, {\n basename: basename,\n children: children,\n location: location,\n navigationType: action,\n navigator: staticNavigator,\n static: true\n });\n}\n\nexport { BrowserRouter, CompatRoute, CompatRouter, Form, HashRouter, Link, NavLink, RouterProvider, ScrollRestoration, StaticRouter, useScrollRestoration as UNSAFE_useScrollRestoration, createBrowserRouter, createHashRouter, createSearchParams, HistoryRouter as unstable_HistoryRouter, usePrompt as unstable_usePrompt, useBeforeUnload, useFetcher, useFetchers, useFormAction, useLinkClickHandler, useSearchParams, useSubmit };\n//# sourceMappingURL=index.js.map\n"],"names":["_extends","target","i","source","key","DataRouterContext","React.createContext","DataRouterStateContext","AwaitContext","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","matches","locationPathname","routePathnamesJson","UNSAFE_getPathContributingMatches","match","activeRef","React.useRef","React.useCallback","options","path","resolveTo","OutletContext","useOutlet","context","outlet","React.createElement","useParams","routeMatch","_temp2","React.useMemo","useRoutes","routes","locationArg","useRoutesImpl","dataRouterState","parentMatches","parentParams","parentPathnameBase","locationFromContext","location","_parsedLocationArg$pa","parsedLocationArg","parsePath","remainingPathname","matchRoutes","renderedMatches","_renderMatches","Action","DefaultErrorComponent","error","useRouteError","message","isRouteErrorResponse","stack","preStyles","React.Fragment","defaultErrorElement","RenderErrorBoundary","React.Component","props","state","errorInfo","RenderedRoute","_ref","routeContext","children","_dataRouterState2","_dataRouterState","errors","errorIndex","m","index","errorElement","getChildren","DataRouterHook","DataRouterStateHook","useDataRouterContext","hookName","ctx","useDataRouterState","useRouteContext","route","useCurrentRouteId","thisRoute","useRouteId","_state$errors","routeId","useAsyncValue","value","router","id","Navigate","_ref4","replace","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","mapRouteProperties","updates","_objectWithoutPropertiesLoose","excluded","sourceKeys","defaultMethod","defaultEncType","isHtmlElement","object","isButtonElement","isFormElement","isInputElement","isModifiedEvent","event","shouldProcessLinkClick","createSearchParams","init","memo","v","getSearchParamsForLocation","locationSearch","defaultSearchParams","searchParams","_","_formDataSupportsSubmitter","isFormDataSubmitterSupported","supportedFormEncTypes","getFormEncType","encType","getFormSubmissionInfo","method","action","formData","body","attr","form","name","type","prefix","_excluded","_excluded3","createBrowserRouter","opts","createRouter","createBrowserHistory","parseHydrationData","UNSAFE_mapRouteProperties","_window","deserializeErrors","entries","serialized","val","UNSAFE_ErrorResponseImpl","ErrorConstructor","ViewTransitionContext","FetchersContext","START_TRANSITION","startTransitionImpl","React","FLUSH_SYNC","flushSyncImpl","ReactDOM","startTransitionSafe","flushSyncSafe","Deferred","resolve","reject","reason","RouterProvider","fallbackElement","future","setStateImpl","React.useState","pendingState","setPendingState","vtContext","setVtContext","renderDfd","setRenderDfd","transition","setTransition","interruption","setInterruption","fetcherData","v7_startTransition","optInStartTransition","setState","newState","_ref2","deletedFetchers","flushSync","viewTransitionOpts","fetcher","isViewTransitionUnavailable","t","renderPromise","n","UNSAFE_DataRouterContext","UNSAFE_DataRouterStateContext","DataRoutes","_ref3","UNSAFE_useRoutesImpl","BrowserRouter","window","historyRef","history","isBrowser","ABSOLUTE_URL_REGEX$1","Link","React.forwardRef","_ref7","ref","onClick","reloadDocument","preventScrollReset","unstable_viewTransition","rest","UNSAFE_NavigationContext","absoluteHref","isExternal","currentUrl","targetUrl","href","internalOnClick","useLinkClickHandler","handleClick","Form","_ref9","forwardedRef","fetcherKey","onSubmit","submit","useSubmit","formAction","useFormAction","formMethod","submitHandler","submitter","submitMethod","replaceProp","createPath","useSearchParams","defaultInit","defaultSearchParamsRef","hasSetSearchParamsRef","setSearchParams","nextInit","navigateOptions","newSearchParams","validateClientSideSubmission","fetcherId","getUniqueFetcherId","currentRouteId","UNSAFE_useRouteId","UNSAFE_RouteContext","params","useFetcher","_temp3","_route$matches","setFetcherKey","load","submitImpl","FetcherForm","IDLE_FETCHER","data","useBeforeUnload","callback","capture","canUseEffectHooks","CompatRouter","useHistory"],"mappings":"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","x_google_ignoreList":[0,1]}