| 1 | {"version":3,"file":"react-router.production.min.js","sources":["../../../../packages/react-router/index.tsx"],"sourcesContent":["import * as React from \"react\";\nimport type {\n History,\n InitialEntry,\n Location,\n MemoryHistory,\n Path,\n To\n} from \"history\";\nimport {\n Action as NavigationType,\n createMemoryHistory,\n parsePath\n} from \"history\";\n\nexport type { Location, Path, To, NavigationType };\n\nfunction invariant(cond: any, message: string): asserts cond {\n if (!cond) throw new Error(message);\n}\n\nfunction warning(cond: any, message: string): void {\n if (!cond) {\n // eslint-disable-next-line no-console\n if (typeof console !== \"undefined\") console.warn(message);\n\n try {\n // Welcome to debugging React Router!\n //\n // This error is thrown as a convenience so you can more easily\n // find the source for a warning that appears in the console by\n // enabling \"pause on exceptions\" in your JavaScript debugger.\n throw new Error(message);\n // eslint-disable-next-line no-empty\n } catch (e) {}\n }\n}\n\nconst alreadyWarned: Record<string, boolean> = {};\nfunction warningOnce(key: string, cond: boolean, message: string) {\n if (!cond && !alreadyWarned[key]) {\n alreadyWarned[key] = true;\n warning(false, message);\n }\n}\n\n///////////////////////////////////////////////////////////////////////////////\n// CONTEXT\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 type Navigator = Pick<History, \"go\" | \"push\" | \"replace\" | \"createHref\">;\n\ninterface NavigationContextObject {\n basename: string;\n navigator: Navigator;\n static: boolean;\n}\n\nconst NavigationContext = React.createContext<NavigationContextObject>(null!);\n\nif (__DEV__) {\n NavigationContext.displayName = \"Navigation\";\n}\n\ninterface LocationContextObject {\n location: Location;\n navigationType: NavigationType;\n}\n\nconst LocationContext = React.createContext<LocationContextObject>(null!);\n\nif (__DEV__) {\n LocationContext.displayName = \"Location\";\n}\n\ninterface RouteContextObject {\n outlet: React.ReactElement | null;\n matches: RouteMatch[];\n}\n\nconst RouteContext = React.createContext<RouteContextObject>({\n outlet: null,\n matches: []\n});\n\nif (__DEV__) {\n RouteContext.displayName = \"Route\";\n}\n\n///////////////////////////////////////////////////////////////////////////////\n// COMPONENTS\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/docs/en/v6/api#memoryrouter\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({ initialEntries, initialIndex });\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}\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/docs/en/v6/api#navigate\n */\nexport function Navigate({ to, replace, state }: 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 navigate = useNavigate();\n React.useEffect(() => {\n navigate(to, { 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/docs/en/v6/api#outlet\n */\nexport function Outlet(props: OutletProps): React.ReactElement | null {\n return useOutlet(props.context);\n}\n\nexport interface RouteProps {\n caseSensitive?: boolean;\n children?: React.ReactNode;\n element?: React.ReactNode | null;\n index?: boolean;\n path?: string;\n}\n\nexport interface PathRouteProps {\n caseSensitive?: boolean;\n children?: React.ReactNode;\n element?: React.ReactNode | null;\n index?: false;\n path: string;\n}\n\nexport interface LayoutRouteProps {\n children?: React.ReactNode;\n element?: React.ReactNode | null;\n}\n\nexport interface IndexRouteProps {\n element?: React.ReactNode | null;\n index: true;\n}\n\n/**\n * Declares an element that should be rendered at a certain URL path.\n *\n * @see https://reactrouter.com/docs/en/v6/api#route\n */\nexport function Route(\n _props: PathRouteProps | LayoutRouteProps | IndexRouteProps\n): 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/docs/en/v6/api#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 let basename = normalizePathname(basenameProp);\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 location = React.useMemo(() => {\n let trailingPathname = stripBasename(pathname, basename);\n\n if (trailingPathname == null) {\n return null;\n }\n\n return {\n pathname: trailingPathname,\n search,\n hash,\n state,\n key\n };\n }, [basename, pathname, search, hash, state, key]);\n\n warning(\n location != 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 (location == null) {\n return null;\n }\n\n return (\n <NavigationContext.Provider value={navigationContext}>\n <LocationContext.Provider\n children={children}\n value={{ location, navigationType }}\n />\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/docs/en/v6/api#routes\n */\nexport function Routes({\n children,\n location\n}: RoutesProps): React.ReactElement | null {\n return useRoutes(createRoutesFromChildren(children), location);\n}\n\n///////////////////////////////////////////////////////////////////////////////\n// HOOKS\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/docs/en/v6/api#usehref\n */\nexport function useHref(to: To): 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);\n\n let joinedPathname = pathname;\n if (basename !== \"/\") {\n let toPathname = getToPathname(to);\n let endsWithSlash = toPathname != null && toPathname.endsWith(\"/\");\n joinedPathname =\n pathname === \"/\"\n ? basename + (endsWithSlash ? \"/\" : \"\")\n : 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/docs/en/v6/api#useinroutercontext\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/docs/en/v6/api#uselocation\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\ntype ParamParseFailed = { failed: true };\n\ntype ParamParseSegment<Segment extends string> =\n // Check here if there exists a forward slash in the string.\n Segment extends `${infer LeftSegment}/${infer RightSegment}`\n ? // If there is a forward slash, then attempt to parse each side of the\n // forward slash.\n ParamParseSegment<LeftSegment> extends infer LeftResult\n ? ParamParseSegment<RightSegment> extends infer RightResult\n ? LeftResult extends string\n ? // If the left side is successfully parsed as a param, then check if\n // the right side can be successfully parsed as well. If both sides\n // can be parsed, then the result is a union of the two sides\n // (read: \"foo\" | \"bar\").\n RightResult extends string\n ? LeftResult | RightResult\n : LeftResult\n : // If the left side is not successfully parsed as a param, then check\n // if only the right side can be successfully parse as a param. If it\n // can, then the result is just right, else it's a failure.\n RightResult extends string\n ? RightResult\n : ParamParseFailed\n : ParamParseFailed\n : // If the left side didn't parse into a param, then just check the right\n // side.\n ParamParseSegment<RightSegment> extends infer RightResult\n ? RightResult extends string\n ? RightResult\n : ParamParseFailed\n : ParamParseFailed\n : // If there's no forward slash, then check if this segment starts with a\n // colon. If it does, then this is a dynamic segment, so the result is\n // just the remainder of the string. Otherwise, it's a failure.\n Segment extends `:${infer Remaining}`\n ? Remaining\n : ParamParseFailed;\n\n// Attempt to parse the given string segment. If it fails, then just return the\n// plain string type as a default fallback. Otherwise return the union of the\n// parsed string literals that were referenced as dynamic segments in the route.\ntype ParamParseKey<Segment extends string> =\n ParamParseSegment<Segment> extends string\n ? ParamParseSegment<Segment>\n : string;\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/docs/en/v6/api#usenavigationtype\n */\nexport function useNavigationType(): NavigationType {\n return React.useContext(LocationContext).navigationType;\n}\n\n/**\n * Returns true if the URL for the given \"to\" value 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/docs/en/v6/api#usematch\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\nexport interface NavigateOptions {\n replace?: boolean;\n state?: any;\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/docs/en/v6/api#usenavigate\n */\nexport function useNavigate(): 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 { basename, navigator } = React.useContext(NavigationContext);\n let { matches } = React.useContext(RouteContext);\n let { pathname: locationPathname } = useLocation();\n\n let routePathnamesJson = JSON.stringify(\n matches.map(match => match.pathnameBase)\n );\n\n let activeRef = React.useRef(false);\n React.useEffect(() => {\n activeRef.current = true;\n });\n\n let navigate: NavigateFunction = React.useCallback(\n (to: To | number, options: NavigateOptions = {}) => {\n warning(\n activeRef.current,\n `You should call navigate() in a React.useEffect(), not when ` +\n `your component is first rendered.`\n );\n\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 );\n\n if (basename !== \"/\") {\n path.pathname = joinPaths([basename, path.pathname]);\n }\n\n (!!options.replace ? navigator.replace : navigator.push)(\n path,\n options.state\n );\n },\n [basename, navigator, routePathnamesJson, locationPathname]\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/docs/en/v6/api#useoutletcontext\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/docs/en/v6/api#useoutlet\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/docs/en/v6/api#useparams\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/docs/en/v6/api#useresolvedpath\n */\nexport function useResolvedPath(to: To): Path {\n let { matches } = React.useContext(RouteContext);\n let { pathname: locationPathname } = useLocation();\n\n let routePathnamesJson = JSON.stringify(\n matches.map(match => match.pathnameBase)\n );\n\n return React.useMemo(\n () => resolveTo(to, JSON.parse(routePathnamesJson), locationPathname),\n [to, routePathnamesJson, locationPathname]\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/docs/en/v6/api#useroutes\n */\nexport function useRoutes(\n routes: RouteObject[],\n locationArg?: Partial<Location> | string\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 { 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 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 `Matched leaf route at location \"${location.pathname}${location.search}${location.hash}\" does not have an element. ` +\n `This means it will render an <Outlet /> with a null value by default resulting in an \"empty\" page.`\n );\n }\n\n return _renderMatches(\n matches &&\n matches.map(match =>\n Object.assign({}, match, {\n params: Object.assign({}, parentParams, match.params),\n pathname: joinPaths([parentPathnameBase, match.pathname]),\n pathnameBase:\n match.pathnameBase === \"/\"\n ? parentPathnameBase\n : joinPaths([parentPathnameBase, match.pathnameBase])\n })\n ),\n parentMatches\n );\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/docs/en/v6/api#createroutesfromchildren\n */\nexport function createRoutesFromChildren(\n children: React.ReactNode\n): RouteObject[] {\n let routes: RouteObject[] = [];\n\n React.Children.forEach(children, element => {\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 if (element.type === React.Fragment) {\n // Transparently support React.Fragment and its children.\n routes.push.apply(\n routes,\n createRoutesFromChildren(element.props.children)\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 let route: RouteObject = {\n caseSensitive: element.props.caseSensitive,\n element: element.props.element,\n index: element.props.index,\n path: element.props.path\n };\n\n if (element.props.children) {\n route.children = createRoutesFromChildren(element.props.children);\n }\n\n routes.push(route);\n });\n\n return routes;\n}\n\n/**\n * The parameters that were parsed from the URL path.\n */\nexport type Params<Key extends string = string> = {\n readonly [key in Key]: string | undefined;\n};\n\n/**\n * A route object represents a logical route, with (optionally) its child\n * routes organized in a tree-like structure.\n */\nexport interface RouteObject {\n caseSensitive?: boolean;\n children?: RouteObject[];\n element?: React.ReactNode;\n index?: boolean;\n path?: string;\n}\n\n/**\n * Returns a path with params interpolated.\n *\n * @see https://reactrouter.com/docs/en/v6/api#generatepath\n */\nexport function generatePath(path: string, params: Params = {}): string {\n return path\n .replace(/:(\\w+)/g, (_, key) => {\n invariant(params[key] != null, `Missing \":${key}\" param`);\n return params[key]!;\n })\n .replace(/\\/*\\*$/, _ =>\n params[\"*\"] == null ? \"\" : params[\"*\"].replace(/^\\/*/, \"/\")\n );\n}\n\n/**\n * A RouteMatch contains info about how a route matched a URL.\n */\nexport interface RouteMatch<ParamKey extends string = string> {\n /**\n * The names and values of dynamic parameters in the URL.\n */\n params: Params<ParamKey>;\n /**\n * The portion of the URL pathname that was matched.\n */\n pathname: string;\n /**\n * The portion of the URL pathname that was matched before child routes.\n */\n pathnameBase: string;\n /**\n * The route object that was used to match.\n */\n route: RouteObject;\n}\n\n/**\n * Matches the given routes to a location and returns the match data.\n *\n * @see https://reactrouter.com/docs/en/v6/api#matchroutes\n */\nexport function matchRoutes(\n routes: RouteObject[],\n locationArg: Partial<Location> | string,\n basename = \"/\"\n): RouteMatch[] | null {\n let location =\n typeof locationArg === \"string\" ? parsePath(locationArg) : locationArg;\n\n let pathname = stripBasename(location.pathname || \"/\", basename);\n\n if (pathname == null) {\n return null;\n }\n\n let branches = flattenRoutes(routes);\n rankRouteBranches(branches);\n\n let matches = null;\n for (let i = 0; matches == null && i < branches.length; ++i) {\n matches = matchRouteBranch(branches[i], pathname);\n }\n\n return matches;\n}\n\ninterface RouteMeta {\n relativePath: string;\n caseSensitive: boolean;\n childrenIndex: number;\n route: RouteObject;\n}\n\ninterface RouteBranch {\n path: string;\n score: number;\n routesMeta: RouteMeta[];\n}\n\nfunction flattenRoutes(\n routes: RouteObject[],\n branches: RouteBranch[] = [],\n parentsMeta: RouteMeta[] = [],\n parentPath = \"\"\n): RouteBranch[] {\n routes.forEach((route, index) => {\n let meta: RouteMeta = {\n relativePath: route.path || \"\",\n caseSensitive: route.caseSensitive === true,\n childrenIndex: index,\n route\n };\n\n if (meta.relativePath.startsWith(\"/\")) {\n invariant(\n meta.relativePath.startsWith(parentPath),\n `Absolute route path \"${meta.relativePath}\" nested under path ` +\n `\"${parentPath}\" is not valid. An absolute child route path ` +\n `must start with the combined path of all its parent routes.`\n );\n\n meta.relativePath = meta.relativePath.slice(parentPath.length);\n }\n\n let path = joinPaths([parentPath, meta.relativePath]);\n let routesMeta = parentsMeta.concat(meta);\n\n // Add the children before adding this route to the array so we traverse the\n // route tree depth-first and child routes appear before their parents in\n // the \"flattened\" version.\n if (route.children && route.children.length > 0) {\n invariant(\n route.index !== true,\n `Index routes must not have child routes. Please remove ` +\n `all child routes from route path \"${path}\".`\n );\n\n flattenRoutes(route.children, branches, routesMeta, path);\n }\n\n // Routes without a path shouldn't ever match by themselves unless they are\n // index routes, so don't add them to the list of possible branches.\n if (route.path == null && !route.index) {\n return;\n }\n\n branches.push({ path, score: computeScore(path, route.index), routesMeta });\n });\n\n return branches;\n}\n\nfunction rankRouteBranches(branches: RouteBranch[]): void {\n branches.sort((a, b) =>\n a.score !== b.score\n ? b.score - a.score // Higher score first\n : compareIndexes(\n a.routesMeta.map(meta => meta.childrenIndex),\n b.routesMeta.map(meta => meta.childrenIndex)\n )\n );\n}\n\nconst paramRe = /^:\\w+$/;\nconst dynamicSegmentValue = 3;\nconst indexRouteValue = 2;\nconst emptySegmentValue = 1;\nconst staticSegmentValue = 10;\nconst splatPenalty = -2;\nconst isSplat = (s: string) => s === \"*\";\n\nfunction computeScore(path: string, index: boolean | undefined): number {\n let segments = path.split(\"/\");\n let initialScore = segments.length;\n if (segments.some(isSplat)) {\n initialScore += splatPenalty;\n }\n\n if (index) {\n initialScore += indexRouteValue;\n }\n\n return segments\n .filter(s => !isSplat(s))\n .reduce(\n (score, segment) =>\n score +\n (paramRe.test(segment)\n ? dynamicSegmentValue\n : segment === \"\"\n ? emptySegmentValue\n : staticSegmentValue),\n initialScore\n );\n}\n\nfunction compareIndexes(a: number[], b: number[]): number {\n let siblings =\n a.length === b.length && a.slice(0, -1).every((n, i) => n === b[i]);\n\n return siblings\n ? // If two routes are siblings, we should try to match the earlier sibling\n // first. This allows people to have fine-grained control over the matching\n // behavior by simply putting routes with identical paths in the order they\n // want them tried.\n a[a.length - 1] - b[b.length - 1]\n : // Otherwise, it doesn't really make sense to rank non-siblings by index,\n // so they sort equally.\n 0;\n}\n\nfunction matchRouteBranch<ParamKey extends string = string>(\n branch: RouteBranch,\n pathname: string\n): RouteMatch<ParamKey>[] | null {\n let { routesMeta } = branch;\n\n let matchedParams = {};\n let matchedPathname = \"/\";\n let matches: RouteMatch[] = [];\n for (let i = 0; i < routesMeta.length; ++i) {\n let meta = routesMeta[i];\n let end = i === routesMeta.length - 1;\n let remainingPathname =\n matchedPathname === \"/\"\n ? pathname\n : pathname.slice(matchedPathname.length) || \"/\";\n let match = matchPath(\n { path: meta.relativePath, caseSensitive: meta.caseSensitive, end },\n remainingPathname\n );\n\n if (!match) return null;\n\n Object.assign(matchedParams, match.params);\n\n let route = meta.route;\n\n matches.push({\n params: matchedParams,\n pathname: joinPaths([matchedPathname, match.pathname]),\n pathnameBase: joinPaths([matchedPathname, match.pathnameBase]),\n route\n });\n\n if (match.pathnameBase !== \"/\") {\n matchedPathname = joinPaths([matchedPathname, match.pathnameBase]);\n }\n }\n\n return matches;\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\nfunction _renderMatches(\n matches: RouteMatch[] | null,\n parentMatches: RouteMatch[] = []\n): React.ReactElement | null {\n if (matches == null) return null;\n\n return matches.reduceRight((outlet, match, index) => {\n return (\n <RouteContext.Provider\n children={\n match.route.element !== undefined ? match.route.element : <Outlet />\n }\n value={{\n outlet,\n matches: parentMatches.concat(matches.slice(0, index + 1))\n }}\n />\n );\n }, null as React.ReactElement | null);\n}\n\n/**\n * A PathPattern is used to match on some portion of a URL pathname.\n */\nexport interface PathPattern<Path extends string = string> {\n /**\n * A string to match against a URL pathname. May contain `:id`-style segments\n * to indicate placeholders for dynamic parameters. May also end with `/*` to\n * indicate matching the rest of the URL pathname.\n */\n path: Path;\n /**\n * Should be `true` if the static portions of the `path` should be matched in\n * the same case.\n */\n caseSensitive?: boolean;\n /**\n * Should be `true` if this pattern should match the entire URL pathname.\n */\n end?: boolean;\n}\n\n/**\n * A PathMatch contains info about how a PathPattern matched on a URL pathname.\n */\nexport interface PathMatch<ParamKey extends string = string> {\n /**\n * The names and values of dynamic parameters in the URL.\n */\n params: Params<ParamKey>;\n /**\n * The portion of the URL pathname that was matched.\n */\n pathname: string;\n /**\n * The portion of the URL pathname that was matched before child routes.\n */\n pathnameBase: string;\n /**\n * The pattern that was used to match.\n */\n pattern: PathPattern;\n}\n\ntype Mutable<T> = {\n -readonly [P in keyof T]: T[P];\n};\n\n/**\n * Performs pattern matching on a URL pathname and returns information about\n * the match.\n *\n * @see https://reactrouter.com/docs/en/v6/api#matchpath\n */\nexport function matchPath<\n ParamKey extends ParamParseKey<Path>,\n Path extends string\n>(\n pattern: PathPattern<Path> | Path,\n pathname: string\n): PathMatch<ParamKey> | null {\n if (typeof pattern === \"string\") {\n pattern = { path: pattern, caseSensitive: false, end: true };\n }\n\n let [matcher, paramNames] = compilePath(\n pattern.path,\n pattern.caseSensitive,\n pattern.end\n );\n\n let match = pathname.match(matcher);\n if (!match) return null;\n\n let matchedPathname = match[0];\n let pathnameBase = matchedPathname.replace(/(.)\\/+$/, \"$1\");\n let captureGroups = match.slice(1);\n let params: Params = paramNames.reduce<Mutable<Params>>(\n (memo, paramName, index) => {\n // We need to compute the pathnameBase here using the raw splat value\n // instead of using params[\"*\"] later because it will be decoded then\n if (paramName === \"*\") {\n let splatValue = captureGroups[index] || \"\";\n pathnameBase = matchedPathname\n .slice(0, matchedPathname.length - splatValue.length)\n .replace(/(.)\\/+$/, \"$1\");\n }\n\n memo[paramName] = safelyDecodeURIComponent(\n captureGroups[index] || \"\",\n paramName\n );\n return memo;\n },\n {}\n );\n\n return {\n params,\n pathname: matchedPathname,\n pathnameBase,\n pattern\n };\n}\n\nfunction compilePath(\n path: string,\n caseSensitive = false,\n end = true\n): [RegExp, string[]] {\n warning(\n path === \"*\" || !path.endsWith(\"*\") || path.endsWith(\"/*\"),\n `Route path \"${path}\" will be treated as if it were ` +\n `\"${path.replace(/\\*$/, \"/*\")}\" because the \\`*\\` character must ` +\n `always follow a \\`/\\` in the pattern. To get rid of this warning, ` +\n `please change the route path to \"${path.replace(/\\*$/, \"/*\")}\".`\n );\n\n let paramNames: string[] = [];\n let regexpSource =\n \"^\" +\n path\n .replace(/\\/*\\*?$/, \"\") // Ignore trailing / and /*, we'll handle it below\n .replace(/^\\/*/, \"/\") // Make sure it has a leading /\n .replace(/[\\\\.*+^$?{}|()[\\]]/g, \"\\\\$&\") // Escape special regex chars\n .replace(/:(\\w+)/g, (_: string, paramName: string) => {\n paramNames.push(paramName);\n return \"([^\\\\/]+)\";\n });\n\n if (path.endsWith(\"*\")) {\n paramNames.push(\"*\");\n regexpSource +=\n path === \"*\" || path === \"/*\"\n ? \"(.*)$\" // Already matched the initial /, just match the rest\n : \"(?:\\\\/(.+)|\\\\/*)$\"; // Don't include the / in params[\"*\"]\n } else {\n regexpSource += end\n ? \"\\\\/*$\" // When matching to the end, ignore trailing slashes\n : // Otherwise, match a word boundary or a proceeding /. The word boundary restricts\n // parent routes to matching only their own words and nothing more, e.g. parent\n // route \"/home\" should not match \"/home2\".\n \"(?:\\\\b|\\\\/|$)\";\n }\n\n let matcher = new RegExp(regexpSource, caseSensitive ? undefined : \"i\");\n\n return [matcher, paramNames];\n}\n\nfunction safelyDecodeURIComponent(value: string, paramName: string) {\n try {\n return decodeURIComponent(value);\n } catch (error) {\n warning(\n false,\n `The value for the URL param \"${paramName}\" will not be decoded because` +\n ` the string \"${value}\" is a malformed URL segment. This is probably` +\n ` due to a bad percent encoding (${error}).`\n );\n\n return value;\n }\n}\n\n/**\n * Returns a resolved path object relative to the given pathname.\n *\n * @see https://reactrouter.com/docs/en/v6/api#resolvepath\n */\nexport function resolvePath(to: To, fromPathname = \"/\"): Path {\n let {\n pathname: toPathname,\n search = \"\",\n hash = \"\"\n } = typeof to === \"string\" ? parsePath(to) : to;\n\n let pathname = toPathname\n ? toPathname.startsWith(\"/\")\n ? toPathname\n : resolvePathname(toPathname, fromPathname)\n : fromPathname;\n\n return {\n pathname,\n search: normalizeSearch(search),\n hash: normalizeHash(hash)\n };\n}\n\nfunction resolvePathname(relativePath: string, fromPathname: string): string {\n let segments = fromPathname.replace(/\\/+$/, \"\").split(\"/\");\n let relativeSegments = relativePath.split(\"/\");\n\n relativeSegments.forEach(segment => {\n if (segment === \"..\") {\n // Keep the root \"\" segment so the pathname starts at /\n if (segments.length > 1) segments.pop();\n } else if (segment !== \".\") {\n segments.push(segment);\n }\n });\n\n return segments.length > 1 ? segments.join(\"/\") : \"/\";\n}\n\nfunction resolveTo(\n toArg: To,\n routePathnames: string[],\n locationPathname: string\n): Path {\n let to = typeof toArg === \"string\" ? parsePath(toArg) : toArg;\n let toPathname = toArg === \"\" || to.pathname === \"\" ? \"/\" : to.pathname;\n\n // If a pathname is explicitly provided in `to`, it should be relative to the\n // route context. This is explained in `Note on `<Link to>` values` in our\n // migration guide from v5 as a means of disambiguation between `to` values\n // that begin with `/` and those that do not. However, this is problematic for\n // `to` values that do not provide a pathname. `to` can simply be a search or\n // hash string, in which case we should assume that the navigation is relative\n // to the current location's pathname and *not* the route pathname.\n let from: string;\n if (toPathname == null) {\n from = locationPathname;\n } else {\n let routePathnameIndex = routePathnames.length - 1;\n\n if (toPathname.startsWith(\"..\")) {\n let toSegments = toPathname.split(\"/\");\n\n // Each leading .. segment means \"go up one route\" instead of \"go up one\n // URL segment\". This is a key difference from how <a href> works and a\n // major reason we call this a \"to\" value instead of a \"href\".\n while (toSegments[0] === \"..\") {\n toSegments.shift();\n routePathnameIndex -= 1;\n }\n\n to.pathname = toSegments.join(\"/\");\n }\n\n // If there are more \"..\" segments than parent routes, resolve relative to\n // the root / URL.\n from = routePathnameIndex >= 0 ? routePathnames[routePathnameIndex] : \"/\";\n }\n\n let path = resolvePath(to, from);\n\n // Ensure the pathname has a trailing slash if the original to value had one.\n if (\n toPathname &&\n toPathname !== \"/\" &&\n toPathname.endsWith(\"/\") &&\n !path.pathname.endsWith(\"/\")\n ) {\n path.pathname += \"/\";\n }\n\n return path;\n}\n\nfunction getToPathname(to: To): string | undefined {\n // Empty strings should be treated the same as / paths\n return to === \"\" || (to as Path).pathname === \"\"\n ? \"/\"\n : typeof to === \"string\"\n ? parsePath(to).pathname\n : to.pathname;\n}\n\nfunction stripBasename(pathname: string, basename: string): string | null {\n if (basename === \"/\") return pathname;\n\n if (!pathname.toLowerCase().startsWith(basename.toLowerCase())) {\n return null;\n }\n\n let nextChar = pathname.charAt(basename.length);\n if (nextChar && nextChar !== \"/\") {\n // pathname does not start with basename/\n return null;\n }\n\n return pathname.slice(basename.length) || \"/\";\n}\n\nconst joinPaths = (paths: string[]): string =>\n paths.join(\"/\").replace(/\\/\\/+/g, \"/\");\n\nconst normalizePathname = (pathname: string): string =>\n pathname.replace(/\\/+$/, \"\").replace(/^\\/*/, \"/\");\n\nconst normalizeSearch = (search: string): string =>\n !search || search === \"?\"\n ? \"\"\n : search.startsWith(\"?\")\n ? search\n : \"?\" + search;\n\nconst normalizeHash = (hash: string): string =>\n !hash || hash === \"#\" ? \"\" : hash.startsWith(\"#\") ? hash : \"#\" + hash;\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};\n"],"names":["invariant","cond","message","Error","NavigationContext","React","LocationContext","RouteContext","outlet","matches","Outlet","props","useOutlet","context","Route","_props","Router","basename","basenameProp","children","location","locationProp","navigationType","NavigationType","Pop","navigator","static","staticProp","useInRouterContext","normalizePathname","navigationContext","parsePath","pathname","search","hash","state","key","trailingPathname","stripBasename","React.createElement","Provider","value","useLocation","useNavigate","locationPathname","routePathnamesJson","JSON","stringify","map","match","pathnameBase","activeRef","current","to","options","go","path","resolveTo","parse","joinPaths","replace","push","OutletContext","useResolvedPath","useRoutes","routes","locationArg","parentMatches","routeMatch","length","parentParams","params","parentPathnameBase","locationFromContext","route","parsedLocationArg","_parsedLocationArg$pa","startsWith","matchRoutes","slice","_renderMatches","Object","assign","createRoutesFromChildren","forEach","element","type","apply","caseSensitive","index","branches","flattenRoutes","sort","a","b","score","every","n","i","compareIndexes","routesMeta","meta","childrenIndex","rankRouteBranches","matchRouteBranch","parentsMeta","parentPath","relativePath","concat","computeScore","paramRe","isSplat","s","segments","split","initialScore","some","filter","reduce","segment","test","branch","matchedParams","matchedPathname","end","remainingPathname","matchPath","reduceRight","undefined","pattern","matcher","paramNames","regexpSource","_","paramName","endsWith","RegExp","compilePath","captureGroups","memo","splatValue","decodeURIComponent","error","safelyDecodeURIComponent","resolvePath","fromPathname","toPathname","pop","join","resolvePathname","normalizeSearch","normalizeHash","toArg","routePathnames","from","routePathnameIndex","toSegments","shift","toLowerCase","nextChar","charAt","paths","initialEntries","initialIndex","historyRef","createMemoryHistory","history","setState","action","listen","navigate","joinedPathname","getToPathname","endsWithSlash","createHref"],"mappings":";;;;;;;;;;4RAiBA,SAASA,EAAUC,EAAWC,OACvBD,EAAM,MAAM,IAAIE,MAAMD,SAiDvBE,EAAoBC,gBAA6C,MAWjEC,EAAkBD,gBAA2C,MAW7DE,EAAeF,gBAAwC,CAC3DG,OAAQ,KACRC,QAAS,KAoGJ,SAASC,EAAOC,UACdC,EAAUD,EAAME,SAkClB,SAASC,EACdC,GAEAf,MAyBK,SAASgB,SACdC,SAAUC,EAAe,IADJC,SAErBA,EAAW,KACXC,SAAUC,EAHWC,eAIrBA,EAAiBC,SAAeC,IAJXC,UAKrBA,EACAC,OAAQC,GAAa,KAGlBC,KADH5B,UAMIiB,EAAWY,EAAkBX,GAC7BY,EAAoBzB,WACtB,MAASY,SAAAA,EAAUQ,UAAAA,EAAWC,OAAQC,KACtC,CAACV,EAAUQ,EAAWE,IAGI,iBAAjBN,IACTA,EAAeU,YAAUV,QAGvBW,SACFA,EAAW,IADTC,OAEFA,EAAS,GAFPC,KAGFA,EAAO,GAHLC,MAIFA,EAAQ,KAJNC,IAKFA,EAAM,WACJf,EAEAD,EAAWf,WAAc,SACvBgC,EAAmBC,EAAcN,EAAUf,UAEvB,MAApBoB,EACK,KAGF,CACLL,SAAUK,EACVJ,OAAAA,EACAC,KAAAA,EACAC,MAAAA,EACAC,IAAAA,KAED,CAACnB,EAAUe,EAAUC,EAAQC,EAAMC,EAAOC,WAS7B,MAAZhB,EACK,KAIPmB,gBAACnC,EAAkBoC,UAASC,MAAOX,GACjCS,gBAACjC,EAAgBkC,UACfrB,SAAUA,EACVsB,MAAO,CAAErB,SAAAA,EAAUE,eAAAA,MA+DpB,SAASM,WAC8B,MAArCvB,aAAiBC,GAanB,SAASoC,WAEZd,KADF5B,MAOOK,aAAiBC,GAAiBc,SAuGpC,SAASuB,IAEZf,KADF5B,UAOIiB,SAAEA,EAAFQ,UAAYA,GAAcpB,aAAiBD,IAC3CK,QAAEA,GAAYJ,aAAiBE,IAC7ByB,SAAUY,GAAqBF,IAEjCG,EAAqBC,KAAKC,UAC5BtC,EAAQuC,KAAIC,GAASA,EAAMC,gBAGzBC,EAAY9C,UAAa,UAC7BA,aAAgB,KACd8C,EAAUC,SAAU,KAGW/C,eAC/B,SAACgD,EAAiBC,eAAAA,IAAAA,EAA2B,KAOtCH,EAAUC,QAAS,UAEN,iBAAPC,cACT5B,EAAU8B,GAAGF,OAIXG,EAAOC,EACTJ,EACAP,KAAKY,MAAMb,GACXD,GAGe,MAAb3B,IACFuC,EAAKxB,SAAW2B,EAAU,CAAC1C,EAAUuC,EAAKxB,aAGzCsB,EAAQM,QAAUnC,EAAUmC,QAAUnC,EAAUoC,MACjDL,EACAF,EAAQnB,SAGZ,CAAClB,EAAUQ,EAAWoB,EAAoBD,IAM9C,MAAMkB,EAAgBzD,gBAA6B,MAiB5C,SAASO,EAAUC,OACpBL,EAASH,aAAiBE,GAAcC,cACxCA,EAEA+B,gBAACuB,EAActB,UAASC,MAAO5B,GAAUL,GAGtCA,EAwBF,SAASuD,EAAgBV,OAC1B5C,QAAEA,GAAYJ,aAAiBE,IAC7ByB,SAAUY,GAAqBF,IAEjCG,EAAqBC,KAAKC,UAC5BtC,EAAQuC,KAAIC,GAASA,EAAMC,uBAGtB7C,WACL,IAAMoD,EAAUJ,EAAIP,KAAKY,MAAMb,GAAqBD,IACpD,CAACS,EAAIR,EAAoBD,IAYtB,SAASoB,EACdC,EACAC,GAGEtC,KADF5B,UAmDIoB,GA5CEX,QAAS0D,GAAkB9D,aAAiBE,GAC9C6D,EAAaD,EAAcA,EAAcE,OAAS,GAClDC,EAAeF,EAAaA,EAAWG,OAAS,GAEhDC,GADiBJ,GAAaA,EAAWpC,SACpBoC,EAAaA,EAAWlB,aAAe,KAsC5DuB,GArCcL,GAAcA,EAAWM,MAqCjBhC,QAGtBwB,EAAa,WACXS,EACqB,iBAAhBT,EAA2BnC,YAAUmC,GAAeA,EAGpC,MAAvBM,aACEG,EAAkB3C,iBAAlB4C,EAA4BC,WAAWL,KAF3CxE,MASAoB,EAAWuD,OAEXvD,EAAWqD,MAGTzC,EAAWZ,EAASY,UAAY,IAKhCvB,EAAUqE,EAAYb,EAAQ,CAAEjC,SAHX,MAAvBwC,EACIxC,EACAA,EAAS+C,MAAMP,EAAmBH,SAAW,aAiB5CW,EACLvE,GACEA,EAAQuC,KAAIC,GACVgC,OAAOC,OAAO,GAAIjC,EAAO,CACvBsB,OAAQU,OAAOC,OAAO,GAAIZ,EAAcrB,EAAMsB,QAC9CvC,SAAU2B,EAAU,CAACa,EAAoBvB,EAAMjB,WAC/CkB,aACyB,MAAvBD,EAAMC,aACFsB,EACAb,EAAU,CAACa,EAAoBvB,EAAMC,mBAGjDiB,GAeG,SAASgB,EACdhE,OAEI8C,EAAwB,UAE5B5D,WAAe+E,QAAQjE,GAAUkE,QAC1BhF,iBAAqBgF,aAMtBA,EAAQC,OAASjF,uBAEnB4D,EAAOJ,KAAK0B,MACVtB,EACAkB,EAAyBE,EAAQ1E,MAAMQ,WAMzCkE,EAAQC,OAASxE,GADnBd,UAOI0E,EAAqB,CACvBc,cAAeH,EAAQ1E,MAAM6E,cAC7BH,QAASA,EAAQ1E,MAAM0E,QACvBI,MAAOJ,EAAQ1E,MAAM8E,MACrBjC,KAAM6B,EAAQ1E,MAAM6C,MAGlB6B,EAAQ1E,MAAMQ,WAChBuD,EAAMvD,SAAWgE,EAAyBE,EAAQ1E,MAAMQ,WAG1D8C,EAAOJ,KAAKa,MAGPT,EAiEF,SAASa,EACdb,EACAC,EACAjD,YAAAA,IAAAA,EAAW,SAKPe,EAAWM,GAFU,iBAAhB4B,EAA2BnC,YAAUmC,GAAeA,GAEvBlC,UAAY,IAAKf,MAEvC,MAAZe,SACK,SAGL0D,EAAWC,EAAc1B,IA6E/B,SAA2ByB,GACzBA,EAASE,MAAK,CAACC,EAAGC,IAChBD,EAAEE,QAAUD,EAAEC,MACVD,EAAEC,MAAQF,EAAEE,MAyCpB,SAAwBF,EAAaC,UAEjCD,EAAExB,SAAWyB,EAAEzB,QAAUwB,EAAEd,MAAM,GAAI,GAAGiB,OAAM,CAACC,EAAGC,IAAMD,IAAMH,EAAEI,KAO9DL,EAAEA,EAAExB,OAAS,GAAKyB,EAAEA,EAAEzB,OAAS,KAjD7B8B,CACEN,EAAEO,WAAWpD,KAAIqD,GAAQA,EAAKC,gBAC9BR,EAAEM,WAAWpD,KAAIqD,GAAQA,EAAKC,mBAlFtCC,CAAkBb,OAEdjF,EAAU,SACT,IAAIyF,EAAI,EAAc,MAAXzF,GAAmByF,EAAIR,EAASrB,SAAU6B,EACxDzF,EAAU+F,EAAiBd,EAASQ,GAAIlE,UAGnCvB,EAgBT,SAASkF,EACP1B,EACAyB,EACAe,EACAC,mBAFAhB,IAAAA,EAA0B,aAC1Be,IAAAA,EAA2B,aAC3BC,IAAAA,EAAa,IAEbzC,EAAOmB,SAAQ,CAACV,EAAOe,SACjBY,EAAkB,CACpBM,aAAcjC,EAAMlB,MAAQ,GAC5BgC,eAAuC,IAAxBd,EAAMc,cACrBc,cAAeb,EACff,MAAAA,GAGE2B,EAAKM,aAAa9B,WAAW,OAE7BwB,EAAKM,aAAa9B,WAAW6B,IAD/B1G,MAOAqG,EAAKM,aAAeN,EAAKM,aAAa5B,MAAM2B,EAAWrC,aAGrDb,EAAOG,EAAU,CAAC+C,EAAYL,EAAKM,eACnCP,EAAaK,EAAYG,OAAOP,GAKhC3B,EAAMvD,UAAYuD,EAAMvD,SAASkD,OAAS,KAE1B,IAAhBK,EAAMe,OADRzF,MAMA2F,EAAcjB,EAAMvD,SAAUuE,EAAUU,EAAY5C,KAKpC,MAAdkB,EAAMlB,MAAiBkB,EAAMe,QAIjCC,EAAS7B,KAAK,CAAEL,KAAAA,EAAMuC,MAAOc,EAAarD,EAAMkB,EAAMe,OAAQW,WAAAA,OAGzDV,EAcT,MAAMoB,EAAU,SAMVC,EAAWC,GAAoB,MAANA,EAE/B,SAASH,EAAarD,EAAciC,OAC9BwB,EAAWzD,EAAK0D,MAAM,KACtBC,EAAeF,EAAS5C,cACxB4C,EAASG,KAAKL,KAChBI,IAPiB,GAUf1B,IACF0B,GAdoB,GAiBfF,EACJI,QAAOL,IAAMD,EAAQC,KACrBM,QACC,CAACvB,EAAOwB,IACNxB,GACCe,EAAQU,KAAKD,GAvBM,EAyBJ,KAAZA,EAvBc,EACC,KAyBrBJ,GAmBN,SAASX,EACPiB,EACAzF,OAEIoE,WAAEA,GAAeqB,EAEjBC,EAAgB,GAChBC,EAAkB,IAClBlH,EAAwB,OACvB,IAAIyF,EAAI,EAAGA,EAAIE,EAAW/B,SAAU6B,EAAG,KACtCG,EAAOD,EAAWF,GAClB0B,EAAM1B,IAAME,EAAW/B,OAAS,EAChCwD,EACkB,MAApBF,EACI3F,EACAA,EAAS+C,MAAM4C,EAAgBtD,SAAW,IAC5CpB,EAAQ6E,EACV,CAAEtE,KAAM6C,EAAKM,aAAcnB,cAAea,EAAKb,cAAeoC,IAAAA,GAC9DC,OAGG5E,EAAO,OAAO,KAEnBgC,OAAOC,OAAOwC,EAAezE,EAAMsB,YAE/BG,EAAQ2B,EAAK3B,MAEjBjE,EAAQoD,KAAK,CACXU,OAAQmD,EACR1F,SAAU2B,EAAU,CAACgE,EAAiB1E,EAAMjB,WAC5CkB,aAAcS,EAAU,CAACgE,EAAiB1E,EAAMC,eAChDwB,MAAAA,IAGyB,MAAvBzB,EAAMC,eACRyE,EAAkBhE,EAAU,CAACgE,EAAiB1E,EAAMC,uBAIjDzC,EAYT,SAASuE,EACPvE,EACA0D,mBAAAA,IAAAA,EAA8B,IAEf,MAAX1D,EAAwB,KAErBA,EAAQsH,aAAY,CAACvH,EAAQyC,EAAOwC,IAEvClD,gBAAChC,EAAaiC,UACZrB,cAC0B6G,IAAxB/E,EAAMyB,MAAMW,QAAwBpC,EAAMyB,MAAMW,QAAU9C,gBAAC7B,QAE7D+B,MAAO,CACLjC,OAAAA,EACAC,QAAS0D,EAAcyC,OAAOnG,EAAQsE,MAAM,EAAGU,EAAQ,QAI5D,MAwDE,SAASqC,EAIdG,EACAjG,GAEuB,iBAAZiG,IACTA,EAAU,CAAEzE,KAAMyE,EAASzC,eAAe,EAAOoC,KAAK,QAGnDM,EAASC,GAwChB,SACE3E,EACAgC,EACAoC,YADApC,IAAAA,GAAgB,YAChBoC,IAAAA,GAAM,OAUFO,EAAuB,GACvBC,EACF,IACA5E,EACGI,QAAQ,UAAW,IACnBA,QAAQ,OAAQ,KAChBA,QAAQ,sBAAuB,QAC/BA,QAAQ,WAAW,CAACyE,EAAWC,KAC9BH,EAAWtE,KAAKyE,GACT,eAGT9E,EAAK+E,SAAS,MAChBJ,EAAWtE,KAAK,KAChBuE,GACW,MAAT5E,GAAyB,OAATA,EACZ,QACA,qBAEN4E,GAAgBR,EACZ,8BASC,CAFO,IAAIY,OAAOJ,EAAc5C,OAAgBwC,EAAY,KAElDG,GAlFWM,CAC1BR,EAAQzE,KACRyE,EAAQzC,cACRyC,EAAQL,KAGN3E,EAAQjB,EAASiB,MAAMiF,OACtBjF,EAAO,OAAO,SAEf0E,EAAkB1E,EAAM,GACxBC,EAAeyE,EAAgB/D,QAAQ,UAAW,MAClD8E,EAAgBzF,EAAM8B,MAAM,SAqBzB,CACLR,OArBmB4D,EAAWb,QAC9B,CAACqB,EAAML,EAAW7C,QAGE,MAAd6C,EAAmB,KACjBM,EAAaF,EAAcjD,IAAU,GACzCvC,EAAeyE,EACZ5C,MAAM,EAAG4C,EAAgBtD,OAASuE,EAAWvE,QAC7CT,QAAQ,UAAW,aAGxB+E,EAAKL,GA8DX,SAAkC7F,EAAe6F,cAEtCO,mBAAmBpG,GAC1B,MAAOqG,UAQArG,GAzEasG,CAChBL,EAAcjD,IAAU,IAGnBkD,IAET,IAKA3G,SAAU2F,EACVzE,aAAAA,EACA+E,QAAAA,GAqEG,SAASe,EAAY3F,EAAQ4F,YAAAA,IAAAA,EAAe,SAE/CjH,SAAUkH,EADRjH,OAEFA,EAAS,GAFPC,KAGFA,EAAO,IACS,iBAAPmB,EAAkBtB,YAAUsB,GAAMA,EAEzCrB,EAAWkH,EACXA,EAAWrE,WAAW,KACpBqE,EAWR,SAAyBvC,EAAsBsC,OACzChC,EAAWgC,EAAarF,QAAQ,OAAQ,IAAIsD,MAAM,YAC/BP,EAAaO,MAAM,KAEzB9B,SAAQmC,IACP,OAAZA,EAEEN,EAAS5C,OAAS,GAAG4C,EAASkC,MACb,MAAZ5B,GACTN,EAASpD,KAAK0D,MAIXN,EAAS5C,OAAS,EAAI4C,EAASmC,KAAK,KAAO,IAvB5CC,CAAgBH,EAAYD,GAC9BA,QAEG,CACLjH,SAAAA,EACAC,OAAQqH,EAAgBrH,GACxBC,KAAMqH,EAAcrH,IAoBxB,SAASuB,EACP+F,EACAC,EACA7G,OAYI8G,EAVArG,EAAsB,iBAAVmG,EAAqBzH,YAAUyH,GAASA,EACpDN,EAAuB,KAAVM,GAAgC,KAAhBnG,EAAGrB,SAAkB,IAAMqB,EAAGrB,YAU7C,MAAdkH,EACFQ,EAAO9G,MACF,KACD+G,EAAqBF,EAAepF,OAAS,KAE7C6E,EAAWrE,WAAW,MAAO,KAC3B+E,EAAaV,EAAWhC,MAAM,UAKT,OAAlB0C,EAAW,IAChBA,EAAWC,QACXF,GAAsB,EAGxBtG,EAAGrB,SAAW4H,EAAWR,KAAK,KAKhCM,EAAOC,GAAsB,EAAIF,EAAeE,GAAsB,QAGpEnG,EAAOwF,EAAY3F,EAAIqG,UAIzBR,GACe,MAAfA,GACAA,EAAWX,SAAS,OACnB/E,EAAKxB,SAASuG,SAAS,OAExB/E,EAAKxB,UAAY,KAGZwB,EAYT,SAASlB,EAAcN,EAAkBf,MACtB,MAAbA,EAAkB,OAAOe,MAExBA,EAAS8H,cAAcjF,WAAW5D,EAAS6I,sBACvC,SAGLC,EAAW/H,EAASgI,OAAO/I,EAASoD,eACpC0F,GAAyB,MAAbA,EAEP,KAGF/H,EAAS+C,MAAM9D,EAASoD,SAAW,IAG5C,MAAMV,EAAasG,GACjBA,EAAMb,KAAK,KAAKxF,QAAQ,SAAU,KAE9B/B,EAAqBG,GACzBA,EAAS4B,QAAQ,OAAQ,IAAIA,QAAQ,OAAQ,KAEzC0F,EAAmBrH,GACtBA,GAAqB,MAAXA,EAEPA,EAAO4C,WAAW,KAClB5C,EACA,IAAMA,EAHN,GAKAsH,EAAiBrH,GACpBA,GAAiB,MAATA,EAAoBA,EAAK2C,WAAW,KAAO3C,EAAO,IAAMA,EAAzC,kBApvCnB,gBAAsBjB,SAC3BA,EAD2BE,SAE3BA,EAF2B+I,eAG3BA,EAH2BC,aAI3BA,KAEIC,EAAa/J,WACS,MAAtB+J,EAAWhH,UACbgH,EAAWhH,QAAUiH,sBAAoB,CAAEH,eAAAA,EAAgBC,aAAAA,SAGzDG,EAAUF,EAAWhH,SACpBjB,EAAOoI,GAAYlK,WAAe,CACrCmK,OAAQF,EAAQE,OAChBpJ,SAAUkJ,EAAQlJ,kBAGpBf,mBAAsB,IAAMiK,EAAQG,OAAOF,IAAW,CAACD,IAGrD/H,gBAACvB,GACCC,SAAUA,EACVE,SAAUA,EACVC,SAAUe,EAAMf,SAChBE,eAAgBa,EAAMqI,OACtB/I,UAAW6I,gBAoBV,gBAAkBjH,GAAEA,EAAFO,QAAMA,EAANzB,MAAeA,KAEpCP,KADF5B,UAcI0K,EAAW/H,WACftC,aAAgB,KACdqK,EAASrH,EAAI,CAAEO,QAAAA,EAASzB,MAAAA,OAGnB,+CA2JF,gBAAgBhB,SACrBA,EADqBC,SAErBA,YAEO4C,EAAUmB,EAAyBhE,GAAWC,gIAqehD,SAAsBoC,EAAce,mBAAAA,IAAAA,EAAiB,IACnDf,EACJI,QAAQ,WAAW,CAACyE,EAAGjG,KACG,MAAfmC,EAAOnC,IAAjBpC,MACOuE,EAAOnC,MAEfwB,QAAQ,UAAUyE,GACF,MAAf9D,EAAO,KAAe,GAAKA,EAAO,KAAKX,QAAQ,OAAQ,sDAkOtD,SACLnD,UAEOuE,EAAevE,8BApsBjB,SAAiB4C,GAEpBzB,KADF5B,UAOIiB,SAAEA,EAAFQ,UAAYA,GAAcpB,aAAiBD,IAC3C8B,KAAEA,EAAFF,SAAQA,EAARC,OAAkBA,GAAW8B,EAAgBV,GAE7CsH,EAAiB3I,KACJ,MAAbf,EAAkB,KAChBiI,EAm9BR,SAAuB7F,SAEP,KAAPA,GAAuC,KAAzBA,EAAYrB,SAC7B,IACc,iBAAPqB,EACPtB,YAAUsB,GAAIrB,SACdqB,EAAGrB,SAz9BY4I,CAAcvH,GAC3BwH,EAA8B,MAAd3B,GAAsBA,EAAWX,SAAS,KAC9DoC,EACe,MAAb3I,EACIf,GAAY4J,EAAgB,IAAM,IAClClH,EAAU,CAAC1C,EAAUe,WAGtBP,EAAUqJ,WAAW,CAAE9I,SAAU2I,EAAgB1I,OAAAA,EAAQC,KAAAA,uDAgG3D,SAGL+F,GAEErG,KADF5B,UAOIgC,SAAEA,GAAaU,WACZrC,WACL,IAAMyH,EAA0BG,EAASjG,IACzC,CAACA,EAAUiG,yCAzBR,kBACE5H,aAAiBC,GAAiBgB,iDA+GpC,kBACEjB,aAAiByD,gBAyBnB,eAKDrD,QAAEA,GAAYJ,aAAiBE,GAC/B6D,EAAa3D,EAAQA,EAAQ4D,OAAS,UACnCD,EAAcA,EAAWG,OAAiB"} |