| 1 | {"version":3,"file":"react-router.production.min.js","sources":["../../lib/context.ts","../../lib/hooks.tsx","../../lib/components.tsx","../../index.ts"],"sourcesContent":["import * as React from \"react\";\nimport type {\n AgnosticRouteMatch,\n AgnosticIndexRouteObject,\n AgnosticNonIndexRouteObject,\n History,\n Location,\n RelativeRoutingType,\n Router,\n StaticHandlerContext,\n To,\n TrackedPromise,\n LazyRouteFunction,\n} from \"@remix-run/router\";\nimport type { Action as NavigationType } from \"@remix-run/router\";\n\n// Create react-specific types from the agnostic types in @remix-run/router to\n// export from react-router\nexport interface IndexRouteObject {\n caseSensitive?: AgnosticIndexRouteObject[\"caseSensitive\"];\n path?: AgnosticIndexRouteObject[\"path\"];\n id?: AgnosticIndexRouteObject[\"id\"];\n loader?: AgnosticIndexRouteObject[\"loader\"];\n action?: AgnosticIndexRouteObject[\"action\"];\n hasErrorBoundary?: AgnosticIndexRouteObject[\"hasErrorBoundary\"];\n shouldRevalidate?: AgnosticIndexRouteObject[\"shouldRevalidate\"];\n handle?: AgnosticIndexRouteObject[\"handle\"];\n index: true;\n children?: undefined;\n element?: React.ReactNode | null;\n errorElement?: React.ReactNode | null;\n Component?: React.ComponentType | null;\n ErrorBoundary?: React.ComponentType | null;\n lazy?: LazyRouteFunction<IndexRouteObject>;\n}\n\nexport interface NonIndexRouteObject {\n caseSensitive?: AgnosticNonIndexRouteObject[\"caseSensitive\"];\n path?: AgnosticNonIndexRouteObject[\"path\"];\n id?: AgnosticNonIndexRouteObject[\"id\"];\n loader?: AgnosticNonIndexRouteObject[\"loader\"];\n action?: AgnosticNonIndexRouteObject[\"action\"];\n hasErrorBoundary?: AgnosticNonIndexRouteObject[\"hasErrorBoundary\"];\n shouldRevalidate?: AgnosticNonIndexRouteObject[\"shouldRevalidate\"];\n handle?: AgnosticNonIndexRouteObject[\"handle\"];\n index?: false;\n children?: RouteObject[];\n element?: React.ReactNode | null;\n errorElement?: React.ReactNode | null;\n Component?: React.ComponentType | null;\n ErrorBoundary?: React.ComponentType | null;\n lazy?: LazyRouteFunction<NonIndexRouteObject>;\n}\n\nexport type RouteObject = IndexRouteObject | NonIndexRouteObject;\n\nexport type DataRouteObject = RouteObject & {\n children?: DataRouteObject[];\n id: string;\n};\n\nexport interface RouteMatch<\n ParamKey extends string = string,\n RouteObjectType extends RouteObject = RouteObject\n> extends AgnosticRouteMatch<ParamKey, RouteObjectType> {}\n\nexport interface DataRouteMatch extends RouteMatch<string, DataRouteObject> {}\n\nexport interface DataRouterContextObject extends NavigationContextObject {\n router: Router;\n staticContext?: StaticHandlerContext;\n}\n\nexport const DataRouterContext =\n React.createContext<DataRouterContextObject | null>(null);\nif (__DEV__) {\n DataRouterContext.displayName = \"DataRouter\";\n}\n\nexport const DataRouterStateContext = React.createContext<\n Router[\"state\"] | null\n>(null);\nif (__DEV__) {\n DataRouterStateContext.displayName = \"DataRouterState\";\n}\n\nexport const AwaitContext = React.createContext<TrackedPromise | null>(null);\nif (__DEV__) {\n AwaitContext.displayName = \"Await\";\n}\n\nexport interface NavigateOptions {\n replace?: boolean;\n state?: any;\n preventScrollReset?: boolean;\n relative?: RelativeRoutingType;\n}\n\n/**\n * A Navigator is a \"location changer\"; it's how you get to different locations.\n *\n * Every history instance conforms to the Navigator interface, but the\n * distinction is useful primarily when it comes to the low-level <Router> API\n * where both the location and a navigator must be provided separately in order\n * to avoid \"tearing\" that may occur in a suspense-enabled app if the action\n * and/or location were to be read directly from the history instance.\n */\nexport interface Navigator {\n createHref: History[\"createHref\"];\n // Optional for backwards-compat with Router/HistoryRouter usage (edge case)\n encodeLocation?: History[\"encodeLocation\"];\n go: History[\"go\"];\n push(to: To, state?: any, opts?: NavigateOptions): void;\n replace(to: To, state?: any, opts?: NavigateOptions): void;\n}\n\ninterface NavigationContextObject {\n basename: string;\n navigator: Navigator;\n static: boolean;\n}\n\nexport const NavigationContext = React.createContext<NavigationContextObject>(\n null!\n);\n\nif (__DEV__) {\n NavigationContext.displayName = \"Navigation\";\n}\n\ninterface LocationContextObject {\n location: Location;\n navigationType: NavigationType;\n}\n\nexport const LocationContext = React.createContext<LocationContextObject>(\n null!\n);\n\nif (__DEV__) {\n LocationContext.displayName = \"Location\";\n}\n\nexport interface RouteContextObject {\n outlet: React.ReactElement | null;\n matches: RouteMatch[];\n isDataRoute: boolean;\n}\n\nexport const RouteContext = React.createContext<RouteContextObject>({\n outlet: null,\n matches: [],\n isDataRoute: false,\n});\n\nif (__DEV__) {\n RouteContext.displayName = \"Route\";\n}\n\nexport const RouteErrorContext = React.createContext<any>(null);\n\nif (__DEV__) {\n RouteErrorContext.displayName = \"RouteError\";\n}\n","import * as React from \"react\";\nimport type {\n Blocker,\n BlockerFunction,\n Location,\n ParamParseKey,\n Params,\n Path,\n PathMatch,\n PathPattern,\n RelativeRoutingType,\n Router as RemixRouter,\n RevalidationState,\n To,\n} from \"@remix-run/router\";\nimport {\n Action as NavigationType,\n UNSAFE_invariant as invariant,\n isRouteErrorResponse,\n joinPaths,\n matchPath,\n matchRoutes,\n parsePath,\n resolveTo,\n UNSAFE_getPathContributingMatches as getPathContributingMatches,\n UNSAFE_warning as warning,\n} from \"@remix-run/router\";\n\nimport type {\n NavigateOptions,\n RouteContextObject,\n RouteMatch,\n RouteObject,\n DataRouteMatch,\n} from \"./context\";\nimport {\n DataRouterContext,\n DataRouterStateContext,\n LocationContext,\n NavigationContext,\n RouteContext,\n RouteErrorContext,\n AwaitContext,\n} from \"./context\";\n\n/**\n * Returns the full href for the given \"to\" value. This is useful for building\n * custom links that are also accessible and preserve right-click behavior.\n *\n * @see https://reactrouter.com/hooks/use-href\n */\nexport function useHref(\n to: To,\n { relative }: { relative?: RelativeRoutingType } = {}\n): string {\n invariant(\n useInRouterContext(),\n // TODO: This error is probably because they somehow have 2 versions of the\n // router loaded. We can help them understand how to avoid that.\n `useHref() may be used only in the context of a <Router> component.`\n );\n\n let { basename, navigator } = React.useContext(NavigationContext);\n let { hash, pathname, search } = useResolvedPath(to, { relative });\n\n let joinedPathname = pathname;\n\n // If we're operating within a basename, prepend it to the pathname prior\n // to creating the href. If this is a root navigation, then just use the raw\n // basename which allows the basename to have full control over the presence\n // of a trailing slash on root links\n if (basename !== \"/\") {\n joinedPathname =\n pathname === \"/\" ? basename : joinPaths([basename, pathname]);\n }\n\n return navigator.createHref({ pathname: joinedPathname, search, hash });\n}\n\n/**\n * Returns true if this component is a descendant of a <Router>.\n *\n * @see https://reactrouter.com/hooks/use-in-router-context\n */\nexport function useInRouterContext(): boolean {\n return React.useContext(LocationContext) != null;\n}\n\n/**\n * Returns the current location object, which represents the current URL in web\n * browsers.\n *\n * Note: If you're using this it may mean you're doing some of your own\n * \"routing\" in your app, and we'd like to know what your use case is. We may\n * be able to provide something higher-level to better suit your needs.\n *\n * @see https://reactrouter.com/hooks/use-location\n */\nexport function useLocation(): Location {\n invariant(\n useInRouterContext(),\n // TODO: This error is probably because they somehow have 2 versions of the\n // router loaded. We can help them understand how to avoid that.\n `useLocation() may be used only in the context of a <Router> component.`\n );\n\n return React.useContext(LocationContext).location;\n}\n\n/**\n * Returns the current navigation action which describes how the router came to\n * the current location, either by a pop, push, or replace on the history stack.\n *\n * @see https://reactrouter.com/hooks/use-navigation-type\n */\nexport function useNavigationType(): NavigationType {\n return React.useContext(LocationContext).navigationType;\n}\n\n/**\n * Returns a PathMatch object if the given pattern matches the current URL.\n * This is useful for components that need to know \"active\" state, e.g.\n * <NavLink>.\n *\n * @see https://reactrouter.com/hooks/use-match\n */\nexport function useMatch<\n ParamKey extends ParamParseKey<Path>,\n Path extends string\n>(pattern: PathPattern<Path> | Path): PathMatch<ParamKey> | null {\n invariant(\n useInRouterContext(),\n // TODO: This error is probably because they somehow have 2 versions of the\n // router loaded. We can help them understand how to avoid that.\n `useMatch() may be used only in the context of a <Router> component.`\n );\n\n let { pathname } = useLocation();\n return React.useMemo(\n () => matchPath<ParamKey, Path>(pattern, pathname),\n [pathname, pattern]\n );\n}\n\n/**\n * The interface for the navigate() function returned from useNavigate().\n */\nexport interface NavigateFunction {\n (to: To, options?: NavigateOptions): void;\n (delta: number): void;\n}\n\nconst navigateEffectWarning =\n `You should call navigate() in a React.useEffect(), not when ` +\n `your component is first rendered.`;\n\n// Mute warnings for calls to useNavigate in SSR environments\nfunction useIsomorphicLayoutEffect(\n cb: Parameters<typeof React.useLayoutEffect>[0]\n) {\n let isStatic = React.useContext(NavigationContext).static;\n if (!isStatic) {\n // We should be able to get rid of this once react 18.3 is released\n // See: https://github.com/facebook/react/pull/26395\n // eslint-disable-next-line react-hooks/rules-of-hooks\n React.useLayoutEffect(cb);\n }\n}\n\n/**\n * Returns an imperative method for changing the location. Used by <Link>s, but\n * may also be used by other elements to change the location.\n *\n * @see https://reactrouter.com/hooks/use-navigate\n */\nexport function useNavigate(): NavigateFunction {\n let { isDataRoute } = React.useContext(RouteContext);\n // Conditional usage is OK here because the usage of a data router is static\n // eslint-disable-next-line react-hooks/rules-of-hooks\n return isDataRoute ? useNavigateStable() : useNavigateUnstable();\n}\n\nfunction useNavigateUnstable(): NavigateFunction {\n invariant(\n useInRouterContext(),\n // TODO: This error is probably because they somehow have 2 versions of the\n // router loaded. We can help them understand how to avoid that.\n `useNavigate() may be used only in the context of a <Router> component.`\n );\n\n let dataRouterContext = React.useContext(DataRouterContext);\n let { basename, navigator } = React.useContext(NavigationContext);\n let { matches } = React.useContext(RouteContext);\n let { pathname: locationPathname } = useLocation();\n\n let routePathnamesJson = JSON.stringify(\n getPathContributingMatches(matches).map((match) => match.pathnameBase)\n );\n\n let activeRef = React.useRef(false);\n useIsomorphicLayoutEffect(() => {\n activeRef.current = true;\n });\n\n let navigate: NavigateFunction = React.useCallback(\n (to: To | number, options: NavigateOptions = {}) => {\n warning(activeRef.current, navigateEffectWarning);\n\n // Short circuit here since if this happens on first render the navigate\n // is useless because we haven't wired up our history listener yet\n if (!activeRef.current) return;\n\n if (typeof to === \"number\") {\n navigator.go(to);\n return;\n }\n\n let path = resolveTo(\n to,\n JSON.parse(routePathnamesJson),\n locationPathname,\n options.relative === \"path\"\n );\n\n // If we're operating within a basename, prepend it to the pathname prior\n // to handing off to history (but only if we're not in a data router,\n // otherwise it'll prepend the basename inside of the router).\n // If this is a root navigation, then we navigate to the raw basename\n // which allows the basename to have full control over the presence of a\n // trailing slash on root links\n if (dataRouterContext == null && basename !== \"/\") {\n path.pathname =\n path.pathname === \"/\"\n ? basename\n : joinPaths([basename, path.pathname]);\n }\n\n (!!options.replace ? navigator.replace : navigator.push)(\n path,\n options.state,\n options\n );\n },\n [\n basename,\n navigator,\n routePathnamesJson,\n locationPathname,\n dataRouterContext,\n ]\n );\n\n return navigate;\n}\n\nconst OutletContext = React.createContext<unknown>(null);\n\n/**\n * Returns the context (if provided) for the child route at this level of the route\n * hierarchy.\n * @see https://reactrouter.com/hooks/use-outlet-context\n */\nexport function useOutletContext<Context = unknown>(): Context {\n return React.useContext(OutletContext) as Context;\n}\n\n/**\n * Returns the element for the child route at this level of the route\n * hierarchy. Used internally by <Outlet> to render child routes.\n *\n * @see https://reactrouter.com/hooks/use-outlet\n */\nexport function useOutlet(context?: unknown): React.ReactElement | null {\n let outlet = React.useContext(RouteContext).outlet;\n if (outlet) {\n return (\n <OutletContext.Provider value={context}>{outlet}</OutletContext.Provider>\n );\n }\n return outlet;\n}\n\n/**\n * Returns an object of key/value pairs of the dynamic params from the current\n * URL that were matched by the route path.\n *\n * @see https://reactrouter.com/hooks/use-params\n */\nexport function useParams<\n ParamsOrKey extends string | Record<string, string | undefined> = string\n>(): Readonly<\n [ParamsOrKey] extends [string] ? Params<ParamsOrKey> : Partial<ParamsOrKey>\n> {\n let { matches } = React.useContext(RouteContext);\n let routeMatch = matches[matches.length - 1];\n return routeMatch ? (routeMatch.params as any) : {};\n}\n\n/**\n * Resolves the pathname of the given `to` value against the current location.\n *\n * @see https://reactrouter.com/hooks/use-resolved-path\n */\nexport function useResolvedPath(\n to: To,\n { relative }: { relative?: RelativeRoutingType } = {}\n): Path {\n let { matches } = React.useContext(RouteContext);\n let { pathname: locationPathname } = useLocation();\n\n let routePathnamesJson = JSON.stringify(\n getPathContributingMatches(matches).map((match) => match.pathnameBase)\n );\n\n return React.useMemo(\n () =>\n resolveTo(\n to,\n JSON.parse(routePathnamesJson),\n locationPathname,\n relative === \"path\"\n ),\n [to, routePathnamesJson, locationPathname, relative]\n );\n}\n\n/**\n * Returns the element of the route that matched the current location, prepared\n * with the correct context to render the remainder of the route tree. Route\n * elements in the tree must render an <Outlet> to render their child route's\n * element.\n *\n * @see https://reactrouter.com/hooks/use-routes\n */\nexport function useRoutes(\n routes: RouteObject[],\n locationArg?: Partial<Location> | string\n): React.ReactElement | null {\n return useRoutesImpl(routes, locationArg);\n}\n\n// Internal implementation with accept optional param for RouterProvider usage\nexport function useRoutesImpl(\n routes: RouteObject[],\n locationArg?: Partial<Location> | string,\n dataRouterState?: RemixRouter[\"state\"]\n): React.ReactElement | null {\n invariant(\n useInRouterContext(),\n // TODO: This error is probably because they somehow have 2 versions of the\n // router loaded. We can help them understand how to avoid that.\n `useRoutes() may be used only in the context of a <Router> component.`\n );\n\n let { navigator } = React.useContext(NavigationContext);\n let { matches: parentMatches } = React.useContext(RouteContext);\n let routeMatch = parentMatches[parentMatches.length - 1];\n let parentParams = routeMatch ? routeMatch.params : {};\n let parentPathname = routeMatch ? routeMatch.pathname : \"/\";\n let parentPathnameBase = routeMatch ? routeMatch.pathnameBase : \"/\";\n let parentRoute = routeMatch && routeMatch.route;\n\n if (__DEV__) {\n // You won't get a warning about 2 different <Routes> under a <Route>\n // without a trailing *, but this is a best-effort warning anyway since we\n // cannot even give the warning unless they land at the parent route.\n //\n // Example:\n //\n // <Routes>\n // {/* This route path MUST end with /* because otherwise\n // it will never match /blog/post/123 */}\n // <Route path=\"blog\" element={<Blog />} />\n // <Route path=\"blog/feed\" element={<BlogFeed />} />\n // </Routes>\n //\n // function Blog() {\n // return (\n // <Routes>\n // <Route path=\"post/:id\" element={<Post />} />\n // </Routes>\n // );\n // }\n let parentPath = (parentRoute && parentRoute.path) || \"\";\n warningOnce(\n parentPathname,\n !parentRoute || parentPath.endsWith(\"*\"),\n `You rendered descendant <Routes> (or called \\`useRoutes()\\`) at ` +\n `\"${parentPathname}\" (under <Route path=\"${parentPath}\">) but the ` +\n `parent route path has no trailing \"*\". This means if you navigate ` +\n `deeper, the parent won't match anymore and therefore the child ` +\n `routes will never render.\\n\\n` +\n `Please change the parent <Route path=\"${parentPath}\"> to <Route ` +\n `path=\"${parentPath === \"/\" ? \"*\" : `${parentPath}/*`}\">.`\n );\n }\n\n let locationFromContext = useLocation();\n\n let location;\n if (locationArg) {\n let parsedLocationArg =\n typeof locationArg === \"string\" ? parsePath(locationArg) : locationArg;\n\n invariant(\n parentPathnameBase === \"/\" ||\n parsedLocationArg.pathname?.startsWith(parentPathnameBase),\n `When overriding the location using \\`<Routes location>\\` or \\`useRoutes(routes, location)\\`, ` +\n `the location pathname must begin with the portion of the URL pathname that was ` +\n `matched by all parent routes. The current pathname base is \"${parentPathnameBase}\" ` +\n `but pathname \"${parsedLocationArg.pathname}\" was given in the \\`location\\` prop.`\n );\n\n location = parsedLocationArg;\n } else {\n location = locationFromContext;\n }\n\n let pathname = location.pathname || \"/\";\n let remainingPathname =\n parentPathnameBase === \"/\"\n ? pathname\n : pathname.slice(parentPathnameBase.length) || \"/\";\n\n let matches = matchRoutes(routes, { pathname: remainingPathname });\n\n if (__DEV__) {\n warning(\n parentRoute || matches != null,\n `No routes matched location \"${location.pathname}${location.search}${location.hash}\" `\n );\n\n warning(\n matches == null ||\n matches[matches.length - 1].route.element !== undefined ||\n matches[matches.length - 1].route.Component !== undefined,\n `Matched leaf route at location \"${location.pathname}${location.search}${location.hash}\" ` +\n `does not have an element or Component. This means it will render an <Outlet /> with a ` +\n `null value by default resulting in an \"empty\" page.`\n );\n }\n\n let renderedMatches = _renderMatches(\n matches &&\n matches.map((match) =>\n Object.assign({}, match, {\n params: Object.assign({}, parentParams, match.params),\n pathname: joinPaths([\n parentPathnameBase,\n // Re-encode pathnames that were decoded inside matchRoutes\n navigator.encodeLocation\n ? navigator.encodeLocation(match.pathname).pathname\n : match.pathname,\n ]),\n pathnameBase:\n match.pathnameBase === \"/\"\n ? parentPathnameBase\n : joinPaths([\n parentPathnameBase,\n // Re-encode pathnames that were decoded inside matchRoutes\n navigator.encodeLocation\n ? navigator.encodeLocation(match.pathnameBase).pathname\n : match.pathnameBase,\n ]),\n })\n ),\n parentMatches,\n dataRouterState\n );\n\n // When a user passes in a `locationArg`, the associated routes need to\n // be wrapped in a new `LocationContext.Provider` in order for `useLocation`\n // to use the scoped location instead of the global location.\n if (locationArg && renderedMatches) {\n return (\n <LocationContext.Provider\n value={{\n location: {\n pathname: \"/\",\n search: \"\",\n hash: \"\",\n state: null,\n key: \"default\",\n ...location,\n },\n navigationType: NavigationType.Pop,\n }}\n >\n {renderedMatches}\n </LocationContext.Provider>\n );\n }\n\n return renderedMatches;\n}\n\nfunction DefaultErrorComponent() {\n let error = useRouteError();\n let message = isRouteErrorResponse(error)\n ? `${error.status} ${error.statusText}`\n : error instanceof Error\n ? error.message\n : JSON.stringify(error);\n let stack = error instanceof Error ? error.stack : null;\n let lightgrey = \"rgba(200,200,200, 0.5)\";\n let preStyles = { padding: \"0.5rem\", backgroundColor: lightgrey };\n let codeStyles = { padding: \"2px 4px\", backgroundColor: lightgrey };\n\n let devInfo = null;\n if (__DEV__) {\n console.error(\n \"Error handled by React Router default ErrorBoundary:\",\n error\n );\n\n devInfo = (\n <>\n <p>💿 Hey developer 👋</p>\n <p>\n You can provide a way better UX than this when your app throws errors\n by providing your own <code style={codeStyles}>ErrorBoundary</code> or{\" \"}\n <code style={codeStyles}>errorElement</code> prop on your route.\n </p>\n </>\n );\n }\n\n return (\n <>\n <h2>Unexpected Application Error!</h2>\n <h3 style={{ fontStyle: \"italic\" }}>{message}</h3>\n {stack ? <pre style={preStyles}>{stack}</pre> : null}\n {devInfo}\n </>\n );\n}\n\nconst defaultErrorElement = <DefaultErrorComponent />;\n\ntype RenderErrorBoundaryProps = React.PropsWithChildren<{\n location: Location;\n revalidation: RevalidationState;\n error: any;\n component: React.ReactNode;\n routeContext: RouteContextObject;\n}>;\n\ntype RenderErrorBoundaryState = {\n location: Location;\n revalidation: RevalidationState;\n error: any;\n};\n\nexport class RenderErrorBoundary extends React.Component<\n RenderErrorBoundaryProps,\n RenderErrorBoundaryState\n> {\n constructor(props: RenderErrorBoundaryProps) {\n super(props);\n this.state = {\n location: props.location,\n revalidation: props.revalidation,\n error: props.error,\n };\n }\n\n static getDerivedStateFromError(error: any) {\n return { error: error };\n }\n\n static getDerivedStateFromProps(\n props: RenderErrorBoundaryProps,\n state: RenderErrorBoundaryState\n ) {\n // When we get into an error state, the user will likely click \"back\" to the\n // previous page that didn't have an error. Because this wraps the entire\n // application, that will have no effect--the error page continues to display.\n // This gives us a mechanism to recover from the error when the location changes.\n //\n // Whether we're in an error state or not, we update the location in state\n // so that when we are in an error state, it gets reset when a new location\n // comes in and the user recovers from the error.\n if (\n state.location !== props.location ||\n (state.revalidation !== \"idle\" && props.revalidation === \"idle\")\n ) {\n return {\n error: props.error,\n location: props.location,\n revalidation: props.revalidation,\n };\n }\n\n // If we're not changing locations, preserve the location but still surface\n // any new errors that may come through. We retain the existing error, we do\n // this because the error provided from the app state may be cleared without\n // the location changing.\n return {\n error: props.error || state.error,\n location: state.location,\n revalidation: props.revalidation || state.revalidation,\n };\n }\n\n componentDidCatch(error: any, errorInfo: any) {\n console.error(\n \"React Router caught the following error during render\",\n error,\n errorInfo\n );\n }\n\n render() {\n return this.state.error ? (\n <RouteContext.Provider value={this.props.routeContext}>\n <RouteErrorContext.Provider\n value={this.state.error}\n children={this.props.component}\n />\n </RouteContext.Provider>\n ) : (\n this.props.children\n );\n }\n}\n\ninterface RenderedRouteProps {\n routeContext: RouteContextObject;\n match: RouteMatch<string, RouteObject>;\n children: React.ReactNode | null;\n}\n\nfunction RenderedRoute({ routeContext, match, children }: RenderedRouteProps) {\n let dataRouterContext = React.useContext(DataRouterContext);\n\n // Track how deep we got in our render pass to emulate SSR componentDidCatch\n // in a DataStaticRouter\n if (\n dataRouterContext &&\n dataRouterContext.static &&\n dataRouterContext.staticContext &&\n (match.route.errorElement || match.route.ErrorBoundary)\n ) {\n dataRouterContext.staticContext._deepestRenderedBoundaryId = match.route.id;\n }\n\n return (\n <RouteContext.Provider value={routeContext}>\n {children}\n </RouteContext.Provider>\n );\n}\n\nexport function _renderMatches(\n matches: RouteMatch[] | null,\n parentMatches: RouteMatch[] = [],\n dataRouterState: RemixRouter[\"state\"] | null = null\n): React.ReactElement | null {\n if (matches == null) {\n if (dataRouterState?.errors) {\n // Don't bail if we have data router errors so we can render them in the\n // boundary. Use the pre-matched (or shimmed) matches\n matches = dataRouterState.matches as DataRouteMatch[];\n } else {\n return null;\n }\n }\n\n let renderedMatches = matches;\n\n // If we have data errors, trim matches to the highest error boundary\n let errors = dataRouterState?.errors;\n if (errors != null) {\n let errorIndex = renderedMatches.findIndex(\n (m) => m.route.id && errors?.[m.route.id]\n );\n invariant(\n errorIndex >= 0,\n `Could not find a matching route for errors on route IDs: ${Object.keys(\n errors\n ).join(\",\")}`\n );\n renderedMatches = renderedMatches.slice(\n 0,\n Math.min(renderedMatches.length, errorIndex + 1)\n );\n }\n\n return renderedMatches.reduceRight((outlet, match, index) => {\n let error = match.route.id ? errors?.[match.route.id] : null;\n // Only data routers handle errors\n let errorElement: React.ReactNode | null = 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: React.ReactNode;\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 = <match.route.Component />;\n } else if (match.route.element) {\n children = match.route.element;\n } else {\n children = outlet;\n }\n return (\n <RenderedRoute\n match={match}\n routeContext={{\n outlet,\n matches,\n isDataRoute: dataRouterState != null,\n }}\n children={children}\n />\n );\n };\n // Only wrap in an error boundary within data router usages when we have an\n // ErrorBoundary/errorElement on this route. Otherwise let it bubble up to\n // an ancestor ErrorBoundary/errorElement\n return dataRouterState &&\n (match.route.ErrorBoundary || match.route.errorElement || index === 0) ? (\n <RenderErrorBoundary\n location={dataRouterState.location}\n revalidation={dataRouterState.revalidation}\n component={errorElement}\n error={error}\n children={getChildren()}\n routeContext={{ outlet: null, matches, isDataRoute: true }}\n />\n ) : (\n getChildren()\n );\n }, null as React.ReactElement | null);\n}\n\nenum DataRouterHook {\n UseBlocker = \"useBlocker\",\n UseRevalidator = \"useRevalidator\",\n UseNavigateStable = \"useNavigate\",\n}\n\nenum DataRouterStateHook {\n UseBlocker = \"useBlocker\",\n UseLoaderData = \"useLoaderData\",\n UseActionData = \"useActionData\",\n UseRouteError = \"useRouteError\",\n UseNavigation = \"useNavigation\",\n UseRouteLoaderData = \"useRouteLoaderData\",\n UseMatches = \"useMatches\",\n UseRevalidator = \"useRevalidator\",\n UseNavigateStable = \"useNavigate\",\n UseRouteId = \"useRouteId\",\n}\n\nfunction getDataRouterConsoleError(\n hookName: DataRouterHook | DataRouterStateHook\n) {\n return `${hookName} must be used within a data router. See https://reactrouter.com/routers/picking-a-router.`;\n}\n\nfunction useDataRouterContext(hookName: DataRouterHook) {\n let ctx = React.useContext(DataRouterContext);\n invariant(ctx, getDataRouterConsoleError(hookName));\n return ctx;\n}\n\nfunction useDataRouterState(hookName: DataRouterStateHook) {\n let state = React.useContext(DataRouterStateContext);\n invariant(state, getDataRouterConsoleError(hookName));\n return state;\n}\n\nfunction useRouteContext(hookName: DataRouterStateHook) {\n let route = React.useContext(RouteContext);\n invariant(route, getDataRouterConsoleError(hookName));\n return route;\n}\n\n// Internal version with hookName-aware debugging\nfunction useCurrentRouteId(hookName: DataRouterStateHook) {\n let route = useRouteContext(hookName);\n let thisRoute = route.matches[route.matches.length - 1];\n invariant(\n thisRoute.route.id,\n `${hookName} can only be used on routes that contain a unique \"id\"`\n );\n return thisRoute.route.id;\n}\n\n/**\n * Returns the ID for the nearest contextual route\n */\nexport function useRouteId() {\n return useCurrentRouteId(DataRouterStateHook.UseRouteId);\n}\n\n/**\n * Returns the current navigation, defaulting to an \"idle\" navigation when\n * no navigation is in progress\n */\nexport function useNavigation() {\n let state = useDataRouterState(DataRouterStateHook.UseNavigation);\n return state.navigation;\n}\n\n/**\n * Returns a revalidate function for manually triggering revalidation, as well\n * as the current state of any manual revalidations\n */\nexport function useRevalidator() {\n let dataRouterContext = useDataRouterContext(DataRouterHook.UseRevalidator);\n let state = useDataRouterState(DataRouterStateHook.UseRevalidator);\n return {\n revalidate: dataRouterContext.router.revalidate,\n state: state.revalidation,\n };\n}\n\n/**\n * Returns the active route matches, useful for accessing loaderData for\n * parent/child routes or the route \"handle\" property\n */\nexport function useMatches() {\n let { matches, loaderData } = useDataRouterState(\n DataRouterStateHook.UseMatches\n );\n return React.useMemo(\n () =>\n matches.map((match) => {\n let { pathname, params } = match;\n // Note: This structure matches that created by createUseMatchesMatch\n // in the @remix-run/router , so if you change this please also change\n // that :) Eventually we'll DRY this up\n return {\n id: match.route.id,\n pathname,\n params,\n data: loaderData[match.route.id] as unknown,\n handle: match.route.handle as unknown,\n };\n }),\n [matches, loaderData]\n );\n}\n\n/**\n * Returns the loader data for the nearest ancestor Route loader\n */\nexport function useLoaderData(): unknown {\n let state = useDataRouterState(DataRouterStateHook.UseLoaderData);\n let routeId = useCurrentRouteId(DataRouterStateHook.UseLoaderData);\n\n if (state.errors && state.errors[routeId] != null) {\n console.error(\n `You cannot \\`useLoaderData\\` in an errorElement (routeId: ${routeId})`\n );\n return undefined;\n }\n return state.loaderData[routeId];\n}\n\n/**\n * Returns the loaderData for the given routeId\n */\nexport function useRouteLoaderData(routeId: string): unknown {\n let state = useDataRouterState(DataRouterStateHook.UseRouteLoaderData);\n return state.loaderData[routeId];\n}\n\n/**\n * Returns the action data for the nearest ancestor Route action\n */\nexport function useActionData(): unknown {\n let state = useDataRouterState(DataRouterStateHook.UseActionData);\n\n let route = React.useContext(RouteContext);\n invariant(route, `useActionData must be used inside a RouteContext`);\n\n return Object.values(state?.actionData || {})[0];\n}\n\n/**\n * Returns the nearest ancestor Route error, which could be a loader/action\n * error or a render error. This is intended to be called from your\n * ErrorBoundary/errorElement to display a proper error message.\n */\nexport function useRouteError(): unknown {\n let error = React.useContext(RouteErrorContext);\n let state = useDataRouterState(DataRouterStateHook.UseRouteError);\n let routeId = useCurrentRouteId(DataRouterStateHook.UseRouteError);\n\n // If this was a render error, we put it in a RouteError context inside\n // of RenderErrorBoundary\n if (error) {\n return error;\n }\n\n // Otherwise look for errors from our data router state\n return state.errors?.[routeId];\n}\n\n/**\n * Returns the happy-path data from the nearest ancestor <Await /> value\n */\nexport function useAsyncValue(): unknown {\n let value = React.useContext(AwaitContext);\n return value?._data;\n}\n\n/**\n * Returns the error from the nearest ancestor <Await /> value\n */\nexport function useAsyncError(): unknown {\n let value = React.useContext(AwaitContext);\n return value?._error;\n}\n\nlet blockerId = 0;\n\n/**\n * Allow the application to block navigations within the SPA and present the\n * user a confirmation dialog to confirm the navigation. Mostly used to avoid\n * using half-filled form data. This does not handle hard-reloads or\n * cross-origin navigations.\n */\nexport function useBlocker(shouldBlock: boolean | BlockerFunction): Blocker {\n let { router } = useDataRouterContext(DataRouterHook.UseBlocker);\n let state = useDataRouterState(DataRouterStateHook.UseBlocker);\n let [blockerKey] = React.useState(() => String(++blockerId));\n\n let blockerFunction = React.useCallback<BlockerFunction>(\n (args) => {\n return typeof shouldBlock === \"function\"\n ? !!shouldBlock(args)\n : !!shouldBlock;\n },\n [shouldBlock]\n );\n\n let blocker = router.getBlocker(blockerKey, blockerFunction);\n\n // Cleanup on unmount\n React.useEffect(\n () => () => router.deleteBlocker(blockerKey),\n [router, blockerKey]\n );\n\n // Prefer the blocker from state since DataRouterContext is memoized so this\n // ensures we update on blocker state updates\n return state.blockers.get(blockerKey) || blocker;\n}\n\n/**\n * Stable version of useNavigate that is used when we are in the context of\n * a RouterProvider.\n */\nfunction useNavigateStable(): NavigateFunction {\n let { router } = useDataRouterContext(DataRouterHook.UseNavigateStable);\n let id = useCurrentRouteId(DataRouterStateHook.UseNavigateStable);\n\n let activeRef = React.useRef(false);\n useIsomorphicLayoutEffect(() => {\n activeRef.current = true;\n });\n\n let navigate: NavigateFunction = React.useCallback(\n (to: To | number, options: NavigateOptions = {}) => {\n warning(activeRef.current, navigateEffectWarning);\n\n // Short circuit here since if this happens on first render the navigate\n // is useless because we haven't wired up our router subscriber yet\n if (!activeRef.current) return;\n\n if (typeof to === \"number\") {\n router.navigate(to);\n } else {\n router.navigate(to, { fromRouteId: id, ...options });\n }\n },\n [router, id]\n );\n\n return navigate;\n}\n\nconst alreadyWarned: Record<string, boolean> = {};\n\nfunction warningOnce(key: string, cond: boolean, message: string) {\n if (!cond && !alreadyWarned[key]) {\n alreadyWarned[key] = true;\n warning(false, message);\n }\n}\n","import * as React from \"react\";\nimport type {\n TrackedPromise,\n InitialEntry,\n Location,\n MemoryHistory,\n Router as RemixRouter,\n To,\n LazyRouteFunction,\n RelativeRoutingType,\n RouterState,\n} from \"@remix-run/router\";\nimport {\n Action as NavigationType,\n AbortedDeferredError,\n createMemoryHistory,\n UNSAFE_invariant as invariant,\n parsePath,\n resolveTo,\n stripBasename,\n UNSAFE_warning as warning,\n UNSAFE_getPathContributingMatches as getPathContributingMatches,\n} from \"@remix-run/router\";\n\nimport type {\n DataRouteObject,\n IndexRouteObject,\n RouteMatch,\n RouteObject,\n Navigator,\n NonIndexRouteObject,\n} from \"./context\";\nimport {\n LocationContext,\n NavigationContext,\n DataRouterContext,\n DataRouterStateContext,\n AwaitContext,\n RouteContext,\n} from \"./context\";\nimport {\n useAsyncValue,\n useInRouterContext,\n useNavigate,\n useOutlet,\n useRoutes,\n _renderMatches,\n useRoutesImpl,\n useLocation,\n} from \"./hooks\";\n\nexport interface RouterProviderProps {\n fallbackElement?: React.ReactNode;\n router: RemixRouter;\n}\n\n/**\n * Given a Remix Router instance, render the appropriate UI\n */\nexport function RouterProvider({\n fallbackElement,\n router,\n}: RouterProviderProps): React.ReactElement {\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 let [state, setState] = React.useState(router.state);\n React.useLayoutEffect(() => router.subscribe(setState), [router, setState]);\n\n let navigator = React.useMemo((): Navigator => {\n return {\n createHref: router.createHref,\n encodeLocation: router.encodeLocation,\n go: (n) => router.navigate(n),\n push: (to, state, opts) =>\n router.navigate(to, {\n state,\n preventScrollReset: opts?.preventScrollReset,\n }),\n replace: (to, state, opts) =>\n router.navigate(to, {\n replace: true,\n state,\n preventScrollReset: opts?.preventScrollReset,\n }),\n };\n }, [router]);\n\n let basename = router.basename || \"/\";\n\n let dataRouterContext = React.useMemo(\n () => ({\n router,\n navigator,\n static: false,\n basename,\n }),\n [router, navigator, basename]\n );\n\n // The fragment and {null} here are important! We need them to keep React 18's\n // useId happy when we are server-rendering since we may have a <script> here\n // containing the hydrated server-side staticContext (from StaticRouterProvider).\n // useId relies on the component tree structure to generate deterministic id's\n // so we need to ensure it remains the same on the client even though\n // we don't need the <script> tag\n return (\n <>\n <DataRouterContext.Provider value={dataRouterContext}>\n <DataRouterStateContext.Provider value={state}>\n <Router\n basename={router.basename}\n location={router.state.location}\n navigationType={router.state.historyAction}\n navigator={navigator}\n >\n {router.state.initialized ? (\n <DataRoutes routes={router.routes} state={state} />\n ) : (\n fallbackElement\n )}\n </Router>\n </DataRouterStateContext.Provider>\n </DataRouterContext.Provider>\n {null}\n </>\n );\n}\n\nfunction DataRoutes({\n routes,\n state,\n}: {\n routes: DataRouteObject[];\n state: RouterState;\n}): React.ReactElement | null {\n return useRoutesImpl(routes, undefined, state);\n}\n\nexport interface MemoryRouterProps {\n basename?: string;\n children?: React.ReactNode;\n initialEntries?: InitialEntry[];\n initialIndex?: number;\n}\n\n/**\n * A <Router> that stores all entries in memory.\n *\n * @see https://reactrouter.com/router-components/memory-router\n */\nexport function MemoryRouter({\n basename,\n children,\n initialEntries,\n initialIndex,\n}: MemoryRouterProps): React.ReactElement {\n let historyRef = React.useRef<MemoryHistory>();\n if (historyRef.current == null) {\n historyRef.current = createMemoryHistory({\n initialEntries,\n initialIndex,\n v5Compat: true,\n });\n }\n\n let history = historyRef.current;\n let [state, setState] = React.useState({\n action: history.action,\n location: history.location,\n });\n\n React.useLayoutEffect(() => history.listen(setState), [history]);\n\n return (\n <Router\n basename={basename}\n children={children}\n location={state.location}\n navigationType={state.action}\n navigator={history}\n />\n );\n}\n\nexport interface NavigateProps {\n to: To;\n replace?: boolean;\n state?: any;\n relative?: RelativeRoutingType;\n}\n\n/**\n * Changes the current location.\n *\n * Note: This API is mostly useful in React.Component subclasses that are not\n * able to use hooks. In functional components, we recommend you use the\n * `useNavigate` hook instead.\n *\n * @see https://reactrouter.com/components/navigate\n */\nexport function Navigate({\n to,\n replace,\n state,\n relative,\n}: NavigateProps): null {\n invariant(\n useInRouterContext(),\n // TODO: This error is probably because they somehow have 2 versions of\n // the router loaded. We can help them understand how to avoid that.\n `<Navigate> may be used only in the context of a <Router> component.`\n );\n\n warning(\n !React.useContext(NavigationContext).static,\n `<Navigate> must not be used on the initial render in a <StaticRouter>. ` +\n `This is a no-op, but you should modify your code so the <Navigate> is ` +\n `only ever rendered in response to some user interaction or state change.`\n );\n\n let { matches } = React.useContext(RouteContext);\n let { pathname: locationPathname } = useLocation();\n let navigate = useNavigate();\n\n // Resolve the path outside of the effect so that when effects run twice in\n // StrictMode they navigate to the same place\n let path = resolveTo(\n to,\n getPathContributingMatches(matches).map((match) => match.pathnameBase),\n locationPathname,\n relative === \"path\"\n );\n let jsonPath = JSON.stringify(path);\n\n React.useEffect(\n () => navigate(JSON.parse(jsonPath), { replace, state, relative }),\n [navigate, jsonPath, relative, replace, state]\n );\n\n return null;\n}\n\nexport interface OutletProps {\n context?: unknown;\n}\n\n/**\n * Renders the child route's element, if there is one.\n *\n * @see https://reactrouter.com/components/outlet\n */\nexport function Outlet(props: OutletProps): React.ReactElement | null {\n return useOutlet(props.context);\n}\n\nexport interface PathRouteProps {\n caseSensitive?: NonIndexRouteObject[\"caseSensitive\"];\n path?: NonIndexRouteObject[\"path\"];\n id?: NonIndexRouteObject[\"id\"];\n lazy?: LazyRouteFunction<NonIndexRouteObject>;\n loader?: NonIndexRouteObject[\"loader\"];\n action?: NonIndexRouteObject[\"action\"];\n hasErrorBoundary?: NonIndexRouteObject[\"hasErrorBoundary\"];\n shouldRevalidate?: NonIndexRouteObject[\"shouldRevalidate\"];\n handle?: NonIndexRouteObject[\"handle\"];\n index?: false;\n children?: React.ReactNode;\n element?: React.ReactNode | null;\n errorElement?: React.ReactNode | null;\n Component?: React.ComponentType | null;\n ErrorBoundary?: React.ComponentType | null;\n}\n\nexport interface LayoutRouteProps extends PathRouteProps {}\n\nexport interface IndexRouteProps {\n caseSensitive?: IndexRouteObject[\"caseSensitive\"];\n path?: IndexRouteObject[\"path\"];\n id?: IndexRouteObject[\"id\"];\n lazy?: LazyRouteFunction<IndexRouteObject>;\n loader?: IndexRouteObject[\"loader\"];\n action?: IndexRouteObject[\"action\"];\n hasErrorBoundary?: IndexRouteObject[\"hasErrorBoundary\"];\n shouldRevalidate?: IndexRouteObject[\"shouldRevalidate\"];\n handle?: IndexRouteObject[\"handle\"];\n index: true;\n children?: undefined;\n element?: React.ReactNode | null;\n errorElement?: React.ReactNode | null;\n Component?: React.ComponentType | null;\n ErrorBoundary?: React.ComponentType | null;\n}\n\nexport type RouteProps = PathRouteProps | LayoutRouteProps | IndexRouteProps;\n\n/**\n * Declares an element that should be rendered at a certain URL path.\n *\n * @see https://reactrouter.com/components/route\n */\nexport function Route(_props: RouteProps): React.ReactElement | null {\n invariant(\n false,\n `A <Route> is only ever to be used as the child of <Routes> element, ` +\n `never rendered directly. Please wrap your <Route> in a <Routes>.`\n );\n}\n\nexport interface RouterProps {\n basename?: string;\n children?: React.ReactNode;\n location: Partial<Location> | string;\n navigationType?: NavigationType;\n navigator: Navigator;\n static?: boolean;\n}\n\n/**\n * Provides location context for the rest of the app.\n *\n * Note: You usually won't render a <Router> directly. Instead, you'll render a\n * router that is more specific to your environment such as a <BrowserRouter>\n * in web browsers or a <StaticRouter> for server rendering.\n *\n * @see https://reactrouter.com/router-components/router\n */\nexport function Router({\n basename: basenameProp = \"/\",\n children = null,\n location: locationProp,\n navigationType = NavigationType.Pop,\n navigator,\n static: staticProp = false,\n}: RouterProps): React.ReactElement | null {\n invariant(\n !useInRouterContext(),\n `You cannot render a <Router> inside another <Router>.` +\n ` You should never have more than one in your app.`\n );\n\n // Preserve trailing slashes on basename, so we can let the user control\n // the enforcement of trailing slashes throughout the app\n let basename = basenameProp.replace(/^\\/*/, \"/\");\n let navigationContext = React.useMemo(\n () => ({ basename, navigator, static: staticProp }),\n [basename, navigator, staticProp]\n );\n\n if (typeof locationProp === \"string\") {\n locationProp = parsePath(locationProp);\n }\n\n let {\n pathname = \"/\",\n search = \"\",\n hash = \"\",\n state = null,\n key = \"default\",\n } = locationProp;\n\n let locationContext = React.useMemo(() => {\n let trailingPathname = stripBasename(pathname, basename);\n\n if (trailingPathname == null) {\n return null;\n }\n\n return {\n location: {\n pathname: trailingPathname,\n search,\n hash,\n state,\n key,\n },\n navigationType,\n };\n }, [basename, pathname, search, hash, state, key, navigationType]);\n\n warning(\n locationContext != null,\n `<Router basename=\"${basename}\"> is not able to match the URL ` +\n `\"${pathname}${search}${hash}\" because it does not start with the ` +\n `basename, so the <Router> won't render anything.`\n );\n\n if (locationContext == null) {\n return null;\n }\n\n return (\n <NavigationContext.Provider value={navigationContext}>\n <LocationContext.Provider children={children} value={locationContext} />\n </NavigationContext.Provider>\n );\n}\n\nexport interface RoutesProps {\n children?: React.ReactNode;\n location?: Partial<Location> | string;\n}\n\n/**\n * A container for a nested tree of <Route> elements that renders the branch\n * that best matches the current location.\n *\n * @see https://reactrouter.com/components/routes\n */\nexport function Routes({\n children,\n location,\n}: RoutesProps): React.ReactElement | null {\n return useRoutes(createRoutesFromChildren(children), location);\n}\n\nexport interface AwaitResolveRenderFunction {\n (data: Awaited<any>): React.ReactNode;\n}\n\nexport interface AwaitProps {\n children: React.ReactNode | AwaitResolveRenderFunction;\n errorElement?: React.ReactNode;\n resolve: TrackedPromise | any;\n}\n\n/**\n * Component to use for rendering lazily loaded data from returning defer()\n * in a loader function\n */\nexport function Await({ children, errorElement, resolve }: AwaitProps) {\n return (\n <AwaitErrorBoundary resolve={resolve} errorElement={errorElement}>\n <ResolveAwait>{children}</ResolveAwait>\n </AwaitErrorBoundary>\n );\n}\n\ntype AwaitErrorBoundaryProps = React.PropsWithChildren<{\n errorElement?: React.ReactNode;\n resolve: TrackedPromise | any;\n}>;\n\ntype AwaitErrorBoundaryState = {\n error: any;\n};\n\nenum AwaitRenderStatus {\n pending,\n success,\n error,\n}\n\nconst neverSettledPromise = new Promise(() => {});\n\nclass AwaitErrorBoundary extends React.Component<\n AwaitErrorBoundaryProps,\n AwaitErrorBoundaryState\n> {\n constructor(props: AwaitErrorBoundaryProps) {\n super(props);\n this.state = { error: null };\n }\n\n static getDerivedStateFromError(error: any) {\n return { error };\n }\n\n componentDidCatch(error: any, errorInfo: any) {\n console.error(\n \"<Await> caught the following error during render\",\n error,\n errorInfo\n );\n }\n\n render() {\n let { children, errorElement, resolve } = this.props;\n\n let promise: TrackedPromise | null = null;\n let status: AwaitRenderStatus = AwaitRenderStatus.pending;\n\n if (!(resolve instanceof Promise)) {\n // Didn't get a promise - provide as a resolved promise\n status = AwaitRenderStatus.success;\n promise = Promise.resolve();\n Object.defineProperty(promise, \"_tracked\", { get: () => true });\n Object.defineProperty(promise, \"_data\", { get: () => resolve });\n } else if (this.state.error) {\n // Caught a render error, provide it as a rejected promise\n status = AwaitRenderStatus.error;\n let renderError = this.state.error;\n promise = Promise.reject().catch(() => {}); // Avoid unhandled rejection warnings\n Object.defineProperty(promise, \"_tracked\", { get: () => true });\n Object.defineProperty(promise, \"_error\", { get: () => renderError });\n } else if ((resolve as TrackedPromise)._tracked) {\n // Already tracked promise - check contents\n promise = resolve;\n status =\n promise._error !== undefined\n ? AwaitRenderStatus.error\n : promise._data !== undefined\n ? AwaitRenderStatus.success\n : AwaitRenderStatus.pending;\n } else {\n // Raw (untracked) promise - track it\n status = AwaitRenderStatus.pending;\n Object.defineProperty(resolve, \"_tracked\", { get: () => true });\n promise = resolve.then(\n (data: any) =>\n Object.defineProperty(resolve, \"_data\", { get: () => data }),\n (error: any) =>\n Object.defineProperty(resolve, \"_error\", { get: () => error })\n );\n }\n\n if (\n status === AwaitRenderStatus.error &&\n promise._error instanceof AbortedDeferredError\n ) {\n // Freeze the UI by throwing a never resolved promise\n throw neverSettledPromise;\n }\n\n if (status === AwaitRenderStatus.error && !errorElement) {\n // No errorElement, throw to the nearest route-level error boundary\n throw promise._error;\n }\n\n if (status === AwaitRenderStatus.error) {\n // Render via our errorElement\n return <AwaitContext.Provider value={promise} children={errorElement} />;\n }\n\n if (status === AwaitRenderStatus.success) {\n // Render children with resolved value\n return <AwaitContext.Provider value={promise} children={children} />;\n }\n\n // Throw to the suspense boundary\n throw promise;\n }\n}\n\n/**\n * @private\n * Indirection to leverage useAsyncValue for a render-prop API on <Await>\n */\nfunction ResolveAwait({\n children,\n}: {\n children: React.ReactNode | AwaitResolveRenderFunction;\n}) {\n let data = useAsyncValue();\n let toRender = typeof children === \"function\" ? children(data) : children;\n return <>{toRender}</>;\n}\n\n///////////////////////////////////////////////////////////////////////////////\n// UTILS\n///////////////////////////////////////////////////////////////////////////////\n\n/**\n * Creates a route config from a React \"children\" object, which is usually\n * either a `<Route>` element or an array of them. Used internally by\n * `<Routes>` to create a route config from its children.\n *\n * @see https://reactrouter.com/utils/create-routes-from-children\n */\nexport function createRoutesFromChildren(\n children: React.ReactNode,\n parentPath: number[] = []\n): RouteObject[] {\n let routes: RouteObject[] = [];\n\n React.Children.forEach(children, (element, index) => {\n if (!React.isValidElement(element)) {\n // Ignore non-elements. This allows people to more easily inline\n // conditionals in their route config.\n return;\n }\n\n let treePath = [...parentPath, index];\n\n if (element.type === React.Fragment) {\n // Transparently support React.Fragment and its children.\n routes.push.apply(\n routes,\n createRoutesFromChildren(element.props.children, treePath)\n );\n return;\n }\n\n invariant(\n element.type === Route,\n `[${\n typeof element.type === \"string\" ? element.type : element.type.name\n }] is not a <Route> component. All component children of <Routes> must be a <Route> or <React.Fragment>`\n );\n\n invariant(\n !element.props.index || !element.props.children,\n \"An index route cannot have child routes.\"\n );\n\n let route: RouteObject = {\n id: element.props.id || treePath.join(\"-\"),\n caseSensitive: element.props.caseSensitive,\n element: element.props.element,\n Component: element.props.Component,\n index: element.props.index,\n path: element.props.path,\n loader: element.props.loader,\n action: element.props.action,\n errorElement: element.props.errorElement,\n ErrorBoundary: element.props.ErrorBoundary,\n hasErrorBoundary:\n element.props.ErrorBoundary != null ||\n element.props.errorElement != null,\n shouldRevalidate: element.props.shouldRevalidate,\n handle: element.props.handle,\n lazy: element.props.lazy,\n };\n\n if (element.props.children) {\n route.children = createRoutesFromChildren(\n element.props.children,\n treePath\n );\n }\n\n routes.push(route);\n });\n\n return routes;\n}\n\n/**\n * Renders the result of `matchRoutes()` into a React element.\n */\nexport function renderMatches(\n matches: RouteMatch[] | null\n): React.ReactElement | null {\n return _renderMatches(matches);\n}\n","import * as React from \"react\";\nimport type {\n ActionFunction,\n ActionFunctionArgs,\n Blocker,\n BlockerFunction,\n Fetcher,\n HydrationState,\n JsonFunction,\n LoaderFunction,\n LoaderFunctionArgs,\n Location,\n Navigation,\n Params,\n ParamParseKey,\n Path,\n PathMatch,\n PathPattern,\n RedirectFunction,\n RelativeRoutingType,\n Router as RemixRouter,\n ShouldRevalidateFunction,\n To,\n InitialEntry,\n LazyRouteFunction,\n FutureConfig,\n} from \"@remix-run/router\";\nimport {\n AbortedDeferredError,\n Action as NavigationType,\n createMemoryHistory,\n createPath,\n createRouter,\n defer,\n generatePath,\n isRouteErrorResponse,\n json,\n matchPath,\n matchRoutes,\n parsePath,\n redirect,\n resolvePath,\n UNSAFE_warning as warning,\n} from \"@remix-run/router\";\n\nimport type {\n AwaitProps,\n MemoryRouterProps,\n NavigateProps,\n OutletProps,\n RouteProps,\n PathRouteProps,\n LayoutRouteProps,\n IndexRouteProps,\n RouterProps,\n RoutesProps,\n RouterProviderProps,\n} from \"./lib/components\";\nimport {\n createRoutesFromChildren,\n renderMatches,\n Await,\n MemoryRouter,\n Navigate,\n Outlet,\n Route,\n Router,\n RouterProvider,\n Routes,\n} from \"./lib/components\";\nimport type {\n DataRouteMatch,\n DataRouteObject,\n IndexRouteObject,\n Navigator,\n NavigateOptions,\n NonIndexRouteObject,\n RouteMatch,\n RouteObject,\n} from \"./lib/context\";\nimport {\n DataRouterContext,\n DataRouterStateContext,\n LocationContext,\n NavigationContext,\n RouteContext,\n} from \"./lib/context\";\nimport type { NavigateFunction } from \"./lib/hooks\";\nimport {\n useBlocker,\n useHref,\n useInRouterContext,\n useLocation,\n useMatch,\n useNavigationType,\n useNavigate,\n useOutlet,\n useOutletContext,\n useParams,\n useResolvedPath,\n useRoutes,\n useActionData,\n useAsyncError,\n useAsyncValue,\n useRouteId,\n useLoaderData,\n useMatches,\n useNavigation,\n useRevalidator,\n useRouteError,\n useRouteLoaderData,\n useRoutesImpl,\n} from \"./lib/hooks\";\n\n// Exported for backwards compatibility, but not being used internally anymore\ntype Hash = string;\ntype Pathname = string;\ntype Search = string;\n\n// Expose react-router public API\nexport type {\n ActionFunction,\n ActionFunctionArgs,\n AwaitProps,\n Blocker as unstable_Blocker,\n BlockerFunction as unstable_BlockerFunction,\n DataRouteMatch,\n DataRouteObject,\n Fetcher,\n Hash,\n IndexRouteObject,\n IndexRouteProps,\n JsonFunction,\n LazyRouteFunction,\n LayoutRouteProps,\n LoaderFunction,\n LoaderFunctionArgs,\n Location,\n MemoryRouterProps,\n NavigateFunction,\n NavigateOptions,\n NavigateProps,\n Navigation,\n Navigator,\n NonIndexRouteObject,\n OutletProps,\n Params,\n ParamParseKey,\n Path,\n PathMatch,\n Pathname,\n PathPattern,\n PathRouteProps,\n RedirectFunction,\n RelativeRoutingType,\n RouteMatch,\n RouteObject,\n RouteProps,\n RouterProps,\n RouterProviderProps,\n RoutesProps,\n Search,\n ShouldRevalidateFunction,\n To,\n};\nexport {\n AbortedDeferredError,\n Await,\n MemoryRouter,\n Navigate,\n NavigationType,\n Outlet,\n Route,\n Router,\n RouterProvider,\n Routes,\n createPath,\n createRoutesFromChildren,\n createRoutesFromChildren as createRoutesFromElements,\n defer,\n isRouteErrorResponse,\n generatePath,\n json,\n matchPath,\n matchRoutes,\n parsePath,\n redirect,\n renderMatches,\n resolvePath,\n useActionData,\n useAsyncError,\n useAsyncValue,\n useBlocker as unstable_useBlocker,\n useHref,\n useInRouterContext,\n useLoaderData,\n useLocation,\n useMatch,\n useMatches,\n useNavigate,\n useNavigation,\n useNavigationType,\n useOutlet,\n useOutletContext,\n useParams,\n useResolvedPath,\n useRevalidator,\n useRouteError,\n useRouteLoaderData,\n useRoutes,\n};\n\nfunction mapRouteProperties(route: RouteObject) {\n let updates: Partial<RouteObject> & { hasErrorBoundary: boolean } = {\n // Note: this check also occurs in createRoutesFromChildren so update\n // there if you change this -- please and thank you!\n hasErrorBoundary: route.ErrorBoundary != null || route.errorElement != null,\n };\n\n if (route.Component) {\n if (__DEV__) {\n if (route.element) {\n warning(\n false,\n \"You should not include both `Component` and `element` on your route - \" +\n \"`Component` will be used.\"\n );\n }\n }\n Object.assign(updates, {\n element: React.createElement(route.Component),\n Component: undefined,\n });\n }\n\n if (route.ErrorBoundary) {\n if (__DEV__) {\n if (route.errorElement) {\n warning(\n false,\n \"You should not include both `ErrorBoundary` and `errorElement` on your route - \" +\n \"`ErrorBoundary` will be used.\"\n );\n }\n }\n Object.assign(updates, {\n errorElement: React.createElement(route.ErrorBoundary),\n ErrorBoundary: undefined,\n });\n }\n\n return updates;\n}\n\nexport function createMemoryRouter(\n routes: RouteObject[],\n opts?: {\n basename?: string;\n future?: Partial<Omit<FutureConfig, \"v7_prependBasename\">>;\n hydrationData?: HydrationState;\n initialEntries?: InitialEntry[];\n initialIndex?: number;\n }\n): RemixRouter {\n return createRouter({\n basename: opts?.basename,\n future: {\n ...opts?.future,\n v7_prependBasename: true,\n },\n history: createMemoryHistory({\n initialEntries: opts?.initialEntries,\n initialIndex: opts?.initialIndex,\n }),\n hydrationData: opts?.hydrationData,\n routes,\n mapRouteProperties,\n }).initialize();\n}\n\n///////////////////////////////////////////////////////////////////////////////\n// DANGER! PLEASE READ ME!\n// We provide these exports as an escape hatch in the event that you need any\n// routing data that we don't provide an explicit API for. With that said, we\n// want to cover your use case if we can, so if you feel the need to use these\n// we want to hear from you. Let us know what you're building and we'll do our\n// best to make sure we can support you!\n//\n// We consider these exports an implementation detail and do not guarantee\n// against any breaking changes, regardless of the semver release. Use with\n// extreme caution and only if you understand the consequences. Godspeed.\n///////////////////////////////////////////////////////////////////////////////\n\n/** @internal */\nexport {\n NavigationContext as UNSAFE_NavigationContext,\n LocationContext as UNSAFE_LocationContext,\n RouteContext as UNSAFE_RouteContext,\n DataRouterContext as UNSAFE_DataRouterContext,\n DataRouterStateContext as UNSAFE_DataRouterStateContext,\n mapRouteProperties as UNSAFE_mapRouteProperties,\n useRouteId as UNSAFE_useRouteId,\n useRoutesImpl as UNSAFE_useRoutesImpl,\n};\n"],"names":["DataRouterContext","React","createContext","DataRouterStateContext","AwaitContext","NavigationContext","LocationContext","RouteContext","outlet","matches","isDataRoute","RouteErrorContext","useInRouterContext","useContext","useLocation","invariant","location","useIsomorphicLayoutEffect","cb","static","useLayoutEffect","useNavigate","router","useDataRouterContext","DataRouterHook","UseNavigateStable","id","useCurrentRouteId","DataRouterStateHook","activeRef","useRef","current","useCallback","to","options","navigate","_extends","fromRouteId","useNavigateStable","dataRouterContext","basename","navigator","pathname","locationPathname","routePathnamesJson","JSON","stringify","getPathContributingMatches","map","match","pathnameBase","go","path","resolveTo","parse","relative","joinPaths","replace","push","state","useNavigateUnstable","OutletContext","useOutlet","context","createElement","Provider","value","useResolvedPath","_temp2","useMemo","useRoutes","routes","locationArg","useRoutesImpl","dataRouterState","parentMatches","routeMatch","length","parentParams","params","parentPathnameBase","route","locationFromContext","_parsedLocationArg$pa","parsedLocationArg","parsePath","startsWith","remainingPathname","slice","matchRoutes","renderedMatches","_renderMatches","Object","assign","encodeLocation","search","hash","key","navigationType","NavigationType","Action","Pop","DefaultErrorComponent","error","useRouteError","message","isRouteErrorResponse","status","statusText","Error","stack","preStyles","padding","backgroundColor","Fragment","style","fontStyle","defaultErrorElement","RenderErrorBoundary","Component","constructor","props","super","this","revalidation","componentDidCatch","errorInfo","console","render","routeContext","children","component","RenderedRoute","_ref","staticContext","errorElement","ErrorBoundary","_deepestRenderedBoundaryId","_dataRouterState2","_dataRouterState","errors","errorIndex","findIndex","m","UNSAFE_invariant","Math","min","reduceRight","index","concat","getChildren","element","hookName","ctx","useDataRouterState","useRouteContext","thisRoute","_state$errors","UseRouteError","routeId","useAsyncValue","_data","blockerId","DataRoutes","_ref2","undefined","Route","_props","Router","_ref5","basenameProp","locationProp","staticProp","navigationContext","locationContext","trailingPathname","stripBasename","AwaitRenderStatus","neverSettledPromise","Promise","AwaitErrorBoundary","resolve","promise","pending","renderError","reject","catch","defineProperty","get","_tracked","_error","success","then","data","AbortedDeferredError","ResolveAwait","_ref8","toRender","createRoutesFromChildren","parentPath","Children","forEach","isValidElement","treePath","type","apply","join","caseSensitive","loader","action","hasErrorBoundary","shouldRevalidate","handle","lazy","mapRouteProperties","updates","_ref7","_ref3","initialEntries","initialIndex","historyRef","createMemoryHistory","v5Compat","history","setState","useState","listen","_ref4","UNSAFE_getPathContributingMatches","jsonPath","useEffect","fallbackElement","subscribe","createHref","n","opts","preventScrollReset","historyAction","initialized","_ref6","UseRouteId","createRouter","future","v7_prependBasename","hydrationData","initialize","shouldBlock","UseBlocker","blockerKey","String","blockerFunction","args","blocker","getBlocker","deleteBlocker","blockers","UseActionData","values","actionData","_temp","joinedPathname","UseLoaderData","loaderData","pattern","matchPath","UseMatches","UseNavigation","navigation","UseRevalidator","revalidate","UseRouteLoaderData"],"mappings":";;;;;;;;;;q2BAyEO,MAAMA,EACXC,EAAMC,cAA8C,MAKzCC,EAAyBF,EAAMC,cAE1C,MAKWE,EAAeH,EAAMC,cAAqC,MAoC1DG,EAAoBJ,EAAMC,cACrC,MAYWI,EAAkBL,EAAMC,cACnC,MAaWK,EAAeN,EAAMC,cAAkC,CAClEM,OAAQ,KACRC,QAAS,GACTC,aAAa,IAOFC,EAAoBV,EAAMC,cAAmB,MC3EnD,SAASU,IACd,OAA4C,MAArCX,EAAMY,WAAWP,EACzB,CAYM,SAASQ,IAQd,OANEF,KADFG,EAAAA,kBAAA,GAOOd,EAAMY,WAAWP,GAAiBU,QAC1C,CAkDD,SAASC,EACPC,GAEejB,EAAMY,WAAWR,GAAmBc,QAKjDlB,EAAMmB,gBAAgBF,EAEzB,CAQM,SAASG,IACd,IAAIX,YAAEA,GAAgBT,EAAMY,WAAWN,GAGvC,OAAOG,EAkxBT,WACE,IAAIY,OAAEA,GAAWC,EAAqBC,EAAeC,mBACjDC,EAAKC,EAAkBC,EAAoBH,mBAE3CI,EAAY5B,EAAM6B,QAAO,GAsB7B,OArBAb,GAA0B,KACxBY,EAAUE,SAAU,CAApB,IAG+B9B,EAAM+B,aACrC,SAACC,EAAiBC,QAAkC,IAAlCA,IAAAA,EAA2B,CAAA,GAKtCL,EAAUE,UAEG,iBAAPE,EACTX,EAAOa,SAASF,GAEhBX,EAAOa,SAASF,EAAhBG,EAAA,CAAsBC,YAAaX,GAAOQ,IAE7C,GACD,CAACZ,EAAQI,GAIZ,CA7yBsBY,GAGvB,WAEI1B,KADFG,EAAAA,kBAAA,GAOA,IAAIwB,EAAoBtC,EAAMY,WAAWb,IACrCwC,SAAEA,EAAFC,UAAYA,GAAcxC,EAAMY,WAAWR,IAC3CI,QAAEA,GAAYR,EAAMY,WAAWN,IAC7BmC,SAAUC,GAAqB7B,IAEjC8B,EAAqBC,KAAKC,UAC5BC,oCAA2BtC,GAASuC,KAAKC,GAAUA,EAAMC,gBAGvDrB,EAAY5B,EAAM6B,QAAO,GAqD7B,OApDAb,GAA0B,KACxBY,EAAUE,SAAU,CAApB,IAG+B9B,EAAM+B,aACrC,SAACC,EAAiBC,GAKhB,QALkD,IAAlCA,IAAAA,EAA2B,CAAA,IAKtCL,EAAUE,QAAS,OAExB,GAAkB,iBAAPE,EAET,YADAQ,EAAUU,GAAGlB,GAIf,IAAImB,EAAOC,EAAAA,UACTpB,EACAY,KAAKS,MAAMV,GACXD,EACqB,SAArBT,EAAQqB,UASe,MAArBhB,GAA0C,MAAbC,IAC/BY,EAAKV,SACe,MAAlBU,EAAKV,SACDF,EACAgB,EAASA,UAAC,CAAChB,EAAUY,EAAKV,aAG/BR,EAAQuB,QAAUhB,EAAUgB,QAAUhB,EAAUiB,MACjDN,EACAlB,EAAQyB,MACRzB,EAEH,GACD,CACEM,EACAC,EACAG,EACAD,EACAJ,GAKL,CA1E4CqB,EAC5C,CA2ED,MAAMC,EAAgB5D,EAAMC,cAAuB,MAiB5C,SAAS4D,EAAUC,GACxB,IAAIvD,EAASP,EAAMY,WAAWN,GAAcC,OAC5C,OAAIA,EAEAP,EAAA+D,cAACH,EAAcI,SAAf,CAAwBC,MAAOH,GAAUvD,GAGtCA,CACR,CAuBM,SAAS2D,EACdlC,EAEMmC,GAAA,IADNb,SAAEA,cAAiD,CAAA,EAC7Ca,GACF3D,QAAEA,GAAYR,EAAMY,WAAWN,IAC7BmC,SAAUC,GAAqB7B,IAEjC8B,EAAqBC,KAAKC,UAC5BC,oCAA2BtC,GAASuC,KAAKC,GAAUA,EAAMC,gBAG3D,OAAOjD,EAAMoE,SACX,IACEhB,EAAAA,UACEpB,EACAY,KAAKS,MAAMV,GACXD,EACa,SAAbY,IAEJ,CAACtB,EAAIW,EAAoBD,EAAkBY,GAE9C,CAUM,SAASe,EACdC,EACAC,GAEA,OAAOC,EAAcF,EAAQC,EAC9B,CAGM,SAASC,EACdF,EACAC,EACAE,GAGE9D,KADFG,EAAAA,kBAAA,GAOA,IAAI0B,UAAEA,GAAcxC,EAAMY,WAAWR,IAC/BI,QAASkE,GAAkB1E,EAAMY,WAAWN,GAC9CqE,EAAaD,EAAcA,EAAcE,OAAS,GAClDC,EAAeF,EAAaA,EAAWG,OAAS,CAAA,GAC/BH,GAAaA,EAAWlC,SAC7C,IAAIsC,EAAqBJ,EAAaA,EAAW1B,aAAe,IAC9C0B,GAAcA,EAAWK,MAqC3C,IAEIjE,EAFAkE,EAAsBpE,IAG1B,GAAI0D,EAAa,CAAA,IAAAW,EACf,IAAIC,EACqB,iBAAhBZ,EAA2Ba,EAAAA,UAAUb,GAAeA,EAGpC,MAAvBQ,IACE,OAAAI,EAAAA,EAAkB1C,eAAlB,EAAAyC,EAA4BG,WAAWN,KAF3CjE,EAAAA,kBAAA,GASAC,EAAWoE,CACZ,MACCpE,EAAWkE,EAGb,IAAIxC,EAAW1B,EAAS0B,UAAY,IAChC6C,EACqB,MAAvBP,EACItC,EACAA,EAAS8C,MAAMR,EAAmBH,SAAW,IAE/CpE,EAAUgF,EAAWA,YAAClB,EAAQ,CAAE7B,SAAU6C,IAkB1CG,EAAkBC,EACpBlF,GACEA,EAAQuC,KAAKC,GACX2C,OAAOC,OAAO,CAAd,EAAkB5C,EAAO,CACvB8B,OAAQa,OAAOC,OAAO,CAAd,EAAkBf,EAAc7B,EAAM8B,QAC9CrC,SAAUc,EAASA,UAAC,CAClBwB,EAEAvC,EAAUqD,eACNrD,EAAUqD,eAAe7C,EAAMP,UAAUA,SACzCO,EAAMP,WAEZQ,aACyB,MAAvBD,EAAMC,aACF8B,EACAxB,EAASA,UAAC,CACRwB,EAEAvC,EAAUqD,eACNrD,EAAUqD,eAAe7C,EAAMC,cAAcR,SAC7CO,EAAMC,mBAIxByB,EACAD,GAMF,OAAIF,GAAekB,EAEfzF,EAAA+D,cAAC1D,EAAgB2D,SAAjB,CACEC,MAAO,CACLlD,SAAQoB,EAAA,CACNM,SAAU,IACVqD,OAAQ,GACRC,KAAM,GACNrC,MAAO,KACPsC,IAAK,WACFjF,GAELkF,eAAgBC,EAAcC,OAACC,MAGhCX,GAKAA,CACR,CAED,SAASY,IACP,IAAIC,EAAQC,IACRC,EAAUC,EAAAA,qBAAqBH,GAC5BA,EAAMI,OAAUJ,IAAAA,EAAMK,WACzBL,aAAiBM,MACjBN,EAAME,QACN5D,KAAKC,UAAUyD,GACfO,EAAQP,aAAiBM,MAAQN,EAAMO,MAAQ,KAE/CC,EAAY,CAAEC,QAAS,SAAUC,gBADrB,0BAuBhB,OACEhH,EAAA+D,cAAA/D,EAAAiH,SAAA,KACEjH,2DACAA,EAAA+D,cAAA,KAAA,CAAImD,MAAO,CAAEC,UAAW,WAAaX,GACpCK,EAAQ7G,EAAA+D,cAAA,MAAA,CAAKmD,MAAOJ,GAAYD,GAAe,KAvBtC,KA2Bf,CAED,MAAMO,EAAsBpH,EAAC+D,cAAAsC,EAA7B,MAgBO,MAAMgB,UAA4BrH,EAAMsH,UAI7CC,YAAYC,GACVC,MAAMD,GACNE,KAAKhE,MAAQ,CACX3C,SAAUyG,EAAMzG,SAChB4G,aAAcH,EAAMG,aACpBrB,MAAOkB,EAAMlB,MAEhB,CAE8BpF,gCAACoF,GAC9B,MAAO,CAAEA,MAAOA,EACjB,CAE8BpF,gCAC7BsG,EACA9D,GAUA,OACEA,EAAM3C,WAAayG,EAAMzG,UACD,SAAvB2C,EAAMiE,cAAkD,SAAvBH,EAAMG,aAEjC,CACLrB,MAAOkB,EAAMlB,MACbvF,SAAUyG,EAAMzG,SAChB4G,aAAcH,EAAMG,cAQjB,CACLrB,MAAOkB,EAAMlB,OAAS5C,EAAM4C,MAC5BvF,SAAU2C,EAAM3C,SAChB4G,aAAcH,EAAMG,cAAgBjE,EAAMiE,aAE7C,CAEDC,kBAAkBtB,EAAYuB,GAC5BC,QAAQxB,MACN,wDACAA,EACAuB,EAEH,CAEDE,SACE,OAAOL,KAAKhE,MAAM4C,MAChBtG,EAAC+D,cAAAzD,EAAa0D,SAAd,CAAuBC,MAAOyD,KAAKF,MAAMQ,cACvChI,EAAA+D,cAACrD,EAAkBsD,SAAnB,CACEC,MAAOyD,KAAKhE,MAAM4C,MAClB2B,SAAUP,KAAKF,MAAMU,aAIzBR,KAAKF,MAAMS,QAEd,EASH,SAASE,EAAqEC,GAAA,IAAvDJ,aAAEA,EAAFhF,MAAgBA,EAAhBiF,SAAuBA,GAAgCG,EACxE9F,EAAoBtC,EAAMY,WAAWb,GAazC,OAREuC,GACAA,EAAkBpB,QAClBoB,EAAkB+F,gBACjBrF,EAAMgC,MAAMsD,cAAgBtF,EAAMgC,MAAMuD,iBAEzCjG,EAAkB+F,cAAcG,2BAA6BxF,EAAMgC,MAAMvD,IAIzEzB,EAAA+D,cAACzD,EAAa0D,SAAd,CAAuBC,MAAO+D,GAC3BC,EAGN,CAEM,SAASvC,EACdlF,EACAkE,EACAD,GAC2B,IAAAgE,EAC3B,QAD2B,IAF3B/D,IAAAA,EAA8B,SAEH,IAD3BD,IAAAA,EAA+C,MAEhC,MAAXjE,EAAiB,CAAA,IAAAkI,EACnB,GAAA,OAAAA,EAAIjE,KAAAiE,EAAiBC,OAKnB,OAAO,KAFPnI,EAAUiE,EAAgBjE,OAI7B,CAED,IAAIiF,EAAkBjF,EAGlBmI,EAAM,OAAAF,EAAGhE,QAAH,EAAGgE,EAAiBE,OAC9B,GAAc,MAAVA,EAAgB,CAClB,IAAIC,EAAanD,EAAgBoD,WAC9BC,GAAMA,EAAE9D,MAAMvD,KAAMkH,MAAAA,OAAAA,EAAAA,EAASG,EAAE9D,MAAMvD,OAGtCmH,GAAc,GADhB9H,EAASiI,kBAAT,GAMAtD,EAAkBA,EAAgBF,MAChC,EACAyD,KAAKC,IAAIxD,EAAgBb,OAAQgE,EAAa,GAEjD,CAED,OAAOnD,EAAgByD,aAAY,CAAC3I,EAAQyC,EAAOmG,KACjD,IAAI7C,EAAQtD,EAAMgC,MAAMvD,GAAZ,MAAiBkH,OAAjB,EAAiBA,EAAS3F,EAAMgC,MAAMvD,IAAM,KAEpD6G,EAAuC,KACvC7D,IACF6D,EAAetF,EAAMgC,MAAMsD,cAAgBlB,GAE7C,IAAI5G,EAAUkE,EAAc0E,OAAO3D,EAAgBF,MAAM,EAAG4D,EAAQ,IAChEE,EAAc,KAChB,IAAIpB,EAgBJ,OAdEA,EADE3B,EACSgC,EACFtF,EAAMgC,MAAMsC,UAOVtH,EAAC+D,cAAAf,EAAMgC,MAAMsC,UAAxB,MACStE,EAAMgC,MAAMsE,QACVtG,EAAMgC,MAAMsE,QAEZ/I,EAGXP,gBAACmI,EAAD,CACEnF,MAAOA,EACPgF,aAAc,CACZzH,SACAC,UACAC,YAAgC,MAAnBgE,GAEfwD,SAAUA,GARd,EAeF,OAAOxD,IACJzB,EAAMgC,MAAMuD,eAAiBvF,EAAMgC,MAAMsD,cAA0B,IAAVa,GAC1DnJ,gBAACqH,EAAD,CACEtG,SAAU0D,EAAgB1D,SAC1B4G,aAAclD,EAAgBkD,aAC9BO,UAAWI,EACXhC,MAAOA,EACP2B,SAAUoB,IACVrB,aAAc,CAAEzH,OAAQ,KAAMC,UAASC,aAAa,KAGtD4I,GAXF,GAaC,KACJ,KAEI9H,EAMAI,EAmBL,SAASL,EAAqBiI,GAC5B,IAAIC,EAAMxJ,EAAMY,WAAWb,GAE3B,OADUyJ,GAAV1I,EAASiI,kBAAT,GACOS,CACR,CAED,SAASC,EAAmBF,GAC1B,IAAI7F,EAAQ1D,EAAMY,WAAWV,GAE7B,OADUwD,GAAV5C,EAASiI,kBAAT,GACOrF,CACR,CASD,SAAShC,EAAkB6H,GACzB,IAAIvE,EARN,SAAyBuE,GACvB,IAAIvE,EAAQhF,EAAMY,WAAWN,GAE7B,OADU0E,GAAVlE,EAASiI,kBAAT,GACO/D,CACR,CAIa0E,GACRC,EAAY3E,EAAMxE,QAAQwE,EAAMxE,QAAQoE,OAAS,GAKrD,OAHE+E,EAAU3E,MAAMvD,IADlBX,EAASiI,kBAAT,GAIOY,EAAU3E,MAAMvD,EACxB,CAmGM,SAAS8E,IAAyB,IAAAqD,EACvC,IAAItD,EAAQtG,EAAMY,WAAWF,GACzBgD,EAAQ+F,EAAmB9H,EAAoBkI,eAC/CC,EAAUpI,EAAkBC,EAAoBkI,eAIpD,OAAIvD,IAKG,OAAPsD,EAAOlG,EAAMiF,aAAN,EAAAiB,EAAeE,GACvB,CAKM,SAASC,IACd,IAAI9F,EAAQjE,EAAMY,WAAWT,GAC7B,OAAA,MAAO8D,OAAP,EAAOA,EAAO+F,KACf,WA5KIzI,GAAAA,0BAAAA,kCAAAA,iCAAAA,EAAAA,IAAAA,gBAMAI,GAAAA,0BAAAA,gCAAAA,gCAAAA,gCAAAA,gCAAAA,0CAAAA,0BAAAA,kCAAAA,kCAAAA,yBAAAA,EAAAA,IAAAA,OAgLL,IAAIsI,EAAY,EC9xBhB,SAASC,EAMqBC,GAAA,IANV7F,OAClBA,EADkBZ,MAElBA,GAI4ByG,EAC5B,OAAO3F,EAAcF,OAAQ8F,EAAW1G,EACzC,CAoKM,SAAS2G,EAAMC,GACpBxJ,EAASiI,kBAAT,EAKD,CAoBM,SAASwB,EAO2BC,GAAA,IANzCjI,SAAUkI,EAAe,IADJxC,SAErBA,EAAW,KACXlH,SAAU2J,EAHWzE,eAIrBA,EAAiBC,EAAcC,OAACC,IAJX5D,UAKrBA,EACAtB,OAAQyJ,GAAa,GACoBH,EAEtC7J,KADHG,EAAAA,kBAAA,GAQA,IAAIyB,EAAWkI,EAAajH,QAAQ,OAAQ,KACxCoH,EAAoB5K,EAAMoE,SAC5B,KAAO,CAAE7B,WAAUC,YAAWtB,OAAQyJ,KACtC,CAACpI,EAAUC,EAAWmI,IAGI,iBAAjBD,IACTA,EAAetF,EAAAA,UAAUsF,IAG3B,IAAIjI,SACFA,EAAW,IADTqD,OAEFA,EAAS,GAFPC,KAGFA,EAAO,GAHLrC,MAIFA,EAAQ,KAJNsC,IAKFA,EAAM,WACJ0E,EAEAG,EAAkB7K,EAAMoE,SAAQ,KAClC,IAAI0G,EAAmBC,EAAAA,cAActI,EAAUF,GAE/C,OAAwB,MAApBuI,EACK,KAGF,CACL/J,SAAU,CACR0B,SAAUqI,EACVhF,SACAC,OACArC,QACAsC,OAEFC,iBARF,GAUC,CAAC1D,EAAUE,EAAUqD,EAAQC,EAAMrC,EAAOsC,EAAKC,IASlD,OAAuB,MAAnB4E,EACK,KAIP7K,EAAA+D,cAAC3D,EAAkB4D,SAAnB,CAA4BC,MAAO2G,GACjC5K,EAAA+D,cAAC1D,EAAgB2D,SAAjB,CAA0BiE,SAAUA,EAAUhE,MAAO4G,IAG1D,KAmDIG,YAAAA,GAAAA,EAAAA,uBAAAA,EAAAA,uBAAAA,EAAAA,kBAAAA,EAAAA,IAAAA,OAML,MAAMC,EAAsB,IAAIC,SAAQ,SAExC,MAAMC,UAA2BnL,EAAMsH,UAIrCC,YAAYC,GACVC,MAAMD,GACNE,KAAKhE,MAAQ,CAAE4C,MAAO,KACvB,CAE8BpF,gCAACoF,GAC9B,MAAO,CAAEA,QACV,CAEDsB,kBAAkBtB,EAAYuB,GAC5BC,QAAQxB,MACN,mDACAA,EACAuB,EAEH,CAEDE,SACE,IAAIE,SAAEA,EAAFK,aAAYA,EAAZ8C,QAA0BA,GAAY1D,KAAKF,MAE3C6D,EAAiC,KACjC3E,EAA4BsE,EAAkBM,QAElD,GAAMF,aAAmBF,QAMlB,GAAIxD,KAAKhE,MAAM4C,MAAO,CAE3BI,EAASsE,EAAkB1E,MAC3B,IAAIiF,EAAc7D,KAAKhE,MAAM4C,MAC7B+E,EAAUH,QAAQM,SAASC,OAAM,SACjC9F,OAAO+F,eAAeL,EAAS,WAAY,CAAEM,IAAK,KAAM,IACxDhG,OAAO+F,eAAeL,EAAS,SAAU,CAAEM,IAAK,IAAMJ,GACvD,MAAWH,EAA2BQ,UAErCP,EAAUD,EACV1E,OACqB0D,IAAnBiB,EAAQQ,OACJb,EAAkB1E,WACA8D,IAAlBiB,EAAQrB,MACRgB,EAAkBc,QAClBd,EAAkBM,UAGxB5E,EAASsE,EAAkBM,QAC3B3F,OAAO+F,eAAeN,EAAS,WAAY,CAAEO,IAAK,KAAM,IACxDN,EAAUD,EAAQW,MACfC,GACCrG,OAAO+F,eAAeN,EAAS,QAAS,CAAEO,IAAK,IAAMK,MACtD1F,GACCX,OAAO+F,eAAeN,EAAS,SAAU,CAAEO,IAAK,IAAMrF,YA5B1DI,EAASsE,EAAkBc,QAC3BT,EAAUH,QAAQE,UAClBzF,OAAO+F,eAAeL,EAAS,WAAY,CAAEM,IAAK,KAAM,IACxDhG,OAAO+F,eAAeL,EAAS,QAAS,CAAEM,IAAK,IAAMP,IA6BvD,GACE1E,IAAWsE,EAAkB1E,OAC7B+E,EAAQQ,kBAAkBI,EAAAA,qBAG1B,MAAMhB,EAGR,GAAIvE,IAAWsE,EAAkB1E,QAAUgC,EAEzC,MAAM+C,EAAQQ,OAGhB,GAAInF,IAAWsE,EAAkB1E,MAE/B,OAAOtG,EAAA+D,cAAC5D,EAAa6D,SAAd,CAAuBC,MAAOoH,EAASpD,SAAUK,IAG1D,GAAI5B,IAAWsE,EAAkBc,QAE/B,OAAO9L,EAAA+D,cAAC5D,EAAa6D,SAAd,CAAuBC,MAAOoH,EAASpD,SAAUA,IAI1D,MAAMoD,CACP,EAOH,SAASa,EAINC,GAAA,IAJmBlE,SACpBA,GAGCkE,EACGH,EAAOjC,IACPqC,EAA+B,mBAAbnE,EAA0BA,EAAS+D,GAAQ/D,EACjE,OAAOjI,EAAA+D,cAAA/D,EAAAiH,SAAA,KAAGmF,EACX,CAaM,SAASC,EACdpE,EACAqE,QACe,IADfA,IAAAA,EAAuB,IAEvB,IAAIhI,EAAwB,GA6D5B,OA3DAtE,EAAMuM,SAASC,QAAQvE,GAAU,CAACqB,EAASH,KACzC,IAAKnJ,EAAMyM,eAAenD,GAGxB,OAGF,IAAIoD,EAAW,IAAIJ,EAAYnD,GAE/B,GAAIG,EAAQqD,OAAS3M,EAAMiH,SAMzB,YAJA3C,EAAOb,KAAKmJ,MACVtI,EACA+H,EAAyB/C,EAAQ9B,MAAMS,SAAUyE,IAMnDpD,EAAQqD,OAAStC,GADnBvJ,EAAAA,kBAAA,GAQGwI,EAAQ9B,MAAM2B,OAAUG,EAAQ9B,MAAMS,UADzCnH,EAASiI,kBAAT,GAKA,IAAI/D,EAAqB,CACvBvD,GAAI6H,EAAQ9B,MAAM/F,IAAMiL,EAASG,KAAK,KACtCC,cAAexD,EAAQ9B,MAAMsF,cAC7BxD,QAASA,EAAQ9B,MAAM8B,QACvBhC,UAAWgC,EAAQ9B,MAAMF,UACzB6B,MAAOG,EAAQ9B,MAAM2B,MACrBhG,KAAMmG,EAAQ9B,MAAMrE,KACpB4J,OAAQzD,EAAQ9B,MAAMuF,OACtBC,OAAQ1D,EAAQ9B,MAAMwF,OACtB1E,aAAcgB,EAAQ9B,MAAMc,aAC5BC,cAAee,EAAQ9B,MAAMe,cAC7B0E,iBACiC,MAA/B3D,EAAQ9B,MAAMe,eACgB,MAA9Be,EAAQ9B,MAAMc,aAChB4E,iBAAkB5D,EAAQ9B,MAAM0F,iBAChCC,OAAQ7D,EAAQ9B,MAAM2F,OACtBC,KAAM9D,EAAQ9B,MAAM4F,MAGlB9D,EAAQ9B,MAAMS,WAChBjD,EAAMiD,SAAWoE,EACf/C,EAAQ9B,MAAMS,SACdyE,IAIJpI,EAAOb,KAAKuB,EAAZ,IAGKV,CACR,CCtaD,SAAS+I,EAAmBrI,GAC1B,IAAIsI,EAAgE,CAGlEL,iBAAyC,MAAvBjI,EAAMuD,eAA+C,MAAtBvD,EAAMsD,cAmCzD,OAhCItD,EAAMsC,WAUR3B,OAAOC,OAAO0H,EAAS,CACrBhE,QAAStJ,EAAM+D,cAAciB,EAAMsC,WACnCA,eAAW8C,IAIXpF,EAAMuD,eAUR5C,OAAOC,OAAO0H,EAAS,CACrBhF,aAActI,EAAM+D,cAAciB,EAAMuD,eACxCA,mBAAe6B,IAIZkD,CACR,mlCDiLM,SAAgEC,GAAA,IAAjDtF,SAAEA,EAAFK,aAAYA,EAAZ8C,QAA0BA,GAAuBmC,EACrE,OACEvN,gBAACmL,EAAD,CAAoBC,QAASA,EAAS9C,aAAcA,GAClDtI,EAAC+D,cAAAmI,EAAcjE,KAAAA,GAGpB,iBA7RM,SAKmCuF,GAAA,IALbjL,SAC3BA,EAD2B0F,SAE3BA,EAF2BwF,eAG3BA,EAH2BC,aAI3BA,GACwCF,EACpCG,EAAa3N,EAAM6B,SACG,MAAtB8L,EAAW7L,UACb6L,EAAW7L,QAAU8L,sBAAoB,CACvCH,iBACAC,eACAG,UAAU,KAId,IAAIC,EAAUH,EAAW7L,SACpB4B,EAAOqK,GAAY/N,EAAMgO,SAAS,CACrChB,OAAQc,EAAQd,OAChBjM,SAAU+M,EAAQ/M,WAKpB,OAFAf,EAAMmB,iBAAgB,IAAM2M,EAAQG,OAAOF,IAAW,CAACD,IAGrD9N,gBAACuK,EAAD,CACEhI,SAAUA,EACV0F,SAAUA,EACVlH,SAAU2C,EAAM3C,SAChBkF,eAAgBvC,EAAMsJ,OACtBxK,UAAWsL,GAGhB,aAkBM,SAKiBI,GAAA,IALClM,GACvBA,EADuBwB,QAEvBA,EAFuBE,MAGvBA,EAHuBJ,SAIvBA,GACsB4K,EAEpBvN,KADFG,EAAAA,kBAAA,GAcA,IAAIN,QAAEA,GAAYR,EAAMY,WAAWN,IAC7BmC,SAAUC,GAAqB7B,IACjCqB,EAAWd,IAIX+B,EAAOC,EAASA,UAClBpB,EACAc,EAA0BqL,kCAAC3N,GAASuC,KAAKC,GAAUA,EAAMC,eACzDP,EACa,SAAbY,GAEE8K,EAAWxL,KAAKC,UAAUM,GAO9B,OALAnD,EAAMqO,WACJ,IAAMnM,EAASU,KAAKS,MAAM+K,GAAW,CAAE5K,UAASE,QAAOJ,cACvD,CAACpB,EAAUkM,EAAU9K,EAAUE,EAASE,IAGnC,IACR,WAWM,SAAgB8D,GACrB,OAAO3D,EAAU2D,EAAM1D,QACxB,wCAlMM,SAGqCsE,GAAA,IAHbkG,gBAC7BA,EAD6BjN,OAE7BA,GAC0C+G,GAGrC1E,EAAOqK,GAAY/N,EAAMgO,SAAS3M,EAAOqC,OAC9C1D,EAAMmB,iBAAgB,IAAME,EAAOkN,UAAUR,IAAW,CAAC1M,EAAQ0M,IAEjE,IAAIvL,EAAYxC,EAAMoE,SAAQ,KACrB,CACLoK,WAAYnN,EAAOmN,WACnB3I,eAAgBxE,EAAOwE,eACvB3C,GAAKuL,GAAMpN,EAAOa,SAASuM,GAC3BhL,KAAM,CAACzB,EAAI0B,EAAOgL,IAChBrN,EAAOa,SAASF,EAAI,CAClB0B,QACAiL,mBAAoBD,MAAAA,OAAAA,EAAAA,EAAMC,qBAE9BnL,QAAS,CAACxB,EAAI0B,EAAOgL,IACnBrN,EAAOa,SAASF,EAAI,CAClBwB,SAAS,EACTE,QACAiL,mBAAoBD,MAAAA,OAAAA,EAAAA,EAAMC,wBAG/B,CAACtN,IAEAkB,EAAWlB,EAAOkB,UAAY,IAE9BD,EAAoBtC,EAAMoE,SAC5B,KAAO,CACL/C,SACAmB,YACAtB,QAAQ,EACRqB,cAEF,CAAClB,EAAQmB,EAAWD,IAStB,OACEvC,EACE+D,cAAA/D,EAAAiH,SAAA,KAAAjH,EAAA+D,cAAChE,EAAkBiE,SAAnB,CAA4BC,MAAO3B,GACjCtC,EAAA+D,cAAC7D,EAAuB8D,SAAxB,CAAiCC,MAAOP,GACtC1D,gBAACuK,EAAD,CACEhI,SAAUlB,EAAOkB,SACjBxB,SAAUM,EAAOqC,MAAM3C,SACvBkF,eAAgB5E,EAAOqC,MAAMkL,cAC7BpM,UAAWA,GAEVnB,EAAOqC,MAAMmL,YACZ7O,gBAACkK,EAAD,CAAY5F,OAAQjD,EAAOiD,OAAQZ,MAAOA,IAE1C4K,KAKP,KAGN,WA0RM,SAGoCQ,GAAA,IAHpB7G,SACrBA,EADqBlH,SAErBA,GACyC+N,EACzC,OAAOzK,EAAUgI,EAAyBpE,GAAWlH,EACtD,mMDoYM,WACL,OAAOW,EAAkBC,EAAoBoN,WAC9C,gDEriBM,SACLzK,EACAoK,GAQA,OAAOM,eAAa,CAClBzM,SAAUmM,MAAAA,OAAAA,EAAAA,EAAMnM,SAChB0M,OACKP,EAAAA,CAAAA,EAAAA,MAAAA,OAAAA,EAAAA,EAAMO,OADL,CAEJC,oBAAoB,IAEtBpB,QAASF,EAAAA,oBAAoB,CAC3BH,eAAgBiB,MAAAA,OAAAA,EAAAA,EAAMjB,eACtBC,aAAcgB,MAAAA,OAAAA,EAAAA,EAAMhB,eAEtByB,cAAeT,MAAAA,OAAAA,EAAAA,EAAMS,cACrB7K,SACA+I,uBACC+B,YACJ,4EDyWM,SACL5O,GAEA,OAAOkF,EAAelF,EACvB,wBDmSM,SAAoB6O,GACzB,IAAIhO,OAAEA,GAAWC,EAAqBC,EAAe+N,YACjD5L,EAAQ+F,EAAmB9H,EAAoB2N,aAC9CC,GAAcvP,EAAMgO,UAAS,IAAMwB,SAASvF,KAE7CwF,EAAkBzP,EAAM+B,aACzB2N,GAC+B,mBAAhBL,IACRA,EAAYK,KACZL,GAER,CAACA,IAGCM,EAAUtO,EAAOuO,WAAWL,EAAYE,GAU5C,OAPAzP,EAAMqO,WACJ,IAAM,IAAMhN,EAAOwO,cAAcN,IACjC,CAAClO,EAAQkO,IAKJ7L,EAAMoM,SAASnE,IAAI4D,IAAeI,CAC1C,kBA9EM,WACL,IAAIjM,EAAQ+F,EAAmB9H,EAAoBoO,eAKnD,OAHY/P,EAAMY,WAAWN,IAC7BQ,EAASiI,kBAAT,GAEOpD,OAAOqK,QAAY,MAALtM,OAAAA,EAAAA,EAAOuM,aAAc,IAAI,EAC/C,kBAiCM,WACL,IAAIhM,EAAQjE,EAAMY,WAAWT,GAC7B,OAAA,MAAO8D,OAAP,EAAOA,EAAO4H,MACf,8BAz2BM,SACL7J,EAEQkO,GAAA,IADR5M,SAAEA,cAAiD,CAAA,EAC3C4M,EAENvP,KADFG,EAAAA,kBAAA,GAOA,IAAIyB,SAAEA,EAAFC,UAAYA,GAAcxC,EAAMY,WAAWR,IAC3C2F,KAAEA,EAAFtD,SAAQA,EAARqD,OAAkBA,GAAW5B,EAAgBlC,EAAI,CAAEsB,aAEnD6M,EAAiB1N,EAWrB,MALiB,MAAbF,IACF4N,EACe,MAAb1N,EAAmBF,EAAWgB,EAASA,UAAC,CAAChB,EAAUE,KAGhDD,EAAUgM,WAAW,CAAE/L,SAAU0N,EAAgBrK,SAAQC,QACjE,yCA4wBM,WACL,IAAIrC,EAAQ+F,EAAmB9H,EAAoByO,eAC/CtG,EAAUpI,EAAkBC,EAAoByO,eAEpD,IAAI1M,EAAMiF,QAAmC,MAAzBjF,EAAMiF,OAAOmB,GAMjC,OAAOpG,EAAM2M,WAAWvG,GALtBhC,QAAQxB,MAAR,2DAC+DwD,EAD/D,IAMH,6BAtuBM,SAGLwG,GAEE3P,KADFG,EAAAA,kBAAA,GAOA,IAAI2B,SAAEA,GAAa5B,IACnB,OAAOb,EAAMoE,SACX,IAAMmM,YAA0BD,EAAS7N,IACzC,CAACA,EAAU6N,GAEd,eAirBM,WACL,IAAI9P,QAAEA,EAAF6P,WAAWA,GAAe5G,EAC5B9H,EAAoB6O,YAEtB,OAAOxQ,EAAMoE,SACX,IACE5D,EAAQuC,KAAKC,IACX,IAAIP,SAAEA,EAAFqC,OAAYA,GAAW9B,EAI3B,MAAO,CACLvB,GAAIuB,EAAMgC,MAAMvD,GAChBgB,WACAqC,SACAkH,KAAMqE,EAAWrN,EAAMgC,MAAMvD,IAC7B0L,OAAQnK,EAAMgC,MAAMmI,OALtB,KAQJ,CAAC3M,EAAS6P,GAEb,kCA3CM,WAEL,OADY5G,EAAmB9H,EAAoB8O,eACtCC,UACd,sBAzrBM,WACL,OAAO1Q,EAAMY,WAAWP,GAAiB4F,cAC1C,mCAiJM,WACL,OAAOjG,EAAMY,WAAWgD,EACzB,cAwBM,WAKL,IAAIpD,QAAEA,GAAYR,EAAMY,WAAWN,GAC/BqE,EAAanE,EAAQA,EAAQoE,OAAS,GAC1C,OAAOD,EAAcA,EAAWG,OAAiB,EAClD,uCA0gBM,WACL,IAAIxC,EAAoBhB,EAAqBC,EAAeoP,gBACxDjN,EAAQ+F,EAAmB9H,EAAoBgP,gBACnD,MAAO,CACLC,WAAYtO,EAAkBjB,OAAOuP,WACrClN,MAAOA,EAAMiE,aAEhB,yCAgDM,SAA4BmC,GAEjC,OADYL,EAAmB9H,EAAoBkP,oBACtCR,WAAWvG,EACzB"} |