{error.message}
\n(\n props: LinkPropsBase (\n props: LinkPropsBase },\n ): React.ReactNode;\n}\n\n// final thing to do is make sure refs still work in React 19\n\n// this smooths over some of the awkwardness when extending this component\nexport const makeLinkComponent = {\n /**\n * @internal matched-prefix state, set when the matcher throws this for a\n * `[REDIRECT]` leaf. Used to render the error route if the redirect fails.\n */\n state?: MatchState;\n /** @internal level index of the guard that threw, for depth-aware bubbling */\n depth?: number;\n\n constructor(readonly options: NavigateOptions ) {}\n}\n\nexport const redirect = (options: NavigateOptions ): Redirect =>\n new Redirect(options);\n","import { PAGE, REDIRECT } from \"./symbols\";\nimport type { Component, LazyComponent, Leaf, Obj, Page, Redirector } from \"./types\";\n\n/**\n * Substitute a path pattern's `:params`. Throws when one has no value —\n * the right default for `navigate()` and `href`, where an unresolved path\n * is a bug rather than a state to render.\n *\n * Use {@link tryResolvePath} for a path you did not construct — resolving a\n * `level.pattern` against params that may not reach that deep, say.\n */\nexport const resolvePath = (to: string, params?: Obj): string => {\n return to.replaceAll(/:[^/]*/g, (segment) => {\n const value = params?.[segment.slice(1)];\n if (!value)\n throw new Error(`Unable to resolve route '${to}'. Parameter '${segment}' not specified.`);\n return value;\n });\n};\n\n/**\n * {@link resolvePath} without the throw: `undefined` when any `:param` has\n * no value. The idiom for \"link it if we can address it, otherwise render\n * it as plain text\".\n */\nexport const tryResolvePath = (to: string, params?: Obj): string | undefined => {\n let resolved = true;\n const path = to.replaceAll(/:[^/]*/g, (segment) => {\n const value = params?.[segment.slice(1)];\n if (!value) {\n resolved = false;\n return segment;\n }\n return value;\n });\n return resolved ? path : undefined;\n};\n\nexport const isComponent = (data: any): data is Component => {\n if (!data) return false;\n return (\n typeof data === \"function\" ||\n (typeof data === \"object\" && data[\"$$typeof\"] === Symbol.for(\"react.memo\"))\n );\n};\n\nexport const isPage = (data: any): data is Page => {\n if (typeof data !== \"object\") return false;\n const symbols = Object.getOwnPropertySymbols(data);\n return symbols.includes(PAGE);\n};\n\nexport const isRedirect = (data: any): data is Redirector => {\n if (typeof data !== \"object\") return false;\n const symbols = Object.getOwnPropertySymbols(data);\n return symbols.includes(REDIRECT);\n};\n\nexport const isLeaf = (data: any): data is Leaf => {\n return isComponent(data) || isPage(data) || isRedirect(data);\n};\n\nexport const isLazyComponent = (data: any): data is LazyComponent => {\n return typeof data === \"function\" && data.toString().startsWith(\"() => import(\");\n};\n","import { makeAutoObservable, observable } from \"mobx\";\nimport { DefaultErrorPage } from \"./components/error\";\nimport { RouterError } from \"./errors\";\nimport { Redirect } from \"./redirect\";\nimport type { Route } from \"./route\";\nimport type { Component, LazyComponent, Loader, Obj, RouteLevel } from \"./types\";\nimport { isLazyComponent } from \"./util\";\n\nexport interface OutletConfig {\n component?: Component | LazyComponent;\n loader?: Loader;\n errorComponent?: Component;\n loadingComponent?: Component;\n /**\n * The matched level this outlet renders at. Passed to whatever component\n * fills the slot — the outlet's own, or the `[LOADING]` / `[ERROR]` that\n * stands in for it — alongside `route`.\n */\n level?: RouteLevel;\n}\n\nexport type RouteSegmentState = \"preloading\" | \"loading\" | \"error\" | \"ready\";\n\nexport interface LoadOptions {\n /**\n * Hold the `[LOADING]` component on screen for\n * `LOADING_MIN_DURATION_MS` after the data arrives, so a just-shown\n * indicator can't vanish a frame later. Only worth paying for when the\n * indicator is actually rendered — i.e. a cold load. During a warm\n * navigation the previous page is still on screen and the pending\n * route's outlets aren't rendered at all, so holding would delay\n * content to hide an indicator nobody saw.\n */\n hold?: boolean;\n}\n\n/**\n * How long an outlet stays `\"preloading\"` — rendering nothing — before\n * it shows its `[LOADING]` component. Loads that finish inside this\n * window never render an indicator at all.\n */\nexport const LOADING_DELAY_MS = 300;\n\n/**\n * Once the `[LOADING]` component is on screen, how long it is held there\n * even if the data has already arrived. Only applies to loads that\n * already exceeded `LOADING_DELAY_MS`, and exists solely to keep a\n * just-shown indicator from vanishing a frame later.\n */\nexport const LOADING_MIN_DURATION_MS = 300;\n\nexport const DefaultOutlet: Component = ({ children }) => children;\n\n/**\n * Rendered in a pending outlet's slot when no `[LOADING]` component is\n * defined at or above that level. Deliberately minimal — define a\n * root-level `[LOADING]` to replace it.\n */\nexport const DefaultLoadingPage: Component = () => Loading... (path: P, exact?: boolean): boolean {\n return matchesSegments(path, this.activeSegments, exact);\n }\n\n /**\n * {@link doesPathMatch} against {@link target} instead of the active route,\n * so it answers for the destination the moment a navigation starts.\n *\n * A separate method rather than an option on `doesPathMatch`: which clock a\n * call site means is worth stating at the call site.\n */\n doesTargetMatch (path: P, exact?: boolean): boolean {\n return matchesSegments(path, this.targetSegments, exact);\n }\n\n /**\n * Navigates to `options`, resolving `true` once the navigation has\n * **landed** — or `false` as soon as a {@link block}er declines it.\n *\n * Landing is the end of the whole chain, not this hop: guards, loaders,\n * any redirect they throw, and the `activeRoute` swap (view transition\n * included). Await it to run a side effect against the page that actually\n * ended up on screen.\n *\n * ```ts\n * await router.navigate({ to: \"/orders/:id\", params: { id } });\n * announce(`Now viewing ${router.target?.pathname}`);\n * ```\n *\n * Resolves rather than rejects when a navigation fails. A rejected guard,\n * a `NOT_FOUND` or a throwing loader commits the `[ERROR]` route, which is\n * a landing like any other — the caller's \"after navigation\" work usually\n * still wants to run. Read `activeRoute.error`, or compare `target.pattern`\n * against where you meant to go, when the distinction matters. A\n * navigation skipped as redundant (already at that URL, no `state`)\n * resolves immediately, and counts as landing.\n *\n * `false` means only that *this* call did not navigate. A blocker that\n * saves and then lets the user leave is expected to return `true` and land\n * normally; `false` is the \"stay here\" answer. See {@link block}.\n *\n * An unresolvable `to` — a `:param` left unfilled — still throws\n * *synchronously*, because that is a caller bug rather than a navigation\n * outcome, and because the redirect path below depends on catching it.\n *\n * A redirect loop resolves too. Guards that redirect to each other would\n * otherwise chain forever and leave this promise pending for the life of\n * the page — see {@link redirectLoop}, which cuts the chain and lands an\n * `[ERROR]` route instead. A guard that calls `navigate()` in a cycle\n * rather than throwing `redirect()` is *not* bounded: that is the app\n * driving navigation through the same public API a link click uses, and\n * the router cannot tell the two apart.\n *\n * What is awaited is \"nothing is in flight\" rather than this call\n * specifically, so a navigation superseded by another resolves when *that*\n * one lands. That is the only useful answer: once a redirect has replaced\n * the destination there is no separate completion for the original hop,\n * and a caller awaiting navigation wants the view it ends on.\n *\n * The router's state is committed when this resolves. React has re-rendered\n * too wherever a view transition ran, since the swap is flushed inside it;\n * without one the re-render is left on React's scheduler, so a test reading\n * the DOM still needs its usual `act` / `waitFor`.\n */\n navigate (options: NavigateOptions ): Promise (options: NavigateOptions ): Promise (options: NavigateOptions ): void {\n const location = this.resolveLocation(options);\n\n if (options.replace) {\n this.history.replace(location, options.state);\n } else {\n this.history.push(location, options.state);\n }\n }\n\n /**\n * Registers a navigation blocker: `when` says whether the block is live,\n * and `blocker` decides what to do about a navigation while it is.\n * Returns the disposer.\n *\n * ```ts\n * const dispose = router.block(\n * () => designer.dirty,\n * async () => {\n * const choice = await confirmLeave(); // the app's own dialog\n * if (choice === \"save\") await designer.save();\n * return choice !== \"stay\";\n * },\n * );\n * ```\n *\n * {@link useNavigationBlock} is this with the lifetime tied to a\n * component, which is the usual way to reach it.\n *\n * Only `true` proceeds — see {@link NavigationBlocker}. The handler may be\n * async, and `navigate()` stays pending until it settles, so a blocker\n * that saves before allowing the navigation still resolves the caller's\n * `await router.navigate(...)` once the destination lands.\n *\n * Covers every navigation that goes through {@link navigate} — ``\n * clicks, programmatic navigation, `search`-only navigations to another\n * path — the back and forward buttons, and closing or reloading the tab.\n *\n * **`when` must be derived from observables.** It is read at the moment a\n * navigation is proposed, but it also *drives registration*: the pop and\n * `beforeunload` halves of this depend on a `history.block` blocker being\n * armed exactly while the predicate holds, and that is kept in step by a\n * MobX reaction. A predicate reading something MobX cannot see — a ref, a\n * DOM query, a plain field — still blocks in-app navigation correctly, and\n * silently stops covering the back button.\n *\n * Does **not** cover:\n * - **The `redirect()` path.** See {@link navigateNow}.\n * - **A change that keeps the same pathname** — a query param, a history\n * state update, or navigating to the current URL. The route on screen\n * does not change, so there is nothing to leave; this is the same rule\n * `setLocation` applies when it declines to re-match, and it is what\n * keeps `setQueryParam` working while a block is live.\n * - **Writes straight to `router.history`.** A push there is let through\n * rather than prompted about — see {@link onTransition}.\n *\n * There is no \"navigate anyway\" option, because the predicate is one: a\n * \"discard and leave\" action resets what it guards and then navigates, by\n * which point `when` is false.\n *\n * Registering more than one blocker is allowed. They are consulted in\n * registration order and the first to decline ends it, so two dirty models\n * prompt one after the other rather than both at once.\n *\n * What blocking a pop cannot do anything about: the URL moves and comes\n * back, so the address bar can flicker — `router.location` does not, since\n * a blocked pop never reaches the history listeners — and popping to an\n * entry the history library did not create cannot be blocked and fails\n * silently in production. A cancelled pop is also invisible to\n * `navigate()`, which was never called for it.\n */\n block(when: () => boolean, blocker: NavigationBlocker): () => void {\n const entry: BlockerEntry = { when, blocker };\n this.blockers.add(entry);\n\n // registration follows the predicate rather than the caller's lifetime:\n // `history.block` installs a `beforeunload` handler that calls\n // `preventDefault()` without ever consulting a blocker, so a\n // registration outliving its predicate would prompt \"Leave site?\" on a\n // clean form. That listener is also why the router keeps none of its\n // own — armed while the predicate holds is exactly the behaviour wanted.\n const stopReaction = reaction(\n () => entry.when(),\n () => this.syncHistoryBlocker(),\n {\n fireImmediately: true,\n },\n );\n\n // idempotent, so StrictMode's mount/unmount/mount and a caller that\n // disposes twice both land in the same place\n return () => {\n stopReaction();\n this.blockers.delete(entry);\n this.syncHistoryBlocker();\n };\n }\n\n /**\n * The blockers with a say in a navigation to `pathname`, in registration\n * order. Empty is the common case and costs one `Set` size check.\n */\n private activeBlockers(pathname: string): NavigationBlocker[] {\n // a same-pathname change leaves the route on screen — see `block`\n if (!this.blockers.size || pathname === this.location?.pathname) return [];\n\n return [...this.blockers].filter((entry) => entry.when()).map((entry) => entry.blocker);\n }\n\n /** Asks each blocker in turn, stopping at the first that says no. */\n private async consultBlockers(\n blockers: NavigationBlocker[],\n navigation: BlockedNavigation,\n ): Promise (options: NavigateOptions ): string {\n const { pathname, search } = this.resolveLocation(options);\n return `${pathname}${search ?? \"\"}`;\n }\n\n private resolveLocation (\n options: NavigateOptions ,\n ): { pathname: string; search: string | undefined } {\n const { to, search = {}, preserveSearch, params } = options;\n\n const searchParams = search instanceof URLSearchParams ? search : new URLSearchParams(search);\n\n if (preserveSearch) {\n for (const [name, value] of this.search) {\n if (!searchParams.has(name)) {\n searchParams.set(name, value);\n }\n }\n }\n\n return {\n pathname: resolvePath(to, params),\n search: searchParams.size ? `?${searchParams.toString()}` : undefined,\n };\n }\n\n private isCurrentLocation (options: NavigateOptions ): boolean {\n if (!this.location) return false;\n\n const target = this.resolveLocation(options);\n return (\n target.pathname === this.location.pathname && (target.search ?? \"\") === this.location.search\n );\n }\n\n setQueryParam(param: string, value: string): void {\n const params = new URLSearchParams(this.location.search);\n params.set(param, value);\n this.history.replace({ search: `?${params.toString()}` });\n }\n\n removeQueryParam(param: string): string | undefined {\n const params = new URLSearchParams(this.location.search);\n const value = params.get(param) ?? undefined;\n if (value !== undefined) {\n params.delete(param);\n this.history.replace({ search: params.size ? `?${params.toString()}` : \"\" });\n }\n return value;\n }\n\n async setLocation(location: Location): Promise