Index: frontend/node_modules/@remix-run/router/CHANGELOG.md
===================================================================
--- frontend/node_modules/@remix-run/router/CHANGELOG.md	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/@remix-run/router/CHANGELOG.md	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,900 @@
+# `@remix-run/router`
+
+## 1.23.2
+
+### Patch Changes
+
+- Validate redirect locations ([#14707](https://github.com/remix-run/react-router/pull/14707))
+
+## 1.23.1
+
+### Patch Changes
+
+- Normalize double-slashes in `resolvePath` ([#14537](https://github.com/remix-run/react-router/pull/14537))
+
+## 1.23.0
+
+### Minor Changes
+
+- Add `fetcherKey` as a parameter to `patchRoutesOnNavigation` ([#13109](https://github.com/remix-run/react-router/pull/13109))
+
+### Patch Changes
+
+- Fix regression introduced in `6.29.0` via [#12169](https://github.com/remix-run/react-router/pull/12169) that caused issues navigating to hash routes inside splat routes for applications using Lazy Route Discovery (`patchRoutesOnNavigation`) ([#13108](https://github.com/remix-run/react-router/pull/13108))
+
+## 1.22.0
+
+### Minor Changes
+
+- Provide the request `signal` as a parameter to `patchRoutesOnNavigation` ([#12900](https://github.com/remix-run/react-router/pull/12900))
+
+  - This can be used to abort any manifest fetches if the in-flight navigation/fetcher is aborted
+
+### Patch Changes
+
+- Do not log v7 deprecation warnings in production builds ([#12794](https://github.com/remix-run/react-router/pull/12794))
+- Strip search parameters from `patchRoutesOnNavigation` `path` param for fetcher calls ([#12899](https://github.com/remix-run/react-router/pull/12899))
+- Properly bubble headers when throwing a `data()` result ([#12845](https://github.com/remix-run/react-router/pull/12845))
+- Optimize route matching by skipping redundant `matchRoutes` calls when possible ([#12169](https://github.com/remix-run/react-router/pull/12169))
+
+## 1.21.1
+
+### Patch Changes
+
+- - Fix issue with fetcher data cleanup in the data layer on fetcher unmount ([#12674](https://github.com/remix-run/react-router/pull/12674))
+  - Fix behavior of manual fetcher keys when not opted into `future.v7_fetcherPersist`
+
+## 1.21.0
+
+### Minor Changes
+
+- - Log deprecation warnings for v7 flags ([#11750](https://github.com/remix-run/react-router/pull/11750))
+  - Add deprecation warnings to `json`/`defer` in favor of returning raw objects
+    - These methods will be removed in React Router v7
+
+### Patch Changes
+
+- Update JSDoc URLs for new website structure (add /v6/ segment) ([#12141](https://github.com/remix-run/react-router/pull/12141))
+
+## 1.20.0
+
+### Minor Changes
+
+- Stabilize `unstable_patchRoutesOnNavigation` ([#11973](https://github.com/remix-run/react-router/pull/11973))
+  - Add new `PatchRoutesOnNavigationFunctionArgs` type for convenience ([#11967](https://github.com/remix-run/react-router/pull/11967))
+- Stabilize `unstable_dataStrategy` ([#11974](https://github.com/remix-run/react-router/pull/11974))
+- Stabilize the `unstable_flushSync` option for navigations and fetchers ([#11989](https://github.com/remix-run/react-router/pull/11989))
+- Stabilize the `unstable_viewTransition` option for navigations and the corresponding `unstable_useViewTransitionState` hook ([#11989](https://github.com/remix-run/react-router/pull/11989))
+
+### Patch Changes
+
+- Fix bug when submitting to the current contextual route (parent route with an index child) when an `?index` param already exists from a prior submission ([#12003](https://github.com/remix-run/react-router/pull/12003))
+- Fix `useFormAction` bug - when removing `?index` param it would not keep other non-Remix `index` params ([#12003](https://github.com/remix-run/react-router/pull/12003))
+- Fix bug with fetchers not persisting `preventScrollReset` through redirects during concurrent fetches ([#11999](https://github.com/remix-run/react-router/pull/11999))
+- Remove internal cache to fix issues with interrupted `patchRoutesOnNavigation` calls ([#12055](https://github.com/remix-run/react-router/pull/12055))
+  - We used to cache in-progress calls to `patchRoutesOnNavigation` internally so that multiple navigations with the same start/end would only execute the function once and use the same promise
+  - However, this approach was at odds with `patch` short circuiting if a navigation was interrupted (and the `request.signal` aborted) since the first invocation's `patch` would no-op
+  - This cache also made some assumptions as to what a valid cache key might be - and is oblivious to any other application-state changes that may have occurred
+  - So, the cache has been removed because in _most_ cases, repeated calls to something like `import()` for async routes will already be cached automatically - and if not it's easy enough for users to implement this cache in userland
+- Avoid unnecessary `console.error` on fetcher abort due to back-to-back revalidation calls ([#12050](https://github.com/remix-run/react-router/pull/12050))
+- Expose errors thrown from `patchRoutesOnNavigation` directly to `useRouteError` instead of wrapping them in a 400 `ErrorResponse` instance ([#12111](https://github.com/remix-run/react-router/pull/12111))
+- Fix types for `RouteObject` within `PatchRoutesOnNavigationFunction`'s `patch` method so it doesn't expect agnostic route objects passed to `patch` ([#11967](https://github.com/remix-run/react-router/pull/11967))
+- Fix bugs with `partialHydration` when hydrating with errors ([#12070](https://github.com/remix-run/react-router/pull/12070))
+- Remove internal `discoveredRoutes` FIFO queue from `unstable_patchRoutesOnNavigation` ([#11977](https://github.com/remix-run/react-router/pull/11977))
+
+## 1.19.2
+
+### Patch Changes
+
+- Update the `unstable_dataStrategy` API to allow for more advanced implementations ([#11943](https://github.com/remix-run/react-router/pull/11943))
+  - Rename `unstable_HandlerResult` to `unstable_DataStrategyResult`
+  - The return signature has changed from a parallel array of `unstable_DataStrategyResult[]` (parallel to `matches`) to a key/value object of `routeId => unstable_DataStrategyResult`
+    - This allows you to more easily decide to opt-into or out-of revalidating data that may not have been revalidated by default (via `match.shouldLoad`)
+    - ⚠️ This is a breaking change if you've currently adopted `unstable_dataStrategy`
+  - Added a new `fetcherKey` parameter to `unstable_dataStrategy` to allow differentiation from navigational and fetcher calls
+  - You should now return/throw a result from your `handlerOverride` instead of returning a `DataStrategyResult`
+    - If you are aggregating the results of `match.resolve()` into a final results object you should not need to think about the `DataStrategyResult` type
+    - If you are manually filling your results object from within your `handlerOverride`, then you will need to assign a `DataStrategyResult` as the value so React Router knows if it's a successful execution or an error.
+- Preserve view transition through redirects ([#11925](https://github.com/remix-run/react-router/pull/11925))
+- Fix blocker usage when `blocker.proceed` is called quickly/synchronously ([#11930](https://github.com/remix-run/react-router/pull/11930))
+- Preserve pending view transitions through a router revalidation call ([#11917](https://github.com/remix-run/react-router/pull/11917))
+
+## 1.19.1
+
+### Patch Changes
+
+- Fog of War: Update `unstable_patchRoutesOnMiss` logic so that we call the method when we match routes with dynamic param or splat segments in case there exists a higher-scoring static route that we've not yet discovered. ([#11883](https://github.com/remix-run/react-router/pull/11883))
+
+  - We also now leverage an internal FIFO queue of previous paths we've already called `unstable_patchRouteOnMiss` against so that we don't re-call on subsequent navigations to the same path
+
+- Rename `unstable_patchRoutesOnMiss` to `unstable_patchRoutesOnNavigation` to match new behavior ([#11888](https://github.com/remix-run/react-router/pull/11888))
+
+## 1.19.0
+
+### Minor Changes
+
+- Add a new `replace(url, init?)` alternative to `redirect(url, init?)` that performs a `history.replaceState` instead of a `history.pushState` on client-side navigation redirects ([#11811](https://github.com/remix-run/react-router/pull/11811))
+- Add a new `unstable_data()` API for usage with Remix Single Fetch ([#11836](https://github.com/remix-run/react-router/pull/11836))
+  - This API is not intended for direct usage in React Router SPA applications
+  - It is primarily intended for usage with `createStaticHandler.query()` to allow loaders/actions to return arbitrary data + `status`/`headers` without forcing the serialization of data into a `Response` instance
+  - This allows for more advanced serialization tactics via `unstable_dataStrategy` such as serializing via `turbo-stream` in Remix Single Fetch
+  - ⚠️ This removes the `status` field from `HandlerResult`
+    - If you need to return a specific `status` from `unstable_dataStrategy` you should instead do so via `unstable_data()`
+
+### Patch Changes
+
+- Fix internal cleanup of interrupted fetchers to avoid invalid revalidations on navigations ([#11839](https://github.com/remix-run/react-router/pull/11839))
+  - When a `fetcher.load` is interrupted by an `action` submission, we track it internally and force revalidation once the `action` completes
+  - We previously only cleared out this internal tracking info on a successful _navigation_ submission
+  - Therefore, if the `fetcher.load` was interrupted by a `fetcher.submit`, then we wouldn't remove it from this internal tracking info on successful load (incorrectly)
+  - And then on the next navigation it's presence in the internal tracking would automatically trigger execution of the `fetcher.load` again, ignoring any `shouldRevalidate` logic
+  - This fix cleans up the internal tracking so it applies to both navigation submission and fetcher submissions
+- Fix initial hydration behavior when using `future.v7_partialHydration` along with `unstable_patchRoutesOnMiss` ([#11838](https://github.com/remix-run/react-router/pull/11838))
+  - During initial hydration, `router.state.matches` will now include any partial matches so that we can render ancestor `HydrateFallback` components
+
+## 1.18.0
+
+### Minor Changes
+
+- Stabilize `future.unstable_skipActionErrorRevalidation` as `future.v7_skipActionErrorRevalidation` ([#11769](https://github.com/remix-run/react-router/pull/11769))
+  - When this flag is enabled, actions will not automatically trigger a revalidation if they return/throw a `Response` with a `4xx`/`5xx` status code
+  - You may still opt-into revalidation via `shouldRevalidate`
+  - This also changes `shouldRevalidate`'s `unstable_actionStatus` parameter to `actionStatus`
+
+### Patch Changes
+
+- Fix bubbling of errors thrown from `unstable_patchRoutesOnMiss` ([#11786](https://github.com/remix-run/react-router/pull/11786))
+- Fix hydration in SSR apps using `unstable_patchRoutesOnMiss` that matched a splat route on the server ([#11790](https://github.com/remix-run/react-router/pull/11790))
+
+## 1.17.1
+
+### Patch Changes
+
+- Fog of War (unstable): Trigger a new `router.routes` identity/reflow during route patching ([#11740](https://github.com/remix-run/react-router/pull/11740))
+- Fog of War (unstable): Fix initial matching when a splat route matches ([#11759](https://github.com/remix-run/react-router/pull/11759))
+
+## 1.17.0
+
+### Minor Changes
+
+- Add support for Lazy Route Discovery (a.k.a. Fog of War) ([#11626](https://github.com/remix-run/react-router/pull/11626))
+
+  - RFC: <https://github.com/remix-run/react-router/discussions/11113>
+  - `unstable_patchRoutesOnMiss` docs: <https://reactrouter.com/v6/routers/create-browser-router>
+
+## 1.16.1
+
+### Patch Changes
+
+- Support `unstable_dataStrategy` on `staticHandler.queryRoute` ([#11515](https://github.com/remix-run/react-router/pull/11515))
+
+## 1.16.0
+
+### Minor Changes
+
+- Add a new `unstable_dataStrategy` configuration option ([#11098](https://github.com/remix-run/react-router/pull/11098))
+  - This option allows Data Router applications to take control over the approach for executing route loaders and actions
+  - The default implementation is today's behavior, to fetch all loaders in parallel, but this option allows users to implement more advanced data flows including Remix single-fetch, middleware/context APIs, automatic loader caching, and more
+- Move `unstable_dataStrategy` from `createStaticHandler` to `staticHandler.query` so it can be request-specific for use with the `ResponseStub` approach in Remix. It's not really applicable to `queryRoute` for now since that's a singular handler call anyway so any pre-processing/post/processing could be done there manually. ([#11377](https://github.com/remix-run/react-router/pull/11377))
+- Add a new `future.unstable_skipActionRevalidation` future flag ([#11098](https://github.com/remix-run/react-router/pull/11098))
+  - Currently, active loaders revalidate after any action, regardless of the result
+  - With this flag enabled, actions that return/throw a 4xx/5xx response status will no longer automatically revalidate
+  - This should reduce load on your server since it's rare that a 4xx/5xx should actually mutate any data
+  - If you need to revalidate after a 4xx/5xx result with this flag enabled, you can still do that via returning `true` from `shouldRevalidate`
+  - `shouldRevalidate` now also receives a new `unstable_actionStatus` argument alongside `actionResult` so you can make decision based on the status of the `action` response without having to encode it into the action data
+- Added a `skipLoaderErrorBubbling` flag to `staticHandler.query` to disable error bubbling on loader executions for single-fetch scenarios where the client-side router will handle the bubbling ([#11098](https://github.com/remix-run/react-router/pull/11098))
+
+## 1.15.3
+
+### Patch Changes
+
+- Fix a `future.v7_partialHydration` bug that would re-run loaders below the boundary on hydration if SSR loader errors bubbled to a parent boundary ([#11324](https://github.com/remix-run/react-router/pull/11324))
+- Fix a `future.v7_partialHydration` bug that would consider the router uninitialized if a route did not have a loader ([#11325](https://github.com/remix-run/react-router/pull/11325))
+
+## 1.15.2
+
+### Patch Changes
+
+- Preserve hydrated errors during partial hydration runs ([#11305](https://github.com/remix-run/react-router/pull/11305))
+
+## 1.15.1
+
+### Patch Changes
+
+- Fix encoding/decoding issues with pre-encoded dynamic parameter values ([#11199](https://github.com/remix-run/react-router/pull/11199))
+
+## 1.15.0
+
+### Minor Changes
+
+- Add a `createStaticHandler` `future.v7_throwAbortReason` flag to throw `request.signal.reason` (defaults to a `DOMException`) when a request is aborted instead of an `Error` such as `new Error("query() call aborted: GET /path")` ([#11104](https://github.com/remix-run/react-router/pull/11104))
+
+  - Please note that `DOMException` was added in Node v17 so you will not get a `DOMException` on Node 16 and below.
+
+### Patch Changes
+
+- Respect the `ErrorResponse` status code if passed to `getStaticContextFormError` ([#11213](https://github.com/remix-run/react-router/pull/11213))
+
+## 1.14.2
+
+### Patch Changes
+
+- Fix bug where dashes were not picked up in dynamic parameter names ([#11160](https://github.com/remix-run/react-router/pull/11160))
+- Do not attempt to deserialize empty JSON responses ([#11164](https://github.com/remix-run/react-router/pull/11164))
+
+## 1.14.1
+
+### Patch Changes
+
+- Fix bug with `route.lazy` not working correctly on initial SPA load when `v7_partialHydration` is specified ([#11121](https://github.com/remix-run/react-router/pull/11121))
+- Fix bug preventing revalidation from occurring for persisted fetchers unmounted during the `submitting` phase ([#11102](https://github.com/remix-run/react-router/pull/11102))
+- De-dup relative path logic in `resolveTo` ([#11097](https://github.com/remix-run/react-router/pull/11097))
+
+## 1.14.0
+
+### Minor Changes
+
+- Added a new `future.v7_partialHydration` future flag that enables partial hydration of a data router when Server-Side Rendering. This allows you to provide `hydrationData.loaderData` that has values for _some_ initially matched route loaders, but not all. When this flag is enabled, the router will call `loader` functions for routes that do not have hydration loader data during `router.initialize()`, and it will render down to the deepest provided `HydrateFallback` (up to the first route without hydration data) while it executes the unhydrated routes. ([#11033](https://github.com/remix-run/react-router/pull/11033))
+
+  For example, the following router has a `root` and `index` route, but only provided `hydrationData.loaderData` for the `root` route. Because the `index` route has a `loader`, we need to run that during initialization. With `future.v7_partialHydration` specified, `<RouterProvider>` will render the `RootComponent` (because it has data) and then the `IndexFallback` (since it does not have data). Once `indexLoader` finishes, application will update and display `IndexComponent`.
+
+  ```jsx
+  let router = createBrowserRouter(
+    [
+      {
+        id: "root",
+        path: "/",
+        loader: rootLoader,
+        Component: RootComponent,
+        Fallback: RootFallback,
+        children: [
+          {
+            id: "index",
+            index: true,
+            loader: indexLoader,
+            Component: IndexComponent,
+            HydrateFallback: IndexFallback,
+          },
+        ],
+      },
+    ],
+    {
+      future: {
+        v7_partialHydration: true,
+      },
+      hydrationData: {
+        loaderData: {
+          root: { message: "Hydrated from Root!" },
+        },
+      },
+    }
+  );
+  ```
+
+  If the above example did not have an `IndexFallback`, then `RouterProvider` would instead render the `RootFallback` while it executed the `indexLoader`.
+
+  **Note:** When `future.v7_partialHydration` is provided, the `<RouterProvider fallbackElement>` prop is ignored since you can move it to a `Fallback` on your top-most route. The `fallbackElement` prop will be removed in React Router v7 when `v7_partialHydration` behavior becomes the standard behavior.
+
+- Add a new `future.v7_relativeSplatPath` flag to implement a breaking bug fix to relative routing when inside a splat route. ([#11087](https://github.com/remix-run/react-router/pull/11087))
+
+  This fix was originally added in [#10983](https://github.com/remix-run/react-router/issues/10983) and was later reverted in [#11078](https://github.com/remix-run/react-router/pull/11078) because it was determined that a large number of existing applications were relying on the buggy behavior (see [#11052](https://github.com/remix-run/react-router/issues/11052))
+
+  **The Bug**
+  The buggy behavior is that without this flag, the default behavior when resolving relative paths is to _ignore_ any splat (`*`) portion of the current route path.
+
+  **The Background**
+  This decision was originally made thinking that it would make the concept of nested different sections of your apps in `<Routes>` easier if relative routing would _replace_ the current splat:
+
+  ```jsx
+  <BrowserRouter>
+    <Routes>
+      <Route path="/" element={<Home />} />
+      <Route path="dashboard/*" element={<Dashboard />} />
+    </Routes>
+  </BrowserRouter>
+  ```
+
+  Any paths like `/dashboard`, `/dashboard/team`, `/dashboard/projects` will match the `Dashboard` route. The dashboard component itself can then render nested `<Routes>`:
+
+  ```jsx
+  function Dashboard() {
+    return (
+      <div>
+        <h2>Dashboard</h2>
+        <nav>
+          <Link to="/">Dashboard Home</Link>
+          <Link to="team">Team</Link>
+          <Link to="projects">Projects</Link>
+        </nav>
+
+        <Routes>
+          <Route path="/" element={<DashboardHome />} />
+          <Route path="team" element={<DashboardTeam />} />
+          <Route path="projects" element={<DashboardProjects />} />
+        </Routes>
+      </div>
+    );
+  }
+  ```
+
+  Now, all links and route paths are relative to the router above them. This makes code splitting and compartmentalizing your app really easy. You could render the `Dashboard` as its own independent app, or embed it into your large app without making any changes to it.
+
+  **The Problem**
+
+  The problem is that this concept of ignoring part of a path breaks a lot of other assumptions in React Router - namely that `"."` always means the current location pathname for that route. When we ignore the splat portion, we start getting invalid paths when using `"."`:
+
+  ```jsx
+  // If we are on URL /dashboard/team, and we want to link to /dashboard/team:
+  function DashboardTeam() {
+    // ❌ This is broken and results in <a href="/dashboard">
+    return <Link to=".">A broken link to the Current URL</Link>;
+
+    // ✅ This is fixed but super unintuitive since we're already at /dashboard/team!
+    return <Link to="./team">A broken link to the Current URL</Link>;
+  }
+  ```
+
+  We've also introduced an issue that we can no longer move our `DashboardTeam` component around our route hierarchy easily - since it behaves differently if we're underneath a non-splat route, such as `/dashboard/:widget`. Now, our `"."` links will, properly point to ourself _inclusive of the dynamic param value_ so behavior will break from it's corresponding usage in a `/dashboard/*` route.
+
+  Even worse, consider a nested splat route configuration:
+
+  ```jsx
+  <BrowserRouter>
+    <Routes>
+      <Route path="dashboard">
+        <Route path="*" element={<Dashboard />} />
+      </Route>
+    </Routes>
+  </BrowserRouter>
+  ```
+
+  Now, a `<Link to=".">` and a `<Link to="..">` inside the `Dashboard` component go to the same place! That is definitely not correct!
+
+  Another common issue arose in Data Routers (and Remix) where any `<Form>` should post to it's own route `action` if you the user doesn't specify a form action:
+
+  ```jsx
+  let router = createBrowserRouter({
+    path: "/dashboard",
+    children: [
+      {
+        path: "*",
+        action: dashboardAction,
+        Component() {
+          // ❌ This form is broken!  It throws a 405 error when it submits because
+          // it tries to submit to /dashboard (without the splat value) and the parent
+          // `/dashboard` route doesn't have an action
+          return <Form method="post">...</Form>;
+        },
+      },
+    ],
+  });
+  ```
+
+  This is just a compounded issue from the above because the default location for a `Form` to submit to is itself (`"."`) - and if we ignore the splat portion, that now resolves to the parent route.
+
+  **The Solution**
+  If you are leveraging this behavior, it's recommended to enable the future flag, move your splat to it's own route, and leverage `../` for any links to "sibling" pages:
+
+  ```jsx
+  <BrowserRouter>
+    <Routes>
+      <Route path="dashboard">
+        <Route index path="*" element={<Dashboard />} />
+      </Route>
+    </Routes>
+  </BrowserRouter>
+
+  function Dashboard() {
+    return (
+      <div>
+        <h2>Dashboard</h2>
+        <nav>
+          <Link to="..">Dashboard Home</Link>
+          <Link to="../team">Team</Link>
+          <Link to="../projects">Projects</Link>
+        </nav>
+
+        <Routes>
+          <Route path="/" element={<DashboardHome />} />
+          <Route path="team" element={<DashboardTeam />} />
+          <Route path="projects" element={<DashboardProjects />} />
+        </Router>
+      </div>
+    );
+  }
+  ```
+
+  This way, `.` means "the full current pathname for my route" in all cases (including static, dynamic, and splat routes) and `..` always means "my parents pathname".
+
+### Patch Changes
+
+- Catch and bubble errors thrown when trying to unwrap responses from `loader`/`action` functions ([#11061](https://github.com/remix-run/react-router/pull/11061))
+- Fix `relative="path"` issue when rendering `Link`/`NavLink` outside of matched routes ([#11062](https://github.com/remix-run/react-router/pull/11062))
+
+## 1.13.1
+
+### Patch Changes
+
+- Revert the `useResolvedPath` fix for splat routes due to a large number of applications that were relying on the buggy behavior (see <https://github.com/remix-run/react-router/issues/11052#issuecomment-1836589329>). We plan to re-introduce this fix behind a future flag in the next minor version. ([#11078](https://github.com/remix-run/react-router/pull/11078))
+
+## 1.13.0
+
+### Minor Changes
+
+- Export the `PathParam` type from the public API ([#10719](https://github.com/remix-run/react-router/pull/10719))
+
+### Patch Changes
+
+- Fix bug with `resolveTo` in splat routes ([#11045](https://github.com/remix-run/react-router/pull/11045))
+  - This is a follow up to [#10983](https://github.com/remix-run/react-router/pull/10983) to handle the few other code paths using `getPathContributingMatches`
+  - This removes the `UNSAFE_getPathContributingMatches` export from `@remix-run/router` since we no longer need this in the `react-router`/`react-router-dom` layers
+- Do not revalidate unmounted fetchers when `v7_fetcherPersist` is enabled ([#11044](https://github.com/remix-run/react-router/pull/11044))
+
+## 1.12.0
+
+### Minor Changes
+
+- Add `unstable_flushSync` option to `router.navigate` and `router.fetch` to tell the React Router layer to opt-out of `React.startTransition` and into `ReactDOM.flushSync` for state updates ([#11005](https://github.com/remix-run/react-router/pull/11005))
+
+### Patch Changes
+
+- Fix `relative="path"` bug where relative path calculations started from the full location pathname, instead of from the current contextual route pathname. ([#11006](https://github.com/remix-run/react-router/pull/11006))
+
+  ```jsx
+  <Route path="/a">
+    <Route path="/b" element={<Component />}>
+      <Route path="/c" />
+    </Route>
+  </Route>;
+
+  function Component() {
+    return (
+      <>
+        {/* This is now correctly relative to /a/b, not /a/b/c */}
+        <Link to=".." relative="path" />
+        <Outlet />
+      </>
+    );
+  }
+  ```
+
+## 1.11.0
+
+### Minor Changes
+
+- Add a new `future.v7_fetcherPersist` flag to the `@remix-run/router` to change the persistence behavior of fetchers when `router.deleteFetcher` is called. Instead of being immediately cleaned up, fetchers will persist until they return to an `idle` state ([RFC](https://github.com/remix-run/remix/discussions/7698)) ([#10962](https://github.com/remix-run/react-router/pull/10962))
+
+  - This is sort of a long-standing bug fix as the `useFetchers()` API was always supposed to only reflect **in-flight** fetcher information for pending/optimistic UI -- it was not intended to reflect fetcher data or hang onto fetchers after they returned to an `idle` state
+  - Keep an eye out for the following specific behavioral changes when opting into this flag and check your app for compatibility:
+    - Fetchers that complete _while still mounted_ will no longer appear in `useFetchers()`. They served effectively no purpose in there since you can access the data via `useFetcher().data`).
+    - Fetchers that previously unmounted _while in-flight_ will not be immediately aborted and will instead be cleaned up once they return to an `idle` state. They will remain exposed via `useFetchers` while in-flight so you can still access pending/optimistic data after unmount.
+
+- When `v7_fetcherPersist` is enabled, the router now performs ref-counting on fetcher keys via `getFetcher`/`deleteFetcher` so it knows when a given fetcher is totally unmounted from the UI ([#10977](https://github.com/remix-run/react-router/pull/10977))
+
+  - Once a fetcher has been totally unmounted, we can ignore post-processing of a persisted fetcher result such as a redirect or an error
+  - The router will also pass a new `deletedFetchers` array to the subscriber callbacks so that the UI layer can remove associated fetcher data
+
+- Add support for optional path segments in `matchPath` ([#10768](https://github.com/remix-run/react-router/pull/10768))
+
+### Patch Changes
+
+- Fix `router.getFetcher`/`router.deleteFetcher` type definitions which incorrectly specified `key` as an optional parameter ([#10960](https://github.com/remix-run/react-router/pull/10960))
+
+## 1.10.0
+
+### Minor Changes
+
+- Add experimental support for the [View Transitions API](https://developer.mozilla.org/en-US/docs/Web/API/ViewTransition) by allowing users to opt-into view transitions on navigations via the new `unstable_viewTransition` option to `router.navigate` ([#10916](https://github.com/remix-run/react-router/pull/10916))
+
+### Patch Changes
+
+- Allow 404 detection to leverage root route error boundary if path contains a URL segment ([#10852](https://github.com/remix-run/react-router/pull/10852))
+- Fix `ErrorResponse` type to avoid leaking internal field ([#10876](https://github.com/remix-run/react-router/pull/10876))
+
+## 1.9.0
+
+### Minor Changes
+
+- In order to move towards stricter TypeScript support in the future, we're aiming to replace current usages of `any` with `unknown` on exposed typings for user-provided data. To do this in Remix v2 without introducing breaking changes in React Router v6, we have added generics to a number of shared types. These continue to default to `any` in React Router and are overridden with `unknown` in Remix. In React Router v7 we plan to move these to `unknown` as a breaking change. ([#10843](https://github.com/remix-run/react-router/pull/10843))
+  - `Location` now accepts a generic for the `location.state` value
+  - `ActionFunctionArgs`/`ActionFunction`/`LoaderFunctionArgs`/`LoaderFunction` now accept a generic for the `context` parameter (only used in SSR usages via `createStaticHandler`)
+  - The return type of `useMatches` (now exported as `UIMatch`) accepts generics for `match.data` and `match.handle` - both of which were already set to `unknown`
+- Move the `@private` class export `ErrorResponse` to an `UNSAFE_ErrorResponseImpl` export since it is an implementation detail and there should be no construction of `ErrorResponse` instances in userland. This frees us up to export a `type ErrorResponse` which correlates to an instance of the class via `InstanceType`. Userland code should only ever be using `ErrorResponse` as a type and should be type-narrowing via `isRouteErrorResponse`. ([#10811](https://github.com/remix-run/react-router/pull/10811))
+- Export `ShouldRevalidateFunctionArgs` interface ([#10797](https://github.com/remix-run/react-router/pull/10797))
+- Removed private/internal APIs only required for the Remix v1 backwards compatibility layer and no longer needed in Remix v2 (`_isFetchActionRedirect`, `_hasFetcherDoneAnything`) ([#10715](https://github.com/remix-run/react-router/pull/10715))
+
+### Patch Changes
+
+- Add method/url to error message on aborted `query`/`queryRoute` calls ([#10793](https://github.com/remix-run/react-router/pull/10793))
+- Fix a race-condition with loader/action-thrown errors on `route.lazy` routes ([#10778](https://github.com/remix-run/react-router/pull/10778))
+- Fix type for `actionResult` on the arguments object passed to `shouldRevalidate` ([#10779](https://github.com/remix-run/react-router/pull/10779))
+
+## 1.8.0
+
+### Minor Changes
+
+- Add's a new `redirectDocument()` function which allows users to specify that a redirect from a `loader`/`action` should trigger a document reload (via `window.location`) instead of attempting to navigate to the redirected location via React Router ([#10705](https://github.com/remix-run/react-router/pull/10705))
+
+### Patch Changes
+
+- Fix an issue in `queryRoute` that was not always identifying thrown `Response` instances ([#10717](https://github.com/remix-run/react-router/pull/10717))
+- Ensure hash history always includes a leading slash on hash pathnames ([#10753](https://github.com/remix-run/react-router/pull/10753))
+
+## 1.7.2
+
+### Patch Changes
+
+- Trigger an error if a `defer` promise resolves/rejects with `undefined` in order to match the behavior of loaders and actions which must return a value or `null` ([#10690](https://github.com/remix-run/react-router/pull/10690))
+- Properly handle fetcher redirects interrupted by normal navigations ([#10674](https://github.com/remix-run/react-router/pull/10674), [#10709](https://github.com/remix-run/react-router/pull/10709))
+- Initial-load fetchers should not automatically revalidate on GET navigations ([#10688](https://github.com/remix-run/react-router/pull/10688))
+- Enhance the return type of `Route.lazy` to prohibit returning an empty object ([#10634](https://github.com/remix-run/react-router/pull/10634))
+
+## 1.7.1
+
+### Patch Changes
+
+- Fix issues with reused blockers on subsequent navigations ([#10656](https://github.com/remix-run/react-router/pull/10656))
+
+## 1.7.0
+
+### Minor Changes
+
+- Add support for `application/json` and `text/plain` encodings for `router.navigate`/`router.fetch` submissions. To leverage these encodings, pass your data in a `body` parameter and specify the desired `formEncType`: ([#10413](https://github.com/remix-run/react-router/pull/10413))
+
+  ```js
+  // By default, the encoding is "application/x-www-form-urlencoded"
+  router.navigate("/", {
+    formMethod: "post",
+    body: { key: "value" },
+  });
+
+  async function action({ request }) {
+    // await request.formData() => FormData instance with entry [key=value]
+  }
+  ```
+
+  ```js
+  // Pass `formEncType` to opt-into a different encoding (json)
+  router.navigate("/", {
+    formMethod: "post",
+    formEncType: "application/json",
+    body: { key: "value" },
+  });
+
+  async function action({ request }) {
+    // await request.json() => { key: "value" }
+  }
+  ```
+
+  ```js
+  // Pass `formEncType` to opt-into a different encoding (text)
+  router.navigate("/", {
+    formMethod: "post",
+    formEncType: "text/plain",
+    body: "Text submission",
+  });
+
+  async function action({ request }) {
+    // await request.text() => "Text submission"
+  }
+  ```
+
+### Patch Changes
+
+- Call `window.history.pushState/replaceState` before updating React Router state (instead of after) so that `window.location` matches `useLocation` during synchronous React 17 rendering ([#10448](https://github.com/remix-run/react-router/pull/10448))
+  - ⚠️ However, generally apps should not be relying on `window.location` and should always reference `useLocation` when possible, as `window.location` will not be in sync 100% of the time (due to `popstate` events, concurrent mode, etc.)
+- Strip `basename` from the `location` provided to `<ScrollRestoration getKey>` to match the `useLocation` behavior ([#10550](https://github.com/remix-run/react-router/pull/10550))
+- Avoid calling `shouldRevalidate` for fetchers that have not yet completed a data load ([#10623](https://github.com/remix-run/react-router/pull/10623))
+- Fix `unstable_useBlocker` key issues in `StrictMode` ([#10573](https://github.com/remix-run/react-router/pull/10573))
+- Upgrade `typescript` to 5.1 ([#10581](https://github.com/remix-run/react-router/pull/10581))
+
+## 1.6.3
+
+### Patch Changes
+
+- Allow fetcher revalidations to complete if submitting fetcher is deleted ([#10535](https://github.com/remix-run/react-router/pull/10535))
+- Re-throw `DOMException` (`DataCloneError`) when attempting to perform a `PUSH` navigation with non-serializable state. ([#10427](https://github.com/remix-run/react-router/pull/10427))
+- Ensure revalidations happen when hash is present ([#10516](https://github.com/remix-run/react-router/pull/10516))
+- upgrade jest and jsdom ([#10453](https://github.com/remix-run/react-router/pull/10453))
+
+## 1.6.2
+
+### Patch Changes
+
+- Fix HMR-driven error boundaries by properly reconstructing new routes and `manifest` in `\_internalSetRoutes` ([#10437](https://github.com/remix-run/react-router/pull/10437))
+- Fix bug where initial data load would not kick off when hash is present ([#10493](https://github.com/remix-run/react-router/pull/10493))
+
+## 1.6.1
+
+### Patch Changes
+
+- Fix `basename` handling when navigating without a path ([#10433](https://github.com/remix-run/react-router/pull/10433))
+- "Same hash" navigations no longer re-run loaders to match browser behavior (i.e. `/path#hash -> /path#hash`) ([#10408](https://github.com/remix-run/react-router/pull/10408))
+
+## 1.6.0
+
+### Minor Changes
+
+- Enable relative routing in the `@remix-run/router` when providing a source route ID from which the path is relative to: ([#10336](https://github.com/remix-run/react-router/pull/10336))
+
+  - Example: `router.navigate("../path", { fromRouteId: "some-route" })`.
+  - This also applies to `router.fetch` which already receives a source route ID
+
+- Introduce a new `@remix-run/router` `future.v7_prependBasename` flag to enable `basename` prefixing to all paths coming into `router.navigate` and `router.fetch`.
+
+  - Previously the `basename` was prepended in the React Router layer, but now that relative routing is being handled by the router we need prepend the `basename` _after_ resolving any relative paths
+  - This also enables `basename` support in `useFetcher` as well
+
+### Patch Changes
+
+- Enhance `LoaderFunction`/`ActionFunction` return type to prevent `undefined` from being a valid return value ([#10267](https://github.com/remix-run/react-router/pull/10267))
+- Ensure proper 404 error on `fetcher.load` call to a route without a `loader` ([#10345](https://github.com/remix-run/react-router/pull/10345))
+- Deprecate the `createRouter` `detectErrorBoundary` option in favor of the new `mapRouteProperties` option for converting a framework-agnostic route to a framework-aware route. This allows us to set more than just the `hasErrorBoundary` property during route pre-processing, and is now used for mapping `Component -> element` and `ErrorBoundary -> errorElement` in `react-router`. ([#10287](https://github.com/remix-run/react-router/pull/10287))
+- Fixed a bug where fetchers were incorrectly attempting to revalidate on search params changes or routing to the same URL (using the same logic for route `loader` revalidations). However, since fetchers have a static href, they should only revalidate on `action` submissions or `router.revalidate` calls. ([#10344](https://github.com/remix-run/react-router/pull/10344))
+- Decouple `AbortController` usage between revalidating fetchers and the thing that triggered them such that the unmount/deletion of a revalidating fetcher doesn't impact the ongoing triggering navigation/revalidation ([#10271](https://github.com/remix-run/react-router/pull/10271))
+
+## 1.5.0
+
+### Minor Changes
+
+- Added support for [**Future Flags**](https://reactrouter.com/v6/guides/api-development-strategy) in React Router. The first flag being introduced is `future.v7_normalizeFormMethod` which will normalize the exposed `useNavigation()/useFetcher()` `formMethod` fields as uppercase HTTP methods to align with the `fetch()` behavior. ([#10207](https://github.com/remix-run/react-router/pull/10207))
+
+  - When `future.v7_normalizeFormMethod === false` (default v6 behavior),
+    - `useNavigation().formMethod` is lowercase
+    - `useFetcher().formMethod` is lowercase
+  - When `future.v7_normalizeFormMethod === true`:
+    - `useNavigation().formMethod` is uppercase
+    - `useFetcher().formMethod` is uppercase
+
+### Patch Changes
+
+- Provide fetcher submission to `shouldRevalidate` if the fetcher action redirects ([#10208](https://github.com/remix-run/react-router/pull/10208))
+- Properly handle `lazy()` errors during router initialization ([#10201](https://github.com/remix-run/react-router/pull/10201))
+- Remove `instanceof` check for `DeferredData` to be resilient to ESM/CJS boundaries in SSR bundling scenarios ([#10247](https://github.com/remix-run/react-router/pull/10247))
+- Update to latest `@remix-run/web-fetch@4.3.3` ([#10216](https://github.com/remix-run/react-router/pull/10216))
+
+## 1.4.0
+
+### Minor Changes
+
+- **Introducing Lazy Route Modules!** ([#10045](https://github.com/remix-run/react-router/pull/10045))
+
+  In order to keep your application bundles small and support code-splitting of your routes, we've introduced a new `lazy()` route property. This is an async function that resolves the non-route-matching portions of your route definition (`loader`, `action`, `element`/`Component`, `errorElement`/`ErrorBoundary`, `shouldRevalidate`, `handle`).
+
+  Lazy routes are resolved on initial load and during the `loading` or `submitting` phase of a navigation or fetcher call. You cannot lazily define route-matching properties (`path`, `index`, `children`) since we only execute your lazy route functions after we've matched known routes.
+
+  Your `lazy` functions will typically return the result of a dynamic import.
+
+  ```jsx
+  // In this example, we assume most folks land on the homepage so we include that
+  // in our critical-path bundle, but then we lazily load modules for /a and /b so
+  // they don't load until the user navigates to those routes
+  let routes = createRoutesFromElements(
+    <Route path="/" element={<Layout />}>
+      <Route index element={<Home />} />
+      <Route path="a" lazy={() => import("./a")} />
+      <Route path="b" lazy={() => import("./b")} />
+    </Route>
+  );
+  ```
+
+  Then in your lazy route modules, export the properties you want defined for the route:
+
+  ```jsx
+  export async function loader({ request }) {
+    let data = await fetchData(request);
+    return json(data);
+  }
+
+  // Export a `Component` directly instead of needing to create a React Element from it
+  export function Component() {
+    let data = useLoaderData();
+
+    return (
+      <>
+        <h1>You made it!</h1>
+        <p>{data}</p>
+      </>
+    );
+  }
+
+  // Export an `ErrorBoundary` directly instead of needing to create a React Element from it
+  export function ErrorBoundary() {
+    let error = useRouteError();
+    return isRouteErrorResponse(error) ? (
+      <h1>
+        {error.status} {error.statusText}
+      </h1>
+    ) : (
+      <h1>{error.message || error}</h1>
+    );
+  }
+  ```
+
+  An example of this in action can be found in the [`examples/lazy-loading-router-provider`](https://github.com/remix-run/react-router/tree/main/examples/lazy-loading-router-provider) directory of the repository.
+
+  🙌 Huge thanks to @rossipedia for the [Initial Proposal](https://github.com/remix-run/react-router/discussions/9826) and [POC Implementation](https://github.com/remix-run/react-router/pull/9830).
+
+### Patch Changes
+
+- Fix `generatePath` incorrectly applying parameters in some cases ([#10078](https://github.com/remix-run/react-router/pull/10078))
+
+## 1.3.3
+
+### Patch Changes
+
+- Correctly perform a hard redirect for same-origin absolute URLs outside of the router `basename` ([#10076](https://github.com/remix-run/react-router/pull/10076))
+- Ensure status code and headers are maintained for `defer` loader responses in `createStaticHandler`'s `query()` method ([#10077](https://github.com/remix-run/react-router/pull/10077))
+- Change `invariant` to an `UNSAFE_invariant` export since it's only intended for internal use ([#10066](https://github.com/remix-run/react-router/pull/10066))
+- Add internal API for custom HMR implementations ([#9996](https://github.com/remix-run/react-router/pull/9996))
+
+## 1.3.2
+
+### Patch Changes
+
+- Remove inaccurate console warning for POP navigations and update active blocker logic ([#10030](https://github.com/remix-run/react-router/pull/10030))
+- Only check for differing origin on absolute URL redirects ([#10033](https://github.com/remix-run/react-router/pull/10033))
+
+## 1.3.1
+
+### Patch Changes
+
+- Fixes 2 separate issues for revalidating fetcher `shouldRevalidate` calls ([#9948](https://github.com/remix-run/react-router/pull/9948))
+  - The `shouldRevalidate` function was only being called for _explicit_ revalidation scenarios (after a mutation, manual `useRevalidator` call, or an `X-Remix-Revalidate` header used for cookie setting in Remix). It was not properly being called on _implicit_ revalidation scenarios that also apply to navigation `loader` revalidation, such as a change in search params or clicking a link for the page we're already on. It's now correctly called in those additional scenarios.
+  - The parameters being passed were incorrect and inconsistent with one another since the `current*`/`next*` parameters reflected the static `fetcher.load` URL (and thus were identical). Instead, they should have reflected the the navigation that triggered the revalidation (as the `form*` parameters did). These parameters now correctly reflect the triggering navigation.
+- Respect `preventScrollReset` on `<fetcher.Form>` ([#9963](https://github.com/remix-run/react-router/pull/9963))
+- Do not short circuit on hash change only mutation submissions ([#9944](https://github.com/remix-run/react-router/pull/9944))
+- Remove `instanceof` check from `isRouteErrorResponse` to avoid bundling issues on the server ([#9930](https://github.com/remix-run/react-router/pull/9930))
+- Fix navigation for hash routers on manual URL changes ([#9980](https://github.com/remix-run/react-router/pull/9980))
+- Detect when a `defer` call only contains critical data and remove the `AbortController` ([#9965](https://github.com/remix-run/react-router/pull/9965))
+- Send the name as the value when url-encoding `File` `FormData` entries ([#9867](https://github.com/remix-run/react-router/pull/9867))
+
+## 1.3.0
+
+### Minor Changes
+
+- Added support for navigation blocking APIs ([#9709](https://github.com/remix-run/react-router/pull/9709))
+- Expose deferred information from `createStaticHandler` ([#9760](https://github.com/remix-run/react-router/pull/9760))
+
+### Patch Changes
+
+- Improved absolute redirect url detection in actions/loaders ([#9829](https://github.com/remix-run/react-router/pull/9829))
+- Fix URL creation with memory histories ([#9814](https://github.com/remix-run/react-router/pull/9814))
+- Fix `generatePath` when optional params are present ([#9764](https://github.com/remix-run/react-router/pull/9764))
+- Fix scroll reset if a submission redirects ([#9886](https://github.com/remix-run/react-router/pull/9886))
+- Fix 404 bug with same-origin absolute redirects ([#9913](https://github.com/remix-run/react-router/pull/9913))
+- Support `OPTIONS` requests in `staticHandler.queryRoute` ([#9914](https://github.com/remix-run/react-router/pull/9914))
+
+## 1.2.1
+
+### Patch Changes
+
+- Include submission info in `shouldRevalidate` on action redirects ([#9777](https://github.com/remix-run/react-router/pull/9777), [#9782](https://github.com/remix-run/react-router/pull/9782))
+- Reset `actionData` on action redirect to current location ([#9772](https://github.com/remix-run/react-router/pull/9772))
+
+## 1.2.0
+
+### Minor Changes
+
+- Remove `unstable_` prefix from `createStaticHandler`/`createStaticRouter`/`StaticRouterProvider` ([#9738](https://github.com/remix-run/react-router/pull/9738))
+
+### Patch Changes
+
+- Fix explicit `replace` on submissions and `PUSH` on submission to new paths ([#9734](https://github.com/remix-run/react-router/pull/9734))
+- Fix a few bugs where loader/action data wasn't properly cleared on errors ([#9735](https://github.com/remix-run/react-router/pull/9735))
+- Prevent `useLoaderData` usage in `errorElement` ([#9735](https://github.com/remix-run/react-router/pull/9735))
+- Skip initial scroll restoration for SSR apps with `hydrationData` ([#9664](https://github.com/remix-run/react-router/pull/9664))
+
+## 1.1.0
+
+This release introduces support for [Optional Route Segments](https://github.com/remix-run/react-router/issues/9546). Now, adding a `?` to the end of any path segment will make that entire segment optional. This works for both static segments and dynamic parameters.
+
+**Optional Params Examples**
+
+- Path `lang?/about` will match:
+  - `/:lang/about`
+  - `/about`
+- Path `/multistep/:widget1?/widget2?/widget3?` will match:
+  - `/multistep`
+  - `/multistep/:widget1`
+  - `/multistep/:widget1/:widget2`
+  - `/multistep/:widget1/:widget2/:widget3`
+
+**Optional Static Segment Example**
+
+- Path `/home?` will match:
+  - `/`
+  - `/home`
+- Path `/fr?/about` will match:
+  - `/about`
+  - `/fr/about`
+
+### Minor Changes
+
+- Allows optional routes and optional static segments ([#9650](https://github.com/remix-run/react-router/pull/9650))
+
+### Patch Changes
+
+- Stop incorrectly matching on partial named parameters, i.e. `<Route path="prefix-:param">`, to align with how splat parameters work. If you were previously relying on this behavior then it's recommended to extract the static portion of the path at the `useParams` call site: ([#9506](https://github.com/remix-run/react-router/pull/9506))
+
+```jsx
+// Old behavior at URL /prefix-123
+<Route path="prefix-:id" element={<Comp /> }>
+
+function Comp() {
+  let params = useParams(); // { id: '123' }
+  let id = params.id; // "123"
+  ...
+}
+
+// New behavior at URL /prefix-123
+<Route path=":id" element={<Comp /> }>
+
+function Comp() {
+  let params = useParams(); // { id: 'prefix-123' }
+  let id = params.id.replace(/^prefix-/, ''); // "123"
+  ...
+}
+```
+
+- Persist `headers` on `loader` `request`'s after SSR document `action` request ([#9721](https://github.com/remix-run/react-router/pull/9721))
+- Fix requests sent to revalidating loaders so they reflect a GET request ([#9660](https://github.com/remix-run/react-router/pull/9660))
+- Fix issue with deeply nested optional segments ([#9727](https://github.com/remix-run/react-router/pull/9727))
+- GET forms now expose a submission on the loading navigation ([#9695](https://github.com/remix-run/react-router/pull/9695))
+- Fix error boundary tracking for multiple errors bubbling to the same boundary ([#9702](https://github.com/remix-run/react-router/pull/9702))
+
+## 1.0.5
+
+### Patch Changes
+
+- Fix requests sent to revalidating loaders so they reflect a `GET` request ([#9680](https://github.com/remix-run/react-router/pull/9680))
+- Remove `instanceof Response` checks in favor of `isResponse` ([#9690](https://github.com/remix-run/react-router/pull/9690))
+- Fix `URL` creation in Cloudflare Pages or other non-browser-environments ([#9682](https://github.com/remix-run/react-router/pull/9682), [#9689](https://github.com/remix-run/react-router/pull/9689))
+- Add `requestContext` support to static handler `query`/`queryRoute` ([#9696](https://github.com/remix-run/react-router/pull/9696))
+  - Note that the unstable API of `queryRoute(path, routeId)` has been changed to `queryRoute(path, { routeId, requestContext })`
+
+## 1.0.4
+
+### Patch Changes
+
+- Throw an error if an `action`/`loader` function returns `undefined` as revalidations need to know whether the loader has previously been executed. `undefined` also causes issues during SSR stringification for hydration. You should always ensure you `loader`/`action` returns a value, and you may return `null` if you don't wish to return anything. ([#9511](https://github.com/remix-run/react-router/pull/9511))
+- Properly handle redirects to external domains ([#9590](https://github.com/remix-run/react-router/pull/9590), [#9654](https://github.com/remix-run/react-router/pull/9654))
+- Preserve the HTTP method on 307/308 redirects ([#9597](https://github.com/remix-run/react-router/pull/9597))
+- Support `basename` in static data routers ([#9591](https://github.com/remix-run/react-router/pull/9591))
+- Enhanced `ErrorResponse` bodies to contain more descriptive text in internal 403/404/405 scenarios
+
+## 1.0.3
+
+### Patch Changes
+
+- Fix hrefs generated when using `createHashRouter` ([#9409](https://github.com/remix-run/react-router/pull/9409))
+- fix encoding/matching issues with special chars ([#9477](https://github.com/remix-run/react-router/pull/9477), [#9496](https://github.com/remix-run/react-router/pull/9496))
+- Support `basename` and relative routing in `loader`/`action` redirects ([#9447](https://github.com/remix-run/react-router/pull/9447))
+- Ignore pathless layout routes when looking for proper submission `action` function ([#9455](https://github.com/remix-run/react-router/pull/9455))
+- properly support `index` routes with a `path` in `useResolvedPath` ([#9486](https://github.com/remix-run/react-router/pull/9486))
+- Add UMD build for `@remix-run/router` ([#9446](https://github.com/remix-run/react-router/pull/9446))
+- fix `createURL` in local file execution in Firefox ([#9464](https://github.com/remix-run/react-router/pull/9464))
+- Updates to `unstable_createStaticHandler` for incorporating into Remix ([#9482](https://github.com/remix-run/react-router/pull/9482), [#9465](https://github.com/remix-run/react-router/pull/9465))
+
+## 1.0.2
+
+### Patch Changes
+
+- Reset `actionData` after a successful action redirect ([#9334](https://github.com/remix-run/react-router/pull/9334))
+- Update `matchPath` to avoid false positives on dash-separated segments ([#9300](https://github.com/remix-run/react-router/pull/9300))
+- If an index route has children, it will result in a runtime error. We have strengthened our `RouteObject`/`RouteProps` types to surface the error in TypeScript. ([#9366](https://github.com/remix-run/react-router/pull/9366))
+
+## 1.0.1
+
+### Patch Changes
+
+- Preserve state from `initialEntries` ([#9288](https://github.com/remix-run/react-router/pull/9288))
+- Preserve `?index` for fetcher get submissions to index routes ([#9312](https://github.com/remix-run/react-router/pull/9312))
+
+## 1.0.0
+
+This is the first stable release of `@remix-run/router`, which provides all the underlying routing and data loading/mutation logic for `react-router`. You should _not_ be using this package directly unless you are authoring a routing library similar to `react-router`.
+
+For an overview of the features provided by `react-router`, we recommend you go check out the [docs](https://reactrouter.com), especially the [feature overview](https://reactrouter.com/en/6.4.0/start/overview) and the [tutorial](https://reactrouter.com/en/6.4.0/start/tutorial).
+
+For an overview of the features provided by `@remix-run/router`, please check out the [`README`](./README.md).
Index: frontend/node_modules/@remix-run/router/LICENSE.md
===================================================================
--- frontend/node_modules/@remix-run/router/LICENSE.md	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/@remix-run/router/LICENSE.md	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,23 @@
+MIT License
+
+Copyright (c) React Training LLC 2015-2019
+Copyright (c) Remix Software Inc. 2020-2021
+Copyright (c) Shopify Inc. 2022-2023
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
Index: frontend/node_modules/@remix-run/router/README.md
===================================================================
--- frontend/node_modules/@remix-run/router/README.md	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/@remix-run/router/README.md	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,135 @@
+# Remix Router
+
+The `@remix-run/router` package is a framework-agnostic routing package (sometimes referred to as a browser-emulator) that serves as the heart of [React Router][react-router] and [Remix][remix] and provides all the core functionality for routing coupled with data loading and data mutations. It comes with built-in handling of errors, race-conditions, interruptions, cancellations, lazy-loading data, and much, much more.
+
+If you're using React Router, you should never `import` anything directly from the `@remix-run/router` - you should have everything you need in `react-router-dom` (or `react-router`/`react-router-native` if you're not rendering in the browser). All of those packages should re-export everything you would otherwise need from `@remix-run/router`.
+
+> [!WARNING]
+>
+> This router is a low-level package intended to be consumed by UI layer routing libraries. You should very likely not be using this package directly unless you are authoring a routing library such as [`react-router-dom`][react-router-repo] or one of it's other [UI ports][remix-routers-repo].
+
+## API
+
+A Router instance can be created using `createRouter`:
+
+```js
+// Create and initialize a router.  "initialize" contains all side effects
+// including history listeners and kicking off the initial data fetch
+let router = createRouter({
+  // Required properties
+  routes: [{
+    path: '/',
+    loader: ({ request, params }) => { /* ... */ },
+    children: [{
+      path: 'home',
+      loader: ({ request, params }) => { /* ... */ },
+    }]
+  },
+  history: createBrowserHistory(),
+
+  // Optional properties
+  basename, // Base path
+  mapRouteProperties, // Map framework-agnostic routes to framework-aware routes
+  future, // Future flags
+  hydrationData, // Hydration data if using server-side-rendering
+}).initialize();
+```
+
+Internally, the Router represents the state in an object of the following format, which is available through `router.state`. You can also register a subscriber of the signature `(state: RouterState) => void` to execute when the state updates via `router.subscribe()`;
+
+```ts
+interface RouterState {
+  // False during the initial data load, true once we have our initial data
+  initialized: boolean;
+  // The `history` action of the most recently completed navigation
+  historyAction: Action;
+  // The current location of the router.  During a navigation this reflects
+  // the "old" location and is updated upon completion of the navigation
+  location: Location;
+  // The current set of route matches
+  matches: DataRouteMatch[];
+  // The state of the current navigation
+  navigation: Navigation;
+  // The state of any in-progress router.revalidate() calls
+  revalidation: RevalidationState;
+  // Data from the loaders for the current matches
+  loaderData: RouteData;
+  // Data from the action for the current matches
+  actionData: RouteData | null;
+  // Errors thrown from loaders/actions for the current matches
+  errors: RouteData | null;
+  // Map of all active fetchers
+  fetchers: Map<string, Fetcher>;
+  // Scroll position to restore to for the active Location, false if we
+  // should not restore, or null if we don't have a saved position
+  // Note: must be enabled via router.enableScrollRestoration()
+  restoreScrollPosition: number | false | null;
+  // Proxied `preventScrollReset` value passed to router.navigate()
+  preventScrollReset: boolean;
+}
+```
+
+### Navigations
+
+All navigations are done through the `router.navigate` API which is overloaded to support different types of navigations:
+
+```js
+// Link navigation (pushes onto the history stack by default)
+router.navigate("/page");
+
+// Link navigation (replacing the history stack)
+router.navigate("/page", { replace: true });
+
+// Pop navigation (moving backward/forward in the history stack)
+router.navigate(-1);
+
+// Form submission navigation
+let formData = new FormData();
+formData.append(key, value);
+router.navigate("/page", {
+  formMethod: "post",
+  formData,
+});
+
+// Relative routing from a source routeId
+router.navigate("../../somewhere", {
+  fromRouteId: "active-route-id",
+});
+```
+
+### Fetchers
+
+Fetchers are a mechanism to call loaders/actions without triggering a navigation, and are done through the `router.fetch()` API. All fetch calls require a unique key to identify the fetcher.
+
+```js
+// Execute the loader for /page
+router.fetch("key", "/page");
+
+// Submit to the action for /page
+let formData = new FormData();
+formData.append(key, value);
+router.fetch("key", "/page", {
+  formMethod: "post",
+  formData,
+});
+```
+
+### Revalidation
+
+By default, active loaders will revalidate after any navigation or fetcher mutation. If you need to kick off a revalidation for other use-cases, you can use `router.revalidate()` to re-execute all active loaders.
+
+### Future Flags
+
+We use _Future Flags_ in the router to help us introduce breaking changes in an opt-in fashion ahead of major releases. Please check out the [blog post][future-flags-post] and [React Router Docs][api-development-strategy] for more information on this process. The currently available future flags in `@remix-run/router` are:
+
+| Flag                     | Description                                                               |
+| ------------------------ | ------------------------------------------------------------------------- |
+| `v7_normalizeFormMethod` | Normalize `useNavigation().formMethod` to be an uppercase HTTP Method     |
+| `v7_prependBasename`     | Prepend the `basename` to incoming `router.navigate`/`router.fetch` paths |
+
+[react-router]: https://reactrouter.com
+[remix]: https://remix.run
+[react-router-repo]: https://github.com/remix-run/react-router
+[remix-routers-repo]: https://github.com/brophdawg11/remix-routers
+[api-development-strategy]: https://reactrouter.com/v6/guides/api-development-strategy
+[future-flags-post]: https://remix.run/blog/future-flags
Index: frontend/node_modules/@remix-run/router/dist/history.d.ts
===================================================================
--- frontend/node_modules/@remix-run/router/dist/history.d.ts	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/@remix-run/router/dist/history.d.ts	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,250 @@
+/**
+ * Actions represent the type of change to a location value.
+ */
+export declare enum Action {
+    /**
+     * A POP indicates a change to an arbitrary index in the history stack, such
+     * as a back or forward navigation. It does not describe the direction of the
+     * navigation, only that the current index changed.
+     *
+     * Note: This is the default action for newly created history objects.
+     */
+    Pop = "POP",
+    /**
+     * A PUSH indicates a new entry being added to the history stack, such as when
+     * a link is clicked and a new page loads. When this happens, all subsequent
+     * entries in the stack are lost.
+     */
+    Push = "PUSH",
+    /**
+     * A REPLACE indicates the entry at the current index in the history stack
+     * being replaced by a new one.
+     */
+    Replace = "REPLACE"
+}
+/**
+ * The pathname, search, and hash values of a URL.
+ */
+export interface Path {
+    /**
+     * A URL pathname, beginning with a /.
+     */
+    pathname: string;
+    /**
+     * A URL search string, beginning with a ?.
+     */
+    search: string;
+    /**
+     * A URL fragment identifier, beginning with a #.
+     */
+    hash: string;
+}
+/**
+ * An entry in a history stack. A location contains information about the
+ * URL path, as well as possibly some arbitrary state and a key.
+ */
+export interface Location<State = any> extends Path {
+    /**
+     * A value of arbitrary data associated with this location.
+     */
+    state: State;
+    /**
+     * A unique string associated with this location. May be used to safely store
+     * and retrieve data in some other storage API, like `localStorage`.
+     *
+     * Note: This value is always "default" on the initial location.
+     */
+    key: string;
+}
+/**
+ * A change to the current location.
+ */
+export interface Update {
+    /**
+     * The action that triggered the change.
+     */
+    action: Action;
+    /**
+     * The new location.
+     */
+    location: Location;
+    /**
+     * The delta between this location and the former location in the history stack
+     */
+    delta: number | null;
+}
+/**
+ * A function that receives notifications about location changes.
+ */
+export interface Listener {
+    (update: Update): void;
+}
+/**
+ * Describes a location that is the destination of some navigation, either via
+ * `history.push` or `history.replace`. This may be either a URL or the pieces
+ * of a URL path.
+ */
+export type To = string | Partial<Path>;
+/**
+ * A history is an interface to the navigation stack. The history serves as the
+ * source of truth for the current location, as well as provides a set of
+ * methods that may be used to change it.
+ *
+ * It is similar to the DOM's `window.history` object, but with a smaller, more
+ * focused API.
+ */
+export interface History {
+    /**
+     * The last action that modified the current location. This will always be
+     * Action.Pop when a history instance is first created. This value is mutable.
+     */
+    readonly action: Action;
+    /**
+     * The current location. This value is mutable.
+     */
+    readonly location: Location;
+    /**
+     * Returns a valid href for the given `to` value that may be used as
+     * the value of an <a href> attribute.
+     *
+     * @param to - The destination URL
+     */
+    createHref(to: To): string;
+    /**
+     * Returns a URL for the given `to` value
+     *
+     * @param to - The destination URL
+     */
+    createURL(to: To): URL;
+    /**
+     * Encode a location the same way window.history would do (no-op for memory
+     * history) so we ensure our PUSH/REPLACE navigations for data routers
+     * behave the same as POP
+     *
+     * @param to Unencoded path
+     */
+    encodeLocation(to: To): Path;
+    /**
+     * Pushes a new location onto the history stack, increasing its length by one.
+     * If there were any entries in the stack after the current one, they are
+     * lost.
+     *
+     * @param to - The new URL
+     * @param state - Data to associate with the new location
+     */
+    push(to: To, state?: any): void;
+    /**
+     * Replaces the current location in the history stack with a new one.  The
+     * location that was replaced will no longer be available.
+     *
+     * @param to - The new URL
+     * @param state - Data to associate with the new location
+     */
+    replace(to: To, state?: any): void;
+    /**
+     * Navigates `n` entries backward/forward in the history stack relative to the
+     * current index. For example, a "back" navigation would use go(-1).
+     *
+     * @param delta - The delta in the stack index
+     */
+    go(delta: number): void;
+    /**
+     * Sets up a listener that will be called whenever the current location
+     * changes.
+     *
+     * @param listener - A function that will be called when the location changes
+     * @returns unlisten - A function that may be used to stop listening
+     */
+    listen(listener: Listener): () => void;
+}
+/**
+ * A user-supplied object that describes a location. Used when providing
+ * entries to `createMemoryHistory` via its `initialEntries` option.
+ */
+export type InitialEntry = string | Partial<Location>;
+export type MemoryHistoryOptions = {
+    initialEntries?: InitialEntry[];
+    initialIndex?: number;
+    v5Compat?: boolean;
+};
+/**
+ * A memory history stores locations in memory. This is useful in stateful
+ * environments where there is no web browser, such as node tests or React
+ * Native.
+ */
+export interface MemoryHistory extends History {
+    /**
+     * The current index in the history stack.
+     */
+    readonly index: number;
+}
+/**
+ * Memory history stores the current location in memory. It is designed for use
+ * in stateful non-browser environments like tests and React Native.
+ */
+export declare function createMemoryHistory(options?: MemoryHistoryOptions): MemoryHistory;
+/**
+ * A browser history stores the current location in regular URLs in a web
+ * browser environment. This is the standard for most web apps and provides the
+ * cleanest URLs the browser's address bar.
+ *
+ * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#browserhistory
+ */
+export interface BrowserHistory extends UrlHistory {
+}
+export type BrowserHistoryOptions = UrlHistoryOptions;
+/**
+ * Browser history stores the location in regular URLs. This is the standard for
+ * most web apps, but it requires some configuration on the server to ensure you
+ * serve the same app at multiple URLs.
+ *
+ * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createbrowserhistory
+ */
+export declare function createBrowserHistory(options?: BrowserHistoryOptions): BrowserHistory;
+/**
+ * A hash history stores the current location in the fragment identifier portion
+ * of the URL in a web browser environment.
+ *
+ * This is ideal for apps that do not control the server for some reason
+ * (because the fragment identifier is never sent to the server), including some
+ * shared hosting environments that do not provide fine-grained controls over
+ * which pages are served at which URLs.
+ *
+ * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#hashhistory
+ */
+export interface HashHistory extends UrlHistory {
+}
+export type HashHistoryOptions = UrlHistoryOptions;
+/**
+ * Hash history stores the location in window.location.hash. This makes it ideal
+ * for situations where you don't want to send the location to the server for
+ * some reason, either because you do cannot configure it or the URL space is
+ * reserved for something else.
+ *
+ * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createhashhistory
+ */
+export declare function createHashHistory(options?: HashHistoryOptions): HashHistory;
+/**
+ * @private
+ */
+export declare function invariant(value: boolean, message?: string): asserts value;
+export declare function invariant<T>(value: T | null | undefined, message?: string): asserts value is T;
+export declare function warning(cond: any, message: string): void;
+/**
+ * Creates a Location object with a unique key from the given Path
+ */
+export declare function createLocation(current: string | Location, to: To, state?: any, key?: string): Readonly<Location>;
+/**
+ * Creates a string URL path from the given pathname, search, and hash components.
+ */
+export declare function createPath({ pathname, search, hash, }: Partial<Path>): string;
+/**
+ * Parses a string URL path into its separate pathname, search, and hash components.
+ */
+export declare function parsePath(path: string): Partial<Path>;
+export interface UrlHistory extends History {
+}
+export type UrlHistoryOptions = {
+    window?: Window;
+    v5Compat?: boolean;
+};
Index: frontend/node_modules/@remix-run/router/dist/index.d.ts
===================================================================
--- frontend/node_modules/@remix-run/router/dist/index.d.ts	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/@remix-run/router/dist/index.d.ts	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,9 @@
+export type { ActionFunction, ActionFunctionArgs, AgnosticDataIndexRouteObject, AgnosticDataNonIndexRouteObject, AgnosticDataRouteMatch, AgnosticDataRouteObject, AgnosticIndexRouteObject, AgnosticNonIndexRouteObject, AgnosticPatchRoutesOnNavigationFunction, AgnosticPatchRoutesOnNavigationFunctionArgs, AgnosticRouteMatch, AgnosticRouteObject, DataStrategyFunction, DataStrategyFunctionArgs, DataStrategyMatch, DataStrategyResult, ErrorResponse, FormEncType, FormMethod, HTMLFormMethod, JsonFunction, LazyRouteFunction, LoaderFunction, LoaderFunctionArgs, ParamParseKey, Params, PathMatch, PathParam, PathPattern, RedirectFunction, ShouldRevalidateFunction, ShouldRevalidateFunctionArgs, TrackedPromise, UIMatch, V7_FormMethod, DataWithResponseInit as UNSAFE_DataWithResponseInit, } from "./utils";
+export { AbortedDeferredError, data, defer, generatePath, getToPathname, isRouteErrorResponse, joinPaths, json, matchPath, matchRoutes, normalizePathname, redirect, redirectDocument, replace, resolvePath, resolveTo, stripBasename, } from "./utils";
+export type { BrowserHistory, BrowserHistoryOptions, HashHistory, HashHistoryOptions, History, InitialEntry, Location, MemoryHistory, MemoryHistoryOptions, Path, To, } from "./history";
+export { Action, createBrowserHistory, createHashHistory, createMemoryHistory, createPath, parsePath, } from "./history";
+export * from "./router";
+/** @internal */
+export type { RouteManifest as UNSAFE_RouteManifest } from "./utils";
+export { DeferredData as UNSAFE_DeferredData, ErrorResponseImpl as UNSAFE_ErrorResponseImpl, convertRoutesToDataRoutes as UNSAFE_convertRoutesToDataRoutes, convertRouteMatchToUiMatch as UNSAFE_convertRouteMatchToUiMatch, decodePath as UNSAFE_decodePath, getResolveToMatches as UNSAFE_getResolveToMatches, } from "./utils";
+export { invariant as UNSAFE_invariant, warning as UNSAFE_warning, } from "./history";
Index: frontend/node_modules/@remix-run/router/dist/router.cjs.js
===================================================================
--- frontend/node_modules/@remix-run/router/dist/router.cjs.js	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/@remix-run/router/dist/router.cjs.js	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,5641 @@
+/**
+ * @remix-run/router v1.23.2
+ *
+ * Copyright (c) Remix Software Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE.md file in the root directory of this source tree.
+ *
+ * @license MIT
+ */
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function _extends() {
+  _extends = Object.assign ? Object.assign.bind() : function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+    return target;
+  };
+  return _extends.apply(this, arguments);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//#region Types and Constants
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Actions represent the type of change to a location value.
+ */
+let Action = /*#__PURE__*/function (Action) {
+  Action["Pop"] = "POP";
+  Action["Push"] = "PUSH";
+  Action["Replace"] = "REPLACE";
+  return Action;
+}({});
+
+/**
+ * The pathname, search, and hash values of a URL.
+ */
+
+// TODO: (v7) Change the Location generic default from `any` to `unknown` and
+// remove Remix `useLocation` wrapper.
+/**
+ * An entry in a history stack. A location contains information about the
+ * URL path, as well as possibly some arbitrary state and a key.
+ */
+/**
+ * A change to the current location.
+ */
+/**
+ * A function that receives notifications about location changes.
+ */
+/**
+ * Describes a location that is the destination of some navigation, either via
+ * `history.push` or `history.replace`. This may be either a URL or the pieces
+ * of a URL path.
+ */
+/**
+ * A history is an interface to the navigation stack. The history serves as the
+ * source of truth for the current location, as well as provides a set of
+ * methods that may be used to change it.
+ *
+ * It is similar to the DOM's `window.history` object, but with a smaller, more
+ * focused API.
+ */
+const PopStateEventType = "popstate";
+//#endregion
+
+////////////////////////////////////////////////////////////////////////////////
+//#region Memory History
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * A user-supplied object that describes a location. Used when providing
+ * entries to `createMemoryHistory` via its `initialEntries` option.
+ */
+/**
+ * A memory history stores locations in memory. This is useful in stateful
+ * environments where there is no web browser, such as node tests or React
+ * Native.
+ */
+/**
+ * Memory history stores the current location in memory. It is designed for use
+ * in stateful non-browser environments like tests and React Native.
+ */
+function createMemoryHistory(options) {
+  if (options === void 0) {
+    options = {};
+  }
+  let {
+    initialEntries = ["/"],
+    initialIndex,
+    v5Compat = false
+  } = options;
+  let entries; // Declare so we can access from createMemoryLocation
+  entries = initialEntries.map((entry, index) => createMemoryLocation(entry, typeof entry === "string" ? null : entry.state, index === 0 ? "default" : undefined));
+  let index = clampIndex(initialIndex == null ? entries.length - 1 : initialIndex);
+  let action = Action.Pop;
+  let listener = null;
+  function clampIndex(n) {
+    return Math.min(Math.max(n, 0), entries.length - 1);
+  }
+  function getCurrentLocation() {
+    return entries[index];
+  }
+  function createMemoryLocation(to, state, key) {
+    if (state === void 0) {
+      state = null;
+    }
+    let location = createLocation(entries ? getCurrentLocation().pathname : "/", to, state, key);
+    warning(location.pathname.charAt(0) === "/", "relative pathnames are not supported in memory history: " + JSON.stringify(to));
+    return location;
+  }
+  function createHref(to) {
+    return typeof to === "string" ? to : createPath(to);
+  }
+  let history = {
+    get index() {
+      return index;
+    },
+    get action() {
+      return action;
+    },
+    get location() {
+      return getCurrentLocation();
+    },
+    createHref,
+    createURL(to) {
+      return new URL(createHref(to), "http://localhost");
+    },
+    encodeLocation(to) {
+      let path = typeof to === "string" ? parsePath(to) : to;
+      return {
+        pathname: path.pathname || "",
+        search: path.search || "",
+        hash: path.hash || ""
+      };
+    },
+    push(to, state) {
+      action = Action.Push;
+      let nextLocation = createMemoryLocation(to, state);
+      index += 1;
+      entries.splice(index, entries.length, nextLocation);
+      if (v5Compat && listener) {
+        listener({
+          action,
+          location: nextLocation,
+          delta: 1
+        });
+      }
+    },
+    replace(to, state) {
+      action = Action.Replace;
+      let nextLocation = createMemoryLocation(to, state);
+      entries[index] = nextLocation;
+      if (v5Compat && listener) {
+        listener({
+          action,
+          location: nextLocation,
+          delta: 0
+        });
+      }
+    },
+    go(delta) {
+      action = Action.Pop;
+      let nextIndex = clampIndex(index + delta);
+      let nextLocation = entries[nextIndex];
+      index = nextIndex;
+      if (listener) {
+        listener({
+          action,
+          location: nextLocation,
+          delta
+        });
+      }
+    },
+    listen(fn) {
+      listener = fn;
+      return () => {
+        listener = null;
+      };
+    }
+  };
+  return history;
+}
+//#endregion
+
+////////////////////////////////////////////////////////////////////////////////
+//#region Browser History
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * A browser history stores the current location in regular URLs in a web
+ * browser environment. This is the standard for most web apps and provides the
+ * cleanest URLs the browser's address bar.
+ *
+ * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#browserhistory
+ */
+/**
+ * Browser history stores the location in regular URLs. This is the standard for
+ * most web apps, but it requires some configuration on the server to ensure you
+ * serve the same app at multiple URLs.
+ *
+ * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createbrowserhistory
+ */
+function createBrowserHistory(options) {
+  if (options === void 0) {
+    options = {};
+  }
+  function createBrowserLocation(window, globalHistory) {
+    let {
+      pathname,
+      search,
+      hash
+    } = window.location;
+    return createLocation("", {
+      pathname,
+      search,
+      hash
+    },
+    // state defaults to `null` because `window.history.state` does
+    globalHistory.state && globalHistory.state.usr || null, globalHistory.state && globalHistory.state.key || "default");
+  }
+  function createBrowserHref(window, to) {
+    return typeof to === "string" ? to : createPath(to);
+  }
+  return getUrlBasedHistory(createBrowserLocation, createBrowserHref, null, options);
+}
+//#endregion
+
+////////////////////////////////////////////////////////////////////////////////
+//#region Hash History
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * A hash history stores the current location in the fragment identifier portion
+ * of the URL in a web browser environment.
+ *
+ * This is ideal for apps that do not control the server for some reason
+ * (because the fragment identifier is never sent to the server), including some
+ * shared hosting environments that do not provide fine-grained controls over
+ * which pages are served at which URLs.
+ *
+ * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#hashhistory
+ */
+/**
+ * Hash history stores the location in window.location.hash. This makes it ideal
+ * for situations where you don't want to send the location to the server for
+ * some reason, either because you do cannot configure it or the URL space is
+ * reserved for something else.
+ *
+ * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createhashhistory
+ */
+function createHashHistory(options) {
+  if (options === void 0) {
+    options = {};
+  }
+  function createHashLocation(window, globalHistory) {
+    let {
+      pathname = "/",
+      search = "",
+      hash = ""
+    } = parsePath(window.location.hash.substr(1));
+
+    // Hash URL should always have a leading / just like window.location.pathname
+    // does, so if an app ends up at a route like /#something then we add a
+    // leading slash so all of our path-matching behaves the same as if it would
+    // in a browser router.  This is particularly important when there exists a
+    // root splat route (<Route path="*">) since that matches internally against
+    // "/*" and we'd expect /#something to 404 in a hash router app.
+    if (!pathname.startsWith("/") && !pathname.startsWith(".")) {
+      pathname = "/" + pathname;
+    }
+    return createLocation("", {
+      pathname,
+      search,
+      hash
+    },
+    // state defaults to `null` because `window.history.state` does
+    globalHistory.state && globalHistory.state.usr || null, globalHistory.state && globalHistory.state.key || "default");
+  }
+  function createHashHref(window, to) {
+    let base = window.document.querySelector("base");
+    let href = "";
+    if (base && base.getAttribute("href")) {
+      let url = window.location.href;
+      let hashIndex = url.indexOf("#");
+      href = hashIndex === -1 ? url : url.slice(0, hashIndex);
+    }
+    return href + "#" + (typeof to === "string" ? to : createPath(to));
+  }
+  function validateHashLocation(location, to) {
+    warning(location.pathname.charAt(0) === "/", "relative pathnames are not supported in hash history.push(" + JSON.stringify(to) + ")");
+  }
+  return getUrlBasedHistory(createHashLocation, createHashHref, validateHashLocation, options);
+}
+//#endregion
+
+////////////////////////////////////////////////////////////////////////////////
+//#region UTILS
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * @private
+ */
+function invariant(value, message) {
+  if (value === false || value === null || typeof value === "undefined") {
+    throw new Error(message);
+  }
+}
+function warning(cond, message) {
+  if (!cond) {
+    // eslint-disable-next-line no-console
+    if (typeof console !== "undefined") console.warn(message);
+    try {
+      // Welcome to debugging history!
+      //
+      // This error is thrown as a convenience, so you can more easily
+      // find the source for a warning that appears in the console by
+      // enabling "pause on exceptions" in your JavaScript debugger.
+      throw new Error(message);
+      // eslint-disable-next-line no-empty
+    } catch (e) {}
+  }
+}
+function createKey() {
+  return Math.random().toString(36).substr(2, 8);
+}
+
+/**
+ * For browser-based histories, we combine the state and key into an object
+ */
+function getHistoryState(location, index) {
+  return {
+    usr: location.state,
+    key: location.key,
+    idx: index
+  };
+}
+
+/**
+ * Creates a Location object with a unique key from the given Path
+ */
+function createLocation(current, to, state, key) {
+  if (state === void 0) {
+    state = null;
+  }
+  let location = _extends({
+    pathname: typeof current === "string" ? current : current.pathname,
+    search: "",
+    hash: ""
+  }, typeof to === "string" ? parsePath(to) : to, {
+    state,
+    // TODO: This could be cleaned up.  push/replace should probably just take
+    // full Locations now and avoid the need to run through this flow at all
+    // But that's a pretty big refactor to the current test suite so going to
+    // keep as is for the time being and just let any incoming keys take precedence
+    key: to && to.key || key || createKey()
+  });
+  return location;
+}
+
+/**
+ * Creates a string URL path from the given pathname, search, and hash components.
+ */
+function createPath(_ref) {
+  let {
+    pathname = "/",
+    search = "",
+    hash = ""
+  } = _ref;
+  if (search && search !== "?") pathname += search.charAt(0) === "?" ? search : "?" + search;
+  if (hash && hash !== "#") pathname += hash.charAt(0) === "#" ? hash : "#" + hash;
+  return pathname;
+}
+
+/**
+ * Parses a string URL path into its separate pathname, search, and hash components.
+ */
+function parsePath(path) {
+  let parsedPath = {};
+  if (path) {
+    let hashIndex = path.indexOf("#");
+    if (hashIndex >= 0) {
+      parsedPath.hash = path.substr(hashIndex);
+      path = path.substr(0, hashIndex);
+    }
+    let searchIndex = path.indexOf("?");
+    if (searchIndex >= 0) {
+      parsedPath.search = path.substr(searchIndex);
+      path = path.substr(0, searchIndex);
+    }
+    if (path) {
+      parsedPath.pathname = path;
+    }
+  }
+  return parsedPath;
+}
+function getUrlBasedHistory(getLocation, createHref, validateLocation, options) {
+  if (options === void 0) {
+    options = {};
+  }
+  let {
+    window = document.defaultView,
+    v5Compat = false
+  } = options;
+  let globalHistory = window.history;
+  let action = Action.Pop;
+  let listener = null;
+  let index = getIndex();
+  // Index should only be null when we initialize. If not, it's because the
+  // user called history.pushState or history.replaceState directly, in which
+  // case we should log a warning as it will result in bugs.
+  if (index == null) {
+    index = 0;
+    globalHistory.replaceState(_extends({}, globalHistory.state, {
+      idx: index
+    }), "");
+  }
+  function getIndex() {
+    let state = globalHistory.state || {
+      idx: null
+    };
+    return state.idx;
+  }
+  function handlePop() {
+    action = Action.Pop;
+    let nextIndex = getIndex();
+    let delta = nextIndex == null ? null : nextIndex - index;
+    index = nextIndex;
+    if (listener) {
+      listener({
+        action,
+        location: history.location,
+        delta
+      });
+    }
+  }
+  function push(to, state) {
+    action = Action.Push;
+    let location = createLocation(history.location, to, state);
+    if (validateLocation) validateLocation(location, to);
+    index = getIndex() + 1;
+    let historyState = getHistoryState(location, index);
+    let url = history.createHref(location);
+
+    // try...catch because iOS limits us to 100 pushState calls :/
+    try {
+      globalHistory.pushState(historyState, "", url);
+    } catch (error) {
+      // If the exception is because `state` can't be serialized, let that throw
+      // outwards just like a replace call would so the dev knows the cause
+      // https://html.spec.whatwg.org/multipage/nav-history-apis.html#shared-history-push/replace-state-steps
+      // https://html.spec.whatwg.org/multipage/structured-data.html#structuredserializeinternal
+      if (error instanceof DOMException && error.name === "DataCloneError") {
+        throw error;
+      }
+      // They are going to lose state here, but there is no real
+      // way to warn them about it since the page will refresh...
+      window.location.assign(url);
+    }
+    if (v5Compat && listener) {
+      listener({
+        action,
+        location: history.location,
+        delta: 1
+      });
+    }
+  }
+  function replace(to, state) {
+    action = Action.Replace;
+    let location = createLocation(history.location, to, state);
+    if (validateLocation) validateLocation(location, to);
+    index = getIndex();
+    let historyState = getHistoryState(location, index);
+    let url = history.createHref(location);
+    globalHistory.replaceState(historyState, "", url);
+    if (v5Compat && listener) {
+      listener({
+        action,
+        location: history.location,
+        delta: 0
+      });
+    }
+  }
+  function createURL(to) {
+    // window.location.origin is "null" (the literal string value) in Firefox
+    // under certain conditions, notably when serving from a local HTML file
+    // See https://bugzilla.mozilla.org/show_bug.cgi?id=878297
+    let base = window.location.origin !== "null" ? window.location.origin : window.location.href;
+    let href = typeof to === "string" ? to : createPath(to);
+    // Treating this as a full URL will strip any trailing spaces so we need to
+    // pre-encode them since they might be part of a matching splat param from
+    // an ancestor route
+    href = href.replace(/ $/, "%20");
+    invariant(base, "No window.location.(origin|href) available to create URL for href: " + href);
+    return new URL(href, base);
+  }
+  let history = {
+    get action() {
+      return action;
+    },
+    get location() {
+      return getLocation(window, globalHistory);
+    },
+    listen(fn) {
+      if (listener) {
+        throw new Error("A history only accepts one active listener");
+      }
+      window.addEventListener(PopStateEventType, handlePop);
+      listener = fn;
+      return () => {
+        window.removeEventListener(PopStateEventType, handlePop);
+        listener = null;
+      };
+    },
+    createHref(to) {
+      return createHref(window, to);
+    },
+    createURL,
+    encodeLocation(to) {
+      // Encode a Location the same way window.location would
+      let url = createURL(to);
+      return {
+        pathname: url.pathname,
+        search: url.search,
+        hash: url.hash
+      };
+    },
+    push,
+    replace,
+    go(n) {
+      return globalHistory.go(n);
+    }
+  };
+  return history;
+}
+
+//#endregion
+
+/**
+ * Map of routeId -> data returned from a loader/action/error
+ */
+
+let ResultType = /*#__PURE__*/function (ResultType) {
+  ResultType["data"] = "data";
+  ResultType["deferred"] = "deferred";
+  ResultType["redirect"] = "redirect";
+  ResultType["error"] = "error";
+  return ResultType;
+}({});
+
+/**
+ * Successful result from a loader or action
+ */
+
+/**
+ * Successful defer() result from a loader or action
+ */
+
+/**
+ * Redirect result from a loader or action
+ */
+
+/**
+ * Unsuccessful result from a loader or action
+ */
+
+/**
+ * Result from a loader or action - potentially successful or unsuccessful
+ */
+
+/**
+ * Users can specify either lowercase or uppercase form methods on `<Form>`,
+ * useSubmit(), `<fetcher.Form>`, etc.
+ */
+
+/**
+ * Active navigation/fetcher form methods are exposed in lowercase on the
+ * RouterState
+ */
+
+/**
+ * In v7, active navigation/fetcher form methods are exposed in uppercase on the
+ * RouterState.  This is to align with the normalization done via fetch().
+ */
+
+// Thanks https://github.com/sindresorhus/type-fest!
+
+/**
+ * @private
+ * Internal interface to pass around for action submissions, not intended for
+ * external consumption
+ */
+
+/**
+ * @private
+ * Arguments passed to route loader/action functions.  Same for now but we keep
+ * this as a private implementation detail in case they diverge in the future.
+ */
+
+// TODO: (v7) Change the defaults from any to unknown in and remove Remix wrappers:
+//   ActionFunction, ActionFunctionArgs, LoaderFunction, LoaderFunctionArgs
+//   Also, make them a type alias instead of an interface
+/**
+ * Arguments passed to loader functions
+ */
+/**
+ * Arguments passed to action functions
+ */
+/**
+ * Loaders and actions can return anything except `undefined` (`null` is a
+ * valid return value if there is no data to return).  Responses are preferred
+ * and will ease any future migration to Remix
+ */
+/**
+ * Route loader function signature
+ */
+/**
+ * Route action function signature
+ */
+/**
+ * Arguments passed to shouldRevalidate function
+ */
+/**
+ * Route shouldRevalidate function signature.  This runs after any submission
+ * (navigation or fetcher), so we flatten the navigation/fetcher submission
+ * onto the arguments.  It shouldn't matter whether it came from a navigation
+ * or a fetcher, what really matters is the URLs and the formData since loaders
+ * have to re-run based on the data models that were potentially mutated.
+ */
+/**
+ * Function provided by the framework-aware layers to set `hasErrorBoundary`
+ * from the framework-aware `errorElement` prop
+ *
+ * @deprecated Use `mapRouteProperties` instead
+ */
+/**
+ * Result from a loader or action called via dataStrategy
+ */
+/**
+ * Function provided by the framework-aware layers to set any framework-specific
+ * properties from framework-agnostic properties
+ */
+/**
+ * Keys we cannot change from within a lazy() function. We spread all other keys
+ * onto the route. Either they're meaningful to the router, or they'll get
+ * ignored.
+ */
+const immutableRouteKeys = new Set(["lazy", "caseSensitive", "path", "id", "index", "children"]);
+
+/**
+ * lazy() function to load a route definition, which can add non-matching
+ * related properties to a route
+ */
+
+/**
+ * Base RouteObject with common props shared by all types of routes
+ */
+
+/**
+ * Index routes must not have children
+ */
+
+/**
+ * Non-index routes may have children, but cannot have index
+ */
+
+/**
+ * A route object represents a logical route, with (optionally) its child
+ * routes organized in a tree-like structure.
+ */
+
+/**
+ * A data route object, which is just a RouteObject with a required unique ID
+ */
+
+// Recursive helper for finding path parameters in the absence of wildcards
+
+/**
+ * Examples:
+ * "/a/b/*" -> "*"
+ * ":a" -> "a"
+ * "/a/:b" -> "b"
+ * "/a/blahblahblah:b" -> "b"
+ * "/:a/:b" -> "a" | "b"
+ * "/:a/b/:c/*" -> "a" | "c" | "*"
+ */
+
+// Attempt to parse the given string segment. If it fails, then just return the
+// plain string type as a default fallback. Otherwise, return the union of the
+// parsed string literals that were referenced as dynamic segments in the route.
+/**
+ * The parameters that were parsed from the URL path.
+ */
+/**
+ * A RouteMatch contains info about how a route matched a URL.
+ */
+function isIndexRoute(route) {
+  return route.index === true;
+}
+
+// Walk the route tree generating unique IDs where necessary, so we are working
+// solely with AgnosticDataRouteObject's within the Router
+function convertRoutesToDataRoutes(routes, mapRouteProperties, parentPath, manifest) {
+  if (parentPath === void 0) {
+    parentPath = [];
+  }
+  if (manifest === void 0) {
+    manifest = {};
+  }
+  return routes.map((route, index) => {
+    let treePath = [...parentPath, String(index)];
+    let id = typeof route.id === "string" ? route.id : treePath.join("-");
+    invariant(route.index !== true || !route.children, "Cannot specify children on an index route");
+    invariant(!manifest[id], "Found a route id collision on id \"" + id + "\".  Route " + "id's must be globally unique within Data Router usages");
+    if (isIndexRoute(route)) {
+      let indexRoute = _extends({}, route, mapRouteProperties(route), {
+        id
+      });
+      manifest[id] = indexRoute;
+      return indexRoute;
+    } else {
+      let pathOrLayoutRoute = _extends({}, route, mapRouteProperties(route), {
+        id,
+        children: undefined
+      });
+      manifest[id] = pathOrLayoutRoute;
+      if (route.children) {
+        pathOrLayoutRoute.children = convertRoutesToDataRoutes(route.children, mapRouteProperties, treePath, manifest);
+      }
+      return pathOrLayoutRoute;
+    }
+  });
+}
+
+/**
+ * Matches the given routes to a location and returns the match data.
+ *
+ * @see https://reactrouter.com/v6/utils/match-routes
+ */
+function matchRoutes(routes, locationArg, basename) {
+  if (basename === void 0) {
+    basename = "/";
+  }
+  return matchRoutesImpl(routes, locationArg, basename, false);
+}
+function matchRoutesImpl(routes, locationArg, basename, allowPartial) {
+  let location = typeof locationArg === "string" ? parsePath(locationArg) : locationArg;
+  let pathname = stripBasename(location.pathname || "/", basename);
+  if (pathname == null) {
+    return null;
+  }
+  let branches = flattenRoutes(routes);
+  rankRouteBranches(branches);
+  let matches = null;
+  for (let i = 0; matches == null && i < branches.length; ++i) {
+    // Incoming pathnames are generally encoded from either window.location
+    // or from router.navigate, but we want to match against the unencoded
+    // paths in the route definitions.  Memory router locations won't be
+    // encoded here but there also shouldn't be anything to decode so this
+    // should be a safe operation.  This avoids needing matchRoutes to be
+    // history-aware.
+    let decoded = decodePath(pathname);
+    matches = matchRouteBranch(branches[i], decoded, allowPartial);
+  }
+  return matches;
+}
+function convertRouteMatchToUiMatch(match, loaderData) {
+  let {
+    route,
+    pathname,
+    params
+  } = match;
+  return {
+    id: route.id,
+    pathname,
+    params,
+    data: loaderData[route.id],
+    handle: route.handle
+  };
+}
+function flattenRoutes(routes, branches, parentsMeta, parentPath) {
+  if (branches === void 0) {
+    branches = [];
+  }
+  if (parentsMeta === void 0) {
+    parentsMeta = [];
+  }
+  if (parentPath === void 0) {
+    parentPath = "";
+  }
+  let flattenRoute = (route, index, relativePath) => {
+    let meta = {
+      relativePath: relativePath === undefined ? route.path || "" : relativePath,
+      caseSensitive: route.caseSensitive === true,
+      childrenIndex: index,
+      route
+    };
+    if (meta.relativePath.startsWith("/")) {
+      invariant(meta.relativePath.startsWith(parentPath), "Absolute route path \"" + meta.relativePath + "\" nested under path " + ("\"" + parentPath + "\" is not valid. An absolute child route path ") + "must start with the combined path of all its parent routes.");
+      meta.relativePath = meta.relativePath.slice(parentPath.length);
+    }
+    let path = joinPaths([parentPath, meta.relativePath]);
+    let routesMeta = parentsMeta.concat(meta);
+
+    // Add the children before adding this route to the array, so we traverse the
+    // route tree depth-first and child routes appear before their parents in
+    // the "flattened" version.
+    if (route.children && route.children.length > 0) {
+      invariant(
+      // Our types know better, but runtime JS may not!
+      // @ts-expect-error
+      route.index !== true, "Index routes must not have child routes. Please remove " + ("all child routes from route path \"" + path + "\"."));
+      flattenRoutes(route.children, branches, routesMeta, path);
+    }
+
+    // Routes without a path shouldn't ever match by themselves unless they are
+    // index routes, so don't add them to the list of possible branches.
+    if (route.path == null && !route.index) {
+      return;
+    }
+    branches.push({
+      path,
+      score: computeScore(path, route.index),
+      routesMeta
+    });
+  };
+  routes.forEach((route, index) => {
+    var _route$path;
+    // coarse-grain check for optional params
+    if (route.path === "" || !((_route$path = route.path) != null && _route$path.includes("?"))) {
+      flattenRoute(route, index);
+    } else {
+      for (let exploded of explodeOptionalSegments(route.path)) {
+        flattenRoute(route, index, exploded);
+      }
+    }
+  });
+  return branches;
+}
+
+/**
+ * Computes all combinations of optional path segments for a given path,
+ * excluding combinations that are ambiguous and of lower priority.
+ *
+ * For example, `/one/:two?/three/:four?/:five?` explodes to:
+ * - `/one/three`
+ * - `/one/:two/three`
+ * - `/one/three/:four`
+ * - `/one/three/:five`
+ * - `/one/:two/three/:four`
+ * - `/one/:two/three/:five`
+ * - `/one/three/:four/:five`
+ * - `/one/:two/three/:four/:five`
+ */
+function explodeOptionalSegments(path) {
+  let segments = path.split("/");
+  if (segments.length === 0) return [];
+  let [first, ...rest] = segments;
+
+  // Optional path segments are denoted by a trailing `?`
+  let isOptional = first.endsWith("?");
+  // Compute the corresponding required segment: `foo?` -> `foo`
+  let required = first.replace(/\?$/, "");
+  if (rest.length === 0) {
+    // Intepret empty string as omitting an optional segment
+    // `["one", "", "three"]` corresponds to omitting `:two` from `/one/:two?/three` -> `/one/three`
+    return isOptional ? [required, ""] : [required];
+  }
+  let restExploded = explodeOptionalSegments(rest.join("/"));
+  let result = [];
+
+  // All child paths with the prefix.  Do this for all children before the
+  // optional version for all children, so we get consistent ordering where the
+  // parent optional aspect is preferred as required.  Otherwise, we can get
+  // child sections interspersed where deeper optional segments are higher than
+  // parent optional segments, where for example, /:two would explode _earlier_
+  // then /:one.  By always including the parent as required _for all children_
+  // first, we avoid this issue
+  result.push(...restExploded.map(subpath => subpath === "" ? required : [required, subpath].join("/")));
+
+  // Then, if this is an optional value, add all child versions without
+  if (isOptional) {
+    result.push(...restExploded);
+  }
+
+  // for absolute paths, ensure `/` instead of empty segment
+  return result.map(exploded => path.startsWith("/") && exploded === "" ? "/" : exploded);
+}
+function rankRouteBranches(branches) {
+  branches.sort((a, b) => a.score !== b.score ? b.score - a.score // Higher score first
+  : compareIndexes(a.routesMeta.map(meta => meta.childrenIndex), b.routesMeta.map(meta => meta.childrenIndex)));
+}
+const paramRe = /^:[\w-]+$/;
+const dynamicSegmentValue = 3;
+const indexRouteValue = 2;
+const emptySegmentValue = 1;
+const staticSegmentValue = 10;
+const splatPenalty = -2;
+const isSplat = s => s === "*";
+function computeScore(path, index) {
+  let segments = path.split("/");
+  let initialScore = segments.length;
+  if (segments.some(isSplat)) {
+    initialScore += splatPenalty;
+  }
+  if (index) {
+    initialScore += indexRouteValue;
+  }
+  return segments.filter(s => !isSplat(s)).reduce((score, segment) => score + (paramRe.test(segment) ? dynamicSegmentValue : segment === "" ? emptySegmentValue : staticSegmentValue), initialScore);
+}
+function compareIndexes(a, b) {
+  let siblings = a.length === b.length && a.slice(0, -1).every((n, i) => n === b[i]);
+  return siblings ?
+  // If two routes are siblings, we should try to match the earlier sibling
+  // first. This allows people to have fine-grained control over the matching
+  // behavior by simply putting routes with identical paths in the order they
+  // want them tried.
+  a[a.length - 1] - b[b.length - 1] :
+  // Otherwise, it doesn't really make sense to rank non-siblings by index,
+  // so they sort equally.
+  0;
+}
+function matchRouteBranch(branch, pathname, allowPartial) {
+  if (allowPartial === void 0) {
+    allowPartial = false;
+  }
+  let {
+    routesMeta
+  } = branch;
+  let matchedParams = {};
+  let matchedPathname = "/";
+  let matches = [];
+  for (let i = 0; i < routesMeta.length; ++i) {
+    let meta = routesMeta[i];
+    let end = i === routesMeta.length - 1;
+    let remainingPathname = matchedPathname === "/" ? pathname : pathname.slice(matchedPathname.length) || "/";
+    let match = matchPath({
+      path: meta.relativePath,
+      caseSensitive: meta.caseSensitive,
+      end
+    }, remainingPathname);
+    let route = meta.route;
+    if (!match && end && allowPartial && !routesMeta[routesMeta.length - 1].route.index) {
+      match = matchPath({
+        path: meta.relativePath,
+        caseSensitive: meta.caseSensitive,
+        end: false
+      }, remainingPathname);
+    }
+    if (!match) {
+      return null;
+    }
+    Object.assign(matchedParams, match.params);
+    matches.push({
+      // TODO: Can this as be avoided?
+      params: matchedParams,
+      pathname: joinPaths([matchedPathname, match.pathname]),
+      pathnameBase: normalizePathname(joinPaths([matchedPathname, match.pathnameBase])),
+      route
+    });
+    if (match.pathnameBase !== "/") {
+      matchedPathname = joinPaths([matchedPathname, match.pathnameBase]);
+    }
+  }
+  return matches;
+}
+
+/**
+ * Returns a path with params interpolated.
+ *
+ * @see https://reactrouter.com/v6/utils/generate-path
+ */
+function generatePath(originalPath, params) {
+  if (params === void 0) {
+    params = {};
+  }
+  let path = originalPath;
+  if (path.endsWith("*") && path !== "*" && !path.endsWith("/*")) {
+    warning(false, "Route path \"" + path + "\" will be treated as if it were " + ("\"" + path.replace(/\*$/, "/*") + "\" because the `*` character must ") + "always follow a `/` in the pattern. To get rid of this warning, " + ("please change the route path to \"" + path.replace(/\*$/, "/*") + "\"."));
+    path = path.replace(/\*$/, "/*");
+  }
+
+  // ensure `/` is added at the beginning if the path is absolute
+  const prefix = path.startsWith("/") ? "/" : "";
+  const stringify = p => p == null ? "" : typeof p === "string" ? p : String(p);
+  const segments = path.split(/\/+/).map((segment, index, array) => {
+    const isLastSegment = index === array.length - 1;
+
+    // only apply the splat if it's the last segment
+    if (isLastSegment && segment === "*") {
+      const star = "*";
+      // Apply the splat
+      return stringify(params[star]);
+    }
+    const keyMatch = segment.match(/^:([\w-]+)(\??)$/);
+    if (keyMatch) {
+      const [, key, optional] = keyMatch;
+      let param = params[key];
+      invariant(optional === "?" || param != null, "Missing \":" + key + "\" param");
+      return stringify(param);
+    }
+
+    // Remove any optional markers from optional static segments
+    return segment.replace(/\?$/g, "");
+  })
+  // Remove empty segments
+  .filter(segment => !!segment);
+  return prefix + segments.join("/");
+}
+
+/**
+ * A PathPattern is used to match on some portion of a URL pathname.
+ */
+
+/**
+ * A PathMatch contains info about how a PathPattern matched on a URL pathname.
+ */
+
+/**
+ * Performs pattern matching on a URL pathname and returns information about
+ * the match.
+ *
+ * @see https://reactrouter.com/v6/utils/match-path
+ */
+function matchPath(pattern, pathname) {
+  if (typeof pattern === "string") {
+    pattern = {
+      path: pattern,
+      caseSensitive: false,
+      end: true
+    };
+  }
+  let [matcher, compiledParams] = compilePath(pattern.path, pattern.caseSensitive, pattern.end);
+  let match = pathname.match(matcher);
+  if (!match) return null;
+  let matchedPathname = match[0];
+  let pathnameBase = matchedPathname.replace(/(.)\/+$/, "$1");
+  let captureGroups = match.slice(1);
+  let params = compiledParams.reduce((memo, _ref, index) => {
+    let {
+      paramName,
+      isOptional
+    } = _ref;
+    // We need to compute the pathnameBase here using the raw splat value
+    // instead of using params["*"] later because it will be decoded then
+    if (paramName === "*") {
+      let splatValue = captureGroups[index] || "";
+      pathnameBase = matchedPathname.slice(0, matchedPathname.length - splatValue.length).replace(/(.)\/+$/, "$1");
+    }
+    const value = captureGroups[index];
+    if (isOptional && !value) {
+      memo[paramName] = undefined;
+    } else {
+      memo[paramName] = (value || "").replace(/%2F/g, "/");
+    }
+    return memo;
+  }, {});
+  return {
+    params,
+    pathname: matchedPathname,
+    pathnameBase,
+    pattern
+  };
+}
+function compilePath(path, caseSensitive, end) {
+  if (caseSensitive === void 0) {
+    caseSensitive = false;
+  }
+  if (end === void 0) {
+    end = true;
+  }
+  warning(path === "*" || !path.endsWith("*") || path.endsWith("/*"), "Route path \"" + path + "\" will be treated as if it were " + ("\"" + path.replace(/\*$/, "/*") + "\" because the `*` character must ") + "always follow a `/` in the pattern. To get rid of this warning, " + ("please change the route path to \"" + path.replace(/\*$/, "/*") + "\"."));
+  let params = [];
+  let regexpSource = "^" + path.replace(/\/*\*?$/, "") // Ignore trailing / and /*, we'll handle it below
+  .replace(/^\/*/, "/") // Make sure it has a leading /
+  .replace(/[\\.*+^${}|()[\]]/g, "\\$&") // Escape special regex chars
+  .replace(/\/:([\w-]+)(\?)?/g, (_, paramName, isOptional) => {
+    params.push({
+      paramName,
+      isOptional: isOptional != null
+    });
+    return isOptional ? "/?([^\\/]+)?" : "/([^\\/]+)";
+  });
+  if (path.endsWith("*")) {
+    params.push({
+      paramName: "*"
+    });
+    regexpSource += path === "*" || path === "/*" ? "(.*)$" // Already matched the initial /, just match the rest
+    : "(?:\\/(.+)|\\/*)$"; // Don't include the / in params["*"]
+  } else if (end) {
+    // When matching to the end, ignore trailing slashes
+    regexpSource += "\\/*$";
+  } else if (path !== "" && path !== "/") {
+    // If our path is non-empty and contains anything beyond an initial slash,
+    // then we have _some_ form of path in our regex, so we should expect to
+    // match only if we find the end of this path segment.  Look for an optional
+    // non-captured trailing slash (to match a portion of the URL) or the end
+    // of the path (if we've matched to the end).  We used to do this with a
+    // word boundary but that gives false positives on routes like
+    // /user-preferences since `-` counts as a word boundary.
+    regexpSource += "(?:(?=\\/|$))";
+  } else ;
+  let matcher = new RegExp(regexpSource, caseSensitive ? undefined : "i");
+  return [matcher, params];
+}
+function decodePath(value) {
+  try {
+    return value.split("/").map(v => decodeURIComponent(v).replace(/\//g, "%2F")).join("/");
+  } catch (error) {
+    warning(false, "The URL path \"" + value + "\" could not be decoded because it is is a " + "malformed URL segment. This is probably due to a bad percent " + ("encoding (" + error + ")."));
+    return value;
+  }
+}
+
+/**
+ * @private
+ */
+function stripBasename(pathname, basename) {
+  if (basename === "/") return pathname;
+  if (!pathname.toLowerCase().startsWith(basename.toLowerCase())) {
+    return null;
+  }
+
+  // We want to leave trailing slash behavior in the user's control, so if they
+  // specify a basename with a trailing slash, we should support it
+  let startIndex = basename.endsWith("/") ? basename.length - 1 : basename.length;
+  let nextChar = pathname.charAt(startIndex);
+  if (nextChar && nextChar !== "/") {
+    // pathname does not start with basename/
+    return null;
+  }
+  return pathname.slice(startIndex) || "/";
+}
+const ABSOLUTE_URL_REGEX$1 = /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i;
+const isAbsoluteUrl = url => ABSOLUTE_URL_REGEX$1.test(url);
+
+/**
+ * Returns a resolved path object relative to the given pathname.
+ *
+ * @see https://reactrouter.com/v6/utils/resolve-path
+ */
+function resolvePath(to, fromPathname) {
+  if (fromPathname === void 0) {
+    fromPathname = "/";
+  }
+  let {
+    pathname: toPathname,
+    search = "",
+    hash = ""
+  } = typeof to === "string" ? parsePath(to) : to;
+  let pathname;
+  if (toPathname) {
+    if (isAbsoluteUrl(toPathname)) {
+      pathname = toPathname;
+    } else {
+      if (toPathname.includes("//")) {
+        let oldPathname = toPathname;
+        toPathname = toPathname.replace(/\/\/+/g, "/");
+        warning(false, "Pathnames cannot have embedded double slashes - normalizing " + (oldPathname + " -> " + toPathname));
+      }
+      if (toPathname.startsWith("/")) {
+        pathname = resolvePathname(toPathname.substring(1), "/");
+      } else {
+        pathname = resolvePathname(toPathname, fromPathname);
+      }
+    }
+  } else {
+    pathname = fromPathname;
+  }
+  return {
+    pathname,
+    search: normalizeSearch(search),
+    hash: normalizeHash(hash)
+  };
+}
+function resolvePathname(relativePath, fromPathname) {
+  let segments = fromPathname.replace(/\/+$/, "").split("/");
+  let relativeSegments = relativePath.split("/");
+  relativeSegments.forEach(segment => {
+    if (segment === "..") {
+      // Keep the root "" segment so the pathname starts at /
+      if (segments.length > 1) segments.pop();
+    } else if (segment !== ".") {
+      segments.push(segment);
+    }
+  });
+  return segments.length > 1 ? segments.join("/") : "/";
+}
+function getInvalidPathError(char, field, dest, path) {
+  return "Cannot include a '" + char + "' character in a manually specified " + ("`to." + field + "` field [" + JSON.stringify(path) + "].  Please separate it out to the ") + ("`to." + dest + "` field. Alternatively you may provide the full path as ") + "a string in <Link to=\"...\"> and the router will parse it for you.";
+}
+
+/**
+ * @private
+ *
+ * When processing relative navigation we want to ignore ancestor routes that
+ * do not contribute to the path, such that index/pathless layout routes don't
+ * interfere.
+ *
+ * For example, when moving a route element into an index route and/or a
+ * pathless layout route, relative link behavior contained within should stay
+ * the same.  Both of the following examples should link back to the root:
+ *
+ *   <Route path="/">
+ *     <Route path="accounts" element={<Link to=".."}>
+ *   </Route>
+ *
+ *   <Route path="/">
+ *     <Route path="accounts">
+ *       <Route element={<AccountsLayout />}>       // <-- Does not contribute
+ *         <Route index element={<Link to=".."} />  // <-- Does not contribute
+ *       </Route
+ *     </Route>
+ *   </Route>
+ */
+function getPathContributingMatches(matches) {
+  return matches.filter((match, index) => index === 0 || match.route.path && match.route.path.length > 0);
+}
+
+// Return the array of pathnames for the current route matches - used to
+// generate the routePathnames input for resolveTo()
+function getResolveToMatches(matches, v7_relativeSplatPath) {
+  let pathMatches = getPathContributingMatches(matches);
+
+  // When v7_relativeSplatPath is enabled, use the full pathname for the leaf
+  // match so we include splat values for "." links.  See:
+  // https://github.com/remix-run/react-router/issues/11052#issuecomment-1836589329
+  if (v7_relativeSplatPath) {
+    return pathMatches.map((match, idx) => idx === pathMatches.length - 1 ? match.pathname : match.pathnameBase);
+  }
+  return pathMatches.map(match => match.pathnameBase);
+}
+
+/**
+ * @private
+ */
+function resolveTo(toArg, routePathnames, locationPathname, isPathRelative) {
+  if (isPathRelative === void 0) {
+    isPathRelative = false;
+  }
+  let to;
+  if (typeof toArg === "string") {
+    to = parsePath(toArg);
+  } else {
+    to = _extends({}, toArg);
+    invariant(!to.pathname || !to.pathname.includes("?"), getInvalidPathError("?", "pathname", "search", to));
+    invariant(!to.pathname || !to.pathname.includes("#"), getInvalidPathError("#", "pathname", "hash", to));
+    invariant(!to.search || !to.search.includes("#"), getInvalidPathError("#", "search", "hash", to));
+  }
+  let isEmptyPath = toArg === "" || to.pathname === "";
+  let toPathname = isEmptyPath ? "/" : to.pathname;
+  let from;
+
+  // Routing is relative to the current pathname if explicitly requested.
+  //
+  // If a pathname is explicitly provided in `to`, it should be relative to the
+  // route context. This is explained in `Note on `<Link to>` values` in our
+  // migration guide from v5 as a means of disambiguation between `to` values
+  // that begin with `/` and those that do not. However, this is problematic for
+  // `to` values that do not provide a pathname. `to` can simply be a search or
+  // hash string, in which case we should assume that the navigation is relative
+  // to the current location's pathname and *not* the route pathname.
+  if (toPathname == null) {
+    from = locationPathname;
+  } else {
+    let routePathnameIndex = routePathnames.length - 1;
+
+    // With relative="route" (the default), each leading .. segment means
+    // "go up one route" instead of "go up one URL segment".  This is a key
+    // difference from how <a href> works and a major reason we call this a
+    // "to" value instead of a "href".
+    if (!isPathRelative && toPathname.startsWith("..")) {
+      let toSegments = toPathname.split("/");
+      while (toSegments[0] === "..") {
+        toSegments.shift();
+        routePathnameIndex -= 1;
+      }
+      to.pathname = toSegments.join("/");
+    }
+    from = routePathnameIndex >= 0 ? routePathnames[routePathnameIndex] : "/";
+  }
+  let path = resolvePath(to, from);
+
+  // Ensure the pathname has a trailing slash if the original "to" had one
+  let hasExplicitTrailingSlash = toPathname && toPathname !== "/" && toPathname.endsWith("/");
+  // Or if this was a link to the current path which has a trailing slash
+  let hasCurrentTrailingSlash = (isEmptyPath || toPathname === ".") && locationPathname.endsWith("/");
+  if (!path.pathname.endsWith("/") && (hasExplicitTrailingSlash || hasCurrentTrailingSlash)) {
+    path.pathname += "/";
+  }
+  return path;
+}
+
+/**
+ * @private
+ */
+function getToPathname(to) {
+  // Empty strings should be treated the same as / paths
+  return to === "" || to.pathname === "" ? "/" : typeof to === "string" ? parsePath(to).pathname : to.pathname;
+}
+
+/**
+ * @private
+ */
+const joinPaths = paths => paths.join("/").replace(/\/\/+/g, "/");
+
+/**
+ * @private
+ */
+const normalizePathname = pathname => pathname.replace(/\/+$/, "").replace(/^\/*/, "/");
+
+/**
+ * @private
+ */
+const normalizeSearch = search => !search || search === "?" ? "" : search.startsWith("?") ? search : "?" + search;
+
+/**
+ * @private
+ */
+const normalizeHash = hash => !hash || hash === "#" ? "" : hash.startsWith("#") ? hash : "#" + hash;
+/**
+ * This is a shortcut for creating `application/json` responses. Converts `data`
+ * to JSON and sets the `Content-Type` header.
+ *
+ * @deprecated The `json` method is deprecated in favor of returning raw objects.
+ * This method will be removed in v7.
+ */
+const json = function json(data, init) {
+  if (init === void 0) {
+    init = {};
+  }
+  let responseInit = typeof init === "number" ? {
+    status: init
+  } : init;
+  let headers = new Headers(responseInit.headers);
+  if (!headers.has("Content-Type")) {
+    headers.set("Content-Type", "application/json; charset=utf-8");
+  }
+  return new Response(JSON.stringify(data), _extends({}, responseInit, {
+    headers
+  }));
+};
+class DataWithResponseInit {
+  constructor(data, init) {
+    this.type = "DataWithResponseInit";
+    this.data = data;
+    this.init = init || null;
+  }
+}
+
+/**
+ * Create "responses" that contain `status`/`headers` without forcing
+ * serialization into an actual `Response` - used by Remix single fetch
+ */
+function data(data, init) {
+  return new DataWithResponseInit(data, typeof init === "number" ? {
+    status: init
+  } : init);
+}
+class AbortedDeferredError extends Error {}
+class DeferredData {
+  constructor(data, responseInit) {
+    this.pendingKeysSet = new Set();
+    this.subscribers = new Set();
+    this.deferredKeys = [];
+    invariant(data && typeof data === "object" && !Array.isArray(data), "defer() only accepts plain objects");
+
+    // Set up an AbortController + Promise we can race against to exit early
+    // cancellation
+    let reject;
+    this.abortPromise = new Promise((_, r) => reject = r);
+    this.controller = new AbortController();
+    let onAbort = () => reject(new AbortedDeferredError("Deferred data aborted"));
+    this.unlistenAbortSignal = () => this.controller.signal.removeEventListener("abort", onAbort);
+    this.controller.signal.addEventListener("abort", onAbort);
+    this.data = Object.entries(data).reduce((acc, _ref2) => {
+      let [key, value] = _ref2;
+      return Object.assign(acc, {
+        [key]: this.trackPromise(key, value)
+      });
+    }, {});
+    if (this.done) {
+      // All incoming values were resolved
+      this.unlistenAbortSignal();
+    }
+    this.init = responseInit;
+  }
+  trackPromise(key, value) {
+    if (!(value instanceof Promise)) {
+      return value;
+    }
+    this.deferredKeys.push(key);
+    this.pendingKeysSet.add(key);
+
+    // We store a little wrapper promise that will be extended with
+    // _data/_error props upon resolve/reject
+    let promise = Promise.race([value, this.abortPromise]).then(data => this.onSettle(promise, key, undefined, data), error => this.onSettle(promise, key, error));
+
+    // Register rejection listeners to avoid uncaught promise rejections on
+    // errors or aborted deferred values
+    promise.catch(() => {});
+    Object.defineProperty(promise, "_tracked", {
+      get: () => true
+    });
+    return promise;
+  }
+  onSettle(promise, key, error, data) {
+    if (this.controller.signal.aborted && error instanceof AbortedDeferredError) {
+      this.unlistenAbortSignal();
+      Object.defineProperty(promise, "_error", {
+        get: () => error
+      });
+      return Promise.reject(error);
+    }
+    this.pendingKeysSet.delete(key);
+    if (this.done) {
+      // Nothing left to abort!
+      this.unlistenAbortSignal();
+    }
+
+    // If the promise was resolved/rejected with undefined, we'll throw an error as you
+    // should always resolve with a value or null
+    if (error === undefined && data === undefined) {
+      let undefinedError = new Error("Deferred data for key \"" + key + "\" resolved/rejected with `undefined`, " + "you must resolve/reject with a value or `null`.");
+      Object.defineProperty(promise, "_error", {
+        get: () => undefinedError
+      });
+      this.emit(false, key);
+      return Promise.reject(undefinedError);
+    }
+    if (data === undefined) {
+      Object.defineProperty(promise, "_error", {
+        get: () => error
+      });
+      this.emit(false, key);
+      return Promise.reject(error);
+    }
+    Object.defineProperty(promise, "_data", {
+      get: () => data
+    });
+    this.emit(false, key);
+    return data;
+  }
+  emit(aborted, settledKey) {
+    this.subscribers.forEach(subscriber => subscriber(aborted, settledKey));
+  }
+  subscribe(fn) {
+    this.subscribers.add(fn);
+    return () => this.subscribers.delete(fn);
+  }
+  cancel() {
+    this.controller.abort();
+    this.pendingKeysSet.forEach((v, k) => this.pendingKeysSet.delete(k));
+    this.emit(true);
+  }
+  async resolveData(signal) {
+    let aborted = false;
+    if (!this.done) {
+      let onAbort = () => this.cancel();
+      signal.addEventListener("abort", onAbort);
+      aborted = await new Promise(resolve => {
+        this.subscribe(aborted => {
+          signal.removeEventListener("abort", onAbort);
+          if (aborted || this.done) {
+            resolve(aborted);
+          }
+        });
+      });
+    }
+    return aborted;
+  }
+  get done() {
+    return this.pendingKeysSet.size === 0;
+  }
+  get unwrappedData() {
+    invariant(this.data !== null && this.done, "Can only unwrap data on initialized and settled deferreds");
+    return Object.entries(this.data).reduce((acc, _ref3) => {
+      let [key, value] = _ref3;
+      return Object.assign(acc, {
+        [key]: unwrapTrackedPromise(value)
+      });
+    }, {});
+  }
+  get pendingKeys() {
+    return Array.from(this.pendingKeysSet);
+  }
+}
+function isTrackedPromise(value) {
+  return value instanceof Promise && value._tracked === true;
+}
+function unwrapTrackedPromise(value) {
+  if (!isTrackedPromise(value)) {
+    return value;
+  }
+  if (value._error) {
+    throw value._error;
+  }
+  return value._data;
+}
+/**
+ * @deprecated The `defer` method is deprecated in favor of returning raw
+ * objects. This method will be removed in v7.
+ */
+const defer = function defer(data, init) {
+  if (init === void 0) {
+    init = {};
+  }
+  let responseInit = typeof init === "number" ? {
+    status: init
+  } : init;
+  return new DeferredData(data, responseInit);
+};
+/**
+ * A redirect response. Sets the status code and the `Location` header.
+ * Defaults to "302 Found".
+ */
+const redirect = function redirect(url, init) {
+  if (init === void 0) {
+    init = 302;
+  }
+  let responseInit = init;
+  if (typeof responseInit === "number") {
+    responseInit = {
+      status: responseInit
+    };
+  } else if (typeof responseInit.status === "undefined") {
+    responseInit.status = 302;
+  }
+  let headers = new Headers(responseInit.headers);
+  headers.set("Location", url);
+  return new Response(null, _extends({}, responseInit, {
+    headers
+  }));
+};
+
+/**
+ * A redirect response that will force a document reload to the new location.
+ * Sets the status code and the `Location` header.
+ * Defaults to "302 Found".
+ */
+const redirectDocument = (url, init) => {
+  let response = redirect(url, init);
+  response.headers.set("X-Remix-Reload-Document", "true");
+  return response;
+};
+
+/**
+ * A redirect response that will perform a `history.replaceState` instead of a
+ * `history.pushState` for client-side navigation redirects.
+ * Sets the status code and the `Location` header.
+ * Defaults to "302 Found".
+ */
+const replace = (url, init) => {
+  let response = redirect(url, init);
+  response.headers.set("X-Remix-Replace", "true");
+  return response;
+};
+/**
+ * @private
+ * Utility class we use to hold auto-unwrapped 4xx/5xx Response bodies
+ *
+ * We don't export the class for public use since it's an implementation
+ * detail, but we export the interface above so folks can build their own
+ * abstractions around instances via isRouteErrorResponse()
+ */
+class ErrorResponseImpl {
+  constructor(status, statusText, data, internal) {
+    if (internal === void 0) {
+      internal = false;
+    }
+    this.status = status;
+    this.statusText = statusText || "";
+    this.internal = internal;
+    if (data instanceof Error) {
+      this.data = data.toString();
+      this.error = data;
+    } else {
+      this.data = data;
+    }
+  }
+}
+
+/**
+ * Check if the given error is an ErrorResponse generated from a 4xx/5xx
+ * Response thrown from an action/loader
+ */
+function isRouteErrorResponse(error) {
+  return error != null && typeof error.status === "number" && typeof error.statusText === "string" && typeof error.internal === "boolean" && "data" in error;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//#region Types and Constants
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * A Router instance manages all navigation and data loading/mutations
+ */
+/**
+ * State maintained internally by the router.  During a navigation, all states
+ * reflect the the "old" location unless otherwise noted.
+ */
+/**
+ * Data that can be passed into hydrate a Router from SSR
+ */
+/**
+ * Future flags to toggle new feature behavior
+ */
+/**
+ * Initialization options for createRouter
+ */
+/**
+ * State returned from a server-side query() call
+ */
+/**
+ * A StaticHandler instance manages a singular SSR navigation/fetch event
+ */
+/**
+ * Subscriber function signature for changes to router state
+ */
+/**
+ * Function signature for determining the key to be used in scroll restoration
+ * for a given location
+ */
+/**
+ * Function signature for determining the current scroll position
+ */
+// Allowed for any navigation or fetch
+// Only allowed for navigations
+// Only allowed for submission navigations
+/**
+ * Options for a navigate() call for a normal (non-submission) navigation
+ */
+/**
+ * Options for a navigate() call for a submission navigation
+ */
+/**
+ * Options to pass to navigate() for a navigation
+ */
+/**
+ * Options for a fetch() load
+ */
+/**
+ * Options for a fetch() submission
+ */
+/**
+ * Options to pass to fetch()
+ */
+/**
+ * Potential states for state.navigation
+ */
+/**
+ * Potential states for fetchers
+ */
+/**
+ * Cached info for active fetcher.load() instances so they can participate
+ * in revalidation
+ */
+/**
+ * Identified fetcher.load() calls that need to be revalidated
+ */
+const validMutationMethodsArr = ["post", "put", "patch", "delete"];
+const validMutationMethods = new Set(validMutationMethodsArr);
+const validRequestMethodsArr = ["get", ...validMutationMethodsArr];
+const validRequestMethods = new Set(validRequestMethodsArr);
+const redirectStatusCodes = new Set([301, 302, 303, 307, 308]);
+const redirectPreserveMethodStatusCodes = new Set([307, 308]);
+const IDLE_NAVIGATION = {
+  state: "idle",
+  location: undefined,
+  formMethod: undefined,
+  formAction: undefined,
+  formEncType: undefined,
+  formData: undefined,
+  json: undefined,
+  text: undefined
+};
+const IDLE_FETCHER = {
+  state: "idle",
+  data: undefined,
+  formMethod: undefined,
+  formAction: undefined,
+  formEncType: undefined,
+  formData: undefined,
+  json: undefined,
+  text: undefined
+};
+const IDLE_BLOCKER = {
+  state: "unblocked",
+  proceed: undefined,
+  reset: undefined,
+  location: undefined
+};
+const ABSOLUTE_URL_REGEX = /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i;
+const defaultMapRouteProperties = route => ({
+  hasErrorBoundary: Boolean(route.hasErrorBoundary)
+});
+const TRANSITIONS_STORAGE_KEY = "remix-router-transitions";
+
+//#endregion
+
+////////////////////////////////////////////////////////////////////////////////
+//#region createRouter
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Create a router and listen to history POP navigations
+ */
+function createRouter(init) {
+  const routerWindow = init.window ? init.window : typeof window !== "undefined" ? window : undefined;
+  const isBrowser = typeof routerWindow !== "undefined" && typeof routerWindow.document !== "undefined" && typeof routerWindow.document.createElement !== "undefined";
+  const isServer = !isBrowser;
+  invariant(init.routes.length > 0, "You must provide a non-empty routes array to createRouter");
+  let mapRouteProperties;
+  if (init.mapRouteProperties) {
+    mapRouteProperties = init.mapRouteProperties;
+  } else if (init.detectErrorBoundary) {
+    // If they are still using the deprecated version, wrap it with the new API
+    let detectErrorBoundary = init.detectErrorBoundary;
+    mapRouteProperties = route => ({
+      hasErrorBoundary: detectErrorBoundary(route)
+    });
+  } else {
+    mapRouteProperties = defaultMapRouteProperties;
+  }
+
+  // Routes keyed by ID
+  let manifest = {};
+  // Routes in tree format for matching
+  let dataRoutes = convertRoutesToDataRoutes(init.routes, mapRouteProperties, undefined, manifest);
+  let inFlightDataRoutes;
+  let basename = init.basename || "/";
+  let dataStrategyImpl = init.dataStrategy || defaultDataStrategy;
+  let patchRoutesOnNavigationImpl = init.patchRoutesOnNavigation;
+
+  // Config driven behavior flags
+  let future = _extends({
+    v7_fetcherPersist: false,
+    v7_normalizeFormMethod: false,
+    v7_partialHydration: false,
+    v7_prependBasename: false,
+    v7_relativeSplatPath: false,
+    v7_skipActionErrorRevalidation: false
+  }, init.future);
+  // Cleanup function for history
+  let unlistenHistory = null;
+  // Externally-provided functions to call on all state changes
+  let subscribers = new Set();
+  // Externally-provided object to hold scroll restoration locations during routing
+  let savedScrollPositions = null;
+  // Externally-provided function to get scroll restoration keys
+  let getScrollRestorationKey = null;
+  // Externally-provided function to get current scroll position
+  let getScrollPosition = null;
+  // One-time flag to control the initial hydration scroll restoration.  Because
+  // we don't get the saved positions from <ScrollRestoration /> until _after_
+  // the initial render, we need to manually trigger a separate updateState to
+  // send along the restoreScrollPosition
+  // Set to true if we have `hydrationData` since we assume we were SSR'd and that
+  // SSR did the initial scroll restoration.
+  let initialScrollRestored = init.hydrationData != null;
+  let initialMatches = matchRoutes(dataRoutes, init.history.location, basename);
+  let initialMatchesIsFOW = false;
+  let initialErrors = null;
+  if (initialMatches == null && !patchRoutesOnNavigationImpl) {
+    // If we do not match a user-provided-route, fall back to the root
+    // to allow the error boundary to take over
+    let error = getInternalRouterError(404, {
+      pathname: init.history.location.pathname
+    });
+    let {
+      matches,
+      route
+    } = getShortCircuitMatches(dataRoutes);
+    initialMatches = matches;
+    initialErrors = {
+      [route.id]: error
+    };
+  }
+
+  // In SPA apps, if the user provided a patchRoutesOnNavigation implementation and
+  // our initial match is a splat route, clear them out so we run through lazy
+  // discovery on hydration in case there's a more accurate lazy route match.
+  // In SSR apps (with `hydrationData`), we expect that the server will send
+  // up the proper matched routes so we don't want to run lazy discovery on
+  // initial hydration and want to hydrate into the splat route.
+  if (initialMatches && !init.hydrationData) {
+    let fogOfWar = checkFogOfWar(initialMatches, dataRoutes, init.history.location.pathname);
+    if (fogOfWar.active) {
+      initialMatches = null;
+    }
+  }
+  let initialized;
+  if (!initialMatches) {
+    initialized = false;
+    initialMatches = [];
+
+    // If partial hydration and fog of war is enabled, we will be running
+    // `patchRoutesOnNavigation` during hydration so include any partial matches as
+    // the initial matches so we can properly render `HydrateFallback`'s
+    if (future.v7_partialHydration) {
+      let fogOfWar = checkFogOfWar(null, dataRoutes, init.history.location.pathname);
+      if (fogOfWar.active && fogOfWar.matches) {
+        initialMatchesIsFOW = true;
+        initialMatches = fogOfWar.matches;
+      }
+    }
+  } else if (initialMatches.some(m => m.route.lazy)) {
+    // All initialMatches need to be loaded before we're ready.  If we have lazy
+    // functions around still then we'll need to run them in initialize()
+    initialized = false;
+  } else if (!initialMatches.some(m => m.route.loader)) {
+    // If we've got no loaders to run, then we're good to go
+    initialized = true;
+  } else if (future.v7_partialHydration) {
+    // If partial hydration is enabled, we're initialized so long as we were
+    // provided with hydrationData for every route with a loader, and no loaders
+    // were marked for explicit hydration
+    let loaderData = init.hydrationData ? init.hydrationData.loaderData : null;
+    let errors = init.hydrationData ? init.hydrationData.errors : null;
+    // If errors exist, don't consider routes below the boundary
+    if (errors) {
+      let idx = initialMatches.findIndex(m => errors[m.route.id] !== undefined);
+      initialized = initialMatches.slice(0, idx + 1).every(m => !shouldLoadRouteOnHydration(m.route, loaderData, errors));
+    } else {
+      initialized = initialMatches.every(m => !shouldLoadRouteOnHydration(m.route, loaderData, errors));
+    }
+  } else {
+    // Without partial hydration - we're initialized if we were provided any
+    // hydrationData - which is expected to be complete
+    initialized = init.hydrationData != null;
+  }
+  let router;
+  let state = {
+    historyAction: init.history.action,
+    location: init.history.location,
+    matches: initialMatches,
+    initialized,
+    navigation: IDLE_NAVIGATION,
+    // Don't restore on initial updateState() if we were SSR'd
+    restoreScrollPosition: init.hydrationData != null ? false : null,
+    preventScrollReset: false,
+    revalidation: "idle",
+    loaderData: init.hydrationData && init.hydrationData.loaderData || {},
+    actionData: init.hydrationData && init.hydrationData.actionData || null,
+    errors: init.hydrationData && init.hydrationData.errors || initialErrors,
+    fetchers: new Map(),
+    blockers: new Map()
+  };
+
+  // -- Stateful internal variables to manage navigations --
+  // Current navigation in progress (to be committed in completeNavigation)
+  let pendingAction = Action.Pop;
+
+  // Should the current navigation prevent the scroll reset if scroll cannot
+  // be restored?
+  let pendingPreventScrollReset = false;
+
+  // AbortController for the active navigation
+  let pendingNavigationController;
+
+  // Should the current navigation enable document.startViewTransition?
+  let pendingViewTransitionEnabled = false;
+
+  // Store applied view transitions so we can apply them on POP
+  let appliedViewTransitions = new Map();
+
+  // Cleanup function for persisting applied transitions to sessionStorage
+  let removePageHideEventListener = null;
+
+  // We use this to avoid touching history in completeNavigation if a
+  // revalidation is entirely uninterrupted
+  let isUninterruptedRevalidation = false;
+
+  // Use this internal flag to force revalidation of all loaders:
+  //  - submissions (completed or interrupted)
+  //  - useRevalidator()
+  //  - X-Remix-Revalidate (from redirect)
+  let isRevalidationRequired = false;
+
+  // Use this internal array to capture routes that require revalidation due
+  // to a cancelled deferred on action submission
+  let cancelledDeferredRoutes = [];
+
+  // Use this internal array to capture fetcher loads that were cancelled by an
+  // action navigation and require revalidation
+  let cancelledFetcherLoads = new Set();
+
+  // AbortControllers for any in-flight fetchers
+  let fetchControllers = new Map();
+
+  // Track loads based on the order in which they started
+  let incrementingLoadId = 0;
+
+  // Track the outstanding pending navigation data load to be compared against
+  // the globally incrementing load when a fetcher load lands after a completed
+  // navigation
+  let pendingNavigationLoadId = -1;
+
+  // Fetchers that triggered data reloads as a result of their actions
+  let fetchReloadIds = new Map();
+
+  // Fetchers that triggered redirect navigations
+  let fetchRedirectIds = new Set();
+
+  // Most recent href/match for fetcher.load calls for fetchers
+  let fetchLoadMatches = new Map();
+
+  // Ref-count mounted fetchers so we know when it's ok to clean them up
+  let activeFetchers = new Map();
+
+  // Fetchers that have requested a delete when using v7_fetcherPersist,
+  // they'll be officially removed after they return to idle
+  let deletedFetchers = new Set();
+
+  // Store DeferredData instances for active route matches.  When a
+  // route loader returns defer() we stick one in here.  Then, when a nested
+  // promise resolves we update loaderData.  If a new navigation starts we
+  // cancel active deferreds for eliminated routes.
+  let activeDeferreds = new Map();
+
+  // Store blocker functions in a separate Map outside of router state since
+  // we don't need to update UI state if they change
+  let blockerFunctions = new Map();
+
+  // Flag to ignore the next history update, so we can revert the URL change on
+  // a POP navigation that was blocked by the user without touching router state
+  let unblockBlockerHistoryUpdate = undefined;
+
+  // Initialize the router, all side effects should be kicked off from here.
+  // Implemented as a Fluent API for ease of:
+  //   let router = createRouter(init).initialize();
+  function initialize() {
+    // If history informs us of a POP navigation, start the navigation but do not update
+    // state.  We'll update our own state once the navigation completes
+    unlistenHistory = init.history.listen(_ref => {
+      let {
+        action: historyAction,
+        location,
+        delta
+      } = _ref;
+      // Ignore this event if it was just us resetting the URL from a
+      // blocked POP navigation
+      if (unblockBlockerHistoryUpdate) {
+        unblockBlockerHistoryUpdate();
+        unblockBlockerHistoryUpdate = undefined;
+        return;
+      }
+      warning(blockerFunctions.size === 0 || delta != null, "You are trying to use a blocker on a POP navigation to a location " + "that was not created by @remix-run/router. This will fail silently in " + "production. This can happen if you are navigating outside the router " + "via `window.history.pushState`/`window.location.hash` instead of using " + "router navigation APIs.  This can also happen if you are using " + "createHashRouter and the user manually changes the URL.");
+      let blockerKey = shouldBlockNavigation({
+        currentLocation: state.location,
+        nextLocation: location,
+        historyAction
+      });
+      if (blockerKey && delta != null) {
+        // Restore the URL to match the current UI, but don't update router state
+        let nextHistoryUpdatePromise = new Promise(resolve => {
+          unblockBlockerHistoryUpdate = resolve;
+        });
+        init.history.go(delta * -1);
+
+        // Put the blocker into a blocked state
+        updateBlocker(blockerKey, {
+          state: "blocked",
+          location,
+          proceed() {
+            updateBlocker(blockerKey, {
+              state: "proceeding",
+              proceed: undefined,
+              reset: undefined,
+              location
+            });
+            // Re-do the same POP navigation we just blocked, after the url
+            // restoration is also complete.  See:
+            // https://github.com/remix-run/react-router/issues/11613
+            nextHistoryUpdatePromise.then(() => init.history.go(delta));
+          },
+          reset() {
+            let blockers = new Map(state.blockers);
+            blockers.set(blockerKey, IDLE_BLOCKER);
+            updateState({
+              blockers
+            });
+          }
+        });
+        return;
+      }
+      return startNavigation(historyAction, location);
+    });
+    if (isBrowser) {
+      // FIXME: This feels gross.  How can we cleanup the lines between
+      // scrollRestoration/appliedTransitions persistance?
+      restoreAppliedTransitions(routerWindow, appliedViewTransitions);
+      let _saveAppliedTransitions = () => persistAppliedTransitions(routerWindow, appliedViewTransitions);
+      routerWindow.addEventListener("pagehide", _saveAppliedTransitions);
+      removePageHideEventListener = () => routerWindow.removeEventListener("pagehide", _saveAppliedTransitions);
+    }
+
+    // Kick off initial data load if needed.  Use Pop to avoid modifying history
+    // Note we don't do any handling of lazy here.  For SPA's it'll get handled
+    // in the normal navigation flow.  For SSR it's expected that lazy modules are
+    // resolved prior to router creation since we can't go into a fallbackElement
+    // UI for SSR'd apps
+    if (!state.initialized) {
+      startNavigation(Action.Pop, state.location, {
+        initialHydration: true
+      });
+    }
+    return router;
+  }
+
+  // Clean up a router and it's side effects
+  function dispose() {
+    if (unlistenHistory) {
+      unlistenHistory();
+    }
+    if (removePageHideEventListener) {
+      removePageHideEventListener();
+    }
+    subscribers.clear();
+    pendingNavigationController && pendingNavigationController.abort();
+    state.fetchers.forEach((_, key) => deleteFetcher(key));
+    state.blockers.forEach((_, key) => deleteBlocker(key));
+  }
+
+  // Subscribe to state updates for the router
+  function subscribe(fn) {
+    subscribers.add(fn);
+    return () => subscribers.delete(fn);
+  }
+
+  // Update our state and notify the calling context of the change
+  function updateState(newState, opts) {
+    if (opts === void 0) {
+      opts = {};
+    }
+    state = _extends({}, state, newState);
+
+    // Prep fetcher cleanup so we can tell the UI which fetcher data entries
+    // can be removed
+    let completedFetchers = [];
+    let deletedFetchersKeys = [];
+    if (future.v7_fetcherPersist) {
+      state.fetchers.forEach((fetcher, key) => {
+        if (fetcher.state === "idle") {
+          if (deletedFetchers.has(key)) {
+            // Unmounted from the UI and can be totally removed
+            deletedFetchersKeys.push(key);
+          } else {
+            // Returned to idle but still mounted in the UI, so semi-remains for
+            // revalidations and such
+            completedFetchers.push(key);
+          }
+        }
+      });
+    }
+
+    // Remove any lingering deleted fetchers that have already been removed
+    // from state.fetchers
+    deletedFetchers.forEach(key => {
+      if (!state.fetchers.has(key) && !fetchControllers.has(key)) {
+        deletedFetchersKeys.push(key);
+      }
+    });
+
+    // Iterate over a local copy so that if flushSync is used and we end up
+    // removing and adding a new subscriber due to the useCallback dependencies,
+    // we don't get ourselves into a loop calling the new subscriber immediately
+    [...subscribers].forEach(subscriber => subscriber(state, {
+      deletedFetchers: deletedFetchersKeys,
+      viewTransitionOpts: opts.viewTransitionOpts,
+      flushSync: opts.flushSync === true
+    }));
+
+    // Remove idle fetchers from state since we only care about in-flight fetchers.
+    if (future.v7_fetcherPersist) {
+      completedFetchers.forEach(key => state.fetchers.delete(key));
+      deletedFetchersKeys.forEach(key => deleteFetcher(key));
+    } else {
+      // We already called deleteFetcher() on these, can remove them from this
+      // Set now that we've handed the keys off to the data layer
+      deletedFetchersKeys.forEach(key => deletedFetchers.delete(key));
+    }
+  }
+
+  // Complete a navigation returning the state.navigation back to the IDLE_NAVIGATION
+  // and setting state.[historyAction/location/matches] to the new route.
+  // - Location is a required param
+  // - Navigation will always be set to IDLE_NAVIGATION
+  // - Can pass any other state in newState
+  function completeNavigation(location, newState, _temp) {
+    var _location$state, _location$state2;
+    let {
+      flushSync
+    } = _temp === void 0 ? {} : _temp;
+    // Deduce if we're in a loading/actionReload state:
+    // - We have committed actionData in the store
+    // - The current navigation was a mutation submission
+    // - We're past the submitting state and into the loading state
+    // - The location being loaded is not the result of a redirect
+    let isActionReload = state.actionData != null && state.navigation.formMethod != null && isMutationMethod(state.navigation.formMethod) && state.navigation.state === "loading" && ((_location$state = location.state) == null ? void 0 : _location$state._isRedirect) !== true;
+    let actionData;
+    if (newState.actionData) {
+      if (Object.keys(newState.actionData).length > 0) {
+        actionData = newState.actionData;
+      } else {
+        // Empty actionData -> clear prior actionData due to an action error
+        actionData = null;
+      }
+    } else if (isActionReload) {
+      // Keep the current data if we're wrapping up the action reload
+      actionData = state.actionData;
+    } else {
+      // Clear actionData on any other completed navigations
+      actionData = null;
+    }
+
+    // Always preserve any existing loaderData from re-used routes
+    let loaderData = newState.loaderData ? mergeLoaderData(state.loaderData, newState.loaderData, newState.matches || [], newState.errors) : state.loaderData;
+
+    // On a successful navigation we can assume we got through all blockers
+    // so we can start fresh
+    let blockers = state.blockers;
+    if (blockers.size > 0) {
+      blockers = new Map(blockers);
+      blockers.forEach((_, k) => blockers.set(k, IDLE_BLOCKER));
+    }
+
+    // Always respect the user flag.  Otherwise don't reset on mutation
+    // submission navigations unless they redirect
+    let preventScrollReset = pendingPreventScrollReset === true || state.navigation.formMethod != null && isMutationMethod(state.navigation.formMethod) && ((_location$state2 = location.state) == null ? void 0 : _location$state2._isRedirect) !== true;
+
+    // Commit any in-flight routes at the end of the HMR revalidation "navigation"
+    if (inFlightDataRoutes) {
+      dataRoutes = inFlightDataRoutes;
+      inFlightDataRoutes = undefined;
+    }
+    if (isUninterruptedRevalidation) ; else if (pendingAction === Action.Pop) ; else if (pendingAction === Action.Push) {
+      init.history.push(location, location.state);
+    } else if (pendingAction === Action.Replace) {
+      init.history.replace(location, location.state);
+    }
+    let viewTransitionOpts;
+
+    // On POP, enable transitions if they were enabled on the original navigation
+    if (pendingAction === Action.Pop) {
+      // Forward takes precedence so they behave like the original navigation
+      let priorPaths = appliedViewTransitions.get(state.location.pathname);
+      if (priorPaths && priorPaths.has(location.pathname)) {
+        viewTransitionOpts = {
+          currentLocation: state.location,
+          nextLocation: location
+        };
+      } else if (appliedViewTransitions.has(location.pathname)) {
+        // If we don't have a previous forward nav, assume we're popping back to
+        // the new location and enable if that location previously enabled
+        viewTransitionOpts = {
+          currentLocation: location,
+          nextLocation: state.location
+        };
+      }
+    } else if (pendingViewTransitionEnabled) {
+      // Store the applied transition on PUSH/REPLACE
+      let toPaths = appliedViewTransitions.get(state.location.pathname);
+      if (toPaths) {
+        toPaths.add(location.pathname);
+      } else {
+        toPaths = new Set([location.pathname]);
+        appliedViewTransitions.set(state.location.pathname, toPaths);
+      }
+      viewTransitionOpts = {
+        currentLocation: state.location,
+        nextLocation: location
+      };
+    }
+    updateState(_extends({}, newState, {
+      // matches, errors, fetchers go through as-is
+      actionData,
+      loaderData,
+      historyAction: pendingAction,
+      location,
+      initialized: true,
+      navigation: IDLE_NAVIGATION,
+      revalidation: "idle",
+      restoreScrollPosition: getSavedScrollPosition(location, newState.matches || state.matches),
+      preventScrollReset,
+      blockers
+    }), {
+      viewTransitionOpts,
+      flushSync: flushSync === true
+    });
+
+    // Reset stateful navigation vars
+    pendingAction = Action.Pop;
+    pendingPreventScrollReset = false;
+    pendingViewTransitionEnabled = false;
+    isUninterruptedRevalidation = false;
+    isRevalidationRequired = false;
+    cancelledDeferredRoutes = [];
+  }
+
+  // Trigger a navigation event, which can either be a numerical POP or a PUSH
+  // replace with an optional submission
+  async function navigate(to, opts) {
+    if (typeof to === "number") {
+      init.history.go(to);
+      return;
+    }
+    let normalizedPath = normalizeTo(state.location, state.matches, basename, future.v7_prependBasename, to, future.v7_relativeSplatPath, opts == null ? void 0 : opts.fromRouteId, opts == null ? void 0 : opts.relative);
+    let {
+      path,
+      submission,
+      error
+    } = normalizeNavigateOptions(future.v7_normalizeFormMethod, false, normalizedPath, opts);
+    let currentLocation = state.location;
+    let nextLocation = createLocation(state.location, path, opts && opts.state);
+
+    // When using navigate as a PUSH/REPLACE we aren't reading an already-encoded
+    // URL from window.location, so we need to encode it here so the behavior
+    // remains the same as POP and non-data-router usages.  new URL() does all
+    // the same encoding we'd get from a history.pushState/window.location read
+    // without having to touch history
+    nextLocation = _extends({}, nextLocation, init.history.encodeLocation(nextLocation));
+    let userReplace = opts && opts.replace != null ? opts.replace : undefined;
+    let historyAction = Action.Push;
+    if (userReplace === true) {
+      historyAction = Action.Replace;
+    } else if (userReplace === false) ; else if (submission != null && isMutationMethod(submission.formMethod) && submission.formAction === state.location.pathname + state.location.search) {
+      // By default on submissions to the current location we REPLACE so that
+      // users don't have to double-click the back button to get to the prior
+      // location.  If the user redirects to a different location from the
+      // action/loader this will be ignored and the redirect will be a PUSH
+      historyAction = Action.Replace;
+    }
+    let preventScrollReset = opts && "preventScrollReset" in opts ? opts.preventScrollReset === true : undefined;
+    let flushSync = (opts && opts.flushSync) === true;
+    let blockerKey = shouldBlockNavigation({
+      currentLocation,
+      nextLocation,
+      historyAction
+    });
+    if (blockerKey) {
+      // Put the blocker into a blocked state
+      updateBlocker(blockerKey, {
+        state: "blocked",
+        location: nextLocation,
+        proceed() {
+          updateBlocker(blockerKey, {
+            state: "proceeding",
+            proceed: undefined,
+            reset: undefined,
+            location: nextLocation
+          });
+          // Send the same navigation through
+          navigate(to, opts);
+        },
+        reset() {
+          let blockers = new Map(state.blockers);
+          blockers.set(blockerKey, IDLE_BLOCKER);
+          updateState({
+            blockers
+          });
+        }
+      });
+      return;
+    }
+    return await startNavigation(historyAction, nextLocation, {
+      submission,
+      // Send through the formData serialization error if we have one so we can
+      // render at the right error boundary after we match routes
+      pendingError: error,
+      preventScrollReset,
+      replace: opts && opts.replace,
+      enableViewTransition: opts && opts.viewTransition,
+      flushSync
+    });
+  }
+
+  // Revalidate all current loaders.  If a navigation is in progress or if this
+  // is interrupted by a navigation, allow this to "succeed" by calling all
+  // loaders during the next loader round
+  function revalidate() {
+    interruptActiveLoads();
+    updateState({
+      revalidation: "loading"
+    });
+
+    // If we're currently submitting an action, we don't need to start a new
+    // navigation, we'll just let the follow up loader execution call all loaders
+    if (state.navigation.state === "submitting") {
+      return;
+    }
+
+    // If we're currently in an idle state, start a new navigation for the current
+    // action/location and mark it as uninterrupted, which will skip the history
+    // update in completeNavigation
+    if (state.navigation.state === "idle") {
+      startNavigation(state.historyAction, state.location, {
+        startUninterruptedRevalidation: true
+      });
+      return;
+    }
+
+    // Otherwise, if we're currently in a loading state, just start a new
+    // navigation to the navigation.location but do not trigger an uninterrupted
+    // revalidation so that history correctly updates once the navigation completes
+    startNavigation(pendingAction || state.historyAction, state.navigation.location, {
+      overrideNavigation: state.navigation,
+      // Proxy through any rending view transition
+      enableViewTransition: pendingViewTransitionEnabled === true
+    });
+  }
+
+  // Start a navigation to the given action/location.  Can optionally provide a
+  // overrideNavigation which will override the normalLoad in the case of a redirect
+  // navigation
+  async function startNavigation(historyAction, location, opts) {
+    // Abort any in-progress navigations and start a new one. Unset any ongoing
+    // uninterrupted revalidations unless told otherwise, since we want this
+    // new navigation to update history normally
+    pendingNavigationController && pendingNavigationController.abort();
+    pendingNavigationController = null;
+    pendingAction = historyAction;
+    isUninterruptedRevalidation = (opts && opts.startUninterruptedRevalidation) === true;
+
+    // Save the current scroll position every time we start a new navigation,
+    // and track whether we should reset scroll on completion
+    saveScrollPosition(state.location, state.matches);
+    pendingPreventScrollReset = (opts && opts.preventScrollReset) === true;
+    pendingViewTransitionEnabled = (opts && opts.enableViewTransition) === true;
+    let routesToUse = inFlightDataRoutes || dataRoutes;
+    let loadingNavigation = opts && opts.overrideNavigation;
+    let matches = opts != null && opts.initialHydration && state.matches && state.matches.length > 0 && !initialMatchesIsFOW ?
+    // `matchRoutes()` has already been called if we're in here via `router.initialize()`
+    state.matches : matchRoutes(routesToUse, location, basename);
+    let flushSync = (opts && opts.flushSync) === true;
+
+    // Short circuit if it's only a hash change and not a revalidation or
+    // mutation submission.
+    //
+    // Ignore on initial page loads because since the initial hydration will always
+    // be "same hash".  For example, on /page#hash and submit a <Form method="post">
+    // which will default to a navigation to /page
+    if (matches && state.initialized && !isRevalidationRequired && isHashChangeOnly(state.location, location) && !(opts && opts.submission && isMutationMethod(opts.submission.formMethod))) {
+      completeNavigation(location, {
+        matches
+      }, {
+        flushSync
+      });
+      return;
+    }
+    let fogOfWar = checkFogOfWar(matches, routesToUse, location.pathname);
+    if (fogOfWar.active && fogOfWar.matches) {
+      matches = fogOfWar.matches;
+    }
+
+    // Short circuit with a 404 on the root error boundary if we match nothing
+    if (!matches) {
+      let {
+        error,
+        notFoundMatches,
+        route
+      } = handleNavigational404(location.pathname);
+      completeNavigation(location, {
+        matches: notFoundMatches,
+        loaderData: {},
+        errors: {
+          [route.id]: error
+        }
+      }, {
+        flushSync
+      });
+      return;
+    }
+
+    // Create a controller/Request for this navigation
+    pendingNavigationController = new AbortController();
+    let request = createClientSideRequest(init.history, location, pendingNavigationController.signal, opts && opts.submission);
+    let pendingActionResult;
+    if (opts && opts.pendingError) {
+      // If we have a pendingError, it means the user attempted a GET submission
+      // with binary FormData so assign here and skip to handleLoaders.  That
+      // way we handle calling loaders above the boundary etc.  It's not really
+      // different from an actionError in that sense.
+      pendingActionResult = [findNearestBoundary(matches).route.id, {
+        type: ResultType.error,
+        error: opts.pendingError
+      }];
+    } else if (opts && opts.submission && isMutationMethod(opts.submission.formMethod)) {
+      // Call action if we received an action submission
+      let actionResult = await handleAction(request, location, opts.submission, matches, fogOfWar.active, {
+        replace: opts.replace,
+        flushSync
+      });
+      if (actionResult.shortCircuited) {
+        return;
+      }
+
+      // If we received a 404 from handleAction, it's because we couldn't lazily
+      // discover the destination route so we don't want to call loaders
+      if (actionResult.pendingActionResult) {
+        let [routeId, result] = actionResult.pendingActionResult;
+        if (isErrorResult(result) && isRouteErrorResponse(result.error) && result.error.status === 404) {
+          pendingNavigationController = null;
+          completeNavigation(location, {
+            matches: actionResult.matches,
+            loaderData: {},
+            errors: {
+              [routeId]: result.error
+            }
+          });
+          return;
+        }
+      }
+      matches = actionResult.matches || matches;
+      pendingActionResult = actionResult.pendingActionResult;
+      loadingNavigation = getLoadingNavigation(location, opts.submission);
+      flushSync = false;
+      // No need to do fog of war matching again on loader execution
+      fogOfWar.active = false;
+
+      // Create a GET request for the loaders
+      request = createClientSideRequest(init.history, request.url, request.signal);
+    }
+
+    // Call loaders
+    let {
+      shortCircuited,
+      matches: updatedMatches,
+      loaderData,
+      errors
+    } = await handleLoaders(request, location, matches, fogOfWar.active, loadingNavigation, opts && opts.submission, opts && opts.fetcherSubmission, opts && opts.replace, opts && opts.initialHydration === true, flushSync, pendingActionResult);
+    if (shortCircuited) {
+      return;
+    }
+
+    // Clean up now that the action/loaders have completed.  Don't clean up if
+    // we short circuited because pendingNavigationController will have already
+    // been assigned to a new controller for the next navigation
+    pendingNavigationController = null;
+    completeNavigation(location, _extends({
+      matches: updatedMatches || matches
+    }, getActionDataForCommit(pendingActionResult), {
+      loaderData,
+      errors
+    }));
+  }
+
+  // Call the action matched by the leaf route for this navigation and handle
+  // redirects/errors
+  async function handleAction(request, location, submission, matches, isFogOfWar, opts) {
+    if (opts === void 0) {
+      opts = {};
+    }
+    interruptActiveLoads();
+
+    // Put us in a submitting state
+    let navigation = getSubmittingNavigation(location, submission);
+    updateState({
+      navigation
+    }, {
+      flushSync: opts.flushSync === true
+    });
+    if (isFogOfWar) {
+      let discoverResult = await discoverRoutes(matches, location.pathname, request.signal);
+      if (discoverResult.type === "aborted") {
+        return {
+          shortCircuited: true
+        };
+      } else if (discoverResult.type === "error") {
+        let boundaryId = findNearestBoundary(discoverResult.partialMatches).route.id;
+        return {
+          matches: discoverResult.partialMatches,
+          pendingActionResult: [boundaryId, {
+            type: ResultType.error,
+            error: discoverResult.error
+          }]
+        };
+      } else if (!discoverResult.matches) {
+        let {
+          notFoundMatches,
+          error,
+          route
+        } = handleNavigational404(location.pathname);
+        return {
+          matches: notFoundMatches,
+          pendingActionResult: [route.id, {
+            type: ResultType.error,
+            error
+          }]
+        };
+      } else {
+        matches = discoverResult.matches;
+      }
+    }
+
+    // Call our action and get the result
+    let result;
+    let actionMatch = getTargetMatch(matches, location);
+    if (!actionMatch.route.action && !actionMatch.route.lazy) {
+      result = {
+        type: ResultType.error,
+        error: getInternalRouterError(405, {
+          method: request.method,
+          pathname: location.pathname,
+          routeId: actionMatch.route.id
+        })
+      };
+    } else {
+      let results = await callDataStrategy("action", state, request, [actionMatch], matches, null);
+      result = results[actionMatch.route.id];
+      if (request.signal.aborted) {
+        return {
+          shortCircuited: true
+        };
+      }
+    }
+    if (isRedirectResult(result)) {
+      let replace;
+      if (opts && opts.replace != null) {
+        replace = opts.replace;
+      } else {
+        // If the user didn't explicity indicate replace behavior, replace if
+        // we redirected to the exact same location we're currently at to avoid
+        // double back-buttons
+        let location = normalizeRedirectLocation(result.response.headers.get("Location"), new URL(request.url), basename, init.history);
+        replace = location === state.location.pathname + state.location.search;
+      }
+      await startRedirectNavigation(request, result, true, {
+        submission,
+        replace
+      });
+      return {
+        shortCircuited: true
+      };
+    }
+    if (isDeferredResult(result)) {
+      throw getInternalRouterError(400, {
+        type: "defer-action"
+      });
+    }
+    if (isErrorResult(result)) {
+      // Store off the pending error - we use it to determine which loaders
+      // to call and will commit it when we complete the navigation
+      let boundaryMatch = findNearestBoundary(matches, actionMatch.route.id);
+
+      // By default, all submissions to the current location are REPLACE
+      // navigations, but if the action threw an error that'll be rendered in
+      // an errorElement, we fall back to PUSH so that the user can use the
+      // back button to get back to the pre-submission form location to try
+      // again
+      if ((opts && opts.replace) !== true) {
+        pendingAction = Action.Push;
+      }
+      return {
+        matches,
+        pendingActionResult: [boundaryMatch.route.id, result]
+      };
+    }
+    return {
+      matches,
+      pendingActionResult: [actionMatch.route.id, result]
+    };
+  }
+
+  // Call all applicable loaders for the given matches, handling redirects,
+  // errors, etc.
+  async function handleLoaders(request, location, matches, isFogOfWar, overrideNavigation, submission, fetcherSubmission, replace, initialHydration, flushSync, pendingActionResult) {
+    // Figure out the right navigation we want to use for data loading
+    let loadingNavigation = overrideNavigation || getLoadingNavigation(location, submission);
+
+    // If this was a redirect from an action we don't have a "submission" but
+    // we have it on the loading navigation so use that if available
+    let activeSubmission = submission || fetcherSubmission || getSubmissionFromNavigation(loadingNavigation);
+
+    // If this is an uninterrupted revalidation, we remain in our current idle
+    // state.  If not, we need to switch to our loading state and load data,
+    // preserving any new action data or existing action data (in the case of
+    // a revalidation interrupting an actionReload)
+    // If we have partialHydration enabled, then don't update the state for the
+    // initial data load since it's not a "navigation"
+    let shouldUpdateNavigationState = !isUninterruptedRevalidation && (!future.v7_partialHydration || !initialHydration);
+
+    // When fog of war is enabled, we enter our `loading` state earlier so we
+    // can discover new routes during the `loading` state.  We skip this if
+    // we've already run actions since we would have done our matching already.
+    // If the children() function threw then, we want to proceed with the
+    // partial matches it discovered.
+    if (isFogOfWar) {
+      if (shouldUpdateNavigationState) {
+        let actionData = getUpdatedActionData(pendingActionResult);
+        updateState(_extends({
+          navigation: loadingNavigation
+        }, actionData !== undefined ? {
+          actionData
+        } : {}), {
+          flushSync
+        });
+      }
+      let discoverResult = await discoverRoutes(matches, location.pathname, request.signal);
+      if (discoverResult.type === "aborted") {
+        return {
+          shortCircuited: true
+        };
+      } else if (discoverResult.type === "error") {
+        let boundaryId = findNearestBoundary(discoverResult.partialMatches).route.id;
+        return {
+          matches: discoverResult.partialMatches,
+          loaderData: {},
+          errors: {
+            [boundaryId]: discoverResult.error
+          }
+        };
+      } else if (!discoverResult.matches) {
+        let {
+          error,
+          notFoundMatches,
+          route
+        } = handleNavigational404(location.pathname);
+        return {
+          matches: notFoundMatches,
+          loaderData: {},
+          errors: {
+            [route.id]: error
+          }
+        };
+      } else {
+        matches = discoverResult.matches;
+      }
+    }
+    let routesToUse = inFlightDataRoutes || dataRoutes;
+    let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(init.history, state, matches, activeSubmission, location, future.v7_partialHydration && initialHydration === true, future.v7_skipActionErrorRevalidation, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, deletedFetchers, fetchLoadMatches, fetchRedirectIds, routesToUse, basename, pendingActionResult);
+
+    // Cancel pending deferreds for no-longer-matched routes or routes we're
+    // about to reload.  Note that if this is an action reload we would have
+    // already cancelled all pending deferreds so this would be a no-op
+    cancelActiveDeferreds(routeId => !(matches && matches.some(m => m.route.id === routeId)) || matchesToLoad && matchesToLoad.some(m => m.route.id === routeId));
+    pendingNavigationLoadId = ++incrementingLoadId;
+
+    // Short circuit if we have no loaders to run
+    if (matchesToLoad.length === 0 && revalidatingFetchers.length === 0) {
+      let updatedFetchers = markFetchRedirectsDone();
+      completeNavigation(location, _extends({
+        matches,
+        loaderData: {},
+        // Commit pending error if we're short circuiting
+        errors: pendingActionResult && isErrorResult(pendingActionResult[1]) ? {
+          [pendingActionResult[0]]: pendingActionResult[1].error
+        } : null
+      }, getActionDataForCommit(pendingActionResult), updatedFetchers ? {
+        fetchers: new Map(state.fetchers)
+      } : {}), {
+        flushSync
+      });
+      return {
+        shortCircuited: true
+      };
+    }
+    if (shouldUpdateNavigationState) {
+      let updates = {};
+      if (!isFogOfWar) {
+        // Only update navigation/actionNData if we didn't already do it above
+        updates.navigation = loadingNavigation;
+        let actionData = getUpdatedActionData(pendingActionResult);
+        if (actionData !== undefined) {
+          updates.actionData = actionData;
+        }
+      }
+      if (revalidatingFetchers.length > 0) {
+        updates.fetchers = getUpdatedRevalidatingFetchers(revalidatingFetchers);
+      }
+      updateState(updates, {
+        flushSync
+      });
+    }
+    revalidatingFetchers.forEach(rf => {
+      abortFetcher(rf.key);
+      if (rf.controller) {
+        // Fetchers use an independent AbortController so that aborting a fetcher
+        // (via deleteFetcher) does not abort the triggering navigation that
+        // triggered the revalidation
+        fetchControllers.set(rf.key, rf.controller);
+      }
+    });
+
+    // Proxy navigation abort through to revalidation fetchers
+    let abortPendingFetchRevalidations = () => revalidatingFetchers.forEach(f => abortFetcher(f.key));
+    if (pendingNavigationController) {
+      pendingNavigationController.signal.addEventListener("abort", abortPendingFetchRevalidations);
+    }
+    let {
+      loaderResults,
+      fetcherResults
+    } = await callLoadersAndMaybeResolveData(state, matches, matchesToLoad, revalidatingFetchers, request);
+    if (request.signal.aborted) {
+      return {
+        shortCircuited: true
+      };
+    }
+
+    // Clean up _after_ loaders have completed.  Don't clean up if we short
+    // circuited because fetchControllers would have been aborted and
+    // reassigned to new controllers for the next navigation
+    if (pendingNavigationController) {
+      pendingNavigationController.signal.removeEventListener("abort", abortPendingFetchRevalidations);
+    }
+    revalidatingFetchers.forEach(rf => fetchControllers.delete(rf.key));
+
+    // If any loaders returned a redirect Response, start a new REPLACE navigation
+    let redirect = findRedirect(loaderResults);
+    if (redirect) {
+      await startRedirectNavigation(request, redirect.result, true, {
+        replace
+      });
+      return {
+        shortCircuited: true
+      };
+    }
+    redirect = findRedirect(fetcherResults);
+    if (redirect) {
+      // If this redirect came from a fetcher make sure we mark it in
+      // fetchRedirectIds so it doesn't get revalidated on the next set of
+      // loader executions
+      fetchRedirectIds.add(redirect.key);
+      await startRedirectNavigation(request, redirect.result, true, {
+        replace
+      });
+      return {
+        shortCircuited: true
+      };
+    }
+
+    // Process and commit output from loaders
+    let {
+      loaderData,
+      errors
+    } = processLoaderData(state, matches, loaderResults, pendingActionResult, revalidatingFetchers, fetcherResults, activeDeferreds);
+
+    // Wire up subscribers to update loaderData as promises settle
+    activeDeferreds.forEach((deferredData, routeId) => {
+      deferredData.subscribe(aborted => {
+        // Note: No need to updateState here since the TrackedPromise on
+        // loaderData is stable across resolve/reject
+        // Remove this instance if we were aborted or if promises have settled
+        if (aborted || deferredData.done) {
+          activeDeferreds.delete(routeId);
+        }
+      });
+    });
+
+    // Preserve SSR errors during partial hydration
+    if (future.v7_partialHydration && initialHydration && state.errors) {
+      errors = _extends({}, state.errors, errors);
+    }
+    let updatedFetchers = markFetchRedirectsDone();
+    let didAbortFetchLoads = abortStaleFetchLoads(pendingNavigationLoadId);
+    let shouldUpdateFetchers = updatedFetchers || didAbortFetchLoads || revalidatingFetchers.length > 0;
+    return _extends({
+      matches,
+      loaderData,
+      errors
+    }, shouldUpdateFetchers ? {
+      fetchers: new Map(state.fetchers)
+    } : {});
+  }
+  function getUpdatedActionData(pendingActionResult) {
+    if (pendingActionResult && !isErrorResult(pendingActionResult[1])) {
+      // This is cast to `any` currently because `RouteData`uses any and it
+      // would be a breaking change to use any.
+      // TODO: v7 - change `RouteData` to use `unknown` instead of `any`
+      return {
+        [pendingActionResult[0]]: pendingActionResult[1].data
+      };
+    } else if (state.actionData) {
+      if (Object.keys(state.actionData).length === 0) {
+        return null;
+      } else {
+        return state.actionData;
+      }
+    }
+  }
+  function getUpdatedRevalidatingFetchers(revalidatingFetchers) {
+    revalidatingFetchers.forEach(rf => {
+      let fetcher = state.fetchers.get(rf.key);
+      let revalidatingFetcher = getLoadingFetcher(undefined, fetcher ? fetcher.data : undefined);
+      state.fetchers.set(rf.key, revalidatingFetcher);
+    });
+    return new Map(state.fetchers);
+  }
+
+  // Trigger a fetcher load/submit for the given fetcher key
+  function fetch(key, routeId, href, opts) {
+    if (isServer) {
+      throw new Error("router.fetch() was called during the server render, but it shouldn't be. " + "You are likely calling a useFetcher() method in the body of your component. " + "Try moving it to a useEffect or a callback.");
+    }
+    abortFetcher(key);
+    let flushSync = (opts && opts.flushSync) === true;
+    let routesToUse = inFlightDataRoutes || dataRoutes;
+    let normalizedPath = normalizeTo(state.location, state.matches, basename, future.v7_prependBasename, href, future.v7_relativeSplatPath, routeId, opts == null ? void 0 : opts.relative);
+    let matches = matchRoutes(routesToUse, normalizedPath, basename);
+    let fogOfWar = checkFogOfWar(matches, routesToUse, normalizedPath);
+    if (fogOfWar.active && fogOfWar.matches) {
+      matches = fogOfWar.matches;
+    }
+    if (!matches) {
+      setFetcherError(key, routeId, getInternalRouterError(404, {
+        pathname: normalizedPath
+      }), {
+        flushSync
+      });
+      return;
+    }
+    let {
+      path,
+      submission,
+      error
+    } = normalizeNavigateOptions(future.v7_normalizeFormMethod, true, normalizedPath, opts);
+    if (error) {
+      setFetcherError(key, routeId, error, {
+        flushSync
+      });
+      return;
+    }
+    let match = getTargetMatch(matches, path);
+    let preventScrollReset = (opts && opts.preventScrollReset) === true;
+    if (submission && isMutationMethod(submission.formMethod)) {
+      handleFetcherAction(key, routeId, path, match, matches, fogOfWar.active, flushSync, preventScrollReset, submission);
+      return;
+    }
+
+    // Store off the match so we can call it's shouldRevalidate on subsequent
+    // revalidations
+    fetchLoadMatches.set(key, {
+      routeId,
+      path
+    });
+    handleFetcherLoader(key, routeId, path, match, matches, fogOfWar.active, flushSync, preventScrollReset, submission);
+  }
+
+  // Call the action for the matched fetcher.submit(), and then handle redirects,
+  // errors, and revalidation
+  async function handleFetcherAction(key, routeId, path, match, requestMatches, isFogOfWar, flushSync, preventScrollReset, submission) {
+    interruptActiveLoads();
+    fetchLoadMatches.delete(key);
+    function detectAndHandle405Error(m) {
+      if (!m.route.action && !m.route.lazy) {
+        let error = getInternalRouterError(405, {
+          method: submission.formMethod,
+          pathname: path,
+          routeId: routeId
+        });
+        setFetcherError(key, routeId, error, {
+          flushSync
+        });
+        return true;
+      }
+      return false;
+    }
+    if (!isFogOfWar && detectAndHandle405Error(match)) {
+      return;
+    }
+
+    // Put this fetcher into it's submitting state
+    let existingFetcher = state.fetchers.get(key);
+    updateFetcherState(key, getSubmittingFetcher(submission, existingFetcher), {
+      flushSync
+    });
+    let abortController = new AbortController();
+    let fetchRequest = createClientSideRequest(init.history, path, abortController.signal, submission);
+    if (isFogOfWar) {
+      let discoverResult = await discoverRoutes(requestMatches, new URL(fetchRequest.url).pathname, fetchRequest.signal, key);
+      if (discoverResult.type === "aborted") {
+        return;
+      } else if (discoverResult.type === "error") {
+        setFetcherError(key, routeId, discoverResult.error, {
+          flushSync
+        });
+        return;
+      } else if (!discoverResult.matches) {
+        setFetcherError(key, routeId, getInternalRouterError(404, {
+          pathname: path
+        }), {
+          flushSync
+        });
+        return;
+      } else {
+        requestMatches = discoverResult.matches;
+        match = getTargetMatch(requestMatches, path);
+        if (detectAndHandle405Error(match)) {
+          return;
+        }
+      }
+    }
+
+    // Call the action for the fetcher
+    fetchControllers.set(key, abortController);
+    let originatingLoadId = incrementingLoadId;
+    let actionResults = await callDataStrategy("action", state, fetchRequest, [match], requestMatches, key);
+    let actionResult = actionResults[match.route.id];
+    if (fetchRequest.signal.aborted) {
+      // We can delete this so long as we weren't aborted by our own fetcher
+      // re-submit which would have put _new_ controller is in fetchControllers
+      if (fetchControllers.get(key) === abortController) {
+        fetchControllers.delete(key);
+      }
+      return;
+    }
+
+    // When using v7_fetcherPersist, we don't want errors bubbling up to the UI
+    // or redirects processed for unmounted fetchers so we just revert them to
+    // idle
+    if (future.v7_fetcherPersist && deletedFetchers.has(key)) {
+      if (isRedirectResult(actionResult) || isErrorResult(actionResult)) {
+        updateFetcherState(key, getDoneFetcher(undefined));
+        return;
+      }
+      // Let SuccessResult's fall through for revalidation
+    } else {
+      if (isRedirectResult(actionResult)) {
+        fetchControllers.delete(key);
+        if (pendingNavigationLoadId > originatingLoadId) {
+          // A new navigation was kicked off after our action started, so that
+          // should take precedence over this redirect navigation.  We already
+          // set isRevalidationRequired so all loaders for the new route should
+          // fire unless opted out via shouldRevalidate
+          updateFetcherState(key, getDoneFetcher(undefined));
+          return;
+        } else {
+          fetchRedirectIds.add(key);
+          updateFetcherState(key, getLoadingFetcher(submission));
+          return startRedirectNavigation(fetchRequest, actionResult, false, {
+            fetcherSubmission: submission,
+            preventScrollReset
+          });
+        }
+      }
+
+      // Process any non-redirect errors thrown
+      if (isErrorResult(actionResult)) {
+        setFetcherError(key, routeId, actionResult.error);
+        return;
+      }
+    }
+    if (isDeferredResult(actionResult)) {
+      throw getInternalRouterError(400, {
+        type: "defer-action"
+      });
+    }
+
+    // Start the data load for current matches, or the next location if we're
+    // in the middle of a navigation
+    let nextLocation = state.navigation.location || state.location;
+    let revalidationRequest = createClientSideRequest(init.history, nextLocation, abortController.signal);
+    let routesToUse = inFlightDataRoutes || dataRoutes;
+    let matches = state.navigation.state !== "idle" ? matchRoutes(routesToUse, state.navigation.location, basename) : state.matches;
+    invariant(matches, "Didn't find any matches after fetcher action");
+    let loadId = ++incrementingLoadId;
+    fetchReloadIds.set(key, loadId);
+    let loadFetcher = getLoadingFetcher(submission, actionResult.data);
+    state.fetchers.set(key, loadFetcher);
+    let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(init.history, state, matches, submission, nextLocation, false, future.v7_skipActionErrorRevalidation, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, deletedFetchers, fetchLoadMatches, fetchRedirectIds, routesToUse, basename, [match.route.id, actionResult]);
+
+    // Put all revalidating fetchers into the loading state, except for the
+    // current fetcher which we want to keep in it's current loading state which
+    // contains it's action submission info + action data
+    revalidatingFetchers.filter(rf => rf.key !== key).forEach(rf => {
+      let staleKey = rf.key;
+      let existingFetcher = state.fetchers.get(staleKey);
+      let revalidatingFetcher = getLoadingFetcher(undefined, existingFetcher ? existingFetcher.data : undefined);
+      state.fetchers.set(staleKey, revalidatingFetcher);
+      abortFetcher(staleKey);
+      if (rf.controller) {
+        fetchControllers.set(staleKey, rf.controller);
+      }
+    });
+    updateState({
+      fetchers: new Map(state.fetchers)
+    });
+    let abortPendingFetchRevalidations = () => revalidatingFetchers.forEach(rf => abortFetcher(rf.key));
+    abortController.signal.addEventListener("abort", abortPendingFetchRevalidations);
+    let {
+      loaderResults,
+      fetcherResults
+    } = await callLoadersAndMaybeResolveData(state, matches, matchesToLoad, revalidatingFetchers, revalidationRequest);
+    if (abortController.signal.aborted) {
+      return;
+    }
+    abortController.signal.removeEventListener("abort", abortPendingFetchRevalidations);
+    fetchReloadIds.delete(key);
+    fetchControllers.delete(key);
+    revalidatingFetchers.forEach(r => fetchControllers.delete(r.key));
+    let redirect = findRedirect(loaderResults);
+    if (redirect) {
+      return startRedirectNavigation(revalidationRequest, redirect.result, false, {
+        preventScrollReset
+      });
+    }
+    redirect = findRedirect(fetcherResults);
+    if (redirect) {
+      // If this redirect came from a fetcher make sure we mark it in
+      // fetchRedirectIds so it doesn't get revalidated on the next set of
+      // loader executions
+      fetchRedirectIds.add(redirect.key);
+      return startRedirectNavigation(revalidationRequest, redirect.result, false, {
+        preventScrollReset
+      });
+    }
+
+    // Process and commit output from loaders
+    let {
+      loaderData,
+      errors
+    } = processLoaderData(state, matches, loaderResults, undefined, revalidatingFetchers, fetcherResults, activeDeferreds);
+
+    // Since we let revalidations complete even if the submitting fetcher was
+    // deleted, only put it back to idle if it hasn't been deleted
+    if (state.fetchers.has(key)) {
+      let doneFetcher = getDoneFetcher(actionResult.data);
+      state.fetchers.set(key, doneFetcher);
+    }
+    abortStaleFetchLoads(loadId);
+
+    // If we are currently in a navigation loading state and this fetcher is
+    // more recent than the navigation, we want the newer data so abort the
+    // navigation and complete it with the fetcher data
+    if (state.navigation.state === "loading" && loadId > pendingNavigationLoadId) {
+      invariant(pendingAction, "Expected pending action");
+      pendingNavigationController && pendingNavigationController.abort();
+      completeNavigation(state.navigation.location, {
+        matches,
+        loaderData,
+        errors,
+        fetchers: new Map(state.fetchers)
+      });
+    } else {
+      // otherwise just update with the fetcher data, preserving any existing
+      // loaderData for loaders that did not need to reload.  We have to
+      // manually merge here since we aren't going through completeNavigation
+      updateState({
+        errors,
+        loaderData: mergeLoaderData(state.loaderData, loaderData, matches, errors),
+        fetchers: new Map(state.fetchers)
+      });
+      isRevalidationRequired = false;
+    }
+  }
+
+  // Call the matched loader for fetcher.load(), handling redirects, errors, etc.
+  async function handleFetcherLoader(key, routeId, path, match, matches, isFogOfWar, flushSync, preventScrollReset, submission) {
+    let existingFetcher = state.fetchers.get(key);
+    updateFetcherState(key, getLoadingFetcher(submission, existingFetcher ? existingFetcher.data : undefined), {
+      flushSync
+    });
+    let abortController = new AbortController();
+    let fetchRequest = createClientSideRequest(init.history, path, abortController.signal);
+    if (isFogOfWar) {
+      let discoverResult = await discoverRoutes(matches, new URL(fetchRequest.url).pathname, fetchRequest.signal, key);
+      if (discoverResult.type === "aborted") {
+        return;
+      } else if (discoverResult.type === "error") {
+        setFetcherError(key, routeId, discoverResult.error, {
+          flushSync
+        });
+        return;
+      } else if (!discoverResult.matches) {
+        setFetcherError(key, routeId, getInternalRouterError(404, {
+          pathname: path
+        }), {
+          flushSync
+        });
+        return;
+      } else {
+        matches = discoverResult.matches;
+        match = getTargetMatch(matches, path);
+      }
+    }
+
+    // Call the loader for this fetcher route match
+    fetchControllers.set(key, abortController);
+    let originatingLoadId = incrementingLoadId;
+    let results = await callDataStrategy("loader", state, fetchRequest, [match], matches, key);
+    let result = results[match.route.id];
+
+    // Deferred isn't supported for fetcher loads, await everything and treat it
+    // as a normal load.  resolveDeferredData will return undefined if this
+    // fetcher gets aborted, so we just leave result untouched and short circuit
+    // below if that happens
+    if (isDeferredResult(result)) {
+      result = (await resolveDeferredData(result, fetchRequest.signal, true)) || result;
+    }
+
+    // We can delete this so long as we weren't aborted by our our own fetcher
+    // re-load which would have put _new_ controller is in fetchControllers
+    if (fetchControllers.get(key) === abortController) {
+      fetchControllers.delete(key);
+    }
+    if (fetchRequest.signal.aborted) {
+      return;
+    }
+
+    // We don't want errors bubbling up or redirects followed for unmounted
+    // fetchers, so short circuit here if it was removed from the UI
+    if (deletedFetchers.has(key)) {
+      updateFetcherState(key, getDoneFetcher(undefined));
+      return;
+    }
+
+    // If the loader threw a redirect Response, start a new REPLACE navigation
+    if (isRedirectResult(result)) {
+      if (pendingNavigationLoadId > originatingLoadId) {
+        // A new navigation was kicked off after our loader started, so that
+        // should take precedence over this redirect navigation
+        updateFetcherState(key, getDoneFetcher(undefined));
+        return;
+      } else {
+        fetchRedirectIds.add(key);
+        await startRedirectNavigation(fetchRequest, result, false, {
+          preventScrollReset
+        });
+        return;
+      }
+    }
+
+    // Process any non-redirect errors thrown
+    if (isErrorResult(result)) {
+      setFetcherError(key, routeId, result.error);
+      return;
+    }
+    invariant(!isDeferredResult(result), "Unhandled fetcher deferred data");
+
+    // Put the fetcher back into an idle state
+    updateFetcherState(key, getDoneFetcher(result.data));
+  }
+
+  /**
+   * Utility function to handle redirects returned from an action or loader.
+   * Normally, a redirect "replaces" the navigation that triggered it.  So, for
+   * example:
+   *
+   *  - user is on /a
+   *  - user clicks a link to /b
+   *  - loader for /b redirects to /c
+   *
+   * In a non-JS app the browser would track the in-flight navigation to /b and
+   * then replace it with /c when it encountered the redirect response.  In
+   * the end it would only ever update the URL bar with /c.
+   *
+   * In client-side routing using pushState/replaceState, we aim to emulate
+   * this behavior and we also do not update history until the end of the
+   * navigation (including processed redirects).  This means that we never
+   * actually touch history until we've processed redirects, so we just use
+   * the history action from the original navigation (PUSH or REPLACE).
+   */
+  async function startRedirectNavigation(request, redirect, isNavigation, _temp2) {
+    let {
+      submission,
+      fetcherSubmission,
+      preventScrollReset,
+      replace
+    } = _temp2 === void 0 ? {} : _temp2;
+    if (redirect.response.headers.has("X-Remix-Revalidate")) {
+      isRevalidationRequired = true;
+    }
+    let location = redirect.response.headers.get("Location");
+    invariant(location, "Expected a Location header on the redirect Response");
+    location = normalizeRedirectLocation(location, new URL(request.url), basename, init.history);
+    let redirectLocation = createLocation(state.location, location, {
+      _isRedirect: true
+    });
+    if (isBrowser) {
+      let isDocumentReload = false;
+      if (redirect.response.headers.has("X-Remix-Reload-Document")) {
+        // Hard reload if the response contained X-Remix-Reload-Document
+        isDocumentReload = true;
+      } else if (ABSOLUTE_URL_REGEX.test(location)) {
+        const url = init.history.createURL(location);
+        isDocumentReload =
+        // Hard reload if it's an absolute URL to a new origin
+        url.origin !== routerWindow.location.origin ||
+        // Hard reload if it's an absolute URL that does not match our basename
+        stripBasename(url.pathname, basename) == null;
+      }
+      if (isDocumentReload) {
+        if (replace) {
+          routerWindow.location.replace(location);
+        } else {
+          routerWindow.location.assign(location);
+        }
+        return;
+      }
+    }
+
+    // There's no need to abort on redirects, since we don't detect the
+    // redirect until the action/loaders have settled
+    pendingNavigationController = null;
+    let redirectHistoryAction = replace === true || redirect.response.headers.has("X-Remix-Replace") ? Action.Replace : Action.Push;
+
+    // Use the incoming submission if provided, fallback on the active one in
+    // state.navigation
+    let {
+      formMethod,
+      formAction,
+      formEncType
+    } = state.navigation;
+    if (!submission && !fetcherSubmission && formMethod && formAction && formEncType) {
+      submission = getSubmissionFromNavigation(state.navigation);
+    }
+
+    // If this was a 307/308 submission we want to preserve the HTTP method and
+    // re-submit the GET/POST/PUT/PATCH/DELETE as a submission navigation to the
+    // redirected location
+    let activeSubmission = submission || fetcherSubmission;
+    if (redirectPreserveMethodStatusCodes.has(redirect.response.status) && activeSubmission && isMutationMethod(activeSubmission.formMethod)) {
+      await startNavigation(redirectHistoryAction, redirectLocation, {
+        submission: _extends({}, activeSubmission, {
+          formAction: location
+        }),
+        // Preserve these flags across redirects
+        preventScrollReset: preventScrollReset || pendingPreventScrollReset,
+        enableViewTransition: isNavigation ? pendingViewTransitionEnabled : undefined
+      });
+    } else {
+      // If we have a navigation submission, we will preserve it through the
+      // redirect navigation
+      let overrideNavigation = getLoadingNavigation(redirectLocation, submission);
+      await startNavigation(redirectHistoryAction, redirectLocation, {
+        overrideNavigation,
+        // Send fetcher submissions through for shouldRevalidate
+        fetcherSubmission,
+        // Preserve these flags across redirects
+        preventScrollReset: preventScrollReset || pendingPreventScrollReset,
+        enableViewTransition: isNavigation ? pendingViewTransitionEnabled : undefined
+      });
+    }
+  }
+
+  // Utility wrapper for calling dataStrategy client-side without having to
+  // pass around the manifest, mapRouteProperties, etc.
+  async function callDataStrategy(type, state, request, matchesToLoad, matches, fetcherKey) {
+    let results;
+    let dataResults = {};
+    try {
+      results = await callDataStrategyImpl(dataStrategyImpl, type, state, request, matchesToLoad, matches, fetcherKey, manifest, mapRouteProperties);
+    } catch (e) {
+      // If the outer dataStrategy method throws, just return the error for all
+      // matches - and it'll naturally bubble to the root
+      matchesToLoad.forEach(m => {
+        dataResults[m.route.id] = {
+          type: ResultType.error,
+          error: e
+        };
+      });
+      return dataResults;
+    }
+    for (let [routeId, result] of Object.entries(results)) {
+      if (isRedirectDataStrategyResultResult(result)) {
+        let response = result.result;
+        dataResults[routeId] = {
+          type: ResultType.redirect,
+          response: normalizeRelativeRoutingRedirectResponse(response, request, routeId, matches, basename, future.v7_relativeSplatPath)
+        };
+      } else {
+        dataResults[routeId] = await convertDataStrategyResultToDataResult(result);
+      }
+    }
+    return dataResults;
+  }
+  async function callLoadersAndMaybeResolveData(state, matches, matchesToLoad, fetchersToLoad, request) {
+    let currentMatches = state.matches;
+
+    // Kick off loaders and fetchers in parallel
+    let loaderResultsPromise = callDataStrategy("loader", state, request, matchesToLoad, matches, null);
+    let fetcherResultsPromise = Promise.all(fetchersToLoad.map(async f => {
+      if (f.matches && f.match && f.controller) {
+        let results = await callDataStrategy("loader", state, createClientSideRequest(init.history, f.path, f.controller.signal), [f.match], f.matches, f.key);
+        let result = results[f.match.route.id];
+        // Fetcher results are keyed by fetcher key from here on out, not routeId
+        return {
+          [f.key]: result
+        };
+      } else {
+        return Promise.resolve({
+          [f.key]: {
+            type: ResultType.error,
+            error: getInternalRouterError(404, {
+              pathname: f.path
+            })
+          }
+        });
+      }
+    }));
+    let loaderResults = await loaderResultsPromise;
+    let fetcherResults = (await fetcherResultsPromise).reduce((acc, r) => Object.assign(acc, r), {});
+    await Promise.all([resolveNavigationDeferredResults(matches, loaderResults, request.signal, currentMatches, state.loaderData), resolveFetcherDeferredResults(matches, fetcherResults, fetchersToLoad)]);
+    return {
+      loaderResults,
+      fetcherResults
+    };
+  }
+  function interruptActiveLoads() {
+    // Every interruption triggers a revalidation
+    isRevalidationRequired = true;
+
+    // Cancel pending route-level deferreds and mark cancelled routes for
+    // revalidation
+    cancelledDeferredRoutes.push(...cancelActiveDeferreds());
+
+    // Abort in-flight fetcher loads
+    fetchLoadMatches.forEach((_, key) => {
+      if (fetchControllers.has(key)) {
+        cancelledFetcherLoads.add(key);
+      }
+      abortFetcher(key);
+    });
+  }
+  function updateFetcherState(key, fetcher, opts) {
+    if (opts === void 0) {
+      opts = {};
+    }
+    state.fetchers.set(key, fetcher);
+    updateState({
+      fetchers: new Map(state.fetchers)
+    }, {
+      flushSync: (opts && opts.flushSync) === true
+    });
+  }
+  function setFetcherError(key, routeId, error, opts) {
+    if (opts === void 0) {
+      opts = {};
+    }
+    let boundaryMatch = findNearestBoundary(state.matches, routeId);
+    deleteFetcher(key);
+    updateState({
+      errors: {
+        [boundaryMatch.route.id]: error
+      },
+      fetchers: new Map(state.fetchers)
+    }, {
+      flushSync: (opts && opts.flushSync) === true
+    });
+  }
+  function getFetcher(key) {
+    activeFetchers.set(key, (activeFetchers.get(key) || 0) + 1);
+    // If this fetcher was previously marked for deletion, unmark it since we
+    // have a new instance
+    if (deletedFetchers.has(key)) {
+      deletedFetchers.delete(key);
+    }
+    return state.fetchers.get(key) || IDLE_FETCHER;
+  }
+  function deleteFetcher(key) {
+    let fetcher = state.fetchers.get(key);
+    // Don't abort the controller if this is a deletion of a fetcher.submit()
+    // in it's loading phase since - we don't want to abort the corresponding
+    // revalidation and want them to complete and land
+    if (fetchControllers.has(key) && !(fetcher && fetcher.state === "loading" && fetchReloadIds.has(key))) {
+      abortFetcher(key);
+    }
+    fetchLoadMatches.delete(key);
+    fetchReloadIds.delete(key);
+    fetchRedirectIds.delete(key);
+
+    // If we opted into the flag we can clear this now since we're calling
+    // deleteFetcher() at the end of updateState() and we've already handed the
+    // deleted fetcher keys off to the data layer.
+    // If not, we're eagerly calling deleteFetcher() and we need to keep this
+    // Set populated until the next updateState call, and we'll clear
+    // `deletedFetchers` then
+    if (future.v7_fetcherPersist) {
+      deletedFetchers.delete(key);
+    }
+    cancelledFetcherLoads.delete(key);
+    state.fetchers.delete(key);
+  }
+  function deleteFetcherAndUpdateState(key) {
+    let count = (activeFetchers.get(key) || 0) - 1;
+    if (count <= 0) {
+      activeFetchers.delete(key);
+      deletedFetchers.add(key);
+      if (!future.v7_fetcherPersist) {
+        deleteFetcher(key);
+      }
+    } else {
+      activeFetchers.set(key, count);
+    }
+    updateState({
+      fetchers: new Map(state.fetchers)
+    });
+  }
+  function abortFetcher(key) {
+    let controller = fetchControllers.get(key);
+    if (controller) {
+      controller.abort();
+      fetchControllers.delete(key);
+    }
+  }
+  function markFetchersDone(keys) {
+    for (let key of keys) {
+      let fetcher = getFetcher(key);
+      let doneFetcher = getDoneFetcher(fetcher.data);
+      state.fetchers.set(key, doneFetcher);
+    }
+  }
+  function markFetchRedirectsDone() {
+    let doneKeys = [];
+    let updatedFetchers = false;
+    for (let key of fetchRedirectIds) {
+      let fetcher = state.fetchers.get(key);
+      invariant(fetcher, "Expected fetcher: " + key);
+      if (fetcher.state === "loading") {
+        fetchRedirectIds.delete(key);
+        doneKeys.push(key);
+        updatedFetchers = true;
+      }
+    }
+    markFetchersDone(doneKeys);
+    return updatedFetchers;
+  }
+  function abortStaleFetchLoads(landedId) {
+    let yeetedKeys = [];
+    for (let [key, id] of fetchReloadIds) {
+      if (id < landedId) {
+        let fetcher = state.fetchers.get(key);
+        invariant(fetcher, "Expected fetcher: " + key);
+        if (fetcher.state === "loading") {
+          abortFetcher(key);
+          fetchReloadIds.delete(key);
+          yeetedKeys.push(key);
+        }
+      }
+    }
+    markFetchersDone(yeetedKeys);
+    return yeetedKeys.length > 0;
+  }
+  function getBlocker(key, fn) {
+    let blocker = state.blockers.get(key) || IDLE_BLOCKER;
+    if (blockerFunctions.get(key) !== fn) {
+      blockerFunctions.set(key, fn);
+    }
+    return blocker;
+  }
+  function deleteBlocker(key) {
+    state.blockers.delete(key);
+    blockerFunctions.delete(key);
+  }
+
+  // Utility function to update blockers, ensuring valid state transitions
+  function updateBlocker(key, newBlocker) {
+    let blocker = state.blockers.get(key) || IDLE_BLOCKER;
+
+    // Poor mans state machine :)
+    // https://mermaid.live/edit#pako:eNqVkc9OwzAMxl8l8nnjAYrEtDIOHEBIgwvKJTReGy3_lDpIqO27k6awMG0XcrLlnz87nwdonESogKXXBuE79rq75XZO3-yHds0RJVuv70YrPlUrCEe2HfrORS3rubqZfuhtpg5C9wk5tZ4VKcRUq88q9Z8RS0-48cE1iHJkL0ugbHuFLus9L6spZy8nX9MP2CNdomVaposqu3fGayT8T8-jJQwhepo_UtpgBQaDEUom04dZhAN1aJBDlUKJBxE1ceB2Smj0Mln-IBW5AFU2dwUiktt_2Qaq2dBfaKdEup85UV7Yd-dKjlnkabl2Pvr0DTkTreM
+    invariant(blocker.state === "unblocked" && newBlocker.state === "blocked" || blocker.state === "blocked" && newBlocker.state === "blocked" || blocker.state === "blocked" && newBlocker.state === "proceeding" || blocker.state === "blocked" && newBlocker.state === "unblocked" || blocker.state === "proceeding" && newBlocker.state === "unblocked", "Invalid blocker state transition: " + blocker.state + " -> " + newBlocker.state);
+    let blockers = new Map(state.blockers);
+    blockers.set(key, newBlocker);
+    updateState({
+      blockers
+    });
+  }
+  function shouldBlockNavigation(_ref2) {
+    let {
+      currentLocation,
+      nextLocation,
+      historyAction
+    } = _ref2;
+    if (blockerFunctions.size === 0) {
+      return;
+    }
+
+    // We ony support a single active blocker at the moment since we don't have
+    // any compelling use cases for multi-blocker yet
+    if (blockerFunctions.size > 1) {
+      warning(false, "A router only supports one blocker at a time");
+    }
+    let entries = Array.from(blockerFunctions.entries());
+    let [blockerKey, blockerFunction] = entries[entries.length - 1];
+    let blocker = state.blockers.get(blockerKey);
+    if (blocker && blocker.state === "proceeding") {
+      // If the blocker is currently proceeding, we don't need to re-check
+      // it and can let this navigation continue
+      return;
+    }
+
+    // At this point, we know we're unblocked/blocked so we need to check the
+    // user-provided blocker function
+    if (blockerFunction({
+      currentLocation,
+      nextLocation,
+      historyAction
+    })) {
+      return blockerKey;
+    }
+  }
+  function handleNavigational404(pathname) {
+    let error = getInternalRouterError(404, {
+      pathname
+    });
+    let routesToUse = inFlightDataRoutes || dataRoutes;
+    let {
+      matches,
+      route
+    } = getShortCircuitMatches(routesToUse);
+
+    // Cancel all pending deferred on 404s since we don't keep any routes
+    cancelActiveDeferreds();
+    return {
+      notFoundMatches: matches,
+      route,
+      error
+    };
+  }
+  function cancelActiveDeferreds(predicate) {
+    let cancelledRouteIds = [];
+    activeDeferreds.forEach((dfd, routeId) => {
+      if (!predicate || predicate(routeId)) {
+        // Cancel the deferred - but do not remove from activeDeferreds here -
+        // we rely on the subscribers to do that so our tests can assert proper
+        // cleanup via _internalActiveDeferreds
+        dfd.cancel();
+        cancelledRouteIds.push(routeId);
+        activeDeferreds.delete(routeId);
+      }
+    });
+    return cancelledRouteIds;
+  }
+
+  // Opt in to capturing and reporting scroll positions during navigations,
+  // used by the <ScrollRestoration> component
+  function enableScrollRestoration(positions, getPosition, getKey) {
+    savedScrollPositions = positions;
+    getScrollPosition = getPosition;
+    getScrollRestorationKey = getKey || null;
+
+    // Perform initial hydration scroll restoration, since we miss the boat on
+    // the initial updateState() because we've not yet rendered <ScrollRestoration/>
+    // and therefore have no savedScrollPositions available
+    if (!initialScrollRestored && state.navigation === IDLE_NAVIGATION) {
+      initialScrollRestored = true;
+      let y = getSavedScrollPosition(state.location, state.matches);
+      if (y != null) {
+        updateState({
+          restoreScrollPosition: y
+        });
+      }
+    }
+    return () => {
+      savedScrollPositions = null;
+      getScrollPosition = null;
+      getScrollRestorationKey = null;
+    };
+  }
+  function getScrollKey(location, matches) {
+    if (getScrollRestorationKey) {
+      let key = getScrollRestorationKey(location, matches.map(m => convertRouteMatchToUiMatch(m, state.loaderData)));
+      return key || location.key;
+    }
+    return location.key;
+  }
+  function saveScrollPosition(location, matches) {
+    if (savedScrollPositions && getScrollPosition) {
+      let key = getScrollKey(location, matches);
+      savedScrollPositions[key] = getScrollPosition();
+    }
+  }
+  function getSavedScrollPosition(location, matches) {
+    if (savedScrollPositions) {
+      let key = getScrollKey(location, matches);
+      let y = savedScrollPositions[key];
+      if (typeof y === "number") {
+        return y;
+      }
+    }
+    return null;
+  }
+  function checkFogOfWar(matches, routesToUse, pathname) {
+    if (patchRoutesOnNavigationImpl) {
+      if (!matches) {
+        let fogMatches = matchRoutesImpl(routesToUse, pathname, basename, true);
+        return {
+          active: true,
+          matches: fogMatches || []
+        };
+      } else {
+        if (Object.keys(matches[0].params).length > 0) {
+          // If we matched a dynamic param or a splat, it might only be because
+          // we haven't yet discovered other routes that would match with a
+          // higher score.  Call patchRoutesOnNavigation just to be sure
+          let partialMatches = matchRoutesImpl(routesToUse, pathname, basename, true);
+          return {
+            active: true,
+            matches: partialMatches
+          };
+        }
+      }
+    }
+    return {
+      active: false,
+      matches: null
+    };
+  }
+  async function discoverRoutes(matches, pathname, signal, fetcherKey) {
+    if (!patchRoutesOnNavigationImpl) {
+      return {
+        type: "success",
+        matches
+      };
+    }
+    let partialMatches = matches;
+    while (true) {
+      let isNonHMR = inFlightDataRoutes == null;
+      let routesToUse = inFlightDataRoutes || dataRoutes;
+      let localManifest = manifest;
+      try {
+        await patchRoutesOnNavigationImpl({
+          signal,
+          path: pathname,
+          matches: partialMatches,
+          fetcherKey,
+          patch: (routeId, children) => {
+            if (signal.aborted) return;
+            patchRoutesImpl(routeId, children, routesToUse, localManifest, mapRouteProperties);
+          }
+        });
+      } catch (e) {
+        return {
+          type: "error",
+          error: e,
+          partialMatches
+        };
+      } finally {
+        // If we are not in the middle of an HMR revalidation and we changed the
+        // routes, provide a new identity so when we `updateState` at the end of
+        // this navigation/fetch `router.routes` will be a new identity and
+        // trigger a re-run of memoized `router.routes` dependencies.
+        // HMR will already update the identity and reflow when it lands
+        // `inFlightDataRoutes` in `completeNavigation`
+        if (isNonHMR && !signal.aborted) {
+          dataRoutes = [...dataRoutes];
+        }
+      }
+      if (signal.aborted) {
+        return {
+          type: "aborted"
+        };
+      }
+      let newMatches = matchRoutes(routesToUse, pathname, basename);
+      if (newMatches) {
+        return {
+          type: "success",
+          matches: newMatches
+        };
+      }
+      let newPartialMatches = matchRoutesImpl(routesToUse, pathname, basename, true);
+
+      // Avoid loops if the second pass results in the same partial matches
+      if (!newPartialMatches || partialMatches.length === newPartialMatches.length && partialMatches.every((m, i) => m.route.id === newPartialMatches[i].route.id)) {
+        return {
+          type: "success",
+          matches: null
+        };
+      }
+      partialMatches = newPartialMatches;
+    }
+  }
+  function _internalSetRoutes(newRoutes) {
+    manifest = {};
+    inFlightDataRoutes = convertRoutesToDataRoutes(newRoutes, mapRouteProperties, undefined, manifest);
+  }
+  function patchRoutes(routeId, children) {
+    let isNonHMR = inFlightDataRoutes == null;
+    let routesToUse = inFlightDataRoutes || dataRoutes;
+    patchRoutesImpl(routeId, children, routesToUse, manifest, mapRouteProperties);
+
+    // If we are not in the middle of an HMR revalidation and we changed the
+    // routes, provide a new identity and trigger a reflow via `updateState`
+    // to re-run memoized `router.routes` dependencies.
+    // HMR will already update the identity and reflow when it lands
+    // `inFlightDataRoutes` in `completeNavigation`
+    if (isNonHMR) {
+      dataRoutes = [...dataRoutes];
+      updateState({});
+    }
+  }
+  router = {
+    get basename() {
+      return basename;
+    },
+    get future() {
+      return future;
+    },
+    get state() {
+      return state;
+    },
+    get routes() {
+      return dataRoutes;
+    },
+    get window() {
+      return routerWindow;
+    },
+    initialize,
+    subscribe,
+    enableScrollRestoration,
+    navigate,
+    fetch,
+    revalidate,
+    // Passthrough to history-aware createHref used by useHref so we get proper
+    // hash-aware URLs in DOM paths
+    createHref: to => init.history.createHref(to),
+    encodeLocation: to => init.history.encodeLocation(to),
+    getFetcher,
+    deleteFetcher: deleteFetcherAndUpdateState,
+    dispose,
+    getBlocker,
+    deleteBlocker,
+    patchRoutes,
+    _internalFetchControllers: fetchControllers,
+    _internalActiveDeferreds: activeDeferreds,
+    // TODO: Remove setRoutes, it's temporary to avoid dealing with
+    // updating the tree while validating the update algorithm.
+    _internalSetRoutes
+  };
+  return router;
+}
+//#endregion
+
+////////////////////////////////////////////////////////////////////////////////
+//#region createStaticHandler
+////////////////////////////////////////////////////////////////////////////////
+
+const UNSAFE_DEFERRED_SYMBOL = Symbol("deferred");
+
+/**
+ * Future flags to toggle new feature behavior
+ */
+
+function createStaticHandler(routes, opts) {
+  invariant(routes.length > 0, "You must provide a non-empty routes array to createStaticHandler");
+  let manifest = {};
+  let basename = (opts ? opts.basename : null) || "/";
+  let mapRouteProperties;
+  if (opts != null && opts.mapRouteProperties) {
+    mapRouteProperties = opts.mapRouteProperties;
+  } else if (opts != null && opts.detectErrorBoundary) {
+    // If they are still using the deprecated version, wrap it with the new API
+    let detectErrorBoundary = opts.detectErrorBoundary;
+    mapRouteProperties = route => ({
+      hasErrorBoundary: detectErrorBoundary(route)
+    });
+  } else {
+    mapRouteProperties = defaultMapRouteProperties;
+  }
+  // Config driven behavior flags
+  let future = _extends({
+    v7_relativeSplatPath: false,
+    v7_throwAbortReason: false
+  }, opts ? opts.future : null);
+  let dataRoutes = convertRoutesToDataRoutes(routes, mapRouteProperties, undefined, manifest);
+
+  /**
+   * The query() method is intended for document requests, in which we want to
+   * call an optional action and potentially multiple loaders for all nested
+   * routes.  It returns a StaticHandlerContext object, which is very similar
+   * to the router state (location, loaderData, actionData, errors, etc.) and
+   * also adds SSR-specific information such as the statusCode and headers
+   * from action/loaders Responses.
+   *
+   * It _should_ never throw and should report all errors through the
+   * returned context.errors object, properly associating errors to their error
+   * boundary.  Additionally, it tracks _deepestRenderedBoundaryId which can be
+   * used to emulate React error boundaries during SSr by performing a second
+   * pass only down to the boundaryId.
+   *
+   * The one exception where we do not return a StaticHandlerContext is when a
+   * redirect response is returned or thrown from any action/loader.  We
+   * propagate that out and return the raw Response so the HTTP server can
+   * return it directly.
+   *
+   * - `opts.requestContext` is an optional server context that will be passed
+   *   to actions/loaders in the `context` parameter
+   * - `opts.skipLoaderErrorBubbling` is an optional parameter that will prevent
+   *   the bubbling of errors which allows single-fetch-type implementations
+   *   where the client will handle the bubbling and we may need to return data
+   *   for the handling route
+   */
+  async function query(request, _temp3) {
+    let {
+      requestContext,
+      skipLoaderErrorBubbling,
+      dataStrategy
+    } = _temp3 === void 0 ? {} : _temp3;
+    let url = new URL(request.url);
+    let method = request.method;
+    let location = createLocation("", createPath(url), null, "default");
+    let matches = matchRoutes(dataRoutes, location, basename);
+
+    // SSR supports HEAD requests while SPA doesn't
+    if (!isValidMethod(method) && method !== "HEAD") {
+      let error = getInternalRouterError(405, {
+        method
+      });
+      let {
+        matches: methodNotAllowedMatches,
+        route
+      } = getShortCircuitMatches(dataRoutes);
+      return {
+        basename,
+        location,
+        matches: methodNotAllowedMatches,
+        loaderData: {},
+        actionData: null,
+        errors: {
+          [route.id]: error
+        },
+        statusCode: error.status,
+        loaderHeaders: {},
+        actionHeaders: {},
+        activeDeferreds: null
+      };
+    } else if (!matches) {
+      let error = getInternalRouterError(404, {
+        pathname: location.pathname
+      });
+      let {
+        matches: notFoundMatches,
+        route
+      } = getShortCircuitMatches(dataRoutes);
+      return {
+        basename,
+        location,
+        matches: notFoundMatches,
+        loaderData: {},
+        actionData: null,
+        errors: {
+          [route.id]: error
+        },
+        statusCode: error.status,
+        loaderHeaders: {},
+        actionHeaders: {},
+        activeDeferreds: null
+      };
+    }
+    let result = await queryImpl(request, location, matches, requestContext, dataStrategy || null, skipLoaderErrorBubbling === true, null);
+    if (isResponse(result)) {
+      return result;
+    }
+
+    // When returning StaticHandlerContext, we patch back in the location here
+    // since we need it for React Context.  But this helps keep our submit and
+    // loadRouteData operating on a Request instead of a Location
+    return _extends({
+      location,
+      basename
+    }, result);
+  }
+
+  /**
+   * The queryRoute() method is intended for targeted route requests, either
+   * for fetch ?_data requests or resource route requests.  In this case, we
+   * are only ever calling a single action or loader, and we are returning the
+   * returned value directly.  In most cases, this will be a Response returned
+   * from the action/loader, but it may be a primitive or other value as well -
+   * and in such cases the calling context should handle that accordingly.
+   *
+   * We do respect the throw/return differentiation, so if an action/loader
+   * throws, then this method will throw the value.  This is important so we
+   * can do proper boundary identification in Remix where a thrown Response
+   * must go to the Catch Boundary but a returned Response is happy-path.
+   *
+   * One thing to note is that any Router-initiated Errors that make sense
+   * to associate with a status code will be thrown as an ErrorResponse
+   * instance which include the raw Error, such that the calling context can
+   * serialize the error as they see fit while including the proper response
+   * code.  Examples here are 404 and 405 errors that occur prior to reaching
+   * any user-defined loaders.
+   *
+   * - `opts.routeId` allows you to specify the specific route handler to call.
+   *   If not provided the handler will determine the proper route by matching
+   *   against `request.url`
+   * - `opts.requestContext` is an optional server context that will be passed
+   *    to actions/loaders in the `context` parameter
+   */
+  async function queryRoute(request, _temp4) {
+    let {
+      routeId,
+      requestContext,
+      dataStrategy
+    } = _temp4 === void 0 ? {} : _temp4;
+    let url = new URL(request.url);
+    let method = request.method;
+    let location = createLocation("", createPath(url), null, "default");
+    let matches = matchRoutes(dataRoutes, location, basename);
+
+    // SSR supports HEAD requests while SPA doesn't
+    if (!isValidMethod(method) && method !== "HEAD" && method !== "OPTIONS") {
+      throw getInternalRouterError(405, {
+        method
+      });
+    } else if (!matches) {
+      throw getInternalRouterError(404, {
+        pathname: location.pathname
+      });
+    }
+    let match = routeId ? matches.find(m => m.route.id === routeId) : getTargetMatch(matches, location);
+    if (routeId && !match) {
+      throw getInternalRouterError(403, {
+        pathname: location.pathname,
+        routeId
+      });
+    } else if (!match) {
+      // This should never hit I don't think?
+      throw getInternalRouterError(404, {
+        pathname: location.pathname
+      });
+    }
+    let result = await queryImpl(request, location, matches, requestContext, dataStrategy || null, false, match);
+    if (isResponse(result)) {
+      return result;
+    }
+    let error = result.errors ? Object.values(result.errors)[0] : undefined;
+    if (error !== undefined) {
+      // If we got back result.errors, that means the loader/action threw
+      // _something_ that wasn't a Response, but it's not guaranteed/required
+      // to be an `instanceof Error` either, so we have to use throw here to
+      // preserve the "error" state outside of queryImpl.
+      throw error;
+    }
+
+    // Pick off the right state value to return
+    if (result.actionData) {
+      return Object.values(result.actionData)[0];
+    }
+    if (result.loaderData) {
+      var _result$activeDeferre;
+      let data = Object.values(result.loaderData)[0];
+      if ((_result$activeDeferre = result.activeDeferreds) != null && _result$activeDeferre[match.route.id]) {
+        data[UNSAFE_DEFERRED_SYMBOL] = result.activeDeferreds[match.route.id];
+      }
+      return data;
+    }
+    return undefined;
+  }
+  async function queryImpl(request, location, matches, requestContext, dataStrategy, skipLoaderErrorBubbling, routeMatch) {
+    invariant(request.signal, "query()/queryRoute() requests must contain an AbortController signal");
+    try {
+      if (isMutationMethod(request.method.toLowerCase())) {
+        let result = await submit(request, matches, routeMatch || getTargetMatch(matches, location), requestContext, dataStrategy, skipLoaderErrorBubbling, routeMatch != null);
+        return result;
+      }
+      let result = await loadRouteData(request, matches, requestContext, dataStrategy, skipLoaderErrorBubbling, routeMatch);
+      return isResponse(result) ? result : _extends({}, result, {
+        actionData: null,
+        actionHeaders: {}
+      });
+    } catch (e) {
+      // If the user threw/returned a Response in callLoaderOrAction for a
+      // `queryRoute` call, we throw the `DataStrategyResult` to bail out early
+      // and then return or throw the raw Response here accordingly
+      if (isDataStrategyResult(e) && isResponse(e.result)) {
+        if (e.type === ResultType.error) {
+          throw e.result;
+        }
+        return e.result;
+      }
+      // Redirects are always returned since they don't propagate to catch
+      // boundaries
+      if (isRedirectResponse(e)) {
+        return e;
+      }
+      throw e;
+    }
+  }
+  async function submit(request, matches, actionMatch, requestContext, dataStrategy, skipLoaderErrorBubbling, isRouteRequest) {
+    let result;
+    if (!actionMatch.route.action && !actionMatch.route.lazy) {
+      let error = getInternalRouterError(405, {
+        method: request.method,
+        pathname: new URL(request.url).pathname,
+        routeId: actionMatch.route.id
+      });
+      if (isRouteRequest) {
+        throw error;
+      }
+      result = {
+        type: ResultType.error,
+        error
+      };
+    } else {
+      let results = await callDataStrategy("action", request, [actionMatch], matches, isRouteRequest, requestContext, dataStrategy);
+      result = results[actionMatch.route.id];
+      if (request.signal.aborted) {
+        throwStaticHandlerAbortedError(request, isRouteRequest, future);
+      }
+    }
+    if (isRedirectResult(result)) {
+      // Uhhhh - this should never happen, we should always throw these from
+      // callLoaderOrAction, but the type narrowing here keeps TS happy and we
+      // can get back on the "throw all redirect responses" train here should
+      // this ever happen :/
+      throw new Response(null, {
+        status: result.response.status,
+        headers: {
+          Location: result.response.headers.get("Location")
+        }
+      });
+    }
+    if (isDeferredResult(result)) {
+      let error = getInternalRouterError(400, {
+        type: "defer-action"
+      });
+      if (isRouteRequest) {
+        throw error;
+      }
+      result = {
+        type: ResultType.error,
+        error
+      };
+    }
+    if (isRouteRequest) {
+      // Note: This should only be non-Response values if we get here, since
+      // isRouteRequest should throw any Response received in callLoaderOrAction
+      if (isErrorResult(result)) {
+        throw result.error;
+      }
+      return {
+        matches: [actionMatch],
+        loaderData: {},
+        actionData: {
+          [actionMatch.route.id]: result.data
+        },
+        errors: null,
+        // Note: statusCode + headers are unused here since queryRoute will
+        // return the raw Response or value
+        statusCode: 200,
+        loaderHeaders: {},
+        actionHeaders: {},
+        activeDeferreds: null
+      };
+    }
+
+    // Create a GET request for the loaders
+    let loaderRequest = new Request(request.url, {
+      headers: request.headers,
+      redirect: request.redirect,
+      signal: request.signal
+    });
+    if (isErrorResult(result)) {
+      // Store off the pending error - we use it to determine which loaders
+      // to call and will commit it when we complete the navigation
+      let boundaryMatch = skipLoaderErrorBubbling ? actionMatch : findNearestBoundary(matches, actionMatch.route.id);
+      let context = await loadRouteData(loaderRequest, matches, requestContext, dataStrategy, skipLoaderErrorBubbling, null, [boundaryMatch.route.id, result]);
+
+      // action status codes take precedence over loader status codes
+      return _extends({}, context, {
+        statusCode: isRouteErrorResponse(result.error) ? result.error.status : result.statusCode != null ? result.statusCode : 500,
+        actionData: null,
+        actionHeaders: _extends({}, result.headers ? {
+          [actionMatch.route.id]: result.headers
+        } : {})
+      });
+    }
+    let context = await loadRouteData(loaderRequest, matches, requestContext, dataStrategy, skipLoaderErrorBubbling, null);
+    return _extends({}, context, {
+      actionData: {
+        [actionMatch.route.id]: result.data
+      }
+    }, result.statusCode ? {
+      statusCode: result.statusCode
+    } : {}, {
+      actionHeaders: result.headers ? {
+        [actionMatch.route.id]: result.headers
+      } : {}
+    });
+  }
+  async function loadRouteData(request, matches, requestContext, dataStrategy, skipLoaderErrorBubbling, routeMatch, pendingActionResult) {
+    let isRouteRequest = routeMatch != null;
+
+    // Short circuit if we have no loaders to run (queryRoute())
+    if (isRouteRequest && !(routeMatch != null && routeMatch.route.loader) && !(routeMatch != null && routeMatch.route.lazy)) {
+      throw getInternalRouterError(400, {
+        method: request.method,
+        pathname: new URL(request.url).pathname,
+        routeId: routeMatch == null ? void 0 : routeMatch.route.id
+      });
+    }
+    let requestMatches = routeMatch ? [routeMatch] : pendingActionResult && isErrorResult(pendingActionResult[1]) ? getLoaderMatchesUntilBoundary(matches, pendingActionResult[0]) : matches;
+    let matchesToLoad = requestMatches.filter(m => m.route.loader || m.route.lazy);
+
+    // Short circuit if we have no loaders to run (query())
+    if (matchesToLoad.length === 0) {
+      return {
+        matches,
+        // Add a null for all matched routes for proper revalidation on the client
+        loaderData: matches.reduce((acc, m) => Object.assign(acc, {
+          [m.route.id]: null
+        }), {}),
+        errors: pendingActionResult && isErrorResult(pendingActionResult[1]) ? {
+          [pendingActionResult[0]]: pendingActionResult[1].error
+        } : null,
+        statusCode: 200,
+        loaderHeaders: {},
+        activeDeferreds: null
+      };
+    }
+    let results = await callDataStrategy("loader", request, matchesToLoad, matches, isRouteRequest, requestContext, dataStrategy);
+    if (request.signal.aborted) {
+      throwStaticHandlerAbortedError(request, isRouteRequest, future);
+    }
+
+    // Process and commit output from loaders
+    let activeDeferreds = new Map();
+    let context = processRouteLoaderData(matches, results, pendingActionResult, activeDeferreds, skipLoaderErrorBubbling);
+
+    // Add a null for any non-loader matches for proper revalidation on the client
+    let executedLoaders = new Set(matchesToLoad.map(match => match.route.id));
+    matches.forEach(match => {
+      if (!executedLoaders.has(match.route.id)) {
+        context.loaderData[match.route.id] = null;
+      }
+    });
+    return _extends({}, context, {
+      matches,
+      activeDeferreds: activeDeferreds.size > 0 ? Object.fromEntries(activeDeferreds.entries()) : null
+    });
+  }
+
+  // Utility wrapper for calling dataStrategy server-side without having to
+  // pass around the manifest, mapRouteProperties, etc.
+  async function callDataStrategy(type, request, matchesToLoad, matches, isRouteRequest, requestContext, dataStrategy) {
+    let results = await callDataStrategyImpl(dataStrategy || defaultDataStrategy, type, null, request, matchesToLoad, matches, null, manifest, mapRouteProperties, requestContext);
+    let dataResults = {};
+    await Promise.all(matches.map(async match => {
+      if (!(match.route.id in results)) {
+        return;
+      }
+      let result = results[match.route.id];
+      if (isRedirectDataStrategyResultResult(result)) {
+        let response = result.result;
+        // Throw redirects and let the server handle them with an HTTP redirect
+        throw normalizeRelativeRoutingRedirectResponse(response, request, match.route.id, matches, basename, future.v7_relativeSplatPath);
+      }
+      if (isResponse(result.result) && isRouteRequest) {
+        // For SSR single-route requests, we want to hand Responses back
+        // directly without unwrapping
+        throw result;
+      }
+      dataResults[match.route.id] = await convertDataStrategyResultToDataResult(result);
+    }));
+    return dataResults;
+  }
+  return {
+    dataRoutes,
+    query,
+    queryRoute
+  };
+}
+
+//#endregion
+
+////////////////////////////////////////////////////////////////////////////////
+//#region Helpers
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Given an existing StaticHandlerContext and an error thrown at render time,
+ * provide an updated StaticHandlerContext suitable for a second SSR render
+ */
+function getStaticContextFromError(routes, context, error) {
+  let newContext = _extends({}, context, {
+    statusCode: isRouteErrorResponse(error) ? error.status : 500,
+    errors: {
+      [context._deepestRenderedBoundaryId || routes[0].id]: error
+    }
+  });
+  return newContext;
+}
+function throwStaticHandlerAbortedError(request, isRouteRequest, future) {
+  if (future.v7_throwAbortReason && request.signal.reason !== undefined) {
+    throw request.signal.reason;
+  }
+  let method = isRouteRequest ? "queryRoute" : "query";
+  throw new Error(method + "() call aborted: " + request.method + " " + request.url);
+}
+function isSubmissionNavigation(opts) {
+  return opts != null && ("formData" in opts && opts.formData != null || "body" in opts && opts.body !== undefined);
+}
+function normalizeTo(location, matches, basename, prependBasename, to, v7_relativeSplatPath, fromRouteId, relative) {
+  let contextualMatches;
+  let activeRouteMatch;
+  if (fromRouteId) {
+    // Grab matches up to the calling route so our route-relative logic is
+    // relative to the correct source route
+    contextualMatches = [];
+    for (let match of matches) {
+      contextualMatches.push(match);
+      if (match.route.id === fromRouteId) {
+        activeRouteMatch = match;
+        break;
+      }
+    }
+  } else {
+    contextualMatches = matches;
+    activeRouteMatch = matches[matches.length - 1];
+  }
+
+  // Resolve the relative path
+  let path = resolveTo(to ? to : ".", getResolveToMatches(contextualMatches, v7_relativeSplatPath), stripBasename(location.pathname, basename) || location.pathname, relative === "path");
+
+  // When `to` is not specified we inherit search/hash from the current
+  // location, unlike when to="." and we just inherit the path.
+  // See https://github.com/remix-run/remix/issues/927
+  if (to == null) {
+    path.search = location.search;
+    path.hash = location.hash;
+  }
+
+  // Account for `?index` params when routing to the current location
+  if ((to == null || to === "" || to === ".") && activeRouteMatch) {
+    let nakedIndex = hasNakedIndexQuery(path.search);
+    if (activeRouteMatch.route.index && !nakedIndex) {
+      // Add one when we're targeting an index route
+      path.search = path.search ? path.search.replace(/^\?/, "?index&") : "?index";
+    } else if (!activeRouteMatch.route.index && nakedIndex) {
+      // Remove existing ones when we're not
+      let params = new URLSearchParams(path.search);
+      let indexValues = params.getAll("index");
+      params.delete("index");
+      indexValues.filter(v => v).forEach(v => params.append("index", v));
+      let qs = params.toString();
+      path.search = qs ? "?" + qs : "";
+    }
+  }
+
+  // If we're operating within a basename, prepend it to the pathname.  If
+  // this is a root navigation, then just use the raw basename which allows
+  // the basename to have full control over the presence of a trailing slash
+  // on root actions
+  if (prependBasename && basename !== "/") {
+    path.pathname = path.pathname === "/" ? basename : joinPaths([basename, path.pathname]);
+  }
+  return createPath(path);
+}
+
+// Normalize navigation options by converting formMethod=GET formData objects to
+// URLSearchParams so they behave identically to links with query params
+function normalizeNavigateOptions(normalizeFormMethod, isFetcher, path, opts) {
+  // Return location verbatim on non-submission navigations
+  if (!opts || !isSubmissionNavigation(opts)) {
+    return {
+      path
+    };
+  }
+  if (opts.formMethod && !isValidMethod(opts.formMethod)) {
+    return {
+      path,
+      error: getInternalRouterError(405, {
+        method: opts.formMethod
+      })
+    };
+  }
+  let getInvalidBodyError = () => ({
+    path,
+    error: getInternalRouterError(400, {
+      type: "invalid-body"
+    })
+  });
+
+  // Create a Submission on non-GET navigations
+  let rawFormMethod = opts.formMethod || "get";
+  let formMethod = normalizeFormMethod ? rawFormMethod.toUpperCase() : rawFormMethod.toLowerCase();
+  let formAction = stripHashFromPath(path);
+  if (opts.body !== undefined) {
+    if (opts.formEncType === "text/plain") {
+      // text only support POST/PUT/PATCH/DELETE submissions
+      if (!isMutationMethod(formMethod)) {
+        return getInvalidBodyError();
+      }
+      let text = typeof opts.body === "string" ? opts.body : opts.body instanceof FormData || opts.body instanceof URLSearchParams ?
+      // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#plain-text-form-data
+      Array.from(opts.body.entries()).reduce((acc, _ref3) => {
+        let [name, value] = _ref3;
+        return "" + acc + name + "=" + value + "\n";
+      }, "") : String(opts.body);
+      return {
+        path,
+        submission: {
+          formMethod,
+          formAction,
+          formEncType: opts.formEncType,
+          formData: undefined,
+          json: undefined,
+          text
+        }
+      };
+    } else if (opts.formEncType === "application/json") {
+      // json only supports POST/PUT/PATCH/DELETE submissions
+      if (!isMutationMethod(formMethod)) {
+        return getInvalidBodyError();
+      }
+      try {
+        let json = typeof opts.body === "string" ? JSON.parse(opts.body) : opts.body;
+        return {
+          path,
+          submission: {
+            formMethod,
+            formAction,
+            formEncType: opts.formEncType,
+            formData: undefined,
+            json,
+            text: undefined
+          }
+        };
+      } catch (e) {
+        return getInvalidBodyError();
+      }
+    }
+  }
+  invariant(typeof FormData === "function", "FormData is not available in this environment");
+  let searchParams;
+  let formData;
+  if (opts.formData) {
+    searchParams = convertFormDataToSearchParams(opts.formData);
+    formData = opts.formData;
+  } else if (opts.body instanceof FormData) {
+    searchParams = convertFormDataToSearchParams(opts.body);
+    formData = opts.body;
+  } else if (opts.body instanceof URLSearchParams) {
+    searchParams = opts.body;
+    formData = convertSearchParamsToFormData(searchParams);
+  } else if (opts.body == null) {
+    searchParams = new URLSearchParams();
+    formData = new FormData();
+  } else {
+    try {
+      searchParams = new URLSearchParams(opts.body);
+      formData = convertSearchParamsToFormData(searchParams);
+    } catch (e) {
+      return getInvalidBodyError();
+    }
+  }
+  let submission = {
+    formMethod,
+    formAction,
+    formEncType: opts && opts.formEncType || "application/x-www-form-urlencoded",
+    formData,
+    json: undefined,
+    text: undefined
+  };
+  if (isMutationMethod(submission.formMethod)) {
+    return {
+      path,
+      submission
+    };
+  }
+
+  // Flatten submission onto URLSearchParams for GET submissions
+  let parsedPath = parsePath(path);
+  // On GET navigation submissions we can drop the ?index param from the
+  // resulting location since all loaders will run.  But fetcher GET submissions
+  // only run a single loader so we need to preserve any incoming ?index params
+  if (isFetcher && parsedPath.search && hasNakedIndexQuery(parsedPath.search)) {
+    searchParams.append("index", "");
+  }
+  parsedPath.search = "?" + searchParams;
+  return {
+    path: createPath(parsedPath),
+    submission
+  };
+}
+
+// Filter out all routes at/below any caught error as they aren't going to
+// render so we don't need to load them
+function getLoaderMatchesUntilBoundary(matches, boundaryId, includeBoundary) {
+  if (includeBoundary === void 0) {
+    includeBoundary = false;
+  }
+  let index = matches.findIndex(m => m.route.id === boundaryId);
+  if (index >= 0) {
+    return matches.slice(0, includeBoundary ? index + 1 : index);
+  }
+  return matches;
+}
+function getMatchesToLoad(history, state, matches, submission, location, initialHydration, skipActionErrorRevalidation, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, deletedFetchers, fetchLoadMatches, fetchRedirectIds, routesToUse, basename, pendingActionResult) {
+  let actionResult = pendingActionResult ? isErrorResult(pendingActionResult[1]) ? pendingActionResult[1].error : pendingActionResult[1].data : undefined;
+  let currentUrl = history.createURL(state.location);
+  let nextUrl = history.createURL(location);
+
+  // Pick navigation matches that are net-new or qualify for revalidation
+  let boundaryMatches = matches;
+  if (initialHydration && state.errors) {
+    // On initial hydration, only consider matches up to _and including_ the boundary.
+    // This is inclusive to handle cases where a server loader ran successfully,
+    // a child server loader bubbled up to this route, but this route has
+    // `clientLoader.hydrate` so we want to still run the `clientLoader` so that
+    // we have a complete version of `loaderData`
+    boundaryMatches = getLoaderMatchesUntilBoundary(matches, Object.keys(state.errors)[0], true);
+  } else if (pendingActionResult && isErrorResult(pendingActionResult[1])) {
+    // If an action threw an error, we call loaders up to, but not including the
+    // boundary
+    boundaryMatches = getLoaderMatchesUntilBoundary(matches, pendingActionResult[0]);
+  }
+
+  // Don't revalidate loaders by default after action 4xx/5xx responses
+  // when the flag is enabled.  They can still opt-into revalidation via
+  // `shouldRevalidate` via `actionResult`
+  let actionStatus = pendingActionResult ? pendingActionResult[1].statusCode : undefined;
+  let shouldSkipRevalidation = skipActionErrorRevalidation && actionStatus && actionStatus >= 400;
+  let navigationMatches = boundaryMatches.filter((match, index) => {
+    let {
+      route
+    } = match;
+    if (route.lazy) {
+      // We haven't loaded this route yet so we don't know if it's got a loader!
+      return true;
+    }
+    if (route.loader == null) {
+      return false;
+    }
+    if (initialHydration) {
+      return shouldLoadRouteOnHydration(route, state.loaderData, state.errors);
+    }
+
+    // Always call the loader on new route instances and pending defer cancellations
+    if (isNewLoader(state.loaderData, state.matches[index], match) || cancelledDeferredRoutes.some(id => id === match.route.id)) {
+      return true;
+    }
+
+    // This is the default implementation for when we revalidate.  If the route
+    // provides it's own implementation, then we give them full control but
+    // provide this value so they can leverage it if needed after they check
+    // their own specific use cases
+    let currentRouteMatch = state.matches[index];
+    let nextRouteMatch = match;
+    return shouldRevalidateLoader(match, _extends({
+      currentUrl,
+      currentParams: currentRouteMatch.params,
+      nextUrl,
+      nextParams: nextRouteMatch.params
+    }, submission, {
+      actionResult,
+      actionStatus,
+      defaultShouldRevalidate: shouldSkipRevalidation ? false :
+      // Forced revalidation due to submission, useRevalidator, or X-Remix-Revalidate
+      isRevalidationRequired || currentUrl.pathname + currentUrl.search === nextUrl.pathname + nextUrl.search ||
+      // Search params affect all loaders
+      currentUrl.search !== nextUrl.search || isNewRouteInstance(currentRouteMatch, nextRouteMatch)
+    }));
+  });
+
+  // Pick fetcher.loads that need to be revalidated
+  let revalidatingFetchers = [];
+  fetchLoadMatches.forEach((f, key) => {
+    // Don't revalidate:
+    //  - on initial hydration (shouldn't be any fetchers then anyway)
+    //  - if fetcher won't be present in the subsequent render
+    //    - no longer matches the URL (v7_fetcherPersist=false)
+    //    - was unmounted but persisted due to v7_fetcherPersist=true
+    if (initialHydration || !matches.some(m => m.route.id === f.routeId) || deletedFetchers.has(key)) {
+      return;
+    }
+    let fetcherMatches = matchRoutes(routesToUse, f.path, basename);
+
+    // If the fetcher path no longer matches, push it in with null matches so
+    // we can trigger a 404 in callLoadersAndMaybeResolveData.  Note this is
+    // currently only a use-case for Remix HMR where the route tree can change
+    // at runtime and remove a route previously loaded via a fetcher
+    if (!fetcherMatches) {
+      revalidatingFetchers.push({
+        key,
+        routeId: f.routeId,
+        path: f.path,
+        matches: null,
+        match: null,
+        controller: null
+      });
+      return;
+    }
+
+    // Revalidating fetchers are decoupled from the route matches since they
+    // load from a static href.  They revalidate based on explicit revalidation
+    // (submission, useRevalidator, or X-Remix-Revalidate)
+    let fetcher = state.fetchers.get(key);
+    let fetcherMatch = getTargetMatch(fetcherMatches, f.path);
+    let shouldRevalidate = false;
+    if (fetchRedirectIds.has(key)) {
+      // Never trigger a revalidation of an actively redirecting fetcher
+      shouldRevalidate = false;
+    } else if (cancelledFetcherLoads.has(key)) {
+      // Always mark for revalidation if the fetcher was cancelled
+      cancelledFetcherLoads.delete(key);
+      shouldRevalidate = true;
+    } else if (fetcher && fetcher.state !== "idle" && fetcher.data === undefined) {
+      // If the fetcher hasn't ever completed loading yet, then this isn't a
+      // revalidation, it would just be a brand new load if an explicit
+      // revalidation is required
+      shouldRevalidate = isRevalidationRequired;
+    } else {
+      // Otherwise fall back on any user-defined shouldRevalidate, defaulting
+      // to explicit revalidations only
+      shouldRevalidate = shouldRevalidateLoader(fetcherMatch, _extends({
+        currentUrl,
+        currentParams: state.matches[state.matches.length - 1].params,
+        nextUrl,
+        nextParams: matches[matches.length - 1].params
+      }, submission, {
+        actionResult,
+        actionStatus,
+        defaultShouldRevalidate: shouldSkipRevalidation ? false : isRevalidationRequired
+      }));
+    }
+    if (shouldRevalidate) {
+      revalidatingFetchers.push({
+        key,
+        routeId: f.routeId,
+        path: f.path,
+        matches: fetcherMatches,
+        match: fetcherMatch,
+        controller: new AbortController()
+      });
+    }
+  });
+  return [navigationMatches, revalidatingFetchers];
+}
+function shouldLoadRouteOnHydration(route, loaderData, errors) {
+  // We dunno if we have a loader - gotta find out!
+  if (route.lazy) {
+    return true;
+  }
+
+  // No loader, nothing to initialize
+  if (!route.loader) {
+    return false;
+  }
+  let hasData = loaderData != null && loaderData[route.id] !== undefined;
+  let hasError = errors != null && errors[route.id] !== undefined;
+
+  // Don't run if we error'd during SSR
+  if (!hasData && hasError) {
+    return false;
+  }
+
+  // Explicitly opting-in to running on hydration
+  if (typeof route.loader === "function" && route.loader.hydrate === true) {
+    return true;
+  }
+
+  // Otherwise, run if we're not yet initialized with anything
+  return !hasData && !hasError;
+}
+function isNewLoader(currentLoaderData, currentMatch, match) {
+  let isNew =
+  // [a] -> [a, b]
+  !currentMatch ||
+  // [a, b] -> [a, c]
+  match.route.id !== currentMatch.route.id;
+
+  // Handle the case that we don't have data for a re-used route, potentially
+  // from a prior error or from a cancelled pending deferred
+  let isMissingData = currentLoaderData[match.route.id] === undefined;
+
+  // Always load if this is a net-new route or we don't yet have data
+  return isNew || isMissingData;
+}
+function isNewRouteInstance(currentMatch, match) {
+  let currentPath = currentMatch.route.path;
+  return (
+    // param change for this match, /users/123 -> /users/456
+    currentMatch.pathname !== match.pathname ||
+    // splat param changed, which is not present in match.path
+    // e.g. /files/images/avatar.jpg -> files/finances.xls
+    currentPath != null && currentPath.endsWith("*") && currentMatch.params["*"] !== match.params["*"]
+  );
+}
+function shouldRevalidateLoader(loaderMatch, arg) {
+  if (loaderMatch.route.shouldRevalidate) {
+    let routeChoice = loaderMatch.route.shouldRevalidate(arg);
+    if (typeof routeChoice === "boolean") {
+      return routeChoice;
+    }
+  }
+  return arg.defaultShouldRevalidate;
+}
+function patchRoutesImpl(routeId, children, routesToUse, manifest, mapRouteProperties) {
+  var _childrenToPatch;
+  let childrenToPatch;
+  if (routeId) {
+    let route = manifest[routeId];
+    invariant(route, "No route found to patch children into: routeId = " + routeId);
+    if (!route.children) {
+      route.children = [];
+    }
+    childrenToPatch = route.children;
+  } else {
+    childrenToPatch = routesToUse;
+  }
+
+  // Don't patch in routes we already know about so that `patch` is idempotent
+  // to simplify user-land code. This is useful because we re-call the
+  // `patchRoutesOnNavigation` function for matched routes with params.
+  let uniqueChildren = children.filter(newRoute => !childrenToPatch.some(existingRoute => isSameRoute(newRoute, existingRoute)));
+  let newRoutes = convertRoutesToDataRoutes(uniqueChildren, mapRouteProperties, [routeId || "_", "patch", String(((_childrenToPatch = childrenToPatch) == null ? void 0 : _childrenToPatch.length) || "0")], manifest);
+  childrenToPatch.push(...newRoutes);
+}
+function isSameRoute(newRoute, existingRoute) {
+  // Most optimal check is by id
+  if ("id" in newRoute && "id" in existingRoute && newRoute.id === existingRoute.id) {
+    return true;
+  }
+
+  // Second is by pathing differences
+  if (!(newRoute.index === existingRoute.index && newRoute.path === existingRoute.path && newRoute.caseSensitive === existingRoute.caseSensitive)) {
+    return false;
+  }
+
+  // Pathless layout routes are trickier since we need to check children.
+  // If they have no children then they're the same as far as we can tell
+  if ((!newRoute.children || newRoute.children.length === 0) && (!existingRoute.children || existingRoute.children.length === 0)) {
+    return true;
+  }
+
+  // Otherwise, we look to see if every child in the new route is already
+  // represented in the existing route's children
+  return newRoute.children.every((aChild, i) => {
+    var _existingRoute$childr;
+    return (_existingRoute$childr = existingRoute.children) == null ? void 0 : _existingRoute$childr.some(bChild => isSameRoute(aChild, bChild));
+  });
+}
+
+/**
+ * Execute route.lazy() methods to lazily load route modules (loader, action,
+ * shouldRevalidate) and update the routeManifest in place which shares objects
+ * with dataRoutes so those get updated as well.
+ */
+async function loadLazyRouteModule(route, mapRouteProperties, manifest) {
+  if (!route.lazy) {
+    return;
+  }
+  let lazyRoute = await route.lazy();
+
+  // If the lazy route function was executed and removed by another parallel
+  // call then we can return - first lazy() to finish wins because the return
+  // value of lazy is expected to be static
+  if (!route.lazy) {
+    return;
+  }
+  let routeToUpdate = manifest[route.id];
+  invariant(routeToUpdate, "No route found in manifest");
+
+  // Update the route in place.  This should be safe because there's no way
+  // we could yet be sitting on this route as we can't get there without
+  // resolving lazy() first.
+  //
+  // This is different than the HMR "update" use-case where we may actively be
+  // on the route being updated.  The main concern boils down to "does this
+  // mutation affect any ongoing navigations or any current state.matches
+  // values?".  If not, it should be safe to update in place.
+  let routeUpdates = {};
+  for (let lazyRouteProperty in lazyRoute) {
+    let staticRouteValue = routeToUpdate[lazyRouteProperty];
+    let isPropertyStaticallyDefined = staticRouteValue !== undefined &&
+    // This property isn't static since it should always be updated based
+    // on the route updates
+    lazyRouteProperty !== "hasErrorBoundary";
+    warning(!isPropertyStaticallyDefined, "Route \"" + routeToUpdate.id + "\" has a static property \"" + lazyRouteProperty + "\" " + "defined but its lazy function is also returning a value for this property. " + ("The lazy route property \"" + lazyRouteProperty + "\" will be ignored."));
+    if (!isPropertyStaticallyDefined && !immutableRouteKeys.has(lazyRouteProperty)) {
+      routeUpdates[lazyRouteProperty] = lazyRoute[lazyRouteProperty];
+    }
+  }
+
+  // Mutate the route with the provided updates.  Do this first so we pass
+  // the updated version to mapRouteProperties
+  Object.assign(routeToUpdate, routeUpdates);
+
+  // Mutate the `hasErrorBoundary` property on the route based on the route
+  // updates and remove the `lazy` function so we don't resolve the lazy
+  // route again.
+  Object.assign(routeToUpdate, _extends({}, mapRouteProperties(routeToUpdate), {
+    lazy: undefined
+  }));
+}
+
+// Default implementation of `dataStrategy` which fetches all loaders in parallel
+async function defaultDataStrategy(_ref4) {
+  let {
+    matches
+  } = _ref4;
+  let matchesToLoad = matches.filter(m => m.shouldLoad);
+  let results = await Promise.all(matchesToLoad.map(m => m.resolve()));
+  return results.reduce((acc, result, i) => Object.assign(acc, {
+    [matchesToLoad[i].route.id]: result
+  }), {});
+}
+async function callDataStrategyImpl(dataStrategyImpl, type, state, request, matchesToLoad, matches, fetcherKey, manifest, mapRouteProperties, requestContext) {
+  let loadRouteDefinitionsPromises = matches.map(m => m.route.lazy ? loadLazyRouteModule(m.route, mapRouteProperties, manifest) : undefined);
+  let dsMatches = matches.map((match, i) => {
+    let loadRoutePromise = loadRouteDefinitionsPromises[i];
+    let shouldLoad = matchesToLoad.some(m => m.route.id === match.route.id);
+    // `resolve` encapsulates route.lazy(), executing the loader/action,
+    // and mapping return values/thrown errors to a `DataStrategyResult`.  Users
+    // can pass a callback to take fine-grained control over the execution
+    // of the loader/action
+    let resolve = async handlerOverride => {
+      if (handlerOverride && request.method === "GET" && (match.route.lazy || match.route.loader)) {
+        shouldLoad = true;
+      }
+      return shouldLoad ? callLoaderOrAction(type, request, match, loadRoutePromise, handlerOverride, requestContext) : Promise.resolve({
+        type: ResultType.data,
+        result: undefined
+      });
+    };
+    return _extends({}, match, {
+      shouldLoad,
+      resolve
+    });
+  });
+
+  // Send all matches here to allow for a middleware-type implementation.
+  // handler will be a no-op for unneeded routes and we filter those results
+  // back out below.
+  let results = await dataStrategyImpl({
+    matches: dsMatches,
+    request,
+    params: matches[0].params,
+    fetcherKey,
+    context: requestContext
+  });
+
+  // Wait for all routes to load here but 'swallow the error since we want
+  // it to bubble up from the `await loadRoutePromise` in `callLoaderOrAction` -
+  // called from `match.resolve()`
+  try {
+    await Promise.all(loadRouteDefinitionsPromises);
+  } catch (e) {
+    // No-op
+  }
+  return results;
+}
+
+// Default logic for calling a loader/action is the user has no specified a dataStrategy
+async function callLoaderOrAction(type, request, match, loadRoutePromise, handlerOverride, staticContext) {
+  let result;
+  let onReject;
+  let runHandler = handler => {
+    // Setup a promise we can race against so that abort signals short circuit
+    let reject;
+    // This will never resolve so safe to type it as Promise<DataStrategyResult> to
+    // satisfy the function return value
+    let abortPromise = new Promise((_, r) => reject = r);
+    onReject = () => reject();
+    request.signal.addEventListener("abort", onReject);
+    let actualHandler = ctx => {
+      if (typeof handler !== "function") {
+        return Promise.reject(new Error("You cannot call the handler for a route which defines a boolean " + ("\"" + type + "\" [routeId: " + match.route.id + "]")));
+      }
+      return handler({
+        request,
+        params: match.params,
+        context: staticContext
+      }, ...(ctx !== undefined ? [ctx] : []));
+    };
+    let handlerPromise = (async () => {
+      try {
+        let val = await (handlerOverride ? handlerOverride(ctx => actualHandler(ctx)) : actualHandler());
+        return {
+          type: "data",
+          result: val
+        };
+      } catch (e) {
+        return {
+          type: "error",
+          result: e
+        };
+      }
+    })();
+    return Promise.race([handlerPromise, abortPromise]);
+  };
+  try {
+    let handler = match.route[type];
+
+    // If we have a route.lazy promise, await that first
+    if (loadRoutePromise) {
+      if (handler) {
+        // Run statically defined handler in parallel with lazy()
+        let handlerError;
+        let [value] = await Promise.all([
+        // If the handler throws, don't let it immediately bubble out,
+        // since we need to let the lazy() execution finish so we know if this
+        // route has a boundary that can handle the error
+        runHandler(handler).catch(e => {
+          handlerError = e;
+        }), loadRoutePromise]);
+        if (handlerError !== undefined) {
+          throw handlerError;
+        }
+        result = value;
+      } else {
+        // Load lazy route module, then run any returned handler
+        await loadRoutePromise;
+        handler = match.route[type];
+        if (handler) {
+          // Handler still runs even if we got interrupted to maintain consistency
+          // with un-abortable behavior of handler execution on non-lazy or
+          // previously-lazy-loaded routes
+          result = await runHandler(handler);
+        } else if (type === "action") {
+          let url = new URL(request.url);
+          let pathname = url.pathname + url.search;
+          throw getInternalRouterError(405, {
+            method: request.method,
+            pathname,
+            routeId: match.route.id
+          });
+        } else {
+          // lazy() route has no loader to run.  Short circuit here so we don't
+          // hit the invariant below that errors on returning undefined.
+          return {
+            type: ResultType.data,
+            result: undefined
+          };
+        }
+      }
+    } else if (!handler) {
+      let url = new URL(request.url);
+      let pathname = url.pathname + url.search;
+      throw getInternalRouterError(404, {
+        pathname
+      });
+    } else {
+      result = await runHandler(handler);
+    }
+    invariant(result.result !== undefined, "You defined " + (type === "action" ? "an action" : "a loader") + " for route " + ("\"" + match.route.id + "\" but didn't return anything from your `" + type + "` ") + "function. Please return a value or `null`.");
+  } catch (e) {
+    // We should already be catching and converting normal handler executions to
+    // DataStrategyResults and returning them, so anything that throws here is an
+    // unexpected error we still need to wrap
+    return {
+      type: ResultType.error,
+      result: e
+    };
+  } finally {
+    if (onReject) {
+      request.signal.removeEventListener("abort", onReject);
+    }
+  }
+  return result;
+}
+async function convertDataStrategyResultToDataResult(dataStrategyResult) {
+  let {
+    result,
+    type
+  } = dataStrategyResult;
+  if (isResponse(result)) {
+    let data;
+    try {
+      let contentType = result.headers.get("Content-Type");
+      // Check between word boundaries instead of startsWith() due to the last
+      // paragraph of https://httpwg.org/specs/rfc9110.html#field.content-type
+      if (contentType && /\bapplication\/json\b/.test(contentType)) {
+        if (result.body == null) {
+          data = null;
+        } else {
+          data = await result.json();
+        }
+      } else {
+        data = await result.text();
+      }
+    } catch (e) {
+      return {
+        type: ResultType.error,
+        error: e
+      };
+    }
+    if (type === ResultType.error) {
+      return {
+        type: ResultType.error,
+        error: new ErrorResponseImpl(result.status, result.statusText, data),
+        statusCode: result.status,
+        headers: result.headers
+      };
+    }
+    return {
+      type: ResultType.data,
+      data,
+      statusCode: result.status,
+      headers: result.headers
+    };
+  }
+  if (type === ResultType.error) {
+    if (isDataWithResponseInit(result)) {
+      var _result$init3, _result$init4;
+      if (result.data instanceof Error) {
+        var _result$init, _result$init2;
+        return {
+          type: ResultType.error,
+          error: result.data,
+          statusCode: (_result$init = result.init) == null ? void 0 : _result$init.status,
+          headers: (_result$init2 = result.init) != null && _result$init2.headers ? new Headers(result.init.headers) : undefined
+        };
+      }
+
+      // Convert thrown data() to ErrorResponse instances
+      return {
+        type: ResultType.error,
+        error: new ErrorResponseImpl(((_result$init3 = result.init) == null ? void 0 : _result$init3.status) || 500, undefined, result.data),
+        statusCode: isRouteErrorResponse(result) ? result.status : undefined,
+        headers: (_result$init4 = result.init) != null && _result$init4.headers ? new Headers(result.init.headers) : undefined
+      };
+    }
+    return {
+      type: ResultType.error,
+      error: result,
+      statusCode: isRouteErrorResponse(result) ? result.status : undefined
+    };
+  }
+  if (isDeferredData(result)) {
+    var _result$init5, _result$init6;
+    return {
+      type: ResultType.deferred,
+      deferredData: result,
+      statusCode: (_result$init5 = result.init) == null ? void 0 : _result$init5.status,
+      headers: ((_result$init6 = result.init) == null ? void 0 : _result$init6.headers) && new Headers(result.init.headers)
+    };
+  }
+  if (isDataWithResponseInit(result)) {
+    var _result$init7, _result$init8;
+    return {
+      type: ResultType.data,
+      data: result.data,
+      statusCode: (_result$init7 = result.init) == null ? void 0 : _result$init7.status,
+      headers: (_result$init8 = result.init) != null && _result$init8.headers ? new Headers(result.init.headers) : undefined
+    };
+  }
+  return {
+    type: ResultType.data,
+    data: result
+  };
+}
+
+// Support relative routing in internal redirects
+function normalizeRelativeRoutingRedirectResponse(response, request, routeId, matches, basename, v7_relativeSplatPath) {
+  let location = response.headers.get("Location");
+  invariant(location, "Redirects returned/thrown from loaders/actions must have a Location header");
+  if (!ABSOLUTE_URL_REGEX.test(location)) {
+    let trimmedMatches = matches.slice(0, matches.findIndex(m => m.route.id === routeId) + 1);
+    location = normalizeTo(new URL(request.url), trimmedMatches, basename, true, location, v7_relativeSplatPath);
+    response.headers.set("Location", location);
+  }
+  return response;
+}
+function normalizeRedirectLocation(location, currentUrl, basename, historyInstance) {
+  // Match Chrome's behavior:
+  // https://github.com/chromium/chromium/blob/216dbeb61db0c667e62082e5f5400a32d6983df3/content/public/common/url_utils.cc#L82
+  let invalidProtocols = ["about:", "blob:", "chrome:", "chrome-untrusted:", "content:", "data:", "devtools:", "file:", "filesystem:",
+  // eslint-disable-next-line no-script-url
+  "javascript:"];
+  if (ABSOLUTE_URL_REGEX.test(location)) {
+    // Strip off the protocol+origin for same-origin + same-basename absolute redirects
+    let normalizedLocation = location;
+    let url = normalizedLocation.startsWith("//") ? new URL(currentUrl.protocol + normalizedLocation) : new URL(normalizedLocation);
+    if (invalidProtocols.includes(url.protocol)) {
+      throw new Error("Invalid redirect location");
+    }
+    let isSameBasename = stripBasename(url.pathname, basename) != null;
+    if (url.origin === currentUrl.origin && isSameBasename) {
+      return url.pathname + url.search + url.hash;
+    }
+  }
+  try {
+    let url = historyInstance.createURL(location);
+    if (invalidProtocols.includes(url.protocol)) {
+      throw new Error("Invalid redirect location");
+    }
+  } catch (e) {}
+  return location;
+}
+
+// Utility method for creating the Request instances for loaders/actions during
+// client-side navigations and fetches.  During SSR we will always have a
+// Request instance from the static handler (query/queryRoute)
+function createClientSideRequest(history, location, signal, submission) {
+  let url = history.createURL(stripHashFromPath(location)).toString();
+  let init = {
+    signal
+  };
+  if (submission && isMutationMethod(submission.formMethod)) {
+    let {
+      formMethod,
+      formEncType
+    } = submission;
+    // Didn't think we needed this but it turns out unlike other methods, patch
+    // won't be properly normalized to uppercase and results in a 405 error.
+    // See: https://fetch.spec.whatwg.org/#concept-method
+    init.method = formMethod.toUpperCase();
+    if (formEncType === "application/json") {
+      init.headers = new Headers({
+        "Content-Type": formEncType
+      });
+      init.body = JSON.stringify(submission.json);
+    } else if (formEncType === "text/plain") {
+      // Content-Type is inferred (https://fetch.spec.whatwg.org/#dom-request)
+      init.body = submission.text;
+    } else if (formEncType === "application/x-www-form-urlencoded" && submission.formData) {
+      // Content-Type is inferred (https://fetch.spec.whatwg.org/#dom-request)
+      init.body = convertFormDataToSearchParams(submission.formData);
+    } else {
+      // Content-Type is inferred (https://fetch.spec.whatwg.org/#dom-request)
+      init.body = submission.formData;
+    }
+  }
+  return new Request(url, init);
+}
+function convertFormDataToSearchParams(formData) {
+  let searchParams = new URLSearchParams();
+  for (let [key, value] of formData.entries()) {
+    // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#converting-an-entry-list-to-a-list-of-name-value-pairs
+    searchParams.append(key, typeof value === "string" ? value : value.name);
+  }
+  return searchParams;
+}
+function convertSearchParamsToFormData(searchParams) {
+  let formData = new FormData();
+  for (let [key, value] of searchParams.entries()) {
+    formData.append(key, value);
+  }
+  return formData;
+}
+function processRouteLoaderData(matches, results, pendingActionResult, activeDeferreds, skipLoaderErrorBubbling) {
+  // Fill in loaderData/errors from our loaders
+  let loaderData = {};
+  let errors = null;
+  let statusCode;
+  let foundError = false;
+  let loaderHeaders = {};
+  let pendingError = pendingActionResult && isErrorResult(pendingActionResult[1]) ? pendingActionResult[1].error : undefined;
+
+  // Process loader results into state.loaderData/state.errors
+  matches.forEach(match => {
+    if (!(match.route.id in results)) {
+      return;
+    }
+    let id = match.route.id;
+    let result = results[id];
+    invariant(!isRedirectResult(result), "Cannot handle redirect results in processLoaderData");
+    if (isErrorResult(result)) {
+      let error = result.error;
+      // If we have a pending action error, we report it at the highest-route
+      // that throws a loader error, and then clear it out to indicate that
+      // it was consumed
+      if (pendingError !== undefined) {
+        error = pendingError;
+        pendingError = undefined;
+      }
+      errors = errors || {};
+      if (skipLoaderErrorBubbling) {
+        errors[id] = error;
+      } else {
+        // Look upwards from the matched route for the closest ancestor error
+        // boundary, defaulting to the root match.  Prefer higher error values
+        // if lower errors bubble to the same boundary
+        let boundaryMatch = findNearestBoundary(matches, id);
+        if (errors[boundaryMatch.route.id] == null) {
+          errors[boundaryMatch.route.id] = error;
+        }
+      }
+
+      // Clear our any prior loaderData for the throwing route
+      loaderData[id] = undefined;
+
+      // Once we find our first (highest) error, we set the status code and
+      // prevent deeper status codes from overriding
+      if (!foundError) {
+        foundError = true;
+        statusCode = isRouteErrorResponse(result.error) ? result.error.status : 500;
+      }
+      if (result.headers) {
+        loaderHeaders[id] = result.headers;
+      }
+    } else {
+      if (isDeferredResult(result)) {
+        activeDeferreds.set(id, result.deferredData);
+        loaderData[id] = result.deferredData.data;
+        // Error status codes always override success status codes, but if all
+        // loaders are successful we take the deepest status code.
+        if (result.statusCode != null && result.statusCode !== 200 && !foundError) {
+          statusCode = result.statusCode;
+        }
+        if (result.headers) {
+          loaderHeaders[id] = result.headers;
+        }
+      } else {
+        loaderData[id] = result.data;
+        // Error status codes always override success status codes, but if all
+        // loaders are successful we take the deepest status code.
+        if (result.statusCode && result.statusCode !== 200 && !foundError) {
+          statusCode = result.statusCode;
+        }
+        if (result.headers) {
+          loaderHeaders[id] = result.headers;
+        }
+      }
+    }
+  });
+
+  // If we didn't consume the pending action error (i.e., all loaders
+  // resolved), then consume it here.  Also clear out any loaderData for the
+  // throwing route
+  if (pendingError !== undefined && pendingActionResult) {
+    errors = {
+      [pendingActionResult[0]]: pendingError
+    };
+    loaderData[pendingActionResult[0]] = undefined;
+  }
+  return {
+    loaderData,
+    errors,
+    statusCode: statusCode || 200,
+    loaderHeaders
+  };
+}
+function processLoaderData(state, matches, results, pendingActionResult, revalidatingFetchers, fetcherResults, activeDeferreds) {
+  let {
+    loaderData,
+    errors
+  } = processRouteLoaderData(matches, results, pendingActionResult, activeDeferreds, false // This method is only called client side so we always want to bubble
+  );
+
+  // Process results from our revalidating fetchers
+  revalidatingFetchers.forEach(rf => {
+    let {
+      key,
+      match,
+      controller
+    } = rf;
+    let result = fetcherResults[key];
+    invariant(result, "Did not find corresponding fetcher result");
+
+    // Process fetcher non-redirect errors
+    if (controller && controller.signal.aborted) {
+      // Nothing to do for aborted fetchers
+      return;
+    } else if (isErrorResult(result)) {
+      let boundaryMatch = findNearestBoundary(state.matches, match == null ? void 0 : match.route.id);
+      if (!(errors && errors[boundaryMatch.route.id])) {
+        errors = _extends({}, errors, {
+          [boundaryMatch.route.id]: result.error
+        });
+      }
+      state.fetchers.delete(key);
+    } else if (isRedirectResult(result)) {
+      // Should never get here, redirects should get processed above, but we
+      // keep this to type narrow to a success result in the else
+      invariant(false, "Unhandled fetcher revalidation redirect");
+    } else if (isDeferredResult(result)) {
+      // Should never get here, deferred data should be awaited for fetchers
+      // in resolveDeferredResults
+      invariant(false, "Unhandled fetcher deferred data");
+    } else {
+      let doneFetcher = getDoneFetcher(result.data);
+      state.fetchers.set(key, doneFetcher);
+    }
+  });
+  return {
+    loaderData,
+    errors
+  };
+}
+function mergeLoaderData(loaderData, newLoaderData, matches, errors) {
+  let mergedLoaderData = _extends({}, newLoaderData);
+  for (let match of matches) {
+    let id = match.route.id;
+    if (newLoaderData.hasOwnProperty(id)) {
+      if (newLoaderData[id] !== undefined) {
+        mergedLoaderData[id] = newLoaderData[id];
+      }
+    } else if (loaderData[id] !== undefined && match.route.loader) {
+      // Preserve existing keys not included in newLoaderData and where a loader
+      // wasn't removed by HMR
+      mergedLoaderData[id] = loaderData[id];
+    }
+    if (errors && errors.hasOwnProperty(id)) {
+      // Don't keep any loader data below the boundary
+      break;
+    }
+  }
+  return mergedLoaderData;
+}
+function getActionDataForCommit(pendingActionResult) {
+  if (!pendingActionResult) {
+    return {};
+  }
+  return isErrorResult(pendingActionResult[1]) ? {
+    // Clear out prior actionData on errors
+    actionData: {}
+  } : {
+    actionData: {
+      [pendingActionResult[0]]: pendingActionResult[1].data
+    }
+  };
+}
+
+// Find the nearest error boundary, looking upwards from the leaf route (or the
+// route specified by routeId) for the closest ancestor error boundary,
+// defaulting to the root match
+function findNearestBoundary(matches, routeId) {
+  let eligibleMatches = routeId ? matches.slice(0, matches.findIndex(m => m.route.id === routeId) + 1) : [...matches];
+  return eligibleMatches.reverse().find(m => m.route.hasErrorBoundary === true) || matches[0];
+}
+function getShortCircuitMatches(routes) {
+  // Prefer a root layout route if present, otherwise shim in a route object
+  let route = routes.length === 1 ? routes[0] : routes.find(r => r.index || !r.path || r.path === "/") || {
+    id: "__shim-error-route__"
+  };
+  return {
+    matches: [{
+      params: {},
+      pathname: "",
+      pathnameBase: "",
+      route
+    }],
+    route
+  };
+}
+function getInternalRouterError(status, _temp5) {
+  let {
+    pathname,
+    routeId,
+    method,
+    type,
+    message
+  } = _temp5 === void 0 ? {} : _temp5;
+  let statusText = "Unknown Server Error";
+  let errorMessage = "Unknown @remix-run/router error";
+  if (status === 400) {
+    statusText = "Bad Request";
+    if (method && pathname && routeId) {
+      errorMessage = "You made a " + method + " request to \"" + pathname + "\" but " + ("did not provide a `loader` for route \"" + routeId + "\", ") + "so there is no way to handle the request.";
+    } else if (type === "defer-action") {
+      errorMessage = "defer() is not supported in actions";
+    } else if (type === "invalid-body") {
+      errorMessage = "Unable to encode submission body";
+    }
+  } else if (status === 403) {
+    statusText = "Forbidden";
+    errorMessage = "Route \"" + routeId + "\" does not match URL \"" + pathname + "\"";
+  } else if (status === 404) {
+    statusText = "Not Found";
+    errorMessage = "No route matches URL \"" + pathname + "\"";
+  } else if (status === 405) {
+    statusText = "Method Not Allowed";
+    if (method && pathname && routeId) {
+      errorMessage = "You made a " + method.toUpperCase() + " request to \"" + pathname + "\" but " + ("did not provide an `action` for route \"" + routeId + "\", ") + "so there is no way to handle the request.";
+    } else if (method) {
+      errorMessage = "Invalid request method \"" + method.toUpperCase() + "\"";
+    }
+  }
+  return new ErrorResponseImpl(status || 500, statusText, new Error(errorMessage), true);
+}
+
+// Find any returned redirect errors, starting from the lowest match
+function findRedirect(results) {
+  let entries = Object.entries(results);
+  for (let i = entries.length - 1; i >= 0; i--) {
+    let [key, result] = entries[i];
+    if (isRedirectResult(result)) {
+      return {
+        key,
+        result
+      };
+    }
+  }
+}
+function stripHashFromPath(path) {
+  let parsedPath = typeof path === "string" ? parsePath(path) : path;
+  return createPath(_extends({}, parsedPath, {
+    hash: ""
+  }));
+}
+function isHashChangeOnly(a, b) {
+  if (a.pathname !== b.pathname || a.search !== b.search) {
+    return false;
+  }
+  if (a.hash === "") {
+    // /page -> /page#hash
+    return b.hash !== "";
+  } else if (a.hash === b.hash) {
+    // /page#hash -> /page#hash
+    return true;
+  } else if (b.hash !== "") {
+    // /page#hash -> /page#other
+    return true;
+  }
+
+  // If the hash is removed the browser will re-perform a request to the server
+  // /page#hash -> /page
+  return false;
+}
+function isDataStrategyResult(result) {
+  return result != null && typeof result === "object" && "type" in result && "result" in result && (result.type === ResultType.data || result.type === ResultType.error);
+}
+function isRedirectDataStrategyResultResult(result) {
+  return isResponse(result.result) && redirectStatusCodes.has(result.result.status);
+}
+function isDeferredResult(result) {
+  return result.type === ResultType.deferred;
+}
+function isErrorResult(result) {
+  return result.type === ResultType.error;
+}
+function isRedirectResult(result) {
+  return (result && result.type) === ResultType.redirect;
+}
+function isDataWithResponseInit(value) {
+  return typeof value === "object" && value != null && "type" in value && "data" in value && "init" in value && value.type === "DataWithResponseInit";
+}
+function isDeferredData(value) {
+  let deferred = value;
+  return deferred && typeof deferred === "object" && typeof deferred.data === "object" && typeof deferred.subscribe === "function" && typeof deferred.cancel === "function" && typeof deferred.resolveData === "function";
+}
+function isResponse(value) {
+  return value != null && typeof value.status === "number" && typeof value.statusText === "string" && typeof value.headers === "object" && typeof value.body !== "undefined";
+}
+function isRedirectResponse(result) {
+  if (!isResponse(result)) {
+    return false;
+  }
+  let status = result.status;
+  let location = result.headers.get("Location");
+  return status >= 300 && status <= 399 && location != null;
+}
+function isValidMethod(method) {
+  return validRequestMethods.has(method.toLowerCase());
+}
+function isMutationMethod(method) {
+  return validMutationMethods.has(method.toLowerCase());
+}
+async function resolveNavigationDeferredResults(matches, results, signal, currentMatches, currentLoaderData) {
+  let entries = Object.entries(results);
+  for (let index = 0; index < entries.length; index++) {
+    let [routeId, result] = entries[index];
+    let match = matches.find(m => (m == null ? void 0 : m.route.id) === routeId);
+    // If we don't have a match, then we can have a deferred result to do
+    // anything with.  This is for revalidating fetchers where the route was
+    // removed during HMR
+    if (!match) {
+      continue;
+    }
+    let currentMatch = currentMatches.find(m => m.route.id === match.route.id);
+    let isRevalidatingLoader = currentMatch != null && !isNewRouteInstance(currentMatch, match) && (currentLoaderData && currentLoaderData[match.route.id]) !== undefined;
+    if (isDeferredResult(result) && isRevalidatingLoader) {
+      // Note: we do not have to touch activeDeferreds here since we race them
+      // against the signal in resolveDeferredData and they'll get aborted
+      // there if needed
+      await resolveDeferredData(result, signal, false).then(result => {
+        if (result) {
+          results[routeId] = result;
+        }
+      });
+    }
+  }
+}
+async function resolveFetcherDeferredResults(matches, results, revalidatingFetchers) {
+  for (let index = 0; index < revalidatingFetchers.length; index++) {
+    let {
+      key,
+      routeId,
+      controller
+    } = revalidatingFetchers[index];
+    let result = results[key];
+    let match = matches.find(m => (m == null ? void 0 : m.route.id) === routeId);
+    // If we don't have a match, then we can have a deferred result to do
+    // anything with.  This is for revalidating fetchers where the route was
+    // removed during HMR
+    if (!match) {
+      continue;
+    }
+    if (isDeferredResult(result)) {
+      // Note: we do not have to touch activeDeferreds here since we race them
+      // against the signal in resolveDeferredData and they'll get aborted
+      // there if needed
+      invariant(controller, "Expected an AbortController for revalidating fetcher deferred result");
+      await resolveDeferredData(result, controller.signal, true).then(result => {
+        if (result) {
+          results[key] = result;
+        }
+      });
+    }
+  }
+}
+async function resolveDeferredData(result, signal, unwrap) {
+  if (unwrap === void 0) {
+    unwrap = false;
+  }
+  let aborted = await result.deferredData.resolveData(signal);
+  if (aborted) {
+    return;
+  }
+  if (unwrap) {
+    try {
+      return {
+        type: ResultType.data,
+        data: result.deferredData.unwrappedData
+      };
+    } catch (e) {
+      // Handle any TrackedPromise._error values encountered while unwrapping
+      return {
+        type: ResultType.error,
+        error: e
+      };
+    }
+  }
+  return {
+    type: ResultType.data,
+    data: result.deferredData.data
+  };
+}
+function hasNakedIndexQuery(search) {
+  return new URLSearchParams(search).getAll("index").some(v => v === "");
+}
+function getTargetMatch(matches, location) {
+  let search = typeof location === "string" ? parsePath(location).search : location.search;
+  if (matches[matches.length - 1].route.index && hasNakedIndexQuery(search || "")) {
+    // Return the leaf index route when index is present
+    return matches[matches.length - 1];
+  }
+  // Otherwise grab the deepest "path contributing" match (ignoring index and
+  // pathless layout routes)
+  let pathMatches = getPathContributingMatches(matches);
+  return pathMatches[pathMatches.length - 1];
+}
+function getSubmissionFromNavigation(navigation) {
+  let {
+    formMethod,
+    formAction,
+    formEncType,
+    text,
+    formData,
+    json
+  } = navigation;
+  if (!formMethod || !formAction || !formEncType) {
+    return;
+  }
+  if (text != null) {
+    return {
+      formMethod,
+      formAction,
+      formEncType,
+      formData: undefined,
+      json: undefined,
+      text
+    };
+  } else if (formData != null) {
+    return {
+      formMethod,
+      formAction,
+      formEncType,
+      formData,
+      json: undefined,
+      text: undefined
+    };
+  } else if (json !== undefined) {
+    return {
+      formMethod,
+      formAction,
+      formEncType,
+      formData: undefined,
+      json,
+      text: undefined
+    };
+  }
+}
+function getLoadingNavigation(location, submission) {
+  if (submission) {
+    let navigation = {
+      state: "loading",
+      location,
+      formMethod: submission.formMethod,
+      formAction: submission.formAction,
+      formEncType: submission.formEncType,
+      formData: submission.formData,
+      json: submission.json,
+      text: submission.text
+    };
+    return navigation;
+  } else {
+    let navigation = {
+      state: "loading",
+      location,
+      formMethod: undefined,
+      formAction: undefined,
+      formEncType: undefined,
+      formData: undefined,
+      json: undefined,
+      text: undefined
+    };
+    return navigation;
+  }
+}
+function getSubmittingNavigation(location, submission) {
+  let navigation = {
+    state: "submitting",
+    location,
+    formMethod: submission.formMethod,
+    formAction: submission.formAction,
+    formEncType: submission.formEncType,
+    formData: submission.formData,
+    json: submission.json,
+    text: submission.text
+  };
+  return navigation;
+}
+function getLoadingFetcher(submission, data) {
+  if (submission) {
+    let fetcher = {
+      state: "loading",
+      formMethod: submission.formMethod,
+      formAction: submission.formAction,
+      formEncType: submission.formEncType,
+      formData: submission.formData,
+      json: submission.json,
+      text: submission.text,
+      data
+    };
+    return fetcher;
+  } else {
+    let fetcher = {
+      state: "loading",
+      formMethod: undefined,
+      formAction: undefined,
+      formEncType: undefined,
+      formData: undefined,
+      json: undefined,
+      text: undefined,
+      data
+    };
+    return fetcher;
+  }
+}
+function getSubmittingFetcher(submission, existingFetcher) {
+  let fetcher = {
+    state: "submitting",
+    formMethod: submission.formMethod,
+    formAction: submission.formAction,
+    formEncType: submission.formEncType,
+    formData: submission.formData,
+    json: submission.json,
+    text: submission.text,
+    data: existingFetcher ? existingFetcher.data : undefined
+  };
+  return fetcher;
+}
+function getDoneFetcher(data) {
+  let fetcher = {
+    state: "idle",
+    formMethod: undefined,
+    formAction: undefined,
+    formEncType: undefined,
+    formData: undefined,
+    json: undefined,
+    text: undefined,
+    data
+  };
+  return fetcher;
+}
+function restoreAppliedTransitions(_window, transitions) {
+  try {
+    let sessionPositions = _window.sessionStorage.getItem(TRANSITIONS_STORAGE_KEY);
+    if (sessionPositions) {
+      let json = JSON.parse(sessionPositions);
+      for (let [k, v] of Object.entries(json || {})) {
+        if (v && Array.isArray(v)) {
+          transitions.set(k, new Set(v || []));
+        }
+      }
+    }
+  } catch (e) {
+    // no-op, use default empty object
+  }
+}
+function persistAppliedTransitions(_window, transitions) {
+  if (transitions.size > 0) {
+    let json = {};
+    for (let [k, v] of transitions) {
+      json[k] = [...v];
+    }
+    try {
+      _window.sessionStorage.setItem(TRANSITIONS_STORAGE_KEY, JSON.stringify(json));
+    } catch (error) {
+      warning(false, "Failed to save applied view transitions in sessionStorage (" + error + ").");
+    }
+  }
+}
+//#endregion
+
+exports.AbortedDeferredError = AbortedDeferredError;
+exports.Action = Action;
+exports.IDLE_BLOCKER = IDLE_BLOCKER;
+exports.IDLE_FETCHER = IDLE_FETCHER;
+exports.IDLE_NAVIGATION = IDLE_NAVIGATION;
+exports.UNSAFE_DEFERRED_SYMBOL = UNSAFE_DEFERRED_SYMBOL;
+exports.UNSAFE_DeferredData = DeferredData;
+exports.UNSAFE_ErrorResponseImpl = ErrorResponseImpl;
+exports.UNSAFE_convertRouteMatchToUiMatch = convertRouteMatchToUiMatch;
+exports.UNSAFE_convertRoutesToDataRoutes = convertRoutesToDataRoutes;
+exports.UNSAFE_decodePath = decodePath;
+exports.UNSAFE_getResolveToMatches = getResolveToMatches;
+exports.UNSAFE_invariant = invariant;
+exports.UNSAFE_warning = warning;
+exports.createBrowserHistory = createBrowserHistory;
+exports.createHashHistory = createHashHistory;
+exports.createMemoryHistory = createMemoryHistory;
+exports.createPath = createPath;
+exports.createRouter = createRouter;
+exports.createStaticHandler = createStaticHandler;
+exports.data = data;
+exports.defer = defer;
+exports.generatePath = generatePath;
+exports.getStaticContextFromError = getStaticContextFromError;
+exports.getToPathname = getToPathname;
+exports.isDataWithResponseInit = isDataWithResponseInit;
+exports.isDeferredData = isDeferredData;
+exports.isRouteErrorResponse = isRouteErrorResponse;
+exports.joinPaths = joinPaths;
+exports.json = json;
+exports.matchPath = matchPath;
+exports.matchRoutes = matchRoutes;
+exports.normalizePathname = normalizePathname;
+exports.parsePath = parsePath;
+exports.redirect = redirect;
+exports.redirectDocument = redirectDocument;
+exports.replace = replace;
+exports.resolvePath = resolvePath;
+exports.resolveTo = resolveTo;
+exports.stripBasename = stripBasename;
+//# sourceMappingURL=router.cjs.js.map
Index: frontend/node_modules/@remix-run/router/dist/router.cjs.js.map
===================================================================
--- frontend/node_modules/@remix-run/router/dist/router.cjs.js.map	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/@remix-run/router/dist/router.cjs.js.map	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,1 @@
+{"version":3,"file":"router.cjs.js","sources":["../history.ts","../utils.ts","../router.ts"],"sourcesContent":["////////////////////////////////////////////////////////////////////////////////\n//#region Types and Constants\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * Actions represent the type of change to a location value.\n */\nexport enum Action {\n  /**\n   * A POP indicates a change to an arbitrary index in the history stack, such\n   * as a back or forward navigation. It does not describe the direction of the\n   * navigation, only that the current index changed.\n   *\n   * Note: This is the default action for newly created history objects.\n   */\n  Pop = \"POP\",\n\n  /**\n   * A PUSH indicates a new entry being added to the history stack, such as when\n   * a link is clicked and a new page loads. When this happens, all subsequent\n   * entries in the stack are lost.\n   */\n  Push = \"PUSH\",\n\n  /**\n   * A REPLACE indicates the entry at the current index in the history stack\n   * being replaced by a new one.\n   */\n  Replace = \"REPLACE\",\n}\n\n/**\n * The pathname, search, and hash values of a URL.\n */\nexport interface Path {\n  /**\n   * A URL pathname, beginning with a /.\n   */\n  pathname: string;\n\n  /**\n   * A URL search string, beginning with a ?.\n   */\n  search: string;\n\n  /**\n   * A URL fragment identifier, beginning with a #.\n   */\n  hash: string;\n}\n\n// TODO: (v7) Change the Location generic default from `any` to `unknown` and\n// remove Remix `useLocation` wrapper.\n\n/**\n * An entry in a history stack. A location contains information about the\n * URL path, as well as possibly some arbitrary state and a key.\n */\nexport interface Location<State = any> extends Path {\n  /**\n   * A value of arbitrary data associated with this location.\n   */\n  state: State;\n\n  /**\n   * A unique string associated with this location. May be used to safely store\n   * and retrieve data in some other storage API, like `localStorage`.\n   *\n   * Note: This value is always \"default\" on the initial location.\n   */\n  key: string;\n}\n\n/**\n * A change to the current location.\n */\nexport interface Update {\n  /**\n   * The action that triggered the change.\n   */\n  action: Action;\n\n  /**\n   * The new location.\n   */\n  location: Location;\n\n  /**\n   * The delta between this location and the former location in the history stack\n   */\n  delta: number | null;\n}\n\n/**\n * A function that receives notifications about location changes.\n */\nexport interface Listener {\n  (update: Update): void;\n}\n\n/**\n * Describes a location that is the destination of some navigation, either via\n * `history.push` or `history.replace`. This may be either a URL or the pieces\n * of a URL path.\n */\nexport type To = string | Partial<Path>;\n\n/**\n * A history is an interface to the navigation stack. The history serves as the\n * source of truth for the current location, as well as provides a set of\n * methods that may be used to change it.\n *\n * It is similar to the DOM's `window.history` object, but with a smaller, more\n * focused API.\n */\nexport interface History {\n  /**\n   * The last action that modified the current location. This will always be\n   * Action.Pop when a history instance is first created. This value is mutable.\n   */\n  readonly action: Action;\n\n  /**\n   * The current location. This value is mutable.\n   */\n  readonly location: Location;\n\n  /**\n   * Returns a valid href for the given `to` value that may be used as\n   * the value of an <a href> attribute.\n   *\n   * @param to - The destination URL\n   */\n  createHref(to: To): string;\n\n  /**\n   * Returns a URL for the given `to` value\n   *\n   * @param to - The destination URL\n   */\n  createURL(to: To): URL;\n\n  /**\n   * Encode a location the same way window.history would do (no-op for memory\n   * history) so we ensure our PUSH/REPLACE navigations for data routers\n   * behave the same as POP\n   *\n   * @param to Unencoded path\n   */\n  encodeLocation(to: To): Path;\n\n  /**\n   * Pushes a new location onto the history stack, increasing its length by one.\n   * If there were any entries in the stack after the current one, they are\n   * lost.\n   *\n   * @param to - The new URL\n   * @param state - Data to associate with the new location\n   */\n  push(to: To, state?: any): void;\n\n  /**\n   * Replaces the current location in the history stack with a new one.  The\n   * location that was replaced will no longer be available.\n   *\n   * @param to - The new URL\n   * @param state - Data to associate with the new location\n   */\n  replace(to: To, state?: any): void;\n\n  /**\n   * Navigates `n` entries backward/forward in the history stack relative to the\n   * current index. For example, a \"back\" navigation would use go(-1).\n   *\n   * @param delta - The delta in the stack index\n   */\n  go(delta: number): void;\n\n  /**\n   * Sets up a listener that will be called whenever the current location\n   * changes.\n   *\n   * @param listener - A function that will be called when the location changes\n   * @returns unlisten - A function that may be used to stop listening\n   */\n  listen(listener: Listener): () => void;\n}\n\ntype HistoryState = {\n  usr: any;\n  key?: string;\n  idx: number;\n};\n\nconst PopStateEventType = \"popstate\";\n//#endregion\n\n////////////////////////////////////////////////////////////////////////////////\n//#region Memory History\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * A user-supplied object that describes a location. Used when providing\n * entries to `createMemoryHistory` via its `initialEntries` option.\n */\nexport type InitialEntry = string | Partial<Location>;\n\nexport type MemoryHistoryOptions = {\n  initialEntries?: InitialEntry[];\n  initialIndex?: number;\n  v5Compat?: boolean;\n};\n\n/**\n * A memory history stores locations in memory. This is useful in stateful\n * environments where there is no web browser, such as node tests or React\n * Native.\n */\nexport interface MemoryHistory extends History {\n  /**\n   * The current index in the history stack.\n   */\n  readonly index: number;\n}\n\n/**\n * Memory history stores the current location in memory. It is designed for use\n * in stateful non-browser environments like tests and React Native.\n */\nexport function createMemoryHistory(\n  options: MemoryHistoryOptions = {}\n): MemoryHistory {\n  let { initialEntries = [\"/\"], initialIndex, v5Compat = false } = options;\n  let entries: Location[]; // Declare so we can access from createMemoryLocation\n  entries = initialEntries.map((entry, index) =>\n    createMemoryLocation(\n      entry,\n      typeof entry === \"string\" ? null : entry.state,\n      index === 0 ? \"default\" : undefined\n    )\n  );\n  let index = clampIndex(\n    initialIndex == null ? entries.length - 1 : initialIndex\n  );\n  let action = Action.Pop;\n  let listener: Listener | null = null;\n\n  function clampIndex(n: number): number {\n    return Math.min(Math.max(n, 0), entries.length - 1);\n  }\n  function getCurrentLocation(): Location {\n    return entries[index];\n  }\n  function createMemoryLocation(\n    to: To,\n    state: any = null,\n    key?: string\n  ): Location {\n    let location = createLocation(\n      entries ? getCurrentLocation().pathname : \"/\",\n      to,\n      state,\n      key\n    );\n    warning(\n      location.pathname.charAt(0) === \"/\",\n      `relative pathnames are not supported in memory history: ${JSON.stringify(\n        to\n      )}`\n    );\n    return location;\n  }\n\n  function createHref(to: To) {\n    return typeof to === \"string\" ? to : createPath(to);\n  }\n\n  let history: MemoryHistory = {\n    get index() {\n      return index;\n    },\n    get action() {\n      return action;\n    },\n    get location() {\n      return getCurrentLocation();\n    },\n    createHref,\n    createURL(to) {\n      return new URL(createHref(to), \"http://localhost\");\n    },\n    encodeLocation(to: To) {\n      let path = typeof to === \"string\" ? parsePath(to) : to;\n      return {\n        pathname: path.pathname || \"\",\n        search: path.search || \"\",\n        hash: path.hash || \"\",\n      };\n    },\n    push(to, state) {\n      action = Action.Push;\n      let nextLocation = createMemoryLocation(to, state);\n      index += 1;\n      entries.splice(index, entries.length, nextLocation);\n      if (v5Compat && listener) {\n        listener({ action, location: nextLocation, delta: 1 });\n      }\n    },\n    replace(to, state) {\n      action = Action.Replace;\n      let nextLocation = createMemoryLocation(to, state);\n      entries[index] = nextLocation;\n      if (v5Compat && listener) {\n        listener({ action, location: nextLocation, delta: 0 });\n      }\n    },\n    go(delta) {\n      action = Action.Pop;\n      let nextIndex = clampIndex(index + delta);\n      let nextLocation = entries[nextIndex];\n      index = nextIndex;\n      if (listener) {\n        listener({ action, location: nextLocation, delta });\n      }\n    },\n    listen(fn: Listener) {\n      listener = fn;\n      return () => {\n        listener = null;\n      };\n    },\n  };\n\n  return history;\n}\n//#endregion\n\n////////////////////////////////////////////////////////////////////////////////\n//#region Browser History\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * A browser history stores the current location in regular URLs in a web\n * browser environment. This is the standard for most web apps and provides the\n * cleanest URLs the browser's address bar.\n *\n * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#browserhistory\n */\nexport interface BrowserHistory extends UrlHistory {}\n\nexport type BrowserHistoryOptions = UrlHistoryOptions;\n\n/**\n * Browser history stores the location in regular URLs. This is the standard for\n * most web apps, but it requires some configuration on the server to ensure you\n * serve the same app at multiple URLs.\n *\n * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createbrowserhistory\n */\nexport function createBrowserHistory(\n  options: BrowserHistoryOptions = {}\n): BrowserHistory {\n  function createBrowserLocation(\n    window: Window,\n    globalHistory: Window[\"history\"]\n  ) {\n    let { pathname, search, hash } = window.location;\n    return createLocation(\n      \"\",\n      { pathname, search, hash },\n      // state defaults to `null` because `window.history.state` does\n      (globalHistory.state && globalHistory.state.usr) || null,\n      (globalHistory.state && globalHistory.state.key) || \"default\"\n    );\n  }\n\n  function createBrowserHref(window: Window, to: To) {\n    return typeof to === \"string\" ? to : createPath(to);\n  }\n\n  return getUrlBasedHistory(\n    createBrowserLocation,\n    createBrowserHref,\n    null,\n    options\n  );\n}\n//#endregion\n\n////////////////////////////////////////////////////////////////////////////////\n//#region Hash History\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * A hash history stores the current location in the fragment identifier portion\n * of the URL in a web browser environment.\n *\n * This is ideal for apps that do not control the server for some reason\n * (because the fragment identifier is never sent to the server), including some\n * shared hosting environments that do not provide fine-grained controls over\n * which pages are served at which URLs.\n *\n * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#hashhistory\n */\nexport interface HashHistory extends UrlHistory {}\n\nexport type HashHistoryOptions = UrlHistoryOptions;\n\n/**\n * Hash history stores the location in window.location.hash. This makes it ideal\n * for situations where you don't want to send the location to the server for\n * some reason, either because you do cannot configure it or the URL space is\n * reserved for something else.\n *\n * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createhashhistory\n */\nexport function createHashHistory(\n  options: HashHistoryOptions = {}\n): HashHistory {\n  function createHashLocation(\n    window: Window,\n    globalHistory: Window[\"history\"]\n  ) {\n    let {\n      pathname = \"/\",\n      search = \"\",\n      hash = \"\",\n    } = parsePath(window.location.hash.substr(1));\n\n    // Hash URL should always have a leading / just like window.location.pathname\n    // does, so if an app ends up at a route like /#something then we add a\n    // leading slash so all of our path-matching behaves the same as if it would\n    // in a browser router.  This is particularly important when there exists a\n    // root splat route (<Route path=\"*\">) since that matches internally against\n    // \"/*\" and we'd expect /#something to 404 in a hash router app.\n    if (!pathname.startsWith(\"/\") && !pathname.startsWith(\".\")) {\n      pathname = \"/\" + pathname;\n    }\n\n    return createLocation(\n      \"\",\n      { pathname, search, hash },\n      // state defaults to `null` because `window.history.state` does\n      (globalHistory.state && globalHistory.state.usr) || null,\n      (globalHistory.state && globalHistory.state.key) || \"default\"\n    );\n  }\n\n  function createHashHref(window: Window, to: To) {\n    let base = window.document.querySelector(\"base\");\n    let href = \"\";\n\n    if (base && base.getAttribute(\"href\")) {\n      let url = window.location.href;\n      let hashIndex = url.indexOf(\"#\");\n      href = hashIndex === -1 ? url : url.slice(0, hashIndex);\n    }\n\n    return href + \"#\" + (typeof to === \"string\" ? to : createPath(to));\n  }\n\n  function validateHashLocation(location: Location, to: To) {\n    warning(\n      location.pathname.charAt(0) === \"/\",\n      `relative pathnames are not supported in hash history.push(${JSON.stringify(\n        to\n      )})`\n    );\n  }\n\n  return getUrlBasedHistory(\n    createHashLocation,\n    createHashHref,\n    validateHashLocation,\n    options\n  );\n}\n//#endregion\n\n////////////////////////////////////////////////////////////////////////////////\n//#region UTILS\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * @private\n */\nexport function invariant(value: boolean, message?: string): asserts value;\nexport function invariant<T>(\n  value: T | null | undefined,\n  message?: string\n): asserts value is T;\nexport function invariant(value: any, message?: string) {\n  if (value === false || value === null || typeof value === \"undefined\") {\n    throw new Error(message);\n  }\n}\n\nexport function warning(cond: any, message: string) {\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 history!\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\nfunction createKey() {\n  return Math.random().toString(36).substr(2, 8);\n}\n\n/**\n * For browser-based histories, we combine the state and key into an object\n */\nfunction getHistoryState(location: Location, index: number): HistoryState {\n  return {\n    usr: location.state,\n    key: location.key,\n    idx: index,\n  };\n}\n\n/**\n * Creates a Location object with a unique key from the given Path\n */\nexport function createLocation(\n  current: string | Location,\n  to: To,\n  state: any = null,\n  key?: string\n): Readonly<Location> {\n  let location: Readonly<Location> = {\n    pathname: typeof current === \"string\" ? current : current.pathname,\n    search: \"\",\n    hash: \"\",\n    ...(typeof to === \"string\" ? parsePath(to) : to),\n    state,\n    // TODO: This could be cleaned up.  push/replace should probably just take\n    // full Locations now and avoid the need to run through this flow at all\n    // But that's a pretty big refactor to the current test suite so going to\n    // keep as is for the time being and just let any incoming keys take precedence\n    key: (to && (to as Location).key) || key || createKey(),\n  };\n  return location;\n}\n\n/**\n * Creates a string URL path from the given pathname, search, and hash components.\n */\nexport function createPath({\n  pathname = \"/\",\n  search = \"\",\n  hash = \"\",\n}: Partial<Path>) {\n  if (search && search !== \"?\")\n    pathname += search.charAt(0) === \"?\" ? search : \"?\" + search;\n  if (hash && hash !== \"#\")\n    pathname += hash.charAt(0) === \"#\" ? hash : \"#\" + hash;\n  return pathname;\n}\n\n/**\n * Parses a string URL path into its separate pathname, search, and hash components.\n */\nexport function parsePath(path: string): Partial<Path> {\n  let parsedPath: Partial<Path> = {};\n\n  if (path) {\n    let hashIndex = path.indexOf(\"#\");\n    if (hashIndex >= 0) {\n      parsedPath.hash = path.substr(hashIndex);\n      path = path.substr(0, hashIndex);\n    }\n\n    let searchIndex = path.indexOf(\"?\");\n    if (searchIndex >= 0) {\n      parsedPath.search = path.substr(searchIndex);\n      path = path.substr(0, searchIndex);\n    }\n\n    if (path) {\n      parsedPath.pathname = path;\n    }\n  }\n\n  return parsedPath;\n}\n\nexport interface UrlHistory extends History {}\n\nexport type UrlHistoryOptions = {\n  window?: Window;\n  v5Compat?: boolean;\n};\n\nfunction getUrlBasedHistory(\n  getLocation: (window: Window, globalHistory: Window[\"history\"]) => Location,\n  createHref: (window: Window, to: To) => string,\n  validateLocation: ((location: Location, to: To) => void) | null,\n  options: UrlHistoryOptions = {}\n): UrlHistory {\n  let { window = document.defaultView!, v5Compat = false } = options;\n  let globalHistory = window.history;\n  let action = Action.Pop;\n  let listener: Listener | null = null;\n\n  let index = getIndex()!;\n  // Index should only be null when we initialize. If not, it's because the\n  // user called history.pushState or history.replaceState directly, in which\n  // case we should log a warning as it will result in bugs.\n  if (index == null) {\n    index = 0;\n    globalHistory.replaceState({ ...globalHistory.state, idx: index }, \"\");\n  }\n\n  function getIndex(): number {\n    let state = globalHistory.state || { idx: null };\n    return state.idx;\n  }\n\n  function handlePop() {\n    action = Action.Pop;\n    let nextIndex = getIndex();\n    let delta = nextIndex == null ? null : nextIndex - index;\n    index = nextIndex;\n    if (listener) {\n      listener({ action, location: history.location, delta });\n    }\n  }\n\n  function push(to: To, state?: any) {\n    action = Action.Push;\n    let location = createLocation(history.location, to, state);\n    if (validateLocation) validateLocation(location, to);\n\n    index = getIndex() + 1;\n    let historyState = getHistoryState(location, index);\n    let url = history.createHref(location);\n\n    // try...catch because iOS limits us to 100 pushState calls :/\n    try {\n      globalHistory.pushState(historyState, \"\", url);\n    } catch (error) {\n      // If the exception is because `state` can't be serialized, let that throw\n      // outwards just like a replace call would so the dev knows the cause\n      // https://html.spec.whatwg.org/multipage/nav-history-apis.html#shared-history-push/replace-state-steps\n      // https://html.spec.whatwg.org/multipage/structured-data.html#structuredserializeinternal\n      if (error instanceof DOMException && error.name === \"DataCloneError\") {\n        throw error;\n      }\n      // They are going to lose state here, but there is no real\n      // way to warn them about it since the page will refresh...\n      window.location.assign(url);\n    }\n\n    if (v5Compat && listener) {\n      listener({ action, location: history.location, delta: 1 });\n    }\n  }\n\n  function replace(to: To, state?: any) {\n    action = Action.Replace;\n    let location = createLocation(history.location, to, state);\n    if (validateLocation) validateLocation(location, to);\n\n    index = getIndex();\n    let historyState = getHistoryState(location, index);\n    let url = history.createHref(location);\n    globalHistory.replaceState(historyState, \"\", url);\n\n    if (v5Compat && listener) {\n      listener({ action, location: history.location, delta: 0 });\n    }\n  }\n\n  function createURL(to: To): URL {\n    // window.location.origin is \"null\" (the literal string value) in Firefox\n    // under certain conditions, notably when serving from a local HTML file\n    // See https://bugzilla.mozilla.org/show_bug.cgi?id=878297\n    let base =\n      window.location.origin !== \"null\"\n        ? window.location.origin\n        : window.location.href;\n\n    let href = typeof to === \"string\" ? to : createPath(to);\n    // Treating this as a full URL will strip any trailing spaces so we need to\n    // pre-encode them since they might be part of a matching splat param from\n    // an ancestor route\n    href = href.replace(/ $/, \"%20\");\n    invariant(\n      base,\n      `No window.location.(origin|href) available to create URL for href: ${href}`\n    );\n    return new URL(href, base);\n  }\n\n  let history: History = {\n    get action() {\n      return action;\n    },\n    get location() {\n      return getLocation(window, globalHistory);\n    },\n    listen(fn: Listener) {\n      if (listener) {\n        throw new Error(\"A history only accepts one active listener\");\n      }\n      window.addEventListener(PopStateEventType, handlePop);\n      listener = fn;\n\n      return () => {\n        window.removeEventListener(PopStateEventType, handlePop);\n        listener = null;\n      };\n    },\n    createHref(to) {\n      return createHref(window, to);\n    },\n    createURL,\n    encodeLocation(to) {\n      // Encode a Location the same way window.location would\n      let url = createURL(to);\n      return {\n        pathname: url.pathname,\n        search: url.search,\n        hash: url.hash,\n      };\n    },\n    push,\n    replace,\n    go(n) {\n      return globalHistory.go(n);\n    },\n  };\n\n  return history;\n}\n\n//#endregion\n","import type { Location, Path, To } from \"./history\";\nimport { invariant, parsePath, warning } from \"./history\";\n\n/**\n * Map of routeId -> data returned from a loader/action/error\n */\nexport interface RouteData {\n  [routeId: string]: any;\n}\n\nexport enum ResultType {\n  data = \"data\",\n  deferred = \"deferred\",\n  redirect = \"redirect\",\n  error = \"error\",\n}\n\n/**\n * Successful result from a loader or action\n */\nexport interface SuccessResult {\n  type: ResultType.data;\n  data: unknown;\n  statusCode?: number;\n  headers?: Headers;\n}\n\n/**\n * Successful defer() result from a loader or action\n */\nexport interface DeferredResult {\n  type: ResultType.deferred;\n  deferredData: DeferredData;\n  statusCode?: number;\n  headers?: Headers;\n}\n\n/**\n * Redirect result from a loader or action\n */\nexport interface RedirectResult {\n  type: ResultType.redirect;\n  // We keep the raw Response for redirects so we can return it verbatim\n  response: Response;\n}\n\n/**\n * Unsuccessful result from a loader or action\n */\nexport interface ErrorResult {\n  type: ResultType.error;\n  error: unknown;\n  statusCode?: number;\n  headers?: Headers;\n}\n\n/**\n * Result from a loader or action - potentially successful or unsuccessful\n */\nexport type DataResult =\n  | SuccessResult\n  | DeferredResult\n  | RedirectResult\n  | ErrorResult;\n\ntype LowerCaseFormMethod = \"get\" | \"post\" | \"put\" | \"patch\" | \"delete\";\ntype UpperCaseFormMethod = Uppercase<LowerCaseFormMethod>;\n\n/**\n * Users can specify either lowercase or uppercase form methods on `<Form>`,\n * useSubmit(), `<fetcher.Form>`, etc.\n */\nexport type HTMLFormMethod = LowerCaseFormMethod | UpperCaseFormMethod;\n\n/**\n * Active navigation/fetcher form methods are exposed in lowercase on the\n * RouterState\n */\nexport type FormMethod = LowerCaseFormMethod;\nexport type MutationFormMethod = Exclude<FormMethod, \"get\">;\n\n/**\n * In v7, active navigation/fetcher form methods are exposed in uppercase on the\n * RouterState.  This is to align with the normalization done via fetch().\n */\nexport type V7_FormMethod = UpperCaseFormMethod;\nexport type V7_MutationFormMethod = Exclude<V7_FormMethod, \"GET\">;\n\nexport type FormEncType =\n  | \"application/x-www-form-urlencoded\"\n  | \"multipart/form-data\"\n  | \"application/json\"\n  | \"text/plain\";\n\n// Thanks https://github.com/sindresorhus/type-fest!\ntype JsonObject = { [Key in string]: JsonValue } & {\n  [Key in string]?: JsonValue | undefined;\n};\ntype JsonArray = JsonValue[] | readonly JsonValue[];\ntype JsonPrimitive = string | number | boolean | null;\ntype JsonValue = JsonPrimitive | JsonObject | JsonArray;\n\n/**\n * @private\n * Internal interface to pass around for action submissions, not intended for\n * external consumption\n */\nexport type Submission =\n  | {\n      formMethod: FormMethod | V7_FormMethod;\n      formAction: string;\n      formEncType: FormEncType;\n      formData: FormData;\n      json: undefined;\n      text: undefined;\n    }\n  | {\n      formMethod: FormMethod | V7_FormMethod;\n      formAction: string;\n      formEncType: FormEncType;\n      formData: undefined;\n      json: JsonValue;\n      text: undefined;\n    }\n  | {\n      formMethod: FormMethod | V7_FormMethod;\n      formAction: string;\n      formEncType: FormEncType;\n      formData: undefined;\n      json: undefined;\n      text: string;\n    };\n\n/**\n * @private\n * Arguments passed to route loader/action functions.  Same for now but we keep\n * this as a private implementation detail in case they diverge in the future.\n */\ninterface DataFunctionArgs<Context> {\n  request: Request;\n  params: Params;\n  context?: Context;\n}\n\n// TODO: (v7) Change the defaults from any to unknown in and remove Remix wrappers:\n//   ActionFunction, ActionFunctionArgs, LoaderFunction, LoaderFunctionArgs\n//   Also, make them a type alias instead of an interface\n\n/**\n * Arguments passed to loader functions\n */\nexport interface LoaderFunctionArgs<Context = any>\n  extends DataFunctionArgs<Context> {}\n\n/**\n * Arguments passed to action functions\n */\nexport interface ActionFunctionArgs<Context = any>\n  extends DataFunctionArgs<Context> {}\n\n/**\n * Loaders and actions can return anything except `undefined` (`null` is a\n * valid return value if there is no data to return).  Responses are preferred\n * and will ease any future migration to Remix\n */\ntype DataFunctionValue = Response | NonNullable<unknown> | null;\n\ntype DataFunctionReturnValue = Promise<DataFunctionValue> | DataFunctionValue;\n\n/**\n * Route loader function signature\n */\nexport type LoaderFunction<Context = any> = {\n  (\n    args: LoaderFunctionArgs<Context>,\n    handlerCtx?: unknown\n  ): DataFunctionReturnValue;\n} & { hydrate?: boolean };\n\n/**\n * Route action function signature\n */\nexport interface ActionFunction<Context = any> {\n  (\n    args: ActionFunctionArgs<Context>,\n    handlerCtx?: unknown\n  ): DataFunctionReturnValue;\n}\n\n/**\n * Arguments passed to shouldRevalidate function\n */\nexport interface ShouldRevalidateFunctionArgs {\n  currentUrl: URL;\n  currentParams: AgnosticDataRouteMatch[\"params\"];\n  nextUrl: URL;\n  nextParams: AgnosticDataRouteMatch[\"params\"];\n  formMethod?: Submission[\"formMethod\"];\n  formAction?: Submission[\"formAction\"];\n  formEncType?: Submission[\"formEncType\"];\n  text?: Submission[\"text\"];\n  formData?: Submission[\"formData\"];\n  json?: Submission[\"json\"];\n  actionStatus?: number;\n  actionResult?: any;\n  defaultShouldRevalidate: boolean;\n}\n\n/**\n * Route shouldRevalidate function signature.  This runs after any submission\n * (navigation or fetcher), so we flatten the navigation/fetcher submission\n * onto the arguments.  It shouldn't matter whether it came from a navigation\n * or a fetcher, what really matters is the URLs and the formData since loaders\n * have to re-run based on the data models that were potentially mutated.\n */\nexport interface ShouldRevalidateFunction {\n  (args: ShouldRevalidateFunctionArgs): boolean;\n}\n\n/**\n * Function provided by the framework-aware layers to set `hasErrorBoundary`\n * from the framework-aware `errorElement` prop\n *\n * @deprecated Use `mapRouteProperties` instead\n */\nexport interface DetectErrorBoundaryFunction {\n  (route: AgnosticRouteObject): boolean;\n}\n\nexport interface DataStrategyMatch\n  extends AgnosticRouteMatch<string, AgnosticDataRouteObject> {\n  shouldLoad: boolean;\n  resolve: (\n    handlerOverride?: (\n      handler: (ctx?: unknown) => DataFunctionReturnValue\n    ) => DataFunctionReturnValue\n  ) => Promise<DataStrategyResult>;\n}\n\nexport interface DataStrategyFunctionArgs<Context = any>\n  extends DataFunctionArgs<Context> {\n  matches: DataStrategyMatch[];\n  fetcherKey: string | null;\n}\n\n/**\n * Result from a loader or action called via dataStrategy\n */\nexport interface DataStrategyResult {\n  type: \"data\" | \"error\";\n  result: unknown; // data, Error, Response, DeferredData, DataWithResponseInit\n}\n\nexport interface DataStrategyFunction {\n  (args: DataStrategyFunctionArgs): Promise<Record<string, DataStrategyResult>>;\n}\n\nexport type AgnosticPatchRoutesOnNavigationFunctionArgs<\n  O extends AgnosticRouteObject = AgnosticRouteObject,\n  M extends AgnosticRouteMatch = AgnosticRouteMatch\n> = {\n  signal: AbortSignal;\n  path: string;\n  matches: M[];\n  fetcherKey: string | undefined;\n  patch: (routeId: string | null, children: O[]) => void;\n};\n\nexport type AgnosticPatchRoutesOnNavigationFunction<\n  O extends AgnosticRouteObject = AgnosticRouteObject,\n  M extends AgnosticRouteMatch = AgnosticRouteMatch\n> = (\n  opts: AgnosticPatchRoutesOnNavigationFunctionArgs<O, M>\n) => void | Promise<void>;\n\n/**\n * Function provided by the framework-aware layers to set any framework-specific\n * properties from framework-agnostic properties\n */\nexport interface MapRoutePropertiesFunction {\n  (route: AgnosticRouteObject): {\n    hasErrorBoundary: boolean;\n  } & Record<string, any>;\n}\n\n/**\n * Keys we cannot change from within a lazy() function. We spread all other keys\n * onto the route. Either they're meaningful to the router, or they'll get\n * ignored.\n */\nexport type ImmutableRouteKey =\n  | \"lazy\"\n  | \"caseSensitive\"\n  | \"path\"\n  | \"id\"\n  | \"index\"\n  | \"children\";\n\nexport const immutableRouteKeys = new Set<ImmutableRouteKey>([\n  \"lazy\",\n  \"caseSensitive\",\n  \"path\",\n  \"id\",\n  \"index\",\n  \"children\",\n]);\n\ntype RequireOne<T, Key = keyof T> = Exclude<\n  {\n    [K in keyof T]: K extends Key ? Omit<T, K> & Required<Pick<T, K>> : never;\n  }[keyof T],\n  undefined\n>;\n\n/**\n * lazy() function to load a route definition, which can add non-matching\n * related properties to a route\n */\nexport interface LazyRouteFunction<R extends AgnosticRouteObject> {\n  (): Promise<RequireOne<Omit<R, ImmutableRouteKey>>>;\n}\n\n/**\n * Base RouteObject with common props shared by all types of routes\n */\ntype AgnosticBaseRouteObject = {\n  caseSensitive?: boolean;\n  path?: string;\n  id?: string;\n  loader?: LoaderFunction | boolean;\n  action?: ActionFunction | boolean;\n  hasErrorBoundary?: boolean;\n  shouldRevalidate?: ShouldRevalidateFunction;\n  handle?: any;\n  lazy?: LazyRouteFunction<AgnosticBaseRouteObject>;\n};\n\n/**\n * Index routes must not have children\n */\nexport type AgnosticIndexRouteObject = AgnosticBaseRouteObject & {\n  children?: undefined;\n  index: true;\n};\n\n/**\n * Non-index routes may have children, but cannot have index\n */\nexport type AgnosticNonIndexRouteObject = AgnosticBaseRouteObject & {\n  children?: AgnosticRouteObject[];\n  index?: false;\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 type AgnosticRouteObject =\n  | AgnosticIndexRouteObject\n  | AgnosticNonIndexRouteObject;\n\nexport type AgnosticDataIndexRouteObject = AgnosticIndexRouteObject & {\n  id: string;\n};\n\nexport type AgnosticDataNonIndexRouteObject = AgnosticNonIndexRouteObject & {\n  children?: AgnosticDataRouteObject[];\n  id: string;\n};\n\n/**\n * A data route object, which is just a RouteObject with a required unique ID\n */\nexport type AgnosticDataRouteObject =\n  | AgnosticDataIndexRouteObject\n  | AgnosticDataNonIndexRouteObject;\n\nexport type RouteManifest = Record<string, AgnosticDataRouteObject | undefined>;\n\n// Recursive helper for finding path parameters in the absence of wildcards\ntype _PathParam<Path extends string> =\n  // split path into individual path segments\n  Path extends `${infer L}/${infer R}`\n    ? _PathParam<L> | _PathParam<R>\n    : // find params after `:`\n    Path extends `:${infer Param}`\n    ? Param extends `${infer Optional}?`\n      ? Optional\n      : Param\n    : // otherwise, there aren't any params present\n      never;\n\n/**\n * Examples:\n * \"/a/b/*\" -> \"*\"\n * \":a\" -> \"a\"\n * \"/a/:b\" -> \"b\"\n * \"/a/blahblahblah:b\" -> \"b\"\n * \"/:a/:b\" -> \"a\" | \"b\"\n * \"/:a/b/:c/*\" -> \"a\" | \"c\" | \"*\"\n */\nexport type PathParam<Path extends string> =\n  // check if path is just a wildcard\n  Path extends \"*\" | \"/*\"\n    ? \"*\"\n    : // look for wildcard at the end of the path\n    Path extends `${infer Rest}/*`\n    ? \"*\" | _PathParam<Rest>\n    : // look for params in the absence of wildcards\n      _PathParam<Path>;\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.\nexport type ParamParseKey<Segment extends string> =\n  // if you could not find path params, fallback to `string`\n  [PathParam<Segment>] extends [never] ? string : PathParam<Segment>;\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 RouteMatch contains info about how a route matched a URL.\n */\nexport interface AgnosticRouteMatch<\n  ParamKey extends string = string,\n  RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject\n> {\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: RouteObjectType;\n}\n\nexport interface AgnosticDataRouteMatch\n  extends AgnosticRouteMatch<string, AgnosticDataRouteObject> {}\n\nfunction isIndexRoute(\n  route: AgnosticRouteObject\n): route is AgnosticIndexRouteObject {\n  return route.index === true;\n}\n\n// Walk the route tree generating unique IDs where necessary, so we are working\n// solely with AgnosticDataRouteObject's within the Router\nexport function convertRoutesToDataRoutes(\n  routes: AgnosticRouteObject[],\n  mapRouteProperties: MapRoutePropertiesFunction,\n  parentPath: string[] = [],\n  manifest: RouteManifest = {}\n): AgnosticDataRouteObject[] {\n  return routes.map((route, index) => {\n    let treePath = [...parentPath, String(index)];\n    let id = typeof route.id === \"string\" ? route.id : treePath.join(\"-\");\n    invariant(\n      route.index !== true || !route.children,\n      `Cannot specify children on an index route`\n    );\n    invariant(\n      !manifest[id],\n      `Found a route id collision on id \"${id}\".  Route ` +\n        \"id's must be globally unique within Data Router usages\"\n    );\n\n    if (isIndexRoute(route)) {\n      let indexRoute: AgnosticDataIndexRouteObject = {\n        ...route,\n        ...mapRouteProperties(route),\n        id,\n      };\n      manifest[id] = indexRoute;\n      return indexRoute;\n    } else {\n      let pathOrLayoutRoute: AgnosticDataNonIndexRouteObject = {\n        ...route,\n        ...mapRouteProperties(route),\n        id,\n        children: undefined,\n      };\n      manifest[id] = pathOrLayoutRoute;\n\n      if (route.children) {\n        pathOrLayoutRoute.children = convertRoutesToDataRoutes(\n          route.children,\n          mapRouteProperties,\n          treePath,\n          manifest\n        );\n      }\n\n      return pathOrLayoutRoute;\n    }\n  });\n}\n\n/**\n * Matches the given routes to a location and returns the match data.\n *\n * @see https://reactrouter.com/v6/utils/match-routes\n */\nexport function matchRoutes<\n  RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject\n>(\n  routes: RouteObjectType[],\n  locationArg: Partial<Location> | string,\n  basename = \"/\"\n): AgnosticRouteMatch<string, RouteObjectType>[] | null {\n  return matchRoutesImpl(routes, locationArg, basename, false);\n}\n\nexport function matchRoutesImpl<\n  RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject\n>(\n  routes: RouteObjectType[],\n  locationArg: Partial<Location> | string,\n  basename: string,\n  allowPartial: boolean\n): AgnosticRouteMatch<string, RouteObjectType>[] | 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    // Incoming pathnames are generally encoded from either window.location\n    // or from router.navigate, but we want to match against the unencoded\n    // paths in the route definitions.  Memory router locations won't be\n    // encoded here but there also shouldn't be anything to decode so this\n    // should be a safe operation.  This avoids needing matchRoutes to be\n    // history-aware.\n    let decoded = decodePath(pathname);\n    matches = matchRouteBranch<string, RouteObjectType>(\n      branches[i],\n      decoded,\n      allowPartial\n    );\n  }\n\n  return matches;\n}\n\nexport interface UIMatch<Data = unknown, Handle = unknown> {\n  id: string;\n  pathname: string;\n  params: AgnosticRouteMatch[\"params\"];\n  data: Data;\n  handle: Handle;\n}\n\nexport function convertRouteMatchToUiMatch(\n  match: AgnosticDataRouteMatch,\n  loaderData: RouteData\n): UIMatch {\n  let { route, pathname, params } = match;\n  return {\n    id: route.id,\n    pathname,\n    params,\n    data: loaderData[route.id],\n    handle: route.handle,\n  };\n}\n\ninterface RouteMeta<\n  RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject\n> {\n  relativePath: string;\n  caseSensitive: boolean;\n  childrenIndex: number;\n  route: RouteObjectType;\n}\n\ninterface RouteBranch<\n  RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject\n> {\n  path: string;\n  score: number;\n  routesMeta: RouteMeta<RouteObjectType>[];\n}\n\nfunction flattenRoutes<\n  RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject\n>(\n  routes: RouteObjectType[],\n  branches: RouteBranch<RouteObjectType>[] = [],\n  parentsMeta: RouteMeta<RouteObjectType>[] = [],\n  parentPath = \"\"\n): RouteBranch<RouteObjectType>[] {\n  let flattenRoute = (\n    route: RouteObjectType,\n    index: number,\n    relativePath?: string\n  ) => {\n    let meta: RouteMeta<RouteObjectType> = {\n      relativePath:\n        relativePath === undefined ? route.path || \"\" : relativePath,\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        // Our types know better, but runtime JS may not!\n        // @ts-expect-error\n        route.index !== true,\n        `Index routes must not have child routes. Please remove ` +\n          `all child routes from route path \"${path}\".`\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({\n      path,\n      score: computeScore(path, route.index),\n      routesMeta,\n    });\n  };\n  routes.forEach((route, index) => {\n    // coarse-grain check for optional params\n    if (route.path === \"\" || !route.path?.includes(\"?\")) {\n      flattenRoute(route, index);\n    } else {\n      for (let exploded of explodeOptionalSegments(route.path)) {\n        flattenRoute(route, index, exploded);\n      }\n    }\n  });\n\n  return branches;\n}\n\n/**\n * Computes all combinations of optional path segments for a given path,\n * excluding combinations that are ambiguous and of lower priority.\n *\n * For example, `/one/:two?/three/:four?/:five?` explodes to:\n * - `/one/three`\n * - `/one/:two/three`\n * - `/one/three/:four`\n * - `/one/three/:five`\n * - `/one/:two/three/:four`\n * - `/one/:two/three/:five`\n * - `/one/three/:four/:five`\n * - `/one/:two/three/:four/:five`\n */\nfunction explodeOptionalSegments(path: string): string[] {\n  let segments = path.split(\"/\");\n  if (segments.length === 0) return [];\n\n  let [first, ...rest] = segments;\n\n  // Optional path segments are denoted by a trailing `?`\n  let isOptional = first.endsWith(\"?\");\n  // Compute the corresponding required segment: `foo?` -> `foo`\n  let required = first.replace(/\\?$/, \"\");\n\n  if (rest.length === 0) {\n    // Intepret empty string as omitting an optional segment\n    // `[\"one\", \"\", \"three\"]` corresponds to omitting `:two` from `/one/:two?/three` -> `/one/three`\n    return isOptional ? [required, \"\"] : [required];\n  }\n\n  let restExploded = explodeOptionalSegments(rest.join(\"/\"));\n\n  let result: string[] = [];\n\n  // All child paths with the prefix.  Do this for all children before the\n  // optional version for all children, so we get consistent ordering where the\n  // parent optional aspect is preferred as required.  Otherwise, we can get\n  // child sections interspersed where deeper optional segments are higher than\n  // parent optional segments, where for example, /:two would explode _earlier_\n  // then /:one.  By always including the parent as required _for all children_\n  // first, we avoid this issue\n  result.push(\n    ...restExploded.map((subpath) =>\n      subpath === \"\" ? required : [required, subpath].join(\"/\")\n    )\n  );\n\n  // Then, if this is an optional value, add all child versions without\n  if (isOptional) {\n    result.push(...restExploded);\n  }\n\n  // for absolute paths, ensure `/` instead of empty segment\n  return result.map((exploded) =>\n    path.startsWith(\"/\") && exploded === \"\" ? \"/\" : exploded\n  );\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<\n  ParamKey extends string = string,\n  RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject\n>(\n  branch: RouteBranch<RouteObjectType>,\n  pathname: string,\n  allowPartial = false\n): AgnosticRouteMatch<ParamKey, RouteObjectType>[] | null {\n  let { routesMeta } = branch;\n\n  let matchedParams = {};\n  let matchedPathname = \"/\";\n  let matches: AgnosticRouteMatch<ParamKey, RouteObjectType>[] = [];\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    let route = meta.route;\n\n    if (\n      !match &&\n      end &&\n      allowPartial &&\n      !routesMeta[routesMeta.length - 1].route.index\n    ) {\n      match = matchPath(\n        {\n          path: meta.relativePath,\n          caseSensitive: meta.caseSensitive,\n          end: false,\n        },\n        remainingPathname\n      );\n    }\n\n    if (!match) {\n      return null;\n    }\n\n    Object.assign(matchedParams, match.params);\n\n    matches.push({\n      // TODO: Can this as be avoided?\n      params: matchedParams as Params<ParamKey>,\n      pathname: joinPaths([matchedPathname, match.pathname]),\n      pathnameBase: normalizePathname(\n        joinPaths([matchedPathname, match.pathnameBase])\n      ),\n      route,\n    });\n\n    if (match.pathnameBase !== \"/\") {\n      matchedPathname = joinPaths([matchedPathname, match.pathnameBase]);\n    }\n  }\n\n  return matches;\n}\n\n/**\n * Returns a path with params interpolated.\n *\n * @see https://reactrouter.com/v6/utils/generate-path\n */\nexport function generatePath<Path extends string>(\n  originalPath: Path,\n  params: {\n    [key in PathParam<Path>]: string | null;\n  } = {} as any\n): string {\n  let path: string = originalPath;\n  if (path.endsWith(\"*\") && path !== \"*\" && !path.endsWith(\"/*\")) {\n    warning(\n      false,\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    path = path.replace(/\\*$/, \"/*\") as Path;\n  }\n\n  // ensure `/` is added at the beginning if the path is absolute\n  const prefix = path.startsWith(\"/\") ? \"/\" : \"\";\n\n  const stringify = (p: any) =>\n    p == null ? \"\" : typeof p === \"string\" ? p : String(p);\n\n  const segments = path\n    .split(/\\/+/)\n    .map((segment, index, array) => {\n      const isLastSegment = index === array.length - 1;\n\n      // only apply the splat if it's the last segment\n      if (isLastSegment && segment === \"*\") {\n        const star = \"*\" as PathParam<Path>;\n        // Apply the splat\n        return stringify(params[star]);\n      }\n\n      const keyMatch = segment.match(/^:([\\w-]+)(\\??)$/);\n      if (keyMatch) {\n        const [, key, optional] = keyMatch;\n        let param = params[key as PathParam<Path>];\n        invariant(optional === \"?\" || param != null, `Missing \":${key}\" param`);\n        return stringify(param);\n      }\n\n      // Remove any optional markers from optional static segments\n      return segment.replace(/\\?$/g, \"\");\n    })\n    // Remove empty segments\n    .filter((segment) => !!segment);\n\n  return prefix + segments.join(\"/\");\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/v6/utils/match-path\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, compiledParams] = 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 = compiledParams.reduce<Mutable<Params>>(\n    (memo, { paramName, isOptional }, 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      const value = captureGroups[index];\n      if (isOptional && !value) {\n        memo[paramName] = undefined;\n      } else {\n        memo[paramName] = (value || \"\").replace(/%2F/g, \"/\");\n      }\n      return memo;\n    },\n    {}\n  );\n\n  return {\n    params,\n    pathname: matchedPathname,\n    pathnameBase,\n    pattern,\n  };\n}\n\ntype CompiledPathParam = { paramName: string; isOptional?: boolean };\n\nfunction compilePath(\n  path: string,\n  caseSensitive = false,\n  end = true\n): [RegExp, CompiledPathParam[]] {\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 params: CompiledPathParam[] = [];\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(\n        /\\/:([\\w-]+)(\\?)?/g,\n        (_: string, paramName: string, isOptional) => {\n          params.push({ paramName, isOptional: isOptional != null });\n          return isOptional ? \"/?([^\\\\/]+)?\" : \"/([^\\\\/]+)\";\n        }\n      );\n\n  if (path.endsWith(\"*\")) {\n    params.push({ paramName: \"*\" });\n    regexpSource +=\n      path === \"*\" || path === \"/*\"\n        ? \"(.*)$\" // Already matched the initial /, just match the rest\n        : \"(?:\\\\/(.+)|\\\\/*)$\"; // Don't include the / in params[\"*\"]\n  } else if (end) {\n    // When matching to the end, ignore trailing slashes\n    regexpSource += \"\\\\/*$\";\n  } else if (path !== \"\" && path !== \"/\") {\n    // If our path is non-empty and contains anything beyond an initial slash,\n    // then we have _some_ form of path in our regex, so we should expect to\n    // match only if we find the end of this path segment.  Look for an optional\n    // non-captured trailing slash (to match a portion of the URL) or the end\n    // of the path (if we've matched to the end).  We used to do this with a\n    // word boundary but that gives false positives on routes like\n    // /user-preferences since `-` counts as a word boundary.\n    regexpSource += \"(?:(?=\\\\/|$))\";\n  } else {\n    // Nothing to match for \"\" or \"/\"\n  }\n\n  let matcher = new RegExp(regexpSource, caseSensitive ? undefined : \"i\");\n\n  return [matcher, params];\n}\n\nexport function decodePath(value: string) {\n  try {\n    return value\n      .split(\"/\")\n      .map((v) => decodeURIComponent(v).replace(/\\//g, \"%2F\"))\n      .join(\"/\");\n  } catch (error) {\n    warning(\n      false,\n      `The URL path \"${value}\" could not be decoded because it is is a ` +\n        `malformed URL segment. This is probably due to a bad percent ` +\n        `encoding (${error}).`\n    );\n\n    return value;\n  }\n}\n\n/**\n * @private\n */\nexport function stripBasename(\n  pathname: string,\n  basename: string\n): string | null {\n  if (basename === \"/\") return pathname;\n\n  if (!pathname.toLowerCase().startsWith(basename.toLowerCase())) {\n    return null;\n  }\n\n  // We want to leave trailing slash behavior in the user's control, so if they\n  // specify a basename with a trailing slash, we should support it\n  let startIndex = basename.endsWith(\"/\")\n    ? basename.length - 1\n    : basename.length;\n  let nextChar = pathname.charAt(startIndex);\n  if (nextChar && nextChar !== \"/\") {\n    // pathname does not start with basename/\n    return null;\n  }\n\n  return pathname.slice(startIndex) || \"/\";\n}\n\nconst ABSOLUTE_URL_REGEX = /^(?:[a-z][a-z0-9+.-]*:|\\/\\/)/i;\nexport const isAbsoluteUrl = (url: string) => ABSOLUTE_URL_REGEX.test(url);\n\n/**\n * Returns a resolved path object relative to the given pathname.\n *\n * @see https://reactrouter.com/v6/utils/resolve-path\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: string;\n  if (toPathname) {\n    if (isAbsoluteUrl(toPathname)) {\n      pathname = toPathname;\n    } else {\n      if (toPathname.includes(\"//\")) {\n        let oldPathname = toPathname;\n        toPathname = toPathname.replace(/\\/\\/+/g, \"/\");\n        warning(\n          false,\n          `Pathnames cannot have embedded double slashes - normalizing ` +\n            `${oldPathname} -> ${toPathname}`\n        );\n      }\n      if (toPathname.startsWith(\"/\")) {\n        pathname = resolvePathname(toPathname.substring(1), \"/\");\n      } else {\n        pathname = resolvePathname(toPathname, fromPathname);\n      }\n    }\n  } else {\n    pathname = fromPathname;\n  }\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 getInvalidPathError(\n  char: string,\n  field: string,\n  dest: string,\n  path: Partial<Path>\n) {\n  return (\n    `Cannot include a '${char}' character in a manually specified ` +\n    `\\`to.${field}\\` field [${JSON.stringify(\n      path\n    )}].  Please separate it out to the ` +\n    `\\`to.${dest}\\` field. Alternatively you may provide the full path as ` +\n    `a string in <Link to=\"...\"> and the router will parse it for you.`\n  );\n}\n\n/**\n * @private\n *\n * When processing relative navigation we want to ignore ancestor routes that\n * do not contribute to the path, such that index/pathless layout routes don't\n * interfere.\n *\n * For example, when moving a route element into an index route and/or a\n * pathless layout route, relative link behavior contained within should stay\n * the same.  Both of the following examples should link back to the root:\n *\n *   <Route path=\"/\">\n *     <Route path=\"accounts\" element={<Link to=\"..\"}>\n *   </Route>\n *\n *   <Route path=\"/\">\n *     <Route path=\"accounts\">\n *       <Route element={<AccountsLayout />}>       // <-- Does not contribute\n *         <Route index element={<Link to=\"..\"} />  // <-- Does not contribute\n *       </Route\n *     </Route>\n *   </Route>\n */\nexport function getPathContributingMatches<\n  T extends AgnosticRouteMatch = AgnosticRouteMatch\n>(matches: T[]) {\n  return matches.filter(\n    (match, index) =>\n      index === 0 || (match.route.path && match.route.path.length > 0)\n  );\n}\n\n// Return the array of pathnames for the current route matches - used to\n// generate the routePathnames input for resolveTo()\nexport function getResolveToMatches<\n  T extends AgnosticRouteMatch = AgnosticRouteMatch\n>(matches: T[], v7_relativeSplatPath: boolean) {\n  let pathMatches = getPathContributingMatches(matches);\n\n  // When v7_relativeSplatPath is enabled, use the full pathname for the leaf\n  // match so we include splat values for \".\" links.  See:\n  // https://github.com/remix-run/react-router/issues/11052#issuecomment-1836589329\n  if (v7_relativeSplatPath) {\n    return pathMatches.map((match, idx) =>\n      idx === pathMatches.length - 1 ? match.pathname : match.pathnameBase\n    );\n  }\n\n  return pathMatches.map((match) => match.pathnameBase);\n}\n\n/**\n * @private\n */\nexport function resolveTo(\n  toArg: To,\n  routePathnames: string[],\n  locationPathname: string,\n  isPathRelative = false\n): Path {\n  let to: Partial<Path>;\n  if (typeof toArg === \"string\") {\n    to = parsePath(toArg);\n  } else {\n    to = { ...toArg };\n\n    invariant(\n      !to.pathname || !to.pathname.includes(\"?\"),\n      getInvalidPathError(\"?\", \"pathname\", \"search\", to)\n    );\n    invariant(\n      !to.pathname || !to.pathname.includes(\"#\"),\n      getInvalidPathError(\"#\", \"pathname\", \"hash\", to)\n    );\n    invariant(\n      !to.search || !to.search.includes(\"#\"),\n      getInvalidPathError(\"#\", \"search\", \"hash\", to)\n    );\n  }\n\n  let isEmptyPath = toArg === \"\" || to.pathname === \"\";\n  let toPathname = isEmptyPath ? \"/\" : to.pathname;\n\n  let from: string;\n\n  // Routing is relative to the current pathname if explicitly requested.\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  if (toPathname == null) {\n    from = locationPathname;\n  } else {\n    let routePathnameIndex = routePathnames.length - 1;\n\n    // With relative=\"route\" (the default), each leading .. segment means\n    // \"go up one route\" instead of \"go up one URL segment\".  This is a key\n    // difference from how <a href> works and a major reason we call this a\n    // \"to\" value instead of a \"href\".\n    if (!isPathRelative && toPathname.startsWith(\"..\")) {\n      let toSegments = toPathname.split(\"/\");\n\n      while (toSegments[0] === \"..\") {\n        toSegments.shift();\n        routePathnameIndex -= 1;\n      }\n\n      to.pathname = toSegments.join(\"/\");\n    }\n\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\" had one\n  let hasExplicitTrailingSlash =\n    toPathname && toPathname !== \"/\" && toPathname.endsWith(\"/\");\n  // Or if this was a link to the current path which has a trailing slash\n  let hasCurrentTrailingSlash =\n    (isEmptyPath || toPathname === \".\") && locationPathname.endsWith(\"/\");\n  if (\n    !path.pathname.endsWith(\"/\") &&\n    (hasExplicitTrailingSlash || hasCurrentTrailingSlash)\n  ) {\n    path.pathname += \"/\";\n  }\n\n  return path;\n}\n\n/**\n * @private\n */\nexport function 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\n/**\n * @private\n */\nexport const joinPaths = (paths: string[]): string =>\n  paths.join(\"/\").replace(/\\/\\/+/g, \"/\");\n\n/**\n * @private\n */\nexport const normalizePathname = (pathname: string): string =>\n  pathname.replace(/\\/+$/, \"\").replace(/^\\/*/, \"/\");\n\n/**\n * @private\n */\nexport const normalizeSearch = (search: string): string =>\n  !search || search === \"?\"\n    ? \"\"\n    : search.startsWith(\"?\")\n    ? search\n    : \"?\" + search;\n\n/**\n * @private\n */\nexport const normalizeHash = (hash: string): string =>\n  !hash || hash === \"#\" ? \"\" : hash.startsWith(\"#\") ? hash : \"#\" + hash;\n\nexport type JsonFunction = <Data>(\n  data: Data,\n  init?: number | ResponseInit\n) => Response;\n\n/**\n * This is a shortcut for creating `application/json` responses. Converts `data`\n * to JSON and sets the `Content-Type` header.\n *\n * @deprecated The `json` method is deprecated in favor of returning raw objects.\n * This method will be removed in v7.\n */\nexport const json: JsonFunction = (data, init = {}) => {\n  let responseInit = typeof init === \"number\" ? { status: init } : init;\n\n  let headers = new Headers(responseInit.headers);\n  if (!headers.has(\"Content-Type\")) {\n    headers.set(\"Content-Type\", \"application/json; charset=utf-8\");\n  }\n\n  return new Response(JSON.stringify(data), {\n    ...responseInit,\n    headers,\n  });\n};\n\nexport class DataWithResponseInit<D> {\n  type: string = \"DataWithResponseInit\";\n  data: D;\n  init: ResponseInit | null;\n\n  constructor(data: D, init?: ResponseInit) {\n    this.data = data;\n    this.init = init || null;\n  }\n}\n\n/**\n * Create \"responses\" that contain `status`/`headers` without forcing\n * serialization into an actual `Response` - used by Remix single fetch\n */\nexport function data<D>(data: D, init?: number | ResponseInit) {\n  return new DataWithResponseInit(\n    data,\n    typeof init === \"number\" ? { status: init } : init\n  );\n}\n\nexport interface TrackedPromise extends Promise<any> {\n  _tracked?: boolean;\n  _data?: any;\n  _error?: any;\n}\n\nexport class AbortedDeferredError extends Error {}\n\nexport class DeferredData {\n  private pendingKeysSet: Set<string> = new Set<string>();\n  private controller: AbortController;\n  private abortPromise: Promise<void>;\n  private unlistenAbortSignal: () => void;\n  private subscribers: Set<(aborted: boolean, settledKey?: string) => void> =\n    new Set();\n  data: Record<string, unknown>;\n  init?: ResponseInit;\n  deferredKeys: string[] = [];\n\n  constructor(data: Record<string, unknown>, responseInit?: ResponseInit) {\n    invariant(\n      data && typeof data === \"object\" && !Array.isArray(data),\n      \"defer() only accepts plain objects\"\n    );\n\n    // Set up an AbortController + Promise we can race against to exit early\n    // cancellation\n    let reject: (e: AbortedDeferredError) => void;\n    this.abortPromise = new Promise((_, r) => (reject = r));\n    this.controller = new AbortController();\n    let onAbort = () =>\n      reject(new AbortedDeferredError(\"Deferred data aborted\"));\n    this.unlistenAbortSignal = () =>\n      this.controller.signal.removeEventListener(\"abort\", onAbort);\n    this.controller.signal.addEventListener(\"abort\", onAbort);\n\n    this.data = Object.entries(data).reduce(\n      (acc, [key, value]) =>\n        Object.assign(acc, {\n          [key]: this.trackPromise(key, value),\n        }),\n      {}\n    );\n\n    if (this.done) {\n      // All incoming values were resolved\n      this.unlistenAbortSignal();\n    }\n\n    this.init = responseInit;\n  }\n\n  private trackPromise(\n    key: string,\n    value: Promise<unknown> | unknown\n  ): TrackedPromise | unknown {\n    if (!(value instanceof Promise)) {\n      return value;\n    }\n\n    this.deferredKeys.push(key);\n    this.pendingKeysSet.add(key);\n\n    // We store a little wrapper promise that will be extended with\n    // _data/_error props upon resolve/reject\n    let promise: TrackedPromise = Promise.race([value, this.abortPromise]).then(\n      (data) => this.onSettle(promise, key, undefined, data as unknown),\n      (error) => this.onSettle(promise, key, error as unknown)\n    );\n\n    // Register rejection listeners to avoid uncaught promise rejections on\n    // errors or aborted deferred values\n    promise.catch(() => {});\n\n    Object.defineProperty(promise, \"_tracked\", { get: () => true });\n    return promise;\n  }\n\n  private onSettle(\n    promise: TrackedPromise,\n    key: string,\n    error: unknown,\n    data?: unknown\n  ): unknown {\n    if (\n      this.controller.signal.aborted &&\n      error instanceof AbortedDeferredError\n    ) {\n      this.unlistenAbortSignal();\n      Object.defineProperty(promise, \"_error\", { get: () => error });\n      return Promise.reject(error);\n    }\n\n    this.pendingKeysSet.delete(key);\n\n    if (this.done) {\n      // Nothing left to abort!\n      this.unlistenAbortSignal();\n    }\n\n    // If the promise was resolved/rejected with undefined, we'll throw an error as you\n    // should always resolve with a value or null\n    if (error === undefined && data === undefined) {\n      let undefinedError = new Error(\n        `Deferred data for key \"${key}\" resolved/rejected with \\`undefined\\`, ` +\n          `you must resolve/reject with a value or \\`null\\`.`\n      );\n      Object.defineProperty(promise, \"_error\", { get: () => undefinedError });\n      this.emit(false, key);\n      return Promise.reject(undefinedError);\n    }\n\n    if (data === undefined) {\n      Object.defineProperty(promise, \"_error\", { get: () => error });\n      this.emit(false, key);\n      return Promise.reject(error);\n    }\n\n    Object.defineProperty(promise, \"_data\", { get: () => data });\n    this.emit(false, key);\n    return data;\n  }\n\n  private emit(aborted: boolean, settledKey?: string) {\n    this.subscribers.forEach((subscriber) => subscriber(aborted, settledKey));\n  }\n\n  subscribe(fn: (aborted: boolean, settledKey?: string) => void) {\n    this.subscribers.add(fn);\n    return () => this.subscribers.delete(fn);\n  }\n\n  cancel() {\n    this.controller.abort();\n    this.pendingKeysSet.forEach((v, k) => this.pendingKeysSet.delete(k));\n    this.emit(true);\n  }\n\n  async resolveData(signal: AbortSignal) {\n    let aborted = false;\n    if (!this.done) {\n      let onAbort = () => this.cancel();\n      signal.addEventListener(\"abort\", onAbort);\n      aborted = await new Promise((resolve) => {\n        this.subscribe((aborted) => {\n          signal.removeEventListener(\"abort\", onAbort);\n          if (aborted || this.done) {\n            resolve(aborted);\n          }\n        });\n      });\n    }\n    return aborted;\n  }\n\n  get done() {\n    return this.pendingKeysSet.size === 0;\n  }\n\n  get unwrappedData() {\n    invariant(\n      this.data !== null && this.done,\n      \"Can only unwrap data on initialized and settled deferreds\"\n    );\n\n    return Object.entries(this.data).reduce(\n      (acc, [key, value]) =>\n        Object.assign(acc, {\n          [key]: unwrapTrackedPromise(value),\n        }),\n      {}\n    );\n  }\n\n  get pendingKeys() {\n    return Array.from(this.pendingKeysSet);\n  }\n}\n\nfunction isTrackedPromise(value: any): value is TrackedPromise {\n  return (\n    value instanceof Promise && (value as TrackedPromise)._tracked === true\n  );\n}\n\nfunction unwrapTrackedPromise(value: any) {\n  if (!isTrackedPromise(value)) {\n    return value;\n  }\n\n  if (value._error) {\n    throw value._error;\n  }\n  return value._data;\n}\n\nexport type DeferFunction = (\n  data: Record<string, unknown>,\n  init?: number | ResponseInit\n) => DeferredData;\n\n/**\n * @deprecated The `defer` method is deprecated in favor of returning raw\n * objects. This method will be removed in v7.\n */\nexport const defer: DeferFunction = (data, init = {}) => {\n  let responseInit = typeof init === \"number\" ? { status: init } : init;\n\n  return new DeferredData(data, responseInit);\n};\n\nexport type RedirectFunction = (\n  url: string,\n  init?: number | ResponseInit\n) => Response;\n\n/**\n * A redirect response. Sets the status code and the `Location` header.\n * Defaults to \"302 Found\".\n */\nexport const redirect: RedirectFunction = (url, init = 302) => {\n  let responseInit = init;\n  if (typeof responseInit === \"number\") {\n    responseInit = { status: responseInit };\n  } else if (typeof responseInit.status === \"undefined\") {\n    responseInit.status = 302;\n  }\n\n  let headers = new Headers(responseInit.headers);\n  headers.set(\"Location\", url);\n\n  return new Response(null, {\n    ...responseInit,\n    headers,\n  });\n};\n\n/**\n * A redirect response that will force a document reload to the new location.\n * Sets the status code and the `Location` header.\n * Defaults to \"302 Found\".\n */\nexport const redirectDocument: RedirectFunction = (url, init) => {\n  let response = redirect(url, init);\n  response.headers.set(\"X-Remix-Reload-Document\", \"true\");\n  return response;\n};\n\n/**\n * A redirect response that will perform a `history.replaceState` instead of a\n * `history.pushState` for client-side navigation redirects.\n * Sets the status code and the `Location` header.\n * Defaults to \"302 Found\".\n */\nexport const replace: RedirectFunction = (url, init) => {\n  let response = redirect(url, init);\n  response.headers.set(\"X-Remix-Replace\", \"true\");\n  return response;\n};\n\nexport type ErrorResponse = {\n  status: number;\n  statusText: string;\n  data: any;\n};\n\n/**\n * @private\n * Utility class we use to hold auto-unwrapped 4xx/5xx Response bodies\n *\n * We don't export the class for public use since it's an implementation\n * detail, but we export the interface above so folks can build their own\n * abstractions around instances via isRouteErrorResponse()\n */\nexport class ErrorResponseImpl implements ErrorResponse {\n  status: number;\n  statusText: string;\n  data: any;\n  private error?: Error;\n  private internal: boolean;\n\n  constructor(\n    status: number,\n    statusText: string | undefined,\n    data: any,\n    internal = false\n  ) {\n    this.status = status;\n    this.statusText = statusText || \"\";\n    this.internal = internal;\n    if (data instanceof Error) {\n      this.data = data.toString();\n      this.error = data;\n    } else {\n      this.data = data;\n    }\n  }\n}\n\n/**\n * Check if the given error is an ErrorResponse generated from a 4xx/5xx\n * Response thrown from an action/loader\n */\nexport function isRouteErrorResponse(error: any): error is ErrorResponse {\n  return (\n    error != null &&\n    typeof error.status === \"number\" &&\n    typeof error.statusText === \"string\" &&\n    typeof error.internal === \"boolean\" &&\n    \"data\" in error\n  );\n}\n","import type { History, Location, Path, To } from \"./history\";\nimport {\n  Action as HistoryAction,\n  createLocation,\n  createPath,\n  invariant,\n  parsePath,\n  warning,\n} from \"./history\";\nimport type {\n  AgnosticDataRouteMatch,\n  AgnosticDataRouteObject,\n  DataStrategyMatch,\n  AgnosticRouteObject,\n  DataResult,\n  DataStrategyFunction,\n  DataStrategyFunctionArgs,\n  DeferredData,\n  DeferredResult,\n  DetectErrorBoundaryFunction,\n  ErrorResult,\n  FormEncType,\n  FormMethod,\n  HTMLFormMethod,\n  DataStrategyResult,\n  ImmutableRouteKey,\n  MapRoutePropertiesFunction,\n  MutationFormMethod,\n  RedirectResult,\n  RouteData,\n  RouteManifest,\n  ShouldRevalidateFunctionArgs,\n  Submission,\n  SuccessResult,\n  UIMatch,\n  V7_FormMethod,\n  V7_MutationFormMethod,\n  AgnosticPatchRoutesOnNavigationFunction,\n  DataWithResponseInit,\n} from \"./utils\";\nimport {\n  ErrorResponseImpl,\n  ResultType,\n  convertRouteMatchToUiMatch,\n  convertRoutesToDataRoutes,\n  getPathContributingMatches,\n  getResolveToMatches,\n  immutableRouteKeys,\n  isRouteErrorResponse,\n  joinPaths,\n  matchRoutes,\n  matchRoutesImpl,\n  resolveTo,\n  stripBasename,\n} from \"./utils\";\n\n////////////////////////////////////////////////////////////////////////////////\n//#region Types and Constants\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * A Router instance manages all navigation and data loading/mutations\n */\nexport interface Router {\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Return the basename for the router\n   */\n  get basename(): RouterInit[\"basename\"];\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Return the future config for the router\n   */\n  get future(): FutureConfig;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Return the current state of the router\n   */\n  get state(): RouterState;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Return the routes for this router instance\n   */\n  get routes(): AgnosticDataRouteObject[];\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Return the window associated with the router\n   */\n  get window(): RouterInit[\"window\"];\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Initialize the router, including adding history listeners and kicking off\n   * initial data fetches.  Returns a function to cleanup listeners and abort\n   * any in-progress loads\n   */\n  initialize(): Router;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Subscribe to router.state updates\n   *\n   * @param fn function to call with the new state\n   */\n  subscribe(fn: RouterSubscriber): () => void;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Enable scroll restoration behavior in the router\n   *\n   * @param savedScrollPositions Object that will manage positions, in case\n   *                             it's being restored from sessionStorage\n   * @param getScrollPosition    Function to get the active Y scroll position\n   * @param getKey               Function to get the key to use for restoration\n   */\n  enableScrollRestoration(\n    savedScrollPositions: Record<string, number>,\n    getScrollPosition: GetScrollPositionFunction,\n    getKey?: GetScrollRestorationKeyFunction\n  ): () => void;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Navigate forward/backward in the history stack\n   * @param to Delta to move in the history stack\n   */\n  navigate(to: number): Promise<void>;\n\n  /**\n   * Navigate to the given path\n   * @param to Path to navigate to\n   * @param opts Navigation options (method, submission, etc.)\n   */\n  navigate(to: To | null, opts?: RouterNavigateOptions): Promise<void>;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Trigger a fetcher load/submission\n   *\n   * @param key     Fetcher key\n   * @param routeId Route that owns the fetcher\n   * @param href    href to fetch\n   * @param opts    Fetcher options, (method, submission, etc.)\n   */\n  fetch(\n    key: string,\n    routeId: string,\n    href: string | null,\n    opts?: RouterFetchOptions\n  ): void;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Trigger a revalidation of all current route loaders and fetcher loads\n   */\n  revalidate(): void;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Utility function to create an href for the given location\n   * @param location\n   */\n  createHref(location: Location | URL): string;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Utility function to URL encode a destination path according to the internal\n   * history implementation\n   * @param to\n   */\n  encodeLocation(to: To): Path;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Get/create a fetcher for the given key\n   * @param key\n   */\n  getFetcher<TData = any>(key: string): Fetcher<TData>;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Delete the fetcher for a given key\n   * @param key\n   */\n  deleteFetcher(key: string): void;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Cleanup listeners and abort any in-progress loads\n   */\n  dispose(): void;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Get a navigation blocker\n   * @param key The identifier for the blocker\n   * @param fn The blocker function implementation\n   */\n  getBlocker(key: string, fn: BlockerFunction): Blocker;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Delete a navigation blocker\n   * @param key The identifier for the blocker\n   */\n  deleteBlocker(key: string): void;\n\n  /**\n   * @internal\n   * PRIVATE DO NOT USE\n   *\n   * Patch additional children routes into an existing parent route\n   * @param routeId The parent route id or a callback function accepting `patch`\n   *                to perform batch patching\n   * @param children The additional children routes\n   */\n  patchRoutes(routeId: string | null, children: AgnosticRouteObject[]): void;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * HMR needs to pass in-flight route updates to React Router\n   * TODO: Replace this with granular route update APIs (addRoute, updateRoute, deleteRoute)\n   */\n  _internalSetRoutes(routes: AgnosticRouteObject[]): void;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Internal fetch AbortControllers accessed by unit tests\n   */\n  _internalFetchControllers: Map<string, AbortController>;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Internal pending DeferredData instances accessed by unit tests\n   */\n  _internalActiveDeferreds: Map<string, DeferredData>;\n}\n\n/**\n * State maintained internally by the router.  During a navigation, all states\n * reflect the the \"old\" location unless otherwise noted.\n */\nexport interface RouterState {\n  /**\n   * The action of the most recent navigation\n   */\n  historyAction: HistoryAction;\n\n  /**\n   * The current location reflected by the router\n   */\n  location: Location;\n\n  /**\n   * The current set of route matches\n   */\n  matches: AgnosticDataRouteMatch[];\n\n  /**\n   * Tracks whether we've completed our initial data load\n   */\n  initialized: boolean;\n\n  /**\n   * Current scroll position we should start at for a new view\n   *  - number -> scroll position to restore to\n   *  - false -> do not restore scroll at all (used during submissions)\n   *  - null -> don't have a saved position, scroll to hash or top of page\n   */\n  restoreScrollPosition: number | false | null;\n\n  /**\n   * Indicate whether this navigation should skip resetting the scroll position\n   * if we are unable to restore the scroll position\n   */\n  preventScrollReset: boolean;\n\n  /**\n   * Tracks the state of the current navigation\n   */\n  navigation: Navigation;\n\n  /**\n   * Tracks any in-progress revalidations\n   */\n  revalidation: RevalidationState;\n\n  /**\n   * Data from the loaders for the current matches\n   */\n  loaderData: RouteData;\n\n  /**\n   * Data from the action for the current matches\n   */\n  actionData: RouteData | null;\n\n  /**\n   * Errors caught from loaders for the current matches\n   */\n  errors: RouteData | null;\n\n  /**\n   * Map of current fetchers\n   */\n  fetchers: Map<string, Fetcher>;\n\n  /**\n   * Map of current blockers\n   */\n  blockers: Map<string, Blocker>;\n}\n\n/**\n * Data that can be passed into hydrate a Router from SSR\n */\nexport type HydrationState = Partial<\n  Pick<RouterState, \"loaderData\" | \"actionData\" | \"errors\">\n>;\n\n/**\n * Future flags to toggle new feature behavior\n */\nexport interface FutureConfig {\n  v7_fetcherPersist: boolean;\n  v7_normalizeFormMethod: boolean;\n  v7_partialHydration: boolean;\n  v7_prependBasename: boolean;\n  v7_relativeSplatPath: boolean;\n  v7_skipActionErrorRevalidation: boolean;\n}\n\n/**\n * Initialization options for createRouter\n */\nexport interface RouterInit {\n  routes: AgnosticRouteObject[];\n  history: History;\n  basename?: string;\n  /**\n   * @deprecated Use `mapRouteProperties` instead\n   */\n  detectErrorBoundary?: DetectErrorBoundaryFunction;\n  mapRouteProperties?: MapRoutePropertiesFunction;\n  future?: Partial<FutureConfig>;\n  hydrationData?: HydrationState;\n  window?: Window;\n  dataStrategy?: DataStrategyFunction;\n  patchRoutesOnNavigation?: AgnosticPatchRoutesOnNavigationFunction;\n}\n\n/**\n * State returned from a server-side query() call\n */\nexport interface StaticHandlerContext {\n  basename: Router[\"basename\"];\n  location: RouterState[\"location\"];\n  matches: RouterState[\"matches\"];\n  loaderData: RouterState[\"loaderData\"];\n  actionData: RouterState[\"actionData\"];\n  errors: RouterState[\"errors\"];\n  statusCode: number;\n  loaderHeaders: Record<string, Headers>;\n  actionHeaders: Record<string, Headers>;\n  activeDeferreds: Record<string, DeferredData> | null;\n  _deepestRenderedBoundaryId?: string | null;\n}\n\n/**\n * A StaticHandler instance manages a singular SSR navigation/fetch event\n */\nexport interface StaticHandler {\n  dataRoutes: AgnosticDataRouteObject[];\n  query(\n    request: Request,\n    opts?: {\n      requestContext?: unknown;\n      skipLoaderErrorBubbling?: boolean;\n      dataStrategy?: DataStrategyFunction;\n    }\n  ): Promise<StaticHandlerContext | Response>;\n  queryRoute(\n    request: Request,\n    opts?: {\n      routeId?: string;\n      requestContext?: unknown;\n      dataStrategy?: DataStrategyFunction;\n    }\n  ): Promise<any>;\n}\n\ntype ViewTransitionOpts = {\n  currentLocation: Location;\n  nextLocation: Location;\n};\n\n/**\n * Subscriber function signature for changes to router state\n */\nexport interface RouterSubscriber {\n  (\n    state: RouterState,\n    opts: {\n      deletedFetchers: string[];\n      viewTransitionOpts?: ViewTransitionOpts;\n      flushSync: boolean;\n    }\n  ): void;\n}\n\n/**\n * Function signature for determining the key to be used in scroll restoration\n * for a given location\n */\nexport interface GetScrollRestorationKeyFunction {\n  (location: Location, matches: UIMatch[]): string | null;\n}\n\n/**\n * Function signature for determining the current scroll position\n */\nexport interface GetScrollPositionFunction {\n  (): number;\n}\n\nexport type RelativeRoutingType = \"route\" | \"path\";\n\n// Allowed for any navigation or fetch\ntype BaseNavigateOrFetchOptions = {\n  preventScrollReset?: boolean;\n  relative?: RelativeRoutingType;\n  flushSync?: boolean;\n};\n\n// Only allowed for navigations\ntype BaseNavigateOptions = BaseNavigateOrFetchOptions & {\n  replace?: boolean;\n  state?: any;\n  fromRouteId?: string;\n  viewTransition?: boolean;\n};\n\n// Only allowed for submission navigations\ntype BaseSubmissionOptions = {\n  formMethod?: HTMLFormMethod;\n  formEncType?: FormEncType;\n} & (\n  | { formData: FormData; body?: undefined }\n  | { formData?: undefined; body: any }\n);\n\n/**\n * Options for a navigate() call for a normal (non-submission) navigation\n */\ntype LinkNavigateOptions = BaseNavigateOptions;\n\n/**\n * Options for a navigate() call for a submission navigation\n */\ntype SubmissionNavigateOptions = BaseNavigateOptions & BaseSubmissionOptions;\n\n/**\n * Options to pass to navigate() for a navigation\n */\nexport type RouterNavigateOptions =\n  | LinkNavigateOptions\n  | SubmissionNavigateOptions;\n\n/**\n * Options for a fetch() load\n */\ntype LoadFetchOptions = BaseNavigateOrFetchOptions;\n\n/**\n * Options for a fetch() submission\n */\ntype SubmitFetchOptions = BaseNavigateOrFetchOptions & BaseSubmissionOptions;\n\n/**\n * Options to pass to fetch()\n */\nexport type RouterFetchOptions = LoadFetchOptions | SubmitFetchOptions;\n\n/**\n * Potential states for state.navigation\n */\nexport type NavigationStates = {\n  Idle: {\n    state: \"idle\";\n    location: undefined;\n    formMethod: undefined;\n    formAction: undefined;\n    formEncType: undefined;\n    formData: undefined;\n    json: undefined;\n    text: undefined;\n  };\n  Loading: {\n    state: \"loading\";\n    location: Location;\n    formMethod: Submission[\"formMethod\"] | undefined;\n    formAction: Submission[\"formAction\"] | undefined;\n    formEncType: Submission[\"formEncType\"] | undefined;\n    formData: Submission[\"formData\"] | undefined;\n    json: Submission[\"json\"] | undefined;\n    text: Submission[\"text\"] | undefined;\n  };\n  Submitting: {\n    state: \"submitting\";\n    location: Location;\n    formMethod: Submission[\"formMethod\"];\n    formAction: Submission[\"formAction\"];\n    formEncType: Submission[\"formEncType\"];\n    formData: Submission[\"formData\"];\n    json: Submission[\"json\"];\n    text: Submission[\"text\"];\n  };\n};\n\nexport type Navigation = NavigationStates[keyof NavigationStates];\n\nexport type RevalidationState = \"idle\" | \"loading\";\n\n/**\n * Potential states for fetchers\n */\ntype FetcherStates<TData = any> = {\n  Idle: {\n    state: \"idle\";\n    formMethod: undefined;\n    formAction: undefined;\n    formEncType: undefined;\n    text: undefined;\n    formData: undefined;\n    json: undefined;\n    data: TData | undefined;\n  };\n  Loading: {\n    state: \"loading\";\n    formMethod: Submission[\"formMethod\"] | undefined;\n    formAction: Submission[\"formAction\"] | undefined;\n    formEncType: Submission[\"formEncType\"] | undefined;\n    text: Submission[\"text\"] | undefined;\n    formData: Submission[\"formData\"] | undefined;\n    json: Submission[\"json\"] | undefined;\n    data: TData | undefined;\n  };\n  Submitting: {\n    state: \"submitting\";\n    formMethod: Submission[\"formMethod\"];\n    formAction: Submission[\"formAction\"];\n    formEncType: Submission[\"formEncType\"];\n    text: Submission[\"text\"];\n    formData: Submission[\"formData\"];\n    json: Submission[\"json\"];\n    data: TData | undefined;\n  };\n};\n\nexport type Fetcher<TData = any> =\n  FetcherStates<TData>[keyof FetcherStates<TData>];\n\ninterface BlockerBlocked {\n  state: \"blocked\";\n  reset(): void;\n  proceed(): void;\n  location: Location;\n}\n\ninterface BlockerUnblocked {\n  state: \"unblocked\";\n  reset: undefined;\n  proceed: undefined;\n  location: undefined;\n}\n\ninterface BlockerProceeding {\n  state: \"proceeding\";\n  reset: undefined;\n  proceed: undefined;\n  location: Location;\n}\n\nexport type Blocker = BlockerUnblocked | BlockerBlocked | BlockerProceeding;\n\nexport type BlockerFunction = (args: {\n  currentLocation: Location;\n  nextLocation: Location;\n  historyAction: HistoryAction;\n}) => boolean;\n\ninterface ShortCircuitable {\n  /**\n   * startNavigation does not need to complete the navigation because we\n   * redirected or got interrupted\n   */\n  shortCircuited?: boolean;\n}\n\ntype PendingActionResult = [string, SuccessResult | ErrorResult];\n\ninterface HandleActionResult extends ShortCircuitable {\n  /**\n   * Route matches which may have been updated from fog of war discovery\n   */\n  matches?: RouterState[\"matches\"];\n  /**\n   * Tuple for the returned or thrown value from the current action.  The routeId\n   * is the action route for success and the bubbled boundary route for errors.\n   */\n  pendingActionResult?: PendingActionResult;\n}\n\ninterface HandleLoadersResult extends ShortCircuitable {\n  /**\n   * Route matches which may have been updated from fog of war discovery\n   */\n  matches?: RouterState[\"matches\"];\n  /**\n   * loaderData returned from the current set of loaders\n   */\n  loaderData?: RouterState[\"loaderData\"];\n  /**\n   * errors thrown from the current set of loaders\n   */\n  errors?: RouterState[\"errors\"];\n}\n\n/**\n * Cached info for active fetcher.load() instances so they can participate\n * in revalidation\n */\ninterface FetchLoadMatch {\n  routeId: string;\n  path: string;\n}\n\n/**\n * Identified fetcher.load() calls that need to be revalidated\n */\ninterface RevalidatingFetcher extends FetchLoadMatch {\n  key: string;\n  match: AgnosticDataRouteMatch | null;\n  matches: AgnosticDataRouteMatch[] | null;\n  controller: AbortController | null;\n}\n\nconst validMutationMethodsArr: MutationFormMethod[] = [\n  \"post\",\n  \"put\",\n  \"patch\",\n  \"delete\",\n];\nconst validMutationMethods = new Set<MutationFormMethod>(\n  validMutationMethodsArr\n);\n\nconst validRequestMethodsArr: FormMethod[] = [\n  \"get\",\n  ...validMutationMethodsArr,\n];\nconst validRequestMethods = new Set<FormMethod>(validRequestMethodsArr);\n\nconst redirectStatusCodes = new Set([301, 302, 303, 307, 308]);\nconst redirectPreserveMethodStatusCodes = new Set([307, 308]);\n\nexport const IDLE_NAVIGATION: NavigationStates[\"Idle\"] = {\n  state: \"idle\",\n  location: undefined,\n  formMethod: undefined,\n  formAction: undefined,\n  formEncType: undefined,\n  formData: undefined,\n  json: undefined,\n  text: undefined,\n};\n\nexport const IDLE_FETCHER: FetcherStates[\"Idle\"] = {\n  state: \"idle\",\n  data: undefined,\n  formMethod: undefined,\n  formAction: undefined,\n  formEncType: undefined,\n  formData: undefined,\n  json: undefined,\n  text: undefined,\n};\n\nexport const IDLE_BLOCKER: BlockerUnblocked = {\n  state: \"unblocked\",\n  proceed: undefined,\n  reset: undefined,\n  location: undefined,\n};\n\nconst ABSOLUTE_URL_REGEX = /^(?:[a-z][a-z0-9+.-]*:|\\/\\/)/i;\n\nconst defaultMapRouteProperties: MapRoutePropertiesFunction = (route) => ({\n  hasErrorBoundary: Boolean(route.hasErrorBoundary),\n});\n\nconst TRANSITIONS_STORAGE_KEY = \"remix-router-transitions\";\n\n//#endregion\n\n////////////////////////////////////////////////////////////////////////////////\n//#region createRouter\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * Create a router and listen to history POP navigations\n */\nexport function createRouter(init: RouterInit): Router {\n  const routerWindow = init.window\n    ? init.window\n    : typeof window !== \"undefined\"\n    ? window\n    : undefined;\n  const isBrowser =\n    typeof routerWindow !== \"undefined\" &&\n    typeof routerWindow.document !== \"undefined\" &&\n    typeof routerWindow.document.createElement !== \"undefined\";\n  const isServer = !isBrowser;\n\n  invariant(\n    init.routes.length > 0,\n    \"You must provide a non-empty routes array to createRouter\"\n  );\n\n  let mapRouteProperties: MapRoutePropertiesFunction;\n  if (init.mapRouteProperties) {\n    mapRouteProperties = init.mapRouteProperties;\n  } else if (init.detectErrorBoundary) {\n    // If they are still using the deprecated version, wrap it with the new API\n    let detectErrorBoundary = init.detectErrorBoundary;\n    mapRouteProperties = (route) => ({\n      hasErrorBoundary: detectErrorBoundary(route),\n    });\n  } else {\n    mapRouteProperties = defaultMapRouteProperties;\n  }\n\n  // Routes keyed by ID\n  let manifest: RouteManifest = {};\n  // Routes in tree format for matching\n  let dataRoutes = convertRoutesToDataRoutes(\n    init.routes,\n    mapRouteProperties,\n    undefined,\n    manifest\n  );\n  let inFlightDataRoutes: AgnosticDataRouteObject[] | undefined;\n  let basename = init.basename || \"/\";\n  let dataStrategyImpl = init.dataStrategy || defaultDataStrategy;\n  let patchRoutesOnNavigationImpl = init.patchRoutesOnNavigation;\n\n  // Config driven behavior flags\n  let future: FutureConfig = {\n    v7_fetcherPersist: false,\n    v7_normalizeFormMethod: false,\n    v7_partialHydration: false,\n    v7_prependBasename: false,\n    v7_relativeSplatPath: false,\n    v7_skipActionErrorRevalidation: false,\n    ...init.future,\n  };\n  // Cleanup function for history\n  let unlistenHistory: (() => void) | null = null;\n  // Externally-provided functions to call on all state changes\n  let subscribers = new Set<RouterSubscriber>();\n  // Externally-provided object to hold scroll restoration locations during routing\n  let savedScrollPositions: Record<string, number> | null = null;\n  // Externally-provided function to get scroll restoration keys\n  let getScrollRestorationKey: GetScrollRestorationKeyFunction | null = null;\n  // Externally-provided function to get current scroll position\n  let getScrollPosition: GetScrollPositionFunction | null = null;\n  // One-time flag to control the initial hydration scroll restoration.  Because\n  // we don't get the saved positions from <ScrollRestoration /> until _after_\n  // the initial render, we need to manually trigger a separate updateState to\n  // send along the restoreScrollPosition\n  // Set to true if we have `hydrationData` since we assume we were SSR'd and that\n  // SSR did the initial scroll restoration.\n  let initialScrollRestored = init.hydrationData != null;\n\n  let initialMatches = matchRoutes(dataRoutes, init.history.location, basename);\n  let initialMatchesIsFOW = false;\n  let initialErrors: RouteData | null = null;\n\n  if (initialMatches == null && !patchRoutesOnNavigationImpl) {\n    // If we do not match a user-provided-route, fall back to the root\n    // to allow the error boundary to take over\n    let error = getInternalRouterError(404, {\n      pathname: init.history.location.pathname,\n    });\n    let { matches, route } = getShortCircuitMatches(dataRoutes);\n    initialMatches = matches;\n    initialErrors = { [route.id]: error };\n  }\n\n  // In SPA apps, if the user provided a patchRoutesOnNavigation implementation and\n  // our initial match is a splat route, clear them out so we run through lazy\n  // discovery on hydration in case there's a more accurate lazy route match.\n  // In SSR apps (with `hydrationData`), we expect that the server will send\n  // up the proper matched routes so we don't want to run lazy discovery on\n  // initial hydration and want to hydrate into the splat route.\n  if (initialMatches && !init.hydrationData) {\n    let fogOfWar = checkFogOfWar(\n      initialMatches,\n      dataRoutes,\n      init.history.location.pathname\n    );\n    if (fogOfWar.active) {\n      initialMatches = null;\n    }\n  }\n\n  let initialized: boolean;\n  if (!initialMatches) {\n    initialized = false;\n    initialMatches = [];\n\n    // If partial hydration and fog of war is enabled, we will be running\n    // `patchRoutesOnNavigation` during hydration so include any partial matches as\n    // the initial matches so we can properly render `HydrateFallback`'s\n    if (future.v7_partialHydration) {\n      let fogOfWar = checkFogOfWar(\n        null,\n        dataRoutes,\n        init.history.location.pathname\n      );\n      if (fogOfWar.active && fogOfWar.matches) {\n        initialMatchesIsFOW = true;\n        initialMatches = fogOfWar.matches;\n      }\n    }\n  } else if (initialMatches.some((m) => m.route.lazy)) {\n    // All initialMatches need to be loaded before we're ready.  If we have lazy\n    // functions around still then we'll need to run them in initialize()\n    initialized = false;\n  } else if (!initialMatches.some((m) => m.route.loader)) {\n    // If we've got no loaders to run, then we're good to go\n    initialized = true;\n  } else if (future.v7_partialHydration) {\n    // If partial hydration is enabled, we're initialized so long as we were\n    // provided with hydrationData for every route with a loader, and no loaders\n    // were marked for explicit hydration\n    let loaderData = init.hydrationData ? init.hydrationData.loaderData : null;\n    let errors = init.hydrationData ? init.hydrationData.errors : null;\n    // If errors exist, don't consider routes below the boundary\n    if (errors) {\n      let idx = initialMatches.findIndex(\n        (m) => errors![m.route.id] !== undefined\n      );\n      initialized = initialMatches\n        .slice(0, idx + 1)\n        .every((m) => !shouldLoadRouteOnHydration(m.route, loaderData, errors));\n    } else {\n      initialized = initialMatches.every(\n        (m) => !shouldLoadRouteOnHydration(m.route, loaderData, errors)\n      );\n    }\n  } else {\n    // Without partial hydration - we're initialized if we were provided any\n    // hydrationData - which is expected to be complete\n    initialized = init.hydrationData != null;\n  }\n\n  let router: Router;\n  let state: RouterState = {\n    historyAction: init.history.action,\n    location: init.history.location,\n    matches: initialMatches,\n    initialized,\n    navigation: IDLE_NAVIGATION,\n    // Don't restore on initial updateState() if we were SSR'd\n    restoreScrollPosition: init.hydrationData != null ? false : null,\n    preventScrollReset: false,\n    revalidation: \"idle\",\n    loaderData: (init.hydrationData && init.hydrationData.loaderData) || {},\n    actionData: (init.hydrationData && init.hydrationData.actionData) || null,\n    errors: (init.hydrationData && init.hydrationData.errors) || initialErrors,\n    fetchers: new Map(),\n    blockers: new Map(),\n  };\n\n  // -- Stateful internal variables to manage navigations --\n  // Current navigation in progress (to be committed in completeNavigation)\n  let pendingAction: HistoryAction = HistoryAction.Pop;\n\n  // Should the current navigation prevent the scroll reset if scroll cannot\n  // be restored?\n  let pendingPreventScrollReset = false;\n\n  // AbortController for the active navigation\n  let pendingNavigationController: AbortController | null;\n\n  // Should the current navigation enable document.startViewTransition?\n  let pendingViewTransitionEnabled = false;\n\n  // Store applied view transitions so we can apply them on POP\n  let appliedViewTransitions: Map<string, Set<string>> = new Map<\n    string,\n    Set<string>\n  >();\n\n  // Cleanup function for persisting applied transitions to sessionStorage\n  let removePageHideEventListener: (() => void) | null = null;\n\n  // We use this to avoid touching history in completeNavigation if a\n  // revalidation is entirely uninterrupted\n  let isUninterruptedRevalidation = false;\n\n  // Use this internal flag to force revalidation of all loaders:\n  //  - submissions (completed or interrupted)\n  //  - useRevalidator()\n  //  - X-Remix-Revalidate (from redirect)\n  let isRevalidationRequired = false;\n\n  // Use this internal array to capture routes that require revalidation due\n  // to a cancelled deferred on action submission\n  let cancelledDeferredRoutes: string[] = [];\n\n  // Use this internal array to capture fetcher loads that were cancelled by an\n  // action navigation and require revalidation\n  let cancelledFetcherLoads: Set<string> = new Set();\n\n  // AbortControllers for any in-flight fetchers\n  let fetchControllers = new Map<string, AbortController>();\n\n  // Track loads based on the order in which they started\n  let incrementingLoadId = 0;\n\n  // Track the outstanding pending navigation data load to be compared against\n  // the globally incrementing load when a fetcher load lands after a completed\n  // navigation\n  let pendingNavigationLoadId = -1;\n\n  // Fetchers that triggered data reloads as a result of their actions\n  let fetchReloadIds = new Map<string, number>();\n\n  // Fetchers that triggered redirect navigations\n  let fetchRedirectIds = new Set<string>();\n\n  // Most recent href/match for fetcher.load calls for fetchers\n  let fetchLoadMatches = new Map<string, FetchLoadMatch>();\n\n  // Ref-count mounted fetchers so we know when it's ok to clean them up\n  let activeFetchers = new Map<string, number>();\n\n  // Fetchers that have requested a delete when using v7_fetcherPersist,\n  // they'll be officially removed after they return to idle\n  let deletedFetchers = new Set<string>();\n\n  // Store DeferredData instances for active route matches.  When a\n  // route loader returns defer() we stick one in here.  Then, when a nested\n  // promise resolves we update loaderData.  If a new navigation starts we\n  // cancel active deferreds for eliminated routes.\n  let activeDeferreds = new Map<string, DeferredData>();\n\n  // Store blocker functions in a separate Map outside of router state since\n  // we don't need to update UI state if they change\n  let blockerFunctions = new Map<string, BlockerFunction>();\n\n  // Map of pending patchRoutesOnNavigation() promises (keyed by path/matches) so\n  // that we only kick them off once for a given combo\n  let pendingPatchRoutes = new Map<\n    string,\n    ReturnType<AgnosticPatchRoutesOnNavigationFunction>\n  >();\n\n  // Flag to ignore the next history update, so we can revert the URL change on\n  // a POP navigation that was blocked by the user without touching router state\n  let unblockBlockerHistoryUpdate: (() => void) | undefined = undefined;\n\n  // Initialize the router, all side effects should be kicked off from here.\n  // Implemented as a Fluent API for ease of:\n  //   let router = createRouter(init).initialize();\n  function initialize() {\n    // If history informs us of a POP navigation, start the navigation but do not update\n    // state.  We'll update our own state once the navigation completes\n    unlistenHistory = init.history.listen(\n      ({ action: historyAction, location, delta }) => {\n        // Ignore this event if it was just us resetting the URL from a\n        // blocked POP navigation\n        if (unblockBlockerHistoryUpdate) {\n          unblockBlockerHistoryUpdate();\n          unblockBlockerHistoryUpdate = undefined;\n          return;\n        }\n\n        warning(\n          blockerFunctions.size === 0 || delta != null,\n          \"You are trying to use a blocker on a POP navigation to a location \" +\n            \"that was not created by @remix-run/router. This will fail silently in \" +\n            \"production. This can happen if you are navigating outside the router \" +\n            \"via `window.history.pushState`/`window.location.hash` instead of using \" +\n            \"router navigation APIs.  This can also happen if you are using \" +\n            \"createHashRouter and the user manually changes the URL.\"\n        );\n\n        let blockerKey = shouldBlockNavigation({\n          currentLocation: state.location,\n          nextLocation: location,\n          historyAction,\n        });\n\n        if (blockerKey && delta != null) {\n          // Restore the URL to match the current UI, but don't update router state\n          let nextHistoryUpdatePromise = new Promise<void>((resolve) => {\n            unblockBlockerHistoryUpdate = resolve;\n          });\n          init.history.go(delta * -1);\n\n          // Put the blocker into a blocked state\n          updateBlocker(blockerKey, {\n            state: \"blocked\",\n            location,\n            proceed() {\n              updateBlocker(blockerKey!, {\n                state: \"proceeding\",\n                proceed: undefined,\n                reset: undefined,\n                location,\n              });\n              // Re-do the same POP navigation we just blocked, after the url\n              // restoration is also complete.  See:\n              // https://github.com/remix-run/react-router/issues/11613\n              nextHistoryUpdatePromise.then(() => init.history.go(delta));\n            },\n            reset() {\n              let blockers = new Map(state.blockers);\n              blockers.set(blockerKey!, IDLE_BLOCKER);\n              updateState({ blockers });\n            },\n          });\n          return;\n        }\n\n        return startNavigation(historyAction, location);\n      }\n    );\n\n    if (isBrowser) {\n      // FIXME: This feels gross.  How can we cleanup the lines between\n      // scrollRestoration/appliedTransitions persistance?\n      restoreAppliedTransitions(routerWindow, appliedViewTransitions);\n      let _saveAppliedTransitions = () =>\n        persistAppliedTransitions(routerWindow, appliedViewTransitions);\n      routerWindow.addEventListener(\"pagehide\", _saveAppliedTransitions);\n      removePageHideEventListener = () =>\n        routerWindow.removeEventListener(\"pagehide\", _saveAppliedTransitions);\n    }\n\n    // Kick off initial data load if needed.  Use Pop to avoid modifying history\n    // Note we don't do any handling of lazy here.  For SPA's it'll get handled\n    // in the normal navigation flow.  For SSR it's expected that lazy modules are\n    // resolved prior to router creation since we can't go into a fallbackElement\n    // UI for SSR'd apps\n    if (!state.initialized) {\n      startNavigation(HistoryAction.Pop, state.location, {\n        initialHydration: true,\n      });\n    }\n\n    return router;\n  }\n\n  // Clean up a router and it's side effects\n  function dispose() {\n    if (unlistenHistory) {\n      unlistenHistory();\n    }\n    if (removePageHideEventListener) {\n      removePageHideEventListener();\n    }\n    subscribers.clear();\n    pendingNavigationController && pendingNavigationController.abort();\n    state.fetchers.forEach((_, key) => deleteFetcher(key));\n    state.blockers.forEach((_, key) => deleteBlocker(key));\n  }\n\n  // Subscribe to state updates for the router\n  function subscribe(fn: RouterSubscriber) {\n    subscribers.add(fn);\n    return () => subscribers.delete(fn);\n  }\n\n  // Update our state and notify the calling context of the change\n  function updateState(\n    newState: Partial<RouterState>,\n    opts: {\n      flushSync?: boolean;\n      viewTransitionOpts?: ViewTransitionOpts;\n    } = {}\n  ): void {\n    state = {\n      ...state,\n      ...newState,\n    };\n\n    // Prep fetcher cleanup so we can tell the UI which fetcher data entries\n    // can be removed\n    let completedFetchers: string[] = [];\n    let deletedFetchersKeys: string[] = [];\n\n    if (future.v7_fetcherPersist) {\n      state.fetchers.forEach((fetcher, key) => {\n        if (fetcher.state === \"idle\") {\n          if (deletedFetchers.has(key)) {\n            // Unmounted from the UI and can be totally removed\n            deletedFetchersKeys.push(key);\n          } else {\n            // Returned to idle but still mounted in the UI, so semi-remains for\n            // revalidations and such\n            completedFetchers.push(key);\n          }\n        }\n      });\n    }\n\n    // Remove any lingering deleted fetchers that have already been removed\n    // from state.fetchers\n    deletedFetchers.forEach((key) => {\n      if (!state.fetchers.has(key) && !fetchControllers.has(key)) {\n        deletedFetchersKeys.push(key);\n      }\n    });\n\n    // Iterate over a local copy so that if flushSync is used and we end up\n    // removing and adding a new subscriber due to the useCallback dependencies,\n    // we don't get ourselves into a loop calling the new subscriber immediately\n    [...subscribers].forEach((subscriber) =>\n      subscriber(state, {\n        deletedFetchers: deletedFetchersKeys,\n        viewTransitionOpts: opts.viewTransitionOpts,\n        flushSync: opts.flushSync === true,\n      })\n    );\n\n    // Remove idle fetchers from state since we only care about in-flight fetchers.\n    if (future.v7_fetcherPersist) {\n      completedFetchers.forEach((key) => state.fetchers.delete(key));\n      deletedFetchersKeys.forEach((key) => deleteFetcher(key));\n    } else {\n      // We already called deleteFetcher() on these, can remove them from this\n      // Set now that we've handed the keys off to the data layer\n      deletedFetchersKeys.forEach((key) => deletedFetchers.delete(key));\n    }\n  }\n\n  // Complete a navigation returning the state.navigation back to the IDLE_NAVIGATION\n  // and setting state.[historyAction/location/matches] to the new route.\n  // - Location is a required param\n  // - Navigation will always be set to IDLE_NAVIGATION\n  // - Can pass any other state in newState\n  function completeNavigation(\n    location: Location,\n    newState: Partial<Omit<RouterState, \"action\" | \"location\" | \"navigation\">>,\n    { flushSync }: { flushSync?: boolean } = {}\n  ): void {\n    // Deduce if we're in a loading/actionReload state:\n    // - We have committed actionData in the store\n    // - The current navigation was a mutation submission\n    // - We're past the submitting state and into the loading state\n    // - The location being loaded is not the result of a redirect\n    let isActionReload =\n      state.actionData != null &&\n      state.navigation.formMethod != null &&\n      isMutationMethod(state.navigation.formMethod) &&\n      state.navigation.state === \"loading\" &&\n      location.state?._isRedirect !== true;\n\n    let actionData: RouteData | null;\n    if (newState.actionData) {\n      if (Object.keys(newState.actionData).length > 0) {\n        actionData = newState.actionData;\n      } else {\n        // Empty actionData -> clear prior actionData due to an action error\n        actionData = null;\n      }\n    } else if (isActionReload) {\n      // Keep the current data if we're wrapping up the action reload\n      actionData = state.actionData;\n    } else {\n      // Clear actionData on any other completed navigations\n      actionData = null;\n    }\n\n    // Always preserve any existing loaderData from re-used routes\n    let loaderData = newState.loaderData\n      ? mergeLoaderData(\n          state.loaderData,\n          newState.loaderData,\n          newState.matches || [],\n          newState.errors\n        )\n      : state.loaderData;\n\n    // On a successful navigation we can assume we got through all blockers\n    // so we can start fresh\n    let blockers = state.blockers;\n    if (blockers.size > 0) {\n      blockers = new Map(blockers);\n      blockers.forEach((_, k) => blockers.set(k, IDLE_BLOCKER));\n    }\n\n    // Always respect the user flag.  Otherwise don't reset on mutation\n    // submission navigations unless they redirect\n    let preventScrollReset =\n      pendingPreventScrollReset === true ||\n      (state.navigation.formMethod != null &&\n        isMutationMethod(state.navigation.formMethod) &&\n        location.state?._isRedirect !== true);\n\n    // Commit any in-flight routes at the end of the HMR revalidation \"navigation\"\n    if (inFlightDataRoutes) {\n      dataRoutes = inFlightDataRoutes;\n      inFlightDataRoutes = undefined;\n    }\n\n    if (isUninterruptedRevalidation) {\n      // If this was an uninterrupted revalidation then do not touch history\n    } else if (pendingAction === HistoryAction.Pop) {\n      // Do nothing for POP - URL has already been updated\n    } else if (pendingAction === HistoryAction.Push) {\n      init.history.push(location, location.state);\n    } else if (pendingAction === HistoryAction.Replace) {\n      init.history.replace(location, location.state);\n    }\n\n    let viewTransitionOpts: ViewTransitionOpts | undefined;\n\n    // On POP, enable transitions if they were enabled on the original navigation\n    if (pendingAction === HistoryAction.Pop) {\n      // Forward takes precedence so they behave like the original navigation\n      let priorPaths = appliedViewTransitions.get(state.location.pathname);\n      if (priorPaths && priorPaths.has(location.pathname)) {\n        viewTransitionOpts = {\n          currentLocation: state.location,\n          nextLocation: location,\n        };\n      } else if (appliedViewTransitions.has(location.pathname)) {\n        // If we don't have a previous forward nav, assume we're popping back to\n        // the new location and enable if that location previously enabled\n        viewTransitionOpts = {\n          currentLocation: location,\n          nextLocation: state.location,\n        };\n      }\n    } else if (pendingViewTransitionEnabled) {\n      // Store the applied transition on PUSH/REPLACE\n      let toPaths = appliedViewTransitions.get(state.location.pathname);\n      if (toPaths) {\n        toPaths.add(location.pathname);\n      } else {\n        toPaths = new Set<string>([location.pathname]);\n        appliedViewTransitions.set(state.location.pathname, toPaths);\n      }\n      viewTransitionOpts = {\n        currentLocation: state.location,\n        nextLocation: location,\n      };\n    }\n\n    updateState(\n      {\n        ...newState, // matches, errors, fetchers go through as-is\n        actionData,\n        loaderData,\n        historyAction: pendingAction,\n        location,\n        initialized: true,\n        navigation: IDLE_NAVIGATION,\n        revalidation: \"idle\",\n        restoreScrollPosition: getSavedScrollPosition(\n          location,\n          newState.matches || state.matches\n        ),\n        preventScrollReset,\n        blockers,\n      },\n      {\n        viewTransitionOpts,\n        flushSync: flushSync === true,\n      }\n    );\n\n    // Reset stateful navigation vars\n    pendingAction = HistoryAction.Pop;\n    pendingPreventScrollReset = false;\n    pendingViewTransitionEnabled = false;\n    isUninterruptedRevalidation = false;\n    isRevalidationRequired = false;\n    cancelledDeferredRoutes = [];\n  }\n\n  // Trigger a navigation event, which can either be a numerical POP or a PUSH\n  // replace with an optional submission\n  async function navigate(\n    to: number | To | null,\n    opts?: RouterNavigateOptions\n  ): Promise<void> {\n    if (typeof to === \"number\") {\n      init.history.go(to);\n      return;\n    }\n\n    let normalizedPath = normalizeTo(\n      state.location,\n      state.matches,\n      basename,\n      future.v7_prependBasename,\n      to,\n      future.v7_relativeSplatPath,\n      opts?.fromRouteId,\n      opts?.relative\n    );\n    let { path, submission, error } = normalizeNavigateOptions(\n      future.v7_normalizeFormMethod,\n      false,\n      normalizedPath,\n      opts\n    );\n\n    let currentLocation = state.location;\n    let nextLocation = createLocation(state.location, path, opts && opts.state);\n\n    // When using navigate as a PUSH/REPLACE we aren't reading an already-encoded\n    // URL from window.location, so we need to encode it here so the behavior\n    // remains the same as POP and non-data-router usages.  new URL() does all\n    // the same encoding we'd get from a history.pushState/window.location read\n    // without having to touch history\n    nextLocation = {\n      ...nextLocation,\n      ...init.history.encodeLocation(nextLocation),\n    };\n\n    let userReplace = opts && opts.replace != null ? opts.replace : undefined;\n\n    let historyAction = HistoryAction.Push;\n\n    if (userReplace === true) {\n      historyAction = HistoryAction.Replace;\n    } else if (userReplace === false) {\n      // no-op\n    } else if (\n      submission != null &&\n      isMutationMethod(submission.formMethod) &&\n      submission.formAction === state.location.pathname + state.location.search\n    ) {\n      // By default on submissions to the current location we REPLACE so that\n      // users don't have to double-click the back button to get to the prior\n      // location.  If the user redirects to a different location from the\n      // action/loader this will be ignored and the redirect will be a PUSH\n      historyAction = HistoryAction.Replace;\n    }\n\n    let preventScrollReset =\n      opts && \"preventScrollReset\" in opts\n        ? opts.preventScrollReset === true\n        : undefined;\n\n    let flushSync = (opts && opts.flushSync) === true;\n\n    let blockerKey = shouldBlockNavigation({\n      currentLocation,\n      nextLocation,\n      historyAction,\n    });\n\n    if (blockerKey) {\n      // Put the blocker into a blocked state\n      updateBlocker(blockerKey, {\n        state: \"blocked\",\n        location: nextLocation,\n        proceed() {\n          updateBlocker(blockerKey!, {\n            state: \"proceeding\",\n            proceed: undefined,\n            reset: undefined,\n            location: nextLocation,\n          });\n          // Send the same navigation through\n          navigate(to, opts);\n        },\n        reset() {\n          let blockers = new Map(state.blockers);\n          blockers.set(blockerKey!, IDLE_BLOCKER);\n          updateState({ blockers });\n        },\n      });\n      return;\n    }\n\n    return await startNavigation(historyAction, nextLocation, {\n      submission,\n      // Send through the formData serialization error if we have one so we can\n      // render at the right error boundary after we match routes\n      pendingError: error,\n      preventScrollReset,\n      replace: opts && opts.replace,\n      enableViewTransition: opts && opts.viewTransition,\n      flushSync,\n    });\n  }\n\n  // Revalidate all current loaders.  If a navigation is in progress or if this\n  // is interrupted by a navigation, allow this to \"succeed\" by calling all\n  // loaders during the next loader round\n  function revalidate() {\n    interruptActiveLoads();\n    updateState({ revalidation: \"loading\" });\n\n    // If we're currently submitting an action, we don't need to start a new\n    // navigation, we'll just let the follow up loader execution call all loaders\n    if (state.navigation.state === \"submitting\") {\n      return;\n    }\n\n    // If we're currently in an idle state, start a new navigation for the current\n    // action/location and mark it as uninterrupted, which will skip the history\n    // update in completeNavigation\n    if (state.navigation.state === \"idle\") {\n      startNavigation(state.historyAction, state.location, {\n        startUninterruptedRevalidation: true,\n      });\n      return;\n    }\n\n    // Otherwise, if we're currently in a loading state, just start a new\n    // navigation to the navigation.location but do not trigger an uninterrupted\n    // revalidation so that history correctly updates once the navigation completes\n    startNavigation(\n      pendingAction || state.historyAction,\n      state.navigation.location,\n      {\n        overrideNavigation: state.navigation,\n        // Proxy through any rending view transition\n        enableViewTransition: pendingViewTransitionEnabled === true,\n      }\n    );\n  }\n\n  // Start a navigation to the given action/location.  Can optionally provide a\n  // overrideNavigation which will override the normalLoad in the case of a redirect\n  // navigation\n  async function startNavigation(\n    historyAction: HistoryAction,\n    location: Location,\n    opts?: {\n      initialHydration?: boolean;\n      submission?: Submission;\n      fetcherSubmission?: Submission;\n      overrideNavigation?: Navigation;\n      pendingError?: ErrorResponseImpl;\n      startUninterruptedRevalidation?: boolean;\n      preventScrollReset?: boolean;\n      replace?: boolean;\n      enableViewTransition?: boolean;\n      flushSync?: boolean;\n    }\n  ): Promise<void> {\n    // Abort any in-progress navigations and start a new one. Unset any ongoing\n    // uninterrupted revalidations unless told otherwise, since we want this\n    // new navigation to update history normally\n    pendingNavigationController && pendingNavigationController.abort();\n    pendingNavigationController = null;\n    pendingAction = historyAction;\n    isUninterruptedRevalidation =\n      (opts && opts.startUninterruptedRevalidation) === true;\n\n    // Save the current scroll position every time we start a new navigation,\n    // and track whether we should reset scroll on completion\n    saveScrollPosition(state.location, state.matches);\n    pendingPreventScrollReset = (opts && opts.preventScrollReset) === true;\n\n    pendingViewTransitionEnabled = (opts && opts.enableViewTransition) === true;\n\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    let loadingNavigation = opts && opts.overrideNavigation;\n    let matches =\n      opts?.initialHydration &&\n      state.matches &&\n      state.matches.length > 0 &&\n      !initialMatchesIsFOW\n        ? // `matchRoutes()` has already been called if we're in here via `router.initialize()`\n          state.matches\n        : matchRoutes(routesToUse, location, basename);\n    let flushSync = (opts && opts.flushSync) === true;\n\n    // Short circuit if it's only a hash change and not a revalidation or\n    // mutation submission.\n    //\n    // Ignore on initial page loads because since the initial hydration will always\n    // be \"same hash\".  For example, on /page#hash and submit a <Form method=\"post\">\n    // which will default to a navigation to /page\n    if (\n      matches &&\n      state.initialized &&\n      !isRevalidationRequired &&\n      isHashChangeOnly(state.location, location) &&\n      !(opts && opts.submission && isMutationMethod(opts.submission.formMethod))\n    ) {\n      completeNavigation(location, { matches }, { flushSync });\n      return;\n    }\n\n    let fogOfWar = checkFogOfWar(matches, routesToUse, location.pathname);\n    if (fogOfWar.active && fogOfWar.matches) {\n      matches = fogOfWar.matches;\n    }\n\n    // Short circuit with a 404 on the root error boundary if we match nothing\n    if (!matches) {\n      let { error, notFoundMatches, route } = handleNavigational404(\n        location.pathname\n      );\n      completeNavigation(\n        location,\n        {\n          matches: notFoundMatches,\n          loaderData: {},\n          errors: {\n            [route.id]: error,\n          },\n        },\n        { flushSync }\n      );\n      return;\n    }\n\n    // Create a controller/Request for this navigation\n    pendingNavigationController = new AbortController();\n    let request = createClientSideRequest(\n      init.history,\n      location,\n      pendingNavigationController.signal,\n      opts && opts.submission\n    );\n    let pendingActionResult: PendingActionResult | undefined;\n\n    if (opts && opts.pendingError) {\n      // If we have a pendingError, it means the user attempted a GET submission\n      // with binary FormData so assign here and skip to handleLoaders.  That\n      // way we handle calling loaders above the boundary etc.  It's not really\n      // different from an actionError in that sense.\n      pendingActionResult = [\n        findNearestBoundary(matches).route.id,\n        { type: ResultType.error, error: opts.pendingError },\n      ];\n    } else if (\n      opts &&\n      opts.submission &&\n      isMutationMethod(opts.submission.formMethod)\n    ) {\n      // Call action if we received an action submission\n      let actionResult = await handleAction(\n        request,\n        location,\n        opts.submission,\n        matches,\n        fogOfWar.active,\n        { replace: opts.replace, flushSync }\n      );\n\n      if (actionResult.shortCircuited) {\n        return;\n      }\n\n      // If we received a 404 from handleAction, it's because we couldn't lazily\n      // discover the destination route so we don't want to call loaders\n      if (actionResult.pendingActionResult) {\n        let [routeId, result] = actionResult.pendingActionResult;\n        if (\n          isErrorResult(result) &&\n          isRouteErrorResponse(result.error) &&\n          result.error.status === 404\n        ) {\n          pendingNavigationController = null;\n\n          completeNavigation(location, {\n            matches: actionResult.matches,\n            loaderData: {},\n            errors: {\n              [routeId]: result.error,\n            },\n          });\n          return;\n        }\n      }\n\n      matches = actionResult.matches || matches;\n      pendingActionResult = actionResult.pendingActionResult;\n      loadingNavigation = getLoadingNavigation(location, opts.submission);\n      flushSync = false;\n      // No need to do fog of war matching again on loader execution\n      fogOfWar.active = false;\n\n      // Create a GET request for the loaders\n      request = createClientSideRequest(\n        init.history,\n        request.url,\n        request.signal\n      );\n    }\n\n    // Call loaders\n    let {\n      shortCircuited,\n      matches: updatedMatches,\n      loaderData,\n      errors,\n    } = await handleLoaders(\n      request,\n      location,\n      matches,\n      fogOfWar.active,\n      loadingNavigation,\n      opts && opts.submission,\n      opts && opts.fetcherSubmission,\n      opts && opts.replace,\n      opts && opts.initialHydration === true,\n      flushSync,\n      pendingActionResult\n    );\n\n    if (shortCircuited) {\n      return;\n    }\n\n    // Clean up now that the action/loaders have completed.  Don't clean up if\n    // we short circuited because pendingNavigationController will have already\n    // been assigned to a new controller for the next navigation\n    pendingNavigationController = null;\n\n    completeNavigation(location, {\n      matches: updatedMatches || matches,\n      ...getActionDataForCommit(pendingActionResult),\n      loaderData,\n      errors,\n    });\n  }\n\n  // Call the action matched by the leaf route for this navigation and handle\n  // redirects/errors\n  async function handleAction(\n    request: Request,\n    location: Location,\n    submission: Submission,\n    matches: AgnosticDataRouteMatch[],\n    isFogOfWar: boolean,\n    opts: { replace?: boolean; flushSync?: boolean } = {}\n  ): Promise<HandleActionResult> {\n    interruptActiveLoads();\n\n    // Put us in a submitting state\n    let navigation = getSubmittingNavigation(location, submission);\n    updateState({ navigation }, { flushSync: opts.flushSync === true });\n\n    if (isFogOfWar) {\n      let discoverResult = await discoverRoutes(\n        matches,\n        location.pathname,\n        request.signal\n      );\n      if (discoverResult.type === \"aborted\") {\n        return { shortCircuited: true };\n      } else if (discoverResult.type === \"error\") {\n        let boundaryId = findNearestBoundary(discoverResult.partialMatches)\n          .route.id;\n        return {\n          matches: discoverResult.partialMatches,\n          pendingActionResult: [\n            boundaryId,\n            {\n              type: ResultType.error,\n              error: discoverResult.error,\n            },\n          ],\n        };\n      } else if (!discoverResult.matches) {\n        let { notFoundMatches, error, route } = handleNavigational404(\n          location.pathname\n        );\n        return {\n          matches: notFoundMatches,\n          pendingActionResult: [\n            route.id,\n            {\n              type: ResultType.error,\n              error,\n            },\n          ],\n        };\n      } else {\n        matches = discoverResult.matches;\n      }\n    }\n\n    // Call our action and get the result\n    let result: DataResult;\n    let actionMatch = getTargetMatch(matches, location);\n\n    if (!actionMatch.route.action && !actionMatch.route.lazy) {\n      result = {\n        type: ResultType.error,\n        error: getInternalRouterError(405, {\n          method: request.method,\n          pathname: location.pathname,\n          routeId: actionMatch.route.id,\n        }),\n      };\n    } else {\n      let results = await callDataStrategy(\n        \"action\",\n        state,\n        request,\n        [actionMatch],\n        matches,\n        null\n      );\n      result = results[actionMatch.route.id];\n\n      if (request.signal.aborted) {\n        return { shortCircuited: true };\n      }\n    }\n\n    if (isRedirectResult(result)) {\n      let replace: boolean;\n      if (opts && opts.replace != null) {\n        replace = opts.replace;\n      } else {\n        // If the user didn't explicity indicate replace behavior, replace if\n        // we redirected to the exact same location we're currently at to avoid\n        // double back-buttons\n        let location = normalizeRedirectLocation(\n          result.response.headers.get(\"Location\")!,\n          new URL(request.url),\n          basename,\n          init.history,\n        );\n        replace = location === state.location.pathname + state.location.search;\n      }\n      await startRedirectNavigation(request, result, true, {\n        submission,\n        replace,\n      });\n      return { shortCircuited: true };\n    }\n\n    if (isDeferredResult(result)) {\n      throw getInternalRouterError(400, { type: \"defer-action\" });\n    }\n\n    if (isErrorResult(result)) {\n      // Store off the pending error - we use it to determine which loaders\n      // to call and will commit it when we complete the navigation\n      let boundaryMatch = findNearestBoundary(matches, actionMatch.route.id);\n\n      // By default, all submissions to the current location are REPLACE\n      // navigations, but if the action threw an error that'll be rendered in\n      // an errorElement, we fall back to PUSH so that the user can use the\n      // back button to get back to the pre-submission form location to try\n      // again\n      if ((opts && opts.replace) !== true) {\n        pendingAction = HistoryAction.Push;\n      }\n\n      return {\n        matches,\n        pendingActionResult: [boundaryMatch.route.id, result],\n      };\n    }\n\n    return {\n      matches,\n      pendingActionResult: [actionMatch.route.id, result],\n    };\n  }\n\n  // Call all applicable loaders for the given matches, handling redirects,\n  // errors, etc.\n  async function handleLoaders(\n    request: Request,\n    location: Location,\n    matches: AgnosticDataRouteMatch[],\n    isFogOfWar: boolean,\n    overrideNavigation?: Navigation,\n    submission?: Submission,\n    fetcherSubmission?: Submission,\n    replace?: boolean,\n    initialHydration?: boolean,\n    flushSync?: boolean,\n    pendingActionResult?: PendingActionResult\n  ): Promise<HandleLoadersResult> {\n    // Figure out the right navigation we want to use for data loading\n    let loadingNavigation =\n      overrideNavigation || getLoadingNavigation(location, submission);\n\n    // If this was a redirect from an action we don't have a \"submission\" but\n    // we have it on the loading navigation so use that if available\n    let activeSubmission =\n      submission ||\n      fetcherSubmission ||\n      getSubmissionFromNavigation(loadingNavigation);\n\n    // If this is an uninterrupted revalidation, we remain in our current idle\n    // state.  If not, we need to switch to our loading state and load data,\n    // preserving any new action data or existing action data (in the case of\n    // a revalidation interrupting an actionReload)\n    // If we have partialHydration enabled, then don't update the state for the\n    // initial data load since it's not a \"navigation\"\n    let shouldUpdateNavigationState =\n      !isUninterruptedRevalidation &&\n      (!future.v7_partialHydration || !initialHydration);\n\n    // When fog of war is enabled, we enter our `loading` state earlier so we\n    // can discover new routes during the `loading` state.  We skip this if\n    // we've already run actions since we would have done our matching already.\n    // If the children() function threw then, we want to proceed with the\n    // partial matches it discovered.\n    if (isFogOfWar) {\n      if (shouldUpdateNavigationState) {\n        let actionData = getUpdatedActionData(pendingActionResult);\n        updateState(\n          {\n            navigation: loadingNavigation,\n            ...(actionData !== undefined ? { actionData } : {}),\n          },\n          {\n            flushSync,\n          }\n        );\n      }\n\n      let discoverResult = await discoverRoutes(\n        matches,\n        location.pathname,\n        request.signal\n      );\n\n      if (discoverResult.type === \"aborted\") {\n        return { shortCircuited: true };\n      } else if (discoverResult.type === \"error\") {\n        let boundaryId = findNearestBoundary(discoverResult.partialMatches)\n          .route.id;\n        return {\n          matches: discoverResult.partialMatches,\n          loaderData: {},\n          errors: {\n            [boundaryId]: discoverResult.error,\n          },\n        };\n      } else if (!discoverResult.matches) {\n        let { error, notFoundMatches, route } = handleNavigational404(\n          location.pathname\n        );\n        return {\n          matches: notFoundMatches,\n          loaderData: {},\n          errors: {\n            [route.id]: error,\n          },\n        };\n      } else {\n        matches = discoverResult.matches;\n      }\n    }\n\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(\n      init.history,\n      state,\n      matches,\n      activeSubmission,\n      location,\n      future.v7_partialHydration && initialHydration === true,\n      future.v7_skipActionErrorRevalidation,\n      isRevalidationRequired,\n      cancelledDeferredRoutes,\n      cancelledFetcherLoads,\n      deletedFetchers,\n      fetchLoadMatches,\n      fetchRedirectIds,\n      routesToUse,\n      basename,\n      pendingActionResult\n    );\n\n    // Cancel pending deferreds for no-longer-matched routes or routes we're\n    // about to reload.  Note that if this is an action reload we would have\n    // already cancelled all pending deferreds so this would be a no-op\n    cancelActiveDeferreds(\n      (routeId) =>\n        !(matches && matches.some((m) => m.route.id === routeId)) ||\n        (matchesToLoad && matchesToLoad.some((m) => m.route.id === routeId))\n    );\n\n    pendingNavigationLoadId = ++incrementingLoadId;\n\n    // Short circuit if we have no loaders to run\n    if (matchesToLoad.length === 0 && revalidatingFetchers.length === 0) {\n      let updatedFetchers = markFetchRedirectsDone();\n      completeNavigation(\n        location,\n        {\n          matches,\n          loaderData: {},\n          // Commit pending error if we're short circuiting\n          errors:\n            pendingActionResult && isErrorResult(pendingActionResult[1])\n              ? { [pendingActionResult[0]]: pendingActionResult[1].error }\n              : null,\n          ...getActionDataForCommit(pendingActionResult),\n          ...(updatedFetchers ? { fetchers: new Map(state.fetchers) } : {}),\n        },\n        { flushSync }\n      );\n      return { shortCircuited: true };\n    }\n\n    if (shouldUpdateNavigationState) {\n      let updates: Partial<RouterState> = {};\n      if (!isFogOfWar) {\n        // Only update navigation/actionNData if we didn't already do it above\n        updates.navigation = loadingNavigation;\n        let actionData = getUpdatedActionData(pendingActionResult);\n        if (actionData !== undefined) {\n          updates.actionData = actionData;\n        }\n      }\n      if (revalidatingFetchers.length > 0) {\n        updates.fetchers = getUpdatedRevalidatingFetchers(revalidatingFetchers);\n      }\n      updateState(updates, { flushSync });\n    }\n\n    revalidatingFetchers.forEach((rf) => {\n      abortFetcher(rf.key);\n      if (rf.controller) {\n        // Fetchers use an independent AbortController so that aborting a fetcher\n        // (via deleteFetcher) does not abort the triggering navigation that\n        // triggered the revalidation\n        fetchControllers.set(rf.key, rf.controller);\n      }\n    });\n\n    // Proxy navigation abort through to revalidation fetchers\n    let abortPendingFetchRevalidations = () =>\n      revalidatingFetchers.forEach((f) => abortFetcher(f.key));\n    if (pendingNavigationController) {\n      pendingNavigationController.signal.addEventListener(\n        \"abort\",\n        abortPendingFetchRevalidations\n      );\n    }\n\n    let { loaderResults, fetcherResults } =\n      await callLoadersAndMaybeResolveData(\n        state,\n        matches,\n        matchesToLoad,\n        revalidatingFetchers,\n        request\n      );\n\n    if (request.signal.aborted) {\n      return { shortCircuited: true };\n    }\n\n    // Clean up _after_ loaders have completed.  Don't clean up if we short\n    // circuited because fetchControllers would have been aborted and\n    // reassigned to new controllers for the next navigation\n    if (pendingNavigationController) {\n      pendingNavigationController.signal.removeEventListener(\n        \"abort\",\n        abortPendingFetchRevalidations\n      );\n    }\n\n    revalidatingFetchers.forEach((rf) => fetchControllers.delete(rf.key));\n\n    // If any loaders returned a redirect Response, start a new REPLACE navigation\n    let redirect = findRedirect(loaderResults);\n    if (redirect) {\n      await startRedirectNavigation(request, redirect.result, true, {\n        replace,\n      });\n      return { shortCircuited: true };\n    }\n\n    redirect = findRedirect(fetcherResults);\n    if (redirect) {\n      // If this redirect came from a fetcher make sure we mark it in\n      // fetchRedirectIds so it doesn't get revalidated on the next set of\n      // loader executions\n      fetchRedirectIds.add(redirect.key);\n      await startRedirectNavigation(request, redirect.result, true, {\n        replace,\n      });\n      return { shortCircuited: true };\n    }\n\n    // Process and commit output from loaders\n    let { loaderData, errors } = processLoaderData(\n      state,\n      matches,\n      loaderResults,\n      pendingActionResult,\n      revalidatingFetchers,\n      fetcherResults,\n      activeDeferreds\n    );\n\n    // Wire up subscribers to update loaderData as promises settle\n    activeDeferreds.forEach((deferredData, routeId) => {\n      deferredData.subscribe((aborted) => {\n        // Note: No need to updateState here since the TrackedPromise on\n        // loaderData is stable across resolve/reject\n        // Remove this instance if we were aborted or if promises have settled\n        if (aborted || deferredData.done) {\n          activeDeferreds.delete(routeId);\n        }\n      });\n    });\n\n    // Preserve SSR errors during partial hydration\n    if (future.v7_partialHydration && initialHydration && state.errors) {\n      errors = { ...state.errors, ...errors };\n    }\n\n    let updatedFetchers = markFetchRedirectsDone();\n    let didAbortFetchLoads = abortStaleFetchLoads(pendingNavigationLoadId);\n    let shouldUpdateFetchers =\n      updatedFetchers || didAbortFetchLoads || revalidatingFetchers.length > 0;\n\n    return {\n      matches,\n      loaderData,\n      errors,\n      ...(shouldUpdateFetchers ? { fetchers: new Map(state.fetchers) } : {}),\n    };\n  }\n\n  function getUpdatedActionData(\n    pendingActionResult: PendingActionResult | undefined\n  ): Record<string, RouteData> | null | undefined {\n    if (pendingActionResult && !isErrorResult(pendingActionResult[1])) {\n      // This is cast to `any` currently because `RouteData`uses any and it\n      // would be a breaking change to use any.\n      // TODO: v7 - change `RouteData` to use `unknown` instead of `any`\n      return {\n        [pendingActionResult[0]]: pendingActionResult[1].data as any,\n      };\n    } else if (state.actionData) {\n      if (Object.keys(state.actionData).length === 0) {\n        return null;\n      } else {\n        return state.actionData;\n      }\n    }\n  }\n\n  function getUpdatedRevalidatingFetchers(\n    revalidatingFetchers: RevalidatingFetcher[]\n  ) {\n    revalidatingFetchers.forEach((rf) => {\n      let fetcher = state.fetchers.get(rf.key);\n      let revalidatingFetcher = getLoadingFetcher(\n        undefined,\n        fetcher ? fetcher.data : undefined\n      );\n      state.fetchers.set(rf.key, revalidatingFetcher);\n    });\n    return new Map(state.fetchers);\n  }\n\n  // Trigger a fetcher load/submit for the given fetcher key\n  function fetch(\n    key: string,\n    routeId: string,\n    href: string | null,\n    opts?: RouterFetchOptions\n  ) {\n    if (isServer) {\n      throw new Error(\n        \"router.fetch() was called during the server render, but it shouldn't be. \" +\n          \"You are likely calling a useFetcher() method in the body of your component. \" +\n          \"Try moving it to a useEffect or a callback.\"\n      );\n    }\n\n    abortFetcher(key);\n\n    let flushSync = (opts && opts.flushSync) === true;\n\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    let normalizedPath = normalizeTo(\n      state.location,\n      state.matches,\n      basename,\n      future.v7_prependBasename,\n      href,\n      future.v7_relativeSplatPath,\n      routeId,\n      opts?.relative\n    );\n    let matches = matchRoutes(routesToUse, normalizedPath, basename);\n\n    let fogOfWar = checkFogOfWar(matches, routesToUse, normalizedPath);\n    if (fogOfWar.active && fogOfWar.matches) {\n      matches = fogOfWar.matches;\n    }\n\n    if (!matches) {\n      setFetcherError(\n        key,\n        routeId,\n        getInternalRouterError(404, { pathname: normalizedPath }),\n        { flushSync }\n      );\n      return;\n    }\n\n    let { path, submission, error } = normalizeNavigateOptions(\n      future.v7_normalizeFormMethod,\n      true,\n      normalizedPath,\n      opts\n    );\n\n    if (error) {\n      setFetcherError(key, routeId, error, { flushSync });\n      return;\n    }\n\n    let match = getTargetMatch(matches, path);\n\n    let preventScrollReset = (opts && opts.preventScrollReset) === true;\n\n    if (submission && isMutationMethod(submission.formMethod)) {\n      handleFetcherAction(\n        key,\n        routeId,\n        path,\n        match,\n        matches,\n        fogOfWar.active,\n        flushSync,\n        preventScrollReset,\n        submission\n      );\n      return;\n    }\n\n    // Store off the match so we can call it's shouldRevalidate on subsequent\n    // revalidations\n    fetchLoadMatches.set(key, { routeId, path });\n    handleFetcherLoader(\n      key,\n      routeId,\n      path,\n      match,\n      matches,\n      fogOfWar.active,\n      flushSync,\n      preventScrollReset,\n      submission\n    );\n  }\n\n  // Call the action for the matched fetcher.submit(), and then handle redirects,\n  // errors, and revalidation\n  async function handleFetcherAction(\n    key: string,\n    routeId: string,\n    path: string,\n    match: AgnosticDataRouteMatch,\n    requestMatches: AgnosticDataRouteMatch[],\n    isFogOfWar: boolean,\n    flushSync: boolean,\n    preventScrollReset: boolean,\n    submission: Submission\n  ) {\n    interruptActiveLoads();\n    fetchLoadMatches.delete(key);\n\n    function detectAndHandle405Error(m: AgnosticDataRouteMatch) {\n      if (!m.route.action && !m.route.lazy) {\n        let error = getInternalRouterError(405, {\n          method: submission.formMethod,\n          pathname: path,\n          routeId: routeId,\n        });\n        setFetcherError(key, routeId, error, { flushSync });\n        return true;\n      }\n      return false;\n    }\n\n    if (!isFogOfWar && detectAndHandle405Error(match)) {\n      return;\n    }\n\n    // Put this fetcher into it's submitting state\n    let existingFetcher = state.fetchers.get(key);\n    updateFetcherState(key, getSubmittingFetcher(submission, existingFetcher), {\n      flushSync,\n    });\n\n    let abortController = new AbortController();\n    let fetchRequest = createClientSideRequest(\n      init.history,\n      path,\n      abortController.signal,\n      submission\n    );\n\n    if (isFogOfWar) {\n      let discoverResult = await discoverRoutes(\n        requestMatches,\n        new URL(fetchRequest.url).pathname,\n        fetchRequest.signal,\n        key\n      );\n\n      if (discoverResult.type === \"aborted\") {\n        return;\n      } else if (discoverResult.type === \"error\") {\n        setFetcherError(key, routeId, discoverResult.error, { flushSync });\n        return;\n      } else if (!discoverResult.matches) {\n        setFetcherError(\n          key,\n          routeId,\n          getInternalRouterError(404, { pathname: path }),\n          { flushSync }\n        );\n        return;\n      } else {\n        requestMatches = discoverResult.matches;\n        match = getTargetMatch(requestMatches, path);\n\n        if (detectAndHandle405Error(match)) {\n          return;\n        }\n      }\n    }\n\n    // Call the action for the fetcher\n    fetchControllers.set(key, abortController);\n\n    let originatingLoadId = incrementingLoadId;\n    let actionResults = await callDataStrategy(\n      \"action\",\n      state,\n      fetchRequest,\n      [match],\n      requestMatches,\n      key\n    );\n    let actionResult = actionResults[match.route.id];\n\n    if (fetchRequest.signal.aborted) {\n      // We can delete this so long as we weren't aborted by our own fetcher\n      // re-submit which would have put _new_ controller is in fetchControllers\n      if (fetchControllers.get(key) === abortController) {\n        fetchControllers.delete(key);\n      }\n      return;\n    }\n\n    // When using v7_fetcherPersist, we don't want errors bubbling up to the UI\n    // or redirects processed for unmounted fetchers so we just revert them to\n    // idle\n    if (future.v7_fetcherPersist && deletedFetchers.has(key)) {\n      if (isRedirectResult(actionResult) || isErrorResult(actionResult)) {\n        updateFetcherState(key, getDoneFetcher(undefined));\n        return;\n      }\n      // Let SuccessResult's fall through for revalidation\n    } else {\n      if (isRedirectResult(actionResult)) {\n        fetchControllers.delete(key);\n        if (pendingNavigationLoadId > originatingLoadId) {\n          // A new navigation was kicked off after our action started, so that\n          // should take precedence over this redirect navigation.  We already\n          // set isRevalidationRequired so all loaders for the new route should\n          // fire unless opted out via shouldRevalidate\n          updateFetcherState(key, getDoneFetcher(undefined));\n          return;\n        } else {\n          fetchRedirectIds.add(key);\n          updateFetcherState(key, getLoadingFetcher(submission));\n          return startRedirectNavigation(fetchRequest, actionResult, false, {\n            fetcherSubmission: submission,\n            preventScrollReset,\n          });\n        }\n      }\n\n      // Process any non-redirect errors thrown\n      if (isErrorResult(actionResult)) {\n        setFetcherError(key, routeId, actionResult.error);\n        return;\n      }\n    }\n\n    if (isDeferredResult(actionResult)) {\n      throw getInternalRouterError(400, { type: \"defer-action\" });\n    }\n\n    // Start the data load for current matches, or the next location if we're\n    // in the middle of a navigation\n    let nextLocation = state.navigation.location || state.location;\n    let revalidationRequest = createClientSideRequest(\n      init.history,\n      nextLocation,\n      abortController.signal\n    );\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    let matches =\n      state.navigation.state !== \"idle\"\n        ? matchRoutes(routesToUse, state.navigation.location, basename)\n        : state.matches;\n\n    invariant(matches, \"Didn't find any matches after fetcher action\");\n\n    let loadId = ++incrementingLoadId;\n    fetchReloadIds.set(key, loadId);\n\n    let loadFetcher = getLoadingFetcher(submission, actionResult.data);\n    state.fetchers.set(key, loadFetcher);\n\n    let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(\n      init.history,\n      state,\n      matches,\n      submission,\n      nextLocation,\n      false,\n      future.v7_skipActionErrorRevalidation,\n      isRevalidationRequired,\n      cancelledDeferredRoutes,\n      cancelledFetcherLoads,\n      deletedFetchers,\n      fetchLoadMatches,\n      fetchRedirectIds,\n      routesToUse,\n      basename,\n      [match.route.id, actionResult]\n    );\n\n    // Put all revalidating fetchers into the loading state, except for the\n    // current fetcher which we want to keep in it's current loading state which\n    // contains it's action submission info + action data\n    revalidatingFetchers\n      .filter((rf) => rf.key !== key)\n      .forEach((rf) => {\n        let staleKey = rf.key;\n        let existingFetcher = state.fetchers.get(staleKey);\n        let revalidatingFetcher = getLoadingFetcher(\n          undefined,\n          existingFetcher ? existingFetcher.data : undefined\n        );\n        state.fetchers.set(staleKey, revalidatingFetcher);\n        abortFetcher(staleKey);\n        if (rf.controller) {\n          fetchControllers.set(staleKey, rf.controller);\n        }\n      });\n\n    updateState({ fetchers: new Map(state.fetchers) });\n\n    let abortPendingFetchRevalidations = () =>\n      revalidatingFetchers.forEach((rf) => abortFetcher(rf.key));\n\n    abortController.signal.addEventListener(\n      \"abort\",\n      abortPendingFetchRevalidations\n    );\n\n    let { loaderResults, fetcherResults } =\n      await callLoadersAndMaybeResolveData(\n        state,\n        matches,\n        matchesToLoad,\n        revalidatingFetchers,\n        revalidationRequest\n      );\n\n    if (abortController.signal.aborted) {\n      return;\n    }\n\n    abortController.signal.removeEventListener(\n      \"abort\",\n      abortPendingFetchRevalidations\n    );\n\n    fetchReloadIds.delete(key);\n    fetchControllers.delete(key);\n    revalidatingFetchers.forEach((r) => fetchControllers.delete(r.key));\n\n    let redirect = findRedirect(loaderResults);\n    if (redirect) {\n      return startRedirectNavigation(\n        revalidationRequest,\n        redirect.result,\n        false,\n        { preventScrollReset }\n      );\n    }\n\n    redirect = findRedirect(fetcherResults);\n    if (redirect) {\n      // If this redirect came from a fetcher make sure we mark it in\n      // fetchRedirectIds so it doesn't get revalidated on the next set of\n      // loader executions\n      fetchRedirectIds.add(redirect.key);\n      return startRedirectNavigation(\n        revalidationRequest,\n        redirect.result,\n        false,\n        { preventScrollReset }\n      );\n    }\n\n    // Process and commit output from loaders\n    let { loaderData, errors } = processLoaderData(\n      state,\n      matches,\n      loaderResults,\n      undefined,\n      revalidatingFetchers,\n      fetcherResults,\n      activeDeferreds\n    );\n\n    // Since we let revalidations complete even if the submitting fetcher was\n    // deleted, only put it back to idle if it hasn't been deleted\n    if (state.fetchers.has(key)) {\n      let doneFetcher = getDoneFetcher(actionResult.data);\n      state.fetchers.set(key, doneFetcher);\n    }\n\n    abortStaleFetchLoads(loadId);\n\n    // If we are currently in a navigation loading state and this fetcher is\n    // more recent than the navigation, we want the newer data so abort the\n    // navigation and complete it with the fetcher data\n    if (\n      state.navigation.state === \"loading\" &&\n      loadId > pendingNavigationLoadId\n    ) {\n      invariant(pendingAction, \"Expected pending action\");\n      pendingNavigationController && pendingNavigationController.abort();\n\n      completeNavigation(state.navigation.location, {\n        matches,\n        loaderData,\n        errors,\n        fetchers: new Map(state.fetchers),\n      });\n    } else {\n      // otherwise just update with the fetcher data, preserving any existing\n      // loaderData for loaders that did not need to reload.  We have to\n      // manually merge here since we aren't going through completeNavigation\n      updateState({\n        errors,\n        loaderData: mergeLoaderData(\n          state.loaderData,\n          loaderData,\n          matches,\n          errors\n        ),\n        fetchers: new Map(state.fetchers),\n      });\n      isRevalidationRequired = false;\n    }\n  }\n\n  // Call the matched loader for fetcher.load(), handling redirects, errors, etc.\n  async function handleFetcherLoader(\n    key: string,\n    routeId: string,\n    path: string,\n    match: AgnosticDataRouteMatch,\n    matches: AgnosticDataRouteMatch[],\n    isFogOfWar: boolean,\n    flushSync: boolean,\n    preventScrollReset: boolean,\n    submission?: Submission\n  ) {\n    let existingFetcher = state.fetchers.get(key);\n    updateFetcherState(\n      key,\n      getLoadingFetcher(\n        submission,\n        existingFetcher ? existingFetcher.data : undefined\n      ),\n      { flushSync }\n    );\n\n    let abortController = new AbortController();\n    let fetchRequest = createClientSideRequest(\n      init.history,\n      path,\n      abortController.signal\n    );\n\n    if (isFogOfWar) {\n      let discoverResult = await discoverRoutes(\n        matches,\n        new URL(fetchRequest.url).pathname,\n        fetchRequest.signal,\n        key\n      );\n\n      if (discoverResult.type === \"aborted\") {\n        return;\n      } else if (discoverResult.type === \"error\") {\n        setFetcherError(key, routeId, discoverResult.error, { flushSync });\n        return;\n      } else if (!discoverResult.matches) {\n        setFetcherError(\n          key,\n          routeId,\n          getInternalRouterError(404, { pathname: path }),\n          { flushSync }\n        );\n        return;\n      } else {\n        matches = discoverResult.matches;\n        match = getTargetMatch(matches, path);\n      }\n    }\n\n    // Call the loader for this fetcher route match\n    fetchControllers.set(key, abortController);\n\n    let originatingLoadId = incrementingLoadId;\n    let results = await callDataStrategy(\n      \"loader\",\n      state,\n      fetchRequest,\n      [match],\n      matches,\n      key\n    );\n    let result = results[match.route.id];\n\n    // Deferred isn't supported for fetcher loads, await everything and treat it\n    // as a normal load.  resolveDeferredData will return undefined if this\n    // fetcher gets aborted, so we just leave result untouched and short circuit\n    // below if that happens\n    if (isDeferredResult(result)) {\n      result =\n        (await resolveDeferredData(result, fetchRequest.signal, true)) ||\n        result;\n    }\n\n    // We can delete this so long as we weren't aborted by our our own fetcher\n    // re-load which would have put _new_ controller is in fetchControllers\n    if (fetchControllers.get(key) === abortController) {\n      fetchControllers.delete(key);\n    }\n\n    if (fetchRequest.signal.aborted) {\n      return;\n    }\n\n    // We don't want errors bubbling up or redirects followed for unmounted\n    // fetchers, so short circuit here if it was removed from the UI\n    if (deletedFetchers.has(key)) {\n      updateFetcherState(key, getDoneFetcher(undefined));\n      return;\n    }\n\n    // If the loader threw a redirect Response, start a new REPLACE navigation\n    if (isRedirectResult(result)) {\n      if (pendingNavigationLoadId > originatingLoadId) {\n        // A new navigation was kicked off after our loader started, so that\n        // should take precedence over this redirect navigation\n        updateFetcherState(key, getDoneFetcher(undefined));\n        return;\n      } else {\n        fetchRedirectIds.add(key);\n        await startRedirectNavigation(fetchRequest, result, false, {\n          preventScrollReset,\n        });\n        return;\n      }\n    }\n\n    // Process any non-redirect errors thrown\n    if (isErrorResult(result)) {\n      setFetcherError(key, routeId, result.error);\n      return;\n    }\n\n    invariant(!isDeferredResult(result), \"Unhandled fetcher deferred data\");\n\n    // Put the fetcher back into an idle state\n    updateFetcherState(key, getDoneFetcher(result.data));\n  }\n\n  /**\n   * Utility function to handle redirects returned from an action or loader.\n   * Normally, a redirect \"replaces\" the navigation that triggered it.  So, for\n   * example:\n   *\n   *  - user is on /a\n   *  - user clicks a link to /b\n   *  - loader for /b redirects to /c\n   *\n   * In a non-JS app the browser would track the in-flight navigation to /b and\n   * then replace it with /c when it encountered the redirect response.  In\n   * the end it would only ever update the URL bar with /c.\n   *\n   * In client-side routing using pushState/replaceState, we aim to emulate\n   * this behavior and we also do not update history until the end of the\n   * navigation (including processed redirects).  This means that we never\n   * actually touch history until we've processed redirects, so we just use\n   * the history action from the original navigation (PUSH or REPLACE).\n   */\n  async function startRedirectNavigation(\n    request: Request,\n    redirect: RedirectResult,\n    isNavigation: boolean,\n    {\n      submission,\n      fetcherSubmission,\n      preventScrollReset,\n      replace,\n    }: {\n      submission?: Submission;\n      fetcherSubmission?: Submission;\n      preventScrollReset?: boolean;\n      replace?: boolean;\n    } = {}\n  ) {\n    if (redirect.response.headers.has(\"X-Remix-Revalidate\")) {\n      isRevalidationRequired = true;\n    }\n\n    let location = redirect.response.headers.get(\"Location\");\n    invariant(location, \"Expected a Location header on the redirect Response\");\n    location = normalizeRedirectLocation(\n      location,\n      new URL(request.url),\n      basename,\n      init.history,\n    );\n    let redirectLocation = createLocation(state.location, location, {\n      _isRedirect: true,\n    });\n\n    if (isBrowser) {\n      let isDocumentReload = false;\n\n      if (redirect.response.headers.has(\"X-Remix-Reload-Document\")) {\n        // Hard reload if the response contained X-Remix-Reload-Document\n        isDocumentReload = true;\n      } else if (ABSOLUTE_URL_REGEX.test(location)) {\n        const url = init.history.createURL(location);\n        isDocumentReload =\n          // Hard reload if it's an absolute URL to a new origin\n          url.origin !== routerWindow.location.origin ||\n          // Hard reload if it's an absolute URL that does not match our basename\n          stripBasename(url.pathname, basename) == null;\n      }\n\n      if (isDocumentReload) {\n        if (replace) {\n          routerWindow.location.replace(location);\n        } else {\n          routerWindow.location.assign(location);\n        }\n        return;\n      }\n    }\n\n    // There's no need to abort on redirects, since we don't detect the\n    // redirect until the action/loaders have settled\n    pendingNavigationController = null;\n\n    let redirectHistoryAction =\n      replace === true || redirect.response.headers.has(\"X-Remix-Replace\")\n        ? HistoryAction.Replace\n        : HistoryAction.Push;\n\n    // Use the incoming submission if provided, fallback on the active one in\n    // state.navigation\n    let { formMethod, formAction, formEncType } = state.navigation;\n    if (\n      !submission &&\n      !fetcherSubmission &&\n      formMethod &&\n      formAction &&\n      formEncType\n    ) {\n      submission = getSubmissionFromNavigation(state.navigation);\n    }\n\n    // If this was a 307/308 submission we want to preserve the HTTP method and\n    // re-submit the GET/POST/PUT/PATCH/DELETE as a submission navigation to the\n    // redirected location\n    let activeSubmission = submission || fetcherSubmission;\n    if (\n      redirectPreserveMethodStatusCodes.has(redirect.response.status) &&\n      activeSubmission &&\n      isMutationMethod(activeSubmission.formMethod)\n    ) {\n      await startNavigation(redirectHistoryAction, redirectLocation, {\n        submission: {\n          ...activeSubmission,\n          formAction: location,\n        },\n        // Preserve these flags across redirects\n        preventScrollReset: preventScrollReset || pendingPreventScrollReset,\n        enableViewTransition: isNavigation\n          ? pendingViewTransitionEnabled\n          : undefined,\n      });\n    } else {\n      // If we have a navigation submission, we will preserve it through the\n      // redirect navigation\n      let overrideNavigation = getLoadingNavigation(\n        redirectLocation,\n        submission\n      );\n      await startNavigation(redirectHistoryAction, redirectLocation, {\n        overrideNavigation,\n        // Send fetcher submissions through for shouldRevalidate\n        fetcherSubmission,\n        // Preserve these flags across redirects\n        preventScrollReset: preventScrollReset || pendingPreventScrollReset,\n        enableViewTransition: isNavigation\n          ? pendingViewTransitionEnabled\n          : undefined,\n      });\n    }\n  }\n\n  // Utility wrapper for calling dataStrategy client-side without having to\n  // pass around the manifest, mapRouteProperties, etc.\n  async function callDataStrategy(\n    type: \"loader\" | \"action\",\n    state: RouterState,\n    request: Request,\n    matchesToLoad: AgnosticDataRouteMatch[],\n    matches: AgnosticDataRouteMatch[],\n    fetcherKey: string | null\n  ): Promise<Record<string, DataResult>> {\n    let results: Record<string, DataStrategyResult>;\n    let dataResults: Record<string, DataResult> = {};\n    try {\n      results = await callDataStrategyImpl(\n        dataStrategyImpl,\n        type,\n        state,\n        request,\n        matchesToLoad,\n        matches,\n        fetcherKey,\n        manifest,\n        mapRouteProperties\n      );\n    } catch (e) {\n      // If the outer dataStrategy method throws, just return the error for all\n      // matches - and it'll naturally bubble to the root\n      matchesToLoad.forEach((m) => {\n        dataResults[m.route.id] = {\n          type: ResultType.error,\n          error: e,\n        };\n      });\n      return dataResults;\n    }\n\n    for (let [routeId, result] of Object.entries(results)) {\n      if (isRedirectDataStrategyResultResult(result)) {\n        let response = result.result as Response;\n        dataResults[routeId] = {\n          type: ResultType.redirect,\n          response: normalizeRelativeRoutingRedirectResponse(\n            response,\n            request,\n            routeId,\n            matches,\n            basename,\n            future.v7_relativeSplatPath\n          ),\n        };\n      } else {\n        dataResults[routeId] = await convertDataStrategyResultToDataResult(\n          result\n        );\n      }\n    }\n\n    return dataResults;\n  }\n\n  async function callLoadersAndMaybeResolveData(\n    state: RouterState,\n    matches: AgnosticDataRouteMatch[],\n    matchesToLoad: AgnosticDataRouteMatch[],\n    fetchersToLoad: RevalidatingFetcher[],\n    request: Request\n  ) {\n    let currentMatches = state.matches;\n\n    // Kick off loaders and fetchers in parallel\n    let loaderResultsPromise = callDataStrategy(\n      \"loader\",\n      state,\n      request,\n      matchesToLoad,\n      matches,\n      null\n    );\n\n    let fetcherResultsPromise = Promise.all(\n      fetchersToLoad.map(async (f) => {\n        if (f.matches && f.match && f.controller) {\n          let results = await callDataStrategy(\n            \"loader\",\n            state,\n            createClientSideRequest(init.history, f.path, f.controller.signal),\n            [f.match],\n            f.matches,\n            f.key\n          );\n          let result = results[f.match.route.id];\n          // Fetcher results are keyed by fetcher key from here on out, not routeId\n          return { [f.key]: result };\n        } else {\n          return Promise.resolve({\n            [f.key]: {\n              type: ResultType.error,\n              error: getInternalRouterError(404, {\n                pathname: f.path,\n              }),\n            } as ErrorResult,\n          });\n        }\n      })\n    );\n\n    let loaderResults = await loaderResultsPromise;\n    let fetcherResults = (await fetcherResultsPromise).reduce(\n      (acc, r) => Object.assign(acc, r),\n      {}\n    );\n\n    await Promise.all([\n      resolveNavigationDeferredResults(\n        matches,\n        loaderResults,\n        request.signal,\n        currentMatches,\n        state.loaderData\n      ),\n      resolveFetcherDeferredResults(matches, fetcherResults, fetchersToLoad),\n    ]);\n\n    return {\n      loaderResults,\n      fetcherResults,\n    };\n  }\n\n  function interruptActiveLoads() {\n    // Every interruption triggers a revalidation\n    isRevalidationRequired = true;\n\n    // Cancel pending route-level deferreds and mark cancelled routes for\n    // revalidation\n    cancelledDeferredRoutes.push(...cancelActiveDeferreds());\n\n    // Abort in-flight fetcher loads\n    fetchLoadMatches.forEach((_, key) => {\n      if (fetchControllers.has(key)) {\n        cancelledFetcherLoads.add(key);\n      }\n      abortFetcher(key);\n    });\n  }\n\n  function updateFetcherState(\n    key: string,\n    fetcher: Fetcher,\n    opts: { flushSync?: boolean } = {}\n  ) {\n    state.fetchers.set(key, fetcher);\n    updateState(\n      { fetchers: new Map(state.fetchers) },\n      { flushSync: (opts && opts.flushSync) === true }\n    );\n  }\n\n  function setFetcherError(\n    key: string,\n    routeId: string,\n    error: any,\n    opts: { flushSync?: boolean } = {}\n  ) {\n    let boundaryMatch = findNearestBoundary(state.matches, routeId);\n    deleteFetcher(key);\n    updateState(\n      {\n        errors: {\n          [boundaryMatch.route.id]: error,\n        },\n        fetchers: new Map(state.fetchers),\n      },\n      { flushSync: (opts && opts.flushSync) === true }\n    );\n  }\n\n  function getFetcher<TData = any>(key: string): Fetcher<TData> {\n    activeFetchers.set(key, (activeFetchers.get(key) || 0) + 1);\n    // If this fetcher was previously marked for deletion, unmark it since we\n    // have a new instance\n    if (deletedFetchers.has(key)) {\n      deletedFetchers.delete(key);\n    }\n    return state.fetchers.get(key) || IDLE_FETCHER;\n  }\n\n  function deleteFetcher(key: string): void {\n    let fetcher = state.fetchers.get(key);\n    // Don't abort the controller if this is a deletion of a fetcher.submit()\n    // in it's loading phase since - we don't want to abort the corresponding\n    // revalidation and want them to complete and land\n    if (\n      fetchControllers.has(key) &&\n      !(fetcher && fetcher.state === \"loading\" && fetchReloadIds.has(key))\n    ) {\n      abortFetcher(key);\n    }\n    fetchLoadMatches.delete(key);\n    fetchReloadIds.delete(key);\n    fetchRedirectIds.delete(key);\n\n    // If we opted into the flag we can clear this now since we're calling\n    // deleteFetcher() at the end of updateState() and we've already handed the\n    // deleted fetcher keys off to the data layer.\n    // If not, we're eagerly calling deleteFetcher() and we need to keep this\n    // Set populated until the next updateState call, and we'll clear\n    // `deletedFetchers` then\n    if (future.v7_fetcherPersist) {\n      deletedFetchers.delete(key);\n    }\n\n    cancelledFetcherLoads.delete(key);\n    state.fetchers.delete(key);\n  }\n\n  function deleteFetcherAndUpdateState(key: string): void {\n    let count = (activeFetchers.get(key) || 0) - 1;\n    if (count <= 0) {\n      activeFetchers.delete(key);\n      deletedFetchers.add(key);\n      if (!future.v7_fetcherPersist) {\n        deleteFetcher(key);\n      }\n    } else {\n      activeFetchers.set(key, count);\n    }\n\n    updateState({ fetchers: new Map(state.fetchers) });\n  }\n\n  function abortFetcher(key: string) {\n    let controller = fetchControllers.get(key);\n    if (controller) {\n      controller.abort();\n      fetchControllers.delete(key);\n    }\n  }\n\n  function markFetchersDone(keys: string[]) {\n    for (let key of keys) {\n      let fetcher = getFetcher(key);\n      let doneFetcher = getDoneFetcher(fetcher.data);\n      state.fetchers.set(key, doneFetcher);\n    }\n  }\n\n  function markFetchRedirectsDone(): boolean {\n    let doneKeys = [];\n    let updatedFetchers = false;\n    for (let key of fetchRedirectIds) {\n      let fetcher = state.fetchers.get(key);\n      invariant(fetcher, `Expected fetcher: ${key}`);\n      if (fetcher.state === \"loading\") {\n        fetchRedirectIds.delete(key);\n        doneKeys.push(key);\n        updatedFetchers = true;\n      }\n    }\n    markFetchersDone(doneKeys);\n    return updatedFetchers;\n  }\n\n  function abortStaleFetchLoads(landedId: number): boolean {\n    let yeetedKeys = [];\n    for (let [key, id] of fetchReloadIds) {\n      if (id < landedId) {\n        let fetcher = state.fetchers.get(key);\n        invariant(fetcher, `Expected fetcher: ${key}`);\n        if (fetcher.state === \"loading\") {\n          abortFetcher(key);\n          fetchReloadIds.delete(key);\n          yeetedKeys.push(key);\n        }\n      }\n    }\n    markFetchersDone(yeetedKeys);\n    return yeetedKeys.length > 0;\n  }\n\n  function getBlocker(key: string, fn: BlockerFunction) {\n    let blocker: Blocker = state.blockers.get(key) || IDLE_BLOCKER;\n\n    if (blockerFunctions.get(key) !== fn) {\n      blockerFunctions.set(key, fn);\n    }\n\n    return blocker;\n  }\n\n  function deleteBlocker(key: string) {\n    state.blockers.delete(key);\n    blockerFunctions.delete(key);\n  }\n\n  // Utility function to update blockers, ensuring valid state transitions\n  function updateBlocker(key: string, newBlocker: Blocker) {\n    let blocker = state.blockers.get(key) || IDLE_BLOCKER;\n\n    // Poor mans state machine :)\n    // https://mermaid.live/edit#pako:eNqVkc9OwzAMxl8l8nnjAYrEtDIOHEBIgwvKJTReGy3_lDpIqO27k6awMG0XcrLlnz87nwdonESogKXXBuE79rq75XZO3-yHds0RJVuv70YrPlUrCEe2HfrORS3rubqZfuhtpg5C9wk5tZ4VKcRUq88q9Z8RS0-48cE1iHJkL0ugbHuFLus9L6spZy8nX9MP2CNdomVaposqu3fGayT8T8-jJQwhepo_UtpgBQaDEUom04dZhAN1aJBDlUKJBxE1ceB2Smj0Mln-IBW5AFU2dwUiktt_2Qaq2dBfaKdEup85UV7Yd-dKjlnkabl2Pvr0DTkTreM\n    invariant(\n      (blocker.state === \"unblocked\" && newBlocker.state === \"blocked\") ||\n        (blocker.state === \"blocked\" && newBlocker.state === \"blocked\") ||\n        (blocker.state === \"blocked\" && newBlocker.state === \"proceeding\") ||\n        (blocker.state === \"blocked\" && newBlocker.state === \"unblocked\") ||\n        (blocker.state === \"proceeding\" && newBlocker.state === \"unblocked\"),\n      `Invalid blocker state transition: ${blocker.state} -> ${newBlocker.state}`\n    );\n\n    let blockers = new Map(state.blockers);\n    blockers.set(key, newBlocker);\n    updateState({ blockers });\n  }\n\n  function shouldBlockNavigation({\n    currentLocation,\n    nextLocation,\n    historyAction,\n  }: {\n    currentLocation: Location;\n    nextLocation: Location;\n    historyAction: HistoryAction;\n  }): string | undefined {\n    if (blockerFunctions.size === 0) {\n      return;\n    }\n\n    // We ony support a single active blocker at the moment since we don't have\n    // any compelling use cases for multi-blocker yet\n    if (blockerFunctions.size > 1) {\n      warning(false, \"A router only supports one blocker at a time\");\n    }\n\n    let entries = Array.from(blockerFunctions.entries());\n    let [blockerKey, blockerFunction] = entries[entries.length - 1];\n    let blocker = state.blockers.get(blockerKey);\n\n    if (blocker && blocker.state === \"proceeding\") {\n      // If the blocker is currently proceeding, we don't need to re-check\n      // it and can let this navigation continue\n      return;\n    }\n\n    // At this point, we know we're unblocked/blocked so we need to check the\n    // user-provided blocker function\n    if (blockerFunction({ currentLocation, nextLocation, historyAction })) {\n      return blockerKey;\n    }\n  }\n\n  function handleNavigational404(pathname: string) {\n    let error = getInternalRouterError(404, { pathname });\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    let { matches, route } = getShortCircuitMatches(routesToUse);\n\n    // Cancel all pending deferred on 404s since we don't keep any routes\n    cancelActiveDeferreds();\n\n    return { notFoundMatches: matches, route, error };\n  }\n\n  function cancelActiveDeferreds(\n    predicate?: (routeId: string) => boolean\n  ): string[] {\n    let cancelledRouteIds: string[] = [];\n    activeDeferreds.forEach((dfd, routeId) => {\n      if (!predicate || predicate(routeId)) {\n        // Cancel the deferred - but do not remove from activeDeferreds here -\n        // we rely on the subscribers to do that so our tests can assert proper\n        // cleanup via _internalActiveDeferreds\n        dfd.cancel();\n        cancelledRouteIds.push(routeId);\n        activeDeferreds.delete(routeId);\n      }\n    });\n    return cancelledRouteIds;\n  }\n\n  // Opt in to capturing and reporting scroll positions during navigations,\n  // used by the <ScrollRestoration> component\n  function enableScrollRestoration(\n    positions: Record<string, number>,\n    getPosition: GetScrollPositionFunction,\n    getKey?: GetScrollRestorationKeyFunction\n  ) {\n    savedScrollPositions = positions;\n    getScrollPosition = getPosition;\n    getScrollRestorationKey = getKey || null;\n\n    // Perform initial hydration scroll restoration, since we miss the boat on\n    // the initial updateState() because we've not yet rendered <ScrollRestoration/>\n    // and therefore have no savedScrollPositions available\n    if (!initialScrollRestored && state.navigation === IDLE_NAVIGATION) {\n      initialScrollRestored = true;\n      let y = getSavedScrollPosition(state.location, state.matches);\n      if (y != null) {\n        updateState({ restoreScrollPosition: y });\n      }\n    }\n\n    return () => {\n      savedScrollPositions = null;\n      getScrollPosition = null;\n      getScrollRestorationKey = null;\n    };\n  }\n\n  function getScrollKey(location: Location, matches: AgnosticDataRouteMatch[]) {\n    if (getScrollRestorationKey) {\n      let key = getScrollRestorationKey(\n        location,\n        matches.map((m) => convertRouteMatchToUiMatch(m, state.loaderData))\n      );\n      return key || location.key;\n    }\n    return location.key;\n  }\n\n  function saveScrollPosition(\n    location: Location,\n    matches: AgnosticDataRouteMatch[]\n  ): void {\n    if (savedScrollPositions && getScrollPosition) {\n      let key = getScrollKey(location, matches);\n      savedScrollPositions[key] = getScrollPosition();\n    }\n  }\n\n  function getSavedScrollPosition(\n    location: Location,\n    matches: AgnosticDataRouteMatch[]\n  ): number | null {\n    if (savedScrollPositions) {\n      let key = getScrollKey(location, matches);\n      let y = savedScrollPositions[key];\n      if (typeof y === \"number\") {\n        return y;\n      }\n    }\n    return null;\n  }\n\n  function checkFogOfWar(\n    matches: AgnosticDataRouteMatch[] | null,\n    routesToUse: AgnosticDataRouteObject[],\n    pathname: string\n  ): { active: boolean; matches: AgnosticDataRouteMatch[] | null } {\n    if (patchRoutesOnNavigationImpl) {\n      if (!matches) {\n        let fogMatches = matchRoutesImpl<AgnosticDataRouteObject>(\n          routesToUse,\n          pathname,\n          basename,\n          true\n        );\n\n        return { active: true, matches: fogMatches || [] };\n      } else {\n        if (Object.keys(matches[0].params).length > 0) {\n          // If we matched a dynamic param or a splat, it might only be because\n          // we haven't yet discovered other routes that would match with a\n          // higher score.  Call patchRoutesOnNavigation just to be sure\n          let partialMatches = matchRoutesImpl<AgnosticDataRouteObject>(\n            routesToUse,\n            pathname,\n            basename,\n            true\n          );\n          return { active: true, matches: partialMatches };\n        }\n      }\n    }\n\n    return { active: false, matches: null };\n  }\n\n  type DiscoverRoutesSuccessResult = {\n    type: \"success\";\n    matches: AgnosticDataRouteMatch[] | null;\n  };\n  type DiscoverRoutesErrorResult = {\n    type: \"error\";\n    error: any;\n    partialMatches: AgnosticDataRouteMatch[];\n  };\n  type DiscoverRoutesAbortedResult = { type: \"aborted\" };\n  type DiscoverRoutesResult =\n    | DiscoverRoutesSuccessResult\n    | DiscoverRoutesErrorResult\n    | DiscoverRoutesAbortedResult;\n\n  async function discoverRoutes(\n    matches: AgnosticDataRouteMatch[],\n    pathname: string,\n    signal: AbortSignal,\n    fetcherKey?: string\n  ): Promise<DiscoverRoutesResult> {\n    if (!patchRoutesOnNavigationImpl) {\n      return { type: \"success\", matches };\n    }\n\n    let partialMatches: AgnosticDataRouteMatch[] | null = matches;\n    while (true) {\n      let isNonHMR = inFlightDataRoutes == null;\n      let routesToUse = inFlightDataRoutes || dataRoutes;\n      let localManifest = manifest;\n      try {\n        await patchRoutesOnNavigationImpl({\n          signal,\n          path: pathname,\n          matches: partialMatches,\n          fetcherKey,\n          patch: (routeId, children) => {\n            if (signal.aborted) return;\n            patchRoutesImpl(\n              routeId,\n              children,\n              routesToUse,\n              localManifest,\n              mapRouteProperties\n            );\n          },\n        });\n      } catch (e) {\n        return { type: \"error\", error: e, partialMatches };\n      } finally {\n        // If we are not in the middle of an HMR revalidation and we changed the\n        // routes, provide a new identity so when we `updateState` at the end of\n        // this navigation/fetch `router.routes` will be a new identity and\n        // trigger a re-run of memoized `router.routes` dependencies.\n        // HMR will already update the identity and reflow when it lands\n        // `inFlightDataRoutes` in `completeNavigation`\n        if (isNonHMR && !signal.aborted) {\n          dataRoutes = [...dataRoutes];\n        }\n      }\n\n      if (signal.aborted) {\n        return { type: \"aborted\" };\n      }\n\n      let newMatches = matchRoutes(routesToUse, pathname, basename);\n      if (newMatches) {\n        return { type: \"success\", matches: newMatches };\n      }\n\n      let newPartialMatches = matchRoutesImpl<AgnosticDataRouteObject>(\n        routesToUse,\n        pathname,\n        basename,\n        true\n      );\n\n      // Avoid loops if the second pass results in the same partial matches\n      if (\n        !newPartialMatches ||\n        (partialMatches.length === newPartialMatches.length &&\n          partialMatches.every(\n            (m, i) => m.route.id === newPartialMatches![i].route.id\n          ))\n      ) {\n        return { type: \"success\", matches: null };\n      }\n\n      partialMatches = newPartialMatches;\n    }\n  }\n\n  function _internalSetRoutes(newRoutes: AgnosticDataRouteObject[]) {\n    manifest = {};\n    inFlightDataRoutes = convertRoutesToDataRoutes(\n      newRoutes,\n      mapRouteProperties,\n      undefined,\n      manifest\n    );\n  }\n\n  function patchRoutes(\n    routeId: string | null,\n    children: AgnosticRouteObject[]\n  ): void {\n    let isNonHMR = inFlightDataRoutes == null;\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    patchRoutesImpl(\n      routeId,\n      children,\n      routesToUse,\n      manifest,\n      mapRouteProperties\n    );\n\n    // If we are not in the middle of an HMR revalidation and we changed the\n    // routes, provide a new identity and trigger a reflow via `updateState`\n    // to re-run memoized `router.routes` dependencies.\n    // HMR will already update the identity and reflow when it lands\n    // `inFlightDataRoutes` in `completeNavigation`\n    if (isNonHMR) {\n      dataRoutes = [...dataRoutes];\n      updateState({});\n    }\n  }\n\n  router = {\n    get basename() {\n      return basename;\n    },\n    get future() {\n      return future;\n    },\n    get state() {\n      return state;\n    },\n    get routes() {\n      return dataRoutes;\n    },\n    get window() {\n      return routerWindow;\n    },\n    initialize,\n    subscribe,\n    enableScrollRestoration,\n    navigate,\n    fetch,\n    revalidate,\n    // Passthrough to history-aware createHref used by useHref so we get proper\n    // hash-aware URLs in DOM paths\n    createHref: (to: To) => init.history.createHref(to),\n    encodeLocation: (to: To) => init.history.encodeLocation(to),\n    getFetcher,\n    deleteFetcher: deleteFetcherAndUpdateState,\n    dispose,\n    getBlocker,\n    deleteBlocker,\n    patchRoutes,\n    _internalFetchControllers: fetchControllers,\n    _internalActiveDeferreds: activeDeferreds,\n    // TODO: Remove setRoutes, it's temporary to avoid dealing with\n    // updating the tree while validating the update algorithm.\n    _internalSetRoutes,\n  };\n\n  return router;\n}\n//#endregion\n\n////////////////////////////////////////////////////////////////////////////////\n//#region createStaticHandler\n////////////////////////////////////////////////////////////////////////////////\n\nexport const UNSAFE_DEFERRED_SYMBOL = Symbol(\"deferred\");\n\n/**\n * Future flags to toggle new feature behavior\n */\nexport interface StaticHandlerFutureConfig {\n  v7_relativeSplatPath: boolean;\n  v7_throwAbortReason: boolean;\n}\n\nexport interface CreateStaticHandlerOptions {\n  basename?: string;\n  /**\n   * @deprecated Use `mapRouteProperties` instead\n   */\n  detectErrorBoundary?: DetectErrorBoundaryFunction;\n  mapRouteProperties?: MapRoutePropertiesFunction;\n  future?: Partial<StaticHandlerFutureConfig>;\n}\n\nexport function createStaticHandler(\n  routes: AgnosticRouteObject[],\n  opts?: CreateStaticHandlerOptions\n): StaticHandler {\n  invariant(\n    routes.length > 0,\n    \"You must provide a non-empty routes array to createStaticHandler\"\n  );\n\n  let manifest: RouteManifest = {};\n  let basename = (opts ? opts.basename : null) || \"/\";\n  let mapRouteProperties: MapRoutePropertiesFunction;\n  if (opts?.mapRouteProperties) {\n    mapRouteProperties = opts.mapRouteProperties;\n  } else if (opts?.detectErrorBoundary) {\n    // If they are still using the deprecated version, wrap it with the new API\n    let detectErrorBoundary = opts.detectErrorBoundary;\n    mapRouteProperties = (route) => ({\n      hasErrorBoundary: detectErrorBoundary(route),\n    });\n  } else {\n    mapRouteProperties = defaultMapRouteProperties;\n  }\n  // Config driven behavior flags\n  let future: StaticHandlerFutureConfig = {\n    v7_relativeSplatPath: false,\n    v7_throwAbortReason: false,\n    ...(opts ? opts.future : null),\n  };\n\n  let dataRoutes = convertRoutesToDataRoutes(\n    routes,\n    mapRouteProperties,\n    undefined,\n    manifest\n  );\n\n  /**\n   * The query() method is intended for document requests, in which we want to\n   * call an optional action and potentially multiple loaders for all nested\n   * routes.  It returns a StaticHandlerContext object, which is very similar\n   * to the router state (location, loaderData, actionData, errors, etc.) and\n   * also adds SSR-specific information such as the statusCode and headers\n   * from action/loaders Responses.\n   *\n   * It _should_ never throw and should report all errors through the\n   * returned context.errors object, properly associating errors to their error\n   * boundary.  Additionally, it tracks _deepestRenderedBoundaryId which can be\n   * used to emulate React error boundaries during SSr by performing a second\n   * pass only down to the boundaryId.\n   *\n   * The one exception where we do not return a StaticHandlerContext is when a\n   * redirect response is returned or thrown from any action/loader.  We\n   * propagate that out and return the raw Response so the HTTP server can\n   * return it directly.\n   *\n   * - `opts.requestContext` is an optional server context that will be passed\n   *   to actions/loaders in the `context` parameter\n   * - `opts.skipLoaderErrorBubbling` is an optional parameter that will prevent\n   *   the bubbling of errors which allows single-fetch-type implementations\n   *   where the client will handle the bubbling and we may need to return data\n   *   for the handling route\n   */\n  async function query(\n    request: Request,\n    {\n      requestContext,\n      skipLoaderErrorBubbling,\n      dataStrategy,\n    }: {\n      requestContext?: unknown;\n      skipLoaderErrorBubbling?: boolean;\n      dataStrategy?: DataStrategyFunction;\n    } = {}\n  ): Promise<StaticHandlerContext | Response> {\n    let url = new URL(request.url);\n    let method = request.method;\n    let location = createLocation(\"\", createPath(url), null, \"default\");\n    let matches = matchRoutes(dataRoutes, location, basename);\n\n    // SSR supports HEAD requests while SPA doesn't\n    if (!isValidMethod(method) && method !== \"HEAD\") {\n      let error = getInternalRouterError(405, { method });\n      let { matches: methodNotAllowedMatches, route } =\n        getShortCircuitMatches(dataRoutes);\n      return {\n        basename,\n        location,\n        matches: methodNotAllowedMatches,\n        loaderData: {},\n        actionData: null,\n        errors: {\n          [route.id]: error,\n        },\n        statusCode: error.status,\n        loaderHeaders: {},\n        actionHeaders: {},\n        activeDeferreds: null,\n      };\n    } else if (!matches) {\n      let error = getInternalRouterError(404, { pathname: location.pathname });\n      let { matches: notFoundMatches, route } =\n        getShortCircuitMatches(dataRoutes);\n      return {\n        basename,\n        location,\n        matches: notFoundMatches,\n        loaderData: {},\n        actionData: null,\n        errors: {\n          [route.id]: error,\n        },\n        statusCode: error.status,\n        loaderHeaders: {},\n        actionHeaders: {},\n        activeDeferreds: null,\n      };\n    }\n\n    let result = await queryImpl(\n      request,\n      location,\n      matches,\n      requestContext,\n      dataStrategy || null,\n      skipLoaderErrorBubbling === true,\n      null\n    );\n    if (isResponse(result)) {\n      return result;\n    }\n\n    // When returning StaticHandlerContext, we patch back in the location here\n    // since we need it for React Context.  But this helps keep our submit and\n    // loadRouteData operating on a Request instead of a Location\n    return { location, basename, ...result };\n  }\n\n  /**\n   * The queryRoute() method is intended for targeted route requests, either\n   * for fetch ?_data requests or resource route requests.  In this case, we\n   * are only ever calling a single action or loader, and we are returning the\n   * returned value directly.  In most cases, this will be a Response returned\n   * from the action/loader, but it may be a primitive or other value as well -\n   * and in such cases the calling context should handle that accordingly.\n   *\n   * We do respect the throw/return differentiation, so if an action/loader\n   * throws, then this method will throw the value.  This is important so we\n   * can do proper boundary identification in Remix where a thrown Response\n   * must go to the Catch Boundary but a returned Response is happy-path.\n   *\n   * One thing to note is that any Router-initiated Errors that make sense\n   * to associate with a status code will be thrown as an ErrorResponse\n   * instance which include the raw Error, such that the calling context can\n   * serialize the error as they see fit while including the proper response\n   * code.  Examples here are 404 and 405 errors that occur prior to reaching\n   * any user-defined loaders.\n   *\n   * - `opts.routeId` allows you to specify the specific route handler to call.\n   *   If not provided the handler will determine the proper route by matching\n   *   against `request.url`\n   * - `opts.requestContext` is an optional server context that will be passed\n   *    to actions/loaders in the `context` parameter\n   */\n  async function queryRoute(\n    request: Request,\n    {\n      routeId,\n      requestContext,\n      dataStrategy,\n    }: {\n      requestContext?: unknown;\n      routeId?: string;\n      dataStrategy?: DataStrategyFunction;\n    } = {}\n  ): Promise<any> {\n    let url = new URL(request.url);\n    let method = request.method;\n    let location = createLocation(\"\", createPath(url), null, \"default\");\n    let matches = matchRoutes(dataRoutes, location, basename);\n\n    // SSR supports HEAD requests while SPA doesn't\n    if (!isValidMethod(method) && method !== \"HEAD\" && method !== \"OPTIONS\") {\n      throw getInternalRouterError(405, { method });\n    } else if (!matches) {\n      throw getInternalRouterError(404, { pathname: location.pathname });\n    }\n\n    let match = routeId\n      ? matches.find((m) => m.route.id === routeId)\n      : getTargetMatch(matches, location);\n\n    if (routeId && !match) {\n      throw getInternalRouterError(403, {\n        pathname: location.pathname,\n        routeId,\n      });\n    } else if (!match) {\n      // This should never hit I don't think?\n      throw getInternalRouterError(404, { pathname: location.pathname });\n    }\n\n    let result = await queryImpl(\n      request,\n      location,\n      matches,\n      requestContext,\n      dataStrategy || null,\n      false,\n      match\n    );\n\n    if (isResponse(result)) {\n      return result;\n    }\n\n    let error = result.errors ? Object.values(result.errors)[0] : undefined;\n    if (error !== undefined) {\n      // If we got back result.errors, that means the loader/action threw\n      // _something_ that wasn't a Response, but it's not guaranteed/required\n      // to be an `instanceof Error` either, so we have to use throw here to\n      // preserve the \"error\" state outside of queryImpl.\n      throw error;\n    }\n\n    // Pick off the right state value to return\n    if (result.actionData) {\n      return Object.values(result.actionData)[0];\n    }\n\n    if (result.loaderData) {\n      let data = Object.values(result.loaderData)[0];\n      if (result.activeDeferreds?.[match.route.id]) {\n        data[UNSAFE_DEFERRED_SYMBOL] = result.activeDeferreds[match.route.id];\n      }\n      return data;\n    }\n\n    return undefined;\n  }\n\n  async function queryImpl(\n    request: Request,\n    location: Location,\n    matches: AgnosticDataRouteMatch[],\n    requestContext: unknown,\n    dataStrategy: DataStrategyFunction | null,\n    skipLoaderErrorBubbling: boolean,\n    routeMatch: AgnosticDataRouteMatch | null\n  ): Promise<Omit<StaticHandlerContext, \"location\" | \"basename\"> | Response> {\n    invariant(\n      request.signal,\n      \"query()/queryRoute() requests must contain an AbortController signal\"\n    );\n\n    try {\n      if (isMutationMethod(request.method.toLowerCase())) {\n        let result = await submit(\n          request,\n          matches,\n          routeMatch || getTargetMatch(matches, location),\n          requestContext,\n          dataStrategy,\n          skipLoaderErrorBubbling,\n          routeMatch != null\n        );\n        return result;\n      }\n\n      let result = await loadRouteData(\n        request,\n        matches,\n        requestContext,\n        dataStrategy,\n        skipLoaderErrorBubbling,\n        routeMatch\n      );\n      return isResponse(result)\n        ? result\n        : {\n            ...result,\n            actionData: null,\n            actionHeaders: {},\n          };\n    } catch (e) {\n      // If the user threw/returned a Response in callLoaderOrAction for a\n      // `queryRoute` call, we throw the `DataStrategyResult` to bail out early\n      // and then return or throw the raw Response here accordingly\n      if (isDataStrategyResult(e) && isResponse(e.result)) {\n        if (e.type === ResultType.error) {\n          throw e.result;\n        }\n        return e.result;\n      }\n      // Redirects are always returned since they don't propagate to catch\n      // boundaries\n      if (isRedirectResponse(e)) {\n        return e;\n      }\n      throw e;\n    }\n  }\n\n  async function submit(\n    request: Request,\n    matches: AgnosticDataRouteMatch[],\n    actionMatch: AgnosticDataRouteMatch,\n    requestContext: unknown,\n    dataStrategy: DataStrategyFunction | null,\n    skipLoaderErrorBubbling: boolean,\n    isRouteRequest: boolean\n  ): Promise<Omit<StaticHandlerContext, \"location\" | \"basename\"> | Response> {\n    let result: DataResult;\n\n    if (!actionMatch.route.action && !actionMatch.route.lazy) {\n      let error = getInternalRouterError(405, {\n        method: request.method,\n        pathname: new URL(request.url).pathname,\n        routeId: actionMatch.route.id,\n      });\n      if (isRouteRequest) {\n        throw error;\n      }\n      result = {\n        type: ResultType.error,\n        error,\n      };\n    } else {\n      let results = await callDataStrategy(\n        \"action\",\n        request,\n        [actionMatch],\n        matches,\n        isRouteRequest,\n        requestContext,\n        dataStrategy\n      );\n      result = results[actionMatch.route.id];\n\n      if (request.signal.aborted) {\n        throwStaticHandlerAbortedError(request, isRouteRequest, future);\n      }\n    }\n\n    if (isRedirectResult(result)) {\n      // Uhhhh - this should never happen, we should always throw these from\n      // callLoaderOrAction, but the type narrowing here keeps TS happy and we\n      // can get back on the \"throw all redirect responses\" train here should\n      // this ever happen :/\n      throw new Response(null, {\n        status: result.response.status,\n        headers: {\n          Location: result.response.headers.get(\"Location\")!,\n        },\n      });\n    }\n\n    if (isDeferredResult(result)) {\n      let error = getInternalRouterError(400, { type: \"defer-action\" });\n      if (isRouteRequest) {\n        throw error;\n      }\n      result = {\n        type: ResultType.error,\n        error,\n      };\n    }\n\n    if (isRouteRequest) {\n      // Note: This should only be non-Response values if we get here, since\n      // isRouteRequest should throw any Response received in callLoaderOrAction\n      if (isErrorResult(result)) {\n        throw result.error;\n      }\n\n      return {\n        matches: [actionMatch],\n        loaderData: {},\n        actionData: { [actionMatch.route.id]: result.data },\n        errors: null,\n        // Note: statusCode + headers are unused here since queryRoute will\n        // return the raw Response or value\n        statusCode: 200,\n        loaderHeaders: {},\n        actionHeaders: {},\n        activeDeferreds: null,\n      };\n    }\n\n    // Create a GET request for the loaders\n    let loaderRequest = new Request(request.url, {\n      headers: request.headers,\n      redirect: request.redirect,\n      signal: request.signal,\n    });\n\n    if (isErrorResult(result)) {\n      // Store off the pending error - we use it to determine which loaders\n      // to call and will commit it when we complete the navigation\n      let boundaryMatch = skipLoaderErrorBubbling\n        ? actionMatch\n        : findNearestBoundary(matches, actionMatch.route.id);\n\n      let context = await loadRouteData(\n        loaderRequest,\n        matches,\n        requestContext,\n        dataStrategy,\n        skipLoaderErrorBubbling,\n        null,\n        [boundaryMatch.route.id, result]\n      );\n\n      // action status codes take precedence over loader status codes\n      return {\n        ...context,\n        statusCode: isRouteErrorResponse(result.error)\n          ? result.error.status\n          : result.statusCode != null\n          ? result.statusCode\n          : 500,\n        actionData: null,\n        actionHeaders: {\n          ...(result.headers ? { [actionMatch.route.id]: result.headers } : {}),\n        },\n      };\n    }\n\n    let context = await loadRouteData(\n      loaderRequest,\n      matches,\n      requestContext,\n      dataStrategy,\n      skipLoaderErrorBubbling,\n      null\n    );\n\n    return {\n      ...context,\n      actionData: {\n        [actionMatch.route.id]: result.data,\n      },\n      // action status codes take precedence over loader status codes\n      ...(result.statusCode ? { statusCode: result.statusCode } : {}),\n      actionHeaders: result.headers\n        ? { [actionMatch.route.id]: result.headers }\n        : {},\n    };\n  }\n\n  async function loadRouteData(\n    request: Request,\n    matches: AgnosticDataRouteMatch[],\n    requestContext: unknown,\n    dataStrategy: DataStrategyFunction | null,\n    skipLoaderErrorBubbling: boolean,\n    routeMatch: AgnosticDataRouteMatch | null,\n    pendingActionResult?: PendingActionResult\n  ): Promise<\n    | Omit<\n        StaticHandlerContext,\n        \"location\" | \"basename\" | \"actionData\" | \"actionHeaders\"\n      >\n    | Response\n  > {\n    let isRouteRequest = routeMatch != null;\n\n    // Short circuit if we have no loaders to run (queryRoute())\n    if (\n      isRouteRequest &&\n      !routeMatch?.route.loader &&\n      !routeMatch?.route.lazy\n    ) {\n      throw getInternalRouterError(400, {\n        method: request.method,\n        pathname: new URL(request.url).pathname,\n        routeId: routeMatch?.route.id,\n      });\n    }\n\n    let requestMatches = routeMatch\n      ? [routeMatch]\n      : pendingActionResult && isErrorResult(pendingActionResult[1])\n      ? getLoaderMatchesUntilBoundary(matches, pendingActionResult[0])\n      : matches;\n    let matchesToLoad = requestMatches.filter(\n      (m) => m.route.loader || m.route.lazy\n    );\n\n    // Short circuit if we have no loaders to run (query())\n    if (matchesToLoad.length === 0) {\n      return {\n        matches,\n        // Add a null for all matched routes for proper revalidation on the client\n        loaderData: matches.reduce(\n          (acc, m) => Object.assign(acc, { [m.route.id]: null }),\n          {}\n        ),\n        errors:\n          pendingActionResult && isErrorResult(pendingActionResult[1])\n            ? {\n                [pendingActionResult[0]]: pendingActionResult[1].error,\n              }\n            : null,\n        statusCode: 200,\n        loaderHeaders: {},\n        activeDeferreds: null,\n      };\n    }\n\n    let results = await callDataStrategy(\n      \"loader\",\n      request,\n      matchesToLoad,\n      matches,\n      isRouteRequest,\n      requestContext,\n      dataStrategy\n    );\n\n    if (request.signal.aborted) {\n      throwStaticHandlerAbortedError(request, isRouteRequest, future);\n    }\n\n    // Process and commit output from loaders\n    let activeDeferreds = new Map<string, DeferredData>();\n    let context = processRouteLoaderData(\n      matches,\n      results,\n      pendingActionResult,\n      activeDeferreds,\n      skipLoaderErrorBubbling\n    );\n\n    // Add a null for any non-loader matches for proper revalidation on the client\n    let executedLoaders = new Set<string>(\n      matchesToLoad.map((match) => match.route.id)\n    );\n    matches.forEach((match) => {\n      if (!executedLoaders.has(match.route.id)) {\n        context.loaderData[match.route.id] = null;\n      }\n    });\n\n    return {\n      ...context,\n      matches,\n      activeDeferreds:\n        activeDeferreds.size > 0\n          ? Object.fromEntries(activeDeferreds.entries())\n          : null,\n    };\n  }\n\n  // Utility wrapper for calling dataStrategy server-side without having to\n  // pass around the manifest, mapRouteProperties, etc.\n  async function callDataStrategy(\n    type: \"loader\" | \"action\",\n    request: Request,\n    matchesToLoad: AgnosticDataRouteMatch[],\n    matches: AgnosticDataRouteMatch[],\n    isRouteRequest: boolean,\n    requestContext: unknown,\n    dataStrategy: DataStrategyFunction | null\n  ): Promise<Record<string, DataResult>> {\n    let results = await callDataStrategyImpl(\n      dataStrategy || defaultDataStrategy,\n      type,\n      null,\n      request,\n      matchesToLoad,\n      matches,\n      null,\n      manifest,\n      mapRouteProperties,\n      requestContext\n    );\n\n    let dataResults: Record<string, DataResult> = {};\n    await Promise.all(\n      matches.map(async (match) => {\n        if (!(match.route.id in results)) {\n          return;\n        }\n        let result = results[match.route.id];\n        if (isRedirectDataStrategyResultResult(result)) {\n          let response = result.result as Response;\n          // Throw redirects and let the server handle them with an HTTP redirect\n          throw normalizeRelativeRoutingRedirectResponse(\n            response,\n            request,\n            match.route.id,\n            matches,\n            basename,\n            future.v7_relativeSplatPath\n          );\n        }\n        if (isResponse(result.result) && isRouteRequest) {\n          // For SSR single-route requests, we want to hand Responses back\n          // directly without unwrapping\n          throw result;\n        }\n\n        dataResults[match.route.id] =\n          await convertDataStrategyResultToDataResult(result);\n      })\n    );\n    return dataResults;\n  }\n\n  return {\n    dataRoutes,\n    query,\n    queryRoute,\n  };\n}\n\n//#endregion\n\n////////////////////////////////////////////////////////////////////////////////\n//#region Helpers\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * Given an existing StaticHandlerContext and an error thrown at render time,\n * provide an updated StaticHandlerContext suitable for a second SSR render\n */\nexport function getStaticContextFromError(\n  routes: AgnosticDataRouteObject[],\n  context: StaticHandlerContext,\n  error: any\n) {\n  let newContext: StaticHandlerContext = {\n    ...context,\n    statusCode: isRouteErrorResponse(error) ? error.status : 500,\n    errors: {\n      [context._deepestRenderedBoundaryId || routes[0].id]: error,\n    },\n  };\n  return newContext;\n}\n\nfunction throwStaticHandlerAbortedError(\n  request: Request,\n  isRouteRequest: boolean,\n  future: StaticHandlerFutureConfig\n) {\n  if (future.v7_throwAbortReason && request.signal.reason !== undefined) {\n    throw request.signal.reason;\n  }\n\n  let method = isRouteRequest ? \"queryRoute\" : \"query\";\n  throw new Error(`${method}() call aborted: ${request.method} ${request.url}`);\n}\n\nfunction isSubmissionNavigation(\n  opts: BaseNavigateOrFetchOptions\n): opts is SubmissionNavigateOptions {\n  return (\n    opts != null &&\n    ((\"formData\" in opts && opts.formData != null) ||\n      (\"body\" in opts && opts.body !== undefined))\n  );\n}\n\nfunction normalizeTo(\n  location: Path,\n  matches: AgnosticDataRouteMatch[],\n  basename: string,\n  prependBasename: boolean,\n  to: To | null,\n  v7_relativeSplatPath: boolean,\n  fromRouteId?: string,\n  relative?: RelativeRoutingType\n) {\n  let contextualMatches: AgnosticDataRouteMatch[];\n  let activeRouteMatch: AgnosticDataRouteMatch | undefined;\n  if (fromRouteId) {\n    // Grab matches up to the calling route so our route-relative logic is\n    // relative to the correct source route\n    contextualMatches = [];\n    for (let match of matches) {\n      contextualMatches.push(match);\n      if (match.route.id === fromRouteId) {\n        activeRouteMatch = match;\n        break;\n      }\n    }\n  } else {\n    contextualMatches = matches;\n    activeRouteMatch = matches[matches.length - 1];\n  }\n\n  // Resolve the relative path\n  let path = resolveTo(\n    to ? to : \".\",\n    getResolveToMatches(contextualMatches, v7_relativeSplatPath),\n    stripBasename(location.pathname, basename) || location.pathname,\n    relative === \"path\"\n  );\n\n  // When `to` is not specified we inherit search/hash from the current\n  // location, unlike when to=\".\" and we just inherit the path.\n  // See https://github.com/remix-run/remix/issues/927\n  if (to == null) {\n    path.search = location.search;\n    path.hash = location.hash;\n  }\n\n  // Account for `?index` params when routing to the current location\n  if ((to == null || to === \"\" || to === \".\") && activeRouteMatch) {\n    let nakedIndex = hasNakedIndexQuery(path.search);\n    if (activeRouteMatch.route.index && !nakedIndex) {\n      // Add one when we're targeting an index route\n      path.search = path.search\n        ? path.search.replace(/^\\?/, \"?index&\")\n        : \"?index\";\n    } else if (!activeRouteMatch.route.index && nakedIndex) {\n      // Remove existing ones when we're not\n      let params = new URLSearchParams(path.search);\n      let indexValues = params.getAll(\"index\");\n      params.delete(\"index\");\n      indexValues.filter((v) => v).forEach((v) => params.append(\"index\", v));\n      let qs = params.toString();\n      path.search = qs ? `?${qs}` : \"\";\n    }\n  }\n\n  // If we're operating within a basename, prepend it to the pathname.  If\n  // this is a root navigation, then just use the raw basename which allows\n  // the basename to have full control over the presence of a trailing slash\n  // on root actions\n  if (prependBasename && basename !== \"/\") {\n    path.pathname =\n      path.pathname === \"/\" ? basename : joinPaths([basename, path.pathname]);\n  }\n\n  return createPath(path);\n}\n\n// Normalize navigation options by converting formMethod=GET formData objects to\n// URLSearchParams so they behave identically to links with query params\nfunction normalizeNavigateOptions(\n  normalizeFormMethod: boolean,\n  isFetcher: boolean,\n  path: string,\n  opts?: BaseNavigateOrFetchOptions\n): {\n  path: string;\n  submission?: Submission;\n  error?: ErrorResponseImpl;\n} {\n  // Return location verbatim on non-submission navigations\n  if (!opts || !isSubmissionNavigation(opts)) {\n    return { path };\n  }\n\n  if (opts.formMethod && !isValidMethod(opts.formMethod)) {\n    return {\n      path,\n      error: getInternalRouterError(405, { method: opts.formMethod }),\n    };\n  }\n\n  let getInvalidBodyError = () => ({\n    path,\n    error: getInternalRouterError(400, { type: \"invalid-body\" }),\n  });\n\n  // Create a Submission on non-GET navigations\n  let rawFormMethod = opts.formMethod || \"get\";\n  let formMethod = normalizeFormMethod\n    ? (rawFormMethod.toUpperCase() as V7_FormMethod)\n    : (rawFormMethod.toLowerCase() as FormMethod);\n  let formAction = stripHashFromPath(path);\n\n  if (opts.body !== undefined) {\n    if (opts.formEncType === \"text/plain\") {\n      // text only support POST/PUT/PATCH/DELETE submissions\n      if (!isMutationMethod(formMethod)) {\n        return getInvalidBodyError();\n      }\n\n      let text =\n        typeof opts.body === \"string\"\n          ? opts.body\n          : opts.body instanceof FormData ||\n            opts.body instanceof URLSearchParams\n          ? // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#plain-text-form-data\n            Array.from(opts.body.entries()).reduce(\n              (acc, [name, value]) => `${acc}${name}=${value}\\n`,\n              \"\"\n            )\n          : String(opts.body);\n\n      return {\n        path,\n        submission: {\n          formMethod,\n          formAction,\n          formEncType: opts.formEncType,\n          formData: undefined,\n          json: undefined,\n          text,\n        },\n      };\n    } else if (opts.formEncType === \"application/json\") {\n      // json only supports POST/PUT/PATCH/DELETE submissions\n      if (!isMutationMethod(formMethod)) {\n        return getInvalidBodyError();\n      }\n\n      try {\n        let json =\n          typeof opts.body === \"string\" ? JSON.parse(opts.body) : opts.body;\n\n        return {\n          path,\n          submission: {\n            formMethod,\n            formAction,\n            formEncType: opts.formEncType,\n            formData: undefined,\n            json,\n            text: undefined,\n          },\n        };\n      } catch (e) {\n        return getInvalidBodyError();\n      }\n    }\n  }\n\n  invariant(\n    typeof FormData === \"function\",\n    \"FormData is not available in this environment\"\n  );\n\n  let searchParams: URLSearchParams;\n  let formData: FormData;\n\n  if (opts.formData) {\n    searchParams = convertFormDataToSearchParams(opts.formData);\n    formData = opts.formData;\n  } else if (opts.body instanceof FormData) {\n    searchParams = convertFormDataToSearchParams(opts.body);\n    formData = opts.body;\n  } else if (opts.body instanceof URLSearchParams) {\n    searchParams = opts.body;\n    formData = convertSearchParamsToFormData(searchParams);\n  } else if (opts.body == null) {\n    searchParams = new URLSearchParams();\n    formData = new FormData();\n  } else {\n    try {\n      searchParams = new URLSearchParams(opts.body);\n      formData = convertSearchParamsToFormData(searchParams);\n    } catch (e) {\n      return getInvalidBodyError();\n    }\n  }\n\n  let submission: Submission = {\n    formMethod,\n    formAction,\n    formEncType:\n      (opts && opts.formEncType) || \"application/x-www-form-urlencoded\",\n    formData,\n    json: undefined,\n    text: undefined,\n  };\n\n  if (isMutationMethod(submission.formMethod)) {\n    return { path, submission };\n  }\n\n  // Flatten submission onto URLSearchParams for GET submissions\n  let parsedPath = parsePath(path);\n  // On GET navigation submissions we can drop the ?index param from the\n  // resulting location since all loaders will run.  But fetcher GET submissions\n  // only run a single loader so we need to preserve any incoming ?index params\n  if (isFetcher && parsedPath.search && hasNakedIndexQuery(parsedPath.search)) {\n    searchParams.append(\"index\", \"\");\n  }\n  parsedPath.search = `?${searchParams}`;\n\n  return { path: createPath(parsedPath), submission };\n}\n\n// Filter out all routes at/below any caught error as they aren't going to\n// render so we don't need to load them\nfunction getLoaderMatchesUntilBoundary(\n  matches: AgnosticDataRouteMatch[],\n  boundaryId: string,\n  includeBoundary = false\n) {\n  let index = matches.findIndex((m) => m.route.id === boundaryId);\n  if (index >= 0) {\n    return matches.slice(0, includeBoundary ? index + 1 : index);\n  }\n  return matches;\n}\n\nfunction getMatchesToLoad(\n  history: History,\n  state: RouterState,\n  matches: AgnosticDataRouteMatch[],\n  submission: Submission | undefined,\n  location: Location,\n  initialHydration: boolean,\n  skipActionErrorRevalidation: boolean,\n  isRevalidationRequired: boolean,\n  cancelledDeferredRoutes: string[],\n  cancelledFetcherLoads: Set<string>,\n  deletedFetchers: Set<string>,\n  fetchLoadMatches: Map<string, FetchLoadMatch>,\n  fetchRedirectIds: Set<string>,\n  routesToUse: AgnosticDataRouteObject[],\n  basename: string | undefined,\n  pendingActionResult?: PendingActionResult\n): [AgnosticDataRouteMatch[], RevalidatingFetcher[]] {\n  let actionResult = pendingActionResult\n    ? isErrorResult(pendingActionResult[1])\n      ? pendingActionResult[1].error\n      : pendingActionResult[1].data\n    : undefined;\n  let currentUrl = history.createURL(state.location);\n  let nextUrl = history.createURL(location);\n\n  // Pick navigation matches that are net-new or qualify for revalidation\n  let boundaryMatches = matches;\n  if (initialHydration && state.errors) {\n    // On initial hydration, only consider matches up to _and including_ the boundary.\n    // This is inclusive to handle cases where a server loader ran successfully,\n    // a child server loader bubbled up to this route, but this route has\n    // `clientLoader.hydrate` so we want to still run the `clientLoader` so that\n    // we have a complete version of `loaderData`\n    boundaryMatches = getLoaderMatchesUntilBoundary(\n      matches,\n      Object.keys(state.errors)[0],\n      true\n    );\n  } else if (pendingActionResult && isErrorResult(pendingActionResult[1])) {\n    // If an action threw an error, we call loaders up to, but not including the\n    // boundary\n    boundaryMatches = getLoaderMatchesUntilBoundary(\n      matches,\n      pendingActionResult[0]\n    );\n  }\n\n  // Don't revalidate loaders by default after action 4xx/5xx responses\n  // when the flag is enabled.  They can still opt-into revalidation via\n  // `shouldRevalidate` via `actionResult`\n  let actionStatus = pendingActionResult\n    ? pendingActionResult[1].statusCode\n    : undefined;\n  let shouldSkipRevalidation =\n    skipActionErrorRevalidation && actionStatus && actionStatus >= 400;\n\n  let navigationMatches = boundaryMatches.filter((match, index) => {\n    let { route } = match;\n    if (route.lazy) {\n      // We haven't loaded this route yet so we don't know if it's got a loader!\n      return true;\n    }\n\n    if (route.loader == null) {\n      return false;\n    }\n\n    if (initialHydration) {\n      return shouldLoadRouteOnHydration(route, state.loaderData, state.errors);\n    }\n\n    // Always call the loader on new route instances and pending defer cancellations\n    if (\n      isNewLoader(state.loaderData, state.matches[index], match) ||\n      cancelledDeferredRoutes.some((id) => id === match.route.id)\n    ) {\n      return true;\n    }\n\n    // This is the default implementation for when we revalidate.  If the route\n    // provides it's own implementation, then we give them full control but\n    // provide this value so they can leverage it if needed after they check\n    // their own specific use cases\n    let currentRouteMatch = state.matches[index];\n    let nextRouteMatch = match;\n\n    return shouldRevalidateLoader(match, {\n      currentUrl,\n      currentParams: currentRouteMatch.params,\n      nextUrl,\n      nextParams: nextRouteMatch.params,\n      ...submission,\n      actionResult,\n      actionStatus,\n      defaultShouldRevalidate: shouldSkipRevalidation\n        ? false\n        : // Forced revalidation due to submission, useRevalidator, or X-Remix-Revalidate\n          isRevalidationRequired ||\n          currentUrl.pathname + currentUrl.search ===\n            nextUrl.pathname + nextUrl.search ||\n          // Search params affect all loaders\n          currentUrl.search !== nextUrl.search ||\n          isNewRouteInstance(currentRouteMatch, nextRouteMatch),\n    });\n  });\n\n  // Pick fetcher.loads that need to be revalidated\n  let revalidatingFetchers: RevalidatingFetcher[] = [];\n  fetchLoadMatches.forEach((f, key) => {\n    // Don't revalidate:\n    //  - on initial hydration (shouldn't be any fetchers then anyway)\n    //  - if fetcher won't be present in the subsequent render\n    //    - no longer matches the URL (v7_fetcherPersist=false)\n    //    - was unmounted but persisted due to v7_fetcherPersist=true\n    if (\n      initialHydration ||\n      !matches.some((m) => m.route.id === f.routeId) ||\n      deletedFetchers.has(key)\n    ) {\n      return;\n    }\n\n    let fetcherMatches = matchRoutes(routesToUse, f.path, basename);\n\n    // If the fetcher path no longer matches, push it in with null matches so\n    // we can trigger a 404 in callLoadersAndMaybeResolveData.  Note this is\n    // currently only a use-case for Remix HMR where the route tree can change\n    // at runtime and remove a route previously loaded via a fetcher\n    if (!fetcherMatches) {\n      revalidatingFetchers.push({\n        key,\n        routeId: f.routeId,\n        path: f.path,\n        matches: null,\n        match: null,\n        controller: null,\n      });\n      return;\n    }\n\n    // Revalidating fetchers are decoupled from the route matches since they\n    // load from a static href.  They revalidate based on explicit revalidation\n    // (submission, useRevalidator, or X-Remix-Revalidate)\n    let fetcher = state.fetchers.get(key);\n    let fetcherMatch = getTargetMatch(fetcherMatches, f.path);\n\n    let shouldRevalidate = false;\n    if (fetchRedirectIds.has(key)) {\n      // Never trigger a revalidation of an actively redirecting fetcher\n      shouldRevalidate = false;\n    } else if (cancelledFetcherLoads.has(key)) {\n      // Always mark for revalidation if the fetcher was cancelled\n      cancelledFetcherLoads.delete(key);\n      shouldRevalidate = true;\n    } else if (\n      fetcher &&\n      fetcher.state !== \"idle\" &&\n      fetcher.data === undefined\n    ) {\n      // If the fetcher hasn't ever completed loading yet, then this isn't a\n      // revalidation, it would just be a brand new load if an explicit\n      // revalidation is required\n      shouldRevalidate = isRevalidationRequired;\n    } else {\n      // Otherwise fall back on any user-defined shouldRevalidate, defaulting\n      // to explicit revalidations only\n      shouldRevalidate = shouldRevalidateLoader(fetcherMatch, {\n        currentUrl,\n        currentParams: state.matches[state.matches.length - 1].params,\n        nextUrl,\n        nextParams: matches[matches.length - 1].params,\n        ...submission,\n        actionResult,\n        actionStatus,\n        defaultShouldRevalidate: shouldSkipRevalidation\n          ? false\n          : isRevalidationRequired,\n      });\n    }\n\n    if (shouldRevalidate) {\n      revalidatingFetchers.push({\n        key,\n        routeId: f.routeId,\n        path: f.path,\n        matches: fetcherMatches,\n        match: fetcherMatch,\n        controller: new AbortController(),\n      });\n    }\n  });\n\n  return [navigationMatches, revalidatingFetchers];\n}\n\nfunction shouldLoadRouteOnHydration(\n  route: AgnosticDataRouteObject,\n  loaderData: RouteData | null | undefined,\n  errors: RouteData | null | undefined\n) {\n  // We dunno if we have a loader - gotta find out!\n  if (route.lazy) {\n    return true;\n  }\n\n  // No loader, nothing to initialize\n  if (!route.loader) {\n    return false;\n  }\n\n  let hasData = loaderData != null && loaderData[route.id] !== undefined;\n  let hasError = errors != null && errors[route.id] !== undefined;\n\n  // Don't run if we error'd during SSR\n  if (!hasData && hasError) {\n    return false;\n  }\n\n  // Explicitly opting-in to running on hydration\n  if (typeof route.loader === \"function\" && route.loader.hydrate === true) {\n    return true;\n  }\n\n  // Otherwise, run if we're not yet initialized with anything\n  return !hasData && !hasError;\n}\n\nfunction isNewLoader(\n  currentLoaderData: RouteData,\n  currentMatch: AgnosticDataRouteMatch,\n  match: AgnosticDataRouteMatch\n) {\n  let isNew =\n    // [a] -> [a, b]\n    !currentMatch ||\n    // [a, b] -> [a, c]\n    match.route.id !== currentMatch.route.id;\n\n  // Handle the case that we don't have data for a re-used route, potentially\n  // from a prior error or from a cancelled pending deferred\n  let isMissingData = currentLoaderData[match.route.id] === undefined;\n\n  // Always load if this is a net-new route or we don't yet have data\n  return isNew || isMissingData;\n}\n\nfunction isNewRouteInstance(\n  currentMatch: AgnosticDataRouteMatch,\n  match: AgnosticDataRouteMatch\n) {\n  let currentPath = currentMatch.route.path;\n  return (\n    // param change for this match, /users/123 -> /users/456\n    currentMatch.pathname !== match.pathname ||\n    // splat param changed, which is not present in match.path\n    // e.g. /files/images/avatar.jpg -> files/finances.xls\n    (currentPath != null &&\n      currentPath.endsWith(\"*\") &&\n      currentMatch.params[\"*\"] !== match.params[\"*\"])\n  );\n}\n\nfunction shouldRevalidateLoader(\n  loaderMatch: AgnosticDataRouteMatch,\n  arg: ShouldRevalidateFunctionArgs\n) {\n  if (loaderMatch.route.shouldRevalidate) {\n    let routeChoice = loaderMatch.route.shouldRevalidate(arg);\n    if (typeof routeChoice === \"boolean\") {\n      return routeChoice;\n    }\n  }\n\n  return arg.defaultShouldRevalidate;\n}\n\nfunction patchRoutesImpl(\n  routeId: string | null,\n  children: AgnosticRouteObject[],\n  routesToUse: AgnosticDataRouteObject[],\n  manifest: RouteManifest,\n  mapRouteProperties: MapRoutePropertiesFunction\n) {\n  let childrenToPatch: AgnosticDataRouteObject[];\n  if (routeId) {\n    let route = manifest[routeId];\n    invariant(\n      route,\n      `No route found to patch children into: routeId = ${routeId}`\n    );\n    if (!route.children) {\n      route.children = [];\n    }\n    childrenToPatch = route.children;\n  } else {\n    childrenToPatch = routesToUse;\n  }\n\n  // Don't patch in routes we already know about so that `patch` is idempotent\n  // to simplify user-land code. This is useful because we re-call the\n  // `patchRoutesOnNavigation` function for matched routes with params.\n  let uniqueChildren = children.filter(\n    (newRoute) =>\n      !childrenToPatch.some((existingRoute) =>\n        isSameRoute(newRoute, existingRoute)\n      )\n  );\n\n  let newRoutes = convertRoutesToDataRoutes(\n    uniqueChildren,\n    mapRouteProperties,\n    [routeId || \"_\", \"patch\", String(childrenToPatch?.length || \"0\")],\n    manifest\n  );\n\n  childrenToPatch.push(...newRoutes);\n}\n\nfunction isSameRoute(\n  newRoute: AgnosticRouteObject,\n  existingRoute: AgnosticRouteObject\n): boolean {\n  // Most optimal check is by id\n  if (\n    \"id\" in newRoute &&\n    \"id\" in existingRoute &&\n    newRoute.id === existingRoute.id\n  ) {\n    return true;\n  }\n\n  // Second is by pathing differences\n  if (\n    !(\n      newRoute.index === existingRoute.index &&\n      newRoute.path === existingRoute.path &&\n      newRoute.caseSensitive === existingRoute.caseSensitive\n    )\n  ) {\n    return false;\n  }\n\n  // Pathless layout routes are trickier since we need to check children.\n  // If they have no children then they're the same as far as we can tell\n  if (\n    (!newRoute.children || newRoute.children.length === 0) &&\n    (!existingRoute.children || existingRoute.children.length === 0)\n  ) {\n    return true;\n  }\n\n  // Otherwise, we look to see if every child in the new route is already\n  // represented in the existing route's children\n  return newRoute.children!.every((aChild, i) =>\n    existingRoute.children?.some((bChild) => isSameRoute(aChild, bChild))\n  );\n}\n\n/**\n * Execute route.lazy() methods to lazily load route modules (loader, action,\n * shouldRevalidate) and update the routeManifest in place which shares objects\n * with dataRoutes so those get updated as well.\n */\nasync function loadLazyRouteModule(\n  route: AgnosticDataRouteObject,\n  mapRouteProperties: MapRoutePropertiesFunction,\n  manifest: RouteManifest\n) {\n  if (!route.lazy) {\n    return;\n  }\n\n  let lazyRoute = await route.lazy();\n\n  // If the lazy route function was executed and removed by another parallel\n  // call then we can return - first lazy() to finish wins because the return\n  // value of lazy is expected to be static\n  if (!route.lazy) {\n    return;\n  }\n\n  let routeToUpdate = manifest[route.id];\n  invariant(routeToUpdate, \"No route found in manifest\");\n\n  // Update the route in place.  This should be safe because there's no way\n  // we could yet be sitting on this route as we can't get there without\n  // resolving lazy() first.\n  //\n  // This is different than the HMR \"update\" use-case where we may actively be\n  // on the route being updated.  The main concern boils down to \"does this\n  // mutation affect any ongoing navigations or any current state.matches\n  // values?\".  If not, it should be safe to update in place.\n  let routeUpdates: Record<string, any> = {};\n  for (let lazyRouteProperty in lazyRoute) {\n    let staticRouteValue =\n      routeToUpdate[lazyRouteProperty as keyof typeof routeToUpdate];\n\n    let isPropertyStaticallyDefined =\n      staticRouteValue !== undefined &&\n      // This property isn't static since it should always be updated based\n      // on the route updates\n      lazyRouteProperty !== \"hasErrorBoundary\";\n\n    warning(\n      !isPropertyStaticallyDefined,\n      `Route \"${routeToUpdate.id}\" has a static property \"${lazyRouteProperty}\" ` +\n        `defined but its lazy function is also returning a value for this property. ` +\n        `The lazy route property \"${lazyRouteProperty}\" will be ignored.`\n    );\n\n    if (\n      !isPropertyStaticallyDefined &&\n      !immutableRouteKeys.has(lazyRouteProperty as ImmutableRouteKey)\n    ) {\n      routeUpdates[lazyRouteProperty] =\n        lazyRoute[lazyRouteProperty as keyof typeof lazyRoute];\n    }\n  }\n\n  // Mutate the route with the provided updates.  Do this first so we pass\n  // the updated version to mapRouteProperties\n  Object.assign(routeToUpdate, routeUpdates);\n\n  // Mutate the `hasErrorBoundary` property on the route based on the route\n  // updates and remove the `lazy` function so we don't resolve the lazy\n  // route again.\n  Object.assign(routeToUpdate, {\n    // To keep things framework agnostic, we use the provided\n    // `mapRouteProperties` (or wrapped `detectErrorBoundary`) function to\n    // set the framework-aware properties (`element`/`hasErrorBoundary`) since\n    // the logic will differ between frameworks.\n    ...mapRouteProperties(routeToUpdate),\n    lazy: undefined,\n  });\n}\n\n// Default implementation of `dataStrategy` which fetches all loaders in parallel\nasync function defaultDataStrategy({\n  matches,\n}: DataStrategyFunctionArgs): ReturnType<DataStrategyFunction> {\n  let matchesToLoad = matches.filter((m) => m.shouldLoad);\n  let results = await Promise.all(matchesToLoad.map((m) => m.resolve()));\n  return results.reduce(\n    (acc, result, i) =>\n      Object.assign(acc, { [matchesToLoad[i].route.id]: result }),\n    {}\n  );\n}\n\nasync function callDataStrategyImpl(\n  dataStrategyImpl: DataStrategyFunction,\n  type: \"loader\" | \"action\",\n  state: RouterState | null,\n  request: Request,\n  matchesToLoad: AgnosticDataRouteMatch[],\n  matches: AgnosticDataRouteMatch[],\n  fetcherKey: string | null,\n  manifest: RouteManifest,\n  mapRouteProperties: MapRoutePropertiesFunction,\n  requestContext?: unknown\n): Promise<Record<string, DataStrategyResult>> {\n  let loadRouteDefinitionsPromises = matches.map((m) =>\n    m.route.lazy\n      ? loadLazyRouteModule(m.route, mapRouteProperties, manifest)\n      : undefined\n  );\n\n  let dsMatches = matches.map((match, i) => {\n    let loadRoutePromise = loadRouteDefinitionsPromises[i];\n    let shouldLoad = matchesToLoad.some((m) => m.route.id === match.route.id);\n    // `resolve` encapsulates route.lazy(), executing the loader/action,\n    // and mapping return values/thrown errors to a `DataStrategyResult`.  Users\n    // can pass a callback to take fine-grained control over the execution\n    // of the loader/action\n    let resolve: DataStrategyMatch[\"resolve\"] = async (handlerOverride) => {\n      if (\n        handlerOverride &&\n        request.method === \"GET\" &&\n        (match.route.lazy || match.route.loader)\n      ) {\n        shouldLoad = true;\n      }\n      return shouldLoad\n        ? callLoaderOrAction(\n            type,\n            request,\n            match,\n            loadRoutePromise,\n            handlerOverride,\n            requestContext\n          )\n        : Promise.resolve({ type: ResultType.data, result: undefined });\n    };\n\n    return {\n      ...match,\n      shouldLoad,\n      resolve,\n    };\n  });\n\n  // Send all matches here to allow for a middleware-type implementation.\n  // handler will be a no-op for unneeded routes and we filter those results\n  // back out below.\n  let results = await dataStrategyImpl({\n    matches: dsMatches,\n    request,\n    params: matches[0].params,\n    fetcherKey,\n    context: requestContext,\n  });\n\n  // Wait for all routes to load here but 'swallow the error since we want\n  // it to bubble up from the `await loadRoutePromise` in `callLoaderOrAction` -\n  // called from `match.resolve()`\n  try {\n    await Promise.all(loadRouteDefinitionsPromises);\n  } catch (e) {\n    // No-op\n  }\n\n  return results;\n}\n\n// Default logic for calling a loader/action is the user has no specified a dataStrategy\nasync function callLoaderOrAction(\n  type: \"loader\" | \"action\",\n  request: Request,\n  match: AgnosticDataRouteMatch,\n  loadRoutePromise: Promise<void> | undefined,\n  handlerOverride: Parameters<DataStrategyMatch[\"resolve\"]>[0],\n  staticContext?: unknown\n): Promise<DataStrategyResult> {\n  let result: DataStrategyResult;\n  let onReject: (() => void) | undefined;\n\n  let runHandler = (\n    handler: AgnosticRouteObject[\"loader\"] | AgnosticRouteObject[\"action\"]\n  ): Promise<DataStrategyResult> => {\n    // Setup a promise we can race against so that abort signals short circuit\n    let reject: () => void;\n    // This will never resolve so safe to type it as Promise<DataStrategyResult> to\n    // satisfy the function return value\n    let abortPromise = new Promise<DataStrategyResult>((_, r) => (reject = r));\n    onReject = () => reject();\n    request.signal.addEventListener(\"abort\", onReject);\n\n    let actualHandler = (ctx?: unknown) => {\n      if (typeof handler !== \"function\") {\n        return Promise.reject(\n          new Error(\n            `You cannot call the handler for a route which defines a boolean ` +\n              `\"${type}\" [routeId: ${match.route.id}]`\n          )\n        );\n      }\n      return handler(\n        {\n          request,\n          params: match.params,\n          context: staticContext,\n        },\n        ...(ctx !== undefined ? [ctx] : [])\n      );\n    };\n\n    let handlerPromise: Promise<DataStrategyResult> = (async () => {\n      try {\n        let val = await (handlerOverride\n          ? handlerOverride((ctx: unknown) => actualHandler(ctx))\n          : actualHandler());\n        return { type: \"data\", result: val };\n      } catch (e) {\n        return { type: \"error\", result: e };\n      }\n    })();\n\n    return Promise.race([handlerPromise, abortPromise]);\n  };\n\n  try {\n    let handler = match.route[type];\n\n    // If we have a route.lazy promise, await that first\n    if (loadRoutePromise) {\n      if (handler) {\n        // Run statically defined handler in parallel with lazy()\n        let handlerError;\n        let [value] = await Promise.all([\n          // If the handler throws, don't let it immediately bubble out,\n          // since we need to let the lazy() execution finish so we know if this\n          // route has a boundary that can handle the error\n          runHandler(handler).catch((e) => {\n            handlerError = e;\n          }),\n          loadRoutePromise,\n        ]);\n        if (handlerError !== undefined) {\n          throw handlerError;\n        }\n        result = value!;\n      } else {\n        // Load lazy route module, then run any returned handler\n        await loadRoutePromise;\n\n        handler = match.route[type];\n        if (handler) {\n          // Handler still runs even if we got interrupted to maintain consistency\n          // with un-abortable behavior of handler execution on non-lazy or\n          // previously-lazy-loaded routes\n          result = await runHandler(handler);\n        } else if (type === \"action\") {\n          let url = new URL(request.url);\n          let pathname = url.pathname + url.search;\n          throw getInternalRouterError(405, {\n            method: request.method,\n            pathname,\n            routeId: match.route.id,\n          });\n        } else {\n          // lazy() route has no loader to run.  Short circuit here so we don't\n          // hit the invariant below that errors on returning undefined.\n          return { type: ResultType.data, result: undefined };\n        }\n      }\n    } else if (!handler) {\n      let url = new URL(request.url);\n      let pathname = url.pathname + url.search;\n      throw getInternalRouterError(404, {\n        pathname,\n      });\n    } else {\n      result = await runHandler(handler);\n    }\n\n    invariant(\n      result.result !== undefined,\n      `You defined ${type === \"action\" ? \"an action\" : \"a loader\"} for route ` +\n        `\"${match.route.id}\" but didn't return anything from your \\`${type}\\` ` +\n        `function. Please return a value or \\`null\\`.`\n    );\n  } catch (e) {\n    // We should already be catching and converting normal handler executions to\n    // DataStrategyResults and returning them, so anything that throws here is an\n    // unexpected error we still need to wrap\n    return { type: ResultType.error, result: e };\n  } finally {\n    if (onReject) {\n      request.signal.removeEventListener(\"abort\", onReject);\n    }\n  }\n\n  return result;\n}\n\nasync function convertDataStrategyResultToDataResult(\n  dataStrategyResult: DataStrategyResult\n): Promise<DataResult> {\n  let { result, type } = dataStrategyResult;\n\n  if (isResponse(result)) {\n    let data: any;\n\n    try {\n      let contentType = result.headers.get(\"Content-Type\");\n      // Check between word boundaries instead of startsWith() due to the last\n      // paragraph of https://httpwg.org/specs/rfc9110.html#field.content-type\n      if (contentType && /\\bapplication\\/json\\b/.test(contentType)) {\n        if (result.body == null) {\n          data = null;\n        } else {\n          data = await result.json();\n        }\n      } else {\n        data = await result.text();\n      }\n    } catch (e) {\n      return { type: ResultType.error, error: e };\n    }\n\n    if (type === ResultType.error) {\n      return {\n        type: ResultType.error,\n        error: new ErrorResponseImpl(result.status, result.statusText, data),\n        statusCode: result.status,\n        headers: result.headers,\n      };\n    }\n\n    return {\n      type: ResultType.data,\n      data,\n      statusCode: result.status,\n      headers: result.headers,\n    };\n  }\n\n  if (type === ResultType.error) {\n    if (isDataWithResponseInit(result)) {\n      if (result.data instanceof Error) {\n        return {\n          type: ResultType.error,\n          error: result.data,\n          statusCode: result.init?.status,\n          headers: result.init?.headers\n            ? new Headers(result.init.headers)\n            : undefined,\n        };\n      }\n\n      // Convert thrown data() to ErrorResponse instances\n      return {\n        type: ResultType.error,\n        error: new ErrorResponseImpl(\n          result.init?.status || 500,\n          undefined,\n          result.data\n        ),\n        statusCode: isRouteErrorResponse(result) ? result.status : undefined,\n        headers: result.init?.headers\n          ? new Headers(result.init.headers)\n          : undefined,\n      };\n    }\n    return {\n      type: ResultType.error,\n      error: result,\n      statusCode: isRouteErrorResponse(result) ? result.status : undefined,\n    };\n  }\n\n  if (isDeferredData(result)) {\n    return {\n      type: ResultType.deferred,\n      deferredData: result,\n      statusCode: result.init?.status,\n      headers: result.init?.headers && new Headers(result.init.headers),\n    };\n  }\n\n  if (isDataWithResponseInit(result)) {\n    return {\n      type: ResultType.data,\n      data: result.data,\n      statusCode: result.init?.status,\n      headers: result.init?.headers\n        ? new Headers(result.init.headers)\n        : undefined,\n    };\n  }\n\n  return { type: ResultType.data, data: result };\n}\n\n// Support relative routing in internal redirects\nfunction normalizeRelativeRoutingRedirectResponse(\n  response: Response,\n  request: Request,\n  routeId: string,\n  matches: AgnosticDataRouteMatch[],\n  basename: string,\n  v7_relativeSplatPath: boolean\n) {\n  let location = response.headers.get(\"Location\");\n  invariant(\n    location,\n    \"Redirects returned/thrown from loaders/actions must have a Location header\"\n  );\n\n  if (!ABSOLUTE_URL_REGEX.test(location)) {\n    let trimmedMatches = matches.slice(\n      0,\n      matches.findIndex((m) => m.route.id === routeId) + 1\n    );\n    location = normalizeTo(\n      new URL(request.url),\n      trimmedMatches,\n      basename,\n      true,\n      location,\n      v7_relativeSplatPath\n    );\n    response.headers.set(\"Location\", location);\n  }\n\n  return response;\n}\n\nfunction normalizeRedirectLocation(\n  location: string,\n  currentUrl: URL,\n  basename: string,\n  historyInstance: History,\n): string {\n  // Match Chrome's behavior:\n  // https://github.com/chromium/chromium/blob/216dbeb61db0c667e62082e5f5400a32d6983df3/content/public/common/url_utils.cc#L82\n  let invalidProtocols = [\n    \"about:\",\n    \"blob:\",\n    \"chrome:\",\n    \"chrome-untrusted:\",\n    \"content:\",\n    \"data:\",\n    \"devtools:\",\n    \"file:\",\n    \"filesystem:\",\n    // eslint-disable-next-line no-script-url\n    \"javascript:\",\n  ];\n\n  if (ABSOLUTE_URL_REGEX.test(location)) {\n    // Strip off the protocol+origin for same-origin + same-basename absolute redirects\n    let normalizedLocation = location;\n    let url = normalizedLocation.startsWith(\"//\")\n      ? new URL(currentUrl.protocol + normalizedLocation)\n      : new URL(normalizedLocation);\n    if (invalidProtocols.includes(url.protocol)) {\n      throw new Error(\"Invalid redirect location\");\n    }\n    let isSameBasename = stripBasename(url.pathname, basename) != null;\n    if (url.origin === currentUrl.origin && isSameBasename) {\n      return url.pathname + url.search + url.hash;\n    }\n  }\n\n  try {\n    let url = historyInstance.createURL(location);\n    if (invalidProtocols.includes(url.protocol)) {\n      throw new Error(\"Invalid redirect location\");\n    }\n  } catch (e) {}\n\n  return location;\n}\n\n// Utility method for creating the Request instances for loaders/actions during\n// client-side navigations and fetches.  During SSR we will always have a\n// Request instance from the static handler (query/queryRoute)\nfunction createClientSideRequest(\n  history: History,\n  location: string | Location,\n  signal: AbortSignal,\n  submission?: Submission\n): Request {\n  let url = history.createURL(stripHashFromPath(location)).toString();\n  let init: RequestInit = { signal };\n\n  if (submission && isMutationMethod(submission.formMethod)) {\n    let { formMethod, formEncType } = submission;\n    // Didn't think we needed this but it turns out unlike other methods, patch\n    // won't be properly normalized to uppercase and results in a 405 error.\n    // See: https://fetch.spec.whatwg.org/#concept-method\n    init.method = formMethod.toUpperCase();\n\n    if (formEncType === \"application/json\") {\n      init.headers = new Headers({ \"Content-Type\": formEncType });\n      init.body = JSON.stringify(submission.json);\n    } else if (formEncType === \"text/plain\") {\n      // Content-Type is inferred (https://fetch.spec.whatwg.org/#dom-request)\n      init.body = submission.text;\n    } else if (\n      formEncType === \"application/x-www-form-urlencoded\" &&\n      submission.formData\n    ) {\n      // Content-Type is inferred (https://fetch.spec.whatwg.org/#dom-request)\n      init.body = convertFormDataToSearchParams(submission.formData);\n    } else {\n      // Content-Type is inferred (https://fetch.spec.whatwg.org/#dom-request)\n      init.body = submission.formData;\n    }\n  }\n\n  return new Request(url, init);\n}\n\nfunction convertFormDataToSearchParams(formData: FormData): URLSearchParams {\n  let searchParams = new URLSearchParams();\n\n  for (let [key, value] of formData.entries()) {\n    // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#converting-an-entry-list-to-a-list-of-name-value-pairs\n    searchParams.append(key, typeof value === \"string\" ? value : value.name);\n  }\n\n  return searchParams;\n}\n\nfunction convertSearchParamsToFormData(\n  searchParams: URLSearchParams\n): FormData {\n  let formData = new FormData();\n  for (let [key, value] of searchParams.entries()) {\n    formData.append(key, value);\n  }\n  return formData;\n}\n\nfunction processRouteLoaderData(\n  matches: AgnosticDataRouteMatch[],\n  results: Record<string, DataResult>,\n  pendingActionResult: PendingActionResult | undefined,\n  activeDeferreds: Map<string, DeferredData>,\n  skipLoaderErrorBubbling: boolean\n): {\n  loaderData: RouterState[\"loaderData\"];\n  errors: RouterState[\"errors\"] | null;\n  statusCode: number;\n  loaderHeaders: Record<string, Headers>;\n} {\n  // Fill in loaderData/errors from our loaders\n  let loaderData: RouterState[\"loaderData\"] = {};\n  let errors: RouterState[\"errors\"] | null = null;\n  let statusCode: number | undefined;\n  let foundError = false;\n  let loaderHeaders: Record<string, Headers> = {};\n  let pendingError =\n    pendingActionResult && isErrorResult(pendingActionResult[1])\n      ? pendingActionResult[1].error\n      : undefined;\n\n  // Process loader results into state.loaderData/state.errors\n  matches.forEach((match) => {\n    if (!(match.route.id in results)) {\n      return;\n    }\n    let id = match.route.id;\n    let result = results[id];\n    invariant(\n      !isRedirectResult(result),\n      \"Cannot handle redirect results in processLoaderData\"\n    );\n    if (isErrorResult(result)) {\n      let error = result.error;\n      // If we have a pending action error, we report it at the highest-route\n      // that throws a loader error, and then clear it out to indicate that\n      // it was consumed\n      if (pendingError !== undefined) {\n        error = pendingError;\n        pendingError = undefined;\n      }\n\n      errors = errors || {};\n\n      if (skipLoaderErrorBubbling) {\n        errors[id] = error;\n      } else {\n        // Look upwards from the matched route for the closest ancestor error\n        // boundary, defaulting to the root match.  Prefer higher error values\n        // if lower errors bubble to the same boundary\n        let boundaryMatch = findNearestBoundary(matches, id);\n        if (errors[boundaryMatch.route.id] == null) {\n          errors[boundaryMatch.route.id] = error;\n        }\n      }\n\n      // Clear our any prior loaderData for the throwing route\n      loaderData[id] = undefined;\n\n      // Once we find our first (highest) error, we set the status code and\n      // prevent deeper status codes from overriding\n      if (!foundError) {\n        foundError = true;\n        statusCode = isRouteErrorResponse(result.error)\n          ? result.error.status\n          : 500;\n      }\n      if (result.headers) {\n        loaderHeaders[id] = result.headers;\n      }\n    } else {\n      if (isDeferredResult(result)) {\n        activeDeferreds.set(id, result.deferredData);\n        loaderData[id] = result.deferredData.data;\n        // Error status codes always override success status codes, but if all\n        // loaders are successful we take the deepest status code.\n        if (\n          result.statusCode != null &&\n          result.statusCode !== 200 &&\n          !foundError\n        ) {\n          statusCode = result.statusCode;\n        }\n        if (result.headers) {\n          loaderHeaders[id] = result.headers;\n        }\n      } else {\n        loaderData[id] = result.data;\n        // Error status codes always override success status codes, but if all\n        // loaders are successful we take the deepest status code.\n        if (result.statusCode && result.statusCode !== 200 && !foundError) {\n          statusCode = result.statusCode;\n        }\n        if (result.headers) {\n          loaderHeaders[id] = result.headers;\n        }\n      }\n    }\n  });\n\n  // If we didn't consume the pending action error (i.e., all loaders\n  // resolved), then consume it here.  Also clear out any loaderData for the\n  // throwing route\n  if (pendingError !== undefined && pendingActionResult) {\n    errors = { [pendingActionResult[0]]: pendingError };\n    loaderData[pendingActionResult[0]] = undefined;\n  }\n\n  return {\n    loaderData,\n    errors,\n    statusCode: statusCode || 200,\n    loaderHeaders,\n  };\n}\n\nfunction processLoaderData(\n  state: RouterState,\n  matches: AgnosticDataRouteMatch[],\n  results: Record<string, DataResult>,\n  pendingActionResult: PendingActionResult | undefined,\n  revalidatingFetchers: RevalidatingFetcher[],\n  fetcherResults: Record<string, DataResult>,\n  activeDeferreds: Map<string, DeferredData>\n): {\n  loaderData: RouterState[\"loaderData\"];\n  errors?: RouterState[\"errors\"];\n} {\n  let { loaderData, errors } = processRouteLoaderData(\n    matches,\n    results,\n    pendingActionResult,\n    activeDeferreds,\n    false // This method is only called client side so we always want to bubble\n  );\n\n  // Process results from our revalidating fetchers\n  revalidatingFetchers.forEach((rf) => {\n    let { key, match, controller } = rf;\n    let result = fetcherResults[key];\n    invariant(result, \"Did not find corresponding fetcher result\");\n\n    // Process fetcher non-redirect errors\n    if (controller && controller.signal.aborted) {\n      // Nothing to do for aborted fetchers\n      return;\n    } else if (isErrorResult(result)) {\n      let boundaryMatch = findNearestBoundary(state.matches, match?.route.id);\n      if (!(errors && errors[boundaryMatch.route.id])) {\n        errors = {\n          ...errors,\n          [boundaryMatch.route.id]: result.error,\n        };\n      }\n      state.fetchers.delete(key);\n    } else if (isRedirectResult(result)) {\n      // Should never get here, redirects should get processed above, but we\n      // keep this to type narrow to a success result in the else\n      invariant(false, \"Unhandled fetcher revalidation redirect\");\n    } else if (isDeferredResult(result)) {\n      // Should never get here, deferred data should be awaited for fetchers\n      // in resolveDeferredResults\n      invariant(false, \"Unhandled fetcher deferred data\");\n    } else {\n      let doneFetcher = getDoneFetcher(result.data);\n      state.fetchers.set(key, doneFetcher);\n    }\n  });\n\n  return { loaderData, errors };\n}\n\nfunction mergeLoaderData(\n  loaderData: RouteData,\n  newLoaderData: RouteData,\n  matches: AgnosticDataRouteMatch[],\n  errors: RouteData | null | undefined\n): RouteData {\n  let mergedLoaderData = { ...newLoaderData };\n  for (let match of matches) {\n    let id = match.route.id;\n    if (newLoaderData.hasOwnProperty(id)) {\n      if (newLoaderData[id] !== undefined) {\n        mergedLoaderData[id] = newLoaderData[id];\n      } else {\n        // No-op - this is so we ignore existing data if we have a key in the\n        // incoming object with an undefined value, which is how we unset a prior\n        // loaderData if we encounter a loader error\n      }\n    } else if (loaderData[id] !== undefined && match.route.loader) {\n      // Preserve existing keys not included in newLoaderData and where a loader\n      // wasn't removed by HMR\n      mergedLoaderData[id] = loaderData[id];\n    }\n\n    if (errors && errors.hasOwnProperty(id)) {\n      // Don't keep any loader data below the boundary\n      break;\n    }\n  }\n  return mergedLoaderData;\n}\n\nfunction getActionDataForCommit(\n  pendingActionResult: PendingActionResult | undefined\n) {\n  if (!pendingActionResult) {\n    return {};\n  }\n  return isErrorResult(pendingActionResult[1])\n    ? {\n        // Clear out prior actionData on errors\n        actionData: {},\n      }\n    : {\n        actionData: {\n          [pendingActionResult[0]]: pendingActionResult[1].data,\n        },\n      };\n}\n\n// Find the nearest error boundary, looking upwards from the leaf route (or the\n// route specified by routeId) for the closest ancestor error boundary,\n// defaulting to the root match\nfunction findNearestBoundary(\n  matches: AgnosticDataRouteMatch[],\n  routeId?: string\n): AgnosticDataRouteMatch {\n  let eligibleMatches = routeId\n    ? matches.slice(0, matches.findIndex((m) => m.route.id === routeId) + 1)\n    : [...matches];\n  return (\n    eligibleMatches.reverse().find((m) => m.route.hasErrorBoundary === true) ||\n    matches[0]\n  );\n}\n\nfunction getShortCircuitMatches(routes: AgnosticDataRouteObject[]): {\n  matches: AgnosticDataRouteMatch[];\n  route: AgnosticDataRouteObject;\n} {\n  // Prefer a root layout route if present, otherwise shim in a route object\n  let route =\n    routes.length === 1\n      ? routes[0]\n      : routes.find((r) => r.index || !r.path || r.path === \"/\") || {\n          id: `__shim-error-route__`,\n        };\n\n  return {\n    matches: [\n      {\n        params: {},\n        pathname: \"\",\n        pathnameBase: \"\",\n        route,\n      },\n    ],\n    route,\n  };\n}\n\nfunction getInternalRouterError(\n  status: number,\n  {\n    pathname,\n    routeId,\n    method,\n    type,\n    message,\n  }: {\n    pathname?: string;\n    routeId?: string;\n    method?: string;\n    type?: \"defer-action\" | \"invalid-body\";\n    message?: string;\n  } = {}\n) {\n  let statusText = \"Unknown Server Error\";\n  let errorMessage = \"Unknown @remix-run/router error\";\n\n  if (status === 400) {\n    statusText = \"Bad Request\";\n    if (method && pathname && routeId) {\n      errorMessage =\n        `You made a ${method} request to \"${pathname}\" but ` +\n        `did not provide a \\`loader\\` for route \"${routeId}\", ` +\n        `so there is no way to handle the request.`;\n    } else if (type === \"defer-action\") {\n      errorMessage = \"defer() is not supported in actions\";\n    } else if (type === \"invalid-body\") {\n      errorMessage = \"Unable to encode submission body\";\n    }\n  } else if (status === 403) {\n    statusText = \"Forbidden\";\n    errorMessage = `Route \"${routeId}\" does not match URL \"${pathname}\"`;\n  } else if (status === 404) {\n    statusText = \"Not Found\";\n    errorMessage = `No route matches URL \"${pathname}\"`;\n  } else if (status === 405) {\n    statusText = \"Method Not Allowed\";\n    if (method && pathname && routeId) {\n      errorMessage =\n        `You made a ${method.toUpperCase()} request to \"${pathname}\" but ` +\n        `did not provide an \\`action\\` for route \"${routeId}\", ` +\n        `so there is no way to handle the request.`;\n    } else if (method) {\n      errorMessage = `Invalid request method \"${method.toUpperCase()}\"`;\n    }\n  }\n\n  return new ErrorResponseImpl(\n    status || 500,\n    statusText,\n    new Error(errorMessage),\n    true\n  );\n}\n\n// Find any returned redirect errors, starting from the lowest match\nfunction findRedirect(\n  results: Record<string, DataResult>\n): { key: string; result: RedirectResult } | undefined {\n  let entries = Object.entries(results);\n  for (let i = entries.length - 1; i >= 0; i--) {\n    let [key, result] = entries[i];\n    if (isRedirectResult(result)) {\n      return { key, result };\n    }\n  }\n}\n\nfunction stripHashFromPath(path: To) {\n  let parsedPath = typeof path === \"string\" ? parsePath(path) : path;\n  return createPath({ ...parsedPath, hash: \"\" });\n}\n\nfunction isHashChangeOnly(a: Location, b: Location): boolean {\n  if (a.pathname !== b.pathname || a.search !== b.search) {\n    return false;\n  }\n\n  if (a.hash === \"\") {\n    // /page -> /page#hash\n    return b.hash !== \"\";\n  } else if (a.hash === b.hash) {\n    // /page#hash -> /page#hash\n    return true;\n  } else if (b.hash !== \"\") {\n    // /page#hash -> /page#other\n    return true;\n  }\n\n  // If the hash is removed the browser will re-perform a request to the server\n  // /page#hash -> /page\n  return false;\n}\n\nfunction isPromise<T = unknown>(val: unknown): val is Promise<T> {\n  return typeof val === \"object\" && val != null && \"then\" in val;\n}\n\nfunction isDataStrategyResult(result: unknown): result is DataStrategyResult {\n  return (\n    result != null &&\n    typeof result === \"object\" &&\n    \"type\" in result &&\n    \"result\" in result &&\n    (result.type === ResultType.data || result.type === ResultType.error)\n  );\n}\n\nfunction isRedirectDataStrategyResultResult(result: DataStrategyResult) {\n  return (\n    isResponse(result.result) && redirectStatusCodes.has(result.result.status)\n  );\n}\n\nfunction isDeferredResult(result: DataResult): result is DeferredResult {\n  return result.type === ResultType.deferred;\n}\n\nfunction isErrorResult(result: DataResult): result is ErrorResult {\n  return result.type === ResultType.error;\n}\n\nfunction isRedirectResult(result?: DataResult): result is RedirectResult {\n  return (result && result.type) === ResultType.redirect;\n}\n\nexport function isDataWithResponseInit(\n  value: any\n): value is DataWithResponseInit<unknown> {\n  return (\n    typeof value === \"object\" &&\n    value != null &&\n    \"type\" in value &&\n    \"data\" in value &&\n    \"init\" in value &&\n    value.type === \"DataWithResponseInit\"\n  );\n}\n\nexport function isDeferredData(value: any): value is DeferredData {\n  let deferred: DeferredData = value;\n  return (\n    deferred &&\n    typeof deferred === \"object\" &&\n    typeof deferred.data === \"object\" &&\n    typeof deferred.subscribe === \"function\" &&\n    typeof deferred.cancel === \"function\" &&\n    typeof deferred.resolveData === \"function\"\n  );\n}\n\nfunction isResponse(value: any): value is Response {\n  return (\n    value != null &&\n    typeof value.status === \"number\" &&\n    typeof value.statusText === \"string\" &&\n    typeof value.headers === \"object\" &&\n    typeof value.body !== \"undefined\"\n  );\n}\n\nfunction isRedirectResponse(result: any): result is Response {\n  if (!isResponse(result)) {\n    return false;\n  }\n\n  let status = result.status;\n  let location = result.headers.get(\"Location\");\n  return status >= 300 && status <= 399 && location != null;\n}\n\nfunction isValidMethod(method: string): method is FormMethod | V7_FormMethod {\n  return validRequestMethods.has(method.toLowerCase() as FormMethod);\n}\n\nfunction isMutationMethod(\n  method: string\n): method is MutationFormMethod | V7_MutationFormMethod {\n  return validMutationMethods.has(method.toLowerCase() as MutationFormMethod);\n}\n\nasync function resolveNavigationDeferredResults(\n  matches: (AgnosticDataRouteMatch | null)[],\n  results: Record<string, DataResult>,\n  signal: AbortSignal,\n  currentMatches: AgnosticDataRouteMatch[],\n  currentLoaderData: RouteData\n) {\n  let entries = Object.entries(results);\n  for (let index = 0; index < entries.length; index++) {\n    let [routeId, result] = entries[index];\n    let match = matches.find((m) => m?.route.id === routeId);\n    // If we don't have a match, then we can have a deferred result to do\n    // anything with.  This is for revalidating fetchers where the route was\n    // removed during HMR\n    if (!match) {\n      continue;\n    }\n\n    let currentMatch = currentMatches.find(\n      (m) => m.route.id === match!.route.id\n    );\n    let isRevalidatingLoader =\n      currentMatch != null &&\n      !isNewRouteInstance(currentMatch, match) &&\n      (currentLoaderData && currentLoaderData[match.route.id]) !== undefined;\n\n    if (isDeferredResult(result) && isRevalidatingLoader) {\n      // Note: we do not have to touch activeDeferreds here since we race them\n      // against the signal in resolveDeferredData and they'll get aborted\n      // there if needed\n      await resolveDeferredData(result, signal, false).then((result) => {\n        if (result) {\n          results[routeId] = result;\n        }\n      });\n    }\n  }\n}\n\nasync function resolveFetcherDeferredResults(\n  matches: (AgnosticDataRouteMatch | null)[],\n  results: Record<string, DataResult>,\n  revalidatingFetchers: RevalidatingFetcher[]\n) {\n  for (let index = 0; index < revalidatingFetchers.length; index++) {\n    let { key, routeId, controller } = revalidatingFetchers[index];\n    let result = results[key];\n    let match = matches.find((m) => m?.route.id === routeId);\n    // If we don't have a match, then we can have a deferred result to do\n    // anything with.  This is for revalidating fetchers where the route was\n    // removed during HMR\n    if (!match) {\n      continue;\n    }\n\n    if (isDeferredResult(result)) {\n      // Note: we do not have to touch activeDeferreds here since we race them\n      // against the signal in resolveDeferredData and they'll get aborted\n      // there if needed\n      invariant(\n        controller,\n        \"Expected an AbortController for revalidating fetcher deferred result\"\n      );\n      await resolveDeferredData(result, controller.signal, true).then(\n        (result) => {\n          if (result) {\n            results[key] = result;\n          }\n        }\n      );\n    }\n  }\n}\n\nasync function resolveDeferredData(\n  result: DeferredResult,\n  signal: AbortSignal,\n  unwrap = false\n): Promise<SuccessResult | ErrorResult | undefined> {\n  let aborted = await result.deferredData.resolveData(signal);\n  if (aborted) {\n    return;\n  }\n\n  if (unwrap) {\n    try {\n      return {\n        type: ResultType.data,\n        data: result.deferredData.unwrappedData,\n      };\n    } catch (e) {\n      // Handle any TrackedPromise._error values encountered while unwrapping\n      return {\n        type: ResultType.error,\n        error: e,\n      };\n    }\n  }\n\n  return {\n    type: ResultType.data,\n    data: result.deferredData.data,\n  };\n}\n\nfunction hasNakedIndexQuery(search: string): boolean {\n  return new URLSearchParams(search).getAll(\"index\").some((v) => v === \"\");\n}\n\nfunction getTargetMatch(\n  matches: AgnosticDataRouteMatch[],\n  location: Location | string\n) {\n  let search =\n    typeof location === \"string\" ? parsePath(location).search : location.search;\n  if (\n    matches[matches.length - 1].route.index &&\n    hasNakedIndexQuery(search || \"\")\n  ) {\n    // Return the leaf index route when index is present\n    return matches[matches.length - 1];\n  }\n  // Otherwise grab the deepest \"path contributing\" match (ignoring index and\n  // pathless layout routes)\n  let pathMatches = getPathContributingMatches(matches);\n  return pathMatches[pathMatches.length - 1];\n}\n\nfunction getSubmissionFromNavigation(\n  navigation: Navigation\n): Submission | undefined {\n  let { formMethod, formAction, formEncType, text, formData, json } =\n    navigation;\n  if (!formMethod || !formAction || !formEncType) {\n    return;\n  }\n\n  if (text != null) {\n    return {\n      formMethod,\n      formAction,\n      formEncType,\n      formData: undefined,\n      json: undefined,\n      text,\n    };\n  } else if (formData != null) {\n    return {\n      formMethod,\n      formAction,\n      formEncType,\n      formData,\n      json: undefined,\n      text: undefined,\n    };\n  } else if (json !== undefined) {\n    return {\n      formMethod,\n      formAction,\n      formEncType,\n      formData: undefined,\n      json,\n      text: undefined,\n    };\n  }\n}\n\nfunction getLoadingNavigation(\n  location: Location,\n  submission?: Submission\n): NavigationStates[\"Loading\"] {\n  if (submission) {\n    let navigation: NavigationStates[\"Loading\"] = {\n      state: \"loading\",\n      location,\n      formMethod: submission.formMethod,\n      formAction: submission.formAction,\n      formEncType: submission.formEncType,\n      formData: submission.formData,\n      json: submission.json,\n      text: submission.text,\n    };\n    return navigation;\n  } else {\n    let navigation: NavigationStates[\"Loading\"] = {\n      state: \"loading\",\n      location,\n      formMethod: undefined,\n      formAction: undefined,\n      formEncType: undefined,\n      formData: undefined,\n      json: undefined,\n      text: undefined,\n    };\n    return navigation;\n  }\n}\n\nfunction getSubmittingNavigation(\n  location: Location,\n  submission: Submission\n): NavigationStates[\"Submitting\"] {\n  let navigation: NavigationStates[\"Submitting\"] = {\n    state: \"submitting\",\n    location,\n    formMethod: submission.formMethod,\n    formAction: submission.formAction,\n    formEncType: submission.formEncType,\n    formData: submission.formData,\n    json: submission.json,\n    text: submission.text,\n  };\n  return navigation;\n}\n\nfunction getLoadingFetcher(\n  submission?: Submission,\n  data?: Fetcher[\"data\"]\n): FetcherStates[\"Loading\"] {\n  if (submission) {\n    let fetcher: FetcherStates[\"Loading\"] = {\n      state: \"loading\",\n      formMethod: submission.formMethod,\n      formAction: submission.formAction,\n      formEncType: submission.formEncType,\n      formData: submission.formData,\n      json: submission.json,\n      text: submission.text,\n      data,\n    };\n    return fetcher;\n  } else {\n    let fetcher: FetcherStates[\"Loading\"] = {\n      state: \"loading\",\n      formMethod: undefined,\n      formAction: undefined,\n      formEncType: undefined,\n      formData: undefined,\n      json: undefined,\n      text: undefined,\n      data,\n    };\n    return fetcher;\n  }\n}\n\nfunction getSubmittingFetcher(\n  submission: Submission,\n  existingFetcher?: Fetcher\n): FetcherStates[\"Submitting\"] {\n  let fetcher: FetcherStates[\"Submitting\"] = {\n    state: \"submitting\",\n    formMethod: submission.formMethod,\n    formAction: submission.formAction,\n    formEncType: submission.formEncType,\n    formData: submission.formData,\n    json: submission.json,\n    text: submission.text,\n    data: existingFetcher ? existingFetcher.data : undefined,\n  };\n  return fetcher;\n}\n\nfunction getDoneFetcher(data: Fetcher[\"data\"]): FetcherStates[\"Idle\"] {\n  let fetcher: FetcherStates[\"Idle\"] = {\n    state: \"idle\",\n    formMethod: undefined,\n    formAction: undefined,\n    formEncType: undefined,\n    formData: undefined,\n    json: undefined,\n    text: undefined,\n    data,\n  };\n  return fetcher;\n}\n\nfunction restoreAppliedTransitions(\n  _window: Window,\n  transitions: Map<string, Set<string>>\n) {\n  try {\n    let sessionPositions = _window.sessionStorage.getItem(\n      TRANSITIONS_STORAGE_KEY\n    );\n    if (sessionPositions) {\n      let json = JSON.parse(sessionPositions);\n      for (let [k, v] of Object.entries(json || {})) {\n        if (v && Array.isArray(v)) {\n          transitions.set(k, new Set(v || []));\n        }\n      }\n    }\n  } catch (e) {\n    // no-op, use default empty object\n  }\n}\n\nfunction persistAppliedTransitions(\n  _window: Window,\n  transitions: Map<string, Set<string>>\n) {\n  if (transitions.size > 0) {\n    let json: Record<string, string[]> = {};\n    for (let [k, v] of transitions) {\n      json[k] = [...v];\n    }\n    try {\n      _window.sessionStorage.setItem(\n        TRANSITIONS_STORAGE_KEY,\n        JSON.stringify(json)\n      );\n    } catch (error) {\n      warning(\n        false,\n        `Failed to save applied view transitions in sessionStorage (${error}).`\n      );\n    }\n  }\n}\n//#endregion\n"],"names":["Action","PopStateEventType","createMemoryHistory","options","initialEntries","initialIndex","v5Compat","entries","map","entry","index","createMemoryLocation","state","undefined","clampIndex","length","action","Pop","listener","n","Math","min","max","getCurrentLocation","to","key","location","createLocation","pathname","warning","charAt","JSON","stringify","createHref","createPath","history","createURL","URL","encodeLocation","path","parsePath","search","hash","push","Push","nextLocation","splice","delta","replace","Replace","go","nextIndex","listen","fn","createBrowserHistory","createBrowserLocation","window","globalHistory","usr","createBrowserHref","getUrlBasedHistory","createHashHistory","createHashLocation","substr","startsWith","createHashHref","base","document","querySelector","href","getAttribute","url","hashIndex","indexOf","slice","validateHashLocation","invariant","value","message","Error","cond","console","warn","e","createKey","random","toString","getHistoryState","idx","current","_extends","_ref","parsedPath","searchIndex","getLocation","validateLocation","defaultView","getIndex","replaceState","handlePop","historyState","pushState","error","DOMException","name","assign","origin","addEventListener","removeEventListener","ResultType","immutableRouteKeys","Set","isIndexRoute","route","convertRoutesToDataRoutes","routes","mapRouteProperties","parentPath","manifest","treePath","String","id","join","children","indexRoute","pathOrLayoutRoute","matchRoutes","locationArg","basename","matchRoutesImpl","allowPartial","stripBasename","branches","flattenRoutes","rankRouteBranches","matches","i","decoded","decodePath","matchRouteBranch","convertRouteMatchToUiMatch","match","loaderData","params","data","handle","parentsMeta","flattenRoute","relativePath","meta","caseSensitive","childrenIndex","joinPaths","routesMeta","concat","score","computeScore","forEach","_route$path","includes","exploded","explodeOptionalSegments","segments","split","first","rest","isOptional","endsWith","required","restExploded","result","subpath","sort","a","b","compareIndexes","paramRe","dynamicSegmentValue","indexRouteValue","emptySegmentValue","staticSegmentValue","splatPenalty","isSplat","s","initialScore","some","filter","reduce","segment","test","siblings","every","branch","matchedParams","matchedPathname","end","remainingPathname","matchPath","Object","pathnameBase","normalizePathname","generatePath","originalPath","prefix","p","array","isLastSegment","star","keyMatch","optional","param","pattern","matcher","compiledParams","compilePath","captureGroups","memo","paramName","splatValue","regexpSource","_","RegExp","v","decodeURIComponent","toLowerCase","startIndex","nextChar","ABSOLUTE_URL_REGEX","isAbsoluteUrl","resolvePath","fromPathname","toPathname","oldPathname","resolvePathname","substring","normalizeSearch","normalizeHash","relativeSegments","pop","getInvalidPathError","char","field","dest","getPathContributingMatches","getResolveToMatches","v7_relativeSplatPath","pathMatches","resolveTo","toArg","routePathnames","locationPathname","isPathRelative","isEmptyPath","from","routePathnameIndex","toSegments","shift","hasExplicitTrailingSlash","hasCurrentTrailingSlash","getToPathname","paths","json","init","responseInit","status","headers","Headers","has","set","Response","DataWithResponseInit","constructor","type","AbortedDeferredError","DeferredData","pendingKeysSet","subscribers","deferredKeys","Array","isArray","reject","abortPromise","Promise","r","controller","AbortController","onAbort","unlistenAbortSignal","signal","acc","_ref2","trackPromise","done","add","promise","race","then","onSettle","catch","defineProperty","get","aborted","delete","undefinedError","emit","settledKey","subscriber","subscribe","cancel","abort","k","resolveData","resolve","size","unwrappedData","_ref3","unwrapTrackedPromise","pendingKeys","isTrackedPromise","_tracked","_error","_data","defer","redirect","redirectDocument","response","ErrorResponseImpl","statusText","internal","isRouteErrorResponse","validMutationMethodsArr","validMutationMethods","validRequestMethodsArr","validRequestMethods","redirectStatusCodes","redirectPreserveMethodStatusCodes","IDLE_NAVIGATION","formMethod","formAction","formEncType","formData","text","IDLE_FETCHER","IDLE_BLOCKER","proceed","reset","defaultMapRouteProperties","hasErrorBoundary","Boolean","TRANSITIONS_STORAGE_KEY","createRouter","routerWindow","isBrowser","createElement","isServer","detectErrorBoundary","dataRoutes","inFlightDataRoutes","dataStrategyImpl","dataStrategy","defaultDataStrategy","patchRoutesOnNavigationImpl","patchRoutesOnNavigation","future","v7_fetcherPersist","v7_normalizeFormMethod","v7_partialHydration","v7_prependBasename","v7_skipActionErrorRevalidation","unlistenHistory","savedScrollPositions","getScrollRestorationKey","getScrollPosition","initialScrollRestored","hydrationData","initialMatches","initialMatchesIsFOW","initialErrors","getInternalRouterError","getShortCircuitMatches","fogOfWar","checkFogOfWar","active","initialized","m","lazy","loader","errors","findIndex","shouldLoadRouteOnHydration","router","historyAction","navigation","restoreScrollPosition","preventScrollReset","revalidation","actionData","fetchers","Map","blockers","pendingAction","HistoryAction","pendingPreventScrollReset","pendingNavigationController","pendingViewTransitionEnabled","appliedViewTransitions","removePageHideEventListener","isUninterruptedRevalidation","isRevalidationRequired","cancelledDeferredRoutes","cancelledFetcherLoads","fetchControllers","incrementingLoadId","pendingNavigationLoadId","fetchReloadIds","fetchRedirectIds","fetchLoadMatches","activeFetchers","deletedFetchers","activeDeferreds","blockerFunctions","unblockBlockerHistoryUpdate","initialize","blockerKey","shouldBlockNavigation","currentLocation","nextHistoryUpdatePromise","updateBlocker","updateState","startNavigation","restoreAppliedTransitions","_saveAppliedTransitions","persistAppliedTransitions","initialHydration","dispose","clear","deleteFetcher","deleteBlocker","newState","opts","completedFetchers","deletedFetchersKeys","fetcher","viewTransitionOpts","flushSync","completeNavigation","_temp","_location$state","_location$state2","isActionReload","isMutationMethod","_isRedirect","keys","mergeLoaderData","priorPaths","toPaths","getSavedScrollPosition","navigate","normalizedPath","normalizeTo","fromRouteId","relative","submission","normalizeNavigateOptions","userReplace","pendingError","enableViewTransition","viewTransition","revalidate","interruptActiveLoads","startUninterruptedRevalidation","overrideNavigation","saveScrollPosition","routesToUse","loadingNavigation","isHashChangeOnly","notFoundMatches","handleNavigational404","request","createClientSideRequest","pendingActionResult","findNearestBoundary","actionResult","handleAction","shortCircuited","routeId","isErrorResult","getLoadingNavigation","updatedMatches","handleLoaders","fetcherSubmission","getActionDataForCommit","isFogOfWar","getSubmittingNavigation","discoverResult","discoverRoutes","boundaryId","partialMatches","actionMatch","getTargetMatch","method","results","callDataStrategy","isRedirectResult","normalizeRedirectLocation","startRedirectNavigation","isDeferredResult","boundaryMatch","activeSubmission","getSubmissionFromNavigation","shouldUpdateNavigationState","getUpdatedActionData","matchesToLoad","revalidatingFetchers","getMatchesToLoad","cancelActiveDeferreds","updatedFetchers","markFetchRedirectsDone","updates","getUpdatedRevalidatingFetchers","rf","abortFetcher","abortPendingFetchRevalidations","f","loaderResults","fetcherResults","callLoadersAndMaybeResolveData","findRedirect","processLoaderData","deferredData","didAbortFetchLoads","abortStaleFetchLoads","shouldUpdateFetchers","revalidatingFetcher","getLoadingFetcher","fetch","setFetcherError","handleFetcherAction","handleFetcherLoader","requestMatches","detectAndHandle405Error","existingFetcher","updateFetcherState","getSubmittingFetcher","abortController","fetchRequest","originatingLoadId","actionResults","getDoneFetcher","revalidationRequest","loadId","loadFetcher","staleKey","doneFetcher","resolveDeferredData","isNavigation","_temp2","redirectLocation","isDocumentReload","redirectHistoryAction","fetcherKey","dataResults","callDataStrategyImpl","isRedirectDataStrategyResultResult","normalizeRelativeRoutingRedirectResponse","convertDataStrategyResultToDataResult","fetchersToLoad","currentMatches","loaderResultsPromise","fetcherResultsPromise","all","resolveNavigationDeferredResults","resolveFetcherDeferredResults","getFetcher","deleteFetcherAndUpdateState","count","markFetchersDone","doneKeys","landedId","yeetedKeys","getBlocker","blocker","newBlocker","blockerFunction","predicate","cancelledRouteIds","dfd","enableScrollRestoration","positions","getPosition","getKey","y","getScrollKey","fogMatches","isNonHMR","localManifest","patch","patchRoutesImpl","newMatches","newPartialMatches","_internalSetRoutes","newRoutes","patchRoutes","_internalFetchControllers","_internalActiveDeferreds","UNSAFE_DEFERRED_SYMBOL","Symbol","createStaticHandler","v7_throwAbortReason","query","_temp3","requestContext","skipLoaderErrorBubbling","isValidMethod","methodNotAllowedMatches","statusCode","loaderHeaders","actionHeaders","queryImpl","isResponse","queryRoute","_temp4","find","values","_result$activeDeferre","routeMatch","submit","loadRouteData","isDataStrategyResult","isRedirectResponse","isRouteRequest","throwStaticHandlerAbortedError","Location","loaderRequest","Request","context","getLoaderMatchesUntilBoundary","processRouteLoaderData","executedLoaders","fromEntries","getStaticContextFromError","newContext","_deepestRenderedBoundaryId","reason","isSubmissionNavigation","body","prependBasename","contextualMatches","activeRouteMatch","nakedIndex","hasNakedIndexQuery","URLSearchParams","indexValues","getAll","append","qs","normalizeFormMethod","isFetcher","getInvalidBodyError","rawFormMethod","toUpperCase","stripHashFromPath","FormData","parse","searchParams","convertFormDataToSearchParams","convertSearchParamsToFormData","includeBoundary","skipActionErrorRevalidation","currentUrl","nextUrl","boundaryMatches","actionStatus","shouldSkipRevalidation","navigationMatches","isNewLoader","currentRouteMatch","nextRouteMatch","shouldRevalidateLoader","currentParams","nextParams","defaultShouldRevalidate","isNewRouteInstance","fetcherMatches","fetcherMatch","shouldRevalidate","hasData","hasError","hydrate","currentLoaderData","currentMatch","isNew","isMissingData","currentPath","loaderMatch","arg","routeChoice","_childrenToPatch","childrenToPatch","uniqueChildren","newRoute","existingRoute","isSameRoute","aChild","_existingRoute$childr","bChild","loadLazyRouteModule","lazyRoute","routeToUpdate","routeUpdates","lazyRouteProperty","staticRouteValue","isPropertyStaticallyDefined","_ref4","shouldLoad","loadRouteDefinitionsPromises","dsMatches","loadRoutePromise","handlerOverride","callLoaderOrAction","staticContext","onReject","runHandler","handler","actualHandler","ctx","handlerPromise","val","handlerError","dataStrategyResult","contentType","isDataWithResponseInit","_result$init3","_result$init4","_result$init","_result$init2","isDeferredData","_result$init5","_result$init6","deferred","_result$init7","_result$init8","trimmedMatches","historyInstance","invalidProtocols","normalizedLocation","protocol","isSameBasename","foundError","newLoaderData","mergedLoaderData","hasOwnProperty","eligibleMatches","reverse","_temp5","errorMessage","isRevalidatingLoader","unwrap","_window","transitions","sessionPositions","sessionStorage","getItem","setItem"],"mappings":"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"}
Index: frontend/node_modules/@remix-run/router/dist/router.d.ts
===================================================================
--- frontend/node_modules/@remix-run/router/dist/router.d.ts	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/@remix-run/router/dist/router.d.ts	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,525 @@
+import type { History, Location, Path, To } from "./history";
+import { Action as HistoryAction } from "./history";
+import type { AgnosticDataRouteMatch, AgnosticDataRouteObject, AgnosticRouteObject, DataStrategyFunction, DeferredData, DetectErrorBoundaryFunction, FormEncType, HTMLFormMethod, MapRoutePropertiesFunction, RouteData, Submission, UIMatch, AgnosticPatchRoutesOnNavigationFunction, DataWithResponseInit } from "./utils";
+/**
+ * A Router instance manages all navigation and data loading/mutations
+ */
+export interface Router {
+    /**
+     * @internal
+     * PRIVATE - DO NOT USE
+     *
+     * Return the basename for the router
+     */
+    get basename(): RouterInit["basename"];
+    /**
+     * @internal
+     * PRIVATE - DO NOT USE
+     *
+     * Return the future config for the router
+     */
+    get future(): FutureConfig;
+    /**
+     * @internal
+     * PRIVATE - DO NOT USE
+     *
+     * Return the current state of the router
+     */
+    get state(): RouterState;
+    /**
+     * @internal
+     * PRIVATE - DO NOT USE
+     *
+     * Return the routes for this router instance
+     */
+    get routes(): AgnosticDataRouteObject[];
+    /**
+     * @internal
+     * PRIVATE - DO NOT USE
+     *
+     * Return the window associated with the router
+     */
+    get window(): RouterInit["window"];
+    /**
+     * @internal
+     * PRIVATE - DO NOT USE
+     *
+     * Initialize the router, including adding history listeners and kicking off
+     * initial data fetches.  Returns a function to cleanup listeners and abort
+     * any in-progress loads
+     */
+    initialize(): Router;
+    /**
+     * @internal
+     * PRIVATE - DO NOT USE
+     *
+     * Subscribe to router.state updates
+     *
+     * @param fn function to call with the new state
+     */
+    subscribe(fn: RouterSubscriber): () => void;
+    /**
+     * @internal
+     * PRIVATE - DO NOT USE
+     *
+     * Enable scroll restoration behavior in the router
+     *
+     * @param savedScrollPositions Object that will manage positions, in case
+     *                             it's being restored from sessionStorage
+     * @param getScrollPosition    Function to get the active Y scroll position
+     * @param getKey               Function to get the key to use for restoration
+     */
+    enableScrollRestoration(savedScrollPositions: Record<string, number>, getScrollPosition: GetScrollPositionFunction, getKey?: GetScrollRestorationKeyFunction): () => void;
+    /**
+     * @internal
+     * PRIVATE - DO NOT USE
+     *
+     * Navigate forward/backward in the history stack
+     * @param to Delta to move in the history stack
+     */
+    navigate(to: number): Promise<void>;
+    /**
+     * Navigate to the given path
+     * @param to Path to navigate to
+     * @param opts Navigation options (method, submission, etc.)
+     */
+    navigate(to: To | null, opts?: RouterNavigateOptions): Promise<void>;
+    /**
+     * @internal
+     * PRIVATE - DO NOT USE
+     *
+     * Trigger a fetcher load/submission
+     *
+     * @param key     Fetcher key
+     * @param routeId Route that owns the fetcher
+     * @param href    href to fetch
+     * @param opts    Fetcher options, (method, submission, etc.)
+     */
+    fetch(key: string, routeId: string, href: string | null, opts?: RouterFetchOptions): void;
+    /**
+     * @internal
+     * PRIVATE - DO NOT USE
+     *
+     * Trigger a revalidation of all current route loaders and fetcher loads
+     */
+    revalidate(): void;
+    /**
+     * @internal
+     * PRIVATE - DO NOT USE
+     *
+     * Utility function to create an href for the given location
+     * @param location
+     */
+    createHref(location: Location | URL): string;
+    /**
+     * @internal
+     * PRIVATE - DO NOT USE
+     *
+     * Utility function to URL encode a destination path according to the internal
+     * history implementation
+     * @param to
+     */
+    encodeLocation(to: To): Path;
+    /**
+     * @internal
+     * PRIVATE - DO NOT USE
+     *
+     * Get/create a fetcher for the given key
+     * @param key
+     */
+    getFetcher<TData = any>(key: string): Fetcher<TData>;
+    /**
+     * @internal
+     * PRIVATE - DO NOT USE
+     *
+     * Delete the fetcher for a given key
+     * @param key
+     */
+    deleteFetcher(key: string): void;
+    /**
+     * @internal
+     * PRIVATE - DO NOT USE
+     *
+     * Cleanup listeners and abort any in-progress loads
+     */
+    dispose(): void;
+    /**
+     * @internal
+     * PRIVATE - DO NOT USE
+     *
+     * Get a navigation blocker
+     * @param key The identifier for the blocker
+     * @param fn The blocker function implementation
+     */
+    getBlocker(key: string, fn: BlockerFunction): Blocker;
+    /**
+     * @internal
+     * PRIVATE - DO NOT USE
+     *
+     * Delete a navigation blocker
+     * @param key The identifier for the blocker
+     */
+    deleteBlocker(key: string): void;
+    /**
+     * @internal
+     * PRIVATE DO NOT USE
+     *
+     * Patch additional children routes into an existing parent route
+     * @param routeId The parent route id or a callback function accepting `patch`
+     *                to perform batch patching
+     * @param children The additional children routes
+     */
+    patchRoutes(routeId: string | null, children: AgnosticRouteObject[]): void;
+    /**
+     * @internal
+     * PRIVATE - DO NOT USE
+     *
+     * HMR needs to pass in-flight route updates to React Router
+     * TODO: Replace this with granular route update APIs (addRoute, updateRoute, deleteRoute)
+     */
+    _internalSetRoutes(routes: AgnosticRouteObject[]): void;
+    /**
+     * @internal
+     * PRIVATE - DO NOT USE
+     *
+     * Internal fetch AbortControllers accessed by unit tests
+     */
+    _internalFetchControllers: Map<string, AbortController>;
+    /**
+     * @internal
+     * PRIVATE - DO NOT USE
+     *
+     * Internal pending DeferredData instances accessed by unit tests
+     */
+    _internalActiveDeferreds: Map<string, DeferredData>;
+}
+/**
+ * State maintained internally by the router.  During a navigation, all states
+ * reflect the the "old" location unless otherwise noted.
+ */
+export interface RouterState {
+    /**
+     * The action of the most recent navigation
+     */
+    historyAction: HistoryAction;
+    /**
+     * The current location reflected by the router
+     */
+    location: Location;
+    /**
+     * The current set of route matches
+     */
+    matches: AgnosticDataRouteMatch[];
+    /**
+     * Tracks whether we've completed our initial data load
+     */
+    initialized: boolean;
+    /**
+     * Current scroll position we should start at for a new view
+     *  - number -> scroll position to restore to
+     *  - false -> do not restore scroll at all (used during submissions)
+     *  - null -> don't have a saved position, scroll to hash or top of page
+     */
+    restoreScrollPosition: number | false | null;
+    /**
+     * Indicate whether this navigation should skip resetting the scroll position
+     * if we are unable to restore the scroll position
+     */
+    preventScrollReset: boolean;
+    /**
+     * Tracks the state of the current navigation
+     */
+    navigation: Navigation;
+    /**
+     * Tracks any in-progress revalidations
+     */
+    revalidation: RevalidationState;
+    /**
+     * Data from the loaders for the current matches
+     */
+    loaderData: RouteData;
+    /**
+     * Data from the action for the current matches
+     */
+    actionData: RouteData | null;
+    /**
+     * Errors caught from loaders for the current matches
+     */
+    errors: RouteData | null;
+    /**
+     * Map of current fetchers
+     */
+    fetchers: Map<string, Fetcher>;
+    /**
+     * Map of current blockers
+     */
+    blockers: Map<string, Blocker>;
+}
+/**
+ * Data that can be passed into hydrate a Router from SSR
+ */
+export type HydrationState = Partial<Pick<RouterState, "loaderData" | "actionData" | "errors">>;
+/**
+ * Future flags to toggle new feature behavior
+ */
+export interface FutureConfig {
+    v7_fetcherPersist: boolean;
+    v7_normalizeFormMethod: boolean;
+    v7_partialHydration: boolean;
+    v7_prependBasename: boolean;
+    v7_relativeSplatPath: boolean;
+    v7_skipActionErrorRevalidation: boolean;
+}
+/**
+ * Initialization options for createRouter
+ */
+export interface RouterInit {
+    routes: AgnosticRouteObject[];
+    history: History;
+    basename?: string;
+    /**
+     * @deprecated Use `mapRouteProperties` instead
+     */
+    detectErrorBoundary?: DetectErrorBoundaryFunction;
+    mapRouteProperties?: MapRoutePropertiesFunction;
+    future?: Partial<FutureConfig>;
+    hydrationData?: HydrationState;
+    window?: Window;
+    dataStrategy?: DataStrategyFunction;
+    patchRoutesOnNavigation?: AgnosticPatchRoutesOnNavigationFunction;
+}
+/**
+ * State returned from a server-side query() call
+ */
+export interface StaticHandlerContext {
+    basename: Router["basename"];
+    location: RouterState["location"];
+    matches: RouterState["matches"];
+    loaderData: RouterState["loaderData"];
+    actionData: RouterState["actionData"];
+    errors: RouterState["errors"];
+    statusCode: number;
+    loaderHeaders: Record<string, Headers>;
+    actionHeaders: Record<string, Headers>;
+    activeDeferreds: Record<string, DeferredData> | null;
+    _deepestRenderedBoundaryId?: string | null;
+}
+/**
+ * A StaticHandler instance manages a singular SSR navigation/fetch event
+ */
+export interface StaticHandler {
+    dataRoutes: AgnosticDataRouteObject[];
+    query(request: Request, opts?: {
+        requestContext?: unknown;
+        skipLoaderErrorBubbling?: boolean;
+        dataStrategy?: DataStrategyFunction;
+    }): Promise<StaticHandlerContext | Response>;
+    queryRoute(request: Request, opts?: {
+        routeId?: string;
+        requestContext?: unknown;
+        dataStrategy?: DataStrategyFunction;
+    }): Promise<any>;
+}
+type ViewTransitionOpts = {
+    currentLocation: Location;
+    nextLocation: Location;
+};
+/**
+ * Subscriber function signature for changes to router state
+ */
+export interface RouterSubscriber {
+    (state: RouterState, opts: {
+        deletedFetchers: string[];
+        viewTransitionOpts?: ViewTransitionOpts;
+        flushSync: boolean;
+    }): void;
+}
+/**
+ * Function signature for determining the key to be used in scroll restoration
+ * for a given location
+ */
+export interface GetScrollRestorationKeyFunction {
+    (location: Location, matches: UIMatch[]): string | null;
+}
+/**
+ * Function signature for determining the current scroll position
+ */
+export interface GetScrollPositionFunction {
+    (): number;
+}
+export type RelativeRoutingType = "route" | "path";
+type BaseNavigateOrFetchOptions = {
+    preventScrollReset?: boolean;
+    relative?: RelativeRoutingType;
+    flushSync?: boolean;
+};
+type BaseNavigateOptions = BaseNavigateOrFetchOptions & {
+    replace?: boolean;
+    state?: any;
+    fromRouteId?: string;
+    viewTransition?: boolean;
+};
+type BaseSubmissionOptions = {
+    formMethod?: HTMLFormMethod;
+    formEncType?: FormEncType;
+} & ({
+    formData: FormData;
+    body?: undefined;
+} | {
+    formData?: undefined;
+    body: any;
+});
+/**
+ * Options for a navigate() call for a normal (non-submission) navigation
+ */
+type LinkNavigateOptions = BaseNavigateOptions;
+/**
+ * Options for a navigate() call for a submission navigation
+ */
+type SubmissionNavigateOptions = BaseNavigateOptions & BaseSubmissionOptions;
+/**
+ * Options to pass to navigate() for a navigation
+ */
+export type RouterNavigateOptions = LinkNavigateOptions | SubmissionNavigateOptions;
+/**
+ * Options for a fetch() load
+ */
+type LoadFetchOptions = BaseNavigateOrFetchOptions;
+/**
+ * Options for a fetch() submission
+ */
+type SubmitFetchOptions = BaseNavigateOrFetchOptions & BaseSubmissionOptions;
+/**
+ * Options to pass to fetch()
+ */
+export type RouterFetchOptions = LoadFetchOptions | SubmitFetchOptions;
+/**
+ * Potential states for state.navigation
+ */
+export type NavigationStates = {
+    Idle: {
+        state: "idle";
+        location: undefined;
+        formMethod: undefined;
+        formAction: undefined;
+        formEncType: undefined;
+        formData: undefined;
+        json: undefined;
+        text: undefined;
+    };
+    Loading: {
+        state: "loading";
+        location: Location;
+        formMethod: Submission["formMethod"] | undefined;
+        formAction: Submission["formAction"] | undefined;
+        formEncType: Submission["formEncType"] | undefined;
+        formData: Submission["formData"] | undefined;
+        json: Submission["json"] | undefined;
+        text: Submission["text"] | undefined;
+    };
+    Submitting: {
+        state: "submitting";
+        location: Location;
+        formMethod: Submission["formMethod"];
+        formAction: Submission["formAction"];
+        formEncType: Submission["formEncType"];
+        formData: Submission["formData"];
+        json: Submission["json"];
+        text: Submission["text"];
+    };
+};
+export type Navigation = NavigationStates[keyof NavigationStates];
+export type RevalidationState = "idle" | "loading";
+/**
+ * Potential states for fetchers
+ */
+type FetcherStates<TData = any> = {
+    Idle: {
+        state: "idle";
+        formMethod: undefined;
+        formAction: undefined;
+        formEncType: undefined;
+        text: undefined;
+        formData: undefined;
+        json: undefined;
+        data: TData | undefined;
+    };
+    Loading: {
+        state: "loading";
+        formMethod: Submission["formMethod"] | undefined;
+        formAction: Submission["formAction"] | undefined;
+        formEncType: Submission["formEncType"] | undefined;
+        text: Submission["text"] | undefined;
+        formData: Submission["formData"] | undefined;
+        json: Submission["json"] | undefined;
+        data: TData | undefined;
+    };
+    Submitting: {
+        state: "submitting";
+        formMethod: Submission["formMethod"];
+        formAction: Submission["formAction"];
+        formEncType: Submission["formEncType"];
+        text: Submission["text"];
+        formData: Submission["formData"];
+        json: Submission["json"];
+        data: TData | undefined;
+    };
+};
+export type Fetcher<TData = any> = FetcherStates<TData>[keyof FetcherStates<TData>];
+interface BlockerBlocked {
+    state: "blocked";
+    reset(): void;
+    proceed(): void;
+    location: Location;
+}
+interface BlockerUnblocked {
+    state: "unblocked";
+    reset: undefined;
+    proceed: undefined;
+    location: undefined;
+}
+interface BlockerProceeding {
+    state: "proceeding";
+    reset: undefined;
+    proceed: undefined;
+    location: Location;
+}
+export type Blocker = BlockerUnblocked | BlockerBlocked | BlockerProceeding;
+export type BlockerFunction = (args: {
+    currentLocation: Location;
+    nextLocation: Location;
+    historyAction: HistoryAction;
+}) => boolean;
+export declare const IDLE_NAVIGATION: NavigationStates["Idle"];
+export declare const IDLE_FETCHER: FetcherStates["Idle"];
+export declare const IDLE_BLOCKER: BlockerUnblocked;
+/**
+ * Create a router and listen to history POP navigations
+ */
+export declare function createRouter(init: RouterInit): Router;
+export declare const UNSAFE_DEFERRED_SYMBOL: unique symbol;
+/**
+ * Future flags to toggle new feature behavior
+ */
+export interface StaticHandlerFutureConfig {
+    v7_relativeSplatPath: boolean;
+    v7_throwAbortReason: boolean;
+}
+export interface CreateStaticHandlerOptions {
+    basename?: string;
+    /**
+     * @deprecated Use `mapRouteProperties` instead
+     */
+    detectErrorBoundary?: DetectErrorBoundaryFunction;
+    mapRouteProperties?: MapRoutePropertiesFunction;
+    future?: Partial<StaticHandlerFutureConfig>;
+}
+export declare function createStaticHandler(routes: AgnosticRouteObject[], opts?: CreateStaticHandlerOptions): StaticHandler;
+/**
+ * Given an existing StaticHandlerContext and an error thrown at render time,
+ * provide an updated StaticHandlerContext suitable for a second SSR render
+ */
+export declare function getStaticContextFromError(routes: AgnosticDataRouteObject[], context: StaticHandlerContext, error: any): StaticHandlerContext;
+export declare function isDataWithResponseInit(value: any): value is DataWithResponseInit<unknown>;
+export declare function isDeferredData(value: any): value is DeferredData;
+export {};
Index: frontend/node_modules/@remix-run/router/dist/router.js
===================================================================
--- frontend/node_modules/@remix-run/router/dist/router.js	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/@remix-run/router/dist/router.js	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,5072 @@
+/**
+ * @remix-run/router v1.23.2
+ *
+ * Copyright (c) Remix Software Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE.md file in the root directory of this source tree.
+ *
+ * @license MIT
+ */
+function _extends() {
+  _extends = Object.assign ? Object.assign.bind() : function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+    return target;
+  };
+  return _extends.apply(this, arguments);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//#region Types and Constants
+////////////////////////////////////////////////////////////////////////////////
+/**
+ * Actions represent the type of change to a location value.
+ */
+var Action;
+(function (Action) {
+  /**
+   * A POP indicates a change to an arbitrary index in the history stack, such
+   * as a back or forward navigation. It does not describe the direction of the
+   * navigation, only that the current index changed.
+   *
+   * Note: This is the default action for newly created history objects.
+   */
+  Action["Pop"] = "POP";
+  /**
+   * A PUSH indicates a new entry being added to the history stack, such as when
+   * a link is clicked and a new page loads. When this happens, all subsequent
+   * entries in the stack are lost.
+   */
+  Action["Push"] = "PUSH";
+  /**
+   * A REPLACE indicates the entry at the current index in the history stack
+   * being replaced by a new one.
+   */
+  Action["Replace"] = "REPLACE";
+})(Action || (Action = {}));
+const PopStateEventType = "popstate";
+/**
+ * Memory history stores the current location in memory. It is designed for use
+ * in stateful non-browser environments like tests and React Native.
+ */
+function createMemoryHistory(options) {
+  if (options === void 0) {
+    options = {};
+  }
+  let {
+    initialEntries = ["/"],
+    initialIndex,
+    v5Compat = false
+  } = options;
+  let entries; // Declare so we can access from createMemoryLocation
+  entries = initialEntries.map((entry, index) => createMemoryLocation(entry, typeof entry === "string" ? null : entry.state, index === 0 ? "default" : undefined));
+  let index = clampIndex(initialIndex == null ? entries.length - 1 : initialIndex);
+  let action = Action.Pop;
+  let listener = null;
+  function clampIndex(n) {
+    return Math.min(Math.max(n, 0), entries.length - 1);
+  }
+  function getCurrentLocation() {
+    return entries[index];
+  }
+  function createMemoryLocation(to, state, key) {
+    if (state === void 0) {
+      state = null;
+    }
+    let location = createLocation(entries ? getCurrentLocation().pathname : "/", to, state, key);
+    warning(location.pathname.charAt(0) === "/", "relative pathnames are not supported in memory history: " + JSON.stringify(to));
+    return location;
+  }
+  function createHref(to) {
+    return typeof to === "string" ? to : createPath(to);
+  }
+  let history = {
+    get index() {
+      return index;
+    },
+    get action() {
+      return action;
+    },
+    get location() {
+      return getCurrentLocation();
+    },
+    createHref,
+    createURL(to) {
+      return new URL(createHref(to), "http://localhost");
+    },
+    encodeLocation(to) {
+      let path = typeof to === "string" ? parsePath(to) : to;
+      return {
+        pathname: path.pathname || "",
+        search: path.search || "",
+        hash: path.hash || ""
+      };
+    },
+    push(to, state) {
+      action = Action.Push;
+      let nextLocation = createMemoryLocation(to, state);
+      index += 1;
+      entries.splice(index, entries.length, nextLocation);
+      if (v5Compat && listener) {
+        listener({
+          action,
+          location: nextLocation,
+          delta: 1
+        });
+      }
+    },
+    replace(to, state) {
+      action = Action.Replace;
+      let nextLocation = createMemoryLocation(to, state);
+      entries[index] = nextLocation;
+      if (v5Compat && listener) {
+        listener({
+          action,
+          location: nextLocation,
+          delta: 0
+        });
+      }
+    },
+    go(delta) {
+      action = Action.Pop;
+      let nextIndex = clampIndex(index + delta);
+      let nextLocation = entries[nextIndex];
+      index = nextIndex;
+      if (listener) {
+        listener({
+          action,
+          location: nextLocation,
+          delta
+        });
+      }
+    },
+    listen(fn) {
+      listener = fn;
+      return () => {
+        listener = null;
+      };
+    }
+  };
+  return history;
+}
+/**
+ * Browser history stores the location in regular URLs. This is the standard for
+ * most web apps, but it requires some configuration on the server to ensure you
+ * serve the same app at multiple URLs.
+ *
+ * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createbrowserhistory
+ */
+function createBrowserHistory(options) {
+  if (options === void 0) {
+    options = {};
+  }
+  function createBrowserLocation(window, globalHistory) {
+    let {
+      pathname,
+      search,
+      hash
+    } = window.location;
+    return createLocation("", {
+      pathname,
+      search,
+      hash
+    },
+    // state defaults to `null` because `window.history.state` does
+    globalHistory.state && globalHistory.state.usr || null, globalHistory.state && globalHistory.state.key || "default");
+  }
+  function createBrowserHref(window, to) {
+    return typeof to === "string" ? to : createPath(to);
+  }
+  return getUrlBasedHistory(createBrowserLocation, createBrowserHref, null, options);
+}
+/**
+ * Hash history stores the location in window.location.hash. This makes it ideal
+ * for situations where you don't want to send the location to the server for
+ * some reason, either because you do cannot configure it or the URL space is
+ * reserved for something else.
+ *
+ * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createhashhistory
+ */
+function createHashHistory(options) {
+  if (options === void 0) {
+    options = {};
+  }
+  function createHashLocation(window, globalHistory) {
+    let {
+      pathname = "/",
+      search = "",
+      hash = ""
+    } = parsePath(window.location.hash.substr(1));
+    // Hash URL should always have a leading / just like window.location.pathname
+    // does, so if an app ends up at a route like /#something then we add a
+    // leading slash so all of our path-matching behaves the same as if it would
+    // in a browser router.  This is particularly important when there exists a
+    // root splat route (<Route path="*">) since that matches internally against
+    // "/*" and we'd expect /#something to 404 in a hash router app.
+    if (!pathname.startsWith("/") && !pathname.startsWith(".")) {
+      pathname = "/" + pathname;
+    }
+    return createLocation("", {
+      pathname,
+      search,
+      hash
+    },
+    // state defaults to `null` because `window.history.state` does
+    globalHistory.state && globalHistory.state.usr || null, globalHistory.state && globalHistory.state.key || "default");
+  }
+  function createHashHref(window, to) {
+    let base = window.document.querySelector("base");
+    let href = "";
+    if (base && base.getAttribute("href")) {
+      let url = window.location.href;
+      let hashIndex = url.indexOf("#");
+      href = hashIndex === -1 ? url : url.slice(0, hashIndex);
+    }
+    return href + "#" + (typeof to === "string" ? to : createPath(to));
+  }
+  function validateHashLocation(location, to) {
+    warning(location.pathname.charAt(0) === "/", "relative pathnames are not supported in hash history.push(" + JSON.stringify(to) + ")");
+  }
+  return getUrlBasedHistory(createHashLocation, createHashHref, validateHashLocation, options);
+}
+function invariant(value, message) {
+  if (value === false || value === null || typeof value === "undefined") {
+    throw new Error(message);
+  }
+}
+function warning(cond, message) {
+  if (!cond) {
+    // eslint-disable-next-line no-console
+    if (typeof console !== "undefined") console.warn(message);
+    try {
+      // Welcome to debugging history!
+      //
+      // This error is thrown as a convenience, so you can more easily
+      // find the source for a warning that appears in the console by
+      // enabling "pause on exceptions" in your JavaScript debugger.
+      throw new Error(message);
+      // eslint-disable-next-line no-empty
+    } catch (e) {}
+  }
+}
+function createKey() {
+  return Math.random().toString(36).substr(2, 8);
+}
+/**
+ * For browser-based histories, we combine the state and key into an object
+ */
+function getHistoryState(location, index) {
+  return {
+    usr: location.state,
+    key: location.key,
+    idx: index
+  };
+}
+/**
+ * Creates a Location object with a unique key from the given Path
+ */
+function createLocation(current, to, state, key) {
+  if (state === void 0) {
+    state = null;
+  }
+  let location = _extends({
+    pathname: typeof current === "string" ? current : current.pathname,
+    search: "",
+    hash: ""
+  }, typeof to === "string" ? parsePath(to) : to, {
+    state,
+    // TODO: This could be cleaned up.  push/replace should probably just take
+    // full Locations now and avoid the need to run through this flow at all
+    // But that's a pretty big refactor to the current test suite so going to
+    // keep as is for the time being and just let any incoming keys take precedence
+    key: to && to.key || key || createKey()
+  });
+  return location;
+}
+/**
+ * Creates a string URL path from the given pathname, search, and hash components.
+ */
+function createPath(_ref) {
+  let {
+    pathname = "/",
+    search = "",
+    hash = ""
+  } = _ref;
+  if (search && search !== "?") pathname += search.charAt(0) === "?" ? search : "?" + search;
+  if (hash && hash !== "#") pathname += hash.charAt(0) === "#" ? hash : "#" + hash;
+  return pathname;
+}
+/**
+ * Parses a string URL path into its separate pathname, search, and hash components.
+ */
+function parsePath(path) {
+  let parsedPath = {};
+  if (path) {
+    let hashIndex = path.indexOf("#");
+    if (hashIndex >= 0) {
+      parsedPath.hash = path.substr(hashIndex);
+      path = path.substr(0, hashIndex);
+    }
+    let searchIndex = path.indexOf("?");
+    if (searchIndex >= 0) {
+      parsedPath.search = path.substr(searchIndex);
+      path = path.substr(0, searchIndex);
+    }
+    if (path) {
+      parsedPath.pathname = path;
+    }
+  }
+  return parsedPath;
+}
+function getUrlBasedHistory(getLocation, createHref, validateLocation, options) {
+  if (options === void 0) {
+    options = {};
+  }
+  let {
+    window = document.defaultView,
+    v5Compat = false
+  } = options;
+  let globalHistory = window.history;
+  let action = Action.Pop;
+  let listener = null;
+  let index = getIndex();
+  // Index should only be null when we initialize. If not, it's because the
+  // user called history.pushState or history.replaceState directly, in which
+  // case we should log a warning as it will result in bugs.
+  if (index == null) {
+    index = 0;
+    globalHistory.replaceState(_extends({}, globalHistory.state, {
+      idx: index
+    }), "");
+  }
+  function getIndex() {
+    let state = globalHistory.state || {
+      idx: null
+    };
+    return state.idx;
+  }
+  function handlePop() {
+    action = Action.Pop;
+    let nextIndex = getIndex();
+    let delta = nextIndex == null ? null : nextIndex - index;
+    index = nextIndex;
+    if (listener) {
+      listener({
+        action,
+        location: history.location,
+        delta
+      });
+    }
+  }
+  function push(to, state) {
+    action = Action.Push;
+    let location = createLocation(history.location, to, state);
+    if (validateLocation) validateLocation(location, to);
+    index = getIndex() + 1;
+    let historyState = getHistoryState(location, index);
+    let url = history.createHref(location);
+    // try...catch because iOS limits us to 100 pushState calls :/
+    try {
+      globalHistory.pushState(historyState, "", url);
+    } catch (error) {
+      // If the exception is because `state` can't be serialized, let that throw
+      // outwards just like a replace call would so the dev knows the cause
+      // https://html.spec.whatwg.org/multipage/nav-history-apis.html#shared-history-push/replace-state-steps
+      // https://html.spec.whatwg.org/multipage/structured-data.html#structuredserializeinternal
+      if (error instanceof DOMException && error.name === "DataCloneError") {
+        throw error;
+      }
+      // They are going to lose state here, but there is no real
+      // way to warn them about it since the page will refresh...
+      window.location.assign(url);
+    }
+    if (v5Compat && listener) {
+      listener({
+        action,
+        location: history.location,
+        delta: 1
+      });
+    }
+  }
+  function replace(to, state) {
+    action = Action.Replace;
+    let location = createLocation(history.location, to, state);
+    if (validateLocation) validateLocation(location, to);
+    index = getIndex();
+    let historyState = getHistoryState(location, index);
+    let url = history.createHref(location);
+    globalHistory.replaceState(historyState, "", url);
+    if (v5Compat && listener) {
+      listener({
+        action,
+        location: history.location,
+        delta: 0
+      });
+    }
+  }
+  function createURL(to) {
+    // window.location.origin is "null" (the literal string value) in Firefox
+    // under certain conditions, notably when serving from a local HTML file
+    // See https://bugzilla.mozilla.org/show_bug.cgi?id=878297
+    let base = window.location.origin !== "null" ? window.location.origin : window.location.href;
+    let href = typeof to === "string" ? to : createPath(to);
+    // Treating this as a full URL will strip any trailing spaces so we need to
+    // pre-encode them since they might be part of a matching splat param from
+    // an ancestor route
+    href = href.replace(/ $/, "%20");
+    invariant(base, "No window.location.(origin|href) available to create URL for href: " + href);
+    return new URL(href, base);
+  }
+  let history = {
+    get action() {
+      return action;
+    },
+    get location() {
+      return getLocation(window, globalHistory);
+    },
+    listen(fn) {
+      if (listener) {
+        throw new Error("A history only accepts one active listener");
+      }
+      window.addEventListener(PopStateEventType, handlePop);
+      listener = fn;
+      return () => {
+        window.removeEventListener(PopStateEventType, handlePop);
+        listener = null;
+      };
+    },
+    createHref(to) {
+      return createHref(window, to);
+    },
+    createURL,
+    encodeLocation(to) {
+      // Encode a Location the same way window.location would
+      let url = createURL(to);
+      return {
+        pathname: url.pathname,
+        search: url.search,
+        hash: url.hash
+      };
+    },
+    push,
+    replace,
+    go(n) {
+      return globalHistory.go(n);
+    }
+  };
+  return history;
+}
+//#endregion
+
+var ResultType;
+(function (ResultType) {
+  ResultType["data"] = "data";
+  ResultType["deferred"] = "deferred";
+  ResultType["redirect"] = "redirect";
+  ResultType["error"] = "error";
+})(ResultType || (ResultType = {}));
+const immutableRouteKeys = new Set(["lazy", "caseSensitive", "path", "id", "index", "children"]);
+function isIndexRoute(route) {
+  return route.index === true;
+}
+// Walk the route tree generating unique IDs where necessary, so we are working
+// solely with AgnosticDataRouteObject's within the Router
+function convertRoutesToDataRoutes(routes, mapRouteProperties, parentPath, manifest) {
+  if (parentPath === void 0) {
+    parentPath = [];
+  }
+  if (manifest === void 0) {
+    manifest = {};
+  }
+  return routes.map((route, index) => {
+    let treePath = [...parentPath, String(index)];
+    let id = typeof route.id === "string" ? route.id : treePath.join("-");
+    invariant(route.index !== true || !route.children, "Cannot specify children on an index route");
+    invariant(!manifest[id], "Found a route id collision on id \"" + id + "\".  Route " + "id's must be globally unique within Data Router usages");
+    if (isIndexRoute(route)) {
+      let indexRoute = _extends({}, route, mapRouteProperties(route), {
+        id
+      });
+      manifest[id] = indexRoute;
+      return indexRoute;
+    } else {
+      let pathOrLayoutRoute = _extends({}, route, mapRouteProperties(route), {
+        id,
+        children: undefined
+      });
+      manifest[id] = pathOrLayoutRoute;
+      if (route.children) {
+        pathOrLayoutRoute.children = convertRoutesToDataRoutes(route.children, mapRouteProperties, treePath, manifest);
+      }
+      return pathOrLayoutRoute;
+    }
+  });
+}
+/**
+ * Matches the given routes to a location and returns the match data.
+ *
+ * @see https://reactrouter.com/v6/utils/match-routes
+ */
+function matchRoutes(routes, locationArg, basename) {
+  if (basename === void 0) {
+    basename = "/";
+  }
+  return matchRoutesImpl(routes, locationArg, basename, false);
+}
+function matchRoutesImpl(routes, locationArg, basename, allowPartial) {
+  let location = typeof locationArg === "string" ? parsePath(locationArg) : locationArg;
+  let pathname = stripBasename(location.pathname || "/", basename);
+  if (pathname == null) {
+    return null;
+  }
+  let branches = flattenRoutes(routes);
+  rankRouteBranches(branches);
+  let matches = null;
+  for (let i = 0; matches == null && i < branches.length; ++i) {
+    // Incoming pathnames are generally encoded from either window.location
+    // or from router.navigate, but we want to match against the unencoded
+    // paths in the route definitions.  Memory router locations won't be
+    // encoded here but there also shouldn't be anything to decode so this
+    // should be a safe operation.  This avoids needing matchRoutes to be
+    // history-aware.
+    let decoded = decodePath(pathname);
+    matches = matchRouteBranch(branches[i], decoded, allowPartial);
+  }
+  return matches;
+}
+function convertRouteMatchToUiMatch(match, loaderData) {
+  let {
+    route,
+    pathname,
+    params
+  } = match;
+  return {
+    id: route.id,
+    pathname,
+    params,
+    data: loaderData[route.id],
+    handle: route.handle
+  };
+}
+function flattenRoutes(routes, branches, parentsMeta, parentPath) {
+  if (branches === void 0) {
+    branches = [];
+  }
+  if (parentsMeta === void 0) {
+    parentsMeta = [];
+  }
+  if (parentPath === void 0) {
+    parentPath = "";
+  }
+  let flattenRoute = (route, index, relativePath) => {
+    let meta = {
+      relativePath: relativePath === undefined ? route.path || "" : relativePath,
+      caseSensitive: route.caseSensitive === true,
+      childrenIndex: index,
+      route
+    };
+    if (meta.relativePath.startsWith("/")) {
+      invariant(meta.relativePath.startsWith(parentPath), "Absolute route path \"" + meta.relativePath + "\" nested under path " + ("\"" + parentPath + "\" is not valid. An absolute child route path ") + "must start with the combined path of all its parent routes.");
+      meta.relativePath = meta.relativePath.slice(parentPath.length);
+    }
+    let path = joinPaths([parentPath, meta.relativePath]);
+    let routesMeta = parentsMeta.concat(meta);
+    // Add the children before adding this route to the array, so we traverse the
+    // route tree depth-first and child routes appear before their parents in
+    // the "flattened" version.
+    if (route.children && route.children.length > 0) {
+      invariant(
+      // Our types know better, but runtime JS may not!
+      // @ts-expect-error
+      route.index !== true, "Index routes must not have child routes. Please remove " + ("all child routes from route path \"" + path + "\"."));
+      flattenRoutes(route.children, branches, routesMeta, path);
+    }
+    // Routes without a path shouldn't ever match by themselves unless they are
+    // index routes, so don't add them to the list of possible branches.
+    if (route.path == null && !route.index) {
+      return;
+    }
+    branches.push({
+      path,
+      score: computeScore(path, route.index),
+      routesMeta
+    });
+  };
+  routes.forEach((route, index) => {
+    var _route$path;
+    // coarse-grain check for optional params
+    if (route.path === "" || !((_route$path = route.path) != null && _route$path.includes("?"))) {
+      flattenRoute(route, index);
+    } else {
+      for (let exploded of explodeOptionalSegments(route.path)) {
+        flattenRoute(route, index, exploded);
+      }
+    }
+  });
+  return branches;
+}
+/**
+ * Computes all combinations of optional path segments for a given path,
+ * excluding combinations that are ambiguous and of lower priority.
+ *
+ * For example, `/one/:two?/three/:four?/:five?` explodes to:
+ * - `/one/three`
+ * - `/one/:two/three`
+ * - `/one/three/:four`
+ * - `/one/three/:five`
+ * - `/one/:two/three/:four`
+ * - `/one/:two/three/:five`
+ * - `/one/three/:four/:five`
+ * - `/one/:two/three/:four/:five`
+ */
+function explodeOptionalSegments(path) {
+  let segments = path.split("/");
+  if (segments.length === 0) return [];
+  let [first, ...rest] = segments;
+  // Optional path segments are denoted by a trailing `?`
+  let isOptional = first.endsWith("?");
+  // Compute the corresponding required segment: `foo?` -> `foo`
+  let required = first.replace(/\?$/, "");
+  if (rest.length === 0) {
+    // Intepret empty string as omitting an optional segment
+    // `["one", "", "three"]` corresponds to omitting `:two` from `/one/:two?/three` -> `/one/three`
+    return isOptional ? [required, ""] : [required];
+  }
+  let restExploded = explodeOptionalSegments(rest.join("/"));
+  let result = [];
+  // All child paths with the prefix.  Do this for all children before the
+  // optional version for all children, so we get consistent ordering where the
+  // parent optional aspect is preferred as required.  Otherwise, we can get
+  // child sections interspersed where deeper optional segments are higher than
+  // parent optional segments, where for example, /:two would explode _earlier_
+  // then /:one.  By always including the parent as required _for all children_
+  // first, we avoid this issue
+  result.push(...restExploded.map(subpath => subpath === "" ? required : [required, subpath].join("/")));
+  // Then, if this is an optional value, add all child versions without
+  if (isOptional) {
+    result.push(...restExploded);
+  }
+  // for absolute paths, ensure `/` instead of empty segment
+  return result.map(exploded => path.startsWith("/") && exploded === "" ? "/" : exploded);
+}
+function rankRouteBranches(branches) {
+  branches.sort((a, b) => a.score !== b.score ? b.score - a.score // Higher score first
+  : compareIndexes(a.routesMeta.map(meta => meta.childrenIndex), b.routesMeta.map(meta => meta.childrenIndex)));
+}
+const paramRe = /^:[\w-]+$/;
+const dynamicSegmentValue = 3;
+const indexRouteValue = 2;
+const emptySegmentValue = 1;
+const staticSegmentValue = 10;
+const splatPenalty = -2;
+const isSplat = s => s === "*";
+function computeScore(path, index) {
+  let segments = path.split("/");
+  let initialScore = segments.length;
+  if (segments.some(isSplat)) {
+    initialScore += splatPenalty;
+  }
+  if (index) {
+    initialScore += indexRouteValue;
+  }
+  return segments.filter(s => !isSplat(s)).reduce((score, segment) => score + (paramRe.test(segment) ? dynamicSegmentValue : segment === "" ? emptySegmentValue : staticSegmentValue), initialScore);
+}
+function compareIndexes(a, b) {
+  let siblings = a.length === b.length && a.slice(0, -1).every((n, i) => n === b[i]);
+  return siblings ?
+  // If two routes are siblings, we should try to match the earlier sibling
+  // first. This allows people to have fine-grained control over the matching
+  // behavior by simply putting routes with identical paths in the order they
+  // want them tried.
+  a[a.length - 1] - b[b.length - 1] :
+  // Otherwise, it doesn't really make sense to rank non-siblings by index,
+  // so they sort equally.
+  0;
+}
+function matchRouteBranch(branch, pathname, allowPartial) {
+  if (allowPartial === void 0) {
+    allowPartial = false;
+  }
+  let {
+    routesMeta
+  } = branch;
+  let matchedParams = {};
+  let matchedPathname = "/";
+  let matches = [];
+  for (let i = 0; i < routesMeta.length; ++i) {
+    let meta = routesMeta[i];
+    let end = i === routesMeta.length - 1;
+    let remainingPathname = matchedPathname === "/" ? pathname : pathname.slice(matchedPathname.length) || "/";
+    let match = matchPath({
+      path: meta.relativePath,
+      caseSensitive: meta.caseSensitive,
+      end
+    }, remainingPathname);
+    let route = meta.route;
+    if (!match && end && allowPartial && !routesMeta[routesMeta.length - 1].route.index) {
+      match = matchPath({
+        path: meta.relativePath,
+        caseSensitive: meta.caseSensitive,
+        end: false
+      }, remainingPathname);
+    }
+    if (!match) {
+      return null;
+    }
+    Object.assign(matchedParams, match.params);
+    matches.push({
+      // TODO: Can this as be avoided?
+      params: matchedParams,
+      pathname: joinPaths([matchedPathname, match.pathname]),
+      pathnameBase: normalizePathname(joinPaths([matchedPathname, match.pathnameBase])),
+      route
+    });
+    if (match.pathnameBase !== "/") {
+      matchedPathname = joinPaths([matchedPathname, match.pathnameBase]);
+    }
+  }
+  return matches;
+}
+/**
+ * Returns a path with params interpolated.
+ *
+ * @see https://reactrouter.com/v6/utils/generate-path
+ */
+function generatePath(originalPath, params) {
+  if (params === void 0) {
+    params = {};
+  }
+  let path = originalPath;
+  if (path.endsWith("*") && path !== "*" && !path.endsWith("/*")) {
+    warning(false, "Route path \"" + path + "\" will be treated as if it were " + ("\"" + path.replace(/\*$/, "/*") + "\" because the `*` character must ") + "always follow a `/` in the pattern. To get rid of this warning, " + ("please change the route path to \"" + path.replace(/\*$/, "/*") + "\"."));
+    path = path.replace(/\*$/, "/*");
+  }
+  // ensure `/` is added at the beginning if the path is absolute
+  const prefix = path.startsWith("/") ? "/" : "";
+  const stringify = p => p == null ? "" : typeof p === "string" ? p : String(p);
+  const segments = path.split(/\/+/).map((segment, index, array) => {
+    const isLastSegment = index === array.length - 1;
+    // only apply the splat if it's the last segment
+    if (isLastSegment && segment === "*") {
+      const star = "*";
+      // Apply the splat
+      return stringify(params[star]);
+    }
+    const keyMatch = segment.match(/^:([\w-]+)(\??)$/);
+    if (keyMatch) {
+      const [, key, optional] = keyMatch;
+      let param = params[key];
+      invariant(optional === "?" || param != null, "Missing \":" + key + "\" param");
+      return stringify(param);
+    }
+    // Remove any optional markers from optional static segments
+    return segment.replace(/\?$/g, "");
+  })
+  // Remove empty segments
+  .filter(segment => !!segment);
+  return prefix + segments.join("/");
+}
+/**
+ * Performs pattern matching on a URL pathname and returns information about
+ * the match.
+ *
+ * @see https://reactrouter.com/v6/utils/match-path
+ */
+function matchPath(pattern, pathname) {
+  if (typeof pattern === "string") {
+    pattern = {
+      path: pattern,
+      caseSensitive: false,
+      end: true
+    };
+  }
+  let [matcher, compiledParams] = compilePath(pattern.path, pattern.caseSensitive, pattern.end);
+  let match = pathname.match(matcher);
+  if (!match) return null;
+  let matchedPathname = match[0];
+  let pathnameBase = matchedPathname.replace(/(.)\/+$/, "$1");
+  let captureGroups = match.slice(1);
+  let params = compiledParams.reduce((memo, _ref, index) => {
+    let {
+      paramName,
+      isOptional
+    } = _ref;
+    // We need to compute the pathnameBase here using the raw splat value
+    // instead of using params["*"] later because it will be decoded then
+    if (paramName === "*") {
+      let splatValue = captureGroups[index] || "";
+      pathnameBase = matchedPathname.slice(0, matchedPathname.length - splatValue.length).replace(/(.)\/+$/, "$1");
+    }
+    const value = captureGroups[index];
+    if (isOptional && !value) {
+      memo[paramName] = undefined;
+    } else {
+      memo[paramName] = (value || "").replace(/%2F/g, "/");
+    }
+    return memo;
+  }, {});
+  return {
+    params,
+    pathname: matchedPathname,
+    pathnameBase,
+    pattern
+  };
+}
+function compilePath(path, caseSensitive, end) {
+  if (caseSensitive === void 0) {
+    caseSensitive = false;
+  }
+  if (end === void 0) {
+    end = true;
+  }
+  warning(path === "*" || !path.endsWith("*") || path.endsWith("/*"), "Route path \"" + path + "\" will be treated as if it were " + ("\"" + path.replace(/\*$/, "/*") + "\" because the `*` character must ") + "always follow a `/` in the pattern. To get rid of this warning, " + ("please change the route path to \"" + path.replace(/\*$/, "/*") + "\"."));
+  let params = [];
+  let regexpSource = "^" + path.replace(/\/*\*?$/, "") // Ignore trailing / and /*, we'll handle it below
+  .replace(/^\/*/, "/") // Make sure it has a leading /
+  .replace(/[\\.*+^${}|()[\]]/g, "\\$&") // Escape special regex chars
+  .replace(/\/:([\w-]+)(\?)?/g, (_, paramName, isOptional) => {
+    params.push({
+      paramName,
+      isOptional: isOptional != null
+    });
+    return isOptional ? "/?([^\\/]+)?" : "/([^\\/]+)";
+  });
+  if (path.endsWith("*")) {
+    params.push({
+      paramName: "*"
+    });
+    regexpSource += path === "*" || path === "/*" ? "(.*)$" // Already matched the initial /, just match the rest
+    : "(?:\\/(.+)|\\/*)$"; // Don't include the / in params["*"]
+  } else if (end) {
+    // When matching to the end, ignore trailing slashes
+    regexpSource += "\\/*$";
+  } else if (path !== "" && path !== "/") {
+    // If our path is non-empty and contains anything beyond an initial slash,
+    // then we have _some_ form of path in our regex, so we should expect to
+    // match only if we find the end of this path segment.  Look for an optional
+    // non-captured trailing slash (to match a portion of the URL) or the end
+    // of the path (if we've matched to the end).  We used to do this with a
+    // word boundary but that gives false positives on routes like
+    // /user-preferences since `-` counts as a word boundary.
+    regexpSource += "(?:(?=\\/|$))";
+  } else ;
+  let matcher = new RegExp(regexpSource, caseSensitive ? undefined : "i");
+  return [matcher, params];
+}
+function decodePath(value) {
+  try {
+    return value.split("/").map(v => decodeURIComponent(v).replace(/\//g, "%2F")).join("/");
+  } catch (error) {
+    warning(false, "The URL path \"" + value + "\" could not be decoded because it is is a " + "malformed URL segment. This is probably due to a bad percent " + ("encoding (" + error + ")."));
+    return value;
+  }
+}
+/**
+ * @private
+ */
+function stripBasename(pathname, basename) {
+  if (basename === "/") return pathname;
+  if (!pathname.toLowerCase().startsWith(basename.toLowerCase())) {
+    return null;
+  }
+  // We want to leave trailing slash behavior in the user's control, so if they
+  // specify a basename with a trailing slash, we should support it
+  let startIndex = basename.endsWith("/") ? basename.length - 1 : basename.length;
+  let nextChar = pathname.charAt(startIndex);
+  if (nextChar && nextChar !== "/") {
+    // pathname does not start with basename/
+    return null;
+  }
+  return pathname.slice(startIndex) || "/";
+}
+const ABSOLUTE_URL_REGEX$1 = /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i;
+const isAbsoluteUrl = url => ABSOLUTE_URL_REGEX$1.test(url);
+/**
+ * Returns a resolved path object relative to the given pathname.
+ *
+ * @see https://reactrouter.com/v6/utils/resolve-path
+ */
+function resolvePath(to, fromPathname) {
+  if (fromPathname === void 0) {
+    fromPathname = "/";
+  }
+  let {
+    pathname: toPathname,
+    search = "",
+    hash = ""
+  } = typeof to === "string" ? parsePath(to) : to;
+  let pathname;
+  if (toPathname) {
+    if (isAbsoluteUrl(toPathname)) {
+      pathname = toPathname;
+    } else {
+      if (toPathname.includes("//")) {
+        let oldPathname = toPathname;
+        toPathname = toPathname.replace(/\/\/+/g, "/");
+        warning(false, "Pathnames cannot have embedded double slashes - normalizing " + (oldPathname + " -> " + toPathname));
+      }
+      if (toPathname.startsWith("/")) {
+        pathname = resolvePathname(toPathname.substring(1), "/");
+      } else {
+        pathname = resolvePathname(toPathname, fromPathname);
+      }
+    }
+  } else {
+    pathname = fromPathname;
+  }
+  return {
+    pathname,
+    search: normalizeSearch(search),
+    hash: normalizeHash(hash)
+  };
+}
+function resolvePathname(relativePath, fromPathname) {
+  let segments = fromPathname.replace(/\/+$/, "").split("/");
+  let relativeSegments = relativePath.split("/");
+  relativeSegments.forEach(segment => {
+    if (segment === "..") {
+      // Keep the root "" segment so the pathname starts at /
+      if (segments.length > 1) segments.pop();
+    } else if (segment !== ".") {
+      segments.push(segment);
+    }
+  });
+  return segments.length > 1 ? segments.join("/") : "/";
+}
+function getInvalidPathError(char, field, dest, path) {
+  return "Cannot include a '" + char + "' character in a manually specified " + ("`to." + field + "` field [" + JSON.stringify(path) + "].  Please separate it out to the ") + ("`to." + dest + "` field. Alternatively you may provide the full path as ") + "a string in <Link to=\"...\"> and the router will parse it for you.";
+}
+/**
+ * @private
+ *
+ * When processing relative navigation we want to ignore ancestor routes that
+ * do not contribute to the path, such that index/pathless layout routes don't
+ * interfere.
+ *
+ * For example, when moving a route element into an index route and/or a
+ * pathless layout route, relative link behavior contained within should stay
+ * the same.  Both of the following examples should link back to the root:
+ *
+ *   <Route path="/">
+ *     <Route path="accounts" element={<Link to=".."}>
+ *   </Route>
+ *
+ *   <Route path="/">
+ *     <Route path="accounts">
+ *       <Route element={<AccountsLayout />}>       // <-- Does not contribute
+ *         <Route index element={<Link to=".."} />  // <-- Does not contribute
+ *       </Route
+ *     </Route>
+ *   </Route>
+ */
+function getPathContributingMatches(matches) {
+  return matches.filter((match, index) => index === 0 || match.route.path && match.route.path.length > 0);
+}
+// Return the array of pathnames for the current route matches - used to
+// generate the routePathnames input for resolveTo()
+function getResolveToMatches(matches, v7_relativeSplatPath) {
+  let pathMatches = getPathContributingMatches(matches);
+  // When v7_relativeSplatPath is enabled, use the full pathname for the leaf
+  // match so we include splat values for "." links.  See:
+  // https://github.com/remix-run/react-router/issues/11052#issuecomment-1836589329
+  if (v7_relativeSplatPath) {
+    return pathMatches.map((match, idx) => idx === pathMatches.length - 1 ? match.pathname : match.pathnameBase);
+  }
+  return pathMatches.map(match => match.pathnameBase);
+}
+/**
+ * @private
+ */
+function resolveTo(toArg, routePathnames, locationPathname, isPathRelative) {
+  if (isPathRelative === void 0) {
+    isPathRelative = false;
+  }
+  let to;
+  if (typeof toArg === "string") {
+    to = parsePath(toArg);
+  } else {
+    to = _extends({}, toArg);
+    invariant(!to.pathname || !to.pathname.includes("?"), getInvalidPathError("?", "pathname", "search", to));
+    invariant(!to.pathname || !to.pathname.includes("#"), getInvalidPathError("#", "pathname", "hash", to));
+    invariant(!to.search || !to.search.includes("#"), getInvalidPathError("#", "search", "hash", to));
+  }
+  let isEmptyPath = toArg === "" || to.pathname === "";
+  let toPathname = isEmptyPath ? "/" : to.pathname;
+  let from;
+  // Routing is relative to the current pathname if explicitly requested.
+  //
+  // If a pathname is explicitly provided in `to`, it should be relative to the
+  // route context. This is explained in `Note on `<Link to>` values` in our
+  // migration guide from v5 as a means of disambiguation between `to` values
+  // that begin with `/` and those that do not. However, this is problematic for
+  // `to` values that do not provide a pathname. `to` can simply be a search or
+  // hash string, in which case we should assume that the navigation is relative
+  // to the current location's pathname and *not* the route pathname.
+  if (toPathname == null) {
+    from = locationPathname;
+  } else {
+    let routePathnameIndex = routePathnames.length - 1;
+    // With relative="route" (the default), each leading .. segment means
+    // "go up one route" instead of "go up one URL segment".  This is a key
+    // difference from how <a href> works and a major reason we call this a
+    // "to" value instead of a "href".
+    if (!isPathRelative && toPathname.startsWith("..")) {
+      let toSegments = toPathname.split("/");
+      while (toSegments[0] === "..") {
+        toSegments.shift();
+        routePathnameIndex -= 1;
+      }
+      to.pathname = toSegments.join("/");
+    }
+    from = routePathnameIndex >= 0 ? routePathnames[routePathnameIndex] : "/";
+  }
+  let path = resolvePath(to, from);
+  // Ensure the pathname has a trailing slash if the original "to" had one
+  let hasExplicitTrailingSlash = toPathname && toPathname !== "/" && toPathname.endsWith("/");
+  // Or if this was a link to the current path which has a trailing slash
+  let hasCurrentTrailingSlash = (isEmptyPath || toPathname === ".") && locationPathname.endsWith("/");
+  if (!path.pathname.endsWith("/") && (hasExplicitTrailingSlash || hasCurrentTrailingSlash)) {
+    path.pathname += "/";
+  }
+  return path;
+}
+/**
+ * @private
+ */
+function getToPathname(to) {
+  // Empty strings should be treated the same as / paths
+  return to === "" || to.pathname === "" ? "/" : typeof to === "string" ? parsePath(to).pathname : to.pathname;
+}
+/**
+ * @private
+ */
+const joinPaths = paths => paths.join("/").replace(/\/\/+/g, "/");
+/**
+ * @private
+ */
+const normalizePathname = pathname => pathname.replace(/\/+$/, "").replace(/^\/*/, "/");
+/**
+ * @private
+ */
+const normalizeSearch = search => !search || search === "?" ? "" : search.startsWith("?") ? search : "?" + search;
+/**
+ * @private
+ */
+const normalizeHash = hash => !hash || hash === "#" ? "" : hash.startsWith("#") ? hash : "#" + hash;
+/**
+ * This is a shortcut for creating `application/json` responses. Converts `data`
+ * to JSON and sets the `Content-Type` header.
+ *
+ * @deprecated The `json` method is deprecated in favor of returning raw objects.
+ * This method will be removed in v7.
+ */
+const json = function json(data, init) {
+  if (init === void 0) {
+    init = {};
+  }
+  let responseInit = typeof init === "number" ? {
+    status: init
+  } : init;
+  let headers = new Headers(responseInit.headers);
+  if (!headers.has("Content-Type")) {
+    headers.set("Content-Type", "application/json; charset=utf-8");
+  }
+  return new Response(JSON.stringify(data), _extends({}, responseInit, {
+    headers
+  }));
+};
+class DataWithResponseInit {
+  constructor(data, init) {
+    this.type = "DataWithResponseInit";
+    this.data = data;
+    this.init = init || null;
+  }
+}
+/**
+ * Create "responses" that contain `status`/`headers` without forcing
+ * serialization into an actual `Response` - used by Remix single fetch
+ */
+function data(data, init) {
+  return new DataWithResponseInit(data, typeof init === "number" ? {
+    status: init
+  } : init);
+}
+class AbortedDeferredError extends Error {}
+class DeferredData {
+  constructor(data, responseInit) {
+    this.pendingKeysSet = new Set();
+    this.subscribers = new Set();
+    this.deferredKeys = [];
+    invariant(data && typeof data === "object" && !Array.isArray(data), "defer() only accepts plain objects");
+    // Set up an AbortController + Promise we can race against to exit early
+    // cancellation
+    let reject;
+    this.abortPromise = new Promise((_, r) => reject = r);
+    this.controller = new AbortController();
+    let onAbort = () => reject(new AbortedDeferredError("Deferred data aborted"));
+    this.unlistenAbortSignal = () => this.controller.signal.removeEventListener("abort", onAbort);
+    this.controller.signal.addEventListener("abort", onAbort);
+    this.data = Object.entries(data).reduce((acc, _ref2) => {
+      let [key, value] = _ref2;
+      return Object.assign(acc, {
+        [key]: this.trackPromise(key, value)
+      });
+    }, {});
+    if (this.done) {
+      // All incoming values were resolved
+      this.unlistenAbortSignal();
+    }
+    this.init = responseInit;
+  }
+  trackPromise(key, value) {
+    if (!(value instanceof Promise)) {
+      return value;
+    }
+    this.deferredKeys.push(key);
+    this.pendingKeysSet.add(key);
+    // We store a little wrapper promise that will be extended with
+    // _data/_error props upon resolve/reject
+    let promise = Promise.race([value, this.abortPromise]).then(data => this.onSettle(promise, key, undefined, data), error => this.onSettle(promise, key, error));
+    // Register rejection listeners to avoid uncaught promise rejections on
+    // errors or aborted deferred values
+    promise.catch(() => {});
+    Object.defineProperty(promise, "_tracked", {
+      get: () => true
+    });
+    return promise;
+  }
+  onSettle(promise, key, error, data) {
+    if (this.controller.signal.aborted && error instanceof AbortedDeferredError) {
+      this.unlistenAbortSignal();
+      Object.defineProperty(promise, "_error", {
+        get: () => error
+      });
+      return Promise.reject(error);
+    }
+    this.pendingKeysSet.delete(key);
+    if (this.done) {
+      // Nothing left to abort!
+      this.unlistenAbortSignal();
+    }
+    // If the promise was resolved/rejected with undefined, we'll throw an error as you
+    // should always resolve with a value or null
+    if (error === undefined && data === undefined) {
+      let undefinedError = new Error("Deferred data for key \"" + key + "\" resolved/rejected with `undefined`, " + "you must resolve/reject with a value or `null`.");
+      Object.defineProperty(promise, "_error", {
+        get: () => undefinedError
+      });
+      this.emit(false, key);
+      return Promise.reject(undefinedError);
+    }
+    if (data === undefined) {
+      Object.defineProperty(promise, "_error", {
+        get: () => error
+      });
+      this.emit(false, key);
+      return Promise.reject(error);
+    }
+    Object.defineProperty(promise, "_data", {
+      get: () => data
+    });
+    this.emit(false, key);
+    return data;
+  }
+  emit(aborted, settledKey) {
+    this.subscribers.forEach(subscriber => subscriber(aborted, settledKey));
+  }
+  subscribe(fn) {
+    this.subscribers.add(fn);
+    return () => this.subscribers.delete(fn);
+  }
+  cancel() {
+    this.controller.abort();
+    this.pendingKeysSet.forEach((v, k) => this.pendingKeysSet.delete(k));
+    this.emit(true);
+  }
+  async resolveData(signal) {
+    let aborted = false;
+    if (!this.done) {
+      let onAbort = () => this.cancel();
+      signal.addEventListener("abort", onAbort);
+      aborted = await new Promise(resolve => {
+        this.subscribe(aborted => {
+          signal.removeEventListener("abort", onAbort);
+          if (aborted || this.done) {
+            resolve(aborted);
+          }
+        });
+      });
+    }
+    return aborted;
+  }
+  get done() {
+    return this.pendingKeysSet.size === 0;
+  }
+  get unwrappedData() {
+    invariant(this.data !== null && this.done, "Can only unwrap data on initialized and settled deferreds");
+    return Object.entries(this.data).reduce((acc, _ref3) => {
+      let [key, value] = _ref3;
+      return Object.assign(acc, {
+        [key]: unwrapTrackedPromise(value)
+      });
+    }, {});
+  }
+  get pendingKeys() {
+    return Array.from(this.pendingKeysSet);
+  }
+}
+function isTrackedPromise(value) {
+  return value instanceof Promise && value._tracked === true;
+}
+function unwrapTrackedPromise(value) {
+  if (!isTrackedPromise(value)) {
+    return value;
+  }
+  if (value._error) {
+    throw value._error;
+  }
+  return value._data;
+}
+/**
+ * @deprecated The `defer` method is deprecated in favor of returning raw
+ * objects. This method will be removed in v7.
+ */
+const defer = function defer(data, init) {
+  if (init === void 0) {
+    init = {};
+  }
+  let responseInit = typeof init === "number" ? {
+    status: init
+  } : init;
+  return new DeferredData(data, responseInit);
+};
+/**
+ * A redirect response. Sets the status code and the `Location` header.
+ * Defaults to "302 Found".
+ */
+const redirect = function redirect(url, init) {
+  if (init === void 0) {
+    init = 302;
+  }
+  let responseInit = init;
+  if (typeof responseInit === "number") {
+    responseInit = {
+      status: responseInit
+    };
+  } else if (typeof responseInit.status === "undefined") {
+    responseInit.status = 302;
+  }
+  let headers = new Headers(responseInit.headers);
+  headers.set("Location", url);
+  return new Response(null, _extends({}, responseInit, {
+    headers
+  }));
+};
+/**
+ * A redirect response that will force a document reload to the new location.
+ * Sets the status code and the `Location` header.
+ * Defaults to "302 Found".
+ */
+const redirectDocument = (url, init) => {
+  let response = redirect(url, init);
+  response.headers.set("X-Remix-Reload-Document", "true");
+  return response;
+};
+/**
+ * A redirect response that will perform a `history.replaceState` instead of a
+ * `history.pushState` for client-side navigation redirects.
+ * Sets the status code and the `Location` header.
+ * Defaults to "302 Found".
+ */
+const replace = (url, init) => {
+  let response = redirect(url, init);
+  response.headers.set("X-Remix-Replace", "true");
+  return response;
+};
+/**
+ * @private
+ * Utility class we use to hold auto-unwrapped 4xx/5xx Response bodies
+ *
+ * We don't export the class for public use since it's an implementation
+ * detail, but we export the interface above so folks can build their own
+ * abstractions around instances via isRouteErrorResponse()
+ */
+class ErrorResponseImpl {
+  constructor(status, statusText, data, internal) {
+    if (internal === void 0) {
+      internal = false;
+    }
+    this.status = status;
+    this.statusText = statusText || "";
+    this.internal = internal;
+    if (data instanceof Error) {
+      this.data = data.toString();
+      this.error = data;
+    } else {
+      this.data = data;
+    }
+  }
+}
+/**
+ * Check if the given error is an ErrorResponse generated from a 4xx/5xx
+ * Response thrown from an action/loader
+ */
+function isRouteErrorResponse(error) {
+  return error != null && typeof error.status === "number" && typeof error.statusText === "string" && typeof error.internal === "boolean" && "data" in error;
+}
+
+const validMutationMethodsArr = ["post", "put", "patch", "delete"];
+const validMutationMethods = new Set(validMutationMethodsArr);
+const validRequestMethodsArr = ["get", ...validMutationMethodsArr];
+const validRequestMethods = new Set(validRequestMethodsArr);
+const redirectStatusCodes = new Set([301, 302, 303, 307, 308]);
+const redirectPreserveMethodStatusCodes = new Set([307, 308]);
+const IDLE_NAVIGATION = {
+  state: "idle",
+  location: undefined,
+  formMethod: undefined,
+  formAction: undefined,
+  formEncType: undefined,
+  formData: undefined,
+  json: undefined,
+  text: undefined
+};
+const IDLE_FETCHER = {
+  state: "idle",
+  data: undefined,
+  formMethod: undefined,
+  formAction: undefined,
+  formEncType: undefined,
+  formData: undefined,
+  json: undefined,
+  text: undefined
+};
+const IDLE_BLOCKER = {
+  state: "unblocked",
+  proceed: undefined,
+  reset: undefined,
+  location: undefined
+};
+const ABSOLUTE_URL_REGEX = /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i;
+const defaultMapRouteProperties = route => ({
+  hasErrorBoundary: Boolean(route.hasErrorBoundary)
+});
+const TRANSITIONS_STORAGE_KEY = "remix-router-transitions";
+//#endregion
+////////////////////////////////////////////////////////////////////////////////
+//#region createRouter
+////////////////////////////////////////////////////////////////////////////////
+/**
+ * Create a router and listen to history POP navigations
+ */
+function createRouter(init) {
+  const routerWindow = init.window ? init.window : typeof window !== "undefined" ? window : undefined;
+  const isBrowser = typeof routerWindow !== "undefined" && typeof routerWindow.document !== "undefined" && typeof routerWindow.document.createElement !== "undefined";
+  const isServer = !isBrowser;
+  invariant(init.routes.length > 0, "You must provide a non-empty routes array to createRouter");
+  let mapRouteProperties;
+  if (init.mapRouteProperties) {
+    mapRouteProperties = init.mapRouteProperties;
+  } else if (init.detectErrorBoundary) {
+    // If they are still using the deprecated version, wrap it with the new API
+    let detectErrorBoundary = init.detectErrorBoundary;
+    mapRouteProperties = route => ({
+      hasErrorBoundary: detectErrorBoundary(route)
+    });
+  } else {
+    mapRouteProperties = defaultMapRouteProperties;
+  }
+  // Routes keyed by ID
+  let manifest = {};
+  // Routes in tree format for matching
+  let dataRoutes = convertRoutesToDataRoutes(init.routes, mapRouteProperties, undefined, manifest);
+  let inFlightDataRoutes;
+  let basename = init.basename || "/";
+  let dataStrategyImpl = init.dataStrategy || defaultDataStrategy;
+  let patchRoutesOnNavigationImpl = init.patchRoutesOnNavigation;
+  // Config driven behavior flags
+  let future = _extends({
+    v7_fetcherPersist: false,
+    v7_normalizeFormMethod: false,
+    v7_partialHydration: false,
+    v7_prependBasename: false,
+    v7_relativeSplatPath: false,
+    v7_skipActionErrorRevalidation: false
+  }, init.future);
+  // Cleanup function for history
+  let unlistenHistory = null;
+  // Externally-provided functions to call on all state changes
+  let subscribers = new Set();
+  // Externally-provided object to hold scroll restoration locations during routing
+  let savedScrollPositions = null;
+  // Externally-provided function to get scroll restoration keys
+  let getScrollRestorationKey = null;
+  // Externally-provided function to get current scroll position
+  let getScrollPosition = null;
+  // One-time flag to control the initial hydration scroll restoration.  Because
+  // we don't get the saved positions from <ScrollRestoration /> until _after_
+  // the initial render, we need to manually trigger a separate updateState to
+  // send along the restoreScrollPosition
+  // Set to true if we have `hydrationData` since we assume we were SSR'd and that
+  // SSR did the initial scroll restoration.
+  let initialScrollRestored = init.hydrationData != null;
+  let initialMatches = matchRoutes(dataRoutes, init.history.location, basename);
+  let initialMatchesIsFOW = false;
+  let initialErrors = null;
+  if (initialMatches == null && !patchRoutesOnNavigationImpl) {
+    // If we do not match a user-provided-route, fall back to the root
+    // to allow the error boundary to take over
+    let error = getInternalRouterError(404, {
+      pathname: init.history.location.pathname
+    });
+    let {
+      matches,
+      route
+    } = getShortCircuitMatches(dataRoutes);
+    initialMatches = matches;
+    initialErrors = {
+      [route.id]: error
+    };
+  }
+  // In SPA apps, if the user provided a patchRoutesOnNavigation implementation and
+  // our initial match is a splat route, clear them out so we run through lazy
+  // discovery on hydration in case there's a more accurate lazy route match.
+  // In SSR apps (with `hydrationData`), we expect that the server will send
+  // up the proper matched routes so we don't want to run lazy discovery on
+  // initial hydration and want to hydrate into the splat route.
+  if (initialMatches && !init.hydrationData) {
+    let fogOfWar = checkFogOfWar(initialMatches, dataRoutes, init.history.location.pathname);
+    if (fogOfWar.active) {
+      initialMatches = null;
+    }
+  }
+  let initialized;
+  if (!initialMatches) {
+    initialized = false;
+    initialMatches = [];
+    // If partial hydration and fog of war is enabled, we will be running
+    // `patchRoutesOnNavigation` during hydration so include any partial matches as
+    // the initial matches so we can properly render `HydrateFallback`'s
+    if (future.v7_partialHydration) {
+      let fogOfWar = checkFogOfWar(null, dataRoutes, init.history.location.pathname);
+      if (fogOfWar.active && fogOfWar.matches) {
+        initialMatchesIsFOW = true;
+        initialMatches = fogOfWar.matches;
+      }
+    }
+  } else if (initialMatches.some(m => m.route.lazy)) {
+    // All initialMatches need to be loaded before we're ready.  If we have lazy
+    // functions around still then we'll need to run them in initialize()
+    initialized = false;
+  } else if (!initialMatches.some(m => m.route.loader)) {
+    // If we've got no loaders to run, then we're good to go
+    initialized = true;
+  } else if (future.v7_partialHydration) {
+    // If partial hydration is enabled, we're initialized so long as we were
+    // provided with hydrationData for every route with a loader, and no loaders
+    // were marked for explicit hydration
+    let loaderData = init.hydrationData ? init.hydrationData.loaderData : null;
+    let errors = init.hydrationData ? init.hydrationData.errors : null;
+    // If errors exist, don't consider routes below the boundary
+    if (errors) {
+      let idx = initialMatches.findIndex(m => errors[m.route.id] !== undefined);
+      initialized = initialMatches.slice(0, idx + 1).every(m => !shouldLoadRouteOnHydration(m.route, loaderData, errors));
+    } else {
+      initialized = initialMatches.every(m => !shouldLoadRouteOnHydration(m.route, loaderData, errors));
+    }
+  } else {
+    // Without partial hydration - we're initialized if we were provided any
+    // hydrationData - which is expected to be complete
+    initialized = init.hydrationData != null;
+  }
+  let router;
+  let state = {
+    historyAction: init.history.action,
+    location: init.history.location,
+    matches: initialMatches,
+    initialized,
+    navigation: IDLE_NAVIGATION,
+    // Don't restore on initial updateState() if we were SSR'd
+    restoreScrollPosition: init.hydrationData != null ? false : null,
+    preventScrollReset: false,
+    revalidation: "idle",
+    loaderData: init.hydrationData && init.hydrationData.loaderData || {},
+    actionData: init.hydrationData && init.hydrationData.actionData || null,
+    errors: init.hydrationData && init.hydrationData.errors || initialErrors,
+    fetchers: new Map(),
+    blockers: new Map()
+  };
+  // -- Stateful internal variables to manage navigations --
+  // Current navigation in progress (to be committed in completeNavigation)
+  let pendingAction = Action.Pop;
+  // Should the current navigation prevent the scroll reset if scroll cannot
+  // be restored?
+  let pendingPreventScrollReset = false;
+  // AbortController for the active navigation
+  let pendingNavigationController;
+  // Should the current navigation enable document.startViewTransition?
+  let pendingViewTransitionEnabled = false;
+  // Store applied view transitions so we can apply them on POP
+  let appliedViewTransitions = new Map();
+  // Cleanup function for persisting applied transitions to sessionStorage
+  let removePageHideEventListener = null;
+  // We use this to avoid touching history in completeNavigation if a
+  // revalidation is entirely uninterrupted
+  let isUninterruptedRevalidation = false;
+  // Use this internal flag to force revalidation of all loaders:
+  //  - submissions (completed or interrupted)
+  //  - useRevalidator()
+  //  - X-Remix-Revalidate (from redirect)
+  let isRevalidationRequired = false;
+  // Use this internal array to capture routes that require revalidation due
+  // to a cancelled deferred on action submission
+  let cancelledDeferredRoutes = [];
+  // Use this internal array to capture fetcher loads that were cancelled by an
+  // action navigation and require revalidation
+  let cancelledFetcherLoads = new Set();
+  // AbortControllers for any in-flight fetchers
+  let fetchControllers = new Map();
+  // Track loads based on the order in which they started
+  let incrementingLoadId = 0;
+  // Track the outstanding pending navigation data load to be compared against
+  // the globally incrementing load when a fetcher load lands after a completed
+  // navigation
+  let pendingNavigationLoadId = -1;
+  // Fetchers that triggered data reloads as a result of their actions
+  let fetchReloadIds = new Map();
+  // Fetchers that triggered redirect navigations
+  let fetchRedirectIds = new Set();
+  // Most recent href/match for fetcher.load calls for fetchers
+  let fetchLoadMatches = new Map();
+  // Ref-count mounted fetchers so we know when it's ok to clean them up
+  let activeFetchers = new Map();
+  // Fetchers that have requested a delete when using v7_fetcherPersist,
+  // they'll be officially removed after they return to idle
+  let deletedFetchers = new Set();
+  // Store DeferredData instances for active route matches.  When a
+  // route loader returns defer() we stick one in here.  Then, when a nested
+  // promise resolves we update loaderData.  If a new navigation starts we
+  // cancel active deferreds for eliminated routes.
+  let activeDeferreds = new Map();
+  // Store blocker functions in a separate Map outside of router state since
+  // we don't need to update UI state if they change
+  let blockerFunctions = new Map();
+  // Flag to ignore the next history update, so we can revert the URL change on
+  // a POP navigation that was blocked by the user without touching router state
+  let unblockBlockerHistoryUpdate = undefined;
+  // Initialize the router, all side effects should be kicked off from here.
+  // Implemented as a Fluent API for ease of:
+  //   let router = createRouter(init).initialize();
+  function initialize() {
+    // If history informs us of a POP navigation, start the navigation but do not update
+    // state.  We'll update our own state once the navigation completes
+    unlistenHistory = init.history.listen(_ref => {
+      let {
+        action: historyAction,
+        location,
+        delta
+      } = _ref;
+      // Ignore this event if it was just us resetting the URL from a
+      // blocked POP navigation
+      if (unblockBlockerHistoryUpdate) {
+        unblockBlockerHistoryUpdate();
+        unblockBlockerHistoryUpdate = undefined;
+        return;
+      }
+      warning(blockerFunctions.size === 0 || delta != null, "You are trying to use a blocker on a POP navigation to a location " + "that was not created by @remix-run/router. This will fail silently in " + "production. This can happen if you are navigating outside the router " + "via `window.history.pushState`/`window.location.hash` instead of using " + "router navigation APIs.  This can also happen if you are using " + "createHashRouter and the user manually changes the URL.");
+      let blockerKey = shouldBlockNavigation({
+        currentLocation: state.location,
+        nextLocation: location,
+        historyAction
+      });
+      if (blockerKey && delta != null) {
+        // Restore the URL to match the current UI, but don't update router state
+        let nextHistoryUpdatePromise = new Promise(resolve => {
+          unblockBlockerHistoryUpdate = resolve;
+        });
+        init.history.go(delta * -1);
+        // Put the blocker into a blocked state
+        updateBlocker(blockerKey, {
+          state: "blocked",
+          location,
+          proceed() {
+            updateBlocker(blockerKey, {
+              state: "proceeding",
+              proceed: undefined,
+              reset: undefined,
+              location
+            });
+            // Re-do the same POP navigation we just blocked, after the url
+            // restoration is also complete.  See:
+            // https://github.com/remix-run/react-router/issues/11613
+            nextHistoryUpdatePromise.then(() => init.history.go(delta));
+          },
+          reset() {
+            let blockers = new Map(state.blockers);
+            blockers.set(blockerKey, IDLE_BLOCKER);
+            updateState({
+              blockers
+            });
+          }
+        });
+        return;
+      }
+      return startNavigation(historyAction, location);
+    });
+    if (isBrowser) {
+      // FIXME: This feels gross.  How can we cleanup the lines between
+      // scrollRestoration/appliedTransitions persistance?
+      restoreAppliedTransitions(routerWindow, appliedViewTransitions);
+      let _saveAppliedTransitions = () => persistAppliedTransitions(routerWindow, appliedViewTransitions);
+      routerWindow.addEventListener("pagehide", _saveAppliedTransitions);
+      removePageHideEventListener = () => routerWindow.removeEventListener("pagehide", _saveAppliedTransitions);
+    }
+    // Kick off initial data load if needed.  Use Pop to avoid modifying history
+    // Note we don't do any handling of lazy here.  For SPA's it'll get handled
+    // in the normal navigation flow.  For SSR it's expected that lazy modules are
+    // resolved prior to router creation since we can't go into a fallbackElement
+    // UI for SSR'd apps
+    if (!state.initialized) {
+      startNavigation(Action.Pop, state.location, {
+        initialHydration: true
+      });
+    }
+    return router;
+  }
+  // Clean up a router and it's side effects
+  function dispose() {
+    if (unlistenHistory) {
+      unlistenHistory();
+    }
+    if (removePageHideEventListener) {
+      removePageHideEventListener();
+    }
+    subscribers.clear();
+    pendingNavigationController && pendingNavigationController.abort();
+    state.fetchers.forEach((_, key) => deleteFetcher(key));
+    state.blockers.forEach((_, key) => deleteBlocker(key));
+  }
+  // Subscribe to state updates for the router
+  function subscribe(fn) {
+    subscribers.add(fn);
+    return () => subscribers.delete(fn);
+  }
+  // Update our state and notify the calling context of the change
+  function updateState(newState, opts) {
+    if (opts === void 0) {
+      opts = {};
+    }
+    state = _extends({}, state, newState);
+    // Prep fetcher cleanup so we can tell the UI which fetcher data entries
+    // can be removed
+    let completedFetchers = [];
+    let deletedFetchersKeys = [];
+    if (future.v7_fetcherPersist) {
+      state.fetchers.forEach((fetcher, key) => {
+        if (fetcher.state === "idle") {
+          if (deletedFetchers.has(key)) {
+            // Unmounted from the UI and can be totally removed
+            deletedFetchersKeys.push(key);
+          } else {
+            // Returned to idle but still mounted in the UI, so semi-remains for
+            // revalidations and such
+            completedFetchers.push(key);
+          }
+        }
+      });
+    }
+    // Remove any lingering deleted fetchers that have already been removed
+    // from state.fetchers
+    deletedFetchers.forEach(key => {
+      if (!state.fetchers.has(key) && !fetchControllers.has(key)) {
+        deletedFetchersKeys.push(key);
+      }
+    });
+    // Iterate over a local copy so that if flushSync is used and we end up
+    // removing and adding a new subscriber due to the useCallback dependencies,
+    // we don't get ourselves into a loop calling the new subscriber immediately
+    [...subscribers].forEach(subscriber => subscriber(state, {
+      deletedFetchers: deletedFetchersKeys,
+      viewTransitionOpts: opts.viewTransitionOpts,
+      flushSync: opts.flushSync === true
+    }));
+    // Remove idle fetchers from state since we only care about in-flight fetchers.
+    if (future.v7_fetcherPersist) {
+      completedFetchers.forEach(key => state.fetchers.delete(key));
+      deletedFetchersKeys.forEach(key => deleteFetcher(key));
+    } else {
+      // We already called deleteFetcher() on these, can remove them from this
+      // Set now that we've handed the keys off to the data layer
+      deletedFetchersKeys.forEach(key => deletedFetchers.delete(key));
+    }
+  }
+  // Complete a navigation returning the state.navigation back to the IDLE_NAVIGATION
+  // and setting state.[historyAction/location/matches] to the new route.
+  // - Location is a required param
+  // - Navigation will always be set to IDLE_NAVIGATION
+  // - Can pass any other state in newState
+  function completeNavigation(location, newState, _temp) {
+    var _location$state, _location$state2;
+    let {
+      flushSync
+    } = _temp === void 0 ? {} : _temp;
+    // Deduce if we're in a loading/actionReload state:
+    // - We have committed actionData in the store
+    // - The current navigation was a mutation submission
+    // - We're past the submitting state and into the loading state
+    // - The location being loaded is not the result of a redirect
+    let isActionReload = state.actionData != null && state.navigation.formMethod != null && isMutationMethod(state.navigation.formMethod) && state.navigation.state === "loading" && ((_location$state = location.state) == null ? void 0 : _location$state._isRedirect) !== true;
+    let actionData;
+    if (newState.actionData) {
+      if (Object.keys(newState.actionData).length > 0) {
+        actionData = newState.actionData;
+      } else {
+        // Empty actionData -> clear prior actionData due to an action error
+        actionData = null;
+      }
+    } else if (isActionReload) {
+      // Keep the current data if we're wrapping up the action reload
+      actionData = state.actionData;
+    } else {
+      // Clear actionData on any other completed navigations
+      actionData = null;
+    }
+    // Always preserve any existing loaderData from re-used routes
+    let loaderData = newState.loaderData ? mergeLoaderData(state.loaderData, newState.loaderData, newState.matches || [], newState.errors) : state.loaderData;
+    // On a successful navigation we can assume we got through all blockers
+    // so we can start fresh
+    let blockers = state.blockers;
+    if (blockers.size > 0) {
+      blockers = new Map(blockers);
+      blockers.forEach((_, k) => blockers.set(k, IDLE_BLOCKER));
+    }
+    // Always respect the user flag.  Otherwise don't reset on mutation
+    // submission navigations unless they redirect
+    let preventScrollReset = pendingPreventScrollReset === true || state.navigation.formMethod != null && isMutationMethod(state.navigation.formMethod) && ((_location$state2 = location.state) == null ? void 0 : _location$state2._isRedirect) !== true;
+    // Commit any in-flight routes at the end of the HMR revalidation "navigation"
+    if (inFlightDataRoutes) {
+      dataRoutes = inFlightDataRoutes;
+      inFlightDataRoutes = undefined;
+    }
+    if (isUninterruptedRevalidation) ; else if (pendingAction === Action.Pop) ; else if (pendingAction === Action.Push) {
+      init.history.push(location, location.state);
+    } else if (pendingAction === Action.Replace) {
+      init.history.replace(location, location.state);
+    }
+    let viewTransitionOpts;
+    // On POP, enable transitions if they were enabled on the original navigation
+    if (pendingAction === Action.Pop) {
+      // Forward takes precedence so they behave like the original navigation
+      let priorPaths = appliedViewTransitions.get(state.location.pathname);
+      if (priorPaths && priorPaths.has(location.pathname)) {
+        viewTransitionOpts = {
+          currentLocation: state.location,
+          nextLocation: location
+        };
+      } else if (appliedViewTransitions.has(location.pathname)) {
+        // If we don't have a previous forward nav, assume we're popping back to
+        // the new location and enable if that location previously enabled
+        viewTransitionOpts = {
+          currentLocation: location,
+          nextLocation: state.location
+        };
+      }
+    } else if (pendingViewTransitionEnabled) {
+      // Store the applied transition on PUSH/REPLACE
+      let toPaths = appliedViewTransitions.get(state.location.pathname);
+      if (toPaths) {
+        toPaths.add(location.pathname);
+      } else {
+        toPaths = new Set([location.pathname]);
+        appliedViewTransitions.set(state.location.pathname, toPaths);
+      }
+      viewTransitionOpts = {
+        currentLocation: state.location,
+        nextLocation: location
+      };
+    }
+    updateState(_extends({}, newState, {
+      actionData,
+      loaderData,
+      historyAction: pendingAction,
+      location,
+      initialized: true,
+      navigation: IDLE_NAVIGATION,
+      revalidation: "idle",
+      restoreScrollPosition: getSavedScrollPosition(location, newState.matches || state.matches),
+      preventScrollReset,
+      blockers
+    }), {
+      viewTransitionOpts,
+      flushSync: flushSync === true
+    });
+    // Reset stateful navigation vars
+    pendingAction = Action.Pop;
+    pendingPreventScrollReset = false;
+    pendingViewTransitionEnabled = false;
+    isUninterruptedRevalidation = false;
+    isRevalidationRequired = false;
+    cancelledDeferredRoutes = [];
+  }
+  // Trigger a navigation event, which can either be a numerical POP or a PUSH
+  // replace with an optional submission
+  async function navigate(to, opts) {
+    if (typeof to === "number") {
+      init.history.go(to);
+      return;
+    }
+    let normalizedPath = normalizeTo(state.location, state.matches, basename, future.v7_prependBasename, to, future.v7_relativeSplatPath, opts == null ? void 0 : opts.fromRouteId, opts == null ? void 0 : opts.relative);
+    let {
+      path,
+      submission,
+      error
+    } = normalizeNavigateOptions(future.v7_normalizeFormMethod, false, normalizedPath, opts);
+    let currentLocation = state.location;
+    let nextLocation = createLocation(state.location, path, opts && opts.state);
+    // When using navigate as a PUSH/REPLACE we aren't reading an already-encoded
+    // URL from window.location, so we need to encode it here so the behavior
+    // remains the same as POP and non-data-router usages.  new URL() does all
+    // the same encoding we'd get from a history.pushState/window.location read
+    // without having to touch history
+    nextLocation = _extends({}, nextLocation, init.history.encodeLocation(nextLocation));
+    let userReplace = opts && opts.replace != null ? opts.replace : undefined;
+    let historyAction = Action.Push;
+    if (userReplace === true) {
+      historyAction = Action.Replace;
+    } else if (userReplace === false) ; else if (submission != null && isMutationMethod(submission.formMethod) && submission.formAction === state.location.pathname + state.location.search) {
+      // By default on submissions to the current location we REPLACE so that
+      // users don't have to double-click the back button to get to the prior
+      // location.  If the user redirects to a different location from the
+      // action/loader this will be ignored and the redirect will be a PUSH
+      historyAction = Action.Replace;
+    }
+    let preventScrollReset = opts && "preventScrollReset" in opts ? opts.preventScrollReset === true : undefined;
+    let flushSync = (opts && opts.flushSync) === true;
+    let blockerKey = shouldBlockNavigation({
+      currentLocation,
+      nextLocation,
+      historyAction
+    });
+    if (blockerKey) {
+      // Put the blocker into a blocked state
+      updateBlocker(blockerKey, {
+        state: "blocked",
+        location: nextLocation,
+        proceed() {
+          updateBlocker(blockerKey, {
+            state: "proceeding",
+            proceed: undefined,
+            reset: undefined,
+            location: nextLocation
+          });
+          // Send the same navigation through
+          navigate(to, opts);
+        },
+        reset() {
+          let blockers = new Map(state.blockers);
+          blockers.set(blockerKey, IDLE_BLOCKER);
+          updateState({
+            blockers
+          });
+        }
+      });
+      return;
+    }
+    return await startNavigation(historyAction, nextLocation, {
+      submission,
+      // Send through the formData serialization error if we have one so we can
+      // render at the right error boundary after we match routes
+      pendingError: error,
+      preventScrollReset,
+      replace: opts && opts.replace,
+      enableViewTransition: opts && opts.viewTransition,
+      flushSync
+    });
+  }
+  // Revalidate all current loaders.  If a navigation is in progress or if this
+  // is interrupted by a navigation, allow this to "succeed" by calling all
+  // loaders during the next loader round
+  function revalidate() {
+    interruptActiveLoads();
+    updateState({
+      revalidation: "loading"
+    });
+    // If we're currently submitting an action, we don't need to start a new
+    // navigation, we'll just let the follow up loader execution call all loaders
+    if (state.navigation.state === "submitting") {
+      return;
+    }
+    // If we're currently in an idle state, start a new navigation for the current
+    // action/location and mark it as uninterrupted, which will skip the history
+    // update in completeNavigation
+    if (state.navigation.state === "idle") {
+      startNavigation(state.historyAction, state.location, {
+        startUninterruptedRevalidation: true
+      });
+      return;
+    }
+    // Otherwise, if we're currently in a loading state, just start a new
+    // navigation to the navigation.location but do not trigger an uninterrupted
+    // revalidation so that history correctly updates once the navigation completes
+    startNavigation(pendingAction || state.historyAction, state.navigation.location, {
+      overrideNavigation: state.navigation,
+      // Proxy through any rending view transition
+      enableViewTransition: pendingViewTransitionEnabled === true
+    });
+  }
+  // Start a navigation to the given action/location.  Can optionally provide a
+  // overrideNavigation which will override the normalLoad in the case of a redirect
+  // navigation
+  async function startNavigation(historyAction, location, opts) {
+    // Abort any in-progress navigations and start a new one. Unset any ongoing
+    // uninterrupted revalidations unless told otherwise, since we want this
+    // new navigation to update history normally
+    pendingNavigationController && pendingNavigationController.abort();
+    pendingNavigationController = null;
+    pendingAction = historyAction;
+    isUninterruptedRevalidation = (opts && opts.startUninterruptedRevalidation) === true;
+    // Save the current scroll position every time we start a new navigation,
+    // and track whether we should reset scroll on completion
+    saveScrollPosition(state.location, state.matches);
+    pendingPreventScrollReset = (opts && opts.preventScrollReset) === true;
+    pendingViewTransitionEnabled = (opts && opts.enableViewTransition) === true;
+    let routesToUse = inFlightDataRoutes || dataRoutes;
+    let loadingNavigation = opts && opts.overrideNavigation;
+    let matches = opts != null && opts.initialHydration && state.matches && state.matches.length > 0 && !initialMatchesIsFOW ?
+    // `matchRoutes()` has already been called if we're in here via `router.initialize()`
+    state.matches : matchRoutes(routesToUse, location, basename);
+    let flushSync = (opts && opts.flushSync) === true;
+    // Short circuit if it's only a hash change and not a revalidation or
+    // mutation submission.
+    //
+    // Ignore on initial page loads because since the initial hydration will always
+    // be "same hash".  For example, on /page#hash and submit a <Form method="post">
+    // which will default to a navigation to /page
+    if (matches && state.initialized && !isRevalidationRequired && isHashChangeOnly(state.location, location) && !(opts && opts.submission && isMutationMethod(opts.submission.formMethod))) {
+      completeNavigation(location, {
+        matches
+      }, {
+        flushSync
+      });
+      return;
+    }
+    let fogOfWar = checkFogOfWar(matches, routesToUse, location.pathname);
+    if (fogOfWar.active && fogOfWar.matches) {
+      matches = fogOfWar.matches;
+    }
+    // Short circuit with a 404 on the root error boundary if we match nothing
+    if (!matches) {
+      let {
+        error,
+        notFoundMatches,
+        route
+      } = handleNavigational404(location.pathname);
+      completeNavigation(location, {
+        matches: notFoundMatches,
+        loaderData: {},
+        errors: {
+          [route.id]: error
+        }
+      }, {
+        flushSync
+      });
+      return;
+    }
+    // Create a controller/Request for this navigation
+    pendingNavigationController = new AbortController();
+    let request = createClientSideRequest(init.history, location, pendingNavigationController.signal, opts && opts.submission);
+    let pendingActionResult;
+    if (opts && opts.pendingError) {
+      // If we have a pendingError, it means the user attempted a GET submission
+      // with binary FormData so assign here and skip to handleLoaders.  That
+      // way we handle calling loaders above the boundary etc.  It's not really
+      // different from an actionError in that sense.
+      pendingActionResult = [findNearestBoundary(matches).route.id, {
+        type: ResultType.error,
+        error: opts.pendingError
+      }];
+    } else if (opts && opts.submission && isMutationMethod(opts.submission.formMethod)) {
+      // Call action if we received an action submission
+      let actionResult = await handleAction(request, location, opts.submission, matches, fogOfWar.active, {
+        replace: opts.replace,
+        flushSync
+      });
+      if (actionResult.shortCircuited) {
+        return;
+      }
+      // If we received a 404 from handleAction, it's because we couldn't lazily
+      // discover the destination route so we don't want to call loaders
+      if (actionResult.pendingActionResult) {
+        let [routeId, result] = actionResult.pendingActionResult;
+        if (isErrorResult(result) && isRouteErrorResponse(result.error) && result.error.status === 404) {
+          pendingNavigationController = null;
+          completeNavigation(location, {
+            matches: actionResult.matches,
+            loaderData: {},
+            errors: {
+              [routeId]: result.error
+            }
+          });
+          return;
+        }
+      }
+      matches = actionResult.matches || matches;
+      pendingActionResult = actionResult.pendingActionResult;
+      loadingNavigation = getLoadingNavigation(location, opts.submission);
+      flushSync = false;
+      // No need to do fog of war matching again on loader execution
+      fogOfWar.active = false;
+      // Create a GET request for the loaders
+      request = createClientSideRequest(init.history, request.url, request.signal);
+    }
+    // Call loaders
+    let {
+      shortCircuited,
+      matches: updatedMatches,
+      loaderData,
+      errors
+    } = await handleLoaders(request, location, matches, fogOfWar.active, loadingNavigation, opts && opts.submission, opts && opts.fetcherSubmission, opts && opts.replace, opts && opts.initialHydration === true, flushSync, pendingActionResult);
+    if (shortCircuited) {
+      return;
+    }
+    // Clean up now that the action/loaders have completed.  Don't clean up if
+    // we short circuited because pendingNavigationController will have already
+    // been assigned to a new controller for the next navigation
+    pendingNavigationController = null;
+    completeNavigation(location, _extends({
+      matches: updatedMatches || matches
+    }, getActionDataForCommit(pendingActionResult), {
+      loaderData,
+      errors
+    }));
+  }
+  // Call the action matched by the leaf route for this navigation and handle
+  // redirects/errors
+  async function handleAction(request, location, submission, matches, isFogOfWar, opts) {
+    if (opts === void 0) {
+      opts = {};
+    }
+    interruptActiveLoads();
+    // Put us in a submitting state
+    let navigation = getSubmittingNavigation(location, submission);
+    updateState({
+      navigation
+    }, {
+      flushSync: opts.flushSync === true
+    });
+    if (isFogOfWar) {
+      let discoverResult = await discoverRoutes(matches, location.pathname, request.signal);
+      if (discoverResult.type === "aborted") {
+        return {
+          shortCircuited: true
+        };
+      } else if (discoverResult.type === "error") {
+        let boundaryId = findNearestBoundary(discoverResult.partialMatches).route.id;
+        return {
+          matches: discoverResult.partialMatches,
+          pendingActionResult: [boundaryId, {
+            type: ResultType.error,
+            error: discoverResult.error
+          }]
+        };
+      } else if (!discoverResult.matches) {
+        let {
+          notFoundMatches,
+          error,
+          route
+        } = handleNavigational404(location.pathname);
+        return {
+          matches: notFoundMatches,
+          pendingActionResult: [route.id, {
+            type: ResultType.error,
+            error
+          }]
+        };
+      } else {
+        matches = discoverResult.matches;
+      }
+    }
+    // Call our action and get the result
+    let result;
+    let actionMatch = getTargetMatch(matches, location);
+    if (!actionMatch.route.action && !actionMatch.route.lazy) {
+      result = {
+        type: ResultType.error,
+        error: getInternalRouterError(405, {
+          method: request.method,
+          pathname: location.pathname,
+          routeId: actionMatch.route.id
+        })
+      };
+    } else {
+      let results = await callDataStrategy("action", state, request, [actionMatch], matches, null);
+      result = results[actionMatch.route.id];
+      if (request.signal.aborted) {
+        return {
+          shortCircuited: true
+        };
+      }
+    }
+    if (isRedirectResult(result)) {
+      let replace;
+      if (opts && opts.replace != null) {
+        replace = opts.replace;
+      } else {
+        // If the user didn't explicity indicate replace behavior, replace if
+        // we redirected to the exact same location we're currently at to avoid
+        // double back-buttons
+        let location = normalizeRedirectLocation(result.response.headers.get("Location"), new URL(request.url), basename, init.history);
+        replace = location === state.location.pathname + state.location.search;
+      }
+      await startRedirectNavigation(request, result, true, {
+        submission,
+        replace
+      });
+      return {
+        shortCircuited: true
+      };
+    }
+    if (isDeferredResult(result)) {
+      throw getInternalRouterError(400, {
+        type: "defer-action"
+      });
+    }
+    if (isErrorResult(result)) {
+      // Store off the pending error - we use it to determine which loaders
+      // to call and will commit it when we complete the navigation
+      let boundaryMatch = findNearestBoundary(matches, actionMatch.route.id);
+      // By default, all submissions to the current location are REPLACE
+      // navigations, but if the action threw an error that'll be rendered in
+      // an errorElement, we fall back to PUSH so that the user can use the
+      // back button to get back to the pre-submission form location to try
+      // again
+      if ((opts && opts.replace) !== true) {
+        pendingAction = Action.Push;
+      }
+      return {
+        matches,
+        pendingActionResult: [boundaryMatch.route.id, result]
+      };
+    }
+    return {
+      matches,
+      pendingActionResult: [actionMatch.route.id, result]
+    };
+  }
+  // Call all applicable loaders for the given matches, handling redirects,
+  // errors, etc.
+  async function handleLoaders(request, location, matches, isFogOfWar, overrideNavigation, submission, fetcherSubmission, replace, initialHydration, flushSync, pendingActionResult) {
+    // Figure out the right navigation we want to use for data loading
+    let loadingNavigation = overrideNavigation || getLoadingNavigation(location, submission);
+    // If this was a redirect from an action we don't have a "submission" but
+    // we have it on the loading navigation so use that if available
+    let activeSubmission = submission || fetcherSubmission || getSubmissionFromNavigation(loadingNavigation);
+    // If this is an uninterrupted revalidation, we remain in our current idle
+    // state.  If not, we need to switch to our loading state and load data,
+    // preserving any new action data or existing action data (in the case of
+    // a revalidation interrupting an actionReload)
+    // If we have partialHydration enabled, then don't update the state for the
+    // initial data load since it's not a "navigation"
+    let shouldUpdateNavigationState = !isUninterruptedRevalidation && (!future.v7_partialHydration || !initialHydration);
+    // When fog of war is enabled, we enter our `loading` state earlier so we
+    // can discover new routes during the `loading` state.  We skip this if
+    // we've already run actions since we would have done our matching already.
+    // If the children() function threw then, we want to proceed with the
+    // partial matches it discovered.
+    if (isFogOfWar) {
+      if (shouldUpdateNavigationState) {
+        let actionData = getUpdatedActionData(pendingActionResult);
+        updateState(_extends({
+          navigation: loadingNavigation
+        }, actionData !== undefined ? {
+          actionData
+        } : {}), {
+          flushSync
+        });
+      }
+      let discoverResult = await discoverRoutes(matches, location.pathname, request.signal);
+      if (discoverResult.type === "aborted") {
+        return {
+          shortCircuited: true
+        };
+      } else if (discoverResult.type === "error") {
+        let boundaryId = findNearestBoundary(discoverResult.partialMatches).route.id;
+        return {
+          matches: discoverResult.partialMatches,
+          loaderData: {},
+          errors: {
+            [boundaryId]: discoverResult.error
+          }
+        };
+      } else if (!discoverResult.matches) {
+        let {
+          error,
+          notFoundMatches,
+          route
+        } = handleNavigational404(location.pathname);
+        return {
+          matches: notFoundMatches,
+          loaderData: {},
+          errors: {
+            [route.id]: error
+          }
+        };
+      } else {
+        matches = discoverResult.matches;
+      }
+    }
+    let routesToUse = inFlightDataRoutes || dataRoutes;
+    let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(init.history, state, matches, activeSubmission, location, future.v7_partialHydration && initialHydration === true, future.v7_skipActionErrorRevalidation, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, deletedFetchers, fetchLoadMatches, fetchRedirectIds, routesToUse, basename, pendingActionResult);
+    // Cancel pending deferreds for no-longer-matched routes or routes we're
+    // about to reload.  Note that if this is an action reload we would have
+    // already cancelled all pending deferreds so this would be a no-op
+    cancelActiveDeferreds(routeId => !(matches && matches.some(m => m.route.id === routeId)) || matchesToLoad && matchesToLoad.some(m => m.route.id === routeId));
+    pendingNavigationLoadId = ++incrementingLoadId;
+    // Short circuit if we have no loaders to run
+    if (matchesToLoad.length === 0 && revalidatingFetchers.length === 0) {
+      let updatedFetchers = markFetchRedirectsDone();
+      completeNavigation(location, _extends({
+        matches,
+        loaderData: {},
+        // Commit pending error if we're short circuiting
+        errors: pendingActionResult && isErrorResult(pendingActionResult[1]) ? {
+          [pendingActionResult[0]]: pendingActionResult[1].error
+        } : null
+      }, getActionDataForCommit(pendingActionResult), updatedFetchers ? {
+        fetchers: new Map(state.fetchers)
+      } : {}), {
+        flushSync
+      });
+      return {
+        shortCircuited: true
+      };
+    }
+    if (shouldUpdateNavigationState) {
+      let updates = {};
+      if (!isFogOfWar) {
+        // Only update navigation/actionNData if we didn't already do it above
+        updates.navigation = loadingNavigation;
+        let actionData = getUpdatedActionData(pendingActionResult);
+        if (actionData !== undefined) {
+          updates.actionData = actionData;
+        }
+      }
+      if (revalidatingFetchers.length > 0) {
+        updates.fetchers = getUpdatedRevalidatingFetchers(revalidatingFetchers);
+      }
+      updateState(updates, {
+        flushSync
+      });
+    }
+    revalidatingFetchers.forEach(rf => {
+      abortFetcher(rf.key);
+      if (rf.controller) {
+        // Fetchers use an independent AbortController so that aborting a fetcher
+        // (via deleteFetcher) does not abort the triggering navigation that
+        // triggered the revalidation
+        fetchControllers.set(rf.key, rf.controller);
+      }
+    });
+    // Proxy navigation abort through to revalidation fetchers
+    let abortPendingFetchRevalidations = () => revalidatingFetchers.forEach(f => abortFetcher(f.key));
+    if (pendingNavigationController) {
+      pendingNavigationController.signal.addEventListener("abort", abortPendingFetchRevalidations);
+    }
+    let {
+      loaderResults,
+      fetcherResults
+    } = await callLoadersAndMaybeResolveData(state, matches, matchesToLoad, revalidatingFetchers, request);
+    if (request.signal.aborted) {
+      return {
+        shortCircuited: true
+      };
+    }
+    // Clean up _after_ loaders have completed.  Don't clean up if we short
+    // circuited because fetchControllers would have been aborted and
+    // reassigned to new controllers for the next navigation
+    if (pendingNavigationController) {
+      pendingNavigationController.signal.removeEventListener("abort", abortPendingFetchRevalidations);
+    }
+    revalidatingFetchers.forEach(rf => fetchControllers.delete(rf.key));
+    // If any loaders returned a redirect Response, start a new REPLACE navigation
+    let redirect = findRedirect(loaderResults);
+    if (redirect) {
+      await startRedirectNavigation(request, redirect.result, true, {
+        replace
+      });
+      return {
+        shortCircuited: true
+      };
+    }
+    redirect = findRedirect(fetcherResults);
+    if (redirect) {
+      // If this redirect came from a fetcher make sure we mark it in
+      // fetchRedirectIds so it doesn't get revalidated on the next set of
+      // loader executions
+      fetchRedirectIds.add(redirect.key);
+      await startRedirectNavigation(request, redirect.result, true, {
+        replace
+      });
+      return {
+        shortCircuited: true
+      };
+    }
+    // Process and commit output from loaders
+    let {
+      loaderData,
+      errors
+    } = processLoaderData(state, matches, loaderResults, pendingActionResult, revalidatingFetchers, fetcherResults, activeDeferreds);
+    // Wire up subscribers to update loaderData as promises settle
+    activeDeferreds.forEach((deferredData, routeId) => {
+      deferredData.subscribe(aborted => {
+        // Note: No need to updateState here since the TrackedPromise on
+        // loaderData is stable across resolve/reject
+        // Remove this instance if we were aborted or if promises have settled
+        if (aborted || deferredData.done) {
+          activeDeferreds.delete(routeId);
+        }
+      });
+    });
+    // Preserve SSR errors during partial hydration
+    if (future.v7_partialHydration && initialHydration && state.errors) {
+      errors = _extends({}, state.errors, errors);
+    }
+    let updatedFetchers = markFetchRedirectsDone();
+    let didAbortFetchLoads = abortStaleFetchLoads(pendingNavigationLoadId);
+    let shouldUpdateFetchers = updatedFetchers || didAbortFetchLoads || revalidatingFetchers.length > 0;
+    return _extends({
+      matches,
+      loaderData,
+      errors
+    }, shouldUpdateFetchers ? {
+      fetchers: new Map(state.fetchers)
+    } : {});
+  }
+  function getUpdatedActionData(pendingActionResult) {
+    if (pendingActionResult && !isErrorResult(pendingActionResult[1])) {
+      // This is cast to `any` currently because `RouteData`uses any and it
+      // would be a breaking change to use any.
+      // TODO: v7 - change `RouteData` to use `unknown` instead of `any`
+      return {
+        [pendingActionResult[0]]: pendingActionResult[1].data
+      };
+    } else if (state.actionData) {
+      if (Object.keys(state.actionData).length === 0) {
+        return null;
+      } else {
+        return state.actionData;
+      }
+    }
+  }
+  function getUpdatedRevalidatingFetchers(revalidatingFetchers) {
+    revalidatingFetchers.forEach(rf => {
+      let fetcher = state.fetchers.get(rf.key);
+      let revalidatingFetcher = getLoadingFetcher(undefined, fetcher ? fetcher.data : undefined);
+      state.fetchers.set(rf.key, revalidatingFetcher);
+    });
+    return new Map(state.fetchers);
+  }
+  // Trigger a fetcher load/submit for the given fetcher key
+  function fetch(key, routeId, href, opts) {
+    if (isServer) {
+      throw new Error("router.fetch() was called during the server render, but it shouldn't be. " + "You are likely calling a useFetcher() method in the body of your component. " + "Try moving it to a useEffect or a callback.");
+    }
+    abortFetcher(key);
+    let flushSync = (opts && opts.flushSync) === true;
+    let routesToUse = inFlightDataRoutes || dataRoutes;
+    let normalizedPath = normalizeTo(state.location, state.matches, basename, future.v7_prependBasename, href, future.v7_relativeSplatPath, routeId, opts == null ? void 0 : opts.relative);
+    let matches = matchRoutes(routesToUse, normalizedPath, basename);
+    let fogOfWar = checkFogOfWar(matches, routesToUse, normalizedPath);
+    if (fogOfWar.active && fogOfWar.matches) {
+      matches = fogOfWar.matches;
+    }
+    if (!matches) {
+      setFetcherError(key, routeId, getInternalRouterError(404, {
+        pathname: normalizedPath
+      }), {
+        flushSync
+      });
+      return;
+    }
+    let {
+      path,
+      submission,
+      error
+    } = normalizeNavigateOptions(future.v7_normalizeFormMethod, true, normalizedPath, opts);
+    if (error) {
+      setFetcherError(key, routeId, error, {
+        flushSync
+      });
+      return;
+    }
+    let match = getTargetMatch(matches, path);
+    let preventScrollReset = (opts && opts.preventScrollReset) === true;
+    if (submission && isMutationMethod(submission.formMethod)) {
+      handleFetcherAction(key, routeId, path, match, matches, fogOfWar.active, flushSync, preventScrollReset, submission);
+      return;
+    }
+    // Store off the match so we can call it's shouldRevalidate on subsequent
+    // revalidations
+    fetchLoadMatches.set(key, {
+      routeId,
+      path
+    });
+    handleFetcherLoader(key, routeId, path, match, matches, fogOfWar.active, flushSync, preventScrollReset, submission);
+  }
+  // Call the action for the matched fetcher.submit(), and then handle redirects,
+  // errors, and revalidation
+  async function handleFetcherAction(key, routeId, path, match, requestMatches, isFogOfWar, flushSync, preventScrollReset, submission) {
+    interruptActiveLoads();
+    fetchLoadMatches.delete(key);
+    function detectAndHandle405Error(m) {
+      if (!m.route.action && !m.route.lazy) {
+        let error = getInternalRouterError(405, {
+          method: submission.formMethod,
+          pathname: path,
+          routeId: routeId
+        });
+        setFetcherError(key, routeId, error, {
+          flushSync
+        });
+        return true;
+      }
+      return false;
+    }
+    if (!isFogOfWar && detectAndHandle405Error(match)) {
+      return;
+    }
+    // Put this fetcher into it's submitting state
+    let existingFetcher = state.fetchers.get(key);
+    updateFetcherState(key, getSubmittingFetcher(submission, existingFetcher), {
+      flushSync
+    });
+    let abortController = new AbortController();
+    let fetchRequest = createClientSideRequest(init.history, path, abortController.signal, submission);
+    if (isFogOfWar) {
+      let discoverResult = await discoverRoutes(requestMatches, new URL(fetchRequest.url).pathname, fetchRequest.signal, key);
+      if (discoverResult.type === "aborted") {
+        return;
+      } else if (discoverResult.type === "error") {
+        setFetcherError(key, routeId, discoverResult.error, {
+          flushSync
+        });
+        return;
+      } else if (!discoverResult.matches) {
+        setFetcherError(key, routeId, getInternalRouterError(404, {
+          pathname: path
+        }), {
+          flushSync
+        });
+        return;
+      } else {
+        requestMatches = discoverResult.matches;
+        match = getTargetMatch(requestMatches, path);
+        if (detectAndHandle405Error(match)) {
+          return;
+        }
+      }
+    }
+    // Call the action for the fetcher
+    fetchControllers.set(key, abortController);
+    let originatingLoadId = incrementingLoadId;
+    let actionResults = await callDataStrategy("action", state, fetchRequest, [match], requestMatches, key);
+    let actionResult = actionResults[match.route.id];
+    if (fetchRequest.signal.aborted) {
+      // We can delete this so long as we weren't aborted by our own fetcher
+      // re-submit which would have put _new_ controller is in fetchControllers
+      if (fetchControllers.get(key) === abortController) {
+        fetchControllers.delete(key);
+      }
+      return;
+    }
+    // When using v7_fetcherPersist, we don't want errors bubbling up to the UI
+    // or redirects processed for unmounted fetchers so we just revert them to
+    // idle
+    if (future.v7_fetcherPersist && deletedFetchers.has(key)) {
+      if (isRedirectResult(actionResult) || isErrorResult(actionResult)) {
+        updateFetcherState(key, getDoneFetcher(undefined));
+        return;
+      }
+      // Let SuccessResult's fall through for revalidation
+    } else {
+      if (isRedirectResult(actionResult)) {
+        fetchControllers.delete(key);
+        if (pendingNavigationLoadId > originatingLoadId) {
+          // A new navigation was kicked off after our action started, so that
+          // should take precedence over this redirect navigation.  We already
+          // set isRevalidationRequired so all loaders for the new route should
+          // fire unless opted out via shouldRevalidate
+          updateFetcherState(key, getDoneFetcher(undefined));
+          return;
+        } else {
+          fetchRedirectIds.add(key);
+          updateFetcherState(key, getLoadingFetcher(submission));
+          return startRedirectNavigation(fetchRequest, actionResult, false, {
+            fetcherSubmission: submission,
+            preventScrollReset
+          });
+        }
+      }
+      // Process any non-redirect errors thrown
+      if (isErrorResult(actionResult)) {
+        setFetcherError(key, routeId, actionResult.error);
+        return;
+      }
+    }
+    if (isDeferredResult(actionResult)) {
+      throw getInternalRouterError(400, {
+        type: "defer-action"
+      });
+    }
+    // Start the data load for current matches, or the next location if we're
+    // in the middle of a navigation
+    let nextLocation = state.navigation.location || state.location;
+    let revalidationRequest = createClientSideRequest(init.history, nextLocation, abortController.signal);
+    let routesToUse = inFlightDataRoutes || dataRoutes;
+    let matches = state.navigation.state !== "idle" ? matchRoutes(routesToUse, state.navigation.location, basename) : state.matches;
+    invariant(matches, "Didn't find any matches after fetcher action");
+    let loadId = ++incrementingLoadId;
+    fetchReloadIds.set(key, loadId);
+    let loadFetcher = getLoadingFetcher(submission, actionResult.data);
+    state.fetchers.set(key, loadFetcher);
+    let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(init.history, state, matches, submission, nextLocation, false, future.v7_skipActionErrorRevalidation, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, deletedFetchers, fetchLoadMatches, fetchRedirectIds, routesToUse, basename, [match.route.id, actionResult]);
+    // Put all revalidating fetchers into the loading state, except for the
+    // current fetcher which we want to keep in it's current loading state which
+    // contains it's action submission info + action data
+    revalidatingFetchers.filter(rf => rf.key !== key).forEach(rf => {
+      let staleKey = rf.key;
+      let existingFetcher = state.fetchers.get(staleKey);
+      let revalidatingFetcher = getLoadingFetcher(undefined, existingFetcher ? existingFetcher.data : undefined);
+      state.fetchers.set(staleKey, revalidatingFetcher);
+      abortFetcher(staleKey);
+      if (rf.controller) {
+        fetchControllers.set(staleKey, rf.controller);
+      }
+    });
+    updateState({
+      fetchers: new Map(state.fetchers)
+    });
+    let abortPendingFetchRevalidations = () => revalidatingFetchers.forEach(rf => abortFetcher(rf.key));
+    abortController.signal.addEventListener("abort", abortPendingFetchRevalidations);
+    let {
+      loaderResults,
+      fetcherResults
+    } = await callLoadersAndMaybeResolveData(state, matches, matchesToLoad, revalidatingFetchers, revalidationRequest);
+    if (abortController.signal.aborted) {
+      return;
+    }
+    abortController.signal.removeEventListener("abort", abortPendingFetchRevalidations);
+    fetchReloadIds.delete(key);
+    fetchControllers.delete(key);
+    revalidatingFetchers.forEach(r => fetchControllers.delete(r.key));
+    let redirect = findRedirect(loaderResults);
+    if (redirect) {
+      return startRedirectNavigation(revalidationRequest, redirect.result, false, {
+        preventScrollReset
+      });
+    }
+    redirect = findRedirect(fetcherResults);
+    if (redirect) {
+      // If this redirect came from a fetcher make sure we mark it in
+      // fetchRedirectIds so it doesn't get revalidated on the next set of
+      // loader executions
+      fetchRedirectIds.add(redirect.key);
+      return startRedirectNavigation(revalidationRequest, redirect.result, false, {
+        preventScrollReset
+      });
+    }
+    // Process and commit output from loaders
+    let {
+      loaderData,
+      errors
+    } = processLoaderData(state, matches, loaderResults, undefined, revalidatingFetchers, fetcherResults, activeDeferreds);
+    // Since we let revalidations complete even if the submitting fetcher was
+    // deleted, only put it back to idle if it hasn't been deleted
+    if (state.fetchers.has(key)) {
+      let doneFetcher = getDoneFetcher(actionResult.data);
+      state.fetchers.set(key, doneFetcher);
+    }
+    abortStaleFetchLoads(loadId);
+    // If we are currently in a navigation loading state and this fetcher is
+    // more recent than the navigation, we want the newer data so abort the
+    // navigation and complete it with the fetcher data
+    if (state.navigation.state === "loading" && loadId > pendingNavigationLoadId) {
+      invariant(pendingAction, "Expected pending action");
+      pendingNavigationController && pendingNavigationController.abort();
+      completeNavigation(state.navigation.location, {
+        matches,
+        loaderData,
+        errors,
+        fetchers: new Map(state.fetchers)
+      });
+    } else {
+      // otherwise just update with the fetcher data, preserving any existing
+      // loaderData for loaders that did not need to reload.  We have to
+      // manually merge here since we aren't going through completeNavigation
+      updateState({
+        errors,
+        loaderData: mergeLoaderData(state.loaderData, loaderData, matches, errors),
+        fetchers: new Map(state.fetchers)
+      });
+      isRevalidationRequired = false;
+    }
+  }
+  // Call the matched loader for fetcher.load(), handling redirects, errors, etc.
+  async function handleFetcherLoader(key, routeId, path, match, matches, isFogOfWar, flushSync, preventScrollReset, submission) {
+    let existingFetcher = state.fetchers.get(key);
+    updateFetcherState(key, getLoadingFetcher(submission, existingFetcher ? existingFetcher.data : undefined), {
+      flushSync
+    });
+    let abortController = new AbortController();
+    let fetchRequest = createClientSideRequest(init.history, path, abortController.signal);
+    if (isFogOfWar) {
+      let discoverResult = await discoverRoutes(matches, new URL(fetchRequest.url).pathname, fetchRequest.signal, key);
+      if (discoverResult.type === "aborted") {
+        return;
+      } else if (discoverResult.type === "error") {
+        setFetcherError(key, routeId, discoverResult.error, {
+          flushSync
+        });
+        return;
+      } else if (!discoverResult.matches) {
+        setFetcherError(key, routeId, getInternalRouterError(404, {
+          pathname: path
+        }), {
+          flushSync
+        });
+        return;
+      } else {
+        matches = discoverResult.matches;
+        match = getTargetMatch(matches, path);
+      }
+    }
+    // Call the loader for this fetcher route match
+    fetchControllers.set(key, abortController);
+    let originatingLoadId = incrementingLoadId;
+    let results = await callDataStrategy("loader", state, fetchRequest, [match], matches, key);
+    let result = results[match.route.id];
+    // Deferred isn't supported for fetcher loads, await everything and treat it
+    // as a normal load.  resolveDeferredData will return undefined if this
+    // fetcher gets aborted, so we just leave result untouched and short circuit
+    // below if that happens
+    if (isDeferredResult(result)) {
+      result = (await resolveDeferredData(result, fetchRequest.signal, true)) || result;
+    }
+    // We can delete this so long as we weren't aborted by our our own fetcher
+    // re-load which would have put _new_ controller is in fetchControllers
+    if (fetchControllers.get(key) === abortController) {
+      fetchControllers.delete(key);
+    }
+    if (fetchRequest.signal.aborted) {
+      return;
+    }
+    // We don't want errors bubbling up or redirects followed for unmounted
+    // fetchers, so short circuit here if it was removed from the UI
+    if (deletedFetchers.has(key)) {
+      updateFetcherState(key, getDoneFetcher(undefined));
+      return;
+    }
+    // If the loader threw a redirect Response, start a new REPLACE navigation
+    if (isRedirectResult(result)) {
+      if (pendingNavigationLoadId > originatingLoadId) {
+        // A new navigation was kicked off after our loader started, so that
+        // should take precedence over this redirect navigation
+        updateFetcherState(key, getDoneFetcher(undefined));
+        return;
+      } else {
+        fetchRedirectIds.add(key);
+        await startRedirectNavigation(fetchRequest, result, false, {
+          preventScrollReset
+        });
+        return;
+      }
+    }
+    // Process any non-redirect errors thrown
+    if (isErrorResult(result)) {
+      setFetcherError(key, routeId, result.error);
+      return;
+    }
+    invariant(!isDeferredResult(result), "Unhandled fetcher deferred data");
+    // Put the fetcher back into an idle state
+    updateFetcherState(key, getDoneFetcher(result.data));
+  }
+  /**
+   * Utility function to handle redirects returned from an action or loader.
+   * Normally, a redirect "replaces" the navigation that triggered it.  So, for
+   * example:
+   *
+   *  - user is on /a
+   *  - user clicks a link to /b
+   *  - loader for /b redirects to /c
+   *
+   * In a non-JS app the browser would track the in-flight navigation to /b and
+   * then replace it with /c when it encountered the redirect response.  In
+   * the end it would only ever update the URL bar with /c.
+   *
+   * In client-side routing using pushState/replaceState, we aim to emulate
+   * this behavior and we also do not update history until the end of the
+   * navigation (including processed redirects).  This means that we never
+   * actually touch history until we've processed redirects, so we just use
+   * the history action from the original navigation (PUSH or REPLACE).
+   */
+  async function startRedirectNavigation(request, redirect, isNavigation, _temp2) {
+    let {
+      submission,
+      fetcherSubmission,
+      preventScrollReset,
+      replace
+    } = _temp2 === void 0 ? {} : _temp2;
+    if (redirect.response.headers.has("X-Remix-Revalidate")) {
+      isRevalidationRequired = true;
+    }
+    let location = redirect.response.headers.get("Location");
+    invariant(location, "Expected a Location header on the redirect Response");
+    location = normalizeRedirectLocation(location, new URL(request.url), basename, init.history);
+    let redirectLocation = createLocation(state.location, location, {
+      _isRedirect: true
+    });
+    if (isBrowser) {
+      let isDocumentReload = false;
+      if (redirect.response.headers.has("X-Remix-Reload-Document")) {
+        // Hard reload if the response contained X-Remix-Reload-Document
+        isDocumentReload = true;
+      } else if (ABSOLUTE_URL_REGEX.test(location)) {
+        const url = init.history.createURL(location);
+        isDocumentReload =
+        // Hard reload if it's an absolute URL to a new origin
+        url.origin !== routerWindow.location.origin ||
+        // Hard reload if it's an absolute URL that does not match our basename
+        stripBasename(url.pathname, basename) == null;
+      }
+      if (isDocumentReload) {
+        if (replace) {
+          routerWindow.location.replace(location);
+        } else {
+          routerWindow.location.assign(location);
+        }
+        return;
+      }
+    }
+    // There's no need to abort on redirects, since we don't detect the
+    // redirect until the action/loaders have settled
+    pendingNavigationController = null;
+    let redirectHistoryAction = replace === true || redirect.response.headers.has("X-Remix-Replace") ? Action.Replace : Action.Push;
+    // Use the incoming submission if provided, fallback on the active one in
+    // state.navigation
+    let {
+      formMethod,
+      formAction,
+      formEncType
+    } = state.navigation;
+    if (!submission && !fetcherSubmission && formMethod && formAction && formEncType) {
+      submission = getSubmissionFromNavigation(state.navigation);
+    }
+    // If this was a 307/308 submission we want to preserve the HTTP method and
+    // re-submit the GET/POST/PUT/PATCH/DELETE as a submission navigation to the
+    // redirected location
+    let activeSubmission = submission || fetcherSubmission;
+    if (redirectPreserveMethodStatusCodes.has(redirect.response.status) && activeSubmission && isMutationMethod(activeSubmission.formMethod)) {
+      await startNavigation(redirectHistoryAction, redirectLocation, {
+        submission: _extends({}, activeSubmission, {
+          formAction: location
+        }),
+        // Preserve these flags across redirects
+        preventScrollReset: preventScrollReset || pendingPreventScrollReset,
+        enableViewTransition: isNavigation ? pendingViewTransitionEnabled : undefined
+      });
+    } else {
+      // If we have a navigation submission, we will preserve it through the
+      // redirect navigation
+      let overrideNavigation = getLoadingNavigation(redirectLocation, submission);
+      await startNavigation(redirectHistoryAction, redirectLocation, {
+        overrideNavigation,
+        // Send fetcher submissions through for shouldRevalidate
+        fetcherSubmission,
+        // Preserve these flags across redirects
+        preventScrollReset: preventScrollReset || pendingPreventScrollReset,
+        enableViewTransition: isNavigation ? pendingViewTransitionEnabled : undefined
+      });
+    }
+  }
+  // Utility wrapper for calling dataStrategy client-side without having to
+  // pass around the manifest, mapRouteProperties, etc.
+  async function callDataStrategy(type, state, request, matchesToLoad, matches, fetcherKey) {
+    let results;
+    let dataResults = {};
+    try {
+      results = await callDataStrategyImpl(dataStrategyImpl, type, state, request, matchesToLoad, matches, fetcherKey, manifest, mapRouteProperties);
+    } catch (e) {
+      // If the outer dataStrategy method throws, just return the error for all
+      // matches - and it'll naturally bubble to the root
+      matchesToLoad.forEach(m => {
+        dataResults[m.route.id] = {
+          type: ResultType.error,
+          error: e
+        };
+      });
+      return dataResults;
+    }
+    for (let [routeId, result] of Object.entries(results)) {
+      if (isRedirectDataStrategyResultResult(result)) {
+        let response = result.result;
+        dataResults[routeId] = {
+          type: ResultType.redirect,
+          response: normalizeRelativeRoutingRedirectResponse(response, request, routeId, matches, basename, future.v7_relativeSplatPath)
+        };
+      } else {
+        dataResults[routeId] = await convertDataStrategyResultToDataResult(result);
+      }
+    }
+    return dataResults;
+  }
+  async function callLoadersAndMaybeResolveData(state, matches, matchesToLoad, fetchersToLoad, request) {
+    let currentMatches = state.matches;
+    // Kick off loaders and fetchers in parallel
+    let loaderResultsPromise = callDataStrategy("loader", state, request, matchesToLoad, matches, null);
+    let fetcherResultsPromise = Promise.all(fetchersToLoad.map(async f => {
+      if (f.matches && f.match && f.controller) {
+        let results = await callDataStrategy("loader", state, createClientSideRequest(init.history, f.path, f.controller.signal), [f.match], f.matches, f.key);
+        let result = results[f.match.route.id];
+        // Fetcher results are keyed by fetcher key from here on out, not routeId
+        return {
+          [f.key]: result
+        };
+      } else {
+        return Promise.resolve({
+          [f.key]: {
+            type: ResultType.error,
+            error: getInternalRouterError(404, {
+              pathname: f.path
+            })
+          }
+        });
+      }
+    }));
+    let loaderResults = await loaderResultsPromise;
+    let fetcherResults = (await fetcherResultsPromise).reduce((acc, r) => Object.assign(acc, r), {});
+    await Promise.all([resolveNavigationDeferredResults(matches, loaderResults, request.signal, currentMatches, state.loaderData), resolveFetcherDeferredResults(matches, fetcherResults, fetchersToLoad)]);
+    return {
+      loaderResults,
+      fetcherResults
+    };
+  }
+  function interruptActiveLoads() {
+    // Every interruption triggers a revalidation
+    isRevalidationRequired = true;
+    // Cancel pending route-level deferreds and mark cancelled routes for
+    // revalidation
+    cancelledDeferredRoutes.push(...cancelActiveDeferreds());
+    // Abort in-flight fetcher loads
+    fetchLoadMatches.forEach((_, key) => {
+      if (fetchControllers.has(key)) {
+        cancelledFetcherLoads.add(key);
+      }
+      abortFetcher(key);
+    });
+  }
+  function updateFetcherState(key, fetcher, opts) {
+    if (opts === void 0) {
+      opts = {};
+    }
+    state.fetchers.set(key, fetcher);
+    updateState({
+      fetchers: new Map(state.fetchers)
+    }, {
+      flushSync: (opts && opts.flushSync) === true
+    });
+  }
+  function setFetcherError(key, routeId, error, opts) {
+    if (opts === void 0) {
+      opts = {};
+    }
+    let boundaryMatch = findNearestBoundary(state.matches, routeId);
+    deleteFetcher(key);
+    updateState({
+      errors: {
+        [boundaryMatch.route.id]: error
+      },
+      fetchers: new Map(state.fetchers)
+    }, {
+      flushSync: (opts && opts.flushSync) === true
+    });
+  }
+  function getFetcher(key) {
+    activeFetchers.set(key, (activeFetchers.get(key) || 0) + 1);
+    // If this fetcher was previously marked for deletion, unmark it since we
+    // have a new instance
+    if (deletedFetchers.has(key)) {
+      deletedFetchers.delete(key);
+    }
+    return state.fetchers.get(key) || IDLE_FETCHER;
+  }
+  function deleteFetcher(key) {
+    let fetcher = state.fetchers.get(key);
+    // Don't abort the controller if this is a deletion of a fetcher.submit()
+    // in it's loading phase since - we don't want to abort the corresponding
+    // revalidation and want them to complete and land
+    if (fetchControllers.has(key) && !(fetcher && fetcher.state === "loading" && fetchReloadIds.has(key))) {
+      abortFetcher(key);
+    }
+    fetchLoadMatches.delete(key);
+    fetchReloadIds.delete(key);
+    fetchRedirectIds.delete(key);
+    // If we opted into the flag we can clear this now since we're calling
+    // deleteFetcher() at the end of updateState() and we've already handed the
+    // deleted fetcher keys off to the data layer.
+    // If not, we're eagerly calling deleteFetcher() and we need to keep this
+    // Set populated until the next updateState call, and we'll clear
+    // `deletedFetchers` then
+    if (future.v7_fetcherPersist) {
+      deletedFetchers.delete(key);
+    }
+    cancelledFetcherLoads.delete(key);
+    state.fetchers.delete(key);
+  }
+  function deleteFetcherAndUpdateState(key) {
+    let count = (activeFetchers.get(key) || 0) - 1;
+    if (count <= 0) {
+      activeFetchers.delete(key);
+      deletedFetchers.add(key);
+      if (!future.v7_fetcherPersist) {
+        deleteFetcher(key);
+      }
+    } else {
+      activeFetchers.set(key, count);
+    }
+    updateState({
+      fetchers: new Map(state.fetchers)
+    });
+  }
+  function abortFetcher(key) {
+    let controller = fetchControllers.get(key);
+    if (controller) {
+      controller.abort();
+      fetchControllers.delete(key);
+    }
+  }
+  function markFetchersDone(keys) {
+    for (let key of keys) {
+      let fetcher = getFetcher(key);
+      let doneFetcher = getDoneFetcher(fetcher.data);
+      state.fetchers.set(key, doneFetcher);
+    }
+  }
+  function markFetchRedirectsDone() {
+    let doneKeys = [];
+    let updatedFetchers = false;
+    for (let key of fetchRedirectIds) {
+      let fetcher = state.fetchers.get(key);
+      invariant(fetcher, "Expected fetcher: " + key);
+      if (fetcher.state === "loading") {
+        fetchRedirectIds.delete(key);
+        doneKeys.push(key);
+        updatedFetchers = true;
+      }
+    }
+    markFetchersDone(doneKeys);
+    return updatedFetchers;
+  }
+  function abortStaleFetchLoads(landedId) {
+    let yeetedKeys = [];
+    for (let [key, id] of fetchReloadIds) {
+      if (id < landedId) {
+        let fetcher = state.fetchers.get(key);
+        invariant(fetcher, "Expected fetcher: " + key);
+        if (fetcher.state === "loading") {
+          abortFetcher(key);
+          fetchReloadIds.delete(key);
+          yeetedKeys.push(key);
+        }
+      }
+    }
+    markFetchersDone(yeetedKeys);
+    return yeetedKeys.length > 0;
+  }
+  function getBlocker(key, fn) {
+    let blocker = state.blockers.get(key) || IDLE_BLOCKER;
+    if (blockerFunctions.get(key) !== fn) {
+      blockerFunctions.set(key, fn);
+    }
+    return blocker;
+  }
+  function deleteBlocker(key) {
+    state.blockers.delete(key);
+    blockerFunctions.delete(key);
+  }
+  // Utility function to update blockers, ensuring valid state transitions
+  function updateBlocker(key, newBlocker) {
+    let blocker = state.blockers.get(key) || IDLE_BLOCKER;
+    // Poor mans state machine :)
+    // https://mermaid.live/edit#pako:eNqVkc9OwzAMxl8l8nnjAYrEtDIOHEBIgwvKJTReGy3_lDpIqO27k6awMG0XcrLlnz87nwdonESogKXXBuE79rq75XZO3-yHds0RJVuv70YrPlUrCEe2HfrORS3rubqZfuhtpg5C9wk5tZ4VKcRUq88q9Z8RS0-48cE1iHJkL0ugbHuFLus9L6spZy8nX9MP2CNdomVaposqu3fGayT8T8-jJQwhepo_UtpgBQaDEUom04dZhAN1aJBDlUKJBxE1ceB2Smj0Mln-IBW5AFU2dwUiktt_2Qaq2dBfaKdEup85UV7Yd-dKjlnkabl2Pvr0DTkTreM
+    invariant(blocker.state === "unblocked" && newBlocker.state === "blocked" || blocker.state === "blocked" && newBlocker.state === "blocked" || blocker.state === "blocked" && newBlocker.state === "proceeding" || blocker.state === "blocked" && newBlocker.state === "unblocked" || blocker.state === "proceeding" && newBlocker.state === "unblocked", "Invalid blocker state transition: " + blocker.state + " -> " + newBlocker.state);
+    let blockers = new Map(state.blockers);
+    blockers.set(key, newBlocker);
+    updateState({
+      blockers
+    });
+  }
+  function shouldBlockNavigation(_ref2) {
+    let {
+      currentLocation,
+      nextLocation,
+      historyAction
+    } = _ref2;
+    if (blockerFunctions.size === 0) {
+      return;
+    }
+    // We ony support a single active blocker at the moment since we don't have
+    // any compelling use cases for multi-blocker yet
+    if (blockerFunctions.size > 1) {
+      warning(false, "A router only supports one blocker at a time");
+    }
+    let entries = Array.from(blockerFunctions.entries());
+    let [blockerKey, blockerFunction] = entries[entries.length - 1];
+    let blocker = state.blockers.get(blockerKey);
+    if (blocker && blocker.state === "proceeding") {
+      // If the blocker is currently proceeding, we don't need to re-check
+      // it and can let this navigation continue
+      return;
+    }
+    // At this point, we know we're unblocked/blocked so we need to check the
+    // user-provided blocker function
+    if (blockerFunction({
+      currentLocation,
+      nextLocation,
+      historyAction
+    })) {
+      return blockerKey;
+    }
+  }
+  function handleNavigational404(pathname) {
+    let error = getInternalRouterError(404, {
+      pathname
+    });
+    let routesToUse = inFlightDataRoutes || dataRoutes;
+    let {
+      matches,
+      route
+    } = getShortCircuitMatches(routesToUse);
+    // Cancel all pending deferred on 404s since we don't keep any routes
+    cancelActiveDeferreds();
+    return {
+      notFoundMatches: matches,
+      route,
+      error
+    };
+  }
+  function cancelActiveDeferreds(predicate) {
+    let cancelledRouteIds = [];
+    activeDeferreds.forEach((dfd, routeId) => {
+      if (!predicate || predicate(routeId)) {
+        // Cancel the deferred - but do not remove from activeDeferreds here -
+        // we rely on the subscribers to do that so our tests can assert proper
+        // cleanup via _internalActiveDeferreds
+        dfd.cancel();
+        cancelledRouteIds.push(routeId);
+        activeDeferreds.delete(routeId);
+      }
+    });
+    return cancelledRouteIds;
+  }
+  // Opt in to capturing and reporting scroll positions during navigations,
+  // used by the <ScrollRestoration> component
+  function enableScrollRestoration(positions, getPosition, getKey) {
+    savedScrollPositions = positions;
+    getScrollPosition = getPosition;
+    getScrollRestorationKey = getKey || null;
+    // Perform initial hydration scroll restoration, since we miss the boat on
+    // the initial updateState() because we've not yet rendered <ScrollRestoration/>
+    // and therefore have no savedScrollPositions available
+    if (!initialScrollRestored && state.navigation === IDLE_NAVIGATION) {
+      initialScrollRestored = true;
+      let y = getSavedScrollPosition(state.location, state.matches);
+      if (y != null) {
+        updateState({
+          restoreScrollPosition: y
+        });
+      }
+    }
+    return () => {
+      savedScrollPositions = null;
+      getScrollPosition = null;
+      getScrollRestorationKey = null;
+    };
+  }
+  function getScrollKey(location, matches) {
+    if (getScrollRestorationKey) {
+      let key = getScrollRestorationKey(location, matches.map(m => convertRouteMatchToUiMatch(m, state.loaderData)));
+      return key || location.key;
+    }
+    return location.key;
+  }
+  function saveScrollPosition(location, matches) {
+    if (savedScrollPositions && getScrollPosition) {
+      let key = getScrollKey(location, matches);
+      savedScrollPositions[key] = getScrollPosition();
+    }
+  }
+  function getSavedScrollPosition(location, matches) {
+    if (savedScrollPositions) {
+      let key = getScrollKey(location, matches);
+      let y = savedScrollPositions[key];
+      if (typeof y === "number") {
+        return y;
+      }
+    }
+    return null;
+  }
+  function checkFogOfWar(matches, routesToUse, pathname) {
+    if (patchRoutesOnNavigationImpl) {
+      if (!matches) {
+        let fogMatches = matchRoutesImpl(routesToUse, pathname, basename, true);
+        return {
+          active: true,
+          matches: fogMatches || []
+        };
+      } else {
+        if (Object.keys(matches[0].params).length > 0) {
+          // If we matched a dynamic param or a splat, it might only be because
+          // we haven't yet discovered other routes that would match with a
+          // higher score.  Call patchRoutesOnNavigation just to be sure
+          let partialMatches = matchRoutesImpl(routesToUse, pathname, basename, true);
+          return {
+            active: true,
+            matches: partialMatches
+          };
+        }
+      }
+    }
+    return {
+      active: false,
+      matches: null
+    };
+  }
+  async function discoverRoutes(matches, pathname, signal, fetcherKey) {
+    if (!patchRoutesOnNavigationImpl) {
+      return {
+        type: "success",
+        matches
+      };
+    }
+    let partialMatches = matches;
+    while (true) {
+      let isNonHMR = inFlightDataRoutes == null;
+      let routesToUse = inFlightDataRoutes || dataRoutes;
+      let localManifest = manifest;
+      try {
+        await patchRoutesOnNavigationImpl({
+          signal,
+          path: pathname,
+          matches: partialMatches,
+          fetcherKey,
+          patch: (routeId, children) => {
+            if (signal.aborted) return;
+            patchRoutesImpl(routeId, children, routesToUse, localManifest, mapRouteProperties);
+          }
+        });
+      } catch (e) {
+        return {
+          type: "error",
+          error: e,
+          partialMatches
+        };
+      } finally {
+        // If we are not in the middle of an HMR revalidation and we changed the
+        // routes, provide a new identity so when we `updateState` at the end of
+        // this navigation/fetch `router.routes` will be a new identity and
+        // trigger a re-run of memoized `router.routes` dependencies.
+        // HMR will already update the identity and reflow when it lands
+        // `inFlightDataRoutes` in `completeNavigation`
+        if (isNonHMR && !signal.aborted) {
+          dataRoutes = [...dataRoutes];
+        }
+      }
+      if (signal.aborted) {
+        return {
+          type: "aborted"
+        };
+      }
+      let newMatches = matchRoutes(routesToUse, pathname, basename);
+      if (newMatches) {
+        return {
+          type: "success",
+          matches: newMatches
+        };
+      }
+      let newPartialMatches = matchRoutesImpl(routesToUse, pathname, basename, true);
+      // Avoid loops if the second pass results in the same partial matches
+      if (!newPartialMatches || partialMatches.length === newPartialMatches.length && partialMatches.every((m, i) => m.route.id === newPartialMatches[i].route.id)) {
+        return {
+          type: "success",
+          matches: null
+        };
+      }
+      partialMatches = newPartialMatches;
+    }
+  }
+  function _internalSetRoutes(newRoutes) {
+    manifest = {};
+    inFlightDataRoutes = convertRoutesToDataRoutes(newRoutes, mapRouteProperties, undefined, manifest);
+  }
+  function patchRoutes(routeId, children) {
+    let isNonHMR = inFlightDataRoutes == null;
+    let routesToUse = inFlightDataRoutes || dataRoutes;
+    patchRoutesImpl(routeId, children, routesToUse, manifest, mapRouteProperties);
+    // If we are not in the middle of an HMR revalidation and we changed the
+    // routes, provide a new identity and trigger a reflow via `updateState`
+    // to re-run memoized `router.routes` dependencies.
+    // HMR will already update the identity and reflow when it lands
+    // `inFlightDataRoutes` in `completeNavigation`
+    if (isNonHMR) {
+      dataRoutes = [...dataRoutes];
+      updateState({});
+    }
+  }
+  router = {
+    get basename() {
+      return basename;
+    },
+    get future() {
+      return future;
+    },
+    get state() {
+      return state;
+    },
+    get routes() {
+      return dataRoutes;
+    },
+    get window() {
+      return routerWindow;
+    },
+    initialize,
+    subscribe,
+    enableScrollRestoration,
+    navigate,
+    fetch,
+    revalidate,
+    // Passthrough to history-aware createHref used by useHref so we get proper
+    // hash-aware URLs in DOM paths
+    createHref: to => init.history.createHref(to),
+    encodeLocation: to => init.history.encodeLocation(to),
+    getFetcher,
+    deleteFetcher: deleteFetcherAndUpdateState,
+    dispose,
+    getBlocker,
+    deleteBlocker,
+    patchRoutes,
+    _internalFetchControllers: fetchControllers,
+    _internalActiveDeferreds: activeDeferreds,
+    // TODO: Remove setRoutes, it's temporary to avoid dealing with
+    // updating the tree while validating the update algorithm.
+    _internalSetRoutes
+  };
+  return router;
+}
+//#endregion
+////////////////////////////////////////////////////////////////////////////////
+//#region createStaticHandler
+////////////////////////////////////////////////////////////////////////////////
+const UNSAFE_DEFERRED_SYMBOL = Symbol("deferred");
+function createStaticHandler(routes, opts) {
+  invariant(routes.length > 0, "You must provide a non-empty routes array to createStaticHandler");
+  let manifest = {};
+  let basename = (opts ? opts.basename : null) || "/";
+  let mapRouteProperties;
+  if (opts != null && opts.mapRouteProperties) {
+    mapRouteProperties = opts.mapRouteProperties;
+  } else if (opts != null && opts.detectErrorBoundary) {
+    // If they are still using the deprecated version, wrap it with the new API
+    let detectErrorBoundary = opts.detectErrorBoundary;
+    mapRouteProperties = route => ({
+      hasErrorBoundary: detectErrorBoundary(route)
+    });
+  } else {
+    mapRouteProperties = defaultMapRouteProperties;
+  }
+  // Config driven behavior flags
+  let future = _extends({
+    v7_relativeSplatPath: false,
+    v7_throwAbortReason: false
+  }, opts ? opts.future : null);
+  let dataRoutes = convertRoutesToDataRoutes(routes, mapRouteProperties, undefined, manifest);
+  /**
+   * The query() method is intended for document requests, in which we want to
+   * call an optional action and potentially multiple loaders for all nested
+   * routes.  It returns a StaticHandlerContext object, which is very similar
+   * to the router state (location, loaderData, actionData, errors, etc.) and
+   * also adds SSR-specific information such as the statusCode and headers
+   * from action/loaders Responses.
+   *
+   * It _should_ never throw and should report all errors through the
+   * returned context.errors object, properly associating errors to their error
+   * boundary.  Additionally, it tracks _deepestRenderedBoundaryId which can be
+   * used to emulate React error boundaries during SSr by performing a second
+   * pass only down to the boundaryId.
+   *
+   * The one exception where we do not return a StaticHandlerContext is when a
+   * redirect response is returned or thrown from any action/loader.  We
+   * propagate that out and return the raw Response so the HTTP server can
+   * return it directly.
+   *
+   * - `opts.requestContext` is an optional server context that will be passed
+   *   to actions/loaders in the `context` parameter
+   * - `opts.skipLoaderErrorBubbling` is an optional parameter that will prevent
+   *   the bubbling of errors which allows single-fetch-type implementations
+   *   where the client will handle the bubbling and we may need to return data
+   *   for the handling route
+   */
+  async function query(request, _temp3) {
+    let {
+      requestContext,
+      skipLoaderErrorBubbling,
+      dataStrategy
+    } = _temp3 === void 0 ? {} : _temp3;
+    let url = new URL(request.url);
+    let method = request.method;
+    let location = createLocation("", createPath(url), null, "default");
+    let matches = matchRoutes(dataRoutes, location, basename);
+    // SSR supports HEAD requests while SPA doesn't
+    if (!isValidMethod(method) && method !== "HEAD") {
+      let error = getInternalRouterError(405, {
+        method
+      });
+      let {
+        matches: methodNotAllowedMatches,
+        route
+      } = getShortCircuitMatches(dataRoutes);
+      return {
+        basename,
+        location,
+        matches: methodNotAllowedMatches,
+        loaderData: {},
+        actionData: null,
+        errors: {
+          [route.id]: error
+        },
+        statusCode: error.status,
+        loaderHeaders: {},
+        actionHeaders: {},
+        activeDeferreds: null
+      };
+    } else if (!matches) {
+      let error = getInternalRouterError(404, {
+        pathname: location.pathname
+      });
+      let {
+        matches: notFoundMatches,
+        route
+      } = getShortCircuitMatches(dataRoutes);
+      return {
+        basename,
+        location,
+        matches: notFoundMatches,
+        loaderData: {},
+        actionData: null,
+        errors: {
+          [route.id]: error
+        },
+        statusCode: error.status,
+        loaderHeaders: {},
+        actionHeaders: {},
+        activeDeferreds: null
+      };
+    }
+    let result = await queryImpl(request, location, matches, requestContext, dataStrategy || null, skipLoaderErrorBubbling === true, null);
+    if (isResponse(result)) {
+      return result;
+    }
+    // When returning StaticHandlerContext, we patch back in the location here
+    // since we need it for React Context.  But this helps keep our submit and
+    // loadRouteData operating on a Request instead of a Location
+    return _extends({
+      location,
+      basename
+    }, result);
+  }
+  /**
+   * The queryRoute() method is intended for targeted route requests, either
+   * for fetch ?_data requests or resource route requests.  In this case, we
+   * are only ever calling a single action or loader, and we are returning the
+   * returned value directly.  In most cases, this will be a Response returned
+   * from the action/loader, but it may be a primitive or other value as well -
+   * and in such cases the calling context should handle that accordingly.
+   *
+   * We do respect the throw/return differentiation, so if an action/loader
+   * throws, then this method will throw the value.  This is important so we
+   * can do proper boundary identification in Remix where a thrown Response
+   * must go to the Catch Boundary but a returned Response is happy-path.
+   *
+   * One thing to note is that any Router-initiated Errors that make sense
+   * to associate with a status code will be thrown as an ErrorResponse
+   * instance which include the raw Error, such that the calling context can
+   * serialize the error as they see fit while including the proper response
+   * code.  Examples here are 404 and 405 errors that occur prior to reaching
+   * any user-defined loaders.
+   *
+   * - `opts.routeId` allows you to specify the specific route handler to call.
+   *   If not provided the handler will determine the proper route by matching
+   *   against `request.url`
+   * - `opts.requestContext` is an optional server context that will be passed
+   *    to actions/loaders in the `context` parameter
+   */
+  async function queryRoute(request, _temp4) {
+    let {
+      routeId,
+      requestContext,
+      dataStrategy
+    } = _temp4 === void 0 ? {} : _temp4;
+    let url = new URL(request.url);
+    let method = request.method;
+    let location = createLocation("", createPath(url), null, "default");
+    let matches = matchRoutes(dataRoutes, location, basename);
+    // SSR supports HEAD requests while SPA doesn't
+    if (!isValidMethod(method) && method !== "HEAD" && method !== "OPTIONS") {
+      throw getInternalRouterError(405, {
+        method
+      });
+    } else if (!matches) {
+      throw getInternalRouterError(404, {
+        pathname: location.pathname
+      });
+    }
+    let match = routeId ? matches.find(m => m.route.id === routeId) : getTargetMatch(matches, location);
+    if (routeId && !match) {
+      throw getInternalRouterError(403, {
+        pathname: location.pathname,
+        routeId
+      });
+    } else if (!match) {
+      // This should never hit I don't think?
+      throw getInternalRouterError(404, {
+        pathname: location.pathname
+      });
+    }
+    let result = await queryImpl(request, location, matches, requestContext, dataStrategy || null, false, match);
+    if (isResponse(result)) {
+      return result;
+    }
+    let error = result.errors ? Object.values(result.errors)[0] : undefined;
+    if (error !== undefined) {
+      // If we got back result.errors, that means the loader/action threw
+      // _something_ that wasn't a Response, but it's not guaranteed/required
+      // to be an `instanceof Error` either, so we have to use throw here to
+      // preserve the "error" state outside of queryImpl.
+      throw error;
+    }
+    // Pick off the right state value to return
+    if (result.actionData) {
+      return Object.values(result.actionData)[0];
+    }
+    if (result.loaderData) {
+      var _result$activeDeferre;
+      let data = Object.values(result.loaderData)[0];
+      if ((_result$activeDeferre = result.activeDeferreds) != null && _result$activeDeferre[match.route.id]) {
+        data[UNSAFE_DEFERRED_SYMBOL] = result.activeDeferreds[match.route.id];
+      }
+      return data;
+    }
+    return undefined;
+  }
+  async function queryImpl(request, location, matches, requestContext, dataStrategy, skipLoaderErrorBubbling, routeMatch) {
+    invariant(request.signal, "query()/queryRoute() requests must contain an AbortController signal");
+    try {
+      if (isMutationMethod(request.method.toLowerCase())) {
+        let result = await submit(request, matches, routeMatch || getTargetMatch(matches, location), requestContext, dataStrategy, skipLoaderErrorBubbling, routeMatch != null);
+        return result;
+      }
+      let result = await loadRouteData(request, matches, requestContext, dataStrategy, skipLoaderErrorBubbling, routeMatch);
+      return isResponse(result) ? result : _extends({}, result, {
+        actionData: null,
+        actionHeaders: {}
+      });
+    } catch (e) {
+      // If the user threw/returned a Response in callLoaderOrAction for a
+      // `queryRoute` call, we throw the `DataStrategyResult` to bail out early
+      // and then return or throw the raw Response here accordingly
+      if (isDataStrategyResult(e) && isResponse(e.result)) {
+        if (e.type === ResultType.error) {
+          throw e.result;
+        }
+        return e.result;
+      }
+      // Redirects are always returned since they don't propagate to catch
+      // boundaries
+      if (isRedirectResponse(e)) {
+        return e;
+      }
+      throw e;
+    }
+  }
+  async function submit(request, matches, actionMatch, requestContext, dataStrategy, skipLoaderErrorBubbling, isRouteRequest) {
+    let result;
+    if (!actionMatch.route.action && !actionMatch.route.lazy) {
+      let error = getInternalRouterError(405, {
+        method: request.method,
+        pathname: new URL(request.url).pathname,
+        routeId: actionMatch.route.id
+      });
+      if (isRouteRequest) {
+        throw error;
+      }
+      result = {
+        type: ResultType.error,
+        error
+      };
+    } else {
+      let results = await callDataStrategy("action", request, [actionMatch], matches, isRouteRequest, requestContext, dataStrategy);
+      result = results[actionMatch.route.id];
+      if (request.signal.aborted) {
+        throwStaticHandlerAbortedError(request, isRouteRequest, future);
+      }
+    }
+    if (isRedirectResult(result)) {
+      // Uhhhh - this should never happen, we should always throw these from
+      // callLoaderOrAction, but the type narrowing here keeps TS happy and we
+      // can get back on the "throw all redirect responses" train here should
+      // this ever happen :/
+      throw new Response(null, {
+        status: result.response.status,
+        headers: {
+          Location: result.response.headers.get("Location")
+        }
+      });
+    }
+    if (isDeferredResult(result)) {
+      let error = getInternalRouterError(400, {
+        type: "defer-action"
+      });
+      if (isRouteRequest) {
+        throw error;
+      }
+      result = {
+        type: ResultType.error,
+        error
+      };
+    }
+    if (isRouteRequest) {
+      // Note: This should only be non-Response values if we get here, since
+      // isRouteRequest should throw any Response received in callLoaderOrAction
+      if (isErrorResult(result)) {
+        throw result.error;
+      }
+      return {
+        matches: [actionMatch],
+        loaderData: {},
+        actionData: {
+          [actionMatch.route.id]: result.data
+        },
+        errors: null,
+        // Note: statusCode + headers are unused here since queryRoute will
+        // return the raw Response or value
+        statusCode: 200,
+        loaderHeaders: {},
+        actionHeaders: {},
+        activeDeferreds: null
+      };
+    }
+    // Create a GET request for the loaders
+    let loaderRequest = new Request(request.url, {
+      headers: request.headers,
+      redirect: request.redirect,
+      signal: request.signal
+    });
+    if (isErrorResult(result)) {
+      // Store off the pending error - we use it to determine which loaders
+      // to call and will commit it when we complete the navigation
+      let boundaryMatch = skipLoaderErrorBubbling ? actionMatch : findNearestBoundary(matches, actionMatch.route.id);
+      let context = await loadRouteData(loaderRequest, matches, requestContext, dataStrategy, skipLoaderErrorBubbling, null, [boundaryMatch.route.id, result]);
+      // action status codes take precedence over loader status codes
+      return _extends({}, context, {
+        statusCode: isRouteErrorResponse(result.error) ? result.error.status : result.statusCode != null ? result.statusCode : 500,
+        actionData: null,
+        actionHeaders: _extends({}, result.headers ? {
+          [actionMatch.route.id]: result.headers
+        } : {})
+      });
+    }
+    let context = await loadRouteData(loaderRequest, matches, requestContext, dataStrategy, skipLoaderErrorBubbling, null);
+    return _extends({}, context, {
+      actionData: {
+        [actionMatch.route.id]: result.data
+      }
+    }, result.statusCode ? {
+      statusCode: result.statusCode
+    } : {}, {
+      actionHeaders: result.headers ? {
+        [actionMatch.route.id]: result.headers
+      } : {}
+    });
+  }
+  async function loadRouteData(request, matches, requestContext, dataStrategy, skipLoaderErrorBubbling, routeMatch, pendingActionResult) {
+    let isRouteRequest = routeMatch != null;
+    // Short circuit if we have no loaders to run (queryRoute())
+    if (isRouteRequest && !(routeMatch != null && routeMatch.route.loader) && !(routeMatch != null && routeMatch.route.lazy)) {
+      throw getInternalRouterError(400, {
+        method: request.method,
+        pathname: new URL(request.url).pathname,
+        routeId: routeMatch == null ? void 0 : routeMatch.route.id
+      });
+    }
+    let requestMatches = routeMatch ? [routeMatch] : pendingActionResult && isErrorResult(pendingActionResult[1]) ? getLoaderMatchesUntilBoundary(matches, pendingActionResult[0]) : matches;
+    let matchesToLoad = requestMatches.filter(m => m.route.loader || m.route.lazy);
+    // Short circuit if we have no loaders to run (query())
+    if (matchesToLoad.length === 0) {
+      return {
+        matches,
+        // Add a null for all matched routes for proper revalidation on the client
+        loaderData: matches.reduce((acc, m) => Object.assign(acc, {
+          [m.route.id]: null
+        }), {}),
+        errors: pendingActionResult && isErrorResult(pendingActionResult[1]) ? {
+          [pendingActionResult[0]]: pendingActionResult[1].error
+        } : null,
+        statusCode: 200,
+        loaderHeaders: {},
+        activeDeferreds: null
+      };
+    }
+    let results = await callDataStrategy("loader", request, matchesToLoad, matches, isRouteRequest, requestContext, dataStrategy);
+    if (request.signal.aborted) {
+      throwStaticHandlerAbortedError(request, isRouteRequest, future);
+    }
+    // Process and commit output from loaders
+    let activeDeferreds = new Map();
+    let context = processRouteLoaderData(matches, results, pendingActionResult, activeDeferreds, skipLoaderErrorBubbling);
+    // Add a null for any non-loader matches for proper revalidation on the client
+    let executedLoaders = new Set(matchesToLoad.map(match => match.route.id));
+    matches.forEach(match => {
+      if (!executedLoaders.has(match.route.id)) {
+        context.loaderData[match.route.id] = null;
+      }
+    });
+    return _extends({}, context, {
+      matches,
+      activeDeferreds: activeDeferreds.size > 0 ? Object.fromEntries(activeDeferreds.entries()) : null
+    });
+  }
+  // Utility wrapper for calling dataStrategy server-side without having to
+  // pass around the manifest, mapRouteProperties, etc.
+  async function callDataStrategy(type, request, matchesToLoad, matches, isRouteRequest, requestContext, dataStrategy) {
+    let results = await callDataStrategyImpl(dataStrategy || defaultDataStrategy, type, null, request, matchesToLoad, matches, null, manifest, mapRouteProperties, requestContext);
+    let dataResults = {};
+    await Promise.all(matches.map(async match => {
+      if (!(match.route.id in results)) {
+        return;
+      }
+      let result = results[match.route.id];
+      if (isRedirectDataStrategyResultResult(result)) {
+        let response = result.result;
+        // Throw redirects and let the server handle them with an HTTP redirect
+        throw normalizeRelativeRoutingRedirectResponse(response, request, match.route.id, matches, basename, future.v7_relativeSplatPath);
+      }
+      if (isResponse(result.result) && isRouteRequest) {
+        // For SSR single-route requests, we want to hand Responses back
+        // directly without unwrapping
+        throw result;
+      }
+      dataResults[match.route.id] = await convertDataStrategyResultToDataResult(result);
+    }));
+    return dataResults;
+  }
+  return {
+    dataRoutes,
+    query,
+    queryRoute
+  };
+}
+//#endregion
+////////////////////////////////////////////////////////////////////////////////
+//#region Helpers
+////////////////////////////////////////////////////////////////////////////////
+/**
+ * Given an existing StaticHandlerContext and an error thrown at render time,
+ * provide an updated StaticHandlerContext suitable for a second SSR render
+ */
+function getStaticContextFromError(routes, context, error) {
+  let newContext = _extends({}, context, {
+    statusCode: isRouteErrorResponse(error) ? error.status : 500,
+    errors: {
+      [context._deepestRenderedBoundaryId || routes[0].id]: error
+    }
+  });
+  return newContext;
+}
+function throwStaticHandlerAbortedError(request, isRouteRequest, future) {
+  if (future.v7_throwAbortReason && request.signal.reason !== undefined) {
+    throw request.signal.reason;
+  }
+  let method = isRouteRequest ? "queryRoute" : "query";
+  throw new Error(method + "() call aborted: " + request.method + " " + request.url);
+}
+function isSubmissionNavigation(opts) {
+  return opts != null && ("formData" in opts && opts.formData != null || "body" in opts && opts.body !== undefined);
+}
+function normalizeTo(location, matches, basename, prependBasename, to, v7_relativeSplatPath, fromRouteId, relative) {
+  let contextualMatches;
+  let activeRouteMatch;
+  if (fromRouteId) {
+    // Grab matches up to the calling route so our route-relative logic is
+    // relative to the correct source route
+    contextualMatches = [];
+    for (let match of matches) {
+      contextualMatches.push(match);
+      if (match.route.id === fromRouteId) {
+        activeRouteMatch = match;
+        break;
+      }
+    }
+  } else {
+    contextualMatches = matches;
+    activeRouteMatch = matches[matches.length - 1];
+  }
+  // Resolve the relative path
+  let path = resolveTo(to ? to : ".", getResolveToMatches(contextualMatches, v7_relativeSplatPath), stripBasename(location.pathname, basename) || location.pathname, relative === "path");
+  // When `to` is not specified we inherit search/hash from the current
+  // location, unlike when to="." and we just inherit the path.
+  // See https://github.com/remix-run/remix/issues/927
+  if (to == null) {
+    path.search = location.search;
+    path.hash = location.hash;
+  }
+  // Account for `?index` params when routing to the current location
+  if ((to == null || to === "" || to === ".") && activeRouteMatch) {
+    let nakedIndex = hasNakedIndexQuery(path.search);
+    if (activeRouteMatch.route.index && !nakedIndex) {
+      // Add one when we're targeting an index route
+      path.search = path.search ? path.search.replace(/^\?/, "?index&") : "?index";
+    } else if (!activeRouteMatch.route.index && nakedIndex) {
+      // Remove existing ones when we're not
+      let params = new URLSearchParams(path.search);
+      let indexValues = params.getAll("index");
+      params.delete("index");
+      indexValues.filter(v => v).forEach(v => params.append("index", v));
+      let qs = params.toString();
+      path.search = qs ? "?" + qs : "";
+    }
+  }
+  // If we're operating within a basename, prepend it to the pathname.  If
+  // this is a root navigation, then just use the raw basename which allows
+  // the basename to have full control over the presence of a trailing slash
+  // on root actions
+  if (prependBasename && basename !== "/") {
+    path.pathname = path.pathname === "/" ? basename : joinPaths([basename, path.pathname]);
+  }
+  return createPath(path);
+}
+// Normalize navigation options by converting formMethod=GET formData objects to
+// URLSearchParams so they behave identically to links with query params
+function normalizeNavigateOptions(normalizeFormMethod, isFetcher, path, opts) {
+  // Return location verbatim on non-submission navigations
+  if (!opts || !isSubmissionNavigation(opts)) {
+    return {
+      path
+    };
+  }
+  if (opts.formMethod && !isValidMethod(opts.formMethod)) {
+    return {
+      path,
+      error: getInternalRouterError(405, {
+        method: opts.formMethod
+      })
+    };
+  }
+  let getInvalidBodyError = () => ({
+    path,
+    error: getInternalRouterError(400, {
+      type: "invalid-body"
+    })
+  });
+  // Create a Submission on non-GET navigations
+  let rawFormMethod = opts.formMethod || "get";
+  let formMethod = normalizeFormMethod ? rawFormMethod.toUpperCase() : rawFormMethod.toLowerCase();
+  let formAction = stripHashFromPath(path);
+  if (opts.body !== undefined) {
+    if (opts.formEncType === "text/plain") {
+      // text only support POST/PUT/PATCH/DELETE submissions
+      if (!isMutationMethod(formMethod)) {
+        return getInvalidBodyError();
+      }
+      let text = typeof opts.body === "string" ? opts.body : opts.body instanceof FormData || opts.body instanceof URLSearchParams ?
+      // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#plain-text-form-data
+      Array.from(opts.body.entries()).reduce((acc, _ref3) => {
+        let [name, value] = _ref3;
+        return "" + acc + name + "=" + value + "\n";
+      }, "") : String(opts.body);
+      return {
+        path,
+        submission: {
+          formMethod,
+          formAction,
+          formEncType: opts.formEncType,
+          formData: undefined,
+          json: undefined,
+          text
+        }
+      };
+    } else if (opts.formEncType === "application/json") {
+      // json only supports POST/PUT/PATCH/DELETE submissions
+      if (!isMutationMethod(formMethod)) {
+        return getInvalidBodyError();
+      }
+      try {
+        let json = typeof opts.body === "string" ? JSON.parse(opts.body) : opts.body;
+        return {
+          path,
+          submission: {
+            formMethod,
+            formAction,
+            formEncType: opts.formEncType,
+            formData: undefined,
+            json,
+            text: undefined
+          }
+        };
+      } catch (e) {
+        return getInvalidBodyError();
+      }
+    }
+  }
+  invariant(typeof FormData === "function", "FormData is not available in this environment");
+  let searchParams;
+  let formData;
+  if (opts.formData) {
+    searchParams = convertFormDataToSearchParams(opts.formData);
+    formData = opts.formData;
+  } else if (opts.body instanceof FormData) {
+    searchParams = convertFormDataToSearchParams(opts.body);
+    formData = opts.body;
+  } else if (opts.body instanceof URLSearchParams) {
+    searchParams = opts.body;
+    formData = convertSearchParamsToFormData(searchParams);
+  } else if (opts.body == null) {
+    searchParams = new URLSearchParams();
+    formData = new FormData();
+  } else {
+    try {
+      searchParams = new URLSearchParams(opts.body);
+      formData = convertSearchParamsToFormData(searchParams);
+    } catch (e) {
+      return getInvalidBodyError();
+    }
+  }
+  let submission = {
+    formMethod,
+    formAction,
+    formEncType: opts && opts.formEncType || "application/x-www-form-urlencoded",
+    formData,
+    json: undefined,
+    text: undefined
+  };
+  if (isMutationMethod(submission.formMethod)) {
+    return {
+      path,
+      submission
+    };
+  }
+  // Flatten submission onto URLSearchParams for GET submissions
+  let parsedPath = parsePath(path);
+  // On GET navigation submissions we can drop the ?index param from the
+  // resulting location since all loaders will run.  But fetcher GET submissions
+  // only run a single loader so we need to preserve any incoming ?index params
+  if (isFetcher && parsedPath.search && hasNakedIndexQuery(parsedPath.search)) {
+    searchParams.append("index", "");
+  }
+  parsedPath.search = "?" + searchParams;
+  return {
+    path: createPath(parsedPath),
+    submission
+  };
+}
+// Filter out all routes at/below any caught error as they aren't going to
+// render so we don't need to load them
+function getLoaderMatchesUntilBoundary(matches, boundaryId, includeBoundary) {
+  if (includeBoundary === void 0) {
+    includeBoundary = false;
+  }
+  let index = matches.findIndex(m => m.route.id === boundaryId);
+  if (index >= 0) {
+    return matches.slice(0, includeBoundary ? index + 1 : index);
+  }
+  return matches;
+}
+function getMatchesToLoad(history, state, matches, submission, location, initialHydration, skipActionErrorRevalidation, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, deletedFetchers, fetchLoadMatches, fetchRedirectIds, routesToUse, basename, pendingActionResult) {
+  let actionResult = pendingActionResult ? isErrorResult(pendingActionResult[1]) ? pendingActionResult[1].error : pendingActionResult[1].data : undefined;
+  let currentUrl = history.createURL(state.location);
+  let nextUrl = history.createURL(location);
+  // Pick navigation matches that are net-new or qualify for revalidation
+  let boundaryMatches = matches;
+  if (initialHydration && state.errors) {
+    // On initial hydration, only consider matches up to _and including_ the boundary.
+    // This is inclusive to handle cases where a server loader ran successfully,
+    // a child server loader bubbled up to this route, but this route has
+    // `clientLoader.hydrate` so we want to still run the `clientLoader` so that
+    // we have a complete version of `loaderData`
+    boundaryMatches = getLoaderMatchesUntilBoundary(matches, Object.keys(state.errors)[0], true);
+  } else if (pendingActionResult && isErrorResult(pendingActionResult[1])) {
+    // If an action threw an error, we call loaders up to, but not including the
+    // boundary
+    boundaryMatches = getLoaderMatchesUntilBoundary(matches, pendingActionResult[0]);
+  }
+  // Don't revalidate loaders by default after action 4xx/5xx responses
+  // when the flag is enabled.  They can still opt-into revalidation via
+  // `shouldRevalidate` via `actionResult`
+  let actionStatus = pendingActionResult ? pendingActionResult[1].statusCode : undefined;
+  let shouldSkipRevalidation = skipActionErrorRevalidation && actionStatus && actionStatus >= 400;
+  let navigationMatches = boundaryMatches.filter((match, index) => {
+    let {
+      route
+    } = match;
+    if (route.lazy) {
+      // We haven't loaded this route yet so we don't know if it's got a loader!
+      return true;
+    }
+    if (route.loader == null) {
+      return false;
+    }
+    if (initialHydration) {
+      return shouldLoadRouteOnHydration(route, state.loaderData, state.errors);
+    }
+    // Always call the loader on new route instances and pending defer cancellations
+    if (isNewLoader(state.loaderData, state.matches[index], match) || cancelledDeferredRoutes.some(id => id === match.route.id)) {
+      return true;
+    }
+    // This is the default implementation for when we revalidate.  If the route
+    // provides it's own implementation, then we give them full control but
+    // provide this value so they can leverage it if needed after they check
+    // their own specific use cases
+    let currentRouteMatch = state.matches[index];
+    let nextRouteMatch = match;
+    return shouldRevalidateLoader(match, _extends({
+      currentUrl,
+      currentParams: currentRouteMatch.params,
+      nextUrl,
+      nextParams: nextRouteMatch.params
+    }, submission, {
+      actionResult,
+      actionStatus,
+      defaultShouldRevalidate: shouldSkipRevalidation ? false :
+      // Forced revalidation due to submission, useRevalidator, or X-Remix-Revalidate
+      isRevalidationRequired || currentUrl.pathname + currentUrl.search === nextUrl.pathname + nextUrl.search ||
+      // Search params affect all loaders
+      currentUrl.search !== nextUrl.search || isNewRouteInstance(currentRouteMatch, nextRouteMatch)
+    }));
+  });
+  // Pick fetcher.loads that need to be revalidated
+  let revalidatingFetchers = [];
+  fetchLoadMatches.forEach((f, key) => {
+    // Don't revalidate:
+    //  - on initial hydration (shouldn't be any fetchers then anyway)
+    //  - if fetcher won't be present in the subsequent render
+    //    - no longer matches the URL (v7_fetcherPersist=false)
+    //    - was unmounted but persisted due to v7_fetcherPersist=true
+    if (initialHydration || !matches.some(m => m.route.id === f.routeId) || deletedFetchers.has(key)) {
+      return;
+    }
+    let fetcherMatches = matchRoutes(routesToUse, f.path, basename);
+    // If the fetcher path no longer matches, push it in with null matches so
+    // we can trigger a 404 in callLoadersAndMaybeResolveData.  Note this is
+    // currently only a use-case for Remix HMR where the route tree can change
+    // at runtime and remove a route previously loaded via a fetcher
+    if (!fetcherMatches) {
+      revalidatingFetchers.push({
+        key,
+        routeId: f.routeId,
+        path: f.path,
+        matches: null,
+        match: null,
+        controller: null
+      });
+      return;
+    }
+    // Revalidating fetchers are decoupled from the route matches since they
+    // load from a static href.  They revalidate based on explicit revalidation
+    // (submission, useRevalidator, or X-Remix-Revalidate)
+    let fetcher = state.fetchers.get(key);
+    let fetcherMatch = getTargetMatch(fetcherMatches, f.path);
+    let shouldRevalidate = false;
+    if (fetchRedirectIds.has(key)) {
+      // Never trigger a revalidation of an actively redirecting fetcher
+      shouldRevalidate = false;
+    } else if (cancelledFetcherLoads.has(key)) {
+      // Always mark for revalidation if the fetcher was cancelled
+      cancelledFetcherLoads.delete(key);
+      shouldRevalidate = true;
+    } else if (fetcher && fetcher.state !== "idle" && fetcher.data === undefined) {
+      // If the fetcher hasn't ever completed loading yet, then this isn't a
+      // revalidation, it would just be a brand new load if an explicit
+      // revalidation is required
+      shouldRevalidate = isRevalidationRequired;
+    } else {
+      // Otherwise fall back on any user-defined shouldRevalidate, defaulting
+      // to explicit revalidations only
+      shouldRevalidate = shouldRevalidateLoader(fetcherMatch, _extends({
+        currentUrl,
+        currentParams: state.matches[state.matches.length - 1].params,
+        nextUrl,
+        nextParams: matches[matches.length - 1].params
+      }, submission, {
+        actionResult,
+        actionStatus,
+        defaultShouldRevalidate: shouldSkipRevalidation ? false : isRevalidationRequired
+      }));
+    }
+    if (shouldRevalidate) {
+      revalidatingFetchers.push({
+        key,
+        routeId: f.routeId,
+        path: f.path,
+        matches: fetcherMatches,
+        match: fetcherMatch,
+        controller: new AbortController()
+      });
+    }
+  });
+  return [navigationMatches, revalidatingFetchers];
+}
+function shouldLoadRouteOnHydration(route, loaderData, errors) {
+  // We dunno if we have a loader - gotta find out!
+  if (route.lazy) {
+    return true;
+  }
+  // No loader, nothing to initialize
+  if (!route.loader) {
+    return false;
+  }
+  let hasData = loaderData != null && loaderData[route.id] !== undefined;
+  let hasError = errors != null && errors[route.id] !== undefined;
+  // Don't run if we error'd during SSR
+  if (!hasData && hasError) {
+    return false;
+  }
+  // Explicitly opting-in to running on hydration
+  if (typeof route.loader === "function" && route.loader.hydrate === true) {
+    return true;
+  }
+  // Otherwise, run if we're not yet initialized with anything
+  return !hasData && !hasError;
+}
+function isNewLoader(currentLoaderData, currentMatch, match) {
+  let isNew =
+  // [a] -> [a, b]
+  !currentMatch ||
+  // [a, b] -> [a, c]
+  match.route.id !== currentMatch.route.id;
+  // Handle the case that we don't have data for a re-used route, potentially
+  // from a prior error or from a cancelled pending deferred
+  let isMissingData = currentLoaderData[match.route.id] === undefined;
+  // Always load if this is a net-new route or we don't yet have data
+  return isNew || isMissingData;
+}
+function isNewRouteInstance(currentMatch, match) {
+  let currentPath = currentMatch.route.path;
+  return (
+    // param change for this match, /users/123 -> /users/456
+    currentMatch.pathname !== match.pathname ||
+    // splat param changed, which is not present in match.path
+    // e.g. /files/images/avatar.jpg -> files/finances.xls
+    currentPath != null && currentPath.endsWith("*") && currentMatch.params["*"] !== match.params["*"]
+  );
+}
+function shouldRevalidateLoader(loaderMatch, arg) {
+  if (loaderMatch.route.shouldRevalidate) {
+    let routeChoice = loaderMatch.route.shouldRevalidate(arg);
+    if (typeof routeChoice === "boolean") {
+      return routeChoice;
+    }
+  }
+  return arg.defaultShouldRevalidate;
+}
+function patchRoutesImpl(routeId, children, routesToUse, manifest, mapRouteProperties) {
+  var _childrenToPatch;
+  let childrenToPatch;
+  if (routeId) {
+    let route = manifest[routeId];
+    invariant(route, "No route found to patch children into: routeId = " + routeId);
+    if (!route.children) {
+      route.children = [];
+    }
+    childrenToPatch = route.children;
+  } else {
+    childrenToPatch = routesToUse;
+  }
+  // Don't patch in routes we already know about so that `patch` is idempotent
+  // to simplify user-land code. This is useful because we re-call the
+  // `patchRoutesOnNavigation` function for matched routes with params.
+  let uniqueChildren = children.filter(newRoute => !childrenToPatch.some(existingRoute => isSameRoute(newRoute, existingRoute)));
+  let newRoutes = convertRoutesToDataRoutes(uniqueChildren, mapRouteProperties, [routeId || "_", "patch", String(((_childrenToPatch = childrenToPatch) == null ? void 0 : _childrenToPatch.length) || "0")], manifest);
+  childrenToPatch.push(...newRoutes);
+}
+function isSameRoute(newRoute, existingRoute) {
+  // Most optimal check is by id
+  if ("id" in newRoute && "id" in existingRoute && newRoute.id === existingRoute.id) {
+    return true;
+  }
+  // Second is by pathing differences
+  if (!(newRoute.index === existingRoute.index && newRoute.path === existingRoute.path && newRoute.caseSensitive === existingRoute.caseSensitive)) {
+    return false;
+  }
+  // Pathless layout routes are trickier since we need to check children.
+  // If they have no children then they're the same as far as we can tell
+  if ((!newRoute.children || newRoute.children.length === 0) && (!existingRoute.children || existingRoute.children.length === 0)) {
+    return true;
+  }
+  // Otherwise, we look to see if every child in the new route is already
+  // represented in the existing route's children
+  return newRoute.children.every((aChild, i) => {
+    var _existingRoute$childr;
+    return (_existingRoute$childr = existingRoute.children) == null ? void 0 : _existingRoute$childr.some(bChild => isSameRoute(aChild, bChild));
+  });
+}
+/**
+ * Execute route.lazy() methods to lazily load route modules (loader, action,
+ * shouldRevalidate) and update the routeManifest in place which shares objects
+ * with dataRoutes so those get updated as well.
+ */
+async function loadLazyRouteModule(route, mapRouteProperties, manifest) {
+  if (!route.lazy) {
+    return;
+  }
+  let lazyRoute = await route.lazy();
+  // If the lazy route function was executed and removed by another parallel
+  // call then we can return - first lazy() to finish wins because the return
+  // value of lazy is expected to be static
+  if (!route.lazy) {
+    return;
+  }
+  let routeToUpdate = manifest[route.id];
+  invariant(routeToUpdate, "No route found in manifest");
+  // Update the route in place.  This should be safe because there's no way
+  // we could yet be sitting on this route as we can't get there without
+  // resolving lazy() first.
+  //
+  // This is different than the HMR "update" use-case where we may actively be
+  // on the route being updated.  The main concern boils down to "does this
+  // mutation affect any ongoing navigations or any current state.matches
+  // values?".  If not, it should be safe to update in place.
+  let routeUpdates = {};
+  for (let lazyRouteProperty in lazyRoute) {
+    let staticRouteValue = routeToUpdate[lazyRouteProperty];
+    let isPropertyStaticallyDefined = staticRouteValue !== undefined &&
+    // This property isn't static since it should always be updated based
+    // on the route updates
+    lazyRouteProperty !== "hasErrorBoundary";
+    warning(!isPropertyStaticallyDefined, "Route \"" + routeToUpdate.id + "\" has a static property \"" + lazyRouteProperty + "\" " + "defined but its lazy function is also returning a value for this property. " + ("The lazy route property \"" + lazyRouteProperty + "\" will be ignored."));
+    if (!isPropertyStaticallyDefined && !immutableRouteKeys.has(lazyRouteProperty)) {
+      routeUpdates[lazyRouteProperty] = lazyRoute[lazyRouteProperty];
+    }
+  }
+  // Mutate the route with the provided updates.  Do this first so we pass
+  // the updated version to mapRouteProperties
+  Object.assign(routeToUpdate, routeUpdates);
+  // Mutate the `hasErrorBoundary` property on the route based on the route
+  // updates and remove the `lazy` function so we don't resolve the lazy
+  // route again.
+  Object.assign(routeToUpdate, _extends({}, mapRouteProperties(routeToUpdate), {
+    lazy: undefined
+  }));
+}
+// Default implementation of `dataStrategy` which fetches all loaders in parallel
+async function defaultDataStrategy(_ref4) {
+  let {
+    matches
+  } = _ref4;
+  let matchesToLoad = matches.filter(m => m.shouldLoad);
+  let results = await Promise.all(matchesToLoad.map(m => m.resolve()));
+  return results.reduce((acc, result, i) => Object.assign(acc, {
+    [matchesToLoad[i].route.id]: result
+  }), {});
+}
+async function callDataStrategyImpl(dataStrategyImpl, type, state, request, matchesToLoad, matches, fetcherKey, manifest, mapRouteProperties, requestContext) {
+  let loadRouteDefinitionsPromises = matches.map(m => m.route.lazy ? loadLazyRouteModule(m.route, mapRouteProperties, manifest) : undefined);
+  let dsMatches = matches.map((match, i) => {
+    let loadRoutePromise = loadRouteDefinitionsPromises[i];
+    let shouldLoad = matchesToLoad.some(m => m.route.id === match.route.id);
+    // `resolve` encapsulates route.lazy(), executing the loader/action,
+    // and mapping return values/thrown errors to a `DataStrategyResult`.  Users
+    // can pass a callback to take fine-grained control over the execution
+    // of the loader/action
+    let resolve = async handlerOverride => {
+      if (handlerOverride && request.method === "GET" && (match.route.lazy || match.route.loader)) {
+        shouldLoad = true;
+      }
+      return shouldLoad ? callLoaderOrAction(type, request, match, loadRoutePromise, handlerOverride, requestContext) : Promise.resolve({
+        type: ResultType.data,
+        result: undefined
+      });
+    };
+    return _extends({}, match, {
+      shouldLoad,
+      resolve
+    });
+  });
+  // Send all matches here to allow for a middleware-type implementation.
+  // handler will be a no-op for unneeded routes and we filter those results
+  // back out below.
+  let results = await dataStrategyImpl({
+    matches: dsMatches,
+    request,
+    params: matches[0].params,
+    fetcherKey,
+    context: requestContext
+  });
+  // Wait for all routes to load here but 'swallow the error since we want
+  // it to bubble up from the `await loadRoutePromise` in `callLoaderOrAction` -
+  // called from `match.resolve()`
+  try {
+    await Promise.all(loadRouteDefinitionsPromises);
+  } catch (e) {
+    // No-op
+  }
+  return results;
+}
+// Default logic for calling a loader/action is the user has no specified a dataStrategy
+async function callLoaderOrAction(type, request, match, loadRoutePromise, handlerOverride, staticContext) {
+  let result;
+  let onReject;
+  let runHandler = handler => {
+    // Setup a promise we can race against so that abort signals short circuit
+    let reject;
+    // This will never resolve so safe to type it as Promise<DataStrategyResult> to
+    // satisfy the function return value
+    let abortPromise = new Promise((_, r) => reject = r);
+    onReject = () => reject();
+    request.signal.addEventListener("abort", onReject);
+    let actualHandler = ctx => {
+      if (typeof handler !== "function") {
+        return Promise.reject(new Error("You cannot call the handler for a route which defines a boolean " + ("\"" + type + "\" [routeId: " + match.route.id + "]")));
+      }
+      return handler({
+        request,
+        params: match.params,
+        context: staticContext
+      }, ...(ctx !== undefined ? [ctx] : []));
+    };
+    let handlerPromise = (async () => {
+      try {
+        let val = await (handlerOverride ? handlerOverride(ctx => actualHandler(ctx)) : actualHandler());
+        return {
+          type: "data",
+          result: val
+        };
+      } catch (e) {
+        return {
+          type: "error",
+          result: e
+        };
+      }
+    })();
+    return Promise.race([handlerPromise, abortPromise]);
+  };
+  try {
+    let handler = match.route[type];
+    // If we have a route.lazy promise, await that first
+    if (loadRoutePromise) {
+      if (handler) {
+        // Run statically defined handler in parallel with lazy()
+        let handlerError;
+        let [value] = await Promise.all([
+        // If the handler throws, don't let it immediately bubble out,
+        // since we need to let the lazy() execution finish so we know if this
+        // route has a boundary that can handle the error
+        runHandler(handler).catch(e => {
+          handlerError = e;
+        }), loadRoutePromise]);
+        if (handlerError !== undefined) {
+          throw handlerError;
+        }
+        result = value;
+      } else {
+        // Load lazy route module, then run any returned handler
+        await loadRoutePromise;
+        handler = match.route[type];
+        if (handler) {
+          // Handler still runs even if we got interrupted to maintain consistency
+          // with un-abortable behavior of handler execution on non-lazy or
+          // previously-lazy-loaded routes
+          result = await runHandler(handler);
+        } else if (type === "action") {
+          let url = new URL(request.url);
+          let pathname = url.pathname + url.search;
+          throw getInternalRouterError(405, {
+            method: request.method,
+            pathname,
+            routeId: match.route.id
+          });
+        } else {
+          // lazy() route has no loader to run.  Short circuit here so we don't
+          // hit the invariant below that errors on returning undefined.
+          return {
+            type: ResultType.data,
+            result: undefined
+          };
+        }
+      }
+    } else if (!handler) {
+      let url = new URL(request.url);
+      let pathname = url.pathname + url.search;
+      throw getInternalRouterError(404, {
+        pathname
+      });
+    } else {
+      result = await runHandler(handler);
+    }
+    invariant(result.result !== undefined, "You defined " + (type === "action" ? "an action" : "a loader") + " for route " + ("\"" + match.route.id + "\" but didn't return anything from your `" + type + "` ") + "function. Please return a value or `null`.");
+  } catch (e) {
+    // We should already be catching and converting normal handler executions to
+    // DataStrategyResults and returning them, so anything that throws here is an
+    // unexpected error we still need to wrap
+    return {
+      type: ResultType.error,
+      result: e
+    };
+  } finally {
+    if (onReject) {
+      request.signal.removeEventListener("abort", onReject);
+    }
+  }
+  return result;
+}
+async function convertDataStrategyResultToDataResult(dataStrategyResult) {
+  let {
+    result,
+    type
+  } = dataStrategyResult;
+  if (isResponse(result)) {
+    let data;
+    try {
+      let contentType = result.headers.get("Content-Type");
+      // Check between word boundaries instead of startsWith() due to the last
+      // paragraph of https://httpwg.org/specs/rfc9110.html#field.content-type
+      if (contentType && /\bapplication\/json\b/.test(contentType)) {
+        if (result.body == null) {
+          data = null;
+        } else {
+          data = await result.json();
+        }
+      } else {
+        data = await result.text();
+      }
+    } catch (e) {
+      return {
+        type: ResultType.error,
+        error: e
+      };
+    }
+    if (type === ResultType.error) {
+      return {
+        type: ResultType.error,
+        error: new ErrorResponseImpl(result.status, result.statusText, data),
+        statusCode: result.status,
+        headers: result.headers
+      };
+    }
+    return {
+      type: ResultType.data,
+      data,
+      statusCode: result.status,
+      headers: result.headers
+    };
+  }
+  if (type === ResultType.error) {
+    if (isDataWithResponseInit(result)) {
+      var _result$init3, _result$init4;
+      if (result.data instanceof Error) {
+        var _result$init, _result$init2;
+        return {
+          type: ResultType.error,
+          error: result.data,
+          statusCode: (_result$init = result.init) == null ? void 0 : _result$init.status,
+          headers: (_result$init2 = result.init) != null && _result$init2.headers ? new Headers(result.init.headers) : undefined
+        };
+      }
+      // Convert thrown data() to ErrorResponse instances
+      return {
+        type: ResultType.error,
+        error: new ErrorResponseImpl(((_result$init3 = result.init) == null ? void 0 : _result$init3.status) || 500, undefined, result.data),
+        statusCode: isRouteErrorResponse(result) ? result.status : undefined,
+        headers: (_result$init4 = result.init) != null && _result$init4.headers ? new Headers(result.init.headers) : undefined
+      };
+    }
+    return {
+      type: ResultType.error,
+      error: result,
+      statusCode: isRouteErrorResponse(result) ? result.status : undefined
+    };
+  }
+  if (isDeferredData(result)) {
+    var _result$init5, _result$init6;
+    return {
+      type: ResultType.deferred,
+      deferredData: result,
+      statusCode: (_result$init5 = result.init) == null ? void 0 : _result$init5.status,
+      headers: ((_result$init6 = result.init) == null ? void 0 : _result$init6.headers) && new Headers(result.init.headers)
+    };
+  }
+  if (isDataWithResponseInit(result)) {
+    var _result$init7, _result$init8;
+    return {
+      type: ResultType.data,
+      data: result.data,
+      statusCode: (_result$init7 = result.init) == null ? void 0 : _result$init7.status,
+      headers: (_result$init8 = result.init) != null && _result$init8.headers ? new Headers(result.init.headers) : undefined
+    };
+  }
+  return {
+    type: ResultType.data,
+    data: result
+  };
+}
+// Support relative routing in internal redirects
+function normalizeRelativeRoutingRedirectResponse(response, request, routeId, matches, basename, v7_relativeSplatPath) {
+  let location = response.headers.get("Location");
+  invariant(location, "Redirects returned/thrown from loaders/actions must have a Location header");
+  if (!ABSOLUTE_URL_REGEX.test(location)) {
+    let trimmedMatches = matches.slice(0, matches.findIndex(m => m.route.id === routeId) + 1);
+    location = normalizeTo(new URL(request.url), trimmedMatches, basename, true, location, v7_relativeSplatPath);
+    response.headers.set("Location", location);
+  }
+  return response;
+}
+function normalizeRedirectLocation(location, currentUrl, basename, historyInstance) {
+  // Match Chrome's behavior:
+  // https://github.com/chromium/chromium/blob/216dbeb61db0c667e62082e5f5400a32d6983df3/content/public/common/url_utils.cc#L82
+  let invalidProtocols = ["about:", "blob:", "chrome:", "chrome-untrusted:", "content:", "data:", "devtools:", "file:", "filesystem:",
+  // eslint-disable-next-line no-script-url
+  "javascript:"];
+  if (ABSOLUTE_URL_REGEX.test(location)) {
+    // Strip off the protocol+origin for same-origin + same-basename absolute redirects
+    let normalizedLocation = location;
+    let url = normalizedLocation.startsWith("//") ? new URL(currentUrl.protocol + normalizedLocation) : new URL(normalizedLocation);
+    if (invalidProtocols.includes(url.protocol)) {
+      throw new Error("Invalid redirect location");
+    }
+    let isSameBasename = stripBasename(url.pathname, basename) != null;
+    if (url.origin === currentUrl.origin && isSameBasename) {
+      return url.pathname + url.search + url.hash;
+    }
+  }
+  try {
+    let url = historyInstance.createURL(location);
+    if (invalidProtocols.includes(url.protocol)) {
+      throw new Error("Invalid redirect location");
+    }
+  } catch (e) {}
+  return location;
+}
+// Utility method for creating the Request instances for loaders/actions during
+// client-side navigations and fetches.  During SSR we will always have a
+// Request instance from the static handler (query/queryRoute)
+function createClientSideRequest(history, location, signal, submission) {
+  let url = history.createURL(stripHashFromPath(location)).toString();
+  let init = {
+    signal
+  };
+  if (submission && isMutationMethod(submission.formMethod)) {
+    let {
+      formMethod,
+      formEncType
+    } = submission;
+    // Didn't think we needed this but it turns out unlike other methods, patch
+    // won't be properly normalized to uppercase and results in a 405 error.
+    // See: https://fetch.spec.whatwg.org/#concept-method
+    init.method = formMethod.toUpperCase();
+    if (formEncType === "application/json") {
+      init.headers = new Headers({
+        "Content-Type": formEncType
+      });
+      init.body = JSON.stringify(submission.json);
+    } else if (formEncType === "text/plain") {
+      // Content-Type is inferred (https://fetch.spec.whatwg.org/#dom-request)
+      init.body = submission.text;
+    } else if (formEncType === "application/x-www-form-urlencoded" && submission.formData) {
+      // Content-Type is inferred (https://fetch.spec.whatwg.org/#dom-request)
+      init.body = convertFormDataToSearchParams(submission.formData);
+    } else {
+      // Content-Type is inferred (https://fetch.spec.whatwg.org/#dom-request)
+      init.body = submission.formData;
+    }
+  }
+  return new Request(url, init);
+}
+function convertFormDataToSearchParams(formData) {
+  let searchParams = new URLSearchParams();
+  for (let [key, value] of formData.entries()) {
+    // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#converting-an-entry-list-to-a-list-of-name-value-pairs
+    searchParams.append(key, typeof value === "string" ? value : value.name);
+  }
+  return searchParams;
+}
+function convertSearchParamsToFormData(searchParams) {
+  let formData = new FormData();
+  for (let [key, value] of searchParams.entries()) {
+    formData.append(key, value);
+  }
+  return formData;
+}
+function processRouteLoaderData(matches, results, pendingActionResult, activeDeferreds, skipLoaderErrorBubbling) {
+  // Fill in loaderData/errors from our loaders
+  let loaderData = {};
+  let errors = null;
+  let statusCode;
+  let foundError = false;
+  let loaderHeaders = {};
+  let pendingError = pendingActionResult && isErrorResult(pendingActionResult[1]) ? pendingActionResult[1].error : undefined;
+  // Process loader results into state.loaderData/state.errors
+  matches.forEach(match => {
+    if (!(match.route.id in results)) {
+      return;
+    }
+    let id = match.route.id;
+    let result = results[id];
+    invariant(!isRedirectResult(result), "Cannot handle redirect results in processLoaderData");
+    if (isErrorResult(result)) {
+      let error = result.error;
+      // If we have a pending action error, we report it at the highest-route
+      // that throws a loader error, and then clear it out to indicate that
+      // it was consumed
+      if (pendingError !== undefined) {
+        error = pendingError;
+        pendingError = undefined;
+      }
+      errors = errors || {};
+      if (skipLoaderErrorBubbling) {
+        errors[id] = error;
+      } else {
+        // Look upwards from the matched route for the closest ancestor error
+        // boundary, defaulting to the root match.  Prefer higher error values
+        // if lower errors bubble to the same boundary
+        let boundaryMatch = findNearestBoundary(matches, id);
+        if (errors[boundaryMatch.route.id] == null) {
+          errors[boundaryMatch.route.id] = error;
+        }
+      }
+      // Clear our any prior loaderData for the throwing route
+      loaderData[id] = undefined;
+      // Once we find our first (highest) error, we set the status code and
+      // prevent deeper status codes from overriding
+      if (!foundError) {
+        foundError = true;
+        statusCode = isRouteErrorResponse(result.error) ? result.error.status : 500;
+      }
+      if (result.headers) {
+        loaderHeaders[id] = result.headers;
+      }
+    } else {
+      if (isDeferredResult(result)) {
+        activeDeferreds.set(id, result.deferredData);
+        loaderData[id] = result.deferredData.data;
+        // Error status codes always override success status codes, but if all
+        // loaders are successful we take the deepest status code.
+        if (result.statusCode != null && result.statusCode !== 200 && !foundError) {
+          statusCode = result.statusCode;
+        }
+        if (result.headers) {
+          loaderHeaders[id] = result.headers;
+        }
+      } else {
+        loaderData[id] = result.data;
+        // Error status codes always override success status codes, but if all
+        // loaders are successful we take the deepest status code.
+        if (result.statusCode && result.statusCode !== 200 && !foundError) {
+          statusCode = result.statusCode;
+        }
+        if (result.headers) {
+          loaderHeaders[id] = result.headers;
+        }
+      }
+    }
+  });
+  // If we didn't consume the pending action error (i.e., all loaders
+  // resolved), then consume it here.  Also clear out any loaderData for the
+  // throwing route
+  if (pendingError !== undefined && pendingActionResult) {
+    errors = {
+      [pendingActionResult[0]]: pendingError
+    };
+    loaderData[pendingActionResult[0]] = undefined;
+  }
+  return {
+    loaderData,
+    errors,
+    statusCode: statusCode || 200,
+    loaderHeaders
+  };
+}
+function processLoaderData(state, matches, results, pendingActionResult, revalidatingFetchers, fetcherResults, activeDeferreds) {
+  let {
+    loaderData,
+    errors
+  } = processRouteLoaderData(matches, results, pendingActionResult, activeDeferreds, false // This method is only called client side so we always want to bubble
+  );
+  // Process results from our revalidating fetchers
+  revalidatingFetchers.forEach(rf => {
+    let {
+      key,
+      match,
+      controller
+    } = rf;
+    let result = fetcherResults[key];
+    invariant(result, "Did not find corresponding fetcher result");
+    // Process fetcher non-redirect errors
+    if (controller && controller.signal.aborted) {
+      // Nothing to do for aborted fetchers
+      return;
+    } else if (isErrorResult(result)) {
+      let boundaryMatch = findNearestBoundary(state.matches, match == null ? void 0 : match.route.id);
+      if (!(errors && errors[boundaryMatch.route.id])) {
+        errors = _extends({}, errors, {
+          [boundaryMatch.route.id]: result.error
+        });
+      }
+      state.fetchers.delete(key);
+    } else if (isRedirectResult(result)) {
+      // Should never get here, redirects should get processed above, but we
+      // keep this to type narrow to a success result in the else
+      invariant(false, "Unhandled fetcher revalidation redirect");
+    } else if (isDeferredResult(result)) {
+      // Should never get here, deferred data should be awaited for fetchers
+      // in resolveDeferredResults
+      invariant(false, "Unhandled fetcher deferred data");
+    } else {
+      let doneFetcher = getDoneFetcher(result.data);
+      state.fetchers.set(key, doneFetcher);
+    }
+  });
+  return {
+    loaderData,
+    errors
+  };
+}
+function mergeLoaderData(loaderData, newLoaderData, matches, errors) {
+  let mergedLoaderData = _extends({}, newLoaderData);
+  for (let match of matches) {
+    let id = match.route.id;
+    if (newLoaderData.hasOwnProperty(id)) {
+      if (newLoaderData[id] !== undefined) {
+        mergedLoaderData[id] = newLoaderData[id];
+      }
+    } else if (loaderData[id] !== undefined && match.route.loader) {
+      // Preserve existing keys not included in newLoaderData and where a loader
+      // wasn't removed by HMR
+      mergedLoaderData[id] = loaderData[id];
+    }
+    if (errors && errors.hasOwnProperty(id)) {
+      // Don't keep any loader data below the boundary
+      break;
+    }
+  }
+  return mergedLoaderData;
+}
+function getActionDataForCommit(pendingActionResult) {
+  if (!pendingActionResult) {
+    return {};
+  }
+  return isErrorResult(pendingActionResult[1]) ? {
+    // Clear out prior actionData on errors
+    actionData: {}
+  } : {
+    actionData: {
+      [pendingActionResult[0]]: pendingActionResult[1].data
+    }
+  };
+}
+// Find the nearest error boundary, looking upwards from the leaf route (or the
+// route specified by routeId) for the closest ancestor error boundary,
+// defaulting to the root match
+function findNearestBoundary(matches, routeId) {
+  let eligibleMatches = routeId ? matches.slice(0, matches.findIndex(m => m.route.id === routeId) + 1) : [...matches];
+  return eligibleMatches.reverse().find(m => m.route.hasErrorBoundary === true) || matches[0];
+}
+function getShortCircuitMatches(routes) {
+  // Prefer a root layout route if present, otherwise shim in a route object
+  let route = routes.length === 1 ? routes[0] : routes.find(r => r.index || !r.path || r.path === "/") || {
+    id: "__shim-error-route__"
+  };
+  return {
+    matches: [{
+      params: {},
+      pathname: "",
+      pathnameBase: "",
+      route
+    }],
+    route
+  };
+}
+function getInternalRouterError(status, _temp5) {
+  let {
+    pathname,
+    routeId,
+    method,
+    type,
+    message
+  } = _temp5 === void 0 ? {} : _temp5;
+  let statusText = "Unknown Server Error";
+  let errorMessage = "Unknown @remix-run/router error";
+  if (status === 400) {
+    statusText = "Bad Request";
+    if (method && pathname && routeId) {
+      errorMessage = "You made a " + method + " request to \"" + pathname + "\" but " + ("did not provide a `loader` for route \"" + routeId + "\", ") + "so there is no way to handle the request.";
+    } else if (type === "defer-action") {
+      errorMessage = "defer() is not supported in actions";
+    } else if (type === "invalid-body") {
+      errorMessage = "Unable to encode submission body";
+    }
+  } else if (status === 403) {
+    statusText = "Forbidden";
+    errorMessage = "Route \"" + routeId + "\" does not match URL \"" + pathname + "\"";
+  } else if (status === 404) {
+    statusText = "Not Found";
+    errorMessage = "No route matches URL \"" + pathname + "\"";
+  } else if (status === 405) {
+    statusText = "Method Not Allowed";
+    if (method && pathname && routeId) {
+      errorMessage = "You made a " + method.toUpperCase() + " request to \"" + pathname + "\" but " + ("did not provide an `action` for route \"" + routeId + "\", ") + "so there is no way to handle the request.";
+    } else if (method) {
+      errorMessage = "Invalid request method \"" + method.toUpperCase() + "\"";
+    }
+  }
+  return new ErrorResponseImpl(status || 500, statusText, new Error(errorMessage), true);
+}
+// Find any returned redirect errors, starting from the lowest match
+function findRedirect(results) {
+  let entries = Object.entries(results);
+  for (let i = entries.length - 1; i >= 0; i--) {
+    let [key, result] = entries[i];
+    if (isRedirectResult(result)) {
+      return {
+        key,
+        result
+      };
+    }
+  }
+}
+function stripHashFromPath(path) {
+  let parsedPath = typeof path === "string" ? parsePath(path) : path;
+  return createPath(_extends({}, parsedPath, {
+    hash: ""
+  }));
+}
+function isHashChangeOnly(a, b) {
+  if (a.pathname !== b.pathname || a.search !== b.search) {
+    return false;
+  }
+  if (a.hash === "") {
+    // /page -> /page#hash
+    return b.hash !== "";
+  } else if (a.hash === b.hash) {
+    // /page#hash -> /page#hash
+    return true;
+  } else if (b.hash !== "") {
+    // /page#hash -> /page#other
+    return true;
+  }
+  // If the hash is removed the browser will re-perform a request to the server
+  // /page#hash -> /page
+  return false;
+}
+function isDataStrategyResult(result) {
+  return result != null && typeof result === "object" && "type" in result && "result" in result && (result.type === ResultType.data || result.type === ResultType.error);
+}
+function isRedirectDataStrategyResultResult(result) {
+  return isResponse(result.result) && redirectStatusCodes.has(result.result.status);
+}
+function isDeferredResult(result) {
+  return result.type === ResultType.deferred;
+}
+function isErrorResult(result) {
+  return result.type === ResultType.error;
+}
+function isRedirectResult(result) {
+  return (result && result.type) === ResultType.redirect;
+}
+function isDataWithResponseInit(value) {
+  return typeof value === "object" && value != null && "type" in value && "data" in value && "init" in value && value.type === "DataWithResponseInit";
+}
+function isDeferredData(value) {
+  let deferred = value;
+  return deferred && typeof deferred === "object" && typeof deferred.data === "object" && typeof deferred.subscribe === "function" && typeof deferred.cancel === "function" && typeof deferred.resolveData === "function";
+}
+function isResponse(value) {
+  return value != null && typeof value.status === "number" && typeof value.statusText === "string" && typeof value.headers === "object" && typeof value.body !== "undefined";
+}
+function isRedirectResponse(result) {
+  if (!isResponse(result)) {
+    return false;
+  }
+  let status = result.status;
+  let location = result.headers.get("Location");
+  return status >= 300 && status <= 399 && location != null;
+}
+function isValidMethod(method) {
+  return validRequestMethods.has(method.toLowerCase());
+}
+function isMutationMethod(method) {
+  return validMutationMethods.has(method.toLowerCase());
+}
+async function resolveNavigationDeferredResults(matches, results, signal, currentMatches, currentLoaderData) {
+  let entries = Object.entries(results);
+  for (let index = 0; index < entries.length; index++) {
+    let [routeId, result] = entries[index];
+    let match = matches.find(m => (m == null ? void 0 : m.route.id) === routeId);
+    // If we don't have a match, then we can have a deferred result to do
+    // anything with.  This is for revalidating fetchers where the route was
+    // removed during HMR
+    if (!match) {
+      continue;
+    }
+    let currentMatch = currentMatches.find(m => m.route.id === match.route.id);
+    let isRevalidatingLoader = currentMatch != null && !isNewRouteInstance(currentMatch, match) && (currentLoaderData && currentLoaderData[match.route.id]) !== undefined;
+    if (isDeferredResult(result) && isRevalidatingLoader) {
+      // Note: we do not have to touch activeDeferreds here since we race them
+      // against the signal in resolveDeferredData and they'll get aborted
+      // there if needed
+      await resolveDeferredData(result, signal, false).then(result => {
+        if (result) {
+          results[routeId] = result;
+        }
+      });
+    }
+  }
+}
+async function resolveFetcherDeferredResults(matches, results, revalidatingFetchers) {
+  for (let index = 0; index < revalidatingFetchers.length; index++) {
+    let {
+      key,
+      routeId,
+      controller
+    } = revalidatingFetchers[index];
+    let result = results[key];
+    let match = matches.find(m => (m == null ? void 0 : m.route.id) === routeId);
+    // If we don't have a match, then we can have a deferred result to do
+    // anything with.  This is for revalidating fetchers where the route was
+    // removed during HMR
+    if (!match) {
+      continue;
+    }
+    if (isDeferredResult(result)) {
+      // Note: we do not have to touch activeDeferreds here since we race them
+      // against the signal in resolveDeferredData and they'll get aborted
+      // there if needed
+      invariant(controller, "Expected an AbortController for revalidating fetcher deferred result");
+      await resolveDeferredData(result, controller.signal, true).then(result => {
+        if (result) {
+          results[key] = result;
+        }
+      });
+    }
+  }
+}
+async function resolveDeferredData(result, signal, unwrap) {
+  if (unwrap === void 0) {
+    unwrap = false;
+  }
+  let aborted = await result.deferredData.resolveData(signal);
+  if (aborted) {
+    return;
+  }
+  if (unwrap) {
+    try {
+      return {
+        type: ResultType.data,
+        data: result.deferredData.unwrappedData
+      };
+    } catch (e) {
+      // Handle any TrackedPromise._error values encountered while unwrapping
+      return {
+        type: ResultType.error,
+        error: e
+      };
+    }
+  }
+  return {
+    type: ResultType.data,
+    data: result.deferredData.data
+  };
+}
+function hasNakedIndexQuery(search) {
+  return new URLSearchParams(search).getAll("index").some(v => v === "");
+}
+function getTargetMatch(matches, location) {
+  let search = typeof location === "string" ? parsePath(location).search : location.search;
+  if (matches[matches.length - 1].route.index && hasNakedIndexQuery(search || "")) {
+    // Return the leaf index route when index is present
+    return matches[matches.length - 1];
+  }
+  // Otherwise grab the deepest "path contributing" match (ignoring index and
+  // pathless layout routes)
+  let pathMatches = getPathContributingMatches(matches);
+  return pathMatches[pathMatches.length - 1];
+}
+function getSubmissionFromNavigation(navigation) {
+  let {
+    formMethod,
+    formAction,
+    formEncType,
+    text,
+    formData,
+    json
+  } = navigation;
+  if (!formMethod || !formAction || !formEncType) {
+    return;
+  }
+  if (text != null) {
+    return {
+      formMethod,
+      formAction,
+      formEncType,
+      formData: undefined,
+      json: undefined,
+      text
+    };
+  } else if (formData != null) {
+    return {
+      formMethod,
+      formAction,
+      formEncType,
+      formData,
+      json: undefined,
+      text: undefined
+    };
+  } else if (json !== undefined) {
+    return {
+      formMethod,
+      formAction,
+      formEncType,
+      formData: undefined,
+      json,
+      text: undefined
+    };
+  }
+}
+function getLoadingNavigation(location, submission) {
+  if (submission) {
+    let navigation = {
+      state: "loading",
+      location,
+      formMethod: submission.formMethod,
+      formAction: submission.formAction,
+      formEncType: submission.formEncType,
+      formData: submission.formData,
+      json: submission.json,
+      text: submission.text
+    };
+    return navigation;
+  } else {
+    let navigation = {
+      state: "loading",
+      location,
+      formMethod: undefined,
+      formAction: undefined,
+      formEncType: undefined,
+      formData: undefined,
+      json: undefined,
+      text: undefined
+    };
+    return navigation;
+  }
+}
+function getSubmittingNavigation(location, submission) {
+  let navigation = {
+    state: "submitting",
+    location,
+    formMethod: submission.formMethod,
+    formAction: submission.formAction,
+    formEncType: submission.formEncType,
+    formData: submission.formData,
+    json: submission.json,
+    text: submission.text
+  };
+  return navigation;
+}
+function getLoadingFetcher(submission, data) {
+  if (submission) {
+    let fetcher = {
+      state: "loading",
+      formMethod: submission.formMethod,
+      formAction: submission.formAction,
+      formEncType: submission.formEncType,
+      formData: submission.formData,
+      json: submission.json,
+      text: submission.text,
+      data
+    };
+    return fetcher;
+  } else {
+    let fetcher = {
+      state: "loading",
+      formMethod: undefined,
+      formAction: undefined,
+      formEncType: undefined,
+      formData: undefined,
+      json: undefined,
+      text: undefined,
+      data
+    };
+    return fetcher;
+  }
+}
+function getSubmittingFetcher(submission, existingFetcher) {
+  let fetcher = {
+    state: "submitting",
+    formMethod: submission.formMethod,
+    formAction: submission.formAction,
+    formEncType: submission.formEncType,
+    formData: submission.formData,
+    json: submission.json,
+    text: submission.text,
+    data: existingFetcher ? existingFetcher.data : undefined
+  };
+  return fetcher;
+}
+function getDoneFetcher(data) {
+  let fetcher = {
+    state: "idle",
+    formMethod: undefined,
+    formAction: undefined,
+    formEncType: undefined,
+    formData: undefined,
+    json: undefined,
+    text: undefined,
+    data
+  };
+  return fetcher;
+}
+function restoreAppliedTransitions(_window, transitions) {
+  try {
+    let sessionPositions = _window.sessionStorage.getItem(TRANSITIONS_STORAGE_KEY);
+    if (sessionPositions) {
+      let json = JSON.parse(sessionPositions);
+      for (let [k, v] of Object.entries(json || {})) {
+        if (v && Array.isArray(v)) {
+          transitions.set(k, new Set(v || []));
+        }
+      }
+    }
+  } catch (e) {
+    // no-op, use default empty object
+  }
+}
+function persistAppliedTransitions(_window, transitions) {
+  if (transitions.size > 0) {
+    let json = {};
+    for (let [k, v] of transitions) {
+      json[k] = [...v];
+    }
+    try {
+      _window.sessionStorage.setItem(TRANSITIONS_STORAGE_KEY, JSON.stringify(json));
+    } catch (error) {
+      warning(false, "Failed to save applied view transitions in sessionStorage (" + error + ").");
+    }
+  }
+}
+//#endregion
+
+export { AbortedDeferredError, Action, IDLE_BLOCKER, IDLE_FETCHER, IDLE_NAVIGATION, UNSAFE_DEFERRED_SYMBOL, DeferredData as UNSAFE_DeferredData, ErrorResponseImpl as UNSAFE_ErrorResponseImpl, convertRouteMatchToUiMatch as UNSAFE_convertRouteMatchToUiMatch, convertRoutesToDataRoutes as UNSAFE_convertRoutesToDataRoutes, decodePath as UNSAFE_decodePath, getResolveToMatches as UNSAFE_getResolveToMatches, invariant as UNSAFE_invariant, warning as UNSAFE_warning, createBrowserHistory, createHashHistory, createMemoryHistory, createPath, createRouter, createStaticHandler, data, defer, generatePath, getStaticContextFromError, getToPathname, isDataWithResponseInit, isDeferredData, isRouteErrorResponse, joinPaths, json, matchPath, matchRoutes, normalizePathname, parsePath, redirect, redirectDocument, replace, resolvePath, resolveTo, stripBasename };
+//# sourceMappingURL=router.js.map
Index: frontend/node_modules/@remix-run/router/dist/router.js.map
===================================================================
--- frontend/node_modules/@remix-run/router/dist/router.js.map	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/@remix-run/router/dist/router.js.map	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,1 @@
+{"version":3,"file":"router.js","sources":["../history.ts","../utils.ts","../router.ts"],"sourcesContent":["////////////////////////////////////////////////////////////////////////////////\n//#region Types and Constants\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * Actions represent the type of change to a location value.\n */\nexport enum Action {\n  /**\n   * A POP indicates a change to an arbitrary index in the history stack, such\n   * as a back or forward navigation. It does not describe the direction of the\n   * navigation, only that the current index changed.\n   *\n   * Note: This is the default action for newly created history objects.\n   */\n  Pop = \"POP\",\n\n  /**\n   * A PUSH indicates a new entry being added to the history stack, such as when\n   * a link is clicked and a new page loads. When this happens, all subsequent\n   * entries in the stack are lost.\n   */\n  Push = \"PUSH\",\n\n  /**\n   * A REPLACE indicates the entry at the current index in the history stack\n   * being replaced by a new one.\n   */\n  Replace = \"REPLACE\",\n}\n\n/**\n * The pathname, search, and hash values of a URL.\n */\nexport interface Path {\n  /**\n   * A URL pathname, beginning with a /.\n   */\n  pathname: string;\n\n  /**\n   * A URL search string, beginning with a ?.\n   */\n  search: string;\n\n  /**\n   * A URL fragment identifier, beginning with a #.\n   */\n  hash: string;\n}\n\n// TODO: (v7) Change the Location generic default from `any` to `unknown` and\n// remove Remix `useLocation` wrapper.\n\n/**\n * An entry in a history stack. A location contains information about the\n * URL path, as well as possibly some arbitrary state and a key.\n */\nexport interface Location<State = any> extends Path {\n  /**\n   * A value of arbitrary data associated with this location.\n   */\n  state: State;\n\n  /**\n   * A unique string associated with this location. May be used to safely store\n   * and retrieve data in some other storage API, like `localStorage`.\n   *\n   * Note: This value is always \"default\" on the initial location.\n   */\n  key: string;\n}\n\n/**\n * A change to the current location.\n */\nexport interface Update {\n  /**\n   * The action that triggered the change.\n   */\n  action: Action;\n\n  /**\n   * The new location.\n   */\n  location: Location;\n\n  /**\n   * The delta between this location and the former location in the history stack\n   */\n  delta: number | null;\n}\n\n/**\n * A function that receives notifications about location changes.\n */\nexport interface Listener {\n  (update: Update): void;\n}\n\n/**\n * Describes a location that is the destination of some navigation, either via\n * `history.push` or `history.replace`. This may be either a URL or the pieces\n * of a URL path.\n */\nexport type To = string | Partial<Path>;\n\n/**\n * A history is an interface to the navigation stack. The history serves as the\n * source of truth for the current location, as well as provides a set of\n * methods that may be used to change it.\n *\n * It is similar to the DOM's `window.history` object, but with a smaller, more\n * focused API.\n */\nexport interface History {\n  /**\n   * The last action that modified the current location. This will always be\n   * Action.Pop when a history instance is first created. This value is mutable.\n   */\n  readonly action: Action;\n\n  /**\n   * The current location. This value is mutable.\n   */\n  readonly location: Location;\n\n  /**\n   * Returns a valid href for the given `to` value that may be used as\n   * the value of an <a href> attribute.\n   *\n   * @param to - The destination URL\n   */\n  createHref(to: To): string;\n\n  /**\n   * Returns a URL for the given `to` value\n   *\n   * @param to - The destination URL\n   */\n  createURL(to: To): URL;\n\n  /**\n   * Encode a location the same way window.history would do (no-op for memory\n   * history) so we ensure our PUSH/REPLACE navigations for data routers\n   * behave the same as POP\n   *\n   * @param to Unencoded path\n   */\n  encodeLocation(to: To): Path;\n\n  /**\n   * Pushes a new location onto the history stack, increasing its length by one.\n   * If there were any entries in the stack after the current one, they are\n   * lost.\n   *\n   * @param to - The new URL\n   * @param state - Data to associate with the new location\n   */\n  push(to: To, state?: any): void;\n\n  /**\n   * Replaces the current location in the history stack with a new one.  The\n   * location that was replaced will no longer be available.\n   *\n   * @param to - The new URL\n   * @param state - Data to associate with the new location\n   */\n  replace(to: To, state?: any): void;\n\n  /**\n   * Navigates `n` entries backward/forward in the history stack relative to the\n   * current index. For example, a \"back\" navigation would use go(-1).\n   *\n   * @param delta - The delta in the stack index\n   */\n  go(delta: number): void;\n\n  /**\n   * Sets up a listener that will be called whenever the current location\n   * changes.\n   *\n   * @param listener - A function that will be called when the location changes\n   * @returns unlisten - A function that may be used to stop listening\n   */\n  listen(listener: Listener): () => void;\n}\n\ntype HistoryState = {\n  usr: any;\n  key?: string;\n  idx: number;\n};\n\nconst PopStateEventType = \"popstate\";\n//#endregion\n\n////////////////////////////////////////////////////////////////////////////////\n//#region Memory History\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * A user-supplied object that describes a location. Used when providing\n * entries to `createMemoryHistory` via its `initialEntries` option.\n */\nexport type InitialEntry = string | Partial<Location>;\n\nexport type MemoryHistoryOptions = {\n  initialEntries?: InitialEntry[];\n  initialIndex?: number;\n  v5Compat?: boolean;\n};\n\n/**\n * A memory history stores locations in memory. This is useful in stateful\n * environments where there is no web browser, such as node tests or React\n * Native.\n */\nexport interface MemoryHistory extends History {\n  /**\n   * The current index in the history stack.\n   */\n  readonly index: number;\n}\n\n/**\n * Memory history stores the current location in memory. It is designed for use\n * in stateful non-browser environments like tests and React Native.\n */\nexport function createMemoryHistory(\n  options: MemoryHistoryOptions = {}\n): MemoryHistory {\n  let { initialEntries = [\"/\"], initialIndex, v5Compat = false } = options;\n  let entries: Location[]; // Declare so we can access from createMemoryLocation\n  entries = initialEntries.map((entry, index) =>\n    createMemoryLocation(\n      entry,\n      typeof entry === \"string\" ? null : entry.state,\n      index === 0 ? \"default\" : undefined\n    )\n  );\n  let index = clampIndex(\n    initialIndex == null ? entries.length - 1 : initialIndex\n  );\n  let action = Action.Pop;\n  let listener: Listener | null = null;\n\n  function clampIndex(n: number): number {\n    return Math.min(Math.max(n, 0), entries.length - 1);\n  }\n  function getCurrentLocation(): Location {\n    return entries[index];\n  }\n  function createMemoryLocation(\n    to: To,\n    state: any = null,\n    key?: string\n  ): Location {\n    let location = createLocation(\n      entries ? getCurrentLocation().pathname : \"/\",\n      to,\n      state,\n      key\n    );\n    warning(\n      location.pathname.charAt(0) === \"/\",\n      `relative pathnames are not supported in memory history: ${JSON.stringify(\n        to\n      )}`\n    );\n    return location;\n  }\n\n  function createHref(to: To) {\n    return typeof to === \"string\" ? to : createPath(to);\n  }\n\n  let history: MemoryHistory = {\n    get index() {\n      return index;\n    },\n    get action() {\n      return action;\n    },\n    get location() {\n      return getCurrentLocation();\n    },\n    createHref,\n    createURL(to) {\n      return new URL(createHref(to), \"http://localhost\");\n    },\n    encodeLocation(to: To) {\n      let path = typeof to === \"string\" ? parsePath(to) : to;\n      return {\n        pathname: path.pathname || \"\",\n        search: path.search || \"\",\n        hash: path.hash || \"\",\n      };\n    },\n    push(to, state) {\n      action = Action.Push;\n      let nextLocation = createMemoryLocation(to, state);\n      index += 1;\n      entries.splice(index, entries.length, nextLocation);\n      if (v5Compat && listener) {\n        listener({ action, location: nextLocation, delta: 1 });\n      }\n    },\n    replace(to, state) {\n      action = Action.Replace;\n      let nextLocation = createMemoryLocation(to, state);\n      entries[index] = nextLocation;\n      if (v5Compat && listener) {\n        listener({ action, location: nextLocation, delta: 0 });\n      }\n    },\n    go(delta) {\n      action = Action.Pop;\n      let nextIndex = clampIndex(index + delta);\n      let nextLocation = entries[nextIndex];\n      index = nextIndex;\n      if (listener) {\n        listener({ action, location: nextLocation, delta });\n      }\n    },\n    listen(fn: Listener) {\n      listener = fn;\n      return () => {\n        listener = null;\n      };\n    },\n  };\n\n  return history;\n}\n//#endregion\n\n////////////////////////////////////////////////////////////////////////////////\n//#region Browser History\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * A browser history stores the current location in regular URLs in a web\n * browser environment. This is the standard for most web apps and provides the\n * cleanest URLs the browser's address bar.\n *\n * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#browserhistory\n */\nexport interface BrowserHistory extends UrlHistory {}\n\nexport type BrowserHistoryOptions = UrlHistoryOptions;\n\n/**\n * Browser history stores the location in regular URLs. This is the standard for\n * most web apps, but it requires some configuration on the server to ensure you\n * serve the same app at multiple URLs.\n *\n * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createbrowserhistory\n */\nexport function createBrowserHistory(\n  options: BrowserHistoryOptions = {}\n): BrowserHistory {\n  function createBrowserLocation(\n    window: Window,\n    globalHistory: Window[\"history\"]\n  ) {\n    let { pathname, search, hash } = window.location;\n    return createLocation(\n      \"\",\n      { pathname, search, hash },\n      // state defaults to `null` because `window.history.state` does\n      (globalHistory.state && globalHistory.state.usr) || null,\n      (globalHistory.state && globalHistory.state.key) || \"default\"\n    );\n  }\n\n  function createBrowserHref(window: Window, to: To) {\n    return typeof to === \"string\" ? to : createPath(to);\n  }\n\n  return getUrlBasedHistory(\n    createBrowserLocation,\n    createBrowserHref,\n    null,\n    options\n  );\n}\n//#endregion\n\n////////////////////////////////////////////////////////////////////////////////\n//#region Hash History\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * A hash history stores the current location in the fragment identifier portion\n * of the URL in a web browser environment.\n *\n * This is ideal for apps that do not control the server for some reason\n * (because the fragment identifier is never sent to the server), including some\n * shared hosting environments that do not provide fine-grained controls over\n * which pages are served at which URLs.\n *\n * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#hashhistory\n */\nexport interface HashHistory extends UrlHistory {}\n\nexport type HashHistoryOptions = UrlHistoryOptions;\n\n/**\n * Hash history stores the location in window.location.hash. This makes it ideal\n * for situations where you don't want to send the location to the server for\n * some reason, either because you do cannot configure it or the URL space is\n * reserved for something else.\n *\n * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createhashhistory\n */\nexport function createHashHistory(\n  options: HashHistoryOptions = {}\n): HashHistory {\n  function createHashLocation(\n    window: Window,\n    globalHistory: Window[\"history\"]\n  ) {\n    let {\n      pathname = \"/\",\n      search = \"\",\n      hash = \"\",\n    } = parsePath(window.location.hash.substr(1));\n\n    // Hash URL should always have a leading / just like window.location.pathname\n    // does, so if an app ends up at a route like /#something then we add a\n    // leading slash so all of our path-matching behaves the same as if it would\n    // in a browser router.  This is particularly important when there exists a\n    // root splat route (<Route path=\"*\">) since that matches internally against\n    // \"/*\" and we'd expect /#something to 404 in a hash router app.\n    if (!pathname.startsWith(\"/\") && !pathname.startsWith(\".\")) {\n      pathname = \"/\" + pathname;\n    }\n\n    return createLocation(\n      \"\",\n      { pathname, search, hash },\n      // state defaults to `null` because `window.history.state` does\n      (globalHistory.state && globalHistory.state.usr) || null,\n      (globalHistory.state && globalHistory.state.key) || \"default\"\n    );\n  }\n\n  function createHashHref(window: Window, to: To) {\n    let base = window.document.querySelector(\"base\");\n    let href = \"\";\n\n    if (base && base.getAttribute(\"href\")) {\n      let url = window.location.href;\n      let hashIndex = url.indexOf(\"#\");\n      href = hashIndex === -1 ? url : url.slice(0, hashIndex);\n    }\n\n    return href + \"#\" + (typeof to === \"string\" ? to : createPath(to));\n  }\n\n  function validateHashLocation(location: Location, to: To) {\n    warning(\n      location.pathname.charAt(0) === \"/\",\n      `relative pathnames are not supported in hash history.push(${JSON.stringify(\n        to\n      )})`\n    );\n  }\n\n  return getUrlBasedHistory(\n    createHashLocation,\n    createHashHref,\n    validateHashLocation,\n    options\n  );\n}\n//#endregion\n\n////////////////////////////////////////////////////////////////////////////////\n//#region UTILS\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * @private\n */\nexport function invariant(value: boolean, message?: string): asserts value;\nexport function invariant<T>(\n  value: T | null | undefined,\n  message?: string\n): asserts value is T;\nexport function invariant(value: any, message?: string) {\n  if (value === false || value === null || typeof value === \"undefined\") {\n    throw new Error(message);\n  }\n}\n\nexport function warning(cond: any, message: string) {\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 history!\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\nfunction createKey() {\n  return Math.random().toString(36).substr(2, 8);\n}\n\n/**\n * For browser-based histories, we combine the state and key into an object\n */\nfunction getHistoryState(location: Location, index: number): HistoryState {\n  return {\n    usr: location.state,\n    key: location.key,\n    idx: index,\n  };\n}\n\n/**\n * Creates a Location object with a unique key from the given Path\n */\nexport function createLocation(\n  current: string | Location,\n  to: To,\n  state: any = null,\n  key?: string\n): Readonly<Location> {\n  let location: Readonly<Location> = {\n    pathname: typeof current === \"string\" ? current : current.pathname,\n    search: \"\",\n    hash: \"\",\n    ...(typeof to === \"string\" ? parsePath(to) : to),\n    state,\n    // TODO: This could be cleaned up.  push/replace should probably just take\n    // full Locations now and avoid the need to run through this flow at all\n    // But that's a pretty big refactor to the current test suite so going to\n    // keep as is for the time being and just let any incoming keys take precedence\n    key: (to && (to as Location).key) || key || createKey(),\n  };\n  return location;\n}\n\n/**\n * Creates a string URL path from the given pathname, search, and hash components.\n */\nexport function createPath({\n  pathname = \"/\",\n  search = \"\",\n  hash = \"\",\n}: Partial<Path>) {\n  if (search && search !== \"?\")\n    pathname += search.charAt(0) === \"?\" ? search : \"?\" + search;\n  if (hash && hash !== \"#\")\n    pathname += hash.charAt(0) === \"#\" ? hash : \"#\" + hash;\n  return pathname;\n}\n\n/**\n * Parses a string URL path into its separate pathname, search, and hash components.\n */\nexport function parsePath(path: string): Partial<Path> {\n  let parsedPath: Partial<Path> = {};\n\n  if (path) {\n    let hashIndex = path.indexOf(\"#\");\n    if (hashIndex >= 0) {\n      parsedPath.hash = path.substr(hashIndex);\n      path = path.substr(0, hashIndex);\n    }\n\n    let searchIndex = path.indexOf(\"?\");\n    if (searchIndex >= 0) {\n      parsedPath.search = path.substr(searchIndex);\n      path = path.substr(0, searchIndex);\n    }\n\n    if (path) {\n      parsedPath.pathname = path;\n    }\n  }\n\n  return parsedPath;\n}\n\nexport interface UrlHistory extends History {}\n\nexport type UrlHistoryOptions = {\n  window?: Window;\n  v5Compat?: boolean;\n};\n\nfunction getUrlBasedHistory(\n  getLocation: (window: Window, globalHistory: Window[\"history\"]) => Location,\n  createHref: (window: Window, to: To) => string,\n  validateLocation: ((location: Location, to: To) => void) | null,\n  options: UrlHistoryOptions = {}\n): UrlHistory {\n  let { window = document.defaultView!, v5Compat = false } = options;\n  let globalHistory = window.history;\n  let action = Action.Pop;\n  let listener: Listener | null = null;\n\n  let index = getIndex()!;\n  // Index should only be null when we initialize. If not, it's because the\n  // user called history.pushState or history.replaceState directly, in which\n  // case we should log a warning as it will result in bugs.\n  if (index == null) {\n    index = 0;\n    globalHistory.replaceState({ ...globalHistory.state, idx: index }, \"\");\n  }\n\n  function getIndex(): number {\n    let state = globalHistory.state || { idx: null };\n    return state.idx;\n  }\n\n  function handlePop() {\n    action = Action.Pop;\n    let nextIndex = getIndex();\n    let delta = nextIndex == null ? null : nextIndex - index;\n    index = nextIndex;\n    if (listener) {\n      listener({ action, location: history.location, delta });\n    }\n  }\n\n  function push(to: To, state?: any) {\n    action = Action.Push;\n    let location = createLocation(history.location, to, state);\n    if (validateLocation) validateLocation(location, to);\n\n    index = getIndex() + 1;\n    let historyState = getHistoryState(location, index);\n    let url = history.createHref(location);\n\n    // try...catch because iOS limits us to 100 pushState calls :/\n    try {\n      globalHistory.pushState(historyState, \"\", url);\n    } catch (error) {\n      // If the exception is because `state` can't be serialized, let that throw\n      // outwards just like a replace call would so the dev knows the cause\n      // https://html.spec.whatwg.org/multipage/nav-history-apis.html#shared-history-push/replace-state-steps\n      // https://html.spec.whatwg.org/multipage/structured-data.html#structuredserializeinternal\n      if (error instanceof DOMException && error.name === \"DataCloneError\") {\n        throw error;\n      }\n      // They are going to lose state here, but there is no real\n      // way to warn them about it since the page will refresh...\n      window.location.assign(url);\n    }\n\n    if (v5Compat && listener) {\n      listener({ action, location: history.location, delta: 1 });\n    }\n  }\n\n  function replace(to: To, state?: any) {\n    action = Action.Replace;\n    let location = createLocation(history.location, to, state);\n    if (validateLocation) validateLocation(location, to);\n\n    index = getIndex();\n    let historyState = getHistoryState(location, index);\n    let url = history.createHref(location);\n    globalHistory.replaceState(historyState, \"\", url);\n\n    if (v5Compat && listener) {\n      listener({ action, location: history.location, delta: 0 });\n    }\n  }\n\n  function createURL(to: To): URL {\n    // window.location.origin is \"null\" (the literal string value) in Firefox\n    // under certain conditions, notably when serving from a local HTML file\n    // See https://bugzilla.mozilla.org/show_bug.cgi?id=878297\n    let base =\n      window.location.origin !== \"null\"\n        ? window.location.origin\n        : window.location.href;\n\n    let href = typeof to === \"string\" ? to : createPath(to);\n    // Treating this as a full URL will strip any trailing spaces so we need to\n    // pre-encode them since they might be part of a matching splat param from\n    // an ancestor route\n    href = href.replace(/ $/, \"%20\");\n    invariant(\n      base,\n      `No window.location.(origin|href) available to create URL for href: ${href}`\n    );\n    return new URL(href, base);\n  }\n\n  let history: History = {\n    get action() {\n      return action;\n    },\n    get location() {\n      return getLocation(window, globalHistory);\n    },\n    listen(fn: Listener) {\n      if (listener) {\n        throw new Error(\"A history only accepts one active listener\");\n      }\n      window.addEventListener(PopStateEventType, handlePop);\n      listener = fn;\n\n      return () => {\n        window.removeEventListener(PopStateEventType, handlePop);\n        listener = null;\n      };\n    },\n    createHref(to) {\n      return createHref(window, to);\n    },\n    createURL,\n    encodeLocation(to) {\n      // Encode a Location the same way window.location would\n      let url = createURL(to);\n      return {\n        pathname: url.pathname,\n        search: url.search,\n        hash: url.hash,\n      };\n    },\n    push,\n    replace,\n    go(n) {\n      return globalHistory.go(n);\n    },\n  };\n\n  return history;\n}\n\n//#endregion\n","import type { Location, Path, To } from \"./history\";\nimport { invariant, parsePath, warning } from \"./history\";\n\n/**\n * Map of routeId -> data returned from a loader/action/error\n */\nexport interface RouteData {\n  [routeId: string]: any;\n}\n\nexport enum ResultType {\n  data = \"data\",\n  deferred = \"deferred\",\n  redirect = \"redirect\",\n  error = \"error\",\n}\n\n/**\n * Successful result from a loader or action\n */\nexport interface SuccessResult {\n  type: ResultType.data;\n  data: unknown;\n  statusCode?: number;\n  headers?: Headers;\n}\n\n/**\n * Successful defer() result from a loader or action\n */\nexport interface DeferredResult {\n  type: ResultType.deferred;\n  deferredData: DeferredData;\n  statusCode?: number;\n  headers?: Headers;\n}\n\n/**\n * Redirect result from a loader or action\n */\nexport interface RedirectResult {\n  type: ResultType.redirect;\n  // We keep the raw Response for redirects so we can return it verbatim\n  response: Response;\n}\n\n/**\n * Unsuccessful result from a loader or action\n */\nexport interface ErrorResult {\n  type: ResultType.error;\n  error: unknown;\n  statusCode?: number;\n  headers?: Headers;\n}\n\n/**\n * Result from a loader or action - potentially successful or unsuccessful\n */\nexport type DataResult =\n  | SuccessResult\n  | DeferredResult\n  | RedirectResult\n  | ErrorResult;\n\ntype LowerCaseFormMethod = \"get\" | \"post\" | \"put\" | \"patch\" | \"delete\";\ntype UpperCaseFormMethod = Uppercase<LowerCaseFormMethod>;\n\n/**\n * Users can specify either lowercase or uppercase form methods on `<Form>`,\n * useSubmit(), `<fetcher.Form>`, etc.\n */\nexport type HTMLFormMethod = LowerCaseFormMethod | UpperCaseFormMethod;\n\n/**\n * Active navigation/fetcher form methods are exposed in lowercase on the\n * RouterState\n */\nexport type FormMethod = LowerCaseFormMethod;\nexport type MutationFormMethod = Exclude<FormMethod, \"get\">;\n\n/**\n * In v7, active navigation/fetcher form methods are exposed in uppercase on the\n * RouterState.  This is to align with the normalization done via fetch().\n */\nexport type V7_FormMethod = UpperCaseFormMethod;\nexport type V7_MutationFormMethod = Exclude<V7_FormMethod, \"GET\">;\n\nexport type FormEncType =\n  | \"application/x-www-form-urlencoded\"\n  | \"multipart/form-data\"\n  | \"application/json\"\n  | \"text/plain\";\n\n// Thanks https://github.com/sindresorhus/type-fest!\ntype JsonObject = { [Key in string]: JsonValue } & {\n  [Key in string]?: JsonValue | undefined;\n};\ntype JsonArray = JsonValue[] | readonly JsonValue[];\ntype JsonPrimitive = string | number | boolean | null;\ntype JsonValue = JsonPrimitive | JsonObject | JsonArray;\n\n/**\n * @private\n * Internal interface to pass around for action submissions, not intended for\n * external consumption\n */\nexport type Submission =\n  | {\n      formMethod: FormMethod | V7_FormMethod;\n      formAction: string;\n      formEncType: FormEncType;\n      formData: FormData;\n      json: undefined;\n      text: undefined;\n    }\n  | {\n      formMethod: FormMethod | V7_FormMethod;\n      formAction: string;\n      formEncType: FormEncType;\n      formData: undefined;\n      json: JsonValue;\n      text: undefined;\n    }\n  | {\n      formMethod: FormMethod | V7_FormMethod;\n      formAction: string;\n      formEncType: FormEncType;\n      formData: undefined;\n      json: undefined;\n      text: string;\n    };\n\n/**\n * @private\n * Arguments passed to route loader/action functions.  Same for now but we keep\n * this as a private implementation detail in case they diverge in the future.\n */\ninterface DataFunctionArgs<Context> {\n  request: Request;\n  params: Params;\n  context?: Context;\n}\n\n// TODO: (v7) Change the defaults from any to unknown in and remove Remix wrappers:\n//   ActionFunction, ActionFunctionArgs, LoaderFunction, LoaderFunctionArgs\n//   Also, make them a type alias instead of an interface\n\n/**\n * Arguments passed to loader functions\n */\nexport interface LoaderFunctionArgs<Context = any>\n  extends DataFunctionArgs<Context> {}\n\n/**\n * Arguments passed to action functions\n */\nexport interface ActionFunctionArgs<Context = any>\n  extends DataFunctionArgs<Context> {}\n\n/**\n * Loaders and actions can return anything except `undefined` (`null` is a\n * valid return value if there is no data to return).  Responses are preferred\n * and will ease any future migration to Remix\n */\ntype DataFunctionValue = Response | NonNullable<unknown> | null;\n\ntype DataFunctionReturnValue = Promise<DataFunctionValue> | DataFunctionValue;\n\n/**\n * Route loader function signature\n */\nexport type LoaderFunction<Context = any> = {\n  (\n    args: LoaderFunctionArgs<Context>,\n    handlerCtx?: unknown\n  ): DataFunctionReturnValue;\n} & { hydrate?: boolean };\n\n/**\n * Route action function signature\n */\nexport interface ActionFunction<Context = any> {\n  (\n    args: ActionFunctionArgs<Context>,\n    handlerCtx?: unknown\n  ): DataFunctionReturnValue;\n}\n\n/**\n * Arguments passed to shouldRevalidate function\n */\nexport interface ShouldRevalidateFunctionArgs {\n  currentUrl: URL;\n  currentParams: AgnosticDataRouteMatch[\"params\"];\n  nextUrl: URL;\n  nextParams: AgnosticDataRouteMatch[\"params\"];\n  formMethod?: Submission[\"formMethod\"];\n  formAction?: Submission[\"formAction\"];\n  formEncType?: Submission[\"formEncType\"];\n  text?: Submission[\"text\"];\n  formData?: Submission[\"formData\"];\n  json?: Submission[\"json\"];\n  actionStatus?: number;\n  actionResult?: any;\n  defaultShouldRevalidate: boolean;\n}\n\n/**\n * Route shouldRevalidate function signature.  This runs after any submission\n * (navigation or fetcher), so we flatten the navigation/fetcher submission\n * onto the arguments.  It shouldn't matter whether it came from a navigation\n * or a fetcher, what really matters is the URLs and the formData since loaders\n * have to re-run based on the data models that were potentially mutated.\n */\nexport interface ShouldRevalidateFunction {\n  (args: ShouldRevalidateFunctionArgs): boolean;\n}\n\n/**\n * Function provided by the framework-aware layers to set `hasErrorBoundary`\n * from the framework-aware `errorElement` prop\n *\n * @deprecated Use `mapRouteProperties` instead\n */\nexport interface DetectErrorBoundaryFunction {\n  (route: AgnosticRouteObject): boolean;\n}\n\nexport interface DataStrategyMatch\n  extends AgnosticRouteMatch<string, AgnosticDataRouteObject> {\n  shouldLoad: boolean;\n  resolve: (\n    handlerOverride?: (\n      handler: (ctx?: unknown) => DataFunctionReturnValue\n    ) => DataFunctionReturnValue\n  ) => Promise<DataStrategyResult>;\n}\n\nexport interface DataStrategyFunctionArgs<Context = any>\n  extends DataFunctionArgs<Context> {\n  matches: DataStrategyMatch[];\n  fetcherKey: string | null;\n}\n\n/**\n * Result from a loader or action called via dataStrategy\n */\nexport interface DataStrategyResult {\n  type: \"data\" | \"error\";\n  result: unknown; // data, Error, Response, DeferredData, DataWithResponseInit\n}\n\nexport interface DataStrategyFunction {\n  (args: DataStrategyFunctionArgs): Promise<Record<string, DataStrategyResult>>;\n}\n\nexport type AgnosticPatchRoutesOnNavigationFunctionArgs<\n  O extends AgnosticRouteObject = AgnosticRouteObject,\n  M extends AgnosticRouteMatch = AgnosticRouteMatch\n> = {\n  signal: AbortSignal;\n  path: string;\n  matches: M[];\n  fetcherKey: string | undefined;\n  patch: (routeId: string | null, children: O[]) => void;\n};\n\nexport type AgnosticPatchRoutesOnNavigationFunction<\n  O extends AgnosticRouteObject = AgnosticRouteObject,\n  M extends AgnosticRouteMatch = AgnosticRouteMatch\n> = (\n  opts: AgnosticPatchRoutesOnNavigationFunctionArgs<O, M>\n) => void | Promise<void>;\n\n/**\n * Function provided by the framework-aware layers to set any framework-specific\n * properties from framework-agnostic properties\n */\nexport interface MapRoutePropertiesFunction {\n  (route: AgnosticRouteObject): {\n    hasErrorBoundary: boolean;\n  } & Record<string, any>;\n}\n\n/**\n * Keys we cannot change from within a lazy() function. We spread all other keys\n * onto the route. Either they're meaningful to the router, or they'll get\n * ignored.\n */\nexport type ImmutableRouteKey =\n  | \"lazy\"\n  | \"caseSensitive\"\n  | \"path\"\n  | \"id\"\n  | \"index\"\n  | \"children\";\n\nexport const immutableRouteKeys = new Set<ImmutableRouteKey>([\n  \"lazy\",\n  \"caseSensitive\",\n  \"path\",\n  \"id\",\n  \"index\",\n  \"children\",\n]);\n\ntype RequireOne<T, Key = keyof T> = Exclude<\n  {\n    [K in keyof T]: K extends Key ? Omit<T, K> & Required<Pick<T, K>> : never;\n  }[keyof T],\n  undefined\n>;\n\n/**\n * lazy() function to load a route definition, which can add non-matching\n * related properties to a route\n */\nexport interface LazyRouteFunction<R extends AgnosticRouteObject> {\n  (): Promise<RequireOne<Omit<R, ImmutableRouteKey>>>;\n}\n\n/**\n * Base RouteObject with common props shared by all types of routes\n */\ntype AgnosticBaseRouteObject = {\n  caseSensitive?: boolean;\n  path?: string;\n  id?: string;\n  loader?: LoaderFunction | boolean;\n  action?: ActionFunction | boolean;\n  hasErrorBoundary?: boolean;\n  shouldRevalidate?: ShouldRevalidateFunction;\n  handle?: any;\n  lazy?: LazyRouteFunction<AgnosticBaseRouteObject>;\n};\n\n/**\n * Index routes must not have children\n */\nexport type AgnosticIndexRouteObject = AgnosticBaseRouteObject & {\n  children?: undefined;\n  index: true;\n};\n\n/**\n * Non-index routes may have children, but cannot have index\n */\nexport type AgnosticNonIndexRouteObject = AgnosticBaseRouteObject & {\n  children?: AgnosticRouteObject[];\n  index?: false;\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 type AgnosticRouteObject =\n  | AgnosticIndexRouteObject\n  | AgnosticNonIndexRouteObject;\n\nexport type AgnosticDataIndexRouteObject = AgnosticIndexRouteObject & {\n  id: string;\n};\n\nexport type AgnosticDataNonIndexRouteObject = AgnosticNonIndexRouteObject & {\n  children?: AgnosticDataRouteObject[];\n  id: string;\n};\n\n/**\n * A data route object, which is just a RouteObject with a required unique ID\n */\nexport type AgnosticDataRouteObject =\n  | AgnosticDataIndexRouteObject\n  | AgnosticDataNonIndexRouteObject;\n\nexport type RouteManifest = Record<string, AgnosticDataRouteObject | undefined>;\n\n// Recursive helper for finding path parameters in the absence of wildcards\ntype _PathParam<Path extends string> =\n  // split path into individual path segments\n  Path extends `${infer L}/${infer R}`\n    ? _PathParam<L> | _PathParam<R>\n    : // find params after `:`\n    Path extends `:${infer Param}`\n    ? Param extends `${infer Optional}?`\n      ? Optional\n      : Param\n    : // otherwise, there aren't any params present\n      never;\n\n/**\n * Examples:\n * \"/a/b/*\" -> \"*\"\n * \":a\" -> \"a\"\n * \"/a/:b\" -> \"b\"\n * \"/a/blahblahblah:b\" -> \"b\"\n * \"/:a/:b\" -> \"a\" | \"b\"\n * \"/:a/b/:c/*\" -> \"a\" | \"c\" | \"*\"\n */\nexport type PathParam<Path extends string> =\n  // check if path is just a wildcard\n  Path extends \"*\" | \"/*\"\n    ? \"*\"\n    : // look for wildcard at the end of the path\n    Path extends `${infer Rest}/*`\n    ? \"*\" | _PathParam<Rest>\n    : // look for params in the absence of wildcards\n      _PathParam<Path>;\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.\nexport type ParamParseKey<Segment extends string> =\n  // if you could not find path params, fallback to `string`\n  [PathParam<Segment>] extends [never] ? string : PathParam<Segment>;\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 RouteMatch contains info about how a route matched a URL.\n */\nexport interface AgnosticRouteMatch<\n  ParamKey extends string = string,\n  RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject\n> {\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: RouteObjectType;\n}\n\nexport interface AgnosticDataRouteMatch\n  extends AgnosticRouteMatch<string, AgnosticDataRouteObject> {}\n\nfunction isIndexRoute(\n  route: AgnosticRouteObject\n): route is AgnosticIndexRouteObject {\n  return route.index === true;\n}\n\n// Walk the route tree generating unique IDs where necessary, so we are working\n// solely with AgnosticDataRouteObject's within the Router\nexport function convertRoutesToDataRoutes(\n  routes: AgnosticRouteObject[],\n  mapRouteProperties: MapRoutePropertiesFunction,\n  parentPath: string[] = [],\n  manifest: RouteManifest = {}\n): AgnosticDataRouteObject[] {\n  return routes.map((route, index) => {\n    let treePath = [...parentPath, String(index)];\n    let id = typeof route.id === \"string\" ? route.id : treePath.join(\"-\");\n    invariant(\n      route.index !== true || !route.children,\n      `Cannot specify children on an index route`\n    );\n    invariant(\n      !manifest[id],\n      `Found a route id collision on id \"${id}\".  Route ` +\n        \"id's must be globally unique within Data Router usages\"\n    );\n\n    if (isIndexRoute(route)) {\n      let indexRoute: AgnosticDataIndexRouteObject = {\n        ...route,\n        ...mapRouteProperties(route),\n        id,\n      };\n      manifest[id] = indexRoute;\n      return indexRoute;\n    } else {\n      let pathOrLayoutRoute: AgnosticDataNonIndexRouteObject = {\n        ...route,\n        ...mapRouteProperties(route),\n        id,\n        children: undefined,\n      };\n      manifest[id] = pathOrLayoutRoute;\n\n      if (route.children) {\n        pathOrLayoutRoute.children = convertRoutesToDataRoutes(\n          route.children,\n          mapRouteProperties,\n          treePath,\n          manifest\n        );\n      }\n\n      return pathOrLayoutRoute;\n    }\n  });\n}\n\n/**\n * Matches the given routes to a location and returns the match data.\n *\n * @see https://reactrouter.com/v6/utils/match-routes\n */\nexport function matchRoutes<\n  RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject\n>(\n  routes: RouteObjectType[],\n  locationArg: Partial<Location> | string,\n  basename = \"/\"\n): AgnosticRouteMatch<string, RouteObjectType>[] | null {\n  return matchRoutesImpl(routes, locationArg, basename, false);\n}\n\nexport function matchRoutesImpl<\n  RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject\n>(\n  routes: RouteObjectType[],\n  locationArg: Partial<Location> | string,\n  basename: string,\n  allowPartial: boolean\n): AgnosticRouteMatch<string, RouteObjectType>[] | 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    // Incoming pathnames are generally encoded from either window.location\n    // or from router.navigate, but we want to match against the unencoded\n    // paths in the route definitions.  Memory router locations won't be\n    // encoded here but there also shouldn't be anything to decode so this\n    // should be a safe operation.  This avoids needing matchRoutes to be\n    // history-aware.\n    let decoded = decodePath(pathname);\n    matches = matchRouteBranch<string, RouteObjectType>(\n      branches[i],\n      decoded,\n      allowPartial\n    );\n  }\n\n  return matches;\n}\n\nexport interface UIMatch<Data = unknown, Handle = unknown> {\n  id: string;\n  pathname: string;\n  params: AgnosticRouteMatch[\"params\"];\n  data: Data;\n  handle: Handle;\n}\n\nexport function convertRouteMatchToUiMatch(\n  match: AgnosticDataRouteMatch,\n  loaderData: RouteData\n): UIMatch {\n  let { route, pathname, params } = match;\n  return {\n    id: route.id,\n    pathname,\n    params,\n    data: loaderData[route.id],\n    handle: route.handle,\n  };\n}\n\ninterface RouteMeta<\n  RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject\n> {\n  relativePath: string;\n  caseSensitive: boolean;\n  childrenIndex: number;\n  route: RouteObjectType;\n}\n\ninterface RouteBranch<\n  RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject\n> {\n  path: string;\n  score: number;\n  routesMeta: RouteMeta<RouteObjectType>[];\n}\n\nfunction flattenRoutes<\n  RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject\n>(\n  routes: RouteObjectType[],\n  branches: RouteBranch<RouteObjectType>[] = [],\n  parentsMeta: RouteMeta<RouteObjectType>[] = [],\n  parentPath = \"\"\n): RouteBranch<RouteObjectType>[] {\n  let flattenRoute = (\n    route: RouteObjectType,\n    index: number,\n    relativePath?: string\n  ) => {\n    let meta: RouteMeta<RouteObjectType> = {\n      relativePath:\n        relativePath === undefined ? route.path || \"\" : relativePath,\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        // Our types know better, but runtime JS may not!\n        // @ts-expect-error\n        route.index !== true,\n        `Index routes must not have child routes. Please remove ` +\n          `all child routes from route path \"${path}\".`\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({\n      path,\n      score: computeScore(path, route.index),\n      routesMeta,\n    });\n  };\n  routes.forEach((route, index) => {\n    // coarse-grain check for optional params\n    if (route.path === \"\" || !route.path?.includes(\"?\")) {\n      flattenRoute(route, index);\n    } else {\n      for (let exploded of explodeOptionalSegments(route.path)) {\n        flattenRoute(route, index, exploded);\n      }\n    }\n  });\n\n  return branches;\n}\n\n/**\n * Computes all combinations of optional path segments for a given path,\n * excluding combinations that are ambiguous and of lower priority.\n *\n * For example, `/one/:two?/three/:four?/:five?` explodes to:\n * - `/one/three`\n * - `/one/:two/three`\n * - `/one/three/:four`\n * - `/one/three/:five`\n * - `/one/:two/three/:four`\n * - `/one/:two/three/:five`\n * - `/one/three/:four/:five`\n * - `/one/:two/three/:four/:five`\n */\nfunction explodeOptionalSegments(path: string): string[] {\n  let segments = path.split(\"/\");\n  if (segments.length === 0) return [];\n\n  let [first, ...rest] = segments;\n\n  // Optional path segments are denoted by a trailing `?`\n  let isOptional = first.endsWith(\"?\");\n  // Compute the corresponding required segment: `foo?` -> `foo`\n  let required = first.replace(/\\?$/, \"\");\n\n  if (rest.length === 0) {\n    // Intepret empty string as omitting an optional segment\n    // `[\"one\", \"\", \"three\"]` corresponds to omitting `:two` from `/one/:two?/three` -> `/one/three`\n    return isOptional ? [required, \"\"] : [required];\n  }\n\n  let restExploded = explodeOptionalSegments(rest.join(\"/\"));\n\n  let result: string[] = [];\n\n  // All child paths with the prefix.  Do this for all children before the\n  // optional version for all children, so we get consistent ordering where the\n  // parent optional aspect is preferred as required.  Otherwise, we can get\n  // child sections interspersed where deeper optional segments are higher than\n  // parent optional segments, where for example, /:two would explode _earlier_\n  // then /:one.  By always including the parent as required _for all children_\n  // first, we avoid this issue\n  result.push(\n    ...restExploded.map((subpath) =>\n      subpath === \"\" ? required : [required, subpath].join(\"/\")\n    )\n  );\n\n  // Then, if this is an optional value, add all child versions without\n  if (isOptional) {\n    result.push(...restExploded);\n  }\n\n  // for absolute paths, ensure `/` instead of empty segment\n  return result.map((exploded) =>\n    path.startsWith(\"/\") && exploded === \"\" ? \"/\" : exploded\n  );\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<\n  ParamKey extends string = string,\n  RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject\n>(\n  branch: RouteBranch<RouteObjectType>,\n  pathname: string,\n  allowPartial = false\n): AgnosticRouteMatch<ParamKey, RouteObjectType>[] | null {\n  let { routesMeta } = branch;\n\n  let matchedParams = {};\n  let matchedPathname = \"/\";\n  let matches: AgnosticRouteMatch<ParamKey, RouteObjectType>[] = [];\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    let route = meta.route;\n\n    if (\n      !match &&\n      end &&\n      allowPartial &&\n      !routesMeta[routesMeta.length - 1].route.index\n    ) {\n      match = matchPath(\n        {\n          path: meta.relativePath,\n          caseSensitive: meta.caseSensitive,\n          end: false,\n        },\n        remainingPathname\n      );\n    }\n\n    if (!match) {\n      return null;\n    }\n\n    Object.assign(matchedParams, match.params);\n\n    matches.push({\n      // TODO: Can this as be avoided?\n      params: matchedParams as Params<ParamKey>,\n      pathname: joinPaths([matchedPathname, match.pathname]),\n      pathnameBase: normalizePathname(\n        joinPaths([matchedPathname, match.pathnameBase])\n      ),\n      route,\n    });\n\n    if (match.pathnameBase !== \"/\") {\n      matchedPathname = joinPaths([matchedPathname, match.pathnameBase]);\n    }\n  }\n\n  return matches;\n}\n\n/**\n * Returns a path with params interpolated.\n *\n * @see https://reactrouter.com/v6/utils/generate-path\n */\nexport function generatePath<Path extends string>(\n  originalPath: Path,\n  params: {\n    [key in PathParam<Path>]: string | null;\n  } = {} as any\n): string {\n  let path: string = originalPath;\n  if (path.endsWith(\"*\") && path !== \"*\" && !path.endsWith(\"/*\")) {\n    warning(\n      false,\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    path = path.replace(/\\*$/, \"/*\") as Path;\n  }\n\n  // ensure `/` is added at the beginning if the path is absolute\n  const prefix = path.startsWith(\"/\") ? \"/\" : \"\";\n\n  const stringify = (p: any) =>\n    p == null ? \"\" : typeof p === \"string\" ? p : String(p);\n\n  const segments = path\n    .split(/\\/+/)\n    .map((segment, index, array) => {\n      const isLastSegment = index === array.length - 1;\n\n      // only apply the splat if it's the last segment\n      if (isLastSegment && segment === \"*\") {\n        const star = \"*\" as PathParam<Path>;\n        // Apply the splat\n        return stringify(params[star]);\n      }\n\n      const keyMatch = segment.match(/^:([\\w-]+)(\\??)$/);\n      if (keyMatch) {\n        const [, key, optional] = keyMatch;\n        let param = params[key as PathParam<Path>];\n        invariant(optional === \"?\" || param != null, `Missing \":${key}\" param`);\n        return stringify(param);\n      }\n\n      // Remove any optional markers from optional static segments\n      return segment.replace(/\\?$/g, \"\");\n    })\n    // Remove empty segments\n    .filter((segment) => !!segment);\n\n  return prefix + segments.join(\"/\");\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/v6/utils/match-path\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, compiledParams] = 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 = compiledParams.reduce<Mutable<Params>>(\n    (memo, { paramName, isOptional }, 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      const value = captureGroups[index];\n      if (isOptional && !value) {\n        memo[paramName] = undefined;\n      } else {\n        memo[paramName] = (value || \"\").replace(/%2F/g, \"/\");\n      }\n      return memo;\n    },\n    {}\n  );\n\n  return {\n    params,\n    pathname: matchedPathname,\n    pathnameBase,\n    pattern,\n  };\n}\n\ntype CompiledPathParam = { paramName: string; isOptional?: boolean };\n\nfunction compilePath(\n  path: string,\n  caseSensitive = false,\n  end = true\n): [RegExp, CompiledPathParam[]] {\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 params: CompiledPathParam[] = [];\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(\n        /\\/:([\\w-]+)(\\?)?/g,\n        (_: string, paramName: string, isOptional) => {\n          params.push({ paramName, isOptional: isOptional != null });\n          return isOptional ? \"/?([^\\\\/]+)?\" : \"/([^\\\\/]+)\";\n        }\n      );\n\n  if (path.endsWith(\"*\")) {\n    params.push({ paramName: \"*\" });\n    regexpSource +=\n      path === \"*\" || path === \"/*\"\n        ? \"(.*)$\" // Already matched the initial /, just match the rest\n        : \"(?:\\\\/(.+)|\\\\/*)$\"; // Don't include the / in params[\"*\"]\n  } else if (end) {\n    // When matching to the end, ignore trailing slashes\n    regexpSource += \"\\\\/*$\";\n  } else if (path !== \"\" && path !== \"/\") {\n    // If our path is non-empty and contains anything beyond an initial slash,\n    // then we have _some_ form of path in our regex, so we should expect to\n    // match only if we find the end of this path segment.  Look for an optional\n    // non-captured trailing slash (to match a portion of the URL) or the end\n    // of the path (if we've matched to the end).  We used to do this with a\n    // word boundary but that gives false positives on routes like\n    // /user-preferences since `-` counts as a word boundary.\n    regexpSource += \"(?:(?=\\\\/|$))\";\n  } else {\n    // Nothing to match for \"\" or \"/\"\n  }\n\n  let matcher = new RegExp(regexpSource, caseSensitive ? undefined : \"i\");\n\n  return [matcher, params];\n}\n\nexport function decodePath(value: string) {\n  try {\n    return value\n      .split(\"/\")\n      .map((v) => decodeURIComponent(v).replace(/\\//g, \"%2F\"))\n      .join(\"/\");\n  } catch (error) {\n    warning(\n      false,\n      `The URL path \"${value}\" could not be decoded because it is is a ` +\n        `malformed URL segment. This is probably due to a bad percent ` +\n        `encoding (${error}).`\n    );\n\n    return value;\n  }\n}\n\n/**\n * @private\n */\nexport function stripBasename(\n  pathname: string,\n  basename: string\n): string | null {\n  if (basename === \"/\") return pathname;\n\n  if (!pathname.toLowerCase().startsWith(basename.toLowerCase())) {\n    return null;\n  }\n\n  // We want to leave trailing slash behavior in the user's control, so if they\n  // specify a basename with a trailing slash, we should support it\n  let startIndex = basename.endsWith(\"/\")\n    ? basename.length - 1\n    : basename.length;\n  let nextChar = pathname.charAt(startIndex);\n  if (nextChar && nextChar !== \"/\") {\n    // pathname does not start with basename/\n    return null;\n  }\n\n  return pathname.slice(startIndex) || \"/\";\n}\n\nconst ABSOLUTE_URL_REGEX = /^(?:[a-z][a-z0-9+.-]*:|\\/\\/)/i;\nexport const isAbsoluteUrl = (url: string) => ABSOLUTE_URL_REGEX.test(url);\n\n/**\n * Returns a resolved path object relative to the given pathname.\n *\n * @see https://reactrouter.com/v6/utils/resolve-path\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: string;\n  if (toPathname) {\n    if (isAbsoluteUrl(toPathname)) {\n      pathname = toPathname;\n    } else {\n      if (toPathname.includes(\"//\")) {\n        let oldPathname = toPathname;\n        toPathname = toPathname.replace(/\\/\\/+/g, \"/\");\n        warning(\n          false,\n          `Pathnames cannot have embedded double slashes - normalizing ` +\n            `${oldPathname} -> ${toPathname}`\n        );\n      }\n      if (toPathname.startsWith(\"/\")) {\n        pathname = resolvePathname(toPathname.substring(1), \"/\");\n      } else {\n        pathname = resolvePathname(toPathname, fromPathname);\n      }\n    }\n  } else {\n    pathname = fromPathname;\n  }\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 getInvalidPathError(\n  char: string,\n  field: string,\n  dest: string,\n  path: Partial<Path>\n) {\n  return (\n    `Cannot include a '${char}' character in a manually specified ` +\n    `\\`to.${field}\\` field [${JSON.stringify(\n      path\n    )}].  Please separate it out to the ` +\n    `\\`to.${dest}\\` field. Alternatively you may provide the full path as ` +\n    `a string in <Link to=\"...\"> and the router will parse it for you.`\n  );\n}\n\n/**\n * @private\n *\n * When processing relative navigation we want to ignore ancestor routes that\n * do not contribute to the path, such that index/pathless layout routes don't\n * interfere.\n *\n * For example, when moving a route element into an index route and/or a\n * pathless layout route, relative link behavior contained within should stay\n * the same.  Both of the following examples should link back to the root:\n *\n *   <Route path=\"/\">\n *     <Route path=\"accounts\" element={<Link to=\"..\"}>\n *   </Route>\n *\n *   <Route path=\"/\">\n *     <Route path=\"accounts\">\n *       <Route element={<AccountsLayout />}>       // <-- Does not contribute\n *         <Route index element={<Link to=\"..\"} />  // <-- Does not contribute\n *       </Route\n *     </Route>\n *   </Route>\n */\nexport function getPathContributingMatches<\n  T extends AgnosticRouteMatch = AgnosticRouteMatch\n>(matches: T[]) {\n  return matches.filter(\n    (match, index) =>\n      index === 0 || (match.route.path && match.route.path.length > 0)\n  );\n}\n\n// Return the array of pathnames for the current route matches - used to\n// generate the routePathnames input for resolveTo()\nexport function getResolveToMatches<\n  T extends AgnosticRouteMatch = AgnosticRouteMatch\n>(matches: T[], v7_relativeSplatPath: boolean) {\n  let pathMatches = getPathContributingMatches(matches);\n\n  // When v7_relativeSplatPath is enabled, use the full pathname for the leaf\n  // match so we include splat values for \".\" links.  See:\n  // https://github.com/remix-run/react-router/issues/11052#issuecomment-1836589329\n  if (v7_relativeSplatPath) {\n    return pathMatches.map((match, idx) =>\n      idx === pathMatches.length - 1 ? match.pathname : match.pathnameBase\n    );\n  }\n\n  return pathMatches.map((match) => match.pathnameBase);\n}\n\n/**\n * @private\n */\nexport function resolveTo(\n  toArg: To,\n  routePathnames: string[],\n  locationPathname: string,\n  isPathRelative = false\n): Path {\n  let to: Partial<Path>;\n  if (typeof toArg === \"string\") {\n    to = parsePath(toArg);\n  } else {\n    to = { ...toArg };\n\n    invariant(\n      !to.pathname || !to.pathname.includes(\"?\"),\n      getInvalidPathError(\"?\", \"pathname\", \"search\", to)\n    );\n    invariant(\n      !to.pathname || !to.pathname.includes(\"#\"),\n      getInvalidPathError(\"#\", \"pathname\", \"hash\", to)\n    );\n    invariant(\n      !to.search || !to.search.includes(\"#\"),\n      getInvalidPathError(\"#\", \"search\", \"hash\", to)\n    );\n  }\n\n  let isEmptyPath = toArg === \"\" || to.pathname === \"\";\n  let toPathname = isEmptyPath ? \"/\" : to.pathname;\n\n  let from: string;\n\n  // Routing is relative to the current pathname if explicitly requested.\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  if (toPathname == null) {\n    from = locationPathname;\n  } else {\n    let routePathnameIndex = routePathnames.length - 1;\n\n    // With relative=\"route\" (the default), each leading .. segment means\n    // \"go up one route\" instead of \"go up one URL segment\".  This is a key\n    // difference from how <a href> works and a major reason we call this a\n    // \"to\" value instead of a \"href\".\n    if (!isPathRelative && toPathname.startsWith(\"..\")) {\n      let toSegments = toPathname.split(\"/\");\n\n      while (toSegments[0] === \"..\") {\n        toSegments.shift();\n        routePathnameIndex -= 1;\n      }\n\n      to.pathname = toSegments.join(\"/\");\n    }\n\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\" had one\n  let hasExplicitTrailingSlash =\n    toPathname && toPathname !== \"/\" && toPathname.endsWith(\"/\");\n  // Or if this was a link to the current path which has a trailing slash\n  let hasCurrentTrailingSlash =\n    (isEmptyPath || toPathname === \".\") && locationPathname.endsWith(\"/\");\n  if (\n    !path.pathname.endsWith(\"/\") &&\n    (hasExplicitTrailingSlash || hasCurrentTrailingSlash)\n  ) {\n    path.pathname += \"/\";\n  }\n\n  return path;\n}\n\n/**\n * @private\n */\nexport function 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\n/**\n * @private\n */\nexport const joinPaths = (paths: string[]): string =>\n  paths.join(\"/\").replace(/\\/\\/+/g, \"/\");\n\n/**\n * @private\n */\nexport const normalizePathname = (pathname: string): string =>\n  pathname.replace(/\\/+$/, \"\").replace(/^\\/*/, \"/\");\n\n/**\n * @private\n */\nexport const normalizeSearch = (search: string): string =>\n  !search || search === \"?\"\n    ? \"\"\n    : search.startsWith(\"?\")\n    ? search\n    : \"?\" + search;\n\n/**\n * @private\n */\nexport const normalizeHash = (hash: string): string =>\n  !hash || hash === \"#\" ? \"\" : hash.startsWith(\"#\") ? hash : \"#\" + hash;\n\nexport type JsonFunction = <Data>(\n  data: Data,\n  init?: number | ResponseInit\n) => Response;\n\n/**\n * This is a shortcut for creating `application/json` responses. Converts `data`\n * to JSON and sets the `Content-Type` header.\n *\n * @deprecated The `json` method is deprecated in favor of returning raw objects.\n * This method will be removed in v7.\n */\nexport const json: JsonFunction = (data, init = {}) => {\n  let responseInit = typeof init === \"number\" ? { status: init } : init;\n\n  let headers = new Headers(responseInit.headers);\n  if (!headers.has(\"Content-Type\")) {\n    headers.set(\"Content-Type\", \"application/json; charset=utf-8\");\n  }\n\n  return new Response(JSON.stringify(data), {\n    ...responseInit,\n    headers,\n  });\n};\n\nexport class DataWithResponseInit<D> {\n  type: string = \"DataWithResponseInit\";\n  data: D;\n  init: ResponseInit | null;\n\n  constructor(data: D, init?: ResponseInit) {\n    this.data = data;\n    this.init = init || null;\n  }\n}\n\n/**\n * Create \"responses\" that contain `status`/`headers` without forcing\n * serialization into an actual `Response` - used by Remix single fetch\n */\nexport function data<D>(data: D, init?: number | ResponseInit) {\n  return new DataWithResponseInit(\n    data,\n    typeof init === \"number\" ? { status: init } : init\n  );\n}\n\nexport interface TrackedPromise extends Promise<any> {\n  _tracked?: boolean;\n  _data?: any;\n  _error?: any;\n}\n\nexport class AbortedDeferredError extends Error {}\n\nexport class DeferredData {\n  private pendingKeysSet: Set<string> = new Set<string>();\n  private controller: AbortController;\n  private abortPromise: Promise<void>;\n  private unlistenAbortSignal: () => void;\n  private subscribers: Set<(aborted: boolean, settledKey?: string) => void> =\n    new Set();\n  data: Record<string, unknown>;\n  init?: ResponseInit;\n  deferredKeys: string[] = [];\n\n  constructor(data: Record<string, unknown>, responseInit?: ResponseInit) {\n    invariant(\n      data && typeof data === \"object\" && !Array.isArray(data),\n      \"defer() only accepts plain objects\"\n    );\n\n    // Set up an AbortController + Promise we can race against to exit early\n    // cancellation\n    let reject: (e: AbortedDeferredError) => void;\n    this.abortPromise = new Promise((_, r) => (reject = r));\n    this.controller = new AbortController();\n    let onAbort = () =>\n      reject(new AbortedDeferredError(\"Deferred data aborted\"));\n    this.unlistenAbortSignal = () =>\n      this.controller.signal.removeEventListener(\"abort\", onAbort);\n    this.controller.signal.addEventListener(\"abort\", onAbort);\n\n    this.data = Object.entries(data).reduce(\n      (acc, [key, value]) =>\n        Object.assign(acc, {\n          [key]: this.trackPromise(key, value),\n        }),\n      {}\n    );\n\n    if (this.done) {\n      // All incoming values were resolved\n      this.unlistenAbortSignal();\n    }\n\n    this.init = responseInit;\n  }\n\n  private trackPromise(\n    key: string,\n    value: Promise<unknown> | unknown\n  ): TrackedPromise | unknown {\n    if (!(value instanceof Promise)) {\n      return value;\n    }\n\n    this.deferredKeys.push(key);\n    this.pendingKeysSet.add(key);\n\n    // We store a little wrapper promise that will be extended with\n    // _data/_error props upon resolve/reject\n    let promise: TrackedPromise = Promise.race([value, this.abortPromise]).then(\n      (data) => this.onSettle(promise, key, undefined, data as unknown),\n      (error) => this.onSettle(promise, key, error as unknown)\n    );\n\n    // Register rejection listeners to avoid uncaught promise rejections on\n    // errors or aborted deferred values\n    promise.catch(() => {});\n\n    Object.defineProperty(promise, \"_tracked\", { get: () => true });\n    return promise;\n  }\n\n  private onSettle(\n    promise: TrackedPromise,\n    key: string,\n    error: unknown,\n    data?: unknown\n  ): unknown {\n    if (\n      this.controller.signal.aborted &&\n      error instanceof AbortedDeferredError\n    ) {\n      this.unlistenAbortSignal();\n      Object.defineProperty(promise, \"_error\", { get: () => error });\n      return Promise.reject(error);\n    }\n\n    this.pendingKeysSet.delete(key);\n\n    if (this.done) {\n      // Nothing left to abort!\n      this.unlistenAbortSignal();\n    }\n\n    // If the promise was resolved/rejected with undefined, we'll throw an error as you\n    // should always resolve with a value or null\n    if (error === undefined && data === undefined) {\n      let undefinedError = new Error(\n        `Deferred data for key \"${key}\" resolved/rejected with \\`undefined\\`, ` +\n          `you must resolve/reject with a value or \\`null\\`.`\n      );\n      Object.defineProperty(promise, \"_error\", { get: () => undefinedError });\n      this.emit(false, key);\n      return Promise.reject(undefinedError);\n    }\n\n    if (data === undefined) {\n      Object.defineProperty(promise, \"_error\", { get: () => error });\n      this.emit(false, key);\n      return Promise.reject(error);\n    }\n\n    Object.defineProperty(promise, \"_data\", { get: () => data });\n    this.emit(false, key);\n    return data;\n  }\n\n  private emit(aborted: boolean, settledKey?: string) {\n    this.subscribers.forEach((subscriber) => subscriber(aborted, settledKey));\n  }\n\n  subscribe(fn: (aborted: boolean, settledKey?: string) => void) {\n    this.subscribers.add(fn);\n    return () => this.subscribers.delete(fn);\n  }\n\n  cancel() {\n    this.controller.abort();\n    this.pendingKeysSet.forEach((v, k) => this.pendingKeysSet.delete(k));\n    this.emit(true);\n  }\n\n  async resolveData(signal: AbortSignal) {\n    let aborted = false;\n    if (!this.done) {\n      let onAbort = () => this.cancel();\n      signal.addEventListener(\"abort\", onAbort);\n      aborted = await new Promise((resolve) => {\n        this.subscribe((aborted) => {\n          signal.removeEventListener(\"abort\", onAbort);\n          if (aborted || this.done) {\n            resolve(aborted);\n          }\n        });\n      });\n    }\n    return aborted;\n  }\n\n  get done() {\n    return this.pendingKeysSet.size === 0;\n  }\n\n  get unwrappedData() {\n    invariant(\n      this.data !== null && this.done,\n      \"Can only unwrap data on initialized and settled deferreds\"\n    );\n\n    return Object.entries(this.data).reduce(\n      (acc, [key, value]) =>\n        Object.assign(acc, {\n          [key]: unwrapTrackedPromise(value),\n        }),\n      {}\n    );\n  }\n\n  get pendingKeys() {\n    return Array.from(this.pendingKeysSet);\n  }\n}\n\nfunction isTrackedPromise(value: any): value is TrackedPromise {\n  return (\n    value instanceof Promise && (value as TrackedPromise)._tracked === true\n  );\n}\n\nfunction unwrapTrackedPromise(value: any) {\n  if (!isTrackedPromise(value)) {\n    return value;\n  }\n\n  if (value._error) {\n    throw value._error;\n  }\n  return value._data;\n}\n\nexport type DeferFunction = (\n  data: Record<string, unknown>,\n  init?: number | ResponseInit\n) => DeferredData;\n\n/**\n * @deprecated The `defer` method is deprecated in favor of returning raw\n * objects. This method will be removed in v7.\n */\nexport const defer: DeferFunction = (data, init = {}) => {\n  let responseInit = typeof init === \"number\" ? { status: init } : init;\n\n  return new DeferredData(data, responseInit);\n};\n\nexport type RedirectFunction = (\n  url: string,\n  init?: number | ResponseInit\n) => Response;\n\n/**\n * A redirect response. Sets the status code and the `Location` header.\n * Defaults to \"302 Found\".\n */\nexport const redirect: RedirectFunction = (url, init = 302) => {\n  let responseInit = init;\n  if (typeof responseInit === \"number\") {\n    responseInit = { status: responseInit };\n  } else if (typeof responseInit.status === \"undefined\") {\n    responseInit.status = 302;\n  }\n\n  let headers = new Headers(responseInit.headers);\n  headers.set(\"Location\", url);\n\n  return new Response(null, {\n    ...responseInit,\n    headers,\n  });\n};\n\n/**\n * A redirect response that will force a document reload to the new location.\n * Sets the status code and the `Location` header.\n * Defaults to \"302 Found\".\n */\nexport const redirectDocument: RedirectFunction = (url, init) => {\n  let response = redirect(url, init);\n  response.headers.set(\"X-Remix-Reload-Document\", \"true\");\n  return response;\n};\n\n/**\n * A redirect response that will perform a `history.replaceState` instead of a\n * `history.pushState` for client-side navigation redirects.\n * Sets the status code and the `Location` header.\n * Defaults to \"302 Found\".\n */\nexport const replace: RedirectFunction = (url, init) => {\n  let response = redirect(url, init);\n  response.headers.set(\"X-Remix-Replace\", \"true\");\n  return response;\n};\n\nexport type ErrorResponse = {\n  status: number;\n  statusText: string;\n  data: any;\n};\n\n/**\n * @private\n * Utility class we use to hold auto-unwrapped 4xx/5xx Response bodies\n *\n * We don't export the class for public use since it's an implementation\n * detail, but we export the interface above so folks can build their own\n * abstractions around instances via isRouteErrorResponse()\n */\nexport class ErrorResponseImpl implements ErrorResponse {\n  status: number;\n  statusText: string;\n  data: any;\n  private error?: Error;\n  private internal: boolean;\n\n  constructor(\n    status: number,\n    statusText: string | undefined,\n    data: any,\n    internal = false\n  ) {\n    this.status = status;\n    this.statusText = statusText || \"\";\n    this.internal = internal;\n    if (data instanceof Error) {\n      this.data = data.toString();\n      this.error = data;\n    } else {\n      this.data = data;\n    }\n  }\n}\n\n/**\n * Check if the given error is an ErrorResponse generated from a 4xx/5xx\n * Response thrown from an action/loader\n */\nexport function isRouteErrorResponse(error: any): error is ErrorResponse {\n  return (\n    error != null &&\n    typeof error.status === \"number\" &&\n    typeof error.statusText === \"string\" &&\n    typeof error.internal === \"boolean\" &&\n    \"data\" in error\n  );\n}\n","import type { History, Location, Path, To } from \"./history\";\nimport {\n  Action as HistoryAction,\n  createLocation,\n  createPath,\n  invariant,\n  parsePath,\n  warning,\n} from \"./history\";\nimport type {\n  AgnosticDataRouteMatch,\n  AgnosticDataRouteObject,\n  DataStrategyMatch,\n  AgnosticRouteObject,\n  DataResult,\n  DataStrategyFunction,\n  DataStrategyFunctionArgs,\n  DeferredData,\n  DeferredResult,\n  DetectErrorBoundaryFunction,\n  ErrorResult,\n  FormEncType,\n  FormMethod,\n  HTMLFormMethod,\n  DataStrategyResult,\n  ImmutableRouteKey,\n  MapRoutePropertiesFunction,\n  MutationFormMethod,\n  RedirectResult,\n  RouteData,\n  RouteManifest,\n  ShouldRevalidateFunctionArgs,\n  Submission,\n  SuccessResult,\n  UIMatch,\n  V7_FormMethod,\n  V7_MutationFormMethod,\n  AgnosticPatchRoutesOnNavigationFunction,\n  DataWithResponseInit,\n} from \"./utils\";\nimport {\n  ErrorResponseImpl,\n  ResultType,\n  convertRouteMatchToUiMatch,\n  convertRoutesToDataRoutes,\n  getPathContributingMatches,\n  getResolveToMatches,\n  immutableRouteKeys,\n  isRouteErrorResponse,\n  joinPaths,\n  matchRoutes,\n  matchRoutesImpl,\n  resolveTo,\n  stripBasename,\n} from \"./utils\";\n\n////////////////////////////////////////////////////////////////////////////////\n//#region Types and Constants\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * A Router instance manages all navigation and data loading/mutations\n */\nexport interface Router {\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Return the basename for the router\n   */\n  get basename(): RouterInit[\"basename\"];\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Return the future config for the router\n   */\n  get future(): FutureConfig;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Return the current state of the router\n   */\n  get state(): RouterState;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Return the routes for this router instance\n   */\n  get routes(): AgnosticDataRouteObject[];\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Return the window associated with the router\n   */\n  get window(): RouterInit[\"window\"];\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Initialize the router, including adding history listeners and kicking off\n   * initial data fetches.  Returns a function to cleanup listeners and abort\n   * any in-progress loads\n   */\n  initialize(): Router;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Subscribe to router.state updates\n   *\n   * @param fn function to call with the new state\n   */\n  subscribe(fn: RouterSubscriber): () => void;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Enable scroll restoration behavior in the router\n   *\n   * @param savedScrollPositions Object that will manage positions, in case\n   *                             it's being restored from sessionStorage\n   * @param getScrollPosition    Function to get the active Y scroll position\n   * @param getKey               Function to get the key to use for restoration\n   */\n  enableScrollRestoration(\n    savedScrollPositions: Record<string, number>,\n    getScrollPosition: GetScrollPositionFunction,\n    getKey?: GetScrollRestorationKeyFunction\n  ): () => void;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Navigate forward/backward in the history stack\n   * @param to Delta to move in the history stack\n   */\n  navigate(to: number): Promise<void>;\n\n  /**\n   * Navigate to the given path\n   * @param to Path to navigate to\n   * @param opts Navigation options (method, submission, etc.)\n   */\n  navigate(to: To | null, opts?: RouterNavigateOptions): Promise<void>;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Trigger a fetcher load/submission\n   *\n   * @param key     Fetcher key\n   * @param routeId Route that owns the fetcher\n   * @param href    href to fetch\n   * @param opts    Fetcher options, (method, submission, etc.)\n   */\n  fetch(\n    key: string,\n    routeId: string,\n    href: string | null,\n    opts?: RouterFetchOptions\n  ): void;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Trigger a revalidation of all current route loaders and fetcher loads\n   */\n  revalidate(): void;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Utility function to create an href for the given location\n   * @param location\n   */\n  createHref(location: Location | URL): string;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Utility function to URL encode a destination path according to the internal\n   * history implementation\n   * @param to\n   */\n  encodeLocation(to: To): Path;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Get/create a fetcher for the given key\n   * @param key\n   */\n  getFetcher<TData = any>(key: string): Fetcher<TData>;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Delete the fetcher for a given key\n   * @param key\n   */\n  deleteFetcher(key: string): void;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Cleanup listeners and abort any in-progress loads\n   */\n  dispose(): void;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Get a navigation blocker\n   * @param key The identifier for the blocker\n   * @param fn The blocker function implementation\n   */\n  getBlocker(key: string, fn: BlockerFunction): Blocker;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Delete a navigation blocker\n   * @param key The identifier for the blocker\n   */\n  deleteBlocker(key: string): void;\n\n  /**\n   * @internal\n   * PRIVATE DO NOT USE\n   *\n   * Patch additional children routes into an existing parent route\n   * @param routeId The parent route id or a callback function accepting `patch`\n   *                to perform batch patching\n   * @param children The additional children routes\n   */\n  patchRoutes(routeId: string | null, children: AgnosticRouteObject[]): void;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * HMR needs to pass in-flight route updates to React Router\n   * TODO: Replace this with granular route update APIs (addRoute, updateRoute, deleteRoute)\n   */\n  _internalSetRoutes(routes: AgnosticRouteObject[]): void;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Internal fetch AbortControllers accessed by unit tests\n   */\n  _internalFetchControllers: Map<string, AbortController>;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Internal pending DeferredData instances accessed by unit tests\n   */\n  _internalActiveDeferreds: Map<string, DeferredData>;\n}\n\n/**\n * State maintained internally by the router.  During a navigation, all states\n * reflect the the \"old\" location unless otherwise noted.\n */\nexport interface RouterState {\n  /**\n   * The action of the most recent navigation\n   */\n  historyAction: HistoryAction;\n\n  /**\n   * The current location reflected by the router\n   */\n  location: Location;\n\n  /**\n   * The current set of route matches\n   */\n  matches: AgnosticDataRouteMatch[];\n\n  /**\n   * Tracks whether we've completed our initial data load\n   */\n  initialized: boolean;\n\n  /**\n   * Current scroll position we should start at for a new view\n   *  - number -> scroll position to restore to\n   *  - false -> do not restore scroll at all (used during submissions)\n   *  - null -> don't have a saved position, scroll to hash or top of page\n   */\n  restoreScrollPosition: number | false | null;\n\n  /**\n   * Indicate whether this navigation should skip resetting the scroll position\n   * if we are unable to restore the scroll position\n   */\n  preventScrollReset: boolean;\n\n  /**\n   * Tracks the state of the current navigation\n   */\n  navigation: Navigation;\n\n  /**\n   * Tracks any in-progress revalidations\n   */\n  revalidation: RevalidationState;\n\n  /**\n   * Data from the loaders for the current matches\n   */\n  loaderData: RouteData;\n\n  /**\n   * Data from the action for the current matches\n   */\n  actionData: RouteData | null;\n\n  /**\n   * Errors caught from loaders for the current matches\n   */\n  errors: RouteData | null;\n\n  /**\n   * Map of current fetchers\n   */\n  fetchers: Map<string, Fetcher>;\n\n  /**\n   * Map of current blockers\n   */\n  blockers: Map<string, Blocker>;\n}\n\n/**\n * Data that can be passed into hydrate a Router from SSR\n */\nexport type HydrationState = Partial<\n  Pick<RouterState, \"loaderData\" | \"actionData\" | \"errors\">\n>;\n\n/**\n * Future flags to toggle new feature behavior\n */\nexport interface FutureConfig {\n  v7_fetcherPersist: boolean;\n  v7_normalizeFormMethod: boolean;\n  v7_partialHydration: boolean;\n  v7_prependBasename: boolean;\n  v7_relativeSplatPath: boolean;\n  v7_skipActionErrorRevalidation: boolean;\n}\n\n/**\n * Initialization options for createRouter\n */\nexport interface RouterInit {\n  routes: AgnosticRouteObject[];\n  history: History;\n  basename?: string;\n  /**\n   * @deprecated Use `mapRouteProperties` instead\n   */\n  detectErrorBoundary?: DetectErrorBoundaryFunction;\n  mapRouteProperties?: MapRoutePropertiesFunction;\n  future?: Partial<FutureConfig>;\n  hydrationData?: HydrationState;\n  window?: Window;\n  dataStrategy?: DataStrategyFunction;\n  patchRoutesOnNavigation?: AgnosticPatchRoutesOnNavigationFunction;\n}\n\n/**\n * State returned from a server-side query() call\n */\nexport interface StaticHandlerContext {\n  basename: Router[\"basename\"];\n  location: RouterState[\"location\"];\n  matches: RouterState[\"matches\"];\n  loaderData: RouterState[\"loaderData\"];\n  actionData: RouterState[\"actionData\"];\n  errors: RouterState[\"errors\"];\n  statusCode: number;\n  loaderHeaders: Record<string, Headers>;\n  actionHeaders: Record<string, Headers>;\n  activeDeferreds: Record<string, DeferredData> | null;\n  _deepestRenderedBoundaryId?: string | null;\n}\n\n/**\n * A StaticHandler instance manages a singular SSR navigation/fetch event\n */\nexport interface StaticHandler {\n  dataRoutes: AgnosticDataRouteObject[];\n  query(\n    request: Request,\n    opts?: {\n      requestContext?: unknown;\n      skipLoaderErrorBubbling?: boolean;\n      dataStrategy?: DataStrategyFunction;\n    }\n  ): Promise<StaticHandlerContext | Response>;\n  queryRoute(\n    request: Request,\n    opts?: {\n      routeId?: string;\n      requestContext?: unknown;\n      dataStrategy?: DataStrategyFunction;\n    }\n  ): Promise<any>;\n}\n\ntype ViewTransitionOpts = {\n  currentLocation: Location;\n  nextLocation: Location;\n};\n\n/**\n * Subscriber function signature for changes to router state\n */\nexport interface RouterSubscriber {\n  (\n    state: RouterState,\n    opts: {\n      deletedFetchers: string[];\n      viewTransitionOpts?: ViewTransitionOpts;\n      flushSync: boolean;\n    }\n  ): void;\n}\n\n/**\n * Function signature for determining the key to be used in scroll restoration\n * for a given location\n */\nexport interface GetScrollRestorationKeyFunction {\n  (location: Location, matches: UIMatch[]): string | null;\n}\n\n/**\n * Function signature for determining the current scroll position\n */\nexport interface GetScrollPositionFunction {\n  (): number;\n}\n\nexport type RelativeRoutingType = \"route\" | \"path\";\n\n// Allowed for any navigation or fetch\ntype BaseNavigateOrFetchOptions = {\n  preventScrollReset?: boolean;\n  relative?: RelativeRoutingType;\n  flushSync?: boolean;\n};\n\n// Only allowed for navigations\ntype BaseNavigateOptions = BaseNavigateOrFetchOptions & {\n  replace?: boolean;\n  state?: any;\n  fromRouteId?: string;\n  viewTransition?: boolean;\n};\n\n// Only allowed for submission navigations\ntype BaseSubmissionOptions = {\n  formMethod?: HTMLFormMethod;\n  formEncType?: FormEncType;\n} & (\n  | { formData: FormData; body?: undefined }\n  | { formData?: undefined; body: any }\n);\n\n/**\n * Options for a navigate() call for a normal (non-submission) navigation\n */\ntype LinkNavigateOptions = BaseNavigateOptions;\n\n/**\n * Options for a navigate() call for a submission navigation\n */\ntype SubmissionNavigateOptions = BaseNavigateOptions & BaseSubmissionOptions;\n\n/**\n * Options to pass to navigate() for a navigation\n */\nexport type RouterNavigateOptions =\n  | LinkNavigateOptions\n  | SubmissionNavigateOptions;\n\n/**\n * Options for a fetch() load\n */\ntype LoadFetchOptions = BaseNavigateOrFetchOptions;\n\n/**\n * Options for a fetch() submission\n */\ntype SubmitFetchOptions = BaseNavigateOrFetchOptions & BaseSubmissionOptions;\n\n/**\n * Options to pass to fetch()\n */\nexport type RouterFetchOptions = LoadFetchOptions | SubmitFetchOptions;\n\n/**\n * Potential states for state.navigation\n */\nexport type NavigationStates = {\n  Idle: {\n    state: \"idle\";\n    location: undefined;\n    formMethod: undefined;\n    formAction: undefined;\n    formEncType: undefined;\n    formData: undefined;\n    json: undefined;\n    text: undefined;\n  };\n  Loading: {\n    state: \"loading\";\n    location: Location;\n    formMethod: Submission[\"formMethod\"] | undefined;\n    formAction: Submission[\"formAction\"] | undefined;\n    formEncType: Submission[\"formEncType\"] | undefined;\n    formData: Submission[\"formData\"] | undefined;\n    json: Submission[\"json\"] | undefined;\n    text: Submission[\"text\"] | undefined;\n  };\n  Submitting: {\n    state: \"submitting\";\n    location: Location;\n    formMethod: Submission[\"formMethod\"];\n    formAction: Submission[\"formAction\"];\n    formEncType: Submission[\"formEncType\"];\n    formData: Submission[\"formData\"];\n    json: Submission[\"json\"];\n    text: Submission[\"text\"];\n  };\n};\n\nexport type Navigation = NavigationStates[keyof NavigationStates];\n\nexport type RevalidationState = \"idle\" | \"loading\";\n\n/**\n * Potential states for fetchers\n */\ntype FetcherStates<TData = any> = {\n  Idle: {\n    state: \"idle\";\n    formMethod: undefined;\n    formAction: undefined;\n    formEncType: undefined;\n    text: undefined;\n    formData: undefined;\n    json: undefined;\n    data: TData | undefined;\n  };\n  Loading: {\n    state: \"loading\";\n    formMethod: Submission[\"formMethod\"] | undefined;\n    formAction: Submission[\"formAction\"] | undefined;\n    formEncType: Submission[\"formEncType\"] | undefined;\n    text: Submission[\"text\"] | undefined;\n    formData: Submission[\"formData\"] | undefined;\n    json: Submission[\"json\"] | undefined;\n    data: TData | undefined;\n  };\n  Submitting: {\n    state: \"submitting\";\n    formMethod: Submission[\"formMethod\"];\n    formAction: Submission[\"formAction\"];\n    formEncType: Submission[\"formEncType\"];\n    text: Submission[\"text\"];\n    formData: Submission[\"formData\"];\n    json: Submission[\"json\"];\n    data: TData | undefined;\n  };\n};\n\nexport type Fetcher<TData = any> =\n  FetcherStates<TData>[keyof FetcherStates<TData>];\n\ninterface BlockerBlocked {\n  state: \"blocked\";\n  reset(): void;\n  proceed(): void;\n  location: Location;\n}\n\ninterface BlockerUnblocked {\n  state: \"unblocked\";\n  reset: undefined;\n  proceed: undefined;\n  location: undefined;\n}\n\ninterface BlockerProceeding {\n  state: \"proceeding\";\n  reset: undefined;\n  proceed: undefined;\n  location: Location;\n}\n\nexport type Blocker = BlockerUnblocked | BlockerBlocked | BlockerProceeding;\n\nexport type BlockerFunction = (args: {\n  currentLocation: Location;\n  nextLocation: Location;\n  historyAction: HistoryAction;\n}) => boolean;\n\ninterface ShortCircuitable {\n  /**\n   * startNavigation does not need to complete the navigation because we\n   * redirected or got interrupted\n   */\n  shortCircuited?: boolean;\n}\n\ntype PendingActionResult = [string, SuccessResult | ErrorResult];\n\ninterface HandleActionResult extends ShortCircuitable {\n  /**\n   * Route matches which may have been updated from fog of war discovery\n   */\n  matches?: RouterState[\"matches\"];\n  /**\n   * Tuple for the returned or thrown value from the current action.  The routeId\n   * is the action route for success and the bubbled boundary route for errors.\n   */\n  pendingActionResult?: PendingActionResult;\n}\n\ninterface HandleLoadersResult extends ShortCircuitable {\n  /**\n   * Route matches which may have been updated from fog of war discovery\n   */\n  matches?: RouterState[\"matches\"];\n  /**\n   * loaderData returned from the current set of loaders\n   */\n  loaderData?: RouterState[\"loaderData\"];\n  /**\n   * errors thrown from the current set of loaders\n   */\n  errors?: RouterState[\"errors\"];\n}\n\n/**\n * Cached info for active fetcher.load() instances so they can participate\n * in revalidation\n */\ninterface FetchLoadMatch {\n  routeId: string;\n  path: string;\n}\n\n/**\n * Identified fetcher.load() calls that need to be revalidated\n */\ninterface RevalidatingFetcher extends FetchLoadMatch {\n  key: string;\n  match: AgnosticDataRouteMatch | null;\n  matches: AgnosticDataRouteMatch[] | null;\n  controller: AbortController | null;\n}\n\nconst validMutationMethodsArr: MutationFormMethod[] = [\n  \"post\",\n  \"put\",\n  \"patch\",\n  \"delete\",\n];\nconst validMutationMethods = new Set<MutationFormMethod>(\n  validMutationMethodsArr\n);\n\nconst validRequestMethodsArr: FormMethod[] = [\n  \"get\",\n  ...validMutationMethodsArr,\n];\nconst validRequestMethods = new Set<FormMethod>(validRequestMethodsArr);\n\nconst redirectStatusCodes = new Set([301, 302, 303, 307, 308]);\nconst redirectPreserveMethodStatusCodes = new Set([307, 308]);\n\nexport const IDLE_NAVIGATION: NavigationStates[\"Idle\"] = {\n  state: \"idle\",\n  location: undefined,\n  formMethod: undefined,\n  formAction: undefined,\n  formEncType: undefined,\n  formData: undefined,\n  json: undefined,\n  text: undefined,\n};\n\nexport const IDLE_FETCHER: FetcherStates[\"Idle\"] = {\n  state: \"idle\",\n  data: undefined,\n  formMethod: undefined,\n  formAction: undefined,\n  formEncType: undefined,\n  formData: undefined,\n  json: undefined,\n  text: undefined,\n};\n\nexport const IDLE_BLOCKER: BlockerUnblocked = {\n  state: \"unblocked\",\n  proceed: undefined,\n  reset: undefined,\n  location: undefined,\n};\n\nconst ABSOLUTE_URL_REGEX = /^(?:[a-z][a-z0-9+.-]*:|\\/\\/)/i;\n\nconst defaultMapRouteProperties: MapRoutePropertiesFunction = (route) => ({\n  hasErrorBoundary: Boolean(route.hasErrorBoundary),\n});\n\nconst TRANSITIONS_STORAGE_KEY = \"remix-router-transitions\";\n\n//#endregion\n\n////////////////////////////////////////////////////////////////////////////////\n//#region createRouter\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * Create a router and listen to history POP navigations\n */\nexport function createRouter(init: RouterInit): Router {\n  const routerWindow = init.window\n    ? init.window\n    : typeof window !== \"undefined\"\n    ? window\n    : undefined;\n  const isBrowser =\n    typeof routerWindow !== \"undefined\" &&\n    typeof routerWindow.document !== \"undefined\" &&\n    typeof routerWindow.document.createElement !== \"undefined\";\n  const isServer = !isBrowser;\n\n  invariant(\n    init.routes.length > 0,\n    \"You must provide a non-empty routes array to createRouter\"\n  );\n\n  let mapRouteProperties: MapRoutePropertiesFunction;\n  if (init.mapRouteProperties) {\n    mapRouteProperties = init.mapRouteProperties;\n  } else if (init.detectErrorBoundary) {\n    // If they are still using the deprecated version, wrap it with the new API\n    let detectErrorBoundary = init.detectErrorBoundary;\n    mapRouteProperties = (route) => ({\n      hasErrorBoundary: detectErrorBoundary(route),\n    });\n  } else {\n    mapRouteProperties = defaultMapRouteProperties;\n  }\n\n  // Routes keyed by ID\n  let manifest: RouteManifest = {};\n  // Routes in tree format for matching\n  let dataRoutes = convertRoutesToDataRoutes(\n    init.routes,\n    mapRouteProperties,\n    undefined,\n    manifest\n  );\n  let inFlightDataRoutes: AgnosticDataRouteObject[] | undefined;\n  let basename = init.basename || \"/\";\n  let dataStrategyImpl = init.dataStrategy || defaultDataStrategy;\n  let patchRoutesOnNavigationImpl = init.patchRoutesOnNavigation;\n\n  // Config driven behavior flags\n  let future: FutureConfig = {\n    v7_fetcherPersist: false,\n    v7_normalizeFormMethod: false,\n    v7_partialHydration: false,\n    v7_prependBasename: false,\n    v7_relativeSplatPath: false,\n    v7_skipActionErrorRevalidation: false,\n    ...init.future,\n  };\n  // Cleanup function for history\n  let unlistenHistory: (() => void) | null = null;\n  // Externally-provided functions to call on all state changes\n  let subscribers = new Set<RouterSubscriber>();\n  // Externally-provided object to hold scroll restoration locations during routing\n  let savedScrollPositions: Record<string, number> | null = null;\n  // Externally-provided function to get scroll restoration keys\n  let getScrollRestorationKey: GetScrollRestorationKeyFunction | null = null;\n  // Externally-provided function to get current scroll position\n  let getScrollPosition: GetScrollPositionFunction | null = null;\n  // One-time flag to control the initial hydration scroll restoration.  Because\n  // we don't get the saved positions from <ScrollRestoration /> until _after_\n  // the initial render, we need to manually trigger a separate updateState to\n  // send along the restoreScrollPosition\n  // Set to true if we have `hydrationData` since we assume we were SSR'd and that\n  // SSR did the initial scroll restoration.\n  let initialScrollRestored = init.hydrationData != null;\n\n  let initialMatches = matchRoutes(dataRoutes, init.history.location, basename);\n  let initialMatchesIsFOW = false;\n  let initialErrors: RouteData | null = null;\n\n  if (initialMatches == null && !patchRoutesOnNavigationImpl) {\n    // If we do not match a user-provided-route, fall back to the root\n    // to allow the error boundary to take over\n    let error = getInternalRouterError(404, {\n      pathname: init.history.location.pathname,\n    });\n    let { matches, route } = getShortCircuitMatches(dataRoutes);\n    initialMatches = matches;\n    initialErrors = { [route.id]: error };\n  }\n\n  // In SPA apps, if the user provided a patchRoutesOnNavigation implementation and\n  // our initial match is a splat route, clear them out so we run through lazy\n  // discovery on hydration in case there's a more accurate lazy route match.\n  // In SSR apps (with `hydrationData`), we expect that the server will send\n  // up the proper matched routes so we don't want to run lazy discovery on\n  // initial hydration and want to hydrate into the splat route.\n  if (initialMatches && !init.hydrationData) {\n    let fogOfWar = checkFogOfWar(\n      initialMatches,\n      dataRoutes,\n      init.history.location.pathname\n    );\n    if (fogOfWar.active) {\n      initialMatches = null;\n    }\n  }\n\n  let initialized: boolean;\n  if (!initialMatches) {\n    initialized = false;\n    initialMatches = [];\n\n    // If partial hydration and fog of war is enabled, we will be running\n    // `patchRoutesOnNavigation` during hydration so include any partial matches as\n    // the initial matches so we can properly render `HydrateFallback`'s\n    if (future.v7_partialHydration) {\n      let fogOfWar = checkFogOfWar(\n        null,\n        dataRoutes,\n        init.history.location.pathname\n      );\n      if (fogOfWar.active && fogOfWar.matches) {\n        initialMatchesIsFOW = true;\n        initialMatches = fogOfWar.matches;\n      }\n    }\n  } else if (initialMatches.some((m) => m.route.lazy)) {\n    // All initialMatches need to be loaded before we're ready.  If we have lazy\n    // functions around still then we'll need to run them in initialize()\n    initialized = false;\n  } else if (!initialMatches.some((m) => m.route.loader)) {\n    // If we've got no loaders to run, then we're good to go\n    initialized = true;\n  } else if (future.v7_partialHydration) {\n    // If partial hydration is enabled, we're initialized so long as we were\n    // provided with hydrationData for every route with a loader, and no loaders\n    // were marked for explicit hydration\n    let loaderData = init.hydrationData ? init.hydrationData.loaderData : null;\n    let errors = init.hydrationData ? init.hydrationData.errors : null;\n    // If errors exist, don't consider routes below the boundary\n    if (errors) {\n      let idx = initialMatches.findIndex(\n        (m) => errors![m.route.id] !== undefined\n      );\n      initialized = initialMatches\n        .slice(0, idx + 1)\n        .every((m) => !shouldLoadRouteOnHydration(m.route, loaderData, errors));\n    } else {\n      initialized = initialMatches.every(\n        (m) => !shouldLoadRouteOnHydration(m.route, loaderData, errors)\n      );\n    }\n  } else {\n    // Without partial hydration - we're initialized if we were provided any\n    // hydrationData - which is expected to be complete\n    initialized = init.hydrationData != null;\n  }\n\n  let router: Router;\n  let state: RouterState = {\n    historyAction: init.history.action,\n    location: init.history.location,\n    matches: initialMatches,\n    initialized,\n    navigation: IDLE_NAVIGATION,\n    // Don't restore on initial updateState() if we were SSR'd\n    restoreScrollPosition: init.hydrationData != null ? false : null,\n    preventScrollReset: false,\n    revalidation: \"idle\",\n    loaderData: (init.hydrationData && init.hydrationData.loaderData) || {},\n    actionData: (init.hydrationData && init.hydrationData.actionData) || null,\n    errors: (init.hydrationData && init.hydrationData.errors) || initialErrors,\n    fetchers: new Map(),\n    blockers: new Map(),\n  };\n\n  // -- Stateful internal variables to manage navigations --\n  // Current navigation in progress (to be committed in completeNavigation)\n  let pendingAction: HistoryAction = HistoryAction.Pop;\n\n  // Should the current navigation prevent the scroll reset if scroll cannot\n  // be restored?\n  let pendingPreventScrollReset = false;\n\n  // AbortController for the active navigation\n  let pendingNavigationController: AbortController | null;\n\n  // Should the current navigation enable document.startViewTransition?\n  let pendingViewTransitionEnabled = false;\n\n  // Store applied view transitions so we can apply them on POP\n  let appliedViewTransitions: Map<string, Set<string>> = new Map<\n    string,\n    Set<string>\n  >();\n\n  // Cleanup function for persisting applied transitions to sessionStorage\n  let removePageHideEventListener: (() => void) | null = null;\n\n  // We use this to avoid touching history in completeNavigation if a\n  // revalidation is entirely uninterrupted\n  let isUninterruptedRevalidation = false;\n\n  // Use this internal flag to force revalidation of all loaders:\n  //  - submissions (completed or interrupted)\n  //  - useRevalidator()\n  //  - X-Remix-Revalidate (from redirect)\n  let isRevalidationRequired = false;\n\n  // Use this internal array to capture routes that require revalidation due\n  // to a cancelled deferred on action submission\n  let cancelledDeferredRoutes: string[] = [];\n\n  // Use this internal array to capture fetcher loads that were cancelled by an\n  // action navigation and require revalidation\n  let cancelledFetcherLoads: Set<string> = new Set();\n\n  // AbortControllers for any in-flight fetchers\n  let fetchControllers = new Map<string, AbortController>();\n\n  // Track loads based on the order in which they started\n  let incrementingLoadId = 0;\n\n  // Track the outstanding pending navigation data load to be compared against\n  // the globally incrementing load when a fetcher load lands after a completed\n  // navigation\n  let pendingNavigationLoadId = -1;\n\n  // Fetchers that triggered data reloads as a result of their actions\n  let fetchReloadIds = new Map<string, number>();\n\n  // Fetchers that triggered redirect navigations\n  let fetchRedirectIds = new Set<string>();\n\n  // Most recent href/match for fetcher.load calls for fetchers\n  let fetchLoadMatches = new Map<string, FetchLoadMatch>();\n\n  // Ref-count mounted fetchers so we know when it's ok to clean them up\n  let activeFetchers = new Map<string, number>();\n\n  // Fetchers that have requested a delete when using v7_fetcherPersist,\n  // they'll be officially removed after they return to idle\n  let deletedFetchers = new Set<string>();\n\n  // Store DeferredData instances for active route matches.  When a\n  // route loader returns defer() we stick one in here.  Then, when a nested\n  // promise resolves we update loaderData.  If a new navigation starts we\n  // cancel active deferreds for eliminated routes.\n  let activeDeferreds = new Map<string, DeferredData>();\n\n  // Store blocker functions in a separate Map outside of router state since\n  // we don't need to update UI state if they change\n  let blockerFunctions = new Map<string, BlockerFunction>();\n\n  // Map of pending patchRoutesOnNavigation() promises (keyed by path/matches) so\n  // that we only kick them off once for a given combo\n  let pendingPatchRoutes = new Map<\n    string,\n    ReturnType<AgnosticPatchRoutesOnNavigationFunction>\n  >();\n\n  // Flag to ignore the next history update, so we can revert the URL change on\n  // a POP navigation that was blocked by the user without touching router state\n  let unblockBlockerHistoryUpdate: (() => void) | undefined = undefined;\n\n  // Initialize the router, all side effects should be kicked off from here.\n  // Implemented as a Fluent API for ease of:\n  //   let router = createRouter(init).initialize();\n  function initialize() {\n    // If history informs us of a POP navigation, start the navigation but do not update\n    // state.  We'll update our own state once the navigation completes\n    unlistenHistory = init.history.listen(\n      ({ action: historyAction, location, delta }) => {\n        // Ignore this event if it was just us resetting the URL from a\n        // blocked POP navigation\n        if (unblockBlockerHistoryUpdate) {\n          unblockBlockerHistoryUpdate();\n          unblockBlockerHistoryUpdate = undefined;\n          return;\n        }\n\n        warning(\n          blockerFunctions.size === 0 || delta != null,\n          \"You are trying to use a blocker on a POP navigation to a location \" +\n            \"that was not created by @remix-run/router. This will fail silently in \" +\n            \"production. This can happen if you are navigating outside the router \" +\n            \"via `window.history.pushState`/`window.location.hash` instead of using \" +\n            \"router navigation APIs.  This can also happen if you are using \" +\n            \"createHashRouter and the user manually changes the URL.\"\n        );\n\n        let blockerKey = shouldBlockNavigation({\n          currentLocation: state.location,\n          nextLocation: location,\n          historyAction,\n        });\n\n        if (blockerKey && delta != null) {\n          // Restore the URL to match the current UI, but don't update router state\n          let nextHistoryUpdatePromise = new Promise<void>((resolve) => {\n            unblockBlockerHistoryUpdate = resolve;\n          });\n          init.history.go(delta * -1);\n\n          // Put the blocker into a blocked state\n          updateBlocker(blockerKey, {\n            state: \"blocked\",\n            location,\n            proceed() {\n              updateBlocker(blockerKey!, {\n                state: \"proceeding\",\n                proceed: undefined,\n                reset: undefined,\n                location,\n              });\n              // Re-do the same POP navigation we just blocked, after the url\n              // restoration is also complete.  See:\n              // https://github.com/remix-run/react-router/issues/11613\n              nextHistoryUpdatePromise.then(() => init.history.go(delta));\n            },\n            reset() {\n              let blockers = new Map(state.blockers);\n              blockers.set(blockerKey!, IDLE_BLOCKER);\n              updateState({ blockers });\n            },\n          });\n          return;\n        }\n\n        return startNavigation(historyAction, location);\n      }\n    );\n\n    if (isBrowser) {\n      // FIXME: This feels gross.  How can we cleanup the lines between\n      // scrollRestoration/appliedTransitions persistance?\n      restoreAppliedTransitions(routerWindow, appliedViewTransitions);\n      let _saveAppliedTransitions = () =>\n        persistAppliedTransitions(routerWindow, appliedViewTransitions);\n      routerWindow.addEventListener(\"pagehide\", _saveAppliedTransitions);\n      removePageHideEventListener = () =>\n        routerWindow.removeEventListener(\"pagehide\", _saveAppliedTransitions);\n    }\n\n    // Kick off initial data load if needed.  Use Pop to avoid modifying history\n    // Note we don't do any handling of lazy here.  For SPA's it'll get handled\n    // in the normal navigation flow.  For SSR it's expected that lazy modules are\n    // resolved prior to router creation since we can't go into a fallbackElement\n    // UI for SSR'd apps\n    if (!state.initialized) {\n      startNavigation(HistoryAction.Pop, state.location, {\n        initialHydration: true,\n      });\n    }\n\n    return router;\n  }\n\n  // Clean up a router and it's side effects\n  function dispose() {\n    if (unlistenHistory) {\n      unlistenHistory();\n    }\n    if (removePageHideEventListener) {\n      removePageHideEventListener();\n    }\n    subscribers.clear();\n    pendingNavigationController && pendingNavigationController.abort();\n    state.fetchers.forEach((_, key) => deleteFetcher(key));\n    state.blockers.forEach((_, key) => deleteBlocker(key));\n  }\n\n  // Subscribe to state updates for the router\n  function subscribe(fn: RouterSubscriber) {\n    subscribers.add(fn);\n    return () => subscribers.delete(fn);\n  }\n\n  // Update our state and notify the calling context of the change\n  function updateState(\n    newState: Partial<RouterState>,\n    opts: {\n      flushSync?: boolean;\n      viewTransitionOpts?: ViewTransitionOpts;\n    } = {}\n  ): void {\n    state = {\n      ...state,\n      ...newState,\n    };\n\n    // Prep fetcher cleanup so we can tell the UI which fetcher data entries\n    // can be removed\n    let completedFetchers: string[] = [];\n    let deletedFetchersKeys: string[] = [];\n\n    if (future.v7_fetcherPersist) {\n      state.fetchers.forEach((fetcher, key) => {\n        if (fetcher.state === \"idle\") {\n          if (deletedFetchers.has(key)) {\n            // Unmounted from the UI and can be totally removed\n            deletedFetchersKeys.push(key);\n          } else {\n            // Returned to idle but still mounted in the UI, so semi-remains for\n            // revalidations and such\n            completedFetchers.push(key);\n          }\n        }\n      });\n    }\n\n    // Remove any lingering deleted fetchers that have already been removed\n    // from state.fetchers\n    deletedFetchers.forEach((key) => {\n      if (!state.fetchers.has(key) && !fetchControllers.has(key)) {\n        deletedFetchersKeys.push(key);\n      }\n    });\n\n    // Iterate over a local copy so that if flushSync is used and we end up\n    // removing and adding a new subscriber due to the useCallback dependencies,\n    // we don't get ourselves into a loop calling the new subscriber immediately\n    [...subscribers].forEach((subscriber) =>\n      subscriber(state, {\n        deletedFetchers: deletedFetchersKeys,\n        viewTransitionOpts: opts.viewTransitionOpts,\n        flushSync: opts.flushSync === true,\n      })\n    );\n\n    // Remove idle fetchers from state since we only care about in-flight fetchers.\n    if (future.v7_fetcherPersist) {\n      completedFetchers.forEach((key) => state.fetchers.delete(key));\n      deletedFetchersKeys.forEach((key) => deleteFetcher(key));\n    } else {\n      // We already called deleteFetcher() on these, can remove them from this\n      // Set now that we've handed the keys off to the data layer\n      deletedFetchersKeys.forEach((key) => deletedFetchers.delete(key));\n    }\n  }\n\n  // Complete a navigation returning the state.navigation back to the IDLE_NAVIGATION\n  // and setting state.[historyAction/location/matches] to the new route.\n  // - Location is a required param\n  // - Navigation will always be set to IDLE_NAVIGATION\n  // - Can pass any other state in newState\n  function completeNavigation(\n    location: Location,\n    newState: Partial<Omit<RouterState, \"action\" | \"location\" | \"navigation\">>,\n    { flushSync }: { flushSync?: boolean } = {}\n  ): void {\n    // Deduce if we're in a loading/actionReload state:\n    // - We have committed actionData in the store\n    // - The current navigation was a mutation submission\n    // - We're past the submitting state and into the loading state\n    // - The location being loaded is not the result of a redirect\n    let isActionReload =\n      state.actionData != null &&\n      state.navigation.formMethod != null &&\n      isMutationMethod(state.navigation.formMethod) &&\n      state.navigation.state === \"loading\" &&\n      location.state?._isRedirect !== true;\n\n    let actionData: RouteData | null;\n    if (newState.actionData) {\n      if (Object.keys(newState.actionData).length > 0) {\n        actionData = newState.actionData;\n      } else {\n        // Empty actionData -> clear prior actionData due to an action error\n        actionData = null;\n      }\n    } else if (isActionReload) {\n      // Keep the current data if we're wrapping up the action reload\n      actionData = state.actionData;\n    } else {\n      // Clear actionData on any other completed navigations\n      actionData = null;\n    }\n\n    // Always preserve any existing loaderData from re-used routes\n    let loaderData = newState.loaderData\n      ? mergeLoaderData(\n          state.loaderData,\n          newState.loaderData,\n          newState.matches || [],\n          newState.errors\n        )\n      : state.loaderData;\n\n    // On a successful navigation we can assume we got through all blockers\n    // so we can start fresh\n    let blockers = state.blockers;\n    if (blockers.size > 0) {\n      blockers = new Map(blockers);\n      blockers.forEach((_, k) => blockers.set(k, IDLE_BLOCKER));\n    }\n\n    // Always respect the user flag.  Otherwise don't reset on mutation\n    // submission navigations unless they redirect\n    let preventScrollReset =\n      pendingPreventScrollReset === true ||\n      (state.navigation.formMethod != null &&\n        isMutationMethod(state.navigation.formMethod) &&\n        location.state?._isRedirect !== true);\n\n    // Commit any in-flight routes at the end of the HMR revalidation \"navigation\"\n    if (inFlightDataRoutes) {\n      dataRoutes = inFlightDataRoutes;\n      inFlightDataRoutes = undefined;\n    }\n\n    if (isUninterruptedRevalidation) {\n      // If this was an uninterrupted revalidation then do not touch history\n    } else if (pendingAction === HistoryAction.Pop) {\n      // Do nothing for POP - URL has already been updated\n    } else if (pendingAction === HistoryAction.Push) {\n      init.history.push(location, location.state);\n    } else if (pendingAction === HistoryAction.Replace) {\n      init.history.replace(location, location.state);\n    }\n\n    let viewTransitionOpts: ViewTransitionOpts | undefined;\n\n    // On POP, enable transitions if they were enabled on the original navigation\n    if (pendingAction === HistoryAction.Pop) {\n      // Forward takes precedence so they behave like the original navigation\n      let priorPaths = appliedViewTransitions.get(state.location.pathname);\n      if (priorPaths && priorPaths.has(location.pathname)) {\n        viewTransitionOpts = {\n          currentLocation: state.location,\n          nextLocation: location,\n        };\n      } else if (appliedViewTransitions.has(location.pathname)) {\n        // If we don't have a previous forward nav, assume we're popping back to\n        // the new location and enable if that location previously enabled\n        viewTransitionOpts = {\n          currentLocation: location,\n          nextLocation: state.location,\n        };\n      }\n    } else if (pendingViewTransitionEnabled) {\n      // Store the applied transition on PUSH/REPLACE\n      let toPaths = appliedViewTransitions.get(state.location.pathname);\n      if (toPaths) {\n        toPaths.add(location.pathname);\n      } else {\n        toPaths = new Set<string>([location.pathname]);\n        appliedViewTransitions.set(state.location.pathname, toPaths);\n      }\n      viewTransitionOpts = {\n        currentLocation: state.location,\n        nextLocation: location,\n      };\n    }\n\n    updateState(\n      {\n        ...newState, // matches, errors, fetchers go through as-is\n        actionData,\n        loaderData,\n        historyAction: pendingAction,\n        location,\n        initialized: true,\n        navigation: IDLE_NAVIGATION,\n        revalidation: \"idle\",\n        restoreScrollPosition: getSavedScrollPosition(\n          location,\n          newState.matches || state.matches\n        ),\n        preventScrollReset,\n        blockers,\n      },\n      {\n        viewTransitionOpts,\n        flushSync: flushSync === true,\n      }\n    );\n\n    // Reset stateful navigation vars\n    pendingAction = HistoryAction.Pop;\n    pendingPreventScrollReset = false;\n    pendingViewTransitionEnabled = false;\n    isUninterruptedRevalidation = false;\n    isRevalidationRequired = false;\n    cancelledDeferredRoutes = [];\n  }\n\n  // Trigger a navigation event, which can either be a numerical POP or a PUSH\n  // replace with an optional submission\n  async function navigate(\n    to: number | To | null,\n    opts?: RouterNavigateOptions\n  ): Promise<void> {\n    if (typeof to === \"number\") {\n      init.history.go(to);\n      return;\n    }\n\n    let normalizedPath = normalizeTo(\n      state.location,\n      state.matches,\n      basename,\n      future.v7_prependBasename,\n      to,\n      future.v7_relativeSplatPath,\n      opts?.fromRouteId,\n      opts?.relative\n    );\n    let { path, submission, error } = normalizeNavigateOptions(\n      future.v7_normalizeFormMethod,\n      false,\n      normalizedPath,\n      opts\n    );\n\n    let currentLocation = state.location;\n    let nextLocation = createLocation(state.location, path, opts && opts.state);\n\n    // When using navigate as a PUSH/REPLACE we aren't reading an already-encoded\n    // URL from window.location, so we need to encode it here so the behavior\n    // remains the same as POP and non-data-router usages.  new URL() does all\n    // the same encoding we'd get from a history.pushState/window.location read\n    // without having to touch history\n    nextLocation = {\n      ...nextLocation,\n      ...init.history.encodeLocation(nextLocation),\n    };\n\n    let userReplace = opts && opts.replace != null ? opts.replace : undefined;\n\n    let historyAction = HistoryAction.Push;\n\n    if (userReplace === true) {\n      historyAction = HistoryAction.Replace;\n    } else if (userReplace === false) {\n      // no-op\n    } else if (\n      submission != null &&\n      isMutationMethod(submission.formMethod) &&\n      submission.formAction === state.location.pathname + state.location.search\n    ) {\n      // By default on submissions to the current location we REPLACE so that\n      // users don't have to double-click the back button to get to the prior\n      // location.  If the user redirects to a different location from the\n      // action/loader this will be ignored and the redirect will be a PUSH\n      historyAction = HistoryAction.Replace;\n    }\n\n    let preventScrollReset =\n      opts && \"preventScrollReset\" in opts\n        ? opts.preventScrollReset === true\n        : undefined;\n\n    let flushSync = (opts && opts.flushSync) === true;\n\n    let blockerKey = shouldBlockNavigation({\n      currentLocation,\n      nextLocation,\n      historyAction,\n    });\n\n    if (blockerKey) {\n      // Put the blocker into a blocked state\n      updateBlocker(blockerKey, {\n        state: \"blocked\",\n        location: nextLocation,\n        proceed() {\n          updateBlocker(blockerKey!, {\n            state: \"proceeding\",\n            proceed: undefined,\n            reset: undefined,\n            location: nextLocation,\n          });\n          // Send the same navigation through\n          navigate(to, opts);\n        },\n        reset() {\n          let blockers = new Map(state.blockers);\n          blockers.set(blockerKey!, IDLE_BLOCKER);\n          updateState({ blockers });\n        },\n      });\n      return;\n    }\n\n    return await startNavigation(historyAction, nextLocation, {\n      submission,\n      // Send through the formData serialization error if we have one so we can\n      // render at the right error boundary after we match routes\n      pendingError: error,\n      preventScrollReset,\n      replace: opts && opts.replace,\n      enableViewTransition: opts && opts.viewTransition,\n      flushSync,\n    });\n  }\n\n  // Revalidate all current loaders.  If a navigation is in progress or if this\n  // is interrupted by a navigation, allow this to \"succeed\" by calling all\n  // loaders during the next loader round\n  function revalidate() {\n    interruptActiveLoads();\n    updateState({ revalidation: \"loading\" });\n\n    // If we're currently submitting an action, we don't need to start a new\n    // navigation, we'll just let the follow up loader execution call all loaders\n    if (state.navigation.state === \"submitting\") {\n      return;\n    }\n\n    // If we're currently in an idle state, start a new navigation for the current\n    // action/location and mark it as uninterrupted, which will skip the history\n    // update in completeNavigation\n    if (state.navigation.state === \"idle\") {\n      startNavigation(state.historyAction, state.location, {\n        startUninterruptedRevalidation: true,\n      });\n      return;\n    }\n\n    // Otherwise, if we're currently in a loading state, just start a new\n    // navigation to the navigation.location but do not trigger an uninterrupted\n    // revalidation so that history correctly updates once the navigation completes\n    startNavigation(\n      pendingAction || state.historyAction,\n      state.navigation.location,\n      {\n        overrideNavigation: state.navigation,\n        // Proxy through any rending view transition\n        enableViewTransition: pendingViewTransitionEnabled === true,\n      }\n    );\n  }\n\n  // Start a navigation to the given action/location.  Can optionally provide a\n  // overrideNavigation which will override the normalLoad in the case of a redirect\n  // navigation\n  async function startNavigation(\n    historyAction: HistoryAction,\n    location: Location,\n    opts?: {\n      initialHydration?: boolean;\n      submission?: Submission;\n      fetcherSubmission?: Submission;\n      overrideNavigation?: Navigation;\n      pendingError?: ErrorResponseImpl;\n      startUninterruptedRevalidation?: boolean;\n      preventScrollReset?: boolean;\n      replace?: boolean;\n      enableViewTransition?: boolean;\n      flushSync?: boolean;\n    }\n  ): Promise<void> {\n    // Abort any in-progress navigations and start a new one. Unset any ongoing\n    // uninterrupted revalidations unless told otherwise, since we want this\n    // new navigation to update history normally\n    pendingNavigationController && pendingNavigationController.abort();\n    pendingNavigationController = null;\n    pendingAction = historyAction;\n    isUninterruptedRevalidation =\n      (opts && opts.startUninterruptedRevalidation) === true;\n\n    // Save the current scroll position every time we start a new navigation,\n    // and track whether we should reset scroll on completion\n    saveScrollPosition(state.location, state.matches);\n    pendingPreventScrollReset = (opts && opts.preventScrollReset) === true;\n\n    pendingViewTransitionEnabled = (opts && opts.enableViewTransition) === true;\n\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    let loadingNavigation = opts && opts.overrideNavigation;\n    let matches =\n      opts?.initialHydration &&\n      state.matches &&\n      state.matches.length > 0 &&\n      !initialMatchesIsFOW\n        ? // `matchRoutes()` has already been called if we're in here via `router.initialize()`\n          state.matches\n        : matchRoutes(routesToUse, location, basename);\n    let flushSync = (opts && opts.flushSync) === true;\n\n    // Short circuit if it's only a hash change and not a revalidation or\n    // mutation submission.\n    //\n    // Ignore on initial page loads because since the initial hydration will always\n    // be \"same hash\".  For example, on /page#hash and submit a <Form method=\"post\">\n    // which will default to a navigation to /page\n    if (\n      matches &&\n      state.initialized &&\n      !isRevalidationRequired &&\n      isHashChangeOnly(state.location, location) &&\n      !(opts && opts.submission && isMutationMethod(opts.submission.formMethod))\n    ) {\n      completeNavigation(location, { matches }, { flushSync });\n      return;\n    }\n\n    let fogOfWar = checkFogOfWar(matches, routesToUse, location.pathname);\n    if (fogOfWar.active && fogOfWar.matches) {\n      matches = fogOfWar.matches;\n    }\n\n    // Short circuit with a 404 on the root error boundary if we match nothing\n    if (!matches) {\n      let { error, notFoundMatches, route } = handleNavigational404(\n        location.pathname\n      );\n      completeNavigation(\n        location,\n        {\n          matches: notFoundMatches,\n          loaderData: {},\n          errors: {\n            [route.id]: error,\n          },\n        },\n        { flushSync }\n      );\n      return;\n    }\n\n    // Create a controller/Request for this navigation\n    pendingNavigationController = new AbortController();\n    let request = createClientSideRequest(\n      init.history,\n      location,\n      pendingNavigationController.signal,\n      opts && opts.submission\n    );\n    let pendingActionResult: PendingActionResult | undefined;\n\n    if (opts && opts.pendingError) {\n      // If we have a pendingError, it means the user attempted a GET submission\n      // with binary FormData so assign here and skip to handleLoaders.  That\n      // way we handle calling loaders above the boundary etc.  It's not really\n      // different from an actionError in that sense.\n      pendingActionResult = [\n        findNearestBoundary(matches).route.id,\n        { type: ResultType.error, error: opts.pendingError },\n      ];\n    } else if (\n      opts &&\n      opts.submission &&\n      isMutationMethod(opts.submission.formMethod)\n    ) {\n      // Call action if we received an action submission\n      let actionResult = await handleAction(\n        request,\n        location,\n        opts.submission,\n        matches,\n        fogOfWar.active,\n        { replace: opts.replace, flushSync }\n      );\n\n      if (actionResult.shortCircuited) {\n        return;\n      }\n\n      // If we received a 404 from handleAction, it's because we couldn't lazily\n      // discover the destination route so we don't want to call loaders\n      if (actionResult.pendingActionResult) {\n        let [routeId, result] = actionResult.pendingActionResult;\n        if (\n          isErrorResult(result) &&\n          isRouteErrorResponse(result.error) &&\n          result.error.status === 404\n        ) {\n          pendingNavigationController = null;\n\n          completeNavigation(location, {\n            matches: actionResult.matches,\n            loaderData: {},\n            errors: {\n              [routeId]: result.error,\n            },\n          });\n          return;\n        }\n      }\n\n      matches = actionResult.matches || matches;\n      pendingActionResult = actionResult.pendingActionResult;\n      loadingNavigation = getLoadingNavigation(location, opts.submission);\n      flushSync = false;\n      // No need to do fog of war matching again on loader execution\n      fogOfWar.active = false;\n\n      // Create a GET request for the loaders\n      request = createClientSideRequest(\n        init.history,\n        request.url,\n        request.signal\n      );\n    }\n\n    // Call loaders\n    let {\n      shortCircuited,\n      matches: updatedMatches,\n      loaderData,\n      errors,\n    } = await handleLoaders(\n      request,\n      location,\n      matches,\n      fogOfWar.active,\n      loadingNavigation,\n      opts && opts.submission,\n      opts && opts.fetcherSubmission,\n      opts && opts.replace,\n      opts && opts.initialHydration === true,\n      flushSync,\n      pendingActionResult\n    );\n\n    if (shortCircuited) {\n      return;\n    }\n\n    // Clean up now that the action/loaders have completed.  Don't clean up if\n    // we short circuited because pendingNavigationController will have already\n    // been assigned to a new controller for the next navigation\n    pendingNavigationController = null;\n\n    completeNavigation(location, {\n      matches: updatedMatches || matches,\n      ...getActionDataForCommit(pendingActionResult),\n      loaderData,\n      errors,\n    });\n  }\n\n  // Call the action matched by the leaf route for this navigation and handle\n  // redirects/errors\n  async function handleAction(\n    request: Request,\n    location: Location,\n    submission: Submission,\n    matches: AgnosticDataRouteMatch[],\n    isFogOfWar: boolean,\n    opts: { replace?: boolean; flushSync?: boolean } = {}\n  ): Promise<HandleActionResult> {\n    interruptActiveLoads();\n\n    // Put us in a submitting state\n    let navigation = getSubmittingNavigation(location, submission);\n    updateState({ navigation }, { flushSync: opts.flushSync === true });\n\n    if (isFogOfWar) {\n      let discoverResult = await discoverRoutes(\n        matches,\n        location.pathname,\n        request.signal\n      );\n      if (discoverResult.type === \"aborted\") {\n        return { shortCircuited: true };\n      } else if (discoverResult.type === \"error\") {\n        let boundaryId = findNearestBoundary(discoverResult.partialMatches)\n          .route.id;\n        return {\n          matches: discoverResult.partialMatches,\n          pendingActionResult: [\n            boundaryId,\n            {\n              type: ResultType.error,\n              error: discoverResult.error,\n            },\n          ],\n        };\n      } else if (!discoverResult.matches) {\n        let { notFoundMatches, error, route } = handleNavigational404(\n          location.pathname\n        );\n        return {\n          matches: notFoundMatches,\n          pendingActionResult: [\n            route.id,\n            {\n              type: ResultType.error,\n              error,\n            },\n          ],\n        };\n      } else {\n        matches = discoverResult.matches;\n      }\n    }\n\n    // Call our action and get the result\n    let result: DataResult;\n    let actionMatch = getTargetMatch(matches, location);\n\n    if (!actionMatch.route.action && !actionMatch.route.lazy) {\n      result = {\n        type: ResultType.error,\n        error: getInternalRouterError(405, {\n          method: request.method,\n          pathname: location.pathname,\n          routeId: actionMatch.route.id,\n        }),\n      };\n    } else {\n      let results = await callDataStrategy(\n        \"action\",\n        state,\n        request,\n        [actionMatch],\n        matches,\n        null\n      );\n      result = results[actionMatch.route.id];\n\n      if (request.signal.aborted) {\n        return { shortCircuited: true };\n      }\n    }\n\n    if (isRedirectResult(result)) {\n      let replace: boolean;\n      if (opts && opts.replace != null) {\n        replace = opts.replace;\n      } else {\n        // If the user didn't explicity indicate replace behavior, replace if\n        // we redirected to the exact same location we're currently at to avoid\n        // double back-buttons\n        let location = normalizeRedirectLocation(\n          result.response.headers.get(\"Location\")!,\n          new URL(request.url),\n          basename,\n          init.history,\n        );\n        replace = location === state.location.pathname + state.location.search;\n      }\n      await startRedirectNavigation(request, result, true, {\n        submission,\n        replace,\n      });\n      return { shortCircuited: true };\n    }\n\n    if (isDeferredResult(result)) {\n      throw getInternalRouterError(400, { type: \"defer-action\" });\n    }\n\n    if (isErrorResult(result)) {\n      // Store off the pending error - we use it to determine which loaders\n      // to call and will commit it when we complete the navigation\n      let boundaryMatch = findNearestBoundary(matches, actionMatch.route.id);\n\n      // By default, all submissions to the current location are REPLACE\n      // navigations, but if the action threw an error that'll be rendered in\n      // an errorElement, we fall back to PUSH so that the user can use the\n      // back button to get back to the pre-submission form location to try\n      // again\n      if ((opts && opts.replace) !== true) {\n        pendingAction = HistoryAction.Push;\n      }\n\n      return {\n        matches,\n        pendingActionResult: [boundaryMatch.route.id, result],\n      };\n    }\n\n    return {\n      matches,\n      pendingActionResult: [actionMatch.route.id, result],\n    };\n  }\n\n  // Call all applicable loaders for the given matches, handling redirects,\n  // errors, etc.\n  async function handleLoaders(\n    request: Request,\n    location: Location,\n    matches: AgnosticDataRouteMatch[],\n    isFogOfWar: boolean,\n    overrideNavigation?: Navigation,\n    submission?: Submission,\n    fetcherSubmission?: Submission,\n    replace?: boolean,\n    initialHydration?: boolean,\n    flushSync?: boolean,\n    pendingActionResult?: PendingActionResult\n  ): Promise<HandleLoadersResult> {\n    // Figure out the right navigation we want to use for data loading\n    let loadingNavigation =\n      overrideNavigation || getLoadingNavigation(location, submission);\n\n    // If this was a redirect from an action we don't have a \"submission\" but\n    // we have it on the loading navigation so use that if available\n    let activeSubmission =\n      submission ||\n      fetcherSubmission ||\n      getSubmissionFromNavigation(loadingNavigation);\n\n    // If this is an uninterrupted revalidation, we remain in our current idle\n    // state.  If not, we need to switch to our loading state and load data,\n    // preserving any new action data or existing action data (in the case of\n    // a revalidation interrupting an actionReload)\n    // If we have partialHydration enabled, then don't update the state for the\n    // initial data load since it's not a \"navigation\"\n    let shouldUpdateNavigationState =\n      !isUninterruptedRevalidation &&\n      (!future.v7_partialHydration || !initialHydration);\n\n    // When fog of war is enabled, we enter our `loading` state earlier so we\n    // can discover new routes during the `loading` state.  We skip this if\n    // we've already run actions since we would have done our matching already.\n    // If the children() function threw then, we want to proceed with the\n    // partial matches it discovered.\n    if (isFogOfWar) {\n      if (shouldUpdateNavigationState) {\n        let actionData = getUpdatedActionData(pendingActionResult);\n        updateState(\n          {\n            navigation: loadingNavigation,\n            ...(actionData !== undefined ? { actionData } : {}),\n          },\n          {\n            flushSync,\n          }\n        );\n      }\n\n      let discoverResult = await discoverRoutes(\n        matches,\n        location.pathname,\n        request.signal\n      );\n\n      if (discoverResult.type === \"aborted\") {\n        return { shortCircuited: true };\n      } else if (discoverResult.type === \"error\") {\n        let boundaryId = findNearestBoundary(discoverResult.partialMatches)\n          .route.id;\n        return {\n          matches: discoverResult.partialMatches,\n          loaderData: {},\n          errors: {\n            [boundaryId]: discoverResult.error,\n          },\n        };\n      } else if (!discoverResult.matches) {\n        let { error, notFoundMatches, route } = handleNavigational404(\n          location.pathname\n        );\n        return {\n          matches: notFoundMatches,\n          loaderData: {},\n          errors: {\n            [route.id]: error,\n          },\n        };\n      } else {\n        matches = discoverResult.matches;\n      }\n    }\n\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(\n      init.history,\n      state,\n      matches,\n      activeSubmission,\n      location,\n      future.v7_partialHydration && initialHydration === true,\n      future.v7_skipActionErrorRevalidation,\n      isRevalidationRequired,\n      cancelledDeferredRoutes,\n      cancelledFetcherLoads,\n      deletedFetchers,\n      fetchLoadMatches,\n      fetchRedirectIds,\n      routesToUse,\n      basename,\n      pendingActionResult\n    );\n\n    // Cancel pending deferreds for no-longer-matched routes or routes we're\n    // about to reload.  Note that if this is an action reload we would have\n    // already cancelled all pending deferreds so this would be a no-op\n    cancelActiveDeferreds(\n      (routeId) =>\n        !(matches && matches.some((m) => m.route.id === routeId)) ||\n        (matchesToLoad && matchesToLoad.some((m) => m.route.id === routeId))\n    );\n\n    pendingNavigationLoadId = ++incrementingLoadId;\n\n    // Short circuit if we have no loaders to run\n    if (matchesToLoad.length === 0 && revalidatingFetchers.length === 0) {\n      let updatedFetchers = markFetchRedirectsDone();\n      completeNavigation(\n        location,\n        {\n          matches,\n          loaderData: {},\n          // Commit pending error if we're short circuiting\n          errors:\n            pendingActionResult && isErrorResult(pendingActionResult[1])\n              ? { [pendingActionResult[0]]: pendingActionResult[1].error }\n              : null,\n          ...getActionDataForCommit(pendingActionResult),\n          ...(updatedFetchers ? { fetchers: new Map(state.fetchers) } : {}),\n        },\n        { flushSync }\n      );\n      return { shortCircuited: true };\n    }\n\n    if (shouldUpdateNavigationState) {\n      let updates: Partial<RouterState> = {};\n      if (!isFogOfWar) {\n        // Only update navigation/actionNData if we didn't already do it above\n        updates.navigation = loadingNavigation;\n        let actionData = getUpdatedActionData(pendingActionResult);\n        if (actionData !== undefined) {\n          updates.actionData = actionData;\n        }\n      }\n      if (revalidatingFetchers.length > 0) {\n        updates.fetchers = getUpdatedRevalidatingFetchers(revalidatingFetchers);\n      }\n      updateState(updates, { flushSync });\n    }\n\n    revalidatingFetchers.forEach((rf) => {\n      abortFetcher(rf.key);\n      if (rf.controller) {\n        // Fetchers use an independent AbortController so that aborting a fetcher\n        // (via deleteFetcher) does not abort the triggering navigation that\n        // triggered the revalidation\n        fetchControllers.set(rf.key, rf.controller);\n      }\n    });\n\n    // Proxy navigation abort through to revalidation fetchers\n    let abortPendingFetchRevalidations = () =>\n      revalidatingFetchers.forEach((f) => abortFetcher(f.key));\n    if (pendingNavigationController) {\n      pendingNavigationController.signal.addEventListener(\n        \"abort\",\n        abortPendingFetchRevalidations\n      );\n    }\n\n    let { loaderResults, fetcherResults } =\n      await callLoadersAndMaybeResolveData(\n        state,\n        matches,\n        matchesToLoad,\n        revalidatingFetchers,\n        request\n      );\n\n    if (request.signal.aborted) {\n      return { shortCircuited: true };\n    }\n\n    // Clean up _after_ loaders have completed.  Don't clean up if we short\n    // circuited because fetchControllers would have been aborted and\n    // reassigned to new controllers for the next navigation\n    if (pendingNavigationController) {\n      pendingNavigationController.signal.removeEventListener(\n        \"abort\",\n        abortPendingFetchRevalidations\n      );\n    }\n\n    revalidatingFetchers.forEach((rf) => fetchControllers.delete(rf.key));\n\n    // If any loaders returned a redirect Response, start a new REPLACE navigation\n    let redirect = findRedirect(loaderResults);\n    if (redirect) {\n      await startRedirectNavigation(request, redirect.result, true, {\n        replace,\n      });\n      return { shortCircuited: true };\n    }\n\n    redirect = findRedirect(fetcherResults);\n    if (redirect) {\n      // If this redirect came from a fetcher make sure we mark it in\n      // fetchRedirectIds so it doesn't get revalidated on the next set of\n      // loader executions\n      fetchRedirectIds.add(redirect.key);\n      await startRedirectNavigation(request, redirect.result, true, {\n        replace,\n      });\n      return { shortCircuited: true };\n    }\n\n    // Process and commit output from loaders\n    let { loaderData, errors } = processLoaderData(\n      state,\n      matches,\n      loaderResults,\n      pendingActionResult,\n      revalidatingFetchers,\n      fetcherResults,\n      activeDeferreds\n    );\n\n    // Wire up subscribers to update loaderData as promises settle\n    activeDeferreds.forEach((deferredData, routeId) => {\n      deferredData.subscribe((aborted) => {\n        // Note: No need to updateState here since the TrackedPromise on\n        // loaderData is stable across resolve/reject\n        // Remove this instance if we were aborted or if promises have settled\n        if (aborted || deferredData.done) {\n          activeDeferreds.delete(routeId);\n        }\n      });\n    });\n\n    // Preserve SSR errors during partial hydration\n    if (future.v7_partialHydration && initialHydration && state.errors) {\n      errors = { ...state.errors, ...errors };\n    }\n\n    let updatedFetchers = markFetchRedirectsDone();\n    let didAbortFetchLoads = abortStaleFetchLoads(pendingNavigationLoadId);\n    let shouldUpdateFetchers =\n      updatedFetchers || didAbortFetchLoads || revalidatingFetchers.length > 0;\n\n    return {\n      matches,\n      loaderData,\n      errors,\n      ...(shouldUpdateFetchers ? { fetchers: new Map(state.fetchers) } : {}),\n    };\n  }\n\n  function getUpdatedActionData(\n    pendingActionResult: PendingActionResult | undefined\n  ): Record<string, RouteData> | null | undefined {\n    if (pendingActionResult && !isErrorResult(pendingActionResult[1])) {\n      // This is cast to `any` currently because `RouteData`uses any and it\n      // would be a breaking change to use any.\n      // TODO: v7 - change `RouteData` to use `unknown` instead of `any`\n      return {\n        [pendingActionResult[0]]: pendingActionResult[1].data as any,\n      };\n    } else if (state.actionData) {\n      if (Object.keys(state.actionData).length === 0) {\n        return null;\n      } else {\n        return state.actionData;\n      }\n    }\n  }\n\n  function getUpdatedRevalidatingFetchers(\n    revalidatingFetchers: RevalidatingFetcher[]\n  ) {\n    revalidatingFetchers.forEach((rf) => {\n      let fetcher = state.fetchers.get(rf.key);\n      let revalidatingFetcher = getLoadingFetcher(\n        undefined,\n        fetcher ? fetcher.data : undefined\n      );\n      state.fetchers.set(rf.key, revalidatingFetcher);\n    });\n    return new Map(state.fetchers);\n  }\n\n  // Trigger a fetcher load/submit for the given fetcher key\n  function fetch(\n    key: string,\n    routeId: string,\n    href: string | null,\n    opts?: RouterFetchOptions\n  ) {\n    if (isServer) {\n      throw new Error(\n        \"router.fetch() was called during the server render, but it shouldn't be. \" +\n          \"You are likely calling a useFetcher() method in the body of your component. \" +\n          \"Try moving it to a useEffect or a callback.\"\n      );\n    }\n\n    abortFetcher(key);\n\n    let flushSync = (opts && opts.flushSync) === true;\n\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    let normalizedPath = normalizeTo(\n      state.location,\n      state.matches,\n      basename,\n      future.v7_prependBasename,\n      href,\n      future.v7_relativeSplatPath,\n      routeId,\n      opts?.relative\n    );\n    let matches = matchRoutes(routesToUse, normalizedPath, basename);\n\n    let fogOfWar = checkFogOfWar(matches, routesToUse, normalizedPath);\n    if (fogOfWar.active && fogOfWar.matches) {\n      matches = fogOfWar.matches;\n    }\n\n    if (!matches) {\n      setFetcherError(\n        key,\n        routeId,\n        getInternalRouterError(404, { pathname: normalizedPath }),\n        { flushSync }\n      );\n      return;\n    }\n\n    let { path, submission, error } = normalizeNavigateOptions(\n      future.v7_normalizeFormMethod,\n      true,\n      normalizedPath,\n      opts\n    );\n\n    if (error) {\n      setFetcherError(key, routeId, error, { flushSync });\n      return;\n    }\n\n    let match = getTargetMatch(matches, path);\n\n    let preventScrollReset = (opts && opts.preventScrollReset) === true;\n\n    if (submission && isMutationMethod(submission.formMethod)) {\n      handleFetcherAction(\n        key,\n        routeId,\n        path,\n        match,\n        matches,\n        fogOfWar.active,\n        flushSync,\n        preventScrollReset,\n        submission\n      );\n      return;\n    }\n\n    // Store off the match so we can call it's shouldRevalidate on subsequent\n    // revalidations\n    fetchLoadMatches.set(key, { routeId, path });\n    handleFetcherLoader(\n      key,\n      routeId,\n      path,\n      match,\n      matches,\n      fogOfWar.active,\n      flushSync,\n      preventScrollReset,\n      submission\n    );\n  }\n\n  // Call the action for the matched fetcher.submit(), and then handle redirects,\n  // errors, and revalidation\n  async function handleFetcherAction(\n    key: string,\n    routeId: string,\n    path: string,\n    match: AgnosticDataRouteMatch,\n    requestMatches: AgnosticDataRouteMatch[],\n    isFogOfWar: boolean,\n    flushSync: boolean,\n    preventScrollReset: boolean,\n    submission: Submission\n  ) {\n    interruptActiveLoads();\n    fetchLoadMatches.delete(key);\n\n    function detectAndHandle405Error(m: AgnosticDataRouteMatch) {\n      if (!m.route.action && !m.route.lazy) {\n        let error = getInternalRouterError(405, {\n          method: submission.formMethod,\n          pathname: path,\n          routeId: routeId,\n        });\n        setFetcherError(key, routeId, error, { flushSync });\n        return true;\n      }\n      return false;\n    }\n\n    if (!isFogOfWar && detectAndHandle405Error(match)) {\n      return;\n    }\n\n    // Put this fetcher into it's submitting state\n    let existingFetcher = state.fetchers.get(key);\n    updateFetcherState(key, getSubmittingFetcher(submission, existingFetcher), {\n      flushSync,\n    });\n\n    let abortController = new AbortController();\n    let fetchRequest = createClientSideRequest(\n      init.history,\n      path,\n      abortController.signal,\n      submission\n    );\n\n    if (isFogOfWar) {\n      let discoverResult = await discoverRoutes(\n        requestMatches,\n        new URL(fetchRequest.url).pathname,\n        fetchRequest.signal,\n        key\n      );\n\n      if (discoverResult.type === \"aborted\") {\n        return;\n      } else if (discoverResult.type === \"error\") {\n        setFetcherError(key, routeId, discoverResult.error, { flushSync });\n        return;\n      } else if (!discoverResult.matches) {\n        setFetcherError(\n          key,\n          routeId,\n          getInternalRouterError(404, { pathname: path }),\n          { flushSync }\n        );\n        return;\n      } else {\n        requestMatches = discoverResult.matches;\n        match = getTargetMatch(requestMatches, path);\n\n        if (detectAndHandle405Error(match)) {\n          return;\n        }\n      }\n    }\n\n    // Call the action for the fetcher\n    fetchControllers.set(key, abortController);\n\n    let originatingLoadId = incrementingLoadId;\n    let actionResults = await callDataStrategy(\n      \"action\",\n      state,\n      fetchRequest,\n      [match],\n      requestMatches,\n      key\n    );\n    let actionResult = actionResults[match.route.id];\n\n    if (fetchRequest.signal.aborted) {\n      // We can delete this so long as we weren't aborted by our own fetcher\n      // re-submit which would have put _new_ controller is in fetchControllers\n      if (fetchControllers.get(key) === abortController) {\n        fetchControllers.delete(key);\n      }\n      return;\n    }\n\n    // When using v7_fetcherPersist, we don't want errors bubbling up to the UI\n    // or redirects processed for unmounted fetchers so we just revert them to\n    // idle\n    if (future.v7_fetcherPersist && deletedFetchers.has(key)) {\n      if (isRedirectResult(actionResult) || isErrorResult(actionResult)) {\n        updateFetcherState(key, getDoneFetcher(undefined));\n        return;\n      }\n      // Let SuccessResult's fall through for revalidation\n    } else {\n      if (isRedirectResult(actionResult)) {\n        fetchControllers.delete(key);\n        if (pendingNavigationLoadId > originatingLoadId) {\n          // A new navigation was kicked off after our action started, so that\n          // should take precedence over this redirect navigation.  We already\n          // set isRevalidationRequired so all loaders for the new route should\n          // fire unless opted out via shouldRevalidate\n          updateFetcherState(key, getDoneFetcher(undefined));\n          return;\n        } else {\n          fetchRedirectIds.add(key);\n          updateFetcherState(key, getLoadingFetcher(submission));\n          return startRedirectNavigation(fetchRequest, actionResult, false, {\n            fetcherSubmission: submission,\n            preventScrollReset,\n          });\n        }\n      }\n\n      // Process any non-redirect errors thrown\n      if (isErrorResult(actionResult)) {\n        setFetcherError(key, routeId, actionResult.error);\n        return;\n      }\n    }\n\n    if (isDeferredResult(actionResult)) {\n      throw getInternalRouterError(400, { type: \"defer-action\" });\n    }\n\n    // Start the data load for current matches, or the next location if we're\n    // in the middle of a navigation\n    let nextLocation = state.navigation.location || state.location;\n    let revalidationRequest = createClientSideRequest(\n      init.history,\n      nextLocation,\n      abortController.signal\n    );\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    let matches =\n      state.navigation.state !== \"idle\"\n        ? matchRoutes(routesToUse, state.navigation.location, basename)\n        : state.matches;\n\n    invariant(matches, \"Didn't find any matches after fetcher action\");\n\n    let loadId = ++incrementingLoadId;\n    fetchReloadIds.set(key, loadId);\n\n    let loadFetcher = getLoadingFetcher(submission, actionResult.data);\n    state.fetchers.set(key, loadFetcher);\n\n    let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(\n      init.history,\n      state,\n      matches,\n      submission,\n      nextLocation,\n      false,\n      future.v7_skipActionErrorRevalidation,\n      isRevalidationRequired,\n      cancelledDeferredRoutes,\n      cancelledFetcherLoads,\n      deletedFetchers,\n      fetchLoadMatches,\n      fetchRedirectIds,\n      routesToUse,\n      basename,\n      [match.route.id, actionResult]\n    );\n\n    // Put all revalidating fetchers into the loading state, except for the\n    // current fetcher which we want to keep in it's current loading state which\n    // contains it's action submission info + action data\n    revalidatingFetchers\n      .filter((rf) => rf.key !== key)\n      .forEach((rf) => {\n        let staleKey = rf.key;\n        let existingFetcher = state.fetchers.get(staleKey);\n        let revalidatingFetcher = getLoadingFetcher(\n          undefined,\n          existingFetcher ? existingFetcher.data : undefined\n        );\n        state.fetchers.set(staleKey, revalidatingFetcher);\n        abortFetcher(staleKey);\n        if (rf.controller) {\n          fetchControllers.set(staleKey, rf.controller);\n        }\n      });\n\n    updateState({ fetchers: new Map(state.fetchers) });\n\n    let abortPendingFetchRevalidations = () =>\n      revalidatingFetchers.forEach((rf) => abortFetcher(rf.key));\n\n    abortController.signal.addEventListener(\n      \"abort\",\n      abortPendingFetchRevalidations\n    );\n\n    let { loaderResults, fetcherResults } =\n      await callLoadersAndMaybeResolveData(\n        state,\n        matches,\n        matchesToLoad,\n        revalidatingFetchers,\n        revalidationRequest\n      );\n\n    if (abortController.signal.aborted) {\n      return;\n    }\n\n    abortController.signal.removeEventListener(\n      \"abort\",\n      abortPendingFetchRevalidations\n    );\n\n    fetchReloadIds.delete(key);\n    fetchControllers.delete(key);\n    revalidatingFetchers.forEach((r) => fetchControllers.delete(r.key));\n\n    let redirect = findRedirect(loaderResults);\n    if (redirect) {\n      return startRedirectNavigation(\n        revalidationRequest,\n        redirect.result,\n        false,\n        { preventScrollReset }\n      );\n    }\n\n    redirect = findRedirect(fetcherResults);\n    if (redirect) {\n      // If this redirect came from a fetcher make sure we mark it in\n      // fetchRedirectIds so it doesn't get revalidated on the next set of\n      // loader executions\n      fetchRedirectIds.add(redirect.key);\n      return startRedirectNavigation(\n        revalidationRequest,\n        redirect.result,\n        false,\n        { preventScrollReset }\n      );\n    }\n\n    // Process and commit output from loaders\n    let { loaderData, errors } = processLoaderData(\n      state,\n      matches,\n      loaderResults,\n      undefined,\n      revalidatingFetchers,\n      fetcherResults,\n      activeDeferreds\n    );\n\n    // Since we let revalidations complete even if the submitting fetcher was\n    // deleted, only put it back to idle if it hasn't been deleted\n    if (state.fetchers.has(key)) {\n      let doneFetcher = getDoneFetcher(actionResult.data);\n      state.fetchers.set(key, doneFetcher);\n    }\n\n    abortStaleFetchLoads(loadId);\n\n    // If we are currently in a navigation loading state and this fetcher is\n    // more recent than the navigation, we want the newer data so abort the\n    // navigation and complete it with the fetcher data\n    if (\n      state.navigation.state === \"loading\" &&\n      loadId > pendingNavigationLoadId\n    ) {\n      invariant(pendingAction, \"Expected pending action\");\n      pendingNavigationController && pendingNavigationController.abort();\n\n      completeNavigation(state.navigation.location, {\n        matches,\n        loaderData,\n        errors,\n        fetchers: new Map(state.fetchers),\n      });\n    } else {\n      // otherwise just update with the fetcher data, preserving any existing\n      // loaderData for loaders that did not need to reload.  We have to\n      // manually merge here since we aren't going through completeNavigation\n      updateState({\n        errors,\n        loaderData: mergeLoaderData(\n          state.loaderData,\n          loaderData,\n          matches,\n          errors\n        ),\n        fetchers: new Map(state.fetchers),\n      });\n      isRevalidationRequired = false;\n    }\n  }\n\n  // Call the matched loader for fetcher.load(), handling redirects, errors, etc.\n  async function handleFetcherLoader(\n    key: string,\n    routeId: string,\n    path: string,\n    match: AgnosticDataRouteMatch,\n    matches: AgnosticDataRouteMatch[],\n    isFogOfWar: boolean,\n    flushSync: boolean,\n    preventScrollReset: boolean,\n    submission?: Submission\n  ) {\n    let existingFetcher = state.fetchers.get(key);\n    updateFetcherState(\n      key,\n      getLoadingFetcher(\n        submission,\n        existingFetcher ? existingFetcher.data : undefined\n      ),\n      { flushSync }\n    );\n\n    let abortController = new AbortController();\n    let fetchRequest = createClientSideRequest(\n      init.history,\n      path,\n      abortController.signal\n    );\n\n    if (isFogOfWar) {\n      let discoverResult = await discoverRoutes(\n        matches,\n        new URL(fetchRequest.url).pathname,\n        fetchRequest.signal,\n        key\n      );\n\n      if (discoverResult.type === \"aborted\") {\n        return;\n      } else if (discoverResult.type === \"error\") {\n        setFetcherError(key, routeId, discoverResult.error, { flushSync });\n        return;\n      } else if (!discoverResult.matches) {\n        setFetcherError(\n          key,\n          routeId,\n          getInternalRouterError(404, { pathname: path }),\n          { flushSync }\n        );\n        return;\n      } else {\n        matches = discoverResult.matches;\n        match = getTargetMatch(matches, path);\n      }\n    }\n\n    // Call the loader for this fetcher route match\n    fetchControllers.set(key, abortController);\n\n    let originatingLoadId = incrementingLoadId;\n    let results = await callDataStrategy(\n      \"loader\",\n      state,\n      fetchRequest,\n      [match],\n      matches,\n      key\n    );\n    let result = results[match.route.id];\n\n    // Deferred isn't supported for fetcher loads, await everything and treat it\n    // as a normal load.  resolveDeferredData will return undefined if this\n    // fetcher gets aborted, so we just leave result untouched and short circuit\n    // below if that happens\n    if (isDeferredResult(result)) {\n      result =\n        (await resolveDeferredData(result, fetchRequest.signal, true)) ||\n        result;\n    }\n\n    // We can delete this so long as we weren't aborted by our our own fetcher\n    // re-load which would have put _new_ controller is in fetchControllers\n    if (fetchControllers.get(key) === abortController) {\n      fetchControllers.delete(key);\n    }\n\n    if (fetchRequest.signal.aborted) {\n      return;\n    }\n\n    // We don't want errors bubbling up or redirects followed for unmounted\n    // fetchers, so short circuit here if it was removed from the UI\n    if (deletedFetchers.has(key)) {\n      updateFetcherState(key, getDoneFetcher(undefined));\n      return;\n    }\n\n    // If the loader threw a redirect Response, start a new REPLACE navigation\n    if (isRedirectResult(result)) {\n      if (pendingNavigationLoadId > originatingLoadId) {\n        // A new navigation was kicked off after our loader started, so that\n        // should take precedence over this redirect navigation\n        updateFetcherState(key, getDoneFetcher(undefined));\n        return;\n      } else {\n        fetchRedirectIds.add(key);\n        await startRedirectNavigation(fetchRequest, result, false, {\n          preventScrollReset,\n        });\n        return;\n      }\n    }\n\n    // Process any non-redirect errors thrown\n    if (isErrorResult(result)) {\n      setFetcherError(key, routeId, result.error);\n      return;\n    }\n\n    invariant(!isDeferredResult(result), \"Unhandled fetcher deferred data\");\n\n    // Put the fetcher back into an idle state\n    updateFetcherState(key, getDoneFetcher(result.data));\n  }\n\n  /**\n   * Utility function to handle redirects returned from an action or loader.\n   * Normally, a redirect \"replaces\" the navigation that triggered it.  So, for\n   * example:\n   *\n   *  - user is on /a\n   *  - user clicks a link to /b\n   *  - loader for /b redirects to /c\n   *\n   * In a non-JS app the browser would track the in-flight navigation to /b and\n   * then replace it with /c when it encountered the redirect response.  In\n   * the end it would only ever update the URL bar with /c.\n   *\n   * In client-side routing using pushState/replaceState, we aim to emulate\n   * this behavior and we also do not update history until the end of the\n   * navigation (including processed redirects).  This means that we never\n   * actually touch history until we've processed redirects, so we just use\n   * the history action from the original navigation (PUSH or REPLACE).\n   */\n  async function startRedirectNavigation(\n    request: Request,\n    redirect: RedirectResult,\n    isNavigation: boolean,\n    {\n      submission,\n      fetcherSubmission,\n      preventScrollReset,\n      replace,\n    }: {\n      submission?: Submission;\n      fetcherSubmission?: Submission;\n      preventScrollReset?: boolean;\n      replace?: boolean;\n    } = {}\n  ) {\n    if (redirect.response.headers.has(\"X-Remix-Revalidate\")) {\n      isRevalidationRequired = true;\n    }\n\n    let location = redirect.response.headers.get(\"Location\");\n    invariant(location, \"Expected a Location header on the redirect Response\");\n    location = normalizeRedirectLocation(\n      location,\n      new URL(request.url),\n      basename,\n      init.history,\n    );\n    let redirectLocation = createLocation(state.location, location, {\n      _isRedirect: true,\n    });\n\n    if (isBrowser) {\n      let isDocumentReload = false;\n\n      if (redirect.response.headers.has(\"X-Remix-Reload-Document\")) {\n        // Hard reload if the response contained X-Remix-Reload-Document\n        isDocumentReload = true;\n      } else if (ABSOLUTE_URL_REGEX.test(location)) {\n        const url = init.history.createURL(location);\n        isDocumentReload =\n          // Hard reload if it's an absolute URL to a new origin\n          url.origin !== routerWindow.location.origin ||\n          // Hard reload if it's an absolute URL that does not match our basename\n          stripBasename(url.pathname, basename) == null;\n      }\n\n      if (isDocumentReload) {\n        if (replace) {\n          routerWindow.location.replace(location);\n        } else {\n          routerWindow.location.assign(location);\n        }\n        return;\n      }\n    }\n\n    // There's no need to abort on redirects, since we don't detect the\n    // redirect until the action/loaders have settled\n    pendingNavigationController = null;\n\n    let redirectHistoryAction =\n      replace === true || redirect.response.headers.has(\"X-Remix-Replace\")\n        ? HistoryAction.Replace\n        : HistoryAction.Push;\n\n    // Use the incoming submission if provided, fallback on the active one in\n    // state.navigation\n    let { formMethod, formAction, formEncType } = state.navigation;\n    if (\n      !submission &&\n      !fetcherSubmission &&\n      formMethod &&\n      formAction &&\n      formEncType\n    ) {\n      submission = getSubmissionFromNavigation(state.navigation);\n    }\n\n    // If this was a 307/308 submission we want to preserve the HTTP method and\n    // re-submit the GET/POST/PUT/PATCH/DELETE as a submission navigation to the\n    // redirected location\n    let activeSubmission = submission || fetcherSubmission;\n    if (\n      redirectPreserveMethodStatusCodes.has(redirect.response.status) &&\n      activeSubmission &&\n      isMutationMethod(activeSubmission.formMethod)\n    ) {\n      await startNavigation(redirectHistoryAction, redirectLocation, {\n        submission: {\n          ...activeSubmission,\n          formAction: location,\n        },\n        // Preserve these flags across redirects\n        preventScrollReset: preventScrollReset || pendingPreventScrollReset,\n        enableViewTransition: isNavigation\n          ? pendingViewTransitionEnabled\n          : undefined,\n      });\n    } else {\n      // If we have a navigation submission, we will preserve it through the\n      // redirect navigation\n      let overrideNavigation = getLoadingNavigation(\n        redirectLocation,\n        submission\n      );\n      await startNavigation(redirectHistoryAction, redirectLocation, {\n        overrideNavigation,\n        // Send fetcher submissions through for shouldRevalidate\n        fetcherSubmission,\n        // Preserve these flags across redirects\n        preventScrollReset: preventScrollReset || pendingPreventScrollReset,\n        enableViewTransition: isNavigation\n          ? pendingViewTransitionEnabled\n          : undefined,\n      });\n    }\n  }\n\n  // Utility wrapper for calling dataStrategy client-side without having to\n  // pass around the manifest, mapRouteProperties, etc.\n  async function callDataStrategy(\n    type: \"loader\" | \"action\",\n    state: RouterState,\n    request: Request,\n    matchesToLoad: AgnosticDataRouteMatch[],\n    matches: AgnosticDataRouteMatch[],\n    fetcherKey: string | null\n  ): Promise<Record<string, DataResult>> {\n    let results: Record<string, DataStrategyResult>;\n    let dataResults: Record<string, DataResult> = {};\n    try {\n      results = await callDataStrategyImpl(\n        dataStrategyImpl,\n        type,\n        state,\n        request,\n        matchesToLoad,\n        matches,\n        fetcherKey,\n        manifest,\n        mapRouteProperties\n      );\n    } catch (e) {\n      // If the outer dataStrategy method throws, just return the error for all\n      // matches - and it'll naturally bubble to the root\n      matchesToLoad.forEach((m) => {\n        dataResults[m.route.id] = {\n          type: ResultType.error,\n          error: e,\n        };\n      });\n      return dataResults;\n    }\n\n    for (let [routeId, result] of Object.entries(results)) {\n      if (isRedirectDataStrategyResultResult(result)) {\n        let response = result.result as Response;\n        dataResults[routeId] = {\n          type: ResultType.redirect,\n          response: normalizeRelativeRoutingRedirectResponse(\n            response,\n            request,\n            routeId,\n            matches,\n            basename,\n            future.v7_relativeSplatPath\n          ),\n        };\n      } else {\n        dataResults[routeId] = await convertDataStrategyResultToDataResult(\n          result\n        );\n      }\n    }\n\n    return dataResults;\n  }\n\n  async function callLoadersAndMaybeResolveData(\n    state: RouterState,\n    matches: AgnosticDataRouteMatch[],\n    matchesToLoad: AgnosticDataRouteMatch[],\n    fetchersToLoad: RevalidatingFetcher[],\n    request: Request\n  ) {\n    let currentMatches = state.matches;\n\n    // Kick off loaders and fetchers in parallel\n    let loaderResultsPromise = callDataStrategy(\n      \"loader\",\n      state,\n      request,\n      matchesToLoad,\n      matches,\n      null\n    );\n\n    let fetcherResultsPromise = Promise.all(\n      fetchersToLoad.map(async (f) => {\n        if (f.matches && f.match && f.controller) {\n          let results = await callDataStrategy(\n            \"loader\",\n            state,\n            createClientSideRequest(init.history, f.path, f.controller.signal),\n            [f.match],\n            f.matches,\n            f.key\n          );\n          let result = results[f.match.route.id];\n          // Fetcher results are keyed by fetcher key from here on out, not routeId\n          return { [f.key]: result };\n        } else {\n          return Promise.resolve({\n            [f.key]: {\n              type: ResultType.error,\n              error: getInternalRouterError(404, {\n                pathname: f.path,\n              }),\n            } as ErrorResult,\n          });\n        }\n      })\n    );\n\n    let loaderResults = await loaderResultsPromise;\n    let fetcherResults = (await fetcherResultsPromise).reduce(\n      (acc, r) => Object.assign(acc, r),\n      {}\n    );\n\n    await Promise.all([\n      resolveNavigationDeferredResults(\n        matches,\n        loaderResults,\n        request.signal,\n        currentMatches,\n        state.loaderData\n      ),\n      resolveFetcherDeferredResults(matches, fetcherResults, fetchersToLoad),\n    ]);\n\n    return {\n      loaderResults,\n      fetcherResults,\n    };\n  }\n\n  function interruptActiveLoads() {\n    // Every interruption triggers a revalidation\n    isRevalidationRequired = true;\n\n    // Cancel pending route-level deferreds and mark cancelled routes for\n    // revalidation\n    cancelledDeferredRoutes.push(...cancelActiveDeferreds());\n\n    // Abort in-flight fetcher loads\n    fetchLoadMatches.forEach((_, key) => {\n      if (fetchControllers.has(key)) {\n        cancelledFetcherLoads.add(key);\n      }\n      abortFetcher(key);\n    });\n  }\n\n  function updateFetcherState(\n    key: string,\n    fetcher: Fetcher,\n    opts: { flushSync?: boolean } = {}\n  ) {\n    state.fetchers.set(key, fetcher);\n    updateState(\n      { fetchers: new Map(state.fetchers) },\n      { flushSync: (opts && opts.flushSync) === true }\n    );\n  }\n\n  function setFetcherError(\n    key: string,\n    routeId: string,\n    error: any,\n    opts: { flushSync?: boolean } = {}\n  ) {\n    let boundaryMatch = findNearestBoundary(state.matches, routeId);\n    deleteFetcher(key);\n    updateState(\n      {\n        errors: {\n          [boundaryMatch.route.id]: error,\n        },\n        fetchers: new Map(state.fetchers),\n      },\n      { flushSync: (opts && opts.flushSync) === true }\n    );\n  }\n\n  function getFetcher<TData = any>(key: string): Fetcher<TData> {\n    activeFetchers.set(key, (activeFetchers.get(key) || 0) + 1);\n    // If this fetcher was previously marked for deletion, unmark it since we\n    // have a new instance\n    if (deletedFetchers.has(key)) {\n      deletedFetchers.delete(key);\n    }\n    return state.fetchers.get(key) || IDLE_FETCHER;\n  }\n\n  function deleteFetcher(key: string): void {\n    let fetcher = state.fetchers.get(key);\n    // Don't abort the controller if this is a deletion of a fetcher.submit()\n    // in it's loading phase since - we don't want to abort the corresponding\n    // revalidation and want them to complete and land\n    if (\n      fetchControllers.has(key) &&\n      !(fetcher && fetcher.state === \"loading\" && fetchReloadIds.has(key))\n    ) {\n      abortFetcher(key);\n    }\n    fetchLoadMatches.delete(key);\n    fetchReloadIds.delete(key);\n    fetchRedirectIds.delete(key);\n\n    // If we opted into the flag we can clear this now since we're calling\n    // deleteFetcher() at the end of updateState() and we've already handed the\n    // deleted fetcher keys off to the data layer.\n    // If not, we're eagerly calling deleteFetcher() and we need to keep this\n    // Set populated until the next updateState call, and we'll clear\n    // `deletedFetchers` then\n    if (future.v7_fetcherPersist) {\n      deletedFetchers.delete(key);\n    }\n\n    cancelledFetcherLoads.delete(key);\n    state.fetchers.delete(key);\n  }\n\n  function deleteFetcherAndUpdateState(key: string): void {\n    let count = (activeFetchers.get(key) || 0) - 1;\n    if (count <= 0) {\n      activeFetchers.delete(key);\n      deletedFetchers.add(key);\n      if (!future.v7_fetcherPersist) {\n        deleteFetcher(key);\n      }\n    } else {\n      activeFetchers.set(key, count);\n    }\n\n    updateState({ fetchers: new Map(state.fetchers) });\n  }\n\n  function abortFetcher(key: string) {\n    let controller = fetchControllers.get(key);\n    if (controller) {\n      controller.abort();\n      fetchControllers.delete(key);\n    }\n  }\n\n  function markFetchersDone(keys: string[]) {\n    for (let key of keys) {\n      let fetcher = getFetcher(key);\n      let doneFetcher = getDoneFetcher(fetcher.data);\n      state.fetchers.set(key, doneFetcher);\n    }\n  }\n\n  function markFetchRedirectsDone(): boolean {\n    let doneKeys = [];\n    let updatedFetchers = false;\n    for (let key of fetchRedirectIds) {\n      let fetcher = state.fetchers.get(key);\n      invariant(fetcher, `Expected fetcher: ${key}`);\n      if (fetcher.state === \"loading\") {\n        fetchRedirectIds.delete(key);\n        doneKeys.push(key);\n        updatedFetchers = true;\n      }\n    }\n    markFetchersDone(doneKeys);\n    return updatedFetchers;\n  }\n\n  function abortStaleFetchLoads(landedId: number): boolean {\n    let yeetedKeys = [];\n    for (let [key, id] of fetchReloadIds) {\n      if (id < landedId) {\n        let fetcher = state.fetchers.get(key);\n        invariant(fetcher, `Expected fetcher: ${key}`);\n        if (fetcher.state === \"loading\") {\n          abortFetcher(key);\n          fetchReloadIds.delete(key);\n          yeetedKeys.push(key);\n        }\n      }\n    }\n    markFetchersDone(yeetedKeys);\n    return yeetedKeys.length > 0;\n  }\n\n  function getBlocker(key: string, fn: BlockerFunction) {\n    let blocker: Blocker = state.blockers.get(key) || IDLE_BLOCKER;\n\n    if (blockerFunctions.get(key) !== fn) {\n      blockerFunctions.set(key, fn);\n    }\n\n    return blocker;\n  }\n\n  function deleteBlocker(key: string) {\n    state.blockers.delete(key);\n    blockerFunctions.delete(key);\n  }\n\n  // Utility function to update blockers, ensuring valid state transitions\n  function updateBlocker(key: string, newBlocker: Blocker) {\n    let blocker = state.blockers.get(key) || IDLE_BLOCKER;\n\n    // Poor mans state machine :)\n    // https://mermaid.live/edit#pako:eNqVkc9OwzAMxl8l8nnjAYrEtDIOHEBIgwvKJTReGy3_lDpIqO27k6awMG0XcrLlnz87nwdonESogKXXBuE79rq75XZO3-yHds0RJVuv70YrPlUrCEe2HfrORS3rubqZfuhtpg5C9wk5tZ4VKcRUq88q9Z8RS0-48cE1iHJkL0ugbHuFLus9L6spZy8nX9MP2CNdomVaposqu3fGayT8T8-jJQwhepo_UtpgBQaDEUom04dZhAN1aJBDlUKJBxE1ceB2Smj0Mln-IBW5AFU2dwUiktt_2Qaq2dBfaKdEup85UV7Yd-dKjlnkabl2Pvr0DTkTreM\n    invariant(\n      (blocker.state === \"unblocked\" && newBlocker.state === \"blocked\") ||\n        (blocker.state === \"blocked\" && newBlocker.state === \"blocked\") ||\n        (blocker.state === \"blocked\" && newBlocker.state === \"proceeding\") ||\n        (blocker.state === \"blocked\" && newBlocker.state === \"unblocked\") ||\n        (blocker.state === \"proceeding\" && newBlocker.state === \"unblocked\"),\n      `Invalid blocker state transition: ${blocker.state} -> ${newBlocker.state}`\n    );\n\n    let blockers = new Map(state.blockers);\n    blockers.set(key, newBlocker);\n    updateState({ blockers });\n  }\n\n  function shouldBlockNavigation({\n    currentLocation,\n    nextLocation,\n    historyAction,\n  }: {\n    currentLocation: Location;\n    nextLocation: Location;\n    historyAction: HistoryAction;\n  }): string | undefined {\n    if (blockerFunctions.size === 0) {\n      return;\n    }\n\n    // We ony support a single active blocker at the moment since we don't have\n    // any compelling use cases for multi-blocker yet\n    if (blockerFunctions.size > 1) {\n      warning(false, \"A router only supports one blocker at a time\");\n    }\n\n    let entries = Array.from(blockerFunctions.entries());\n    let [blockerKey, blockerFunction] = entries[entries.length - 1];\n    let blocker = state.blockers.get(blockerKey);\n\n    if (blocker && blocker.state === \"proceeding\") {\n      // If the blocker is currently proceeding, we don't need to re-check\n      // it and can let this navigation continue\n      return;\n    }\n\n    // At this point, we know we're unblocked/blocked so we need to check the\n    // user-provided blocker function\n    if (blockerFunction({ currentLocation, nextLocation, historyAction })) {\n      return blockerKey;\n    }\n  }\n\n  function handleNavigational404(pathname: string) {\n    let error = getInternalRouterError(404, { pathname });\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    let { matches, route } = getShortCircuitMatches(routesToUse);\n\n    // Cancel all pending deferred on 404s since we don't keep any routes\n    cancelActiveDeferreds();\n\n    return { notFoundMatches: matches, route, error };\n  }\n\n  function cancelActiveDeferreds(\n    predicate?: (routeId: string) => boolean\n  ): string[] {\n    let cancelledRouteIds: string[] = [];\n    activeDeferreds.forEach((dfd, routeId) => {\n      if (!predicate || predicate(routeId)) {\n        // Cancel the deferred - but do not remove from activeDeferreds here -\n        // we rely on the subscribers to do that so our tests can assert proper\n        // cleanup via _internalActiveDeferreds\n        dfd.cancel();\n        cancelledRouteIds.push(routeId);\n        activeDeferreds.delete(routeId);\n      }\n    });\n    return cancelledRouteIds;\n  }\n\n  // Opt in to capturing and reporting scroll positions during navigations,\n  // used by the <ScrollRestoration> component\n  function enableScrollRestoration(\n    positions: Record<string, number>,\n    getPosition: GetScrollPositionFunction,\n    getKey?: GetScrollRestorationKeyFunction\n  ) {\n    savedScrollPositions = positions;\n    getScrollPosition = getPosition;\n    getScrollRestorationKey = getKey || null;\n\n    // Perform initial hydration scroll restoration, since we miss the boat on\n    // the initial updateState() because we've not yet rendered <ScrollRestoration/>\n    // and therefore have no savedScrollPositions available\n    if (!initialScrollRestored && state.navigation === IDLE_NAVIGATION) {\n      initialScrollRestored = true;\n      let y = getSavedScrollPosition(state.location, state.matches);\n      if (y != null) {\n        updateState({ restoreScrollPosition: y });\n      }\n    }\n\n    return () => {\n      savedScrollPositions = null;\n      getScrollPosition = null;\n      getScrollRestorationKey = null;\n    };\n  }\n\n  function getScrollKey(location: Location, matches: AgnosticDataRouteMatch[]) {\n    if (getScrollRestorationKey) {\n      let key = getScrollRestorationKey(\n        location,\n        matches.map((m) => convertRouteMatchToUiMatch(m, state.loaderData))\n      );\n      return key || location.key;\n    }\n    return location.key;\n  }\n\n  function saveScrollPosition(\n    location: Location,\n    matches: AgnosticDataRouteMatch[]\n  ): void {\n    if (savedScrollPositions && getScrollPosition) {\n      let key = getScrollKey(location, matches);\n      savedScrollPositions[key] = getScrollPosition();\n    }\n  }\n\n  function getSavedScrollPosition(\n    location: Location,\n    matches: AgnosticDataRouteMatch[]\n  ): number | null {\n    if (savedScrollPositions) {\n      let key = getScrollKey(location, matches);\n      let y = savedScrollPositions[key];\n      if (typeof y === \"number\") {\n        return y;\n      }\n    }\n    return null;\n  }\n\n  function checkFogOfWar(\n    matches: AgnosticDataRouteMatch[] | null,\n    routesToUse: AgnosticDataRouteObject[],\n    pathname: string\n  ): { active: boolean; matches: AgnosticDataRouteMatch[] | null } {\n    if (patchRoutesOnNavigationImpl) {\n      if (!matches) {\n        let fogMatches = matchRoutesImpl<AgnosticDataRouteObject>(\n          routesToUse,\n          pathname,\n          basename,\n          true\n        );\n\n        return { active: true, matches: fogMatches || [] };\n      } else {\n        if (Object.keys(matches[0].params).length > 0) {\n          // If we matched a dynamic param or a splat, it might only be because\n          // we haven't yet discovered other routes that would match with a\n          // higher score.  Call patchRoutesOnNavigation just to be sure\n          let partialMatches = matchRoutesImpl<AgnosticDataRouteObject>(\n            routesToUse,\n            pathname,\n            basename,\n            true\n          );\n          return { active: true, matches: partialMatches };\n        }\n      }\n    }\n\n    return { active: false, matches: null };\n  }\n\n  type DiscoverRoutesSuccessResult = {\n    type: \"success\";\n    matches: AgnosticDataRouteMatch[] | null;\n  };\n  type DiscoverRoutesErrorResult = {\n    type: \"error\";\n    error: any;\n    partialMatches: AgnosticDataRouteMatch[];\n  };\n  type DiscoverRoutesAbortedResult = { type: \"aborted\" };\n  type DiscoverRoutesResult =\n    | DiscoverRoutesSuccessResult\n    | DiscoverRoutesErrorResult\n    | DiscoverRoutesAbortedResult;\n\n  async function discoverRoutes(\n    matches: AgnosticDataRouteMatch[],\n    pathname: string,\n    signal: AbortSignal,\n    fetcherKey?: string\n  ): Promise<DiscoverRoutesResult> {\n    if (!patchRoutesOnNavigationImpl) {\n      return { type: \"success\", matches };\n    }\n\n    let partialMatches: AgnosticDataRouteMatch[] | null = matches;\n    while (true) {\n      let isNonHMR = inFlightDataRoutes == null;\n      let routesToUse = inFlightDataRoutes || dataRoutes;\n      let localManifest = manifest;\n      try {\n        await patchRoutesOnNavigationImpl({\n          signal,\n          path: pathname,\n          matches: partialMatches,\n          fetcherKey,\n          patch: (routeId, children) => {\n            if (signal.aborted) return;\n            patchRoutesImpl(\n              routeId,\n              children,\n              routesToUse,\n              localManifest,\n              mapRouteProperties\n            );\n          },\n        });\n      } catch (e) {\n        return { type: \"error\", error: e, partialMatches };\n      } finally {\n        // If we are not in the middle of an HMR revalidation and we changed the\n        // routes, provide a new identity so when we `updateState` at the end of\n        // this navigation/fetch `router.routes` will be a new identity and\n        // trigger a re-run of memoized `router.routes` dependencies.\n        // HMR will already update the identity and reflow when it lands\n        // `inFlightDataRoutes` in `completeNavigation`\n        if (isNonHMR && !signal.aborted) {\n          dataRoutes = [...dataRoutes];\n        }\n      }\n\n      if (signal.aborted) {\n        return { type: \"aborted\" };\n      }\n\n      let newMatches = matchRoutes(routesToUse, pathname, basename);\n      if (newMatches) {\n        return { type: \"success\", matches: newMatches };\n      }\n\n      let newPartialMatches = matchRoutesImpl<AgnosticDataRouteObject>(\n        routesToUse,\n        pathname,\n        basename,\n        true\n      );\n\n      // Avoid loops if the second pass results in the same partial matches\n      if (\n        !newPartialMatches ||\n        (partialMatches.length === newPartialMatches.length &&\n          partialMatches.every(\n            (m, i) => m.route.id === newPartialMatches![i].route.id\n          ))\n      ) {\n        return { type: \"success\", matches: null };\n      }\n\n      partialMatches = newPartialMatches;\n    }\n  }\n\n  function _internalSetRoutes(newRoutes: AgnosticDataRouteObject[]) {\n    manifest = {};\n    inFlightDataRoutes = convertRoutesToDataRoutes(\n      newRoutes,\n      mapRouteProperties,\n      undefined,\n      manifest\n    );\n  }\n\n  function patchRoutes(\n    routeId: string | null,\n    children: AgnosticRouteObject[]\n  ): void {\n    let isNonHMR = inFlightDataRoutes == null;\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    patchRoutesImpl(\n      routeId,\n      children,\n      routesToUse,\n      manifest,\n      mapRouteProperties\n    );\n\n    // If we are not in the middle of an HMR revalidation and we changed the\n    // routes, provide a new identity and trigger a reflow via `updateState`\n    // to re-run memoized `router.routes` dependencies.\n    // HMR will already update the identity and reflow when it lands\n    // `inFlightDataRoutes` in `completeNavigation`\n    if (isNonHMR) {\n      dataRoutes = [...dataRoutes];\n      updateState({});\n    }\n  }\n\n  router = {\n    get basename() {\n      return basename;\n    },\n    get future() {\n      return future;\n    },\n    get state() {\n      return state;\n    },\n    get routes() {\n      return dataRoutes;\n    },\n    get window() {\n      return routerWindow;\n    },\n    initialize,\n    subscribe,\n    enableScrollRestoration,\n    navigate,\n    fetch,\n    revalidate,\n    // Passthrough to history-aware createHref used by useHref so we get proper\n    // hash-aware URLs in DOM paths\n    createHref: (to: To) => init.history.createHref(to),\n    encodeLocation: (to: To) => init.history.encodeLocation(to),\n    getFetcher,\n    deleteFetcher: deleteFetcherAndUpdateState,\n    dispose,\n    getBlocker,\n    deleteBlocker,\n    patchRoutes,\n    _internalFetchControllers: fetchControllers,\n    _internalActiveDeferreds: activeDeferreds,\n    // TODO: Remove setRoutes, it's temporary to avoid dealing with\n    // updating the tree while validating the update algorithm.\n    _internalSetRoutes,\n  };\n\n  return router;\n}\n//#endregion\n\n////////////////////////////////////////////////////////////////////////////////\n//#region createStaticHandler\n////////////////////////////////////////////////////////////////////////////////\n\nexport const UNSAFE_DEFERRED_SYMBOL = Symbol(\"deferred\");\n\n/**\n * Future flags to toggle new feature behavior\n */\nexport interface StaticHandlerFutureConfig {\n  v7_relativeSplatPath: boolean;\n  v7_throwAbortReason: boolean;\n}\n\nexport interface CreateStaticHandlerOptions {\n  basename?: string;\n  /**\n   * @deprecated Use `mapRouteProperties` instead\n   */\n  detectErrorBoundary?: DetectErrorBoundaryFunction;\n  mapRouteProperties?: MapRoutePropertiesFunction;\n  future?: Partial<StaticHandlerFutureConfig>;\n}\n\nexport function createStaticHandler(\n  routes: AgnosticRouteObject[],\n  opts?: CreateStaticHandlerOptions\n): StaticHandler {\n  invariant(\n    routes.length > 0,\n    \"You must provide a non-empty routes array to createStaticHandler\"\n  );\n\n  let manifest: RouteManifest = {};\n  let basename = (opts ? opts.basename : null) || \"/\";\n  let mapRouteProperties: MapRoutePropertiesFunction;\n  if (opts?.mapRouteProperties) {\n    mapRouteProperties = opts.mapRouteProperties;\n  } else if (opts?.detectErrorBoundary) {\n    // If they are still using the deprecated version, wrap it with the new API\n    let detectErrorBoundary = opts.detectErrorBoundary;\n    mapRouteProperties = (route) => ({\n      hasErrorBoundary: detectErrorBoundary(route),\n    });\n  } else {\n    mapRouteProperties = defaultMapRouteProperties;\n  }\n  // Config driven behavior flags\n  let future: StaticHandlerFutureConfig = {\n    v7_relativeSplatPath: false,\n    v7_throwAbortReason: false,\n    ...(opts ? opts.future : null),\n  };\n\n  let dataRoutes = convertRoutesToDataRoutes(\n    routes,\n    mapRouteProperties,\n    undefined,\n    manifest\n  );\n\n  /**\n   * The query() method is intended for document requests, in which we want to\n   * call an optional action and potentially multiple loaders for all nested\n   * routes.  It returns a StaticHandlerContext object, which is very similar\n   * to the router state (location, loaderData, actionData, errors, etc.) and\n   * also adds SSR-specific information such as the statusCode and headers\n   * from action/loaders Responses.\n   *\n   * It _should_ never throw and should report all errors through the\n   * returned context.errors object, properly associating errors to their error\n   * boundary.  Additionally, it tracks _deepestRenderedBoundaryId which can be\n   * used to emulate React error boundaries during SSr by performing a second\n   * pass only down to the boundaryId.\n   *\n   * The one exception where we do not return a StaticHandlerContext is when a\n   * redirect response is returned or thrown from any action/loader.  We\n   * propagate that out and return the raw Response so the HTTP server can\n   * return it directly.\n   *\n   * - `opts.requestContext` is an optional server context that will be passed\n   *   to actions/loaders in the `context` parameter\n   * - `opts.skipLoaderErrorBubbling` is an optional parameter that will prevent\n   *   the bubbling of errors which allows single-fetch-type implementations\n   *   where the client will handle the bubbling and we may need to return data\n   *   for the handling route\n   */\n  async function query(\n    request: Request,\n    {\n      requestContext,\n      skipLoaderErrorBubbling,\n      dataStrategy,\n    }: {\n      requestContext?: unknown;\n      skipLoaderErrorBubbling?: boolean;\n      dataStrategy?: DataStrategyFunction;\n    } = {}\n  ): Promise<StaticHandlerContext | Response> {\n    let url = new URL(request.url);\n    let method = request.method;\n    let location = createLocation(\"\", createPath(url), null, \"default\");\n    let matches = matchRoutes(dataRoutes, location, basename);\n\n    // SSR supports HEAD requests while SPA doesn't\n    if (!isValidMethod(method) && method !== \"HEAD\") {\n      let error = getInternalRouterError(405, { method });\n      let { matches: methodNotAllowedMatches, route } =\n        getShortCircuitMatches(dataRoutes);\n      return {\n        basename,\n        location,\n        matches: methodNotAllowedMatches,\n        loaderData: {},\n        actionData: null,\n        errors: {\n          [route.id]: error,\n        },\n        statusCode: error.status,\n        loaderHeaders: {},\n        actionHeaders: {},\n        activeDeferreds: null,\n      };\n    } else if (!matches) {\n      let error = getInternalRouterError(404, { pathname: location.pathname });\n      let { matches: notFoundMatches, route } =\n        getShortCircuitMatches(dataRoutes);\n      return {\n        basename,\n        location,\n        matches: notFoundMatches,\n        loaderData: {},\n        actionData: null,\n        errors: {\n          [route.id]: error,\n        },\n        statusCode: error.status,\n        loaderHeaders: {},\n        actionHeaders: {},\n        activeDeferreds: null,\n      };\n    }\n\n    let result = await queryImpl(\n      request,\n      location,\n      matches,\n      requestContext,\n      dataStrategy || null,\n      skipLoaderErrorBubbling === true,\n      null\n    );\n    if (isResponse(result)) {\n      return result;\n    }\n\n    // When returning StaticHandlerContext, we patch back in the location here\n    // since we need it for React Context.  But this helps keep our submit and\n    // loadRouteData operating on a Request instead of a Location\n    return { location, basename, ...result };\n  }\n\n  /**\n   * The queryRoute() method is intended for targeted route requests, either\n   * for fetch ?_data requests or resource route requests.  In this case, we\n   * are only ever calling a single action or loader, and we are returning the\n   * returned value directly.  In most cases, this will be a Response returned\n   * from the action/loader, but it may be a primitive or other value as well -\n   * and in such cases the calling context should handle that accordingly.\n   *\n   * We do respect the throw/return differentiation, so if an action/loader\n   * throws, then this method will throw the value.  This is important so we\n   * can do proper boundary identification in Remix where a thrown Response\n   * must go to the Catch Boundary but a returned Response is happy-path.\n   *\n   * One thing to note is that any Router-initiated Errors that make sense\n   * to associate with a status code will be thrown as an ErrorResponse\n   * instance which include the raw Error, such that the calling context can\n   * serialize the error as they see fit while including the proper response\n   * code.  Examples here are 404 and 405 errors that occur prior to reaching\n   * any user-defined loaders.\n   *\n   * - `opts.routeId` allows you to specify the specific route handler to call.\n   *   If not provided the handler will determine the proper route by matching\n   *   against `request.url`\n   * - `opts.requestContext` is an optional server context that will be passed\n   *    to actions/loaders in the `context` parameter\n   */\n  async function queryRoute(\n    request: Request,\n    {\n      routeId,\n      requestContext,\n      dataStrategy,\n    }: {\n      requestContext?: unknown;\n      routeId?: string;\n      dataStrategy?: DataStrategyFunction;\n    } = {}\n  ): Promise<any> {\n    let url = new URL(request.url);\n    let method = request.method;\n    let location = createLocation(\"\", createPath(url), null, \"default\");\n    let matches = matchRoutes(dataRoutes, location, basename);\n\n    // SSR supports HEAD requests while SPA doesn't\n    if (!isValidMethod(method) && method !== \"HEAD\" && method !== \"OPTIONS\") {\n      throw getInternalRouterError(405, { method });\n    } else if (!matches) {\n      throw getInternalRouterError(404, { pathname: location.pathname });\n    }\n\n    let match = routeId\n      ? matches.find((m) => m.route.id === routeId)\n      : getTargetMatch(matches, location);\n\n    if (routeId && !match) {\n      throw getInternalRouterError(403, {\n        pathname: location.pathname,\n        routeId,\n      });\n    } else if (!match) {\n      // This should never hit I don't think?\n      throw getInternalRouterError(404, { pathname: location.pathname });\n    }\n\n    let result = await queryImpl(\n      request,\n      location,\n      matches,\n      requestContext,\n      dataStrategy || null,\n      false,\n      match\n    );\n\n    if (isResponse(result)) {\n      return result;\n    }\n\n    let error = result.errors ? Object.values(result.errors)[0] : undefined;\n    if (error !== undefined) {\n      // If we got back result.errors, that means the loader/action threw\n      // _something_ that wasn't a Response, but it's not guaranteed/required\n      // to be an `instanceof Error` either, so we have to use throw here to\n      // preserve the \"error\" state outside of queryImpl.\n      throw error;\n    }\n\n    // Pick off the right state value to return\n    if (result.actionData) {\n      return Object.values(result.actionData)[0];\n    }\n\n    if (result.loaderData) {\n      let data = Object.values(result.loaderData)[0];\n      if (result.activeDeferreds?.[match.route.id]) {\n        data[UNSAFE_DEFERRED_SYMBOL] = result.activeDeferreds[match.route.id];\n      }\n      return data;\n    }\n\n    return undefined;\n  }\n\n  async function queryImpl(\n    request: Request,\n    location: Location,\n    matches: AgnosticDataRouteMatch[],\n    requestContext: unknown,\n    dataStrategy: DataStrategyFunction | null,\n    skipLoaderErrorBubbling: boolean,\n    routeMatch: AgnosticDataRouteMatch | null\n  ): Promise<Omit<StaticHandlerContext, \"location\" | \"basename\"> | Response> {\n    invariant(\n      request.signal,\n      \"query()/queryRoute() requests must contain an AbortController signal\"\n    );\n\n    try {\n      if (isMutationMethod(request.method.toLowerCase())) {\n        let result = await submit(\n          request,\n          matches,\n          routeMatch || getTargetMatch(matches, location),\n          requestContext,\n          dataStrategy,\n          skipLoaderErrorBubbling,\n          routeMatch != null\n        );\n        return result;\n      }\n\n      let result = await loadRouteData(\n        request,\n        matches,\n        requestContext,\n        dataStrategy,\n        skipLoaderErrorBubbling,\n        routeMatch\n      );\n      return isResponse(result)\n        ? result\n        : {\n            ...result,\n            actionData: null,\n            actionHeaders: {},\n          };\n    } catch (e) {\n      // If the user threw/returned a Response in callLoaderOrAction for a\n      // `queryRoute` call, we throw the `DataStrategyResult` to bail out early\n      // and then return or throw the raw Response here accordingly\n      if (isDataStrategyResult(e) && isResponse(e.result)) {\n        if (e.type === ResultType.error) {\n          throw e.result;\n        }\n        return e.result;\n      }\n      // Redirects are always returned since they don't propagate to catch\n      // boundaries\n      if (isRedirectResponse(e)) {\n        return e;\n      }\n      throw e;\n    }\n  }\n\n  async function submit(\n    request: Request,\n    matches: AgnosticDataRouteMatch[],\n    actionMatch: AgnosticDataRouteMatch,\n    requestContext: unknown,\n    dataStrategy: DataStrategyFunction | null,\n    skipLoaderErrorBubbling: boolean,\n    isRouteRequest: boolean\n  ): Promise<Omit<StaticHandlerContext, \"location\" | \"basename\"> | Response> {\n    let result: DataResult;\n\n    if (!actionMatch.route.action && !actionMatch.route.lazy) {\n      let error = getInternalRouterError(405, {\n        method: request.method,\n        pathname: new URL(request.url).pathname,\n        routeId: actionMatch.route.id,\n      });\n      if (isRouteRequest) {\n        throw error;\n      }\n      result = {\n        type: ResultType.error,\n        error,\n      };\n    } else {\n      let results = await callDataStrategy(\n        \"action\",\n        request,\n        [actionMatch],\n        matches,\n        isRouteRequest,\n        requestContext,\n        dataStrategy\n      );\n      result = results[actionMatch.route.id];\n\n      if (request.signal.aborted) {\n        throwStaticHandlerAbortedError(request, isRouteRequest, future);\n      }\n    }\n\n    if (isRedirectResult(result)) {\n      // Uhhhh - this should never happen, we should always throw these from\n      // callLoaderOrAction, but the type narrowing here keeps TS happy and we\n      // can get back on the \"throw all redirect responses\" train here should\n      // this ever happen :/\n      throw new Response(null, {\n        status: result.response.status,\n        headers: {\n          Location: result.response.headers.get(\"Location\")!,\n        },\n      });\n    }\n\n    if (isDeferredResult(result)) {\n      let error = getInternalRouterError(400, { type: \"defer-action\" });\n      if (isRouteRequest) {\n        throw error;\n      }\n      result = {\n        type: ResultType.error,\n        error,\n      };\n    }\n\n    if (isRouteRequest) {\n      // Note: This should only be non-Response values if we get here, since\n      // isRouteRequest should throw any Response received in callLoaderOrAction\n      if (isErrorResult(result)) {\n        throw result.error;\n      }\n\n      return {\n        matches: [actionMatch],\n        loaderData: {},\n        actionData: { [actionMatch.route.id]: result.data },\n        errors: null,\n        // Note: statusCode + headers are unused here since queryRoute will\n        // return the raw Response or value\n        statusCode: 200,\n        loaderHeaders: {},\n        actionHeaders: {},\n        activeDeferreds: null,\n      };\n    }\n\n    // Create a GET request for the loaders\n    let loaderRequest = new Request(request.url, {\n      headers: request.headers,\n      redirect: request.redirect,\n      signal: request.signal,\n    });\n\n    if (isErrorResult(result)) {\n      // Store off the pending error - we use it to determine which loaders\n      // to call and will commit it when we complete the navigation\n      let boundaryMatch = skipLoaderErrorBubbling\n        ? actionMatch\n        : findNearestBoundary(matches, actionMatch.route.id);\n\n      let context = await loadRouteData(\n        loaderRequest,\n        matches,\n        requestContext,\n        dataStrategy,\n        skipLoaderErrorBubbling,\n        null,\n        [boundaryMatch.route.id, result]\n      );\n\n      // action status codes take precedence over loader status codes\n      return {\n        ...context,\n        statusCode: isRouteErrorResponse(result.error)\n          ? result.error.status\n          : result.statusCode != null\n          ? result.statusCode\n          : 500,\n        actionData: null,\n        actionHeaders: {\n          ...(result.headers ? { [actionMatch.route.id]: result.headers } : {}),\n        },\n      };\n    }\n\n    let context = await loadRouteData(\n      loaderRequest,\n      matches,\n      requestContext,\n      dataStrategy,\n      skipLoaderErrorBubbling,\n      null\n    );\n\n    return {\n      ...context,\n      actionData: {\n        [actionMatch.route.id]: result.data,\n      },\n      // action status codes take precedence over loader status codes\n      ...(result.statusCode ? { statusCode: result.statusCode } : {}),\n      actionHeaders: result.headers\n        ? { [actionMatch.route.id]: result.headers }\n        : {},\n    };\n  }\n\n  async function loadRouteData(\n    request: Request,\n    matches: AgnosticDataRouteMatch[],\n    requestContext: unknown,\n    dataStrategy: DataStrategyFunction | null,\n    skipLoaderErrorBubbling: boolean,\n    routeMatch: AgnosticDataRouteMatch | null,\n    pendingActionResult?: PendingActionResult\n  ): Promise<\n    | Omit<\n        StaticHandlerContext,\n        \"location\" | \"basename\" | \"actionData\" | \"actionHeaders\"\n      >\n    | Response\n  > {\n    let isRouteRequest = routeMatch != null;\n\n    // Short circuit if we have no loaders to run (queryRoute())\n    if (\n      isRouteRequest &&\n      !routeMatch?.route.loader &&\n      !routeMatch?.route.lazy\n    ) {\n      throw getInternalRouterError(400, {\n        method: request.method,\n        pathname: new URL(request.url).pathname,\n        routeId: routeMatch?.route.id,\n      });\n    }\n\n    let requestMatches = routeMatch\n      ? [routeMatch]\n      : pendingActionResult && isErrorResult(pendingActionResult[1])\n      ? getLoaderMatchesUntilBoundary(matches, pendingActionResult[0])\n      : matches;\n    let matchesToLoad = requestMatches.filter(\n      (m) => m.route.loader || m.route.lazy\n    );\n\n    // Short circuit if we have no loaders to run (query())\n    if (matchesToLoad.length === 0) {\n      return {\n        matches,\n        // Add a null for all matched routes for proper revalidation on the client\n        loaderData: matches.reduce(\n          (acc, m) => Object.assign(acc, { [m.route.id]: null }),\n          {}\n        ),\n        errors:\n          pendingActionResult && isErrorResult(pendingActionResult[1])\n            ? {\n                [pendingActionResult[0]]: pendingActionResult[1].error,\n              }\n            : null,\n        statusCode: 200,\n        loaderHeaders: {},\n        activeDeferreds: null,\n      };\n    }\n\n    let results = await callDataStrategy(\n      \"loader\",\n      request,\n      matchesToLoad,\n      matches,\n      isRouteRequest,\n      requestContext,\n      dataStrategy\n    );\n\n    if (request.signal.aborted) {\n      throwStaticHandlerAbortedError(request, isRouteRequest, future);\n    }\n\n    // Process and commit output from loaders\n    let activeDeferreds = new Map<string, DeferredData>();\n    let context = processRouteLoaderData(\n      matches,\n      results,\n      pendingActionResult,\n      activeDeferreds,\n      skipLoaderErrorBubbling\n    );\n\n    // Add a null for any non-loader matches for proper revalidation on the client\n    let executedLoaders = new Set<string>(\n      matchesToLoad.map((match) => match.route.id)\n    );\n    matches.forEach((match) => {\n      if (!executedLoaders.has(match.route.id)) {\n        context.loaderData[match.route.id] = null;\n      }\n    });\n\n    return {\n      ...context,\n      matches,\n      activeDeferreds:\n        activeDeferreds.size > 0\n          ? Object.fromEntries(activeDeferreds.entries())\n          : null,\n    };\n  }\n\n  // Utility wrapper for calling dataStrategy server-side without having to\n  // pass around the manifest, mapRouteProperties, etc.\n  async function callDataStrategy(\n    type: \"loader\" | \"action\",\n    request: Request,\n    matchesToLoad: AgnosticDataRouteMatch[],\n    matches: AgnosticDataRouteMatch[],\n    isRouteRequest: boolean,\n    requestContext: unknown,\n    dataStrategy: DataStrategyFunction | null\n  ): Promise<Record<string, DataResult>> {\n    let results = await callDataStrategyImpl(\n      dataStrategy || defaultDataStrategy,\n      type,\n      null,\n      request,\n      matchesToLoad,\n      matches,\n      null,\n      manifest,\n      mapRouteProperties,\n      requestContext\n    );\n\n    let dataResults: Record<string, DataResult> = {};\n    await Promise.all(\n      matches.map(async (match) => {\n        if (!(match.route.id in results)) {\n          return;\n        }\n        let result = results[match.route.id];\n        if (isRedirectDataStrategyResultResult(result)) {\n          let response = result.result as Response;\n          // Throw redirects and let the server handle them with an HTTP redirect\n          throw normalizeRelativeRoutingRedirectResponse(\n            response,\n            request,\n            match.route.id,\n            matches,\n            basename,\n            future.v7_relativeSplatPath\n          );\n        }\n        if (isResponse(result.result) && isRouteRequest) {\n          // For SSR single-route requests, we want to hand Responses back\n          // directly without unwrapping\n          throw result;\n        }\n\n        dataResults[match.route.id] =\n          await convertDataStrategyResultToDataResult(result);\n      })\n    );\n    return dataResults;\n  }\n\n  return {\n    dataRoutes,\n    query,\n    queryRoute,\n  };\n}\n\n//#endregion\n\n////////////////////////////////////////////////////////////////////////////////\n//#region Helpers\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * Given an existing StaticHandlerContext and an error thrown at render time,\n * provide an updated StaticHandlerContext suitable for a second SSR render\n */\nexport function getStaticContextFromError(\n  routes: AgnosticDataRouteObject[],\n  context: StaticHandlerContext,\n  error: any\n) {\n  let newContext: StaticHandlerContext = {\n    ...context,\n    statusCode: isRouteErrorResponse(error) ? error.status : 500,\n    errors: {\n      [context._deepestRenderedBoundaryId || routes[0].id]: error,\n    },\n  };\n  return newContext;\n}\n\nfunction throwStaticHandlerAbortedError(\n  request: Request,\n  isRouteRequest: boolean,\n  future: StaticHandlerFutureConfig\n) {\n  if (future.v7_throwAbortReason && request.signal.reason !== undefined) {\n    throw request.signal.reason;\n  }\n\n  let method = isRouteRequest ? \"queryRoute\" : \"query\";\n  throw new Error(`${method}() call aborted: ${request.method} ${request.url}`);\n}\n\nfunction isSubmissionNavigation(\n  opts: BaseNavigateOrFetchOptions\n): opts is SubmissionNavigateOptions {\n  return (\n    opts != null &&\n    ((\"formData\" in opts && opts.formData != null) ||\n      (\"body\" in opts && opts.body !== undefined))\n  );\n}\n\nfunction normalizeTo(\n  location: Path,\n  matches: AgnosticDataRouteMatch[],\n  basename: string,\n  prependBasename: boolean,\n  to: To | null,\n  v7_relativeSplatPath: boolean,\n  fromRouteId?: string,\n  relative?: RelativeRoutingType\n) {\n  let contextualMatches: AgnosticDataRouteMatch[];\n  let activeRouteMatch: AgnosticDataRouteMatch | undefined;\n  if (fromRouteId) {\n    // Grab matches up to the calling route so our route-relative logic is\n    // relative to the correct source route\n    contextualMatches = [];\n    for (let match of matches) {\n      contextualMatches.push(match);\n      if (match.route.id === fromRouteId) {\n        activeRouteMatch = match;\n        break;\n      }\n    }\n  } else {\n    contextualMatches = matches;\n    activeRouteMatch = matches[matches.length - 1];\n  }\n\n  // Resolve the relative path\n  let path = resolveTo(\n    to ? to : \".\",\n    getResolveToMatches(contextualMatches, v7_relativeSplatPath),\n    stripBasename(location.pathname, basename) || location.pathname,\n    relative === \"path\"\n  );\n\n  // When `to` is not specified we inherit search/hash from the current\n  // location, unlike when to=\".\" and we just inherit the path.\n  // See https://github.com/remix-run/remix/issues/927\n  if (to == null) {\n    path.search = location.search;\n    path.hash = location.hash;\n  }\n\n  // Account for `?index` params when routing to the current location\n  if ((to == null || to === \"\" || to === \".\") && activeRouteMatch) {\n    let nakedIndex = hasNakedIndexQuery(path.search);\n    if (activeRouteMatch.route.index && !nakedIndex) {\n      // Add one when we're targeting an index route\n      path.search = path.search\n        ? path.search.replace(/^\\?/, \"?index&\")\n        : \"?index\";\n    } else if (!activeRouteMatch.route.index && nakedIndex) {\n      // Remove existing ones when we're not\n      let params = new URLSearchParams(path.search);\n      let indexValues = params.getAll(\"index\");\n      params.delete(\"index\");\n      indexValues.filter((v) => v).forEach((v) => params.append(\"index\", v));\n      let qs = params.toString();\n      path.search = qs ? `?${qs}` : \"\";\n    }\n  }\n\n  // If we're operating within a basename, prepend it to the pathname.  If\n  // this is a root navigation, then just use the raw basename which allows\n  // the basename to have full control over the presence of a trailing slash\n  // on root actions\n  if (prependBasename && basename !== \"/\") {\n    path.pathname =\n      path.pathname === \"/\" ? basename : joinPaths([basename, path.pathname]);\n  }\n\n  return createPath(path);\n}\n\n// Normalize navigation options by converting formMethod=GET formData objects to\n// URLSearchParams so they behave identically to links with query params\nfunction normalizeNavigateOptions(\n  normalizeFormMethod: boolean,\n  isFetcher: boolean,\n  path: string,\n  opts?: BaseNavigateOrFetchOptions\n): {\n  path: string;\n  submission?: Submission;\n  error?: ErrorResponseImpl;\n} {\n  // Return location verbatim on non-submission navigations\n  if (!opts || !isSubmissionNavigation(opts)) {\n    return { path };\n  }\n\n  if (opts.formMethod && !isValidMethod(opts.formMethod)) {\n    return {\n      path,\n      error: getInternalRouterError(405, { method: opts.formMethod }),\n    };\n  }\n\n  let getInvalidBodyError = () => ({\n    path,\n    error: getInternalRouterError(400, { type: \"invalid-body\" }),\n  });\n\n  // Create a Submission on non-GET navigations\n  let rawFormMethod = opts.formMethod || \"get\";\n  let formMethod = normalizeFormMethod\n    ? (rawFormMethod.toUpperCase() as V7_FormMethod)\n    : (rawFormMethod.toLowerCase() as FormMethod);\n  let formAction = stripHashFromPath(path);\n\n  if (opts.body !== undefined) {\n    if (opts.formEncType === \"text/plain\") {\n      // text only support POST/PUT/PATCH/DELETE submissions\n      if (!isMutationMethod(formMethod)) {\n        return getInvalidBodyError();\n      }\n\n      let text =\n        typeof opts.body === \"string\"\n          ? opts.body\n          : opts.body instanceof FormData ||\n            opts.body instanceof URLSearchParams\n          ? // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#plain-text-form-data\n            Array.from(opts.body.entries()).reduce(\n              (acc, [name, value]) => `${acc}${name}=${value}\\n`,\n              \"\"\n            )\n          : String(opts.body);\n\n      return {\n        path,\n        submission: {\n          formMethod,\n          formAction,\n          formEncType: opts.formEncType,\n          formData: undefined,\n          json: undefined,\n          text,\n        },\n      };\n    } else if (opts.formEncType === \"application/json\") {\n      // json only supports POST/PUT/PATCH/DELETE submissions\n      if (!isMutationMethod(formMethod)) {\n        return getInvalidBodyError();\n      }\n\n      try {\n        let json =\n          typeof opts.body === \"string\" ? JSON.parse(opts.body) : opts.body;\n\n        return {\n          path,\n          submission: {\n            formMethod,\n            formAction,\n            formEncType: opts.formEncType,\n            formData: undefined,\n            json,\n            text: undefined,\n          },\n        };\n      } catch (e) {\n        return getInvalidBodyError();\n      }\n    }\n  }\n\n  invariant(\n    typeof FormData === \"function\",\n    \"FormData is not available in this environment\"\n  );\n\n  let searchParams: URLSearchParams;\n  let formData: FormData;\n\n  if (opts.formData) {\n    searchParams = convertFormDataToSearchParams(opts.formData);\n    formData = opts.formData;\n  } else if (opts.body instanceof FormData) {\n    searchParams = convertFormDataToSearchParams(opts.body);\n    formData = opts.body;\n  } else if (opts.body instanceof URLSearchParams) {\n    searchParams = opts.body;\n    formData = convertSearchParamsToFormData(searchParams);\n  } else if (opts.body == null) {\n    searchParams = new URLSearchParams();\n    formData = new FormData();\n  } else {\n    try {\n      searchParams = new URLSearchParams(opts.body);\n      formData = convertSearchParamsToFormData(searchParams);\n    } catch (e) {\n      return getInvalidBodyError();\n    }\n  }\n\n  let submission: Submission = {\n    formMethod,\n    formAction,\n    formEncType:\n      (opts && opts.formEncType) || \"application/x-www-form-urlencoded\",\n    formData,\n    json: undefined,\n    text: undefined,\n  };\n\n  if (isMutationMethod(submission.formMethod)) {\n    return { path, submission };\n  }\n\n  // Flatten submission onto URLSearchParams for GET submissions\n  let parsedPath = parsePath(path);\n  // On GET navigation submissions we can drop the ?index param from the\n  // resulting location since all loaders will run.  But fetcher GET submissions\n  // only run a single loader so we need to preserve any incoming ?index params\n  if (isFetcher && parsedPath.search && hasNakedIndexQuery(parsedPath.search)) {\n    searchParams.append(\"index\", \"\");\n  }\n  parsedPath.search = `?${searchParams}`;\n\n  return { path: createPath(parsedPath), submission };\n}\n\n// Filter out all routes at/below any caught error as they aren't going to\n// render so we don't need to load them\nfunction getLoaderMatchesUntilBoundary(\n  matches: AgnosticDataRouteMatch[],\n  boundaryId: string,\n  includeBoundary = false\n) {\n  let index = matches.findIndex((m) => m.route.id === boundaryId);\n  if (index >= 0) {\n    return matches.slice(0, includeBoundary ? index + 1 : index);\n  }\n  return matches;\n}\n\nfunction getMatchesToLoad(\n  history: History,\n  state: RouterState,\n  matches: AgnosticDataRouteMatch[],\n  submission: Submission | undefined,\n  location: Location,\n  initialHydration: boolean,\n  skipActionErrorRevalidation: boolean,\n  isRevalidationRequired: boolean,\n  cancelledDeferredRoutes: string[],\n  cancelledFetcherLoads: Set<string>,\n  deletedFetchers: Set<string>,\n  fetchLoadMatches: Map<string, FetchLoadMatch>,\n  fetchRedirectIds: Set<string>,\n  routesToUse: AgnosticDataRouteObject[],\n  basename: string | undefined,\n  pendingActionResult?: PendingActionResult\n): [AgnosticDataRouteMatch[], RevalidatingFetcher[]] {\n  let actionResult = pendingActionResult\n    ? isErrorResult(pendingActionResult[1])\n      ? pendingActionResult[1].error\n      : pendingActionResult[1].data\n    : undefined;\n  let currentUrl = history.createURL(state.location);\n  let nextUrl = history.createURL(location);\n\n  // Pick navigation matches that are net-new or qualify for revalidation\n  let boundaryMatches = matches;\n  if (initialHydration && state.errors) {\n    // On initial hydration, only consider matches up to _and including_ the boundary.\n    // This is inclusive to handle cases where a server loader ran successfully,\n    // a child server loader bubbled up to this route, but this route has\n    // `clientLoader.hydrate` so we want to still run the `clientLoader` so that\n    // we have a complete version of `loaderData`\n    boundaryMatches = getLoaderMatchesUntilBoundary(\n      matches,\n      Object.keys(state.errors)[0],\n      true\n    );\n  } else if (pendingActionResult && isErrorResult(pendingActionResult[1])) {\n    // If an action threw an error, we call loaders up to, but not including the\n    // boundary\n    boundaryMatches = getLoaderMatchesUntilBoundary(\n      matches,\n      pendingActionResult[0]\n    );\n  }\n\n  // Don't revalidate loaders by default after action 4xx/5xx responses\n  // when the flag is enabled.  They can still opt-into revalidation via\n  // `shouldRevalidate` via `actionResult`\n  let actionStatus = pendingActionResult\n    ? pendingActionResult[1].statusCode\n    : undefined;\n  let shouldSkipRevalidation =\n    skipActionErrorRevalidation && actionStatus && actionStatus >= 400;\n\n  let navigationMatches = boundaryMatches.filter((match, index) => {\n    let { route } = match;\n    if (route.lazy) {\n      // We haven't loaded this route yet so we don't know if it's got a loader!\n      return true;\n    }\n\n    if (route.loader == null) {\n      return false;\n    }\n\n    if (initialHydration) {\n      return shouldLoadRouteOnHydration(route, state.loaderData, state.errors);\n    }\n\n    // Always call the loader on new route instances and pending defer cancellations\n    if (\n      isNewLoader(state.loaderData, state.matches[index], match) ||\n      cancelledDeferredRoutes.some((id) => id === match.route.id)\n    ) {\n      return true;\n    }\n\n    // This is the default implementation for when we revalidate.  If the route\n    // provides it's own implementation, then we give them full control but\n    // provide this value so they can leverage it if needed after they check\n    // their own specific use cases\n    let currentRouteMatch = state.matches[index];\n    let nextRouteMatch = match;\n\n    return shouldRevalidateLoader(match, {\n      currentUrl,\n      currentParams: currentRouteMatch.params,\n      nextUrl,\n      nextParams: nextRouteMatch.params,\n      ...submission,\n      actionResult,\n      actionStatus,\n      defaultShouldRevalidate: shouldSkipRevalidation\n        ? false\n        : // Forced revalidation due to submission, useRevalidator, or X-Remix-Revalidate\n          isRevalidationRequired ||\n          currentUrl.pathname + currentUrl.search ===\n            nextUrl.pathname + nextUrl.search ||\n          // Search params affect all loaders\n          currentUrl.search !== nextUrl.search ||\n          isNewRouteInstance(currentRouteMatch, nextRouteMatch),\n    });\n  });\n\n  // Pick fetcher.loads that need to be revalidated\n  let revalidatingFetchers: RevalidatingFetcher[] = [];\n  fetchLoadMatches.forEach((f, key) => {\n    // Don't revalidate:\n    //  - on initial hydration (shouldn't be any fetchers then anyway)\n    //  - if fetcher won't be present in the subsequent render\n    //    - no longer matches the URL (v7_fetcherPersist=false)\n    //    - was unmounted but persisted due to v7_fetcherPersist=true\n    if (\n      initialHydration ||\n      !matches.some((m) => m.route.id === f.routeId) ||\n      deletedFetchers.has(key)\n    ) {\n      return;\n    }\n\n    let fetcherMatches = matchRoutes(routesToUse, f.path, basename);\n\n    // If the fetcher path no longer matches, push it in with null matches so\n    // we can trigger a 404 in callLoadersAndMaybeResolveData.  Note this is\n    // currently only a use-case for Remix HMR where the route tree can change\n    // at runtime and remove a route previously loaded via a fetcher\n    if (!fetcherMatches) {\n      revalidatingFetchers.push({\n        key,\n        routeId: f.routeId,\n        path: f.path,\n        matches: null,\n        match: null,\n        controller: null,\n      });\n      return;\n    }\n\n    // Revalidating fetchers are decoupled from the route matches since they\n    // load from a static href.  They revalidate based on explicit revalidation\n    // (submission, useRevalidator, or X-Remix-Revalidate)\n    let fetcher = state.fetchers.get(key);\n    let fetcherMatch = getTargetMatch(fetcherMatches, f.path);\n\n    let shouldRevalidate = false;\n    if (fetchRedirectIds.has(key)) {\n      // Never trigger a revalidation of an actively redirecting fetcher\n      shouldRevalidate = false;\n    } else if (cancelledFetcherLoads.has(key)) {\n      // Always mark for revalidation if the fetcher was cancelled\n      cancelledFetcherLoads.delete(key);\n      shouldRevalidate = true;\n    } else if (\n      fetcher &&\n      fetcher.state !== \"idle\" &&\n      fetcher.data === undefined\n    ) {\n      // If the fetcher hasn't ever completed loading yet, then this isn't a\n      // revalidation, it would just be a brand new load if an explicit\n      // revalidation is required\n      shouldRevalidate = isRevalidationRequired;\n    } else {\n      // Otherwise fall back on any user-defined shouldRevalidate, defaulting\n      // to explicit revalidations only\n      shouldRevalidate = shouldRevalidateLoader(fetcherMatch, {\n        currentUrl,\n        currentParams: state.matches[state.matches.length - 1].params,\n        nextUrl,\n        nextParams: matches[matches.length - 1].params,\n        ...submission,\n        actionResult,\n        actionStatus,\n        defaultShouldRevalidate: shouldSkipRevalidation\n          ? false\n          : isRevalidationRequired,\n      });\n    }\n\n    if (shouldRevalidate) {\n      revalidatingFetchers.push({\n        key,\n        routeId: f.routeId,\n        path: f.path,\n        matches: fetcherMatches,\n        match: fetcherMatch,\n        controller: new AbortController(),\n      });\n    }\n  });\n\n  return [navigationMatches, revalidatingFetchers];\n}\n\nfunction shouldLoadRouteOnHydration(\n  route: AgnosticDataRouteObject,\n  loaderData: RouteData | null | undefined,\n  errors: RouteData | null | undefined\n) {\n  // We dunno if we have a loader - gotta find out!\n  if (route.lazy) {\n    return true;\n  }\n\n  // No loader, nothing to initialize\n  if (!route.loader) {\n    return false;\n  }\n\n  let hasData = loaderData != null && loaderData[route.id] !== undefined;\n  let hasError = errors != null && errors[route.id] !== undefined;\n\n  // Don't run if we error'd during SSR\n  if (!hasData && hasError) {\n    return false;\n  }\n\n  // Explicitly opting-in to running on hydration\n  if (typeof route.loader === \"function\" && route.loader.hydrate === true) {\n    return true;\n  }\n\n  // Otherwise, run if we're not yet initialized with anything\n  return !hasData && !hasError;\n}\n\nfunction isNewLoader(\n  currentLoaderData: RouteData,\n  currentMatch: AgnosticDataRouteMatch,\n  match: AgnosticDataRouteMatch\n) {\n  let isNew =\n    // [a] -> [a, b]\n    !currentMatch ||\n    // [a, b] -> [a, c]\n    match.route.id !== currentMatch.route.id;\n\n  // Handle the case that we don't have data for a re-used route, potentially\n  // from a prior error or from a cancelled pending deferred\n  let isMissingData = currentLoaderData[match.route.id] === undefined;\n\n  // Always load if this is a net-new route or we don't yet have data\n  return isNew || isMissingData;\n}\n\nfunction isNewRouteInstance(\n  currentMatch: AgnosticDataRouteMatch,\n  match: AgnosticDataRouteMatch\n) {\n  let currentPath = currentMatch.route.path;\n  return (\n    // param change for this match, /users/123 -> /users/456\n    currentMatch.pathname !== match.pathname ||\n    // splat param changed, which is not present in match.path\n    // e.g. /files/images/avatar.jpg -> files/finances.xls\n    (currentPath != null &&\n      currentPath.endsWith(\"*\") &&\n      currentMatch.params[\"*\"] !== match.params[\"*\"])\n  );\n}\n\nfunction shouldRevalidateLoader(\n  loaderMatch: AgnosticDataRouteMatch,\n  arg: ShouldRevalidateFunctionArgs\n) {\n  if (loaderMatch.route.shouldRevalidate) {\n    let routeChoice = loaderMatch.route.shouldRevalidate(arg);\n    if (typeof routeChoice === \"boolean\") {\n      return routeChoice;\n    }\n  }\n\n  return arg.defaultShouldRevalidate;\n}\n\nfunction patchRoutesImpl(\n  routeId: string | null,\n  children: AgnosticRouteObject[],\n  routesToUse: AgnosticDataRouteObject[],\n  manifest: RouteManifest,\n  mapRouteProperties: MapRoutePropertiesFunction\n) {\n  let childrenToPatch: AgnosticDataRouteObject[];\n  if (routeId) {\n    let route = manifest[routeId];\n    invariant(\n      route,\n      `No route found to patch children into: routeId = ${routeId}`\n    );\n    if (!route.children) {\n      route.children = [];\n    }\n    childrenToPatch = route.children;\n  } else {\n    childrenToPatch = routesToUse;\n  }\n\n  // Don't patch in routes we already know about so that `patch` is idempotent\n  // to simplify user-land code. This is useful because we re-call the\n  // `patchRoutesOnNavigation` function for matched routes with params.\n  let uniqueChildren = children.filter(\n    (newRoute) =>\n      !childrenToPatch.some((existingRoute) =>\n        isSameRoute(newRoute, existingRoute)\n      )\n  );\n\n  let newRoutes = convertRoutesToDataRoutes(\n    uniqueChildren,\n    mapRouteProperties,\n    [routeId || \"_\", \"patch\", String(childrenToPatch?.length || \"0\")],\n    manifest\n  );\n\n  childrenToPatch.push(...newRoutes);\n}\n\nfunction isSameRoute(\n  newRoute: AgnosticRouteObject,\n  existingRoute: AgnosticRouteObject\n): boolean {\n  // Most optimal check is by id\n  if (\n    \"id\" in newRoute &&\n    \"id\" in existingRoute &&\n    newRoute.id === existingRoute.id\n  ) {\n    return true;\n  }\n\n  // Second is by pathing differences\n  if (\n    !(\n      newRoute.index === existingRoute.index &&\n      newRoute.path === existingRoute.path &&\n      newRoute.caseSensitive === existingRoute.caseSensitive\n    )\n  ) {\n    return false;\n  }\n\n  // Pathless layout routes are trickier since we need to check children.\n  // If they have no children then they're the same as far as we can tell\n  if (\n    (!newRoute.children || newRoute.children.length === 0) &&\n    (!existingRoute.children || existingRoute.children.length === 0)\n  ) {\n    return true;\n  }\n\n  // Otherwise, we look to see if every child in the new route is already\n  // represented in the existing route's children\n  return newRoute.children!.every((aChild, i) =>\n    existingRoute.children?.some((bChild) => isSameRoute(aChild, bChild))\n  );\n}\n\n/**\n * Execute route.lazy() methods to lazily load route modules (loader, action,\n * shouldRevalidate) and update the routeManifest in place which shares objects\n * with dataRoutes so those get updated as well.\n */\nasync function loadLazyRouteModule(\n  route: AgnosticDataRouteObject,\n  mapRouteProperties: MapRoutePropertiesFunction,\n  manifest: RouteManifest\n) {\n  if (!route.lazy) {\n    return;\n  }\n\n  let lazyRoute = await route.lazy();\n\n  // If the lazy route function was executed and removed by another parallel\n  // call then we can return - first lazy() to finish wins because the return\n  // value of lazy is expected to be static\n  if (!route.lazy) {\n    return;\n  }\n\n  let routeToUpdate = manifest[route.id];\n  invariant(routeToUpdate, \"No route found in manifest\");\n\n  // Update the route in place.  This should be safe because there's no way\n  // we could yet be sitting on this route as we can't get there without\n  // resolving lazy() first.\n  //\n  // This is different than the HMR \"update\" use-case where we may actively be\n  // on the route being updated.  The main concern boils down to \"does this\n  // mutation affect any ongoing navigations or any current state.matches\n  // values?\".  If not, it should be safe to update in place.\n  let routeUpdates: Record<string, any> = {};\n  for (let lazyRouteProperty in lazyRoute) {\n    let staticRouteValue =\n      routeToUpdate[lazyRouteProperty as keyof typeof routeToUpdate];\n\n    let isPropertyStaticallyDefined =\n      staticRouteValue !== undefined &&\n      // This property isn't static since it should always be updated based\n      // on the route updates\n      lazyRouteProperty !== \"hasErrorBoundary\";\n\n    warning(\n      !isPropertyStaticallyDefined,\n      `Route \"${routeToUpdate.id}\" has a static property \"${lazyRouteProperty}\" ` +\n        `defined but its lazy function is also returning a value for this property. ` +\n        `The lazy route property \"${lazyRouteProperty}\" will be ignored.`\n    );\n\n    if (\n      !isPropertyStaticallyDefined &&\n      !immutableRouteKeys.has(lazyRouteProperty as ImmutableRouteKey)\n    ) {\n      routeUpdates[lazyRouteProperty] =\n        lazyRoute[lazyRouteProperty as keyof typeof lazyRoute];\n    }\n  }\n\n  // Mutate the route with the provided updates.  Do this first so we pass\n  // the updated version to mapRouteProperties\n  Object.assign(routeToUpdate, routeUpdates);\n\n  // Mutate the `hasErrorBoundary` property on the route based on the route\n  // updates and remove the `lazy` function so we don't resolve the lazy\n  // route again.\n  Object.assign(routeToUpdate, {\n    // To keep things framework agnostic, we use the provided\n    // `mapRouteProperties` (or wrapped `detectErrorBoundary`) function to\n    // set the framework-aware properties (`element`/`hasErrorBoundary`) since\n    // the logic will differ between frameworks.\n    ...mapRouteProperties(routeToUpdate),\n    lazy: undefined,\n  });\n}\n\n// Default implementation of `dataStrategy` which fetches all loaders in parallel\nasync function defaultDataStrategy({\n  matches,\n}: DataStrategyFunctionArgs): ReturnType<DataStrategyFunction> {\n  let matchesToLoad = matches.filter((m) => m.shouldLoad);\n  let results = await Promise.all(matchesToLoad.map((m) => m.resolve()));\n  return results.reduce(\n    (acc, result, i) =>\n      Object.assign(acc, { [matchesToLoad[i].route.id]: result }),\n    {}\n  );\n}\n\nasync function callDataStrategyImpl(\n  dataStrategyImpl: DataStrategyFunction,\n  type: \"loader\" | \"action\",\n  state: RouterState | null,\n  request: Request,\n  matchesToLoad: AgnosticDataRouteMatch[],\n  matches: AgnosticDataRouteMatch[],\n  fetcherKey: string | null,\n  manifest: RouteManifest,\n  mapRouteProperties: MapRoutePropertiesFunction,\n  requestContext?: unknown\n): Promise<Record<string, DataStrategyResult>> {\n  let loadRouteDefinitionsPromises = matches.map((m) =>\n    m.route.lazy\n      ? loadLazyRouteModule(m.route, mapRouteProperties, manifest)\n      : undefined\n  );\n\n  let dsMatches = matches.map((match, i) => {\n    let loadRoutePromise = loadRouteDefinitionsPromises[i];\n    let shouldLoad = matchesToLoad.some((m) => m.route.id === match.route.id);\n    // `resolve` encapsulates route.lazy(), executing the loader/action,\n    // and mapping return values/thrown errors to a `DataStrategyResult`.  Users\n    // can pass a callback to take fine-grained control over the execution\n    // of the loader/action\n    let resolve: DataStrategyMatch[\"resolve\"] = async (handlerOverride) => {\n      if (\n        handlerOverride &&\n        request.method === \"GET\" &&\n        (match.route.lazy || match.route.loader)\n      ) {\n        shouldLoad = true;\n      }\n      return shouldLoad\n        ? callLoaderOrAction(\n            type,\n            request,\n            match,\n            loadRoutePromise,\n            handlerOverride,\n            requestContext\n          )\n        : Promise.resolve({ type: ResultType.data, result: undefined });\n    };\n\n    return {\n      ...match,\n      shouldLoad,\n      resolve,\n    };\n  });\n\n  // Send all matches here to allow for a middleware-type implementation.\n  // handler will be a no-op for unneeded routes and we filter those results\n  // back out below.\n  let results = await dataStrategyImpl({\n    matches: dsMatches,\n    request,\n    params: matches[0].params,\n    fetcherKey,\n    context: requestContext,\n  });\n\n  // Wait for all routes to load here but 'swallow the error since we want\n  // it to bubble up from the `await loadRoutePromise` in `callLoaderOrAction` -\n  // called from `match.resolve()`\n  try {\n    await Promise.all(loadRouteDefinitionsPromises);\n  } catch (e) {\n    // No-op\n  }\n\n  return results;\n}\n\n// Default logic for calling a loader/action is the user has no specified a dataStrategy\nasync function callLoaderOrAction(\n  type: \"loader\" | \"action\",\n  request: Request,\n  match: AgnosticDataRouteMatch,\n  loadRoutePromise: Promise<void> | undefined,\n  handlerOverride: Parameters<DataStrategyMatch[\"resolve\"]>[0],\n  staticContext?: unknown\n): Promise<DataStrategyResult> {\n  let result: DataStrategyResult;\n  let onReject: (() => void) | undefined;\n\n  let runHandler = (\n    handler: AgnosticRouteObject[\"loader\"] | AgnosticRouteObject[\"action\"]\n  ): Promise<DataStrategyResult> => {\n    // Setup a promise we can race against so that abort signals short circuit\n    let reject: () => void;\n    // This will never resolve so safe to type it as Promise<DataStrategyResult> to\n    // satisfy the function return value\n    let abortPromise = new Promise<DataStrategyResult>((_, r) => (reject = r));\n    onReject = () => reject();\n    request.signal.addEventListener(\"abort\", onReject);\n\n    let actualHandler = (ctx?: unknown) => {\n      if (typeof handler !== \"function\") {\n        return Promise.reject(\n          new Error(\n            `You cannot call the handler for a route which defines a boolean ` +\n              `\"${type}\" [routeId: ${match.route.id}]`\n          )\n        );\n      }\n      return handler(\n        {\n          request,\n          params: match.params,\n          context: staticContext,\n        },\n        ...(ctx !== undefined ? [ctx] : [])\n      );\n    };\n\n    let handlerPromise: Promise<DataStrategyResult> = (async () => {\n      try {\n        let val = await (handlerOverride\n          ? handlerOverride((ctx: unknown) => actualHandler(ctx))\n          : actualHandler());\n        return { type: \"data\", result: val };\n      } catch (e) {\n        return { type: \"error\", result: e };\n      }\n    })();\n\n    return Promise.race([handlerPromise, abortPromise]);\n  };\n\n  try {\n    let handler = match.route[type];\n\n    // If we have a route.lazy promise, await that first\n    if (loadRoutePromise) {\n      if (handler) {\n        // Run statically defined handler in parallel with lazy()\n        let handlerError;\n        let [value] = await Promise.all([\n          // If the handler throws, don't let it immediately bubble out,\n          // since we need to let the lazy() execution finish so we know if this\n          // route has a boundary that can handle the error\n          runHandler(handler).catch((e) => {\n            handlerError = e;\n          }),\n          loadRoutePromise,\n        ]);\n        if (handlerError !== undefined) {\n          throw handlerError;\n        }\n        result = value!;\n      } else {\n        // Load lazy route module, then run any returned handler\n        await loadRoutePromise;\n\n        handler = match.route[type];\n        if (handler) {\n          // Handler still runs even if we got interrupted to maintain consistency\n          // with un-abortable behavior of handler execution on non-lazy or\n          // previously-lazy-loaded routes\n          result = await runHandler(handler);\n        } else if (type === \"action\") {\n          let url = new URL(request.url);\n          let pathname = url.pathname + url.search;\n          throw getInternalRouterError(405, {\n            method: request.method,\n            pathname,\n            routeId: match.route.id,\n          });\n        } else {\n          // lazy() route has no loader to run.  Short circuit here so we don't\n          // hit the invariant below that errors on returning undefined.\n          return { type: ResultType.data, result: undefined };\n        }\n      }\n    } else if (!handler) {\n      let url = new URL(request.url);\n      let pathname = url.pathname + url.search;\n      throw getInternalRouterError(404, {\n        pathname,\n      });\n    } else {\n      result = await runHandler(handler);\n    }\n\n    invariant(\n      result.result !== undefined,\n      `You defined ${type === \"action\" ? \"an action\" : \"a loader\"} for route ` +\n        `\"${match.route.id}\" but didn't return anything from your \\`${type}\\` ` +\n        `function. Please return a value or \\`null\\`.`\n    );\n  } catch (e) {\n    // We should already be catching and converting normal handler executions to\n    // DataStrategyResults and returning them, so anything that throws here is an\n    // unexpected error we still need to wrap\n    return { type: ResultType.error, result: e };\n  } finally {\n    if (onReject) {\n      request.signal.removeEventListener(\"abort\", onReject);\n    }\n  }\n\n  return result;\n}\n\nasync function convertDataStrategyResultToDataResult(\n  dataStrategyResult: DataStrategyResult\n): Promise<DataResult> {\n  let { result, type } = dataStrategyResult;\n\n  if (isResponse(result)) {\n    let data: any;\n\n    try {\n      let contentType = result.headers.get(\"Content-Type\");\n      // Check between word boundaries instead of startsWith() due to the last\n      // paragraph of https://httpwg.org/specs/rfc9110.html#field.content-type\n      if (contentType && /\\bapplication\\/json\\b/.test(contentType)) {\n        if (result.body == null) {\n          data = null;\n        } else {\n          data = await result.json();\n        }\n      } else {\n        data = await result.text();\n      }\n    } catch (e) {\n      return { type: ResultType.error, error: e };\n    }\n\n    if (type === ResultType.error) {\n      return {\n        type: ResultType.error,\n        error: new ErrorResponseImpl(result.status, result.statusText, data),\n        statusCode: result.status,\n        headers: result.headers,\n      };\n    }\n\n    return {\n      type: ResultType.data,\n      data,\n      statusCode: result.status,\n      headers: result.headers,\n    };\n  }\n\n  if (type === ResultType.error) {\n    if (isDataWithResponseInit(result)) {\n      if (result.data instanceof Error) {\n        return {\n          type: ResultType.error,\n          error: result.data,\n          statusCode: result.init?.status,\n          headers: result.init?.headers\n            ? new Headers(result.init.headers)\n            : undefined,\n        };\n      }\n\n      // Convert thrown data() to ErrorResponse instances\n      return {\n        type: ResultType.error,\n        error: new ErrorResponseImpl(\n          result.init?.status || 500,\n          undefined,\n          result.data\n        ),\n        statusCode: isRouteErrorResponse(result) ? result.status : undefined,\n        headers: result.init?.headers\n          ? new Headers(result.init.headers)\n          : undefined,\n      };\n    }\n    return {\n      type: ResultType.error,\n      error: result,\n      statusCode: isRouteErrorResponse(result) ? result.status : undefined,\n    };\n  }\n\n  if (isDeferredData(result)) {\n    return {\n      type: ResultType.deferred,\n      deferredData: result,\n      statusCode: result.init?.status,\n      headers: result.init?.headers && new Headers(result.init.headers),\n    };\n  }\n\n  if (isDataWithResponseInit(result)) {\n    return {\n      type: ResultType.data,\n      data: result.data,\n      statusCode: result.init?.status,\n      headers: result.init?.headers\n        ? new Headers(result.init.headers)\n        : undefined,\n    };\n  }\n\n  return { type: ResultType.data, data: result };\n}\n\n// Support relative routing in internal redirects\nfunction normalizeRelativeRoutingRedirectResponse(\n  response: Response,\n  request: Request,\n  routeId: string,\n  matches: AgnosticDataRouteMatch[],\n  basename: string,\n  v7_relativeSplatPath: boolean\n) {\n  let location = response.headers.get(\"Location\");\n  invariant(\n    location,\n    \"Redirects returned/thrown from loaders/actions must have a Location header\"\n  );\n\n  if (!ABSOLUTE_URL_REGEX.test(location)) {\n    let trimmedMatches = matches.slice(\n      0,\n      matches.findIndex((m) => m.route.id === routeId) + 1\n    );\n    location = normalizeTo(\n      new URL(request.url),\n      trimmedMatches,\n      basename,\n      true,\n      location,\n      v7_relativeSplatPath\n    );\n    response.headers.set(\"Location\", location);\n  }\n\n  return response;\n}\n\nfunction normalizeRedirectLocation(\n  location: string,\n  currentUrl: URL,\n  basename: string,\n  historyInstance: History,\n): string {\n  // Match Chrome's behavior:\n  // https://github.com/chromium/chromium/blob/216dbeb61db0c667e62082e5f5400a32d6983df3/content/public/common/url_utils.cc#L82\n  let invalidProtocols = [\n    \"about:\",\n    \"blob:\",\n    \"chrome:\",\n    \"chrome-untrusted:\",\n    \"content:\",\n    \"data:\",\n    \"devtools:\",\n    \"file:\",\n    \"filesystem:\",\n    // eslint-disable-next-line no-script-url\n    \"javascript:\",\n  ];\n\n  if (ABSOLUTE_URL_REGEX.test(location)) {\n    // Strip off the protocol+origin for same-origin + same-basename absolute redirects\n    let normalizedLocation = location;\n    let url = normalizedLocation.startsWith(\"//\")\n      ? new URL(currentUrl.protocol + normalizedLocation)\n      : new URL(normalizedLocation);\n    if (invalidProtocols.includes(url.protocol)) {\n      throw new Error(\"Invalid redirect location\");\n    }\n    let isSameBasename = stripBasename(url.pathname, basename) != null;\n    if (url.origin === currentUrl.origin && isSameBasename) {\n      return url.pathname + url.search + url.hash;\n    }\n  }\n\n  try {\n    let url = historyInstance.createURL(location);\n    if (invalidProtocols.includes(url.protocol)) {\n      throw new Error(\"Invalid redirect location\");\n    }\n  } catch (e) {}\n\n  return location;\n}\n\n// Utility method for creating the Request instances for loaders/actions during\n// client-side navigations and fetches.  During SSR we will always have a\n// Request instance from the static handler (query/queryRoute)\nfunction createClientSideRequest(\n  history: History,\n  location: string | Location,\n  signal: AbortSignal,\n  submission?: Submission\n): Request {\n  let url = history.createURL(stripHashFromPath(location)).toString();\n  let init: RequestInit = { signal };\n\n  if (submission && isMutationMethod(submission.formMethod)) {\n    let { formMethod, formEncType } = submission;\n    // Didn't think we needed this but it turns out unlike other methods, patch\n    // won't be properly normalized to uppercase and results in a 405 error.\n    // See: https://fetch.spec.whatwg.org/#concept-method\n    init.method = formMethod.toUpperCase();\n\n    if (formEncType === \"application/json\") {\n      init.headers = new Headers({ \"Content-Type\": formEncType });\n      init.body = JSON.stringify(submission.json);\n    } else if (formEncType === \"text/plain\") {\n      // Content-Type is inferred (https://fetch.spec.whatwg.org/#dom-request)\n      init.body = submission.text;\n    } else if (\n      formEncType === \"application/x-www-form-urlencoded\" &&\n      submission.formData\n    ) {\n      // Content-Type is inferred (https://fetch.spec.whatwg.org/#dom-request)\n      init.body = convertFormDataToSearchParams(submission.formData);\n    } else {\n      // Content-Type is inferred (https://fetch.spec.whatwg.org/#dom-request)\n      init.body = submission.formData;\n    }\n  }\n\n  return new Request(url, init);\n}\n\nfunction convertFormDataToSearchParams(formData: FormData): URLSearchParams {\n  let searchParams = new URLSearchParams();\n\n  for (let [key, value] of formData.entries()) {\n    // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#converting-an-entry-list-to-a-list-of-name-value-pairs\n    searchParams.append(key, typeof value === \"string\" ? value : value.name);\n  }\n\n  return searchParams;\n}\n\nfunction convertSearchParamsToFormData(\n  searchParams: URLSearchParams\n): FormData {\n  let formData = new FormData();\n  for (let [key, value] of searchParams.entries()) {\n    formData.append(key, value);\n  }\n  return formData;\n}\n\nfunction processRouteLoaderData(\n  matches: AgnosticDataRouteMatch[],\n  results: Record<string, DataResult>,\n  pendingActionResult: PendingActionResult | undefined,\n  activeDeferreds: Map<string, DeferredData>,\n  skipLoaderErrorBubbling: boolean\n): {\n  loaderData: RouterState[\"loaderData\"];\n  errors: RouterState[\"errors\"] | null;\n  statusCode: number;\n  loaderHeaders: Record<string, Headers>;\n} {\n  // Fill in loaderData/errors from our loaders\n  let loaderData: RouterState[\"loaderData\"] = {};\n  let errors: RouterState[\"errors\"] | null = null;\n  let statusCode: number | undefined;\n  let foundError = false;\n  let loaderHeaders: Record<string, Headers> = {};\n  let pendingError =\n    pendingActionResult && isErrorResult(pendingActionResult[1])\n      ? pendingActionResult[1].error\n      : undefined;\n\n  // Process loader results into state.loaderData/state.errors\n  matches.forEach((match) => {\n    if (!(match.route.id in results)) {\n      return;\n    }\n    let id = match.route.id;\n    let result = results[id];\n    invariant(\n      !isRedirectResult(result),\n      \"Cannot handle redirect results in processLoaderData\"\n    );\n    if (isErrorResult(result)) {\n      let error = result.error;\n      // If we have a pending action error, we report it at the highest-route\n      // that throws a loader error, and then clear it out to indicate that\n      // it was consumed\n      if (pendingError !== undefined) {\n        error = pendingError;\n        pendingError = undefined;\n      }\n\n      errors = errors || {};\n\n      if (skipLoaderErrorBubbling) {\n        errors[id] = error;\n      } else {\n        // Look upwards from the matched route for the closest ancestor error\n        // boundary, defaulting to the root match.  Prefer higher error values\n        // if lower errors bubble to the same boundary\n        let boundaryMatch = findNearestBoundary(matches, id);\n        if (errors[boundaryMatch.route.id] == null) {\n          errors[boundaryMatch.route.id] = error;\n        }\n      }\n\n      // Clear our any prior loaderData for the throwing route\n      loaderData[id] = undefined;\n\n      // Once we find our first (highest) error, we set the status code and\n      // prevent deeper status codes from overriding\n      if (!foundError) {\n        foundError = true;\n        statusCode = isRouteErrorResponse(result.error)\n          ? result.error.status\n          : 500;\n      }\n      if (result.headers) {\n        loaderHeaders[id] = result.headers;\n      }\n    } else {\n      if (isDeferredResult(result)) {\n        activeDeferreds.set(id, result.deferredData);\n        loaderData[id] = result.deferredData.data;\n        // Error status codes always override success status codes, but if all\n        // loaders are successful we take the deepest status code.\n        if (\n          result.statusCode != null &&\n          result.statusCode !== 200 &&\n          !foundError\n        ) {\n          statusCode = result.statusCode;\n        }\n        if (result.headers) {\n          loaderHeaders[id] = result.headers;\n        }\n      } else {\n        loaderData[id] = result.data;\n        // Error status codes always override success status codes, but if all\n        // loaders are successful we take the deepest status code.\n        if (result.statusCode && result.statusCode !== 200 && !foundError) {\n          statusCode = result.statusCode;\n        }\n        if (result.headers) {\n          loaderHeaders[id] = result.headers;\n        }\n      }\n    }\n  });\n\n  // If we didn't consume the pending action error (i.e., all loaders\n  // resolved), then consume it here.  Also clear out any loaderData for the\n  // throwing route\n  if (pendingError !== undefined && pendingActionResult) {\n    errors = { [pendingActionResult[0]]: pendingError };\n    loaderData[pendingActionResult[0]] = undefined;\n  }\n\n  return {\n    loaderData,\n    errors,\n    statusCode: statusCode || 200,\n    loaderHeaders,\n  };\n}\n\nfunction processLoaderData(\n  state: RouterState,\n  matches: AgnosticDataRouteMatch[],\n  results: Record<string, DataResult>,\n  pendingActionResult: PendingActionResult | undefined,\n  revalidatingFetchers: RevalidatingFetcher[],\n  fetcherResults: Record<string, DataResult>,\n  activeDeferreds: Map<string, DeferredData>\n): {\n  loaderData: RouterState[\"loaderData\"];\n  errors?: RouterState[\"errors\"];\n} {\n  let { loaderData, errors } = processRouteLoaderData(\n    matches,\n    results,\n    pendingActionResult,\n    activeDeferreds,\n    false // This method is only called client side so we always want to bubble\n  );\n\n  // Process results from our revalidating fetchers\n  revalidatingFetchers.forEach((rf) => {\n    let { key, match, controller } = rf;\n    let result = fetcherResults[key];\n    invariant(result, \"Did not find corresponding fetcher result\");\n\n    // Process fetcher non-redirect errors\n    if (controller && controller.signal.aborted) {\n      // Nothing to do for aborted fetchers\n      return;\n    } else if (isErrorResult(result)) {\n      let boundaryMatch = findNearestBoundary(state.matches, match?.route.id);\n      if (!(errors && errors[boundaryMatch.route.id])) {\n        errors = {\n          ...errors,\n          [boundaryMatch.route.id]: result.error,\n        };\n      }\n      state.fetchers.delete(key);\n    } else if (isRedirectResult(result)) {\n      // Should never get here, redirects should get processed above, but we\n      // keep this to type narrow to a success result in the else\n      invariant(false, \"Unhandled fetcher revalidation redirect\");\n    } else if (isDeferredResult(result)) {\n      // Should never get here, deferred data should be awaited for fetchers\n      // in resolveDeferredResults\n      invariant(false, \"Unhandled fetcher deferred data\");\n    } else {\n      let doneFetcher = getDoneFetcher(result.data);\n      state.fetchers.set(key, doneFetcher);\n    }\n  });\n\n  return { loaderData, errors };\n}\n\nfunction mergeLoaderData(\n  loaderData: RouteData,\n  newLoaderData: RouteData,\n  matches: AgnosticDataRouteMatch[],\n  errors: RouteData | null | undefined\n): RouteData {\n  let mergedLoaderData = { ...newLoaderData };\n  for (let match of matches) {\n    let id = match.route.id;\n    if (newLoaderData.hasOwnProperty(id)) {\n      if (newLoaderData[id] !== undefined) {\n        mergedLoaderData[id] = newLoaderData[id];\n      } else {\n        // No-op - this is so we ignore existing data if we have a key in the\n        // incoming object with an undefined value, which is how we unset a prior\n        // loaderData if we encounter a loader error\n      }\n    } else if (loaderData[id] !== undefined && match.route.loader) {\n      // Preserve existing keys not included in newLoaderData and where a loader\n      // wasn't removed by HMR\n      mergedLoaderData[id] = loaderData[id];\n    }\n\n    if (errors && errors.hasOwnProperty(id)) {\n      // Don't keep any loader data below the boundary\n      break;\n    }\n  }\n  return mergedLoaderData;\n}\n\nfunction getActionDataForCommit(\n  pendingActionResult: PendingActionResult | undefined\n) {\n  if (!pendingActionResult) {\n    return {};\n  }\n  return isErrorResult(pendingActionResult[1])\n    ? {\n        // Clear out prior actionData on errors\n        actionData: {},\n      }\n    : {\n        actionData: {\n          [pendingActionResult[0]]: pendingActionResult[1].data,\n        },\n      };\n}\n\n// Find the nearest error boundary, looking upwards from the leaf route (or the\n// route specified by routeId) for the closest ancestor error boundary,\n// defaulting to the root match\nfunction findNearestBoundary(\n  matches: AgnosticDataRouteMatch[],\n  routeId?: string\n): AgnosticDataRouteMatch {\n  let eligibleMatches = routeId\n    ? matches.slice(0, matches.findIndex((m) => m.route.id === routeId) + 1)\n    : [...matches];\n  return (\n    eligibleMatches.reverse().find((m) => m.route.hasErrorBoundary === true) ||\n    matches[0]\n  );\n}\n\nfunction getShortCircuitMatches(routes: AgnosticDataRouteObject[]): {\n  matches: AgnosticDataRouteMatch[];\n  route: AgnosticDataRouteObject;\n} {\n  // Prefer a root layout route if present, otherwise shim in a route object\n  let route =\n    routes.length === 1\n      ? routes[0]\n      : routes.find((r) => r.index || !r.path || r.path === \"/\") || {\n          id: `__shim-error-route__`,\n        };\n\n  return {\n    matches: [\n      {\n        params: {},\n        pathname: \"\",\n        pathnameBase: \"\",\n        route,\n      },\n    ],\n    route,\n  };\n}\n\nfunction getInternalRouterError(\n  status: number,\n  {\n    pathname,\n    routeId,\n    method,\n    type,\n    message,\n  }: {\n    pathname?: string;\n    routeId?: string;\n    method?: string;\n    type?: \"defer-action\" | \"invalid-body\";\n    message?: string;\n  } = {}\n) {\n  let statusText = \"Unknown Server Error\";\n  let errorMessage = \"Unknown @remix-run/router error\";\n\n  if (status === 400) {\n    statusText = \"Bad Request\";\n    if (method && pathname && routeId) {\n      errorMessage =\n        `You made a ${method} request to \"${pathname}\" but ` +\n        `did not provide a \\`loader\\` for route \"${routeId}\", ` +\n        `so there is no way to handle the request.`;\n    } else if (type === \"defer-action\") {\n      errorMessage = \"defer() is not supported in actions\";\n    } else if (type === \"invalid-body\") {\n      errorMessage = \"Unable to encode submission body\";\n    }\n  } else if (status === 403) {\n    statusText = \"Forbidden\";\n    errorMessage = `Route \"${routeId}\" does not match URL \"${pathname}\"`;\n  } else if (status === 404) {\n    statusText = \"Not Found\";\n    errorMessage = `No route matches URL \"${pathname}\"`;\n  } else if (status === 405) {\n    statusText = \"Method Not Allowed\";\n    if (method && pathname && routeId) {\n      errorMessage =\n        `You made a ${method.toUpperCase()} request to \"${pathname}\" but ` +\n        `did not provide an \\`action\\` for route \"${routeId}\", ` +\n        `so there is no way to handle the request.`;\n    } else if (method) {\n      errorMessage = `Invalid request method \"${method.toUpperCase()}\"`;\n    }\n  }\n\n  return new ErrorResponseImpl(\n    status || 500,\n    statusText,\n    new Error(errorMessage),\n    true\n  );\n}\n\n// Find any returned redirect errors, starting from the lowest match\nfunction findRedirect(\n  results: Record<string, DataResult>\n): { key: string; result: RedirectResult } | undefined {\n  let entries = Object.entries(results);\n  for (let i = entries.length - 1; i >= 0; i--) {\n    let [key, result] = entries[i];\n    if (isRedirectResult(result)) {\n      return { key, result };\n    }\n  }\n}\n\nfunction stripHashFromPath(path: To) {\n  let parsedPath = typeof path === \"string\" ? parsePath(path) : path;\n  return createPath({ ...parsedPath, hash: \"\" });\n}\n\nfunction isHashChangeOnly(a: Location, b: Location): boolean {\n  if (a.pathname !== b.pathname || a.search !== b.search) {\n    return false;\n  }\n\n  if (a.hash === \"\") {\n    // /page -> /page#hash\n    return b.hash !== \"\";\n  } else if (a.hash === b.hash) {\n    // /page#hash -> /page#hash\n    return true;\n  } else if (b.hash !== \"\") {\n    // /page#hash -> /page#other\n    return true;\n  }\n\n  // If the hash is removed the browser will re-perform a request to the server\n  // /page#hash -> /page\n  return false;\n}\n\nfunction isPromise<T = unknown>(val: unknown): val is Promise<T> {\n  return typeof val === \"object\" && val != null && \"then\" in val;\n}\n\nfunction isDataStrategyResult(result: unknown): result is DataStrategyResult {\n  return (\n    result != null &&\n    typeof result === \"object\" &&\n    \"type\" in result &&\n    \"result\" in result &&\n    (result.type === ResultType.data || result.type === ResultType.error)\n  );\n}\n\nfunction isRedirectDataStrategyResultResult(result: DataStrategyResult) {\n  return (\n    isResponse(result.result) && redirectStatusCodes.has(result.result.status)\n  );\n}\n\nfunction isDeferredResult(result: DataResult): result is DeferredResult {\n  return result.type === ResultType.deferred;\n}\n\nfunction isErrorResult(result: DataResult): result is ErrorResult {\n  return result.type === ResultType.error;\n}\n\nfunction isRedirectResult(result?: DataResult): result is RedirectResult {\n  return (result && result.type) === ResultType.redirect;\n}\n\nexport function isDataWithResponseInit(\n  value: any\n): value is DataWithResponseInit<unknown> {\n  return (\n    typeof value === \"object\" &&\n    value != null &&\n    \"type\" in value &&\n    \"data\" in value &&\n    \"init\" in value &&\n    value.type === \"DataWithResponseInit\"\n  );\n}\n\nexport function isDeferredData(value: any): value is DeferredData {\n  let deferred: DeferredData = value;\n  return (\n    deferred &&\n    typeof deferred === \"object\" &&\n    typeof deferred.data === \"object\" &&\n    typeof deferred.subscribe === \"function\" &&\n    typeof deferred.cancel === \"function\" &&\n    typeof deferred.resolveData === \"function\"\n  );\n}\n\nfunction isResponse(value: any): value is Response {\n  return (\n    value != null &&\n    typeof value.status === \"number\" &&\n    typeof value.statusText === \"string\" &&\n    typeof value.headers === \"object\" &&\n    typeof value.body !== \"undefined\"\n  );\n}\n\nfunction isRedirectResponse(result: any): result is Response {\n  if (!isResponse(result)) {\n    return false;\n  }\n\n  let status = result.status;\n  let location = result.headers.get(\"Location\");\n  return status >= 300 && status <= 399 && location != null;\n}\n\nfunction isValidMethod(method: string): method is FormMethod | V7_FormMethod {\n  return validRequestMethods.has(method.toLowerCase() as FormMethod);\n}\n\nfunction isMutationMethod(\n  method: string\n): method is MutationFormMethod | V7_MutationFormMethod {\n  return validMutationMethods.has(method.toLowerCase() as MutationFormMethod);\n}\n\nasync function resolveNavigationDeferredResults(\n  matches: (AgnosticDataRouteMatch | null)[],\n  results: Record<string, DataResult>,\n  signal: AbortSignal,\n  currentMatches: AgnosticDataRouteMatch[],\n  currentLoaderData: RouteData\n) {\n  let entries = Object.entries(results);\n  for (let index = 0; index < entries.length; index++) {\n    let [routeId, result] = entries[index];\n    let match = matches.find((m) => m?.route.id === routeId);\n    // If we don't have a match, then we can have a deferred result to do\n    // anything with.  This is for revalidating fetchers where the route was\n    // removed during HMR\n    if (!match) {\n      continue;\n    }\n\n    let currentMatch = currentMatches.find(\n      (m) => m.route.id === match!.route.id\n    );\n    let isRevalidatingLoader =\n      currentMatch != null &&\n      !isNewRouteInstance(currentMatch, match) &&\n      (currentLoaderData && currentLoaderData[match.route.id]) !== undefined;\n\n    if (isDeferredResult(result) && isRevalidatingLoader) {\n      // Note: we do not have to touch activeDeferreds here since we race them\n      // against the signal in resolveDeferredData and they'll get aborted\n      // there if needed\n      await resolveDeferredData(result, signal, false).then((result) => {\n        if (result) {\n          results[routeId] = result;\n        }\n      });\n    }\n  }\n}\n\nasync function resolveFetcherDeferredResults(\n  matches: (AgnosticDataRouteMatch | null)[],\n  results: Record<string, DataResult>,\n  revalidatingFetchers: RevalidatingFetcher[]\n) {\n  for (let index = 0; index < revalidatingFetchers.length; index++) {\n    let { key, routeId, controller } = revalidatingFetchers[index];\n    let result = results[key];\n    let match = matches.find((m) => m?.route.id === routeId);\n    // If we don't have a match, then we can have a deferred result to do\n    // anything with.  This is for revalidating fetchers where the route was\n    // removed during HMR\n    if (!match) {\n      continue;\n    }\n\n    if (isDeferredResult(result)) {\n      // Note: we do not have to touch activeDeferreds here since we race them\n      // against the signal in resolveDeferredData and they'll get aborted\n      // there if needed\n      invariant(\n        controller,\n        \"Expected an AbortController for revalidating fetcher deferred result\"\n      );\n      await resolveDeferredData(result, controller.signal, true).then(\n        (result) => {\n          if (result) {\n            results[key] = result;\n          }\n        }\n      );\n    }\n  }\n}\n\nasync function resolveDeferredData(\n  result: DeferredResult,\n  signal: AbortSignal,\n  unwrap = false\n): Promise<SuccessResult | ErrorResult | undefined> {\n  let aborted = await result.deferredData.resolveData(signal);\n  if (aborted) {\n    return;\n  }\n\n  if (unwrap) {\n    try {\n      return {\n        type: ResultType.data,\n        data: result.deferredData.unwrappedData,\n      };\n    } catch (e) {\n      // Handle any TrackedPromise._error values encountered while unwrapping\n      return {\n        type: ResultType.error,\n        error: e,\n      };\n    }\n  }\n\n  return {\n    type: ResultType.data,\n    data: result.deferredData.data,\n  };\n}\n\nfunction hasNakedIndexQuery(search: string): boolean {\n  return new URLSearchParams(search).getAll(\"index\").some((v) => v === \"\");\n}\n\nfunction getTargetMatch(\n  matches: AgnosticDataRouteMatch[],\n  location: Location | string\n) {\n  let search =\n    typeof location === \"string\" ? parsePath(location).search : location.search;\n  if (\n    matches[matches.length - 1].route.index &&\n    hasNakedIndexQuery(search || \"\")\n  ) {\n    // Return the leaf index route when index is present\n    return matches[matches.length - 1];\n  }\n  // Otherwise grab the deepest \"path contributing\" match (ignoring index and\n  // pathless layout routes)\n  let pathMatches = getPathContributingMatches(matches);\n  return pathMatches[pathMatches.length - 1];\n}\n\nfunction getSubmissionFromNavigation(\n  navigation: Navigation\n): Submission | undefined {\n  let { formMethod, formAction, formEncType, text, formData, json } =\n    navigation;\n  if (!formMethod || !formAction || !formEncType) {\n    return;\n  }\n\n  if (text != null) {\n    return {\n      formMethod,\n      formAction,\n      formEncType,\n      formData: undefined,\n      json: undefined,\n      text,\n    };\n  } else if (formData != null) {\n    return {\n      formMethod,\n      formAction,\n      formEncType,\n      formData,\n      json: undefined,\n      text: undefined,\n    };\n  } else if (json !== undefined) {\n    return {\n      formMethod,\n      formAction,\n      formEncType,\n      formData: undefined,\n      json,\n      text: undefined,\n    };\n  }\n}\n\nfunction getLoadingNavigation(\n  location: Location,\n  submission?: Submission\n): NavigationStates[\"Loading\"] {\n  if (submission) {\n    let navigation: NavigationStates[\"Loading\"] = {\n      state: \"loading\",\n      location,\n      formMethod: submission.formMethod,\n      formAction: submission.formAction,\n      formEncType: submission.formEncType,\n      formData: submission.formData,\n      json: submission.json,\n      text: submission.text,\n    };\n    return navigation;\n  } else {\n    let navigation: NavigationStates[\"Loading\"] = {\n      state: \"loading\",\n      location,\n      formMethod: undefined,\n      formAction: undefined,\n      formEncType: undefined,\n      formData: undefined,\n      json: undefined,\n      text: undefined,\n    };\n    return navigation;\n  }\n}\n\nfunction getSubmittingNavigation(\n  location: Location,\n  submission: Submission\n): NavigationStates[\"Submitting\"] {\n  let navigation: NavigationStates[\"Submitting\"] = {\n    state: \"submitting\",\n    location,\n    formMethod: submission.formMethod,\n    formAction: submission.formAction,\n    formEncType: submission.formEncType,\n    formData: submission.formData,\n    json: submission.json,\n    text: submission.text,\n  };\n  return navigation;\n}\n\nfunction getLoadingFetcher(\n  submission?: Submission,\n  data?: Fetcher[\"data\"]\n): FetcherStates[\"Loading\"] {\n  if (submission) {\n    let fetcher: FetcherStates[\"Loading\"] = {\n      state: \"loading\",\n      formMethod: submission.formMethod,\n      formAction: submission.formAction,\n      formEncType: submission.formEncType,\n      formData: submission.formData,\n      json: submission.json,\n      text: submission.text,\n      data,\n    };\n    return fetcher;\n  } else {\n    let fetcher: FetcherStates[\"Loading\"] = {\n      state: \"loading\",\n      formMethod: undefined,\n      formAction: undefined,\n      formEncType: undefined,\n      formData: undefined,\n      json: undefined,\n      text: undefined,\n      data,\n    };\n    return fetcher;\n  }\n}\n\nfunction getSubmittingFetcher(\n  submission: Submission,\n  existingFetcher?: Fetcher\n): FetcherStates[\"Submitting\"] {\n  let fetcher: FetcherStates[\"Submitting\"] = {\n    state: \"submitting\",\n    formMethod: submission.formMethod,\n    formAction: submission.formAction,\n    formEncType: submission.formEncType,\n    formData: submission.formData,\n    json: submission.json,\n    text: submission.text,\n    data: existingFetcher ? existingFetcher.data : undefined,\n  };\n  return fetcher;\n}\n\nfunction getDoneFetcher(data: Fetcher[\"data\"]): FetcherStates[\"Idle\"] {\n  let fetcher: FetcherStates[\"Idle\"] = {\n    state: \"idle\",\n    formMethod: undefined,\n    formAction: undefined,\n    formEncType: undefined,\n    formData: undefined,\n    json: undefined,\n    text: undefined,\n    data,\n  };\n  return fetcher;\n}\n\nfunction restoreAppliedTransitions(\n  _window: Window,\n  transitions: Map<string, Set<string>>\n) {\n  try {\n    let sessionPositions = _window.sessionStorage.getItem(\n      TRANSITIONS_STORAGE_KEY\n    );\n    if (sessionPositions) {\n      let json = JSON.parse(sessionPositions);\n      for (let [k, v] of Object.entries(json || {})) {\n        if (v && Array.isArray(v)) {\n          transitions.set(k, new Set(v || []));\n        }\n      }\n    }\n  } catch (e) {\n    // no-op, use default empty object\n  }\n}\n\nfunction persistAppliedTransitions(\n  _window: Window,\n  transitions: Map<string, Set<string>>\n) {\n  if (transitions.size > 0) {\n    let json: Record<string, string[]> = {};\n    for (let [k, v] of transitions) {\n      json[k] = [...v];\n    }\n    try {\n      _window.sessionStorage.setItem(\n        TRANSITIONS_STORAGE_KEY,\n        JSON.stringify(json)\n      );\n    } catch (error) {\n      warning(\n        false,\n        `Failed to save applied view transitions in sessionStorage (${error}).`\n      );\n    }\n  }\n}\n//#endregion\n"],"names":["Action","PopStateEventType","createMemoryHistory","options","initialEntries","initialIndex","v5Compat","entries","map","entry","index","createMemoryLocation","state","undefined","clampIndex","length","action","Pop","listener","n","Math","min","max","getCurrentLocation","to","key","location","createLocation","pathname","warning","charAt","JSON","stringify","createHref","createPath","history","createURL","URL","encodeLocation","path","parsePath","search","hash","push","Push","nextLocation","splice","delta","replace","Replace","go","nextIndex","listen","fn","createBrowserHistory","createBrowserLocation","window","globalHistory","usr","createBrowserHref","getUrlBasedHistory","createHashHistory","createHashLocation","substr","startsWith","createHashHref","base","document","querySelector","href","getAttribute","url","hashIndex","indexOf","slice","validateHashLocation","invariant","value","message","Error","cond","console","warn","e","createKey","random","toString","getHistoryState","idx","current","_extends","_ref","parsedPath","searchIndex","getLocation","validateLocation","defaultView","getIndex","replaceState","handlePop","historyState","pushState","error","DOMException","name","assign","origin","addEventListener","removeEventListener","ResultType","immutableRouteKeys","Set","isIndexRoute","route","convertRoutesToDataRoutes","routes","mapRouteProperties","parentPath","manifest","treePath","String","id","join","children","indexRoute","pathOrLayoutRoute","matchRoutes","locationArg","basename","matchRoutesImpl","allowPartial","stripBasename","branches","flattenRoutes","rankRouteBranches","matches","i","decoded","decodePath","matchRouteBranch","convertRouteMatchToUiMatch","match","loaderData","params","data","handle","parentsMeta","flattenRoute","relativePath","meta","caseSensitive","childrenIndex","joinPaths","routesMeta","concat","score","computeScore","forEach","_route$path","includes","exploded","explodeOptionalSegments","segments","split","first","rest","isOptional","endsWith","required","restExploded","result","subpath","sort","a","b","compareIndexes","paramRe","dynamicSegmentValue","indexRouteValue","emptySegmentValue","staticSegmentValue","splatPenalty","isSplat","s","initialScore","some","filter","reduce","segment","test","siblings","every","branch","matchedParams","matchedPathname","end","remainingPathname","matchPath","Object","pathnameBase","normalizePathname","generatePath","originalPath","prefix","p","array","isLastSegment","star","keyMatch","optional","param","pattern","matcher","compiledParams","compilePath","captureGroups","memo","paramName","splatValue","regexpSource","_","RegExp","v","decodeURIComponent","toLowerCase","startIndex","nextChar","ABSOLUTE_URL_REGEX","isAbsoluteUrl","resolvePath","fromPathname","toPathname","oldPathname","resolvePathname","substring","normalizeSearch","normalizeHash","relativeSegments","pop","getInvalidPathError","char","field","dest","getPathContributingMatches","getResolveToMatches","v7_relativeSplatPath","pathMatches","resolveTo","toArg","routePathnames","locationPathname","isPathRelative","isEmptyPath","from","routePathnameIndex","toSegments","shift","hasExplicitTrailingSlash","hasCurrentTrailingSlash","getToPathname","paths","json","init","responseInit","status","headers","Headers","has","set","Response","DataWithResponseInit","constructor","type","AbortedDeferredError","DeferredData","pendingKeysSet","subscribers","deferredKeys","Array","isArray","reject","abortPromise","Promise","r","controller","AbortController","onAbort","unlistenAbortSignal","signal","acc","_ref2","trackPromise","done","add","promise","race","then","onSettle","catch","defineProperty","get","aborted","delete","undefinedError","emit","settledKey","subscriber","subscribe","cancel","abort","k","resolveData","resolve","size","unwrappedData","_ref3","unwrapTrackedPromise","pendingKeys","isTrackedPromise","_tracked","_error","_data","defer","redirect","redirectDocument","response","ErrorResponseImpl","statusText","internal","isRouteErrorResponse","validMutationMethodsArr","validMutationMethods","validRequestMethodsArr","validRequestMethods","redirectStatusCodes","redirectPreserveMethodStatusCodes","IDLE_NAVIGATION","formMethod","formAction","formEncType","formData","text","IDLE_FETCHER","IDLE_BLOCKER","proceed","reset","defaultMapRouteProperties","hasErrorBoundary","Boolean","TRANSITIONS_STORAGE_KEY","createRouter","routerWindow","isBrowser","createElement","isServer","detectErrorBoundary","dataRoutes","inFlightDataRoutes","dataStrategyImpl","dataStrategy","defaultDataStrategy","patchRoutesOnNavigationImpl","patchRoutesOnNavigation","future","v7_fetcherPersist","v7_normalizeFormMethod","v7_partialHydration","v7_prependBasename","v7_skipActionErrorRevalidation","unlistenHistory","savedScrollPositions","getScrollRestorationKey","getScrollPosition","initialScrollRestored","hydrationData","initialMatches","initialMatchesIsFOW","initialErrors","getInternalRouterError","getShortCircuitMatches","fogOfWar","checkFogOfWar","active","initialized","m","lazy","loader","errors","findIndex","shouldLoadRouteOnHydration","router","historyAction","navigation","restoreScrollPosition","preventScrollReset","revalidation","actionData","fetchers","Map","blockers","pendingAction","HistoryAction","pendingPreventScrollReset","pendingNavigationController","pendingViewTransitionEnabled","appliedViewTransitions","removePageHideEventListener","isUninterruptedRevalidation","isRevalidationRequired","cancelledDeferredRoutes","cancelledFetcherLoads","fetchControllers","incrementingLoadId","pendingNavigationLoadId","fetchReloadIds","fetchRedirectIds","fetchLoadMatches","activeFetchers","deletedFetchers","activeDeferreds","blockerFunctions","unblockBlockerHistoryUpdate","initialize","blockerKey","shouldBlockNavigation","currentLocation","nextHistoryUpdatePromise","updateBlocker","updateState","startNavigation","restoreAppliedTransitions","_saveAppliedTransitions","persistAppliedTransitions","initialHydration","dispose","clear","deleteFetcher","deleteBlocker","newState","opts","completedFetchers","deletedFetchersKeys","fetcher","viewTransitionOpts","flushSync","completeNavigation","_temp","_location$state","_location$state2","isActionReload","isMutationMethod","_isRedirect","keys","mergeLoaderData","priorPaths","toPaths","getSavedScrollPosition","navigate","normalizedPath","normalizeTo","fromRouteId","relative","submission","normalizeNavigateOptions","userReplace","pendingError","enableViewTransition","viewTransition","revalidate","interruptActiveLoads","startUninterruptedRevalidation","overrideNavigation","saveScrollPosition","routesToUse","loadingNavigation","isHashChangeOnly","notFoundMatches","handleNavigational404","request","createClientSideRequest","pendingActionResult","findNearestBoundary","actionResult","handleAction","shortCircuited","routeId","isErrorResult","getLoadingNavigation","updatedMatches","handleLoaders","fetcherSubmission","getActionDataForCommit","isFogOfWar","getSubmittingNavigation","discoverResult","discoverRoutes","boundaryId","partialMatches","actionMatch","getTargetMatch","method","results","callDataStrategy","isRedirectResult","normalizeRedirectLocation","startRedirectNavigation","isDeferredResult","boundaryMatch","activeSubmission","getSubmissionFromNavigation","shouldUpdateNavigationState","getUpdatedActionData","matchesToLoad","revalidatingFetchers","getMatchesToLoad","cancelActiveDeferreds","updatedFetchers","markFetchRedirectsDone","updates","getUpdatedRevalidatingFetchers","rf","abortFetcher","abortPendingFetchRevalidations","f","loaderResults","fetcherResults","callLoadersAndMaybeResolveData","findRedirect","processLoaderData","deferredData","didAbortFetchLoads","abortStaleFetchLoads","shouldUpdateFetchers","revalidatingFetcher","getLoadingFetcher","fetch","setFetcherError","handleFetcherAction","handleFetcherLoader","requestMatches","detectAndHandle405Error","existingFetcher","updateFetcherState","getSubmittingFetcher","abortController","fetchRequest","originatingLoadId","actionResults","getDoneFetcher","revalidationRequest","loadId","loadFetcher","staleKey","doneFetcher","resolveDeferredData","isNavigation","_temp2","redirectLocation","isDocumentReload","redirectHistoryAction","fetcherKey","dataResults","callDataStrategyImpl","isRedirectDataStrategyResultResult","normalizeRelativeRoutingRedirectResponse","convertDataStrategyResultToDataResult","fetchersToLoad","currentMatches","loaderResultsPromise","fetcherResultsPromise","all","resolveNavigationDeferredResults","resolveFetcherDeferredResults","getFetcher","deleteFetcherAndUpdateState","count","markFetchersDone","doneKeys","landedId","yeetedKeys","getBlocker","blocker","newBlocker","blockerFunction","predicate","cancelledRouteIds","dfd","enableScrollRestoration","positions","getPosition","getKey","y","getScrollKey","fogMatches","isNonHMR","localManifest","patch","patchRoutesImpl","newMatches","newPartialMatches","_internalSetRoutes","newRoutes","patchRoutes","_internalFetchControllers","_internalActiveDeferreds","UNSAFE_DEFERRED_SYMBOL","Symbol","createStaticHandler","v7_throwAbortReason","query","_temp3","requestContext","skipLoaderErrorBubbling","isValidMethod","methodNotAllowedMatches","statusCode","loaderHeaders","actionHeaders","queryImpl","isResponse","queryRoute","_temp4","find","values","_result$activeDeferre","routeMatch","submit","loadRouteData","isDataStrategyResult","isRedirectResponse","isRouteRequest","throwStaticHandlerAbortedError","Location","loaderRequest","Request","context","getLoaderMatchesUntilBoundary","processRouteLoaderData","executedLoaders","fromEntries","getStaticContextFromError","newContext","_deepestRenderedBoundaryId","reason","isSubmissionNavigation","body","prependBasename","contextualMatches","activeRouteMatch","nakedIndex","hasNakedIndexQuery","URLSearchParams","indexValues","getAll","append","qs","normalizeFormMethod","isFetcher","getInvalidBodyError","rawFormMethod","toUpperCase","stripHashFromPath","FormData","parse","searchParams","convertFormDataToSearchParams","convertSearchParamsToFormData","includeBoundary","skipActionErrorRevalidation","currentUrl","nextUrl","boundaryMatches","actionStatus","shouldSkipRevalidation","navigationMatches","isNewLoader","currentRouteMatch","nextRouteMatch","shouldRevalidateLoader","currentParams","nextParams","defaultShouldRevalidate","isNewRouteInstance","fetcherMatches","fetcherMatch","shouldRevalidate","hasData","hasError","hydrate","currentLoaderData","currentMatch","isNew","isMissingData","currentPath","loaderMatch","arg","routeChoice","_childrenToPatch","childrenToPatch","uniqueChildren","newRoute","existingRoute","isSameRoute","aChild","_existingRoute$childr","bChild","loadLazyRouteModule","lazyRoute","routeToUpdate","routeUpdates","lazyRouteProperty","staticRouteValue","isPropertyStaticallyDefined","_ref4","shouldLoad","loadRouteDefinitionsPromises","dsMatches","loadRoutePromise","handlerOverride","callLoaderOrAction","staticContext","onReject","runHandler","handler","actualHandler","ctx","handlerPromise","val","handlerError","dataStrategyResult","contentType","isDataWithResponseInit","_result$init3","_result$init4","_result$init","_result$init2","isDeferredData","_result$init5","_result$init6","deferred","_result$init7","_result$init8","trimmedMatches","historyInstance","invalidProtocols","normalizedLocation","protocol","isSameBasename","foundError","newLoaderData","mergedLoaderData","hasOwnProperty","eligibleMatches","reverse","_temp5","errorMessage","isRevalidatingLoader","unwrap","_window","transitions","sessionPositions","sessionStorage","getItem","setItem"],"mappings":"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"}
Index: frontend/node_modules/@remix-run/router/dist/router.umd.js
===================================================================
--- frontend/node_modules/@remix-run/router/dist/router.umd.js	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/@remix-run/router/dist/router.umd.js	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,5647 @@
+/**
+ * @remix-run/router v1.23.2
+ *
+ * Copyright (c) Remix Software Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE.md file in the root directory of this source tree.
+ *
+ * @license MIT
+ */
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+  typeof define === 'function' && define.amd ? define(['exports'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.RemixRouter = {}));
+})(this, (function (exports) { 'use strict';
+
+  function _extends() {
+    _extends = Object.assign ? Object.assign.bind() : function (target) {
+      for (var i = 1; i < arguments.length; i++) {
+        var source = arguments[i];
+        for (var key in source) {
+          if (Object.prototype.hasOwnProperty.call(source, key)) {
+            target[key] = source[key];
+          }
+        }
+      }
+      return target;
+    };
+    return _extends.apply(this, arguments);
+  }
+
+  ////////////////////////////////////////////////////////////////////////////////
+  //#region Types and Constants
+  ////////////////////////////////////////////////////////////////////////////////
+
+  /**
+   * Actions represent the type of change to a location value.
+   */
+  let Action = /*#__PURE__*/function (Action) {
+    Action["Pop"] = "POP";
+    Action["Push"] = "PUSH";
+    Action["Replace"] = "REPLACE";
+    return Action;
+  }({});
+
+  /**
+   * The pathname, search, and hash values of a URL.
+   */
+
+  // TODO: (v7) Change the Location generic default from `any` to `unknown` and
+  // remove Remix `useLocation` wrapper.
+  /**
+   * An entry in a history stack. A location contains information about the
+   * URL path, as well as possibly some arbitrary state and a key.
+   */
+  /**
+   * A change to the current location.
+   */
+  /**
+   * A function that receives notifications about location changes.
+   */
+  /**
+   * Describes a location that is the destination of some navigation, either via
+   * `history.push` or `history.replace`. This may be either a URL or the pieces
+   * of a URL path.
+   */
+  /**
+   * A history is an interface to the navigation stack. The history serves as the
+   * source of truth for the current location, as well as provides a set of
+   * methods that may be used to change it.
+   *
+   * It is similar to the DOM's `window.history` object, but with a smaller, more
+   * focused API.
+   */
+  const PopStateEventType = "popstate";
+  //#endregion
+
+  ////////////////////////////////////////////////////////////////////////////////
+  //#region Memory History
+  ////////////////////////////////////////////////////////////////////////////////
+
+  /**
+   * A user-supplied object that describes a location. Used when providing
+   * entries to `createMemoryHistory` via its `initialEntries` option.
+   */
+  /**
+   * A memory history stores locations in memory. This is useful in stateful
+   * environments where there is no web browser, such as node tests or React
+   * Native.
+   */
+  /**
+   * Memory history stores the current location in memory. It is designed for use
+   * in stateful non-browser environments like tests and React Native.
+   */
+  function createMemoryHistory(options) {
+    if (options === void 0) {
+      options = {};
+    }
+    let {
+      initialEntries = ["/"],
+      initialIndex,
+      v5Compat = false
+    } = options;
+    let entries; // Declare so we can access from createMemoryLocation
+    entries = initialEntries.map((entry, index) => createMemoryLocation(entry, typeof entry === "string" ? null : entry.state, index === 0 ? "default" : undefined));
+    let index = clampIndex(initialIndex == null ? entries.length - 1 : initialIndex);
+    let action = Action.Pop;
+    let listener = null;
+    function clampIndex(n) {
+      return Math.min(Math.max(n, 0), entries.length - 1);
+    }
+    function getCurrentLocation() {
+      return entries[index];
+    }
+    function createMemoryLocation(to, state, key) {
+      if (state === void 0) {
+        state = null;
+      }
+      let location = createLocation(entries ? getCurrentLocation().pathname : "/", to, state, key);
+      warning(location.pathname.charAt(0) === "/", "relative pathnames are not supported in memory history: " + JSON.stringify(to));
+      return location;
+    }
+    function createHref(to) {
+      return typeof to === "string" ? to : createPath(to);
+    }
+    let history = {
+      get index() {
+        return index;
+      },
+      get action() {
+        return action;
+      },
+      get location() {
+        return getCurrentLocation();
+      },
+      createHref,
+      createURL(to) {
+        return new URL(createHref(to), "http://localhost");
+      },
+      encodeLocation(to) {
+        let path = typeof to === "string" ? parsePath(to) : to;
+        return {
+          pathname: path.pathname || "",
+          search: path.search || "",
+          hash: path.hash || ""
+        };
+      },
+      push(to, state) {
+        action = Action.Push;
+        let nextLocation = createMemoryLocation(to, state);
+        index += 1;
+        entries.splice(index, entries.length, nextLocation);
+        if (v5Compat && listener) {
+          listener({
+            action,
+            location: nextLocation,
+            delta: 1
+          });
+        }
+      },
+      replace(to, state) {
+        action = Action.Replace;
+        let nextLocation = createMemoryLocation(to, state);
+        entries[index] = nextLocation;
+        if (v5Compat && listener) {
+          listener({
+            action,
+            location: nextLocation,
+            delta: 0
+          });
+        }
+      },
+      go(delta) {
+        action = Action.Pop;
+        let nextIndex = clampIndex(index + delta);
+        let nextLocation = entries[nextIndex];
+        index = nextIndex;
+        if (listener) {
+          listener({
+            action,
+            location: nextLocation,
+            delta
+          });
+        }
+      },
+      listen(fn) {
+        listener = fn;
+        return () => {
+          listener = null;
+        };
+      }
+    };
+    return history;
+  }
+  //#endregion
+
+  ////////////////////////////////////////////////////////////////////////////////
+  //#region Browser History
+  ////////////////////////////////////////////////////////////////////////////////
+
+  /**
+   * A browser history stores the current location in regular URLs in a web
+   * browser environment. This is the standard for most web apps and provides the
+   * cleanest URLs the browser's address bar.
+   *
+   * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#browserhistory
+   */
+  /**
+   * Browser history stores the location in regular URLs. This is the standard for
+   * most web apps, but it requires some configuration on the server to ensure you
+   * serve the same app at multiple URLs.
+   *
+   * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createbrowserhistory
+   */
+  function createBrowserHistory(options) {
+    if (options === void 0) {
+      options = {};
+    }
+    function createBrowserLocation(window, globalHistory) {
+      let {
+        pathname,
+        search,
+        hash
+      } = window.location;
+      return createLocation("", {
+        pathname,
+        search,
+        hash
+      },
+      // state defaults to `null` because `window.history.state` does
+      globalHistory.state && globalHistory.state.usr || null, globalHistory.state && globalHistory.state.key || "default");
+    }
+    function createBrowserHref(window, to) {
+      return typeof to === "string" ? to : createPath(to);
+    }
+    return getUrlBasedHistory(createBrowserLocation, createBrowserHref, null, options);
+  }
+  //#endregion
+
+  ////////////////////////////////////////////////////////////////////////////////
+  //#region Hash History
+  ////////////////////////////////////////////////////////////////////////////////
+
+  /**
+   * A hash history stores the current location in the fragment identifier portion
+   * of the URL in a web browser environment.
+   *
+   * This is ideal for apps that do not control the server for some reason
+   * (because the fragment identifier is never sent to the server), including some
+   * shared hosting environments that do not provide fine-grained controls over
+   * which pages are served at which URLs.
+   *
+   * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#hashhistory
+   */
+  /**
+   * Hash history stores the location in window.location.hash. This makes it ideal
+   * for situations where you don't want to send the location to the server for
+   * some reason, either because you do cannot configure it or the URL space is
+   * reserved for something else.
+   *
+   * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createhashhistory
+   */
+  function createHashHistory(options) {
+    if (options === void 0) {
+      options = {};
+    }
+    function createHashLocation(window, globalHistory) {
+      let {
+        pathname = "/",
+        search = "",
+        hash = ""
+      } = parsePath(window.location.hash.substr(1));
+
+      // Hash URL should always have a leading / just like window.location.pathname
+      // does, so if an app ends up at a route like /#something then we add a
+      // leading slash so all of our path-matching behaves the same as if it would
+      // in a browser router.  This is particularly important when there exists a
+      // root splat route (<Route path="*">) since that matches internally against
+      // "/*" and we'd expect /#something to 404 in a hash router app.
+      if (!pathname.startsWith("/") && !pathname.startsWith(".")) {
+        pathname = "/" + pathname;
+      }
+      return createLocation("", {
+        pathname,
+        search,
+        hash
+      },
+      // state defaults to `null` because `window.history.state` does
+      globalHistory.state && globalHistory.state.usr || null, globalHistory.state && globalHistory.state.key || "default");
+    }
+    function createHashHref(window, to) {
+      let base = window.document.querySelector("base");
+      let href = "";
+      if (base && base.getAttribute("href")) {
+        let url = window.location.href;
+        let hashIndex = url.indexOf("#");
+        href = hashIndex === -1 ? url : url.slice(0, hashIndex);
+      }
+      return href + "#" + (typeof to === "string" ? to : createPath(to));
+    }
+    function validateHashLocation(location, to) {
+      warning(location.pathname.charAt(0) === "/", "relative pathnames are not supported in hash history.push(" + JSON.stringify(to) + ")");
+    }
+    return getUrlBasedHistory(createHashLocation, createHashHref, validateHashLocation, options);
+  }
+  //#endregion
+
+  ////////////////////////////////////////////////////////////////////////////////
+  //#region UTILS
+  ////////////////////////////////////////////////////////////////////////////////
+
+  /**
+   * @private
+   */
+  function invariant(value, message) {
+    if (value === false || value === null || typeof value === "undefined") {
+      throw new Error(message);
+    }
+  }
+  function warning(cond, message) {
+    if (!cond) {
+      // eslint-disable-next-line no-console
+      if (typeof console !== "undefined") console.warn(message);
+      try {
+        // Welcome to debugging history!
+        //
+        // This error is thrown as a convenience, so you can more easily
+        // find the source for a warning that appears in the console by
+        // enabling "pause on exceptions" in your JavaScript debugger.
+        throw new Error(message);
+        // eslint-disable-next-line no-empty
+      } catch (e) {}
+    }
+  }
+  function createKey() {
+    return Math.random().toString(36).substr(2, 8);
+  }
+
+  /**
+   * For browser-based histories, we combine the state and key into an object
+   */
+  function getHistoryState(location, index) {
+    return {
+      usr: location.state,
+      key: location.key,
+      idx: index
+    };
+  }
+
+  /**
+   * Creates a Location object with a unique key from the given Path
+   */
+  function createLocation(current, to, state, key) {
+    if (state === void 0) {
+      state = null;
+    }
+    let location = _extends({
+      pathname: typeof current === "string" ? current : current.pathname,
+      search: "",
+      hash: ""
+    }, typeof to === "string" ? parsePath(to) : to, {
+      state,
+      // TODO: This could be cleaned up.  push/replace should probably just take
+      // full Locations now and avoid the need to run through this flow at all
+      // But that's a pretty big refactor to the current test suite so going to
+      // keep as is for the time being and just let any incoming keys take precedence
+      key: to && to.key || key || createKey()
+    });
+    return location;
+  }
+
+  /**
+   * Creates a string URL path from the given pathname, search, and hash components.
+   */
+  function createPath(_ref) {
+    let {
+      pathname = "/",
+      search = "",
+      hash = ""
+    } = _ref;
+    if (search && search !== "?") pathname += search.charAt(0) === "?" ? search : "?" + search;
+    if (hash && hash !== "#") pathname += hash.charAt(0) === "#" ? hash : "#" + hash;
+    return pathname;
+  }
+
+  /**
+   * Parses a string URL path into its separate pathname, search, and hash components.
+   */
+  function parsePath(path) {
+    let parsedPath = {};
+    if (path) {
+      let hashIndex = path.indexOf("#");
+      if (hashIndex >= 0) {
+        parsedPath.hash = path.substr(hashIndex);
+        path = path.substr(0, hashIndex);
+      }
+      let searchIndex = path.indexOf("?");
+      if (searchIndex >= 0) {
+        parsedPath.search = path.substr(searchIndex);
+        path = path.substr(0, searchIndex);
+      }
+      if (path) {
+        parsedPath.pathname = path;
+      }
+    }
+    return parsedPath;
+  }
+  function getUrlBasedHistory(getLocation, createHref, validateLocation, options) {
+    if (options === void 0) {
+      options = {};
+    }
+    let {
+      window = document.defaultView,
+      v5Compat = false
+    } = options;
+    let globalHistory = window.history;
+    let action = Action.Pop;
+    let listener = null;
+    let index = getIndex();
+    // Index should only be null when we initialize. If not, it's because the
+    // user called history.pushState or history.replaceState directly, in which
+    // case we should log a warning as it will result in bugs.
+    if (index == null) {
+      index = 0;
+      globalHistory.replaceState(_extends({}, globalHistory.state, {
+        idx: index
+      }), "");
+    }
+    function getIndex() {
+      let state = globalHistory.state || {
+        idx: null
+      };
+      return state.idx;
+    }
+    function handlePop() {
+      action = Action.Pop;
+      let nextIndex = getIndex();
+      let delta = nextIndex == null ? null : nextIndex - index;
+      index = nextIndex;
+      if (listener) {
+        listener({
+          action,
+          location: history.location,
+          delta
+        });
+      }
+    }
+    function push(to, state) {
+      action = Action.Push;
+      let location = createLocation(history.location, to, state);
+      if (validateLocation) validateLocation(location, to);
+      index = getIndex() + 1;
+      let historyState = getHistoryState(location, index);
+      let url = history.createHref(location);
+
+      // try...catch because iOS limits us to 100 pushState calls :/
+      try {
+        globalHistory.pushState(historyState, "", url);
+      } catch (error) {
+        // If the exception is because `state` can't be serialized, let that throw
+        // outwards just like a replace call would so the dev knows the cause
+        // https://html.spec.whatwg.org/multipage/nav-history-apis.html#shared-history-push/replace-state-steps
+        // https://html.spec.whatwg.org/multipage/structured-data.html#structuredserializeinternal
+        if (error instanceof DOMException && error.name === "DataCloneError") {
+          throw error;
+        }
+        // They are going to lose state here, but there is no real
+        // way to warn them about it since the page will refresh...
+        window.location.assign(url);
+      }
+      if (v5Compat && listener) {
+        listener({
+          action,
+          location: history.location,
+          delta: 1
+        });
+      }
+    }
+    function replace(to, state) {
+      action = Action.Replace;
+      let location = createLocation(history.location, to, state);
+      if (validateLocation) validateLocation(location, to);
+      index = getIndex();
+      let historyState = getHistoryState(location, index);
+      let url = history.createHref(location);
+      globalHistory.replaceState(historyState, "", url);
+      if (v5Compat && listener) {
+        listener({
+          action,
+          location: history.location,
+          delta: 0
+        });
+      }
+    }
+    function createURL(to) {
+      // window.location.origin is "null" (the literal string value) in Firefox
+      // under certain conditions, notably when serving from a local HTML file
+      // See https://bugzilla.mozilla.org/show_bug.cgi?id=878297
+      let base = window.location.origin !== "null" ? window.location.origin : window.location.href;
+      let href = typeof to === "string" ? to : createPath(to);
+      // Treating this as a full URL will strip any trailing spaces so we need to
+      // pre-encode them since they might be part of a matching splat param from
+      // an ancestor route
+      href = href.replace(/ $/, "%20");
+      invariant(base, "No window.location.(origin|href) available to create URL for href: " + href);
+      return new URL(href, base);
+    }
+    let history = {
+      get action() {
+        return action;
+      },
+      get location() {
+        return getLocation(window, globalHistory);
+      },
+      listen(fn) {
+        if (listener) {
+          throw new Error("A history only accepts one active listener");
+        }
+        window.addEventListener(PopStateEventType, handlePop);
+        listener = fn;
+        return () => {
+          window.removeEventListener(PopStateEventType, handlePop);
+          listener = null;
+        };
+      },
+      createHref(to) {
+        return createHref(window, to);
+      },
+      createURL,
+      encodeLocation(to) {
+        // Encode a Location the same way window.location would
+        let url = createURL(to);
+        return {
+          pathname: url.pathname,
+          search: url.search,
+          hash: url.hash
+        };
+      },
+      push,
+      replace,
+      go(n) {
+        return globalHistory.go(n);
+      }
+    };
+    return history;
+  }
+
+  //#endregion
+
+  /**
+   * Map of routeId -> data returned from a loader/action/error
+   */
+
+  let ResultType = /*#__PURE__*/function (ResultType) {
+    ResultType["data"] = "data";
+    ResultType["deferred"] = "deferred";
+    ResultType["redirect"] = "redirect";
+    ResultType["error"] = "error";
+    return ResultType;
+  }({});
+
+  /**
+   * Successful result from a loader or action
+   */
+
+  /**
+   * Successful defer() result from a loader or action
+   */
+
+  /**
+   * Redirect result from a loader or action
+   */
+
+  /**
+   * Unsuccessful result from a loader or action
+   */
+
+  /**
+   * Result from a loader or action - potentially successful or unsuccessful
+   */
+
+  /**
+   * Users can specify either lowercase or uppercase form methods on `<Form>`,
+   * useSubmit(), `<fetcher.Form>`, etc.
+   */
+
+  /**
+   * Active navigation/fetcher form methods are exposed in lowercase on the
+   * RouterState
+   */
+
+  /**
+   * In v7, active navigation/fetcher form methods are exposed in uppercase on the
+   * RouterState.  This is to align with the normalization done via fetch().
+   */
+
+  // Thanks https://github.com/sindresorhus/type-fest!
+
+  /**
+   * @private
+   * Internal interface to pass around for action submissions, not intended for
+   * external consumption
+   */
+
+  /**
+   * @private
+   * Arguments passed to route loader/action functions.  Same for now but we keep
+   * this as a private implementation detail in case they diverge in the future.
+   */
+
+  // TODO: (v7) Change the defaults from any to unknown in and remove Remix wrappers:
+  //   ActionFunction, ActionFunctionArgs, LoaderFunction, LoaderFunctionArgs
+  //   Also, make them a type alias instead of an interface
+  /**
+   * Arguments passed to loader functions
+   */
+  /**
+   * Arguments passed to action functions
+   */
+  /**
+   * Loaders and actions can return anything except `undefined` (`null` is a
+   * valid return value if there is no data to return).  Responses are preferred
+   * and will ease any future migration to Remix
+   */
+  /**
+   * Route loader function signature
+   */
+  /**
+   * Route action function signature
+   */
+  /**
+   * Arguments passed to shouldRevalidate function
+   */
+  /**
+   * Route shouldRevalidate function signature.  This runs after any submission
+   * (navigation or fetcher), so we flatten the navigation/fetcher submission
+   * onto the arguments.  It shouldn't matter whether it came from a navigation
+   * or a fetcher, what really matters is the URLs and the formData since loaders
+   * have to re-run based on the data models that were potentially mutated.
+   */
+  /**
+   * Function provided by the framework-aware layers to set `hasErrorBoundary`
+   * from the framework-aware `errorElement` prop
+   *
+   * @deprecated Use `mapRouteProperties` instead
+   */
+  /**
+   * Result from a loader or action called via dataStrategy
+   */
+  /**
+   * Function provided by the framework-aware layers to set any framework-specific
+   * properties from framework-agnostic properties
+   */
+  /**
+   * Keys we cannot change from within a lazy() function. We spread all other keys
+   * onto the route. Either they're meaningful to the router, or they'll get
+   * ignored.
+   */
+  const immutableRouteKeys = new Set(["lazy", "caseSensitive", "path", "id", "index", "children"]);
+
+  /**
+   * lazy() function to load a route definition, which can add non-matching
+   * related properties to a route
+   */
+
+  /**
+   * Base RouteObject with common props shared by all types of routes
+   */
+
+  /**
+   * Index routes must not have children
+   */
+
+  /**
+   * Non-index routes may have children, but cannot have index
+   */
+
+  /**
+   * A route object represents a logical route, with (optionally) its child
+   * routes organized in a tree-like structure.
+   */
+
+  /**
+   * A data route object, which is just a RouteObject with a required unique ID
+   */
+
+  // Recursive helper for finding path parameters in the absence of wildcards
+
+  /**
+   * Examples:
+   * "/a/b/*" -> "*"
+   * ":a" -> "a"
+   * "/a/:b" -> "b"
+   * "/a/blahblahblah:b" -> "b"
+   * "/:a/:b" -> "a" | "b"
+   * "/:a/b/:c/*" -> "a" | "c" | "*"
+   */
+
+  // Attempt to parse the given string segment. If it fails, then just return the
+  // plain string type as a default fallback. Otherwise, return the union of the
+  // parsed string literals that were referenced as dynamic segments in the route.
+  /**
+   * The parameters that were parsed from the URL path.
+   */
+  /**
+   * A RouteMatch contains info about how a route matched a URL.
+   */
+  function isIndexRoute(route) {
+    return route.index === true;
+  }
+
+  // Walk the route tree generating unique IDs where necessary, so we are working
+  // solely with AgnosticDataRouteObject's within the Router
+  function convertRoutesToDataRoutes(routes, mapRouteProperties, parentPath, manifest) {
+    if (parentPath === void 0) {
+      parentPath = [];
+    }
+    if (manifest === void 0) {
+      manifest = {};
+    }
+    return routes.map((route, index) => {
+      let treePath = [...parentPath, String(index)];
+      let id = typeof route.id === "string" ? route.id : treePath.join("-");
+      invariant(route.index !== true || !route.children, "Cannot specify children on an index route");
+      invariant(!manifest[id], "Found a route id collision on id \"" + id + "\".  Route " + "id's must be globally unique within Data Router usages");
+      if (isIndexRoute(route)) {
+        let indexRoute = _extends({}, route, mapRouteProperties(route), {
+          id
+        });
+        manifest[id] = indexRoute;
+        return indexRoute;
+      } else {
+        let pathOrLayoutRoute = _extends({}, route, mapRouteProperties(route), {
+          id,
+          children: undefined
+        });
+        manifest[id] = pathOrLayoutRoute;
+        if (route.children) {
+          pathOrLayoutRoute.children = convertRoutesToDataRoutes(route.children, mapRouteProperties, treePath, manifest);
+        }
+        return pathOrLayoutRoute;
+      }
+    });
+  }
+
+  /**
+   * Matches the given routes to a location and returns the match data.
+   *
+   * @see https://reactrouter.com/v6/utils/match-routes
+   */
+  function matchRoutes(routes, locationArg, basename) {
+    if (basename === void 0) {
+      basename = "/";
+    }
+    return matchRoutesImpl(routes, locationArg, basename, false);
+  }
+  function matchRoutesImpl(routes, locationArg, basename, allowPartial) {
+    let location = typeof locationArg === "string" ? parsePath(locationArg) : locationArg;
+    let pathname = stripBasename(location.pathname || "/", basename);
+    if (pathname == null) {
+      return null;
+    }
+    let branches = flattenRoutes(routes);
+    rankRouteBranches(branches);
+    let matches = null;
+    for (let i = 0; matches == null && i < branches.length; ++i) {
+      // Incoming pathnames are generally encoded from either window.location
+      // or from router.navigate, but we want to match against the unencoded
+      // paths in the route definitions.  Memory router locations won't be
+      // encoded here but there also shouldn't be anything to decode so this
+      // should be a safe operation.  This avoids needing matchRoutes to be
+      // history-aware.
+      let decoded = decodePath(pathname);
+      matches = matchRouteBranch(branches[i], decoded, allowPartial);
+    }
+    return matches;
+  }
+  function convertRouteMatchToUiMatch(match, loaderData) {
+    let {
+      route,
+      pathname,
+      params
+    } = match;
+    return {
+      id: route.id,
+      pathname,
+      params,
+      data: loaderData[route.id],
+      handle: route.handle
+    };
+  }
+  function flattenRoutes(routes, branches, parentsMeta, parentPath) {
+    if (branches === void 0) {
+      branches = [];
+    }
+    if (parentsMeta === void 0) {
+      parentsMeta = [];
+    }
+    if (parentPath === void 0) {
+      parentPath = "";
+    }
+    let flattenRoute = (route, index, relativePath) => {
+      let meta = {
+        relativePath: relativePath === undefined ? route.path || "" : relativePath,
+        caseSensitive: route.caseSensitive === true,
+        childrenIndex: index,
+        route
+      };
+      if (meta.relativePath.startsWith("/")) {
+        invariant(meta.relativePath.startsWith(parentPath), "Absolute route path \"" + meta.relativePath + "\" nested under path " + ("\"" + parentPath + "\" is not valid. An absolute child route path ") + "must start with the combined path of all its parent routes.");
+        meta.relativePath = meta.relativePath.slice(parentPath.length);
+      }
+      let path = joinPaths([parentPath, meta.relativePath]);
+      let routesMeta = parentsMeta.concat(meta);
+
+      // Add the children before adding this route to the array, so we traverse the
+      // route tree depth-first and child routes appear before their parents in
+      // the "flattened" version.
+      if (route.children && route.children.length > 0) {
+        invariant(
+        // Our types know better, but runtime JS may not!
+        // @ts-expect-error
+        route.index !== true, "Index routes must not have child routes. Please remove " + ("all child routes from route path \"" + path + "\"."));
+        flattenRoutes(route.children, branches, routesMeta, path);
+      }
+
+      // Routes without a path shouldn't ever match by themselves unless they are
+      // index routes, so don't add them to the list of possible branches.
+      if (route.path == null && !route.index) {
+        return;
+      }
+      branches.push({
+        path,
+        score: computeScore(path, route.index),
+        routesMeta
+      });
+    };
+    routes.forEach((route, index) => {
+      var _route$path;
+      // coarse-grain check for optional params
+      if (route.path === "" || !((_route$path = route.path) != null && _route$path.includes("?"))) {
+        flattenRoute(route, index);
+      } else {
+        for (let exploded of explodeOptionalSegments(route.path)) {
+          flattenRoute(route, index, exploded);
+        }
+      }
+    });
+    return branches;
+  }
+
+  /**
+   * Computes all combinations of optional path segments for a given path,
+   * excluding combinations that are ambiguous and of lower priority.
+   *
+   * For example, `/one/:two?/three/:four?/:five?` explodes to:
+   * - `/one/three`
+   * - `/one/:two/three`
+   * - `/one/three/:four`
+   * - `/one/three/:five`
+   * - `/one/:two/three/:four`
+   * - `/one/:two/three/:five`
+   * - `/one/three/:four/:five`
+   * - `/one/:two/three/:four/:five`
+   */
+  function explodeOptionalSegments(path) {
+    let segments = path.split("/");
+    if (segments.length === 0) return [];
+    let [first, ...rest] = segments;
+
+    // Optional path segments are denoted by a trailing `?`
+    let isOptional = first.endsWith("?");
+    // Compute the corresponding required segment: `foo?` -> `foo`
+    let required = first.replace(/\?$/, "");
+    if (rest.length === 0) {
+      // Intepret empty string as omitting an optional segment
+      // `["one", "", "three"]` corresponds to omitting `:two` from `/one/:two?/three` -> `/one/three`
+      return isOptional ? [required, ""] : [required];
+    }
+    let restExploded = explodeOptionalSegments(rest.join("/"));
+    let result = [];
+
+    // All child paths with the prefix.  Do this for all children before the
+    // optional version for all children, so we get consistent ordering where the
+    // parent optional aspect is preferred as required.  Otherwise, we can get
+    // child sections interspersed where deeper optional segments are higher than
+    // parent optional segments, where for example, /:two would explode _earlier_
+    // then /:one.  By always including the parent as required _for all children_
+    // first, we avoid this issue
+    result.push(...restExploded.map(subpath => subpath === "" ? required : [required, subpath].join("/")));
+
+    // Then, if this is an optional value, add all child versions without
+    if (isOptional) {
+      result.push(...restExploded);
+    }
+
+    // for absolute paths, ensure `/` instead of empty segment
+    return result.map(exploded => path.startsWith("/") && exploded === "" ? "/" : exploded);
+  }
+  function rankRouteBranches(branches) {
+    branches.sort((a, b) => a.score !== b.score ? b.score - a.score // Higher score first
+    : compareIndexes(a.routesMeta.map(meta => meta.childrenIndex), b.routesMeta.map(meta => meta.childrenIndex)));
+  }
+  const paramRe = /^:[\w-]+$/;
+  const dynamicSegmentValue = 3;
+  const indexRouteValue = 2;
+  const emptySegmentValue = 1;
+  const staticSegmentValue = 10;
+  const splatPenalty = -2;
+  const isSplat = s => s === "*";
+  function computeScore(path, index) {
+    let segments = path.split("/");
+    let initialScore = segments.length;
+    if (segments.some(isSplat)) {
+      initialScore += splatPenalty;
+    }
+    if (index) {
+      initialScore += indexRouteValue;
+    }
+    return segments.filter(s => !isSplat(s)).reduce((score, segment) => score + (paramRe.test(segment) ? dynamicSegmentValue : segment === "" ? emptySegmentValue : staticSegmentValue), initialScore);
+  }
+  function compareIndexes(a, b) {
+    let siblings = a.length === b.length && a.slice(0, -1).every((n, i) => n === b[i]);
+    return siblings ?
+    // If two routes are siblings, we should try to match the earlier sibling
+    // first. This allows people to have fine-grained control over the matching
+    // behavior by simply putting routes with identical paths in the order they
+    // want them tried.
+    a[a.length - 1] - b[b.length - 1] :
+    // Otherwise, it doesn't really make sense to rank non-siblings by index,
+    // so they sort equally.
+    0;
+  }
+  function matchRouteBranch(branch, pathname, allowPartial) {
+    if (allowPartial === void 0) {
+      allowPartial = false;
+    }
+    let {
+      routesMeta
+    } = branch;
+    let matchedParams = {};
+    let matchedPathname = "/";
+    let matches = [];
+    for (let i = 0; i < routesMeta.length; ++i) {
+      let meta = routesMeta[i];
+      let end = i === routesMeta.length - 1;
+      let remainingPathname = matchedPathname === "/" ? pathname : pathname.slice(matchedPathname.length) || "/";
+      let match = matchPath({
+        path: meta.relativePath,
+        caseSensitive: meta.caseSensitive,
+        end
+      }, remainingPathname);
+      let route = meta.route;
+      if (!match && end && allowPartial && !routesMeta[routesMeta.length - 1].route.index) {
+        match = matchPath({
+          path: meta.relativePath,
+          caseSensitive: meta.caseSensitive,
+          end: false
+        }, remainingPathname);
+      }
+      if (!match) {
+        return null;
+      }
+      Object.assign(matchedParams, match.params);
+      matches.push({
+        // TODO: Can this as be avoided?
+        params: matchedParams,
+        pathname: joinPaths([matchedPathname, match.pathname]),
+        pathnameBase: normalizePathname(joinPaths([matchedPathname, match.pathnameBase])),
+        route
+      });
+      if (match.pathnameBase !== "/") {
+        matchedPathname = joinPaths([matchedPathname, match.pathnameBase]);
+      }
+    }
+    return matches;
+  }
+
+  /**
+   * Returns a path with params interpolated.
+   *
+   * @see https://reactrouter.com/v6/utils/generate-path
+   */
+  function generatePath(originalPath, params) {
+    if (params === void 0) {
+      params = {};
+    }
+    let path = originalPath;
+    if (path.endsWith("*") && path !== "*" && !path.endsWith("/*")) {
+      warning(false, "Route path \"" + path + "\" will be treated as if it were " + ("\"" + path.replace(/\*$/, "/*") + "\" because the `*` character must ") + "always follow a `/` in the pattern. To get rid of this warning, " + ("please change the route path to \"" + path.replace(/\*$/, "/*") + "\"."));
+      path = path.replace(/\*$/, "/*");
+    }
+
+    // ensure `/` is added at the beginning if the path is absolute
+    const prefix = path.startsWith("/") ? "/" : "";
+    const stringify = p => p == null ? "" : typeof p === "string" ? p : String(p);
+    const segments = path.split(/\/+/).map((segment, index, array) => {
+      const isLastSegment = index === array.length - 1;
+
+      // only apply the splat if it's the last segment
+      if (isLastSegment && segment === "*") {
+        const star = "*";
+        // Apply the splat
+        return stringify(params[star]);
+      }
+      const keyMatch = segment.match(/^:([\w-]+)(\??)$/);
+      if (keyMatch) {
+        const [, key, optional] = keyMatch;
+        let param = params[key];
+        invariant(optional === "?" || param != null, "Missing \":" + key + "\" param");
+        return stringify(param);
+      }
+
+      // Remove any optional markers from optional static segments
+      return segment.replace(/\?$/g, "");
+    })
+    // Remove empty segments
+    .filter(segment => !!segment);
+    return prefix + segments.join("/");
+  }
+
+  /**
+   * A PathPattern is used to match on some portion of a URL pathname.
+   */
+
+  /**
+   * A PathMatch contains info about how a PathPattern matched on a URL pathname.
+   */
+
+  /**
+   * Performs pattern matching on a URL pathname and returns information about
+   * the match.
+   *
+   * @see https://reactrouter.com/v6/utils/match-path
+   */
+  function matchPath(pattern, pathname) {
+    if (typeof pattern === "string") {
+      pattern = {
+        path: pattern,
+        caseSensitive: false,
+        end: true
+      };
+    }
+    let [matcher, compiledParams] = compilePath(pattern.path, pattern.caseSensitive, pattern.end);
+    let match = pathname.match(matcher);
+    if (!match) return null;
+    let matchedPathname = match[0];
+    let pathnameBase = matchedPathname.replace(/(.)\/+$/, "$1");
+    let captureGroups = match.slice(1);
+    let params = compiledParams.reduce((memo, _ref, index) => {
+      let {
+        paramName,
+        isOptional
+      } = _ref;
+      // We need to compute the pathnameBase here using the raw splat value
+      // instead of using params["*"] later because it will be decoded then
+      if (paramName === "*") {
+        let splatValue = captureGroups[index] || "";
+        pathnameBase = matchedPathname.slice(0, matchedPathname.length - splatValue.length).replace(/(.)\/+$/, "$1");
+      }
+      const value = captureGroups[index];
+      if (isOptional && !value) {
+        memo[paramName] = undefined;
+      } else {
+        memo[paramName] = (value || "").replace(/%2F/g, "/");
+      }
+      return memo;
+    }, {});
+    return {
+      params,
+      pathname: matchedPathname,
+      pathnameBase,
+      pattern
+    };
+  }
+  function compilePath(path, caseSensitive, end) {
+    if (caseSensitive === void 0) {
+      caseSensitive = false;
+    }
+    if (end === void 0) {
+      end = true;
+    }
+    warning(path === "*" || !path.endsWith("*") || path.endsWith("/*"), "Route path \"" + path + "\" will be treated as if it were " + ("\"" + path.replace(/\*$/, "/*") + "\" because the `*` character must ") + "always follow a `/` in the pattern. To get rid of this warning, " + ("please change the route path to \"" + path.replace(/\*$/, "/*") + "\"."));
+    let params = [];
+    let regexpSource = "^" + path.replace(/\/*\*?$/, "") // Ignore trailing / and /*, we'll handle it below
+    .replace(/^\/*/, "/") // Make sure it has a leading /
+    .replace(/[\\.*+^${}|()[\]]/g, "\\$&") // Escape special regex chars
+    .replace(/\/:([\w-]+)(\?)?/g, (_, paramName, isOptional) => {
+      params.push({
+        paramName,
+        isOptional: isOptional != null
+      });
+      return isOptional ? "/?([^\\/]+)?" : "/([^\\/]+)";
+    });
+    if (path.endsWith("*")) {
+      params.push({
+        paramName: "*"
+      });
+      regexpSource += path === "*" || path === "/*" ? "(.*)$" // Already matched the initial /, just match the rest
+      : "(?:\\/(.+)|\\/*)$"; // Don't include the / in params["*"]
+    } else if (end) {
+      // When matching to the end, ignore trailing slashes
+      regexpSource += "\\/*$";
+    } else if (path !== "" && path !== "/") {
+      // If our path is non-empty and contains anything beyond an initial slash,
+      // then we have _some_ form of path in our regex, so we should expect to
+      // match only if we find the end of this path segment.  Look for an optional
+      // non-captured trailing slash (to match a portion of the URL) or the end
+      // of the path (if we've matched to the end).  We used to do this with a
+      // word boundary but that gives false positives on routes like
+      // /user-preferences since `-` counts as a word boundary.
+      regexpSource += "(?:(?=\\/|$))";
+    } else ;
+    let matcher = new RegExp(regexpSource, caseSensitive ? undefined : "i");
+    return [matcher, params];
+  }
+  function decodePath(value) {
+    try {
+      return value.split("/").map(v => decodeURIComponent(v).replace(/\//g, "%2F")).join("/");
+    } catch (error) {
+      warning(false, "The URL path \"" + value + "\" could not be decoded because it is is a " + "malformed URL segment. This is probably due to a bad percent " + ("encoding (" + error + ")."));
+      return value;
+    }
+  }
+
+  /**
+   * @private
+   */
+  function stripBasename(pathname, basename) {
+    if (basename === "/") return pathname;
+    if (!pathname.toLowerCase().startsWith(basename.toLowerCase())) {
+      return null;
+    }
+
+    // We want to leave trailing slash behavior in the user's control, so if they
+    // specify a basename with a trailing slash, we should support it
+    let startIndex = basename.endsWith("/") ? basename.length - 1 : basename.length;
+    let nextChar = pathname.charAt(startIndex);
+    if (nextChar && nextChar !== "/") {
+      // pathname does not start with basename/
+      return null;
+    }
+    return pathname.slice(startIndex) || "/";
+  }
+  const ABSOLUTE_URL_REGEX$1 = /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i;
+  const isAbsoluteUrl = url => ABSOLUTE_URL_REGEX$1.test(url);
+
+  /**
+   * Returns a resolved path object relative to the given pathname.
+   *
+   * @see https://reactrouter.com/v6/utils/resolve-path
+   */
+  function resolvePath(to, fromPathname) {
+    if (fromPathname === void 0) {
+      fromPathname = "/";
+    }
+    let {
+      pathname: toPathname,
+      search = "",
+      hash = ""
+    } = typeof to === "string" ? parsePath(to) : to;
+    let pathname;
+    if (toPathname) {
+      if (isAbsoluteUrl(toPathname)) {
+        pathname = toPathname;
+      } else {
+        if (toPathname.includes("//")) {
+          let oldPathname = toPathname;
+          toPathname = toPathname.replace(/\/\/+/g, "/");
+          warning(false, "Pathnames cannot have embedded double slashes - normalizing " + (oldPathname + " -> " + toPathname));
+        }
+        if (toPathname.startsWith("/")) {
+          pathname = resolvePathname(toPathname.substring(1), "/");
+        } else {
+          pathname = resolvePathname(toPathname, fromPathname);
+        }
+      }
+    } else {
+      pathname = fromPathname;
+    }
+    return {
+      pathname,
+      search: normalizeSearch(search),
+      hash: normalizeHash(hash)
+    };
+  }
+  function resolvePathname(relativePath, fromPathname) {
+    let segments = fromPathname.replace(/\/+$/, "").split("/");
+    let relativeSegments = relativePath.split("/");
+    relativeSegments.forEach(segment => {
+      if (segment === "..") {
+        // Keep the root "" segment so the pathname starts at /
+        if (segments.length > 1) segments.pop();
+      } else if (segment !== ".") {
+        segments.push(segment);
+      }
+    });
+    return segments.length > 1 ? segments.join("/") : "/";
+  }
+  function getInvalidPathError(char, field, dest, path) {
+    return "Cannot include a '" + char + "' character in a manually specified " + ("`to." + field + "` field [" + JSON.stringify(path) + "].  Please separate it out to the ") + ("`to." + dest + "` field. Alternatively you may provide the full path as ") + "a string in <Link to=\"...\"> and the router will parse it for you.";
+  }
+
+  /**
+   * @private
+   *
+   * When processing relative navigation we want to ignore ancestor routes that
+   * do not contribute to the path, such that index/pathless layout routes don't
+   * interfere.
+   *
+   * For example, when moving a route element into an index route and/or a
+   * pathless layout route, relative link behavior contained within should stay
+   * the same.  Both of the following examples should link back to the root:
+   *
+   *   <Route path="/">
+   *     <Route path="accounts" element={<Link to=".."}>
+   *   </Route>
+   *
+   *   <Route path="/">
+   *     <Route path="accounts">
+   *       <Route element={<AccountsLayout />}>       // <-- Does not contribute
+   *         <Route index element={<Link to=".."} />  // <-- Does not contribute
+   *       </Route
+   *     </Route>
+   *   </Route>
+   */
+  function getPathContributingMatches(matches) {
+    return matches.filter((match, index) => index === 0 || match.route.path && match.route.path.length > 0);
+  }
+
+  // Return the array of pathnames for the current route matches - used to
+  // generate the routePathnames input for resolveTo()
+  function getResolveToMatches(matches, v7_relativeSplatPath) {
+    let pathMatches = getPathContributingMatches(matches);
+
+    // When v7_relativeSplatPath is enabled, use the full pathname for the leaf
+    // match so we include splat values for "." links.  See:
+    // https://github.com/remix-run/react-router/issues/11052#issuecomment-1836589329
+    if (v7_relativeSplatPath) {
+      return pathMatches.map((match, idx) => idx === pathMatches.length - 1 ? match.pathname : match.pathnameBase);
+    }
+    return pathMatches.map(match => match.pathnameBase);
+  }
+
+  /**
+   * @private
+   */
+  function resolveTo(toArg, routePathnames, locationPathname, isPathRelative) {
+    if (isPathRelative === void 0) {
+      isPathRelative = false;
+    }
+    let to;
+    if (typeof toArg === "string") {
+      to = parsePath(toArg);
+    } else {
+      to = _extends({}, toArg);
+      invariant(!to.pathname || !to.pathname.includes("?"), getInvalidPathError("?", "pathname", "search", to));
+      invariant(!to.pathname || !to.pathname.includes("#"), getInvalidPathError("#", "pathname", "hash", to));
+      invariant(!to.search || !to.search.includes("#"), getInvalidPathError("#", "search", "hash", to));
+    }
+    let isEmptyPath = toArg === "" || to.pathname === "";
+    let toPathname = isEmptyPath ? "/" : to.pathname;
+    let from;
+
+    // Routing is relative to the current pathname if explicitly requested.
+    //
+    // If a pathname is explicitly provided in `to`, it should be relative to the
+    // route context. This is explained in `Note on `<Link to>` values` in our
+    // migration guide from v5 as a means of disambiguation between `to` values
+    // that begin with `/` and those that do not. However, this is problematic for
+    // `to` values that do not provide a pathname. `to` can simply be a search or
+    // hash string, in which case we should assume that the navigation is relative
+    // to the current location's pathname and *not* the route pathname.
+    if (toPathname == null) {
+      from = locationPathname;
+    } else {
+      let routePathnameIndex = routePathnames.length - 1;
+
+      // With relative="route" (the default), each leading .. segment means
+      // "go up one route" instead of "go up one URL segment".  This is a key
+      // difference from how <a href> works and a major reason we call this a
+      // "to" value instead of a "href".
+      if (!isPathRelative && toPathname.startsWith("..")) {
+        let toSegments = toPathname.split("/");
+        while (toSegments[0] === "..") {
+          toSegments.shift();
+          routePathnameIndex -= 1;
+        }
+        to.pathname = toSegments.join("/");
+      }
+      from = routePathnameIndex >= 0 ? routePathnames[routePathnameIndex] : "/";
+    }
+    let path = resolvePath(to, from);
+
+    // Ensure the pathname has a trailing slash if the original "to" had one
+    let hasExplicitTrailingSlash = toPathname && toPathname !== "/" && toPathname.endsWith("/");
+    // Or if this was a link to the current path which has a trailing slash
+    let hasCurrentTrailingSlash = (isEmptyPath || toPathname === ".") && locationPathname.endsWith("/");
+    if (!path.pathname.endsWith("/") && (hasExplicitTrailingSlash || hasCurrentTrailingSlash)) {
+      path.pathname += "/";
+    }
+    return path;
+  }
+
+  /**
+   * @private
+   */
+  function getToPathname(to) {
+    // Empty strings should be treated the same as / paths
+    return to === "" || to.pathname === "" ? "/" : typeof to === "string" ? parsePath(to).pathname : to.pathname;
+  }
+
+  /**
+   * @private
+   */
+  const joinPaths = paths => paths.join("/").replace(/\/\/+/g, "/");
+
+  /**
+   * @private
+   */
+  const normalizePathname = pathname => pathname.replace(/\/+$/, "").replace(/^\/*/, "/");
+
+  /**
+   * @private
+   */
+  const normalizeSearch = search => !search || search === "?" ? "" : search.startsWith("?") ? search : "?" + search;
+
+  /**
+   * @private
+   */
+  const normalizeHash = hash => !hash || hash === "#" ? "" : hash.startsWith("#") ? hash : "#" + hash;
+  /**
+   * This is a shortcut for creating `application/json` responses. Converts `data`
+   * to JSON and sets the `Content-Type` header.
+   *
+   * @deprecated The `json` method is deprecated in favor of returning raw objects.
+   * This method will be removed in v7.
+   */
+  const json = function json(data, init) {
+    if (init === void 0) {
+      init = {};
+    }
+    let responseInit = typeof init === "number" ? {
+      status: init
+    } : init;
+    let headers = new Headers(responseInit.headers);
+    if (!headers.has("Content-Type")) {
+      headers.set("Content-Type", "application/json; charset=utf-8");
+    }
+    return new Response(JSON.stringify(data), _extends({}, responseInit, {
+      headers
+    }));
+  };
+  class DataWithResponseInit {
+    constructor(data, init) {
+      this.type = "DataWithResponseInit";
+      this.data = data;
+      this.init = init || null;
+    }
+  }
+
+  /**
+   * Create "responses" that contain `status`/`headers` without forcing
+   * serialization into an actual `Response` - used by Remix single fetch
+   */
+  function data(data, init) {
+    return new DataWithResponseInit(data, typeof init === "number" ? {
+      status: init
+    } : init);
+  }
+  class AbortedDeferredError extends Error {}
+  class DeferredData {
+    constructor(data, responseInit) {
+      this.pendingKeysSet = new Set();
+      this.subscribers = new Set();
+      this.deferredKeys = [];
+      invariant(data && typeof data === "object" && !Array.isArray(data), "defer() only accepts plain objects");
+
+      // Set up an AbortController + Promise we can race against to exit early
+      // cancellation
+      let reject;
+      this.abortPromise = new Promise((_, r) => reject = r);
+      this.controller = new AbortController();
+      let onAbort = () => reject(new AbortedDeferredError("Deferred data aborted"));
+      this.unlistenAbortSignal = () => this.controller.signal.removeEventListener("abort", onAbort);
+      this.controller.signal.addEventListener("abort", onAbort);
+      this.data = Object.entries(data).reduce((acc, _ref2) => {
+        let [key, value] = _ref2;
+        return Object.assign(acc, {
+          [key]: this.trackPromise(key, value)
+        });
+      }, {});
+      if (this.done) {
+        // All incoming values were resolved
+        this.unlistenAbortSignal();
+      }
+      this.init = responseInit;
+    }
+    trackPromise(key, value) {
+      if (!(value instanceof Promise)) {
+        return value;
+      }
+      this.deferredKeys.push(key);
+      this.pendingKeysSet.add(key);
+
+      // We store a little wrapper promise that will be extended with
+      // _data/_error props upon resolve/reject
+      let promise = Promise.race([value, this.abortPromise]).then(data => this.onSettle(promise, key, undefined, data), error => this.onSettle(promise, key, error));
+
+      // Register rejection listeners to avoid uncaught promise rejections on
+      // errors or aborted deferred values
+      promise.catch(() => {});
+      Object.defineProperty(promise, "_tracked", {
+        get: () => true
+      });
+      return promise;
+    }
+    onSettle(promise, key, error, data) {
+      if (this.controller.signal.aborted && error instanceof AbortedDeferredError) {
+        this.unlistenAbortSignal();
+        Object.defineProperty(promise, "_error", {
+          get: () => error
+        });
+        return Promise.reject(error);
+      }
+      this.pendingKeysSet.delete(key);
+      if (this.done) {
+        // Nothing left to abort!
+        this.unlistenAbortSignal();
+      }
+
+      // If the promise was resolved/rejected with undefined, we'll throw an error as you
+      // should always resolve with a value or null
+      if (error === undefined && data === undefined) {
+        let undefinedError = new Error("Deferred data for key \"" + key + "\" resolved/rejected with `undefined`, " + "you must resolve/reject with a value or `null`.");
+        Object.defineProperty(promise, "_error", {
+          get: () => undefinedError
+        });
+        this.emit(false, key);
+        return Promise.reject(undefinedError);
+      }
+      if (data === undefined) {
+        Object.defineProperty(promise, "_error", {
+          get: () => error
+        });
+        this.emit(false, key);
+        return Promise.reject(error);
+      }
+      Object.defineProperty(promise, "_data", {
+        get: () => data
+      });
+      this.emit(false, key);
+      return data;
+    }
+    emit(aborted, settledKey) {
+      this.subscribers.forEach(subscriber => subscriber(aborted, settledKey));
+    }
+    subscribe(fn) {
+      this.subscribers.add(fn);
+      return () => this.subscribers.delete(fn);
+    }
+    cancel() {
+      this.controller.abort();
+      this.pendingKeysSet.forEach((v, k) => this.pendingKeysSet.delete(k));
+      this.emit(true);
+    }
+    async resolveData(signal) {
+      let aborted = false;
+      if (!this.done) {
+        let onAbort = () => this.cancel();
+        signal.addEventListener("abort", onAbort);
+        aborted = await new Promise(resolve => {
+          this.subscribe(aborted => {
+            signal.removeEventListener("abort", onAbort);
+            if (aborted || this.done) {
+              resolve(aborted);
+            }
+          });
+        });
+      }
+      return aborted;
+    }
+    get done() {
+      return this.pendingKeysSet.size === 0;
+    }
+    get unwrappedData() {
+      invariant(this.data !== null && this.done, "Can only unwrap data on initialized and settled deferreds");
+      return Object.entries(this.data).reduce((acc, _ref3) => {
+        let [key, value] = _ref3;
+        return Object.assign(acc, {
+          [key]: unwrapTrackedPromise(value)
+        });
+      }, {});
+    }
+    get pendingKeys() {
+      return Array.from(this.pendingKeysSet);
+    }
+  }
+  function isTrackedPromise(value) {
+    return value instanceof Promise && value._tracked === true;
+  }
+  function unwrapTrackedPromise(value) {
+    if (!isTrackedPromise(value)) {
+      return value;
+    }
+    if (value._error) {
+      throw value._error;
+    }
+    return value._data;
+  }
+  /**
+   * @deprecated The `defer` method is deprecated in favor of returning raw
+   * objects. This method will be removed in v7.
+   */
+  const defer = function defer(data, init) {
+    if (init === void 0) {
+      init = {};
+    }
+    let responseInit = typeof init === "number" ? {
+      status: init
+    } : init;
+    return new DeferredData(data, responseInit);
+  };
+  /**
+   * A redirect response. Sets the status code and the `Location` header.
+   * Defaults to "302 Found".
+   */
+  const redirect = function redirect(url, init) {
+    if (init === void 0) {
+      init = 302;
+    }
+    let responseInit = init;
+    if (typeof responseInit === "number") {
+      responseInit = {
+        status: responseInit
+      };
+    } else if (typeof responseInit.status === "undefined") {
+      responseInit.status = 302;
+    }
+    let headers = new Headers(responseInit.headers);
+    headers.set("Location", url);
+    return new Response(null, _extends({}, responseInit, {
+      headers
+    }));
+  };
+
+  /**
+   * A redirect response that will force a document reload to the new location.
+   * Sets the status code and the `Location` header.
+   * Defaults to "302 Found".
+   */
+  const redirectDocument = (url, init) => {
+    let response = redirect(url, init);
+    response.headers.set("X-Remix-Reload-Document", "true");
+    return response;
+  };
+
+  /**
+   * A redirect response that will perform a `history.replaceState` instead of a
+   * `history.pushState` for client-side navigation redirects.
+   * Sets the status code and the `Location` header.
+   * Defaults to "302 Found".
+   */
+  const replace = (url, init) => {
+    let response = redirect(url, init);
+    response.headers.set("X-Remix-Replace", "true");
+    return response;
+  };
+  /**
+   * @private
+   * Utility class we use to hold auto-unwrapped 4xx/5xx Response bodies
+   *
+   * We don't export the class for public use since it's an implementation
+   * detail, but we export the interface above so folks can build their own
+   * abstractions around instances via isRouteErrorResponse()
+   */
+  class ErrorResponseImpl {
+    constructor(status, statusText, data, internal) {
+      if (internal === void 0) {
+        internal = false;
+      }
+      this.status = status;
+      this.statusText = statusText || "";
+      this.internal = internal;
+      if (data instanceof Error) {
+        this.data = data.toString();
+        this.error = data;
+      } else {
+        this.data = data;
+      }
+    }
+  }
+
+  /**
+   * Check if the given error is an ErrorResponse generated from a 4xx/5xx
+   * Response thrown from an action/loader
+   */
+  function isRouteErrorResponse(error) {
+    return error != null && typeof error.status === "number" && typeof error.statusText === "string" && typeof error.internal === "boolean" && "data" in error;
+  }
+
+  ////////////////////////////////////////////////////////////////////////////////
+  //#region Types and Constants
+  ////////////////////////////////////////////////////////////////////////////////
+
+  /**
+   * A Router instance manages all navigation and data loading/mutations
+   */
+  /**
+   * State maintained internally by the router.  During a navigation, all states
+   * reflect the the "old" location unless otherwise noted.
+   */
+  /**
+   * Data that can be passed into hydrate a Router from SSR
+   */
+  /**
+   * Future flags to toggle new feature behavior
+   */
+  /**
+   * Initialization options for createRouter
+   */
+  /**
+   * State returned from a server-side query() call
+   */
+  /**
+   * A StaticHandler instance manages a singular SSR navigation/fetch event
+   */
+  /**
+   * Subscriber function signature for changes to router state
+   */
+  /**
+   * Function signature for determining the key to be used in scroll restoration
+   * for a given location
+   */
+  /**
+   * Function signature for determining the current scroll position
+   */
+  // Allowed for any navigation or fetch
+  // Only allowed for navigations
+  // Only allowed for submission navigations
+  /**
+   * Options for a navigate() call for a normal (non-submission) navigation
+   */
+  /**
+   * Options for a navigate() call for a submission navigation
+   */
+  /**
+   * Options to pass to navigate() for a navigation
+   */
+  /**
+   * Options for a fetch() load
+   */
+  /**
+   * Options for a fetch() submission
+   */
+  /**
+   * Options to pass to fetch()
+   */
+  /**
+   * Potential states for state.navigation
+   */
+  /**
+   * Potential states for fetchers
+   */
+  /**
+   * Cached info for active fetcher.load() instances so they can participate
+   * in revalidation
+   */
+  /**
+   * Identified fetcher.load() calls that need to be revalidated
+   */
+  const validMutationMethodsArr = ["post", "put", "patch", "delete"];
+  const validMutationMethods = new Set(validMutationMethodsArr);
+  const validRequestMethodsArr = ["get", ...validMutationMethodsArr];
+  const validRequestMethods = new Set(validRequestMethodsArr);
+  const redirectStatusCodes = new Set([301, 302, 303, 307, 308]);
+  const redirectPreserveMethodStatusCodes = new Set([307, 308]);
+  const IDLE_NAVIGATION = {
+    state: "idle",
+    location: undefined,
+    formMethod: undefined,
+    formAction: undefined,
+    formEncType: undefined,
+    formData: undefined,
+    json: undefined,
+    text: undefined
+  };
+  const IDLE_FETCHER = {
+    state: "idle",
+    data: undefined,
+    formMethod: undefined,
+    formAction: undefined,
+    formEncType: undefined,
+    formData: undefined,
+    json: undefined,
+    text: undefined
+  };
+  const IDLE_BLOCKER = {
+    state: "unblocked",
+    proceed: undefined,
+    reset: undefined,
+    location: undefined
+  };
+  const ABSOLUTE_URL_REGEX = /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i;
+  const defaultMapRouteProperties = route => ({
+    hasErrorBoundary: Boolean(route.hasErrorBoundary)
+  });
+  const TRANSITIONS_STORAGE_KEY = "remix-router-transitions";
+
+  //#endregion
+
+  ////////////////////////////////////////////////////////////////////////////////
+  //#region createRouter
+  ////////////////////////////////////////////////////////////////////////////////
+
+  /**
+   * Create a router and listen to history POP navigations
+   */
+  function createRouter(init) {
+    const routerWindow = init.window ? init.window : typeof window !== "undefined" ? window : undefined;
+    const isBrowser = typeof routerWindow !== "undefined" && typeof routerWindow.document !== "undefined" && typeof routerWindow.document.createElement !== "undefined";
+    const isServer = !isBrowser;
+    invariant(init.routes.length > 0, "You must provide a non-empty routes array to createRouter");
+    let mapRouteProperties;
+    if (init.mapRouteProperties) {
+      mapRouteProperties = init.mapRouteProperties;
+    } else if (init.detectErrorBoundary) {
+      // If they are still using the deprecated version, wrap it with the new API
+      let detectErrorBoundary = init.detectErrorBoundary;
+      mapRouteProperties = route => ({
+        hasErrorBoundary: detectErrorBoundary(route)
+      });
+    } else {
+      mapRouteProperties = defaultMapRouteProperties;
+    }
+
+    // Routes keyed by ID
+    let manifest = {};
+    // Routes in tree format for matching
+    let dataRoutes = convertRoutesToDataRoutes(init.routes, mapRouteProperties, undefined, manifest);
+    let inFlightDataRoutes;
+    let basename = init.basename || "/";
+    let dataStrategyImpl = init.dataStrategy || defaultDataStrategy;
+    let patchRoutesOnNavigationImpl = init.patchRoutesOnNavigation;
+
+    // Config driven behavior flags
+    let future = _extends({
+      v7_fetcherPersist: false,
+      v7_normalizeFormMethod: false,
+      v7_partialHydration: false,
+      v7_prependBasename: false,
+      v7_relativeSplatPath: false,
+      v7_skipActionErrorRevalidation: false
+    }, init.future);
+    // Cleanup function for history
+    let unlistenHistory = null;
+    // Externally-provided functions to call on all state changes
+    let subscribers = new Set();
+    // Externally-provided object to hold scroll restoration locations during routing
+    let savedScrollPositions = null;
+    // Externally-provided function to get scroll restoration keys
+    let getScrollRestorationKey = null;
+    // Externally-provided function to get current scroll position
+    let getScrollPosition = null;
+    // One-time flag to control the initial hydration scroll restoration.  Because
+    // we don't get the saved positions from <ScrollRestoration /> until _after_
+    // the initial render, we need to manually trigger a separate updateState to
+    // send along the restoreScrollPosition
+    // Set to true if we have `hydrationData` since we assume we were SSR'd and that
+    // SSR did the initial scroll restoration.
+    let initialScrollRestored = init.hydrationData != null;
+    let initialMatches = matchRoutes(dataRoutes, init.history.location, basename);
+    let initialMatchesIsFOW = false;
+    let initialErrors = null;
+    if (initialMatches == null && !patchRoutesOnNavigationImpl) {
+      // If we do not match a user-provided-route, fall back to the root
+      // to allow the error boundary to take over
+      let error = getInternalRouterError(404, {
+        pathname: init.history.location.pathname
+      });
+      let {
+        matches,
+        route
+      } = getShortCircuitMatches(dataRoutes);
+      initialMatches = matches;
+      initialErrors = {
+        [route.id]: error
+      };
+    }
+
+    // In SPA apps, if the user provided a patchRoutesOnNavigation implementation and
+    // our initial match is a splat route, clear them out so we run through lazy
+    // discovery on hydration in case there's a more accurate lazy route match.
+    // In SSR apps (with `hydrationData`), we expect that the server will send
+    // up the proper matched routes so we don't want to run lazy discovery on
+    // initial hydration and want to hydrate into the splat route.
+    if (initialMatches && !init.hydrationData) {
+      let fogOfWar = checkFogOfWar(initialMatches, dataRoutes, init.history.location.pathname);
+      if (fogOfWar.active) {
+        initialMatches = null;
+      }
+    }
+    let initialized;
+    if (!initialMatches) {
+      initialized = false;
+      initialMatches = [];
+
+      // If partial hydration and fog of war is enabled, we will be running
+      // `patchRoutesOnNavigation` during hydration so include any partial matches as
+      // the initial matches so we can properly render `HydrateFallback`'s
+      if (future.v7_partialHydration) {
+        let fogOfWar = checkFogOfWar(null, dataRoutes, init.history.location.pathname);
+        if (fogOfWar.active && fogOfWar.matches) {
+          initialMatchesIsFOW = true;
+          initialMatches = fogOfWar.matches;
+        }
+      }
+    } else if (initialMatches.some(m => m.route.lazy)) {
+      // All initialMatches need to be loaded before we're ready.  If we have lazy
+      // functions around still then we'll need to run them in initialize()
+      initialized = false;
+    } else if (!initialMatches.some(m => m.route.loader)) {
+      // If we've got no loaders to run, then we're good to go
+      initialized = true;
+    } else if (future.v7_partialHydration) {
+      // If partial hydration is enabled, we're initialized so long as we were
+      // provided with hydrationData for every route with a loader, and no loaders
+      // were marked for explicit hydration
+      let loaderData = init.hydrationData ? init.hydrationData.loaderData : null;
+      let errors = init.hydrationData ? init.hydrationData.errors : null;
+      // If errors exist, don't consider routes below the boundary
+      if (errors) {
+        let idx = initialMatches.findIndex(m => errors[m.route.id] !== undefined);
+        initialized = initialMatches.slice(0, idx + 1).every(m => !shouldLoadRouteOnHydration(m.route, loaderData, errors));
+      } else {
+        initialized = initialMatches.every(m => !shouldLoadRouteOnHydration(m.route, loaderData, errors));
+      }
+    } else {
+      // Without partial hydration - we're initialized if we were provided any
+      // hydrationData - which is expected to be complete
+      initialized = init.hydrationData != null;
+    }
+    let router;
+    let state = {
+      historyAction: init.history.action,
+      location: init.history.location,
+      matches: initialMatches,
+      initialized,
+      navigation: IDLE_NAVIGATION,
+      // Don't restore on initial updateState() if we were SSR'd
+      restoreScrollPosition: init.hydrationData != null ? false : null,
+      preventScrollReset: false,
+      revalidation: "idle",
+      loaderData: init.hydrationData && init.hydrationData.loaderData || {},
+      actionData: init.hydrationData && init.hydrationData.actionData || null,
+      errors: init.hydrationData && init.hydrationData.errors || initialErrors,
+      fetchers: new Map(),
+      blockers: new Map()
+    };
+
+    // -- Stateful internal variables to manage navigations --
+    // Current navigation in progress (to be committed in completeNavigation)
+    let pendingAction = Action.Pop;
+
+    // Should the current navigation prevent the scroll reset if scroll cannot
+    // be restored?
+    let pendingPreventScrollReset = false;
+
+    // AbortController for the active navigation
+    let pendingNavigationController;
+
+    // Should the current navigation enable document.startViewTransition?
+    let pendingViewTransitionEnabled = false;
+
+    // Store applied view transitions so we can apply them on POP
+    let appliedViewTransitions = new Map();
+
+    // Cleanup function for persisting applied transitions to sessionStorage
+    let removePageHideEventListener = null;
+
+    // We use this to avoid touching history in completeNavigation if a
+    // revalidation is entirely uninterrupted
+    let isUninterruptedRevalidation = false;
+
+    // Use this internal flag to force revalidation of all loaders:
+    //  - submissions (completed or interrupted)
+    //  - useRevalidator()
+    //  - X-Remix-Revalidate (from redirect)
+    let isRevalidationRequired = false;
+
+    // Use this internal array to capture routes that require revalidation due
+    // to a cancelled deferred on action submission
+    let cancelledDeferredRoutes = [];
+
+    // Use this internal array to capture fetcher loads that were cancelled by an
+    // action navigation and require revalidation
+    let cancelledFetcherLoads = new Set();
+
+    // AbortControllers for any in-flight fetchers
+    let fetchControllers = new Map();
+
+    // Track loads based on the order in which they started
+    let incrementingLoadId = 0;
+
+    // Track the outstanding pending navigation data load to be compared against
+    // the globally incrementing load when a fetcher load lands after a completed
+    // navigation
+    let pendingNavigationLoadId = -1;
+
+    // Fetchers that triggered data reloads as a result of their actions
+    let fetchReloadIds = new Map();
+
+    // Fetchers that triggered redirect navigations
+    let fetchRedirectIds = new Set();
+
+    // Most recent href/match for fetcher.load calls for fetchers
+    let fetchLoadMatches = new Map();
+
+    // Ref-count mounted fetchers so we know when it's ok to clean them up
+    let activeFetchers = new Map();
+
+    // Fetchers that have requested a delete when using v7_fetcherPersist,
+    // they'll be officially removed after they return to idle
+    let deletedFetchers = new Set();
+
+    // Store DeferredData instances for active route matches.  When a
+    // route loader returns defer() we stick one in here.  Then, when a nested
+    // promise resolves we update loaderData.  If a new navigation starts we
+    // cancel active deferreds for eliminated routes.
+    let activeDeferreds = new Map();
+
+    // Store blocker functions in a separate Map outside of router state since
+    // we don't need to update UI state if they change
+    let blockerFunctions = new Map();
+
+    // Flag to ignore the next history update, so we can revert the URL change on
+    // a POP navigation that was blocked by the user without touching router state
+    let unblockBlockerHistoryUpdate = undefined;
+
+    // Initialize the router, all side effects should be kicked off from here.
+    // Implemented as a Fluent API for ease of:
+    //   let router = createRouter(init).initialize();
+    function initialize() {
+      // If history informs us of a POP navigation, start the navigation but do not update
+      // state.  We'll update our own state once the navigation completes
+      unlistenHistory = init.history.listen(_ref => {
+        let {
+          action: historyAction,
+          location,
+          delta
+        } = _ref;
+        // Ignore this event if it was just us resetting the URL from a
+        // blocked POP navigation
+        if (unblockBlockerHistoryUpdate) {
+          unblockBlockerHistoryUpdate();
+          unblockBlockerHistoryUpdate = undefined;
+          return;
+        }
+        warning(blockerFunctions.size === 0 || delta != null, "You are trying to use a blocker on a POP navigation to a location " + "that was not created by @remix-run/router. This will fail silently in " + "production. This can happen if you are navigating outside the router " + "via `window.history.pushState`/`window.location.hash` instead of using " + "router navigation APIs.  This can also happen if you are using " + "createHashRouter and the user manually changes the URL.");
+        let blockerKey = shouldBlockNavigation({
+          currentLocation: state.location,
+          nextLocation: location,
+          historyAction
+        });
+        if (blockerKey && delta != null) {
+          // Restore the URL to match the current UI, but don't update router state
+          let nextHistoryUpdatePromise = new Promise(resolve => {
+            unblockBlockerHistoryUpdate = resolve;
+          });
+          init.history.go(delta * -1);
+
+          // Put the blocker into a blocked state
+          updateBlocker(blockerKey, {
+            state: "blocked",
+            location,
+            proceed() {
+              updateBlocker(blockerKey, {
+                state: "proceeding",
+                proceed: undefined,
+                reset: undefined,
+                location
+              });
+              // Re-do the same POP navigation we just blocked, after the url
+              // restoration is also complete.  See:
+              // https://github.com/remix-run/react-router/issues/11613
+              nextHistoryUpdatePromise.then(() => init.history.go(delta));
+            },
+            reset() {
+              let blockers = new Map(state.blockers);
+              blockers.set(blockerKey, IDLE_BLOCKER);
+              updateState({
+                blockers
+              });
+            }
+          });
+          return;
+        }
+        return startNavigation(historyAction, location);
+      });
+      if (isBrowser) {
+        // FIXME: This feels gross.  How can we cleanup the lines between
+        // scrollRestoration/appliedTransitions persistance?
+        restoreAppliedTransitions(routerWindow, appliedViewTransitions);
+        let _saveAppliedTransitions = () => persistAppliedTransitions(routerWindow, appliedViewTransitions);
+        routerWindow.addEventListener("pagehide", _saveAppliedTransitions);
+        removePageHideEventListener = () => routerWindow.removeEventListener("pagehide", _saveAppliedTransitions);
+      }
+
+      // Kick off initial data load if needed.  Use Pop to avoid modifying history
+      // Note we don't do any handling of lazy here.  For SPA's it'll get handled
+      // in the normal navigation flow.  For SSR it's expected that lazy modules are
+      // resolved prior to router creation since we can't go into a fallbackElement
+      // UI for SSR'd apps
+      if (!state.initialized) {
+        startNavigation(Action.Pop, state.location, {
+          initialHydration: true
+        });
+      }
+      return router;
+    }
+
+    // Clean up a router and it's side effects
+    function dispose() {
+      if (unlistenHistory) {
+        unlistenHistory();
+      }
+      if (removePageHideEventListener) {
+        removePageHideEventListener();
+      }
+      subscribers.clear();
+      pendingNavigationController && pendingNavigationController.abort();
+      state.fetchers.forEach((_, key) => deleteFetcher(key));
+      state.blockers.forEach((_, key) => deleteBlocker(key));
+    }
+
+    // Subscribe to state updates for the router
+    function subscribe(fn) {
+      subscribers.add(fn);
+      return () => subscribers.delete(fn);
+    }
+
+    // Update our state and notify the calling context of the change
+    function updateState(newState, opts) {
+      if (opts === void 0) {
+        opts = {};
+      }
+      state = _extends({}, state, newState);
+
+      // Prep fetcher cleanup so we can tell the UI which fetcher data entries
+      // can be removed
+      let completedFetchers = [];
+      let deletedFetchersKeys = [];
+      if (future.v7_fetcherPersist) {
+        state.fetchers.forEach((fetcher, key) => {
+          if (fetcher.state === "idle") {
+            if (deletedFetchers.has(key)) {
+              // Unmounted from the UI and can be totally removed
+              deletedFetchersKeys.push(key);
+            } else {
+              // Returned to idle but still mounted in the UI, so semi-remains for
+              // revalidations and such
+              completedFetchers.push(key);
+            }
+          }
+        });
+      }
+
+      // Remove any lingering deleted fetchers that have already been removed
+      // from state.fetchers
+      deletedFetchers.forEach(key => {
+        if (!state.fetchers.has(key) && !fetchControllers.has(key)) {
+          deletedFetchersKeys.push(key);
+        }
+      });
+
+      // Iterate over a local copy so that if flushSync is used and we end up
+      // removing and adding a new subscriber due to the useCallback dependencies,
+      // we don't get ourselves into a loop calling the new subscriber immediately
+      [...subscribers].forEach(subscriber => subscriber(state, {
+        deletedFetchers: deletedFetchersKeys,
+        viewTransitionOpts: opts.viewTransitionOpts,
+        flushSync: opts.flushSync === true
+      }));
+
+      // Remove idle fetchers from state since we only care about in-flight fetchers.
+      if (future.v7_fetcherPersist) {
+        completedFetchers.forEach(key => state.fetchers.delete(key));
+        deletedFetchersKeys.forEach(key => deleteFetcher(key));
+      } else {
+        // We already called deleteFetcher() on these, can remove them from this
+        // Set now that we've handed the keys off to the data layer
+        deletedFetchersKeys.forEach(key => deletedFetchers.delete(key));
+      }
+    }
+
+    // Complete a navigation returning the state.navigation back to the IDLE_NAVIGATION
+    // and setting state.[historyAction/location/matches] to the new route.
+    // - Location is a required param
+    // - Navigation will always be set to IDLE_NAVIGATION
+    // - Can pass any other state in newState
+    function completeNavigation(location, newState, _temp) {
+      var _location$state, _location$state2;
+      let {
+        flushSync
+      } = _temp === void 0 ? {} : _temp;
+      // Deduce if we're in a loading/actionReload state:
+      // - We have committed actionData in the store
+      // - The current navigation was a mutation submission
+      // - We're past the submitting state and into the loading state
+      // - The location being loaded is not the result of a redirect
+      let isActionReload = state.actionData != null && state.navigation.formMethod != null && isMutationMethod(state.navigation.formMethod) && state.navigation.state === "loading" && ((_location$state = location.state) == null ? void 0 : _location$state._isRedirect) !== true;
+      let actionData;
+      if (newState.actionData) {
+        if (Object.keys(newState.actionData).length > 0) {
+          actionData = newState.actionData;
+        } else {
+          // Empty actionData -> clear prior actionData due to an action error
+          actionData = null;
+        }
+      } else if (isActionReload) {
+        // Keep the current data if we're wrapping up the action reload
+        actionData = state.actionData;
+      } else {
+        // Clear actionData on any other completed navigations
+        actionData = null;
+      }
+
+      // Always preserve any existing loaderData from re-used routes
+      let loaderData = newState.loaderData ? mergeLoaderData(state.loaderData, newState.loaderData, newState.matches || [], newState.errors) : state.loaderData;
+
+      // On a successful navigation we can assume we got through all blockers
+      // so we can start fresh
+      let blockers = state.blockers;
+      if (blockers.size > 0) {
+        blockers = new Map(blockers);
+        blockers.forEach((_, k) => blockers.set(k, IDLE_BLOCKER));
+      }
+
+      // Always respect the user flag.  Otherwise don't reset on mutation
+      // submission navigations unless they redirect
+      let preventScrollReset = pendingPreventScrollReset === true || state.navigation.formMethod != null && isMutationMethod(state.navigation.formMethod) && ((_location$state2 = location.state) == null ? void 0 : _location$state2._isRedirect) !== true;
+
+      // Commit any in-flight routes at the end of the HMR revalidation "navigation"
+      if (inFlightDataRoutes) {
+        dataRoutes = inFlightDataRoutes;
+        inFlightDataRoutes = undefined;
+      }
+      if (isUninterruptedRevalidation) ; else if (pendingAction === Action.Pop) ; else if (pendingAction === Action.Push) {
+        init.history.push(location, location.state);
+      } else if (pendingAction === Action.Replace) {
+        init.history.replace(location, location.state);
+      }
+      let viewTransitionOpts;
+
+      // On POP, enable transitions if they were enabled on the original navigation
+      if (pendingAction === Action.Pop) {
+        // Forward takes precedence so they behave like the original navigation
+        let priorPaths = appliedViewTransitions.get(state.location.pathname);
+        if (priorPaths && priorPaths.has(location.pathname)) {
+          viewTransitionOpts = {
+            currentLocation: state.location,
+            nextLocation: location
+          };
+        } else if (appliedViewTransitions.has(location.pathname)) {
+          // If we don't have a previous forward nav, assume we're popping back to
+          // the new location and enable if that location previously enabled
+          viewTransitionOpts = {
+            currentLocation: location,
+            nextLocation: state.location
+          };
+        }
+      } else if (pendingViewTransitionEnabled) {
+        // Store the applied transition on PUSH/REPLACE
+        let toPaths = appliedViewTransitions.get(state.location.pathname);
+        if (toPaths) {
+          toPaths.add(location.pathname);
+        } else {
+          toPaths = new Set([location.pathname]);
+          appliedViewTransitions.set(state.location.pathname, toPaths);
+        }
+        viewTransitionOpts = {
+          currentLocation: state.location,
+          nextLocation: location
+        };
+      }
+      updateState(_extends({}, newState, {
+        // matches, errors, fetchers go through as-is
+        actionData,
+        loaderData,
+        historyAction: pendingAction,
+        location,
+        initialized: true,
+        navigation: IDLE_NAVIGATION,
+        revalidation: "idle",
+        restoreScrollPosition: getSavedScrollPosition(location, newState.matches || state.matches),
+        preventScrollReset,
+        blockers
+      }), {
+        viewTransitionOpts,
+        flushSync: flushSync === true
+      });
+
+      // Reset stateful navigation vars
+      pendingAction = Action.Pop;
+      pendingPreventScrollReset = false;
+      pendingViewTransitionEnabled = false;
+      isUninterruptedRevalidation = false;
+      isRevalidationRequired = false;
+      cancelledDeferredRoutes = [];
+    }
+
+    // Trigger a navigation event, which can either be a numerical POP or a PUSH
+    // replace with an optional submission
+    async function navigate(to, opts) {
+      if (typeof to === "number") {
+        init.history.go(to);
+        return;
+      }
+      let normalizedPath = normalizeTo(state.location, state.matches, basename, future.v7_prependBasename, to, future.v7_relativeSplatPath, opts == null ? void 0 : opts.fromRouteId, opts == null ? void 0 : opts.relative);
+      let {
+        path,
+        submission,
+        error
+      } = normalizeNavigateOptions(future.v7_normalizeFormMethod, false, normalizedPath, opts);
+      let currentLocation = state.location;
+      let nextLocation = createLocation(state.location, path, opts && opts.state);
+
+      // When using navigate as a PUSH/REPLACE we aren't reading an already-encoded
+      // URL from window.location, so we need to encode it here so the behavior
+      // remains the same as POP and non-data-router usages.  new URL() does all
+      // the same encoding we'd get from a history.pushState/window.location read
+      // without having to touch history
+      nextLocation = _extends({}, nextLocation, init.history.encodeLocation(nextLocation));
+      let userReplace = opts && opts.replace != null ? opts.replace : undefined;
+      let historyAction = Action.Push;
+      if (userReplace === true) {
+        historyAction = Action.Replace;
+      } else if (userReplace === false) ; else if (submission != null && isMutationMethod(submission.formMethod) && submission.formAction === state.location.pathname + state.location.search) {
+        // By default on submissions to the current location we REPLACE so that
+        // users don't have to double-click the back button to get to the prior
+        // location.  If the user redirects to a different location from the
+        // action/loader this will be ignored and the redirect will be a PUSH
+        historyAction = Action.Replace;
+      }
+      let preventScrollReset = opts && "preventScrollReset" in opts ? opts.preventScrollReset === true : undefined;
+      let flushSync = (opts && opts.flushSync) === true;
+      let blockerKey = shouldBlockNavigation({
+        currentLocation,
+        nextLocation,
+        historyAction
+      });
+      if (blockerKey) {
+        // Put the blocker into a blocked state
+        updateBlocker(blockerKey, {
+          state: "blocked",
+          location: nextLocation,
+          proceed() {
+            updateBlocker(blockerKey, {
+              state: "proceeding",
+              proceed: undefined,
+              reset: undefined,
+              location: nextLocation
+            });
+            // Send the same navigation through
+            navigate(to, opts);
+          },
+          reset() {
+            let blockers = new Map(state.blockers);
+            blockers.set(blockerKey, IDLE_BLOCKER);
+            updateState({
+              blockers
+            });
+          }
+        });
+        return;
+      }
+      return await startNavigation(historyAction, nextLocation, {
+        submission,
+        // Send through the formData serialization error if we have one so we can
+        // render at the right error boundary after we match routes
+        pendingError: error,
+        preventScrollReset,
+        replace: opts && opts.replace,
+        enableViewTransition: opts && opts.viewTransition,
+        flushSync
+      });
+    }
+
+    // Revalidate all current loaders.  If a navigation is in progress or if this
+    // is interrupted by a navigation, allow this to "succeed" by calling all
+    // loaders during the next loader round
+    function revalidate() {
+      interruptActiveLoads();
+      updateState({
+        revalidation: "loading"
+      });
+
+      // If we're currently submitting an action, we don't need to start a new
+      // navigation, we'll just let the follow up loader execution call all loaders
+      if (state.navigation.state === "submitting") {
+        return;
+      }
+
+      // If we're currently in an idle state, start a new navigation for the current
+      // action/location and mark it as uninterrupted, which will skip the history
+      // update in completeNavigation
+      if (state.navigation.state === "idle") {
+        startNavigation(state.historyAction, state.location, {
+          startUninterruptedRevalidation: true
+        });
+        return;
+      }
+
+      // Otherwise, if we're currently in a loading state, just start a new
+      // navigation to the navigation.location but do not trigger an uninterrupted
+      // revalidation so that history correctly updates once the navigation completes
+      startNavigation(pendingAction || state.historyAction, state.navigation.location, {
+        overrideNavigation: state.navigation,
+        // Proxy through any rending view transition
+        enableViewTransition: pendingViewTransitionEnabled === true
+      });
+    }
+
+    // Start a navigation to the given action/location.  Can optionally provide a
+    // overrideNavigation which will override the normalLoad in the case of a redirect
+    // navigation
+    async function startNavigation(historyAction, location, opts) {
+      // Abort any in-progress navigations and start a new one. Unset any ongoing
+      // uninterrupted revalidations unless told otherwise, since we want this
+      // new navigation to update history normally
+      pendingNavigationController && pendingNavigationController.abort();
+      pendingNavigationController = null;
+      pendingAction = historyAction;
+      isUninterruptedRevalidation = (opts && opts.startUninterruptedRevalidation) === true;
+
+      // Save the current scroll position every time we start a new navigation,
+      // and track whether we should reset scroll on completion
+      saveScrollPosition(state.location, state.matches);
+      pendingPreventScrollReset = (opts && opts.preventScrollReset) === true;
+      pendingViewTransitionEnabled = (opts && opts.enableViewTransition) === true;
+      let routesToUse = inFlightDataRoutes || dataRoutes;
+      let loadingNavigation = opts && opts.overrideNavigation;
+      let matches = opts != null && opts.initialHydration && state.matches && state.matches.length > 0 && !initialMatchesIsFOW ?
+      // `matchRoutes()` has already been called if we're in here via `router.initialize()`
+      state.matches : matchRoutes(routesToUse, location, basename);
+      let flushSync = (opts && opts.flushSync) === true;
+
+      // Short circuit if it's only a hash change and not a revalidation or
+      // mutation submission.
+      //
+      // Ignore on initial page loads because since the initial hydration will always
+      // be "same hash".  For example, on /page#hash and submit a <Form method="post">
+      // which will default to a navigation to /page
+      if (matches && state.initialized && !isRevalidationRequired && isHashChangeOnly(state.location, location) && !(opts && opts.submission && isMutationMethod(opts.submission.formMethod))) {
+        completeNavigation(location, {
+          matches
+        }, {
+          flushSync
+        });
+        return;
+      }
+      let fogOfWar = checkFogOfWar(matches, routesToUse, location.pathname);
+      if (fogOfWar.active && fogOfWar.matches) {
+        matches = fogOfWar.matches;
+      }
+
+      // Short circuit with a 404 on the root error boundary if we match nothing
+      if (!matches) {
+        let {
+          error,
+          notFoundMatches,
+          route
+        } = handleNavigational404(location.pathname);
+        completeNavigation(location, {
+          matches: notFoundMatches,
+          loaderData: {},
+          errors: {
+            [route.id]: error
+          }
+        }, {
+          flushSync
+        });
+        return;
+      }
+
+      // Create a controller/Request for this navigation
+      pendingNavigationController = new AbortController();
+      let request = createClientSideRequest(init.history, location, pendingNavigationController.signal, opts && opts.submission);
+      let pendingActionResult;
+      if (opts && opts.pendingError) {
+        // If we have a pendingError, it means the user attempted a GET submission
+        // with binary FormData so assign here and skip to handleLoaders.  That
+        // way we handle calling loaders above the boundary etc.  It's not really
+        // different from an actionError in that sense.
+        pendingActionResult = [findNearestBoundary(matches).route.id, {
+          type: ResultType.error,
+          error: opts.pendingError
+        }];
+      } else if (opts && opts.submission && isMutationMethod(opts.submission.formMethod)) {
+        // Call action if we received an action submission
+        let actionResult = await handleAction(request, location, opts.submission, matches, fogOfWar.active, {
+          replace: opts.replace,
+          flushSync
+        });
+        if (actionResult.shortCircuited) {
+          return;
+        }
+
+        // If we received a 404 from handleAction, it's because we couldn't lazily
+        // discover the destination route so we don't want to call loaders
+        if (actionResult.pendingActionResult) {
+          let [routeId, result] = actionResult.pendingActionResult;
+          if (isErrorResult(result) && isRouteErrorResponse(result.error) && result.error.status === 404) {
+            pendingNavigationController = null;
+            completeNavigation(location, {
+              matches: actionResult.matches,
+              loaderData: {},
+              errors: {
+                [routeId]: result.error
+              }
+            });
+            return;
+          }
+        }
+        matches = actionResult.matches || matches;
+        pendingActionResult = actionResult.pendingActionResult;
+        loadingNavigation = getLoadingNavigation(location, opts.submission);
+        flushSync = false;
+        // No need to do fog of war matching again on loader execution
+        fogOfWar.active = false;
+
+        // Create a GET request for the loaders
+        request = createClientSideRequest(init.history, request.url, request.signal);
+      }
+
+      // Call loaders
+      let {
+        shortCircuited,
+        matches: updatedMatches,
+        loaderData,
+        errors
+      } = await handleLoaders(request, location, matches, fogOfWar.active, loadingNavigation, opts && opts.submission, opts && opts.fetcherSubmission, opts && opts.replace, opts && opts.initialHydration === true, flushSync, pendingActionResult);
+      if (shortCircuited) {
+        return;
+      }
+
+      // Clean up now that the action/loaders have completed.  Don't clean up if
+      // we short circuited because pendingNavigationController will have already
+      // been assigned to a new controller for the next navigation
+      pendingNavigationController = null;
+      completeNavigation(location, _extends({
+        matches: updatedMatches || matches
+      }, getActionDataForCommit(pendingActionResult), {
+        loaderData,
+        errors
+      }));
+    }
+
+    // Call the action matched by the leaf route for this navigation and handle
+    // redirects/errors
+    async function handleAction(request, location, submission, matches, isFogOfWar, opts) {
+      if (opts === void 0) {
+        opts = {};
+      }
+      interruptActiveLoads();
+
+      // Put us in a submitting state
+      let navigation = getSubmittingNavigation(location, submission);
+      updateState({
+        navigation
+      }, {
+        flushSync: opts.flushSync === true
+      });
+      if (isFogOfWar) {
+        let discoverResult = await discoverRoutes(matches, location.pathname, request.signal);
+        if (discoverResult.type === "aborted") {
+          return {
+            shortCircuited: true
+          };
+        } else if (discoverResult.type === "error") {
+          let boundaryId = findNearestBoundary(discoverResult.partialMatches).route.id;
+          return {
+            matches: discoverResult.partialMatches,
+            pendingActionResult: [boundaryId, {
+              type: ResultType.error,
+              error: discoverResult.error
+            }]
+          };
+        } else if (!discoverResult.matches) {
+          let {
+            notFoundMatches,
+            error,
+            route
+          } = handleNavigational404(location.pathname);
+          return {
+            matches: notFoundMatches,
+            pendingActionResult: [route.id, {
+              type: ResultType.error,
+              error
+            }]
+          };
+        } else {
+          matches = discoverResult.matches;
+        }
+      }
+
+      // Call our action and get the result
+      let result;
+      let actionMatch = getTargetMatch(matches, location);
+      if (!actionMatch.route.action && !actionMatch.route.lazy) {
+        result = {
+          type: ResultType.error,
+          error: getInternalRouterError(405, {
+            method: request.method,
+            pathname: location.pathname,
+            routeId: actionMatch.route.id
+          })
+        };
+      } else {
+        let results = await callDataStrategy("action", state, request, [actionMatch], matches, null);
+        result = results[actionMatch.route.id];
+        if (request.signal.aborted) {
+          return {
+            shortCircuited: true
+          };
+        }
+      }
+      if (isRedirectResult(result)) {
+        let replace;
+        if (opts && opts.replace != null) {
+          replace = opts.replace;
+        } else {
+          // If the user didn't explicity indicate replace behavior, replace if
+          // we redirected to the exact same location we're currently at to avoid
+          // double back-buttons
+          let location = normalizeRedirectLocation(result.response.headers.get("Location"), new URL(request.url), basename, init.history);
+          replace = location === state.location.pathname + state.location.search;
+        }
+        await startRedirectNavigation(request, result, true, {
+          submission,
+          replace
+        });
+        return {
+          shortCircuited: true
+        };
+      }
+      if (isDeferredResult(result)) {
+        throw getInternalRouterError(400, {
+          type: "defer-action"
+        });
+      }
+      if (isErrorResult(result)) {
+        // Store off the pending error - we use it to determine which loaders
+        // to call and will commit it when we complete the navigation
+        let boundaryMatch = findNearestBoundary(matches, actionMatch.route.id);
+
+        // By default, all submissions to the current location are REPLACE
+        // navigations, but if the action threw an error that'll be rendered in
+        // an errorElement, we fall back to PUSH so that the user can use the
+        // back button to get back to the pre-submission form location to try
+        // again
+        if ((opts && opts.replace) !== true) {
+          pendingAction = Action.Push;
+        }
+        return {
+          matches,
+          pendingActionResult: [boundaryMatch.route.id, result]
+        };
+      }
+      return {
+        matches,
+        pendingActionResult: [actionMatch.route.id, result]
+      };
+    }
+
+    // Call all applicable loaders for the given matches, handling redirects,
+    // errors, etc.
+    async function handleLoaders(request, location, matches, isFogOfWar, overrideNavigation, submission, fetcherSubmission, replace, initialHydration, flushSync, pendingActionResult) {
+      // Figure out the right navigation we want to use for data loading
+      let loadingNavigation = overrideNavigation || getLoadingNavigation(location, submission);
+
+      // If this was a redirect from an action we don't have a "submission" but
+      // we have it on the loading navigation so use that if available
+      let activeSubmission = submission || fetcherSubmission || getSubmissionFromNavigation(loadingNavigation);
+
+      // If this is an uninterrupted revalidation, we remain in our current idle
+      // state.  If not, we need to switch to our loading state and load data,
+      // preserving any new action data or existing action data (in the case of
+      // a revalidation interrupting an actionReload)
+      // If we have partialHydration enabled, then don't update the state for the
+      // initial data load since it's not a "navigation"
+      let shouldUpdateNavigationState = !isUninterruptedRevalidation && (!future.v7_partialHydration || !initialHydration);
+
+      // When fog of war is enabled, we enter our `loading` state earlier so we
+      // can discover new routes during the `loading` state.  We skip this if
+      // we've already run actions since we would have done our matching already.
+      // If the children() function threw then, we want to proceed with the
+      // partial matches it discovered.
+      if (isFogOfWar) {
+        if (shouldUpdateNavigationState) {
+          let actionData = getUpdatedActionData(pendingActionResult);
+          updateState(_extends({
+            navigation: loadingNavigation
+          }, actionData !== undefined ? {
+            actionData
+          } : {}), {
+            flushSync
+          });
+        }
+        let discoverResult = await discoverRoutes(matches, location.pathname, request.signal);
+        if (discoverResult.type === "aborted") {
+          return {
+            shortCircuited: true
+          };
+        } else if (discoverResult.type === "error") {
+          let boundaryId = findNearestBoundary(discoverResult.partialMatches).route.id;
+          return {
+            matches: discoverResult.partialMatches,
+            loaderData: {},
+            errors: {
+              [boundaryId]: discoverResult.error
+            }
+          };
+        } else if (!discoverResult.matches) {
+          let {
+            error,
+            notFoundMatches,
+            route
+          } = handleNavigational404(location.pathname);
+          return {
+            matches: notFoundMatches,
+            loaderData: {},
+            errors: {
+              [route.id]: error
+            }
+          };
+        } else {
+          matches = discoverResult.matches;
+        }
+      }
+      let routesToUse = inFlightDataRoutes || dataRoutes;
+      let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(init.history, state, matches, activeSubmission, location, future.v7_partialHydration && initialHydration === true, future.v7_skipActionErrorRevalidation, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, deletedFetchers, fetchLoadMatches, fetchRedirectIds, routesToUse, basename, pendingActionResult);
+
+      // Cancel pending deferreds for no-longer-matched routes or routes we're
+      // about to reload.  Note that if this is an action reload we would have
+      // already cancelled all pending deferreds so this would be a no-op
+      cancelActiveDeferreds(routeId => !(matches && matches.some(m => m.route.id === routeId)) || matchesToLoad && matchesToLoad.some(m => m.route.id === routeId));
+      pendingNavigationLoadId = ++incrementingLoadId;
+
+      // Short circuit if we have no loaders to run
+      if (matchesToLoad.length === 0 && revalidatingFetchers.length === 0) {
+        let updatedFetchers = markFetchRedirectsDone();
+        completeNavigation(location, _extends({
+          matches,
+          loaderData: {},
+          // Commit pending error if we're short circuiting
+          errors: pendingActionResult && isErrorResult(pendingActionResult[1]) ? {
+            [pendingActionResult[0]]: pendingActionResult[1].error
+          } : null
+        }, getActionDataForCommit(pendingActionResult), updatedFetchers ? {
+          fetchers: new Map(state.fetchers)
+        } : {}), {
+          flushSync
+        });
+        return {
+          shortCircuited: true
+        };
+      }
+      if (shouldUpdateNavigationState) {
+        let updates = {};
+        if (!isFogOfWar) {
+          // Only update navigation/actionNData if we didn't already do it above
+          updates.navigation = loadingNavigation;
+          let actionData = getUpdatedActionData(pendingActionResult);
+          if (actionData !== undefined) {
+            updates.actionData = actionData;
+          }
+        }
+        if (revalidatingFetchers.length > 0) {
+          updates.fetchers = getUpdatedRevalidatingFetchers(revalidatingFetchers);
+        }
+        updateState(updates, {
+          flushSync
+        });
+      }
+      revalidatingFetchers.forEach(rf => {
+        abortFetcher(rf.key);
+        if (rf.controller) {
+          // Fetchers use an independent AbortController so that aborting a fetcher
+          // (via deleteFetcher) does not abort the triggering navigation that
+          // triggered the revalidation
+          fetchControllers.set(rf.key, rf.controller);
+        }
+      });
+
+      // Proxy navigation abort through to revalidation fetchers
+      let abortPendingFetchRevalidations = () => revalidatingFetchers.forEach(f => abortFetcher(f.key));
+      if (pendingNavigationController) {
+        pendingNavigationController.signal.addEventListener("abort", abortPendingFetchRevalidations);
+      }
+      let {
+        loaderResults,
+        fetcherResults
+      } = await callLoadersAndMaybeResolveData(state, matches, matchesToLoad, revalidatingFetchers, request);
+      if (request.signal.aborted) {
+        return {
+          shortCircuited: true
+        };
+      }
+
+      // Clean up _after_ loaders have completed.  Don't clean up if we short
+      // circuited because fetchControllers would have been aborted and
+      // reassigned to new controllers for the next navigation
+      if (pendingNavigationController) {
+        pendingNavigationController.signal.removeEventListener("abort", abortPendingFetchRevalidations);
+      }
+      revalidatingFetchers.forEach(rf => fetchControllers.delete(rf.key));
+
+      // If any loaders returned a redirect Response, start a new REPLACE navigation
+      let redirect = findRedirect(loaderResults);
+      if (redirect) {
+        await startRedirectNavigation(request, redirect.result, true, {
+          replace
+        });
+        return {
+          shortCircuited: true
+        };
+      }
+      redirect = findRedirect(fetcherResults);
+      if (redirect) {
+        // If this redirect came from a fetcher make sure we mark it in
+        // fetchRedirectIds so it doesn't get revalidated on the next set of
+        // loader executions
+        fetchRedirectIds.add(redirect.key);
+        await startRedirectNavigation(request, redirect.result, true, {
+          replace
+        });
+        return {
+          shortCircuited: true
+        };
+      }
+
+      // Process and commit output from loaders
+      let {
+        loaderData,
+        errors
+      } = processLoaderData(state, matches, loaderResults, pendingActionResult, revalidatingFetchers, fetcherResults, activeDeferreds);
+
+      // Wire up subscribers to update loaderData as promises settle
+      activeDeferreds.forEach((deferredData, routeId) => {
+        deferredData.subscribe(aborted => {
+          // Note: No need to updateState here since the TrackedPromise on
+          // loaderData is stable across resolve/reject
+          // Remove this instance if we were aborted or if promises have settled
+          if (aborted || deferredData.done) {
+            activeDeferreds.delete(routeId);
+          }
+        });
+      });
+
+      // Preserve SSR errors during partial hydration
+      if (future.v7_partialHydration && initialHydration && state.errors) {
+        errors = _extends({}, state.errors, errors);
+      }
+      let updatedFetchers = markFetchRedirectsDone();
+      let didAbortFetchLoads = abortStaleFetchLoads(pendingNavigationLoadId);
+      let shouldUpdateFetchers = updatedFetchers || didAbortFetchLoads || revalidatingFetchers.length > 0;
+      return _extends({
+        matches,
+        loaderData,
+        errors
+      }, shouldUpdateFetchers ? {
+        fetchers: new Map(state.fetchers)
+      } : {});
+    }
+    function getUpdatedActionData(pendingActionResult) {
+      if (pendingActionResult && !isErrorResult(pendingActionResult[1])) {
+        // This is cast to `any` currently because `RouteData`uses any and it
+        // would be a breaking change to use any.
+        // TODO: v7 - change `RouteData` to use `unknown` instead of `any`
+        return {
+          [pendingActionResult[0]]: pendingActionResult[1].data
+        };
+      } else if (state.actionData) {
+        if (Object.keys(state.actionData).length === 0) {
+          return null;
+        } else {
+          return state.actionData;
+        }
+      }
+    }
+    function getUpdatedRevalidatingFetchers(revalidatingFetchers) {
+      revalidatingFetchers.forEach(rf => {
+        let fetcher = state.fetchers.get(rf.key);
+        let revalidatingFetcher = getLoadingFetcher(undefined, fetcher ? fetcher.data : undefined);
+        state.fetchers.set(rf.key, revalidatingFetcher);
+      });
+      return new Map(state.fetchers);
+    }
+
+    // Trigger a fetcher load/submit for the given fetcher key
+    function fetch(key, routeId, href, opts) {
+      if (isServer) {
+        throw new Error("router.fetch() was called during the server render, but it shouldn't be. " + "You are likely calling a useFetcher() method in the body of your component. " + "Try moving it to a useEffect or a callback.");
+      }
+      abortFetcher(key);
+      let flushSync = (opts && opts.flushSync) === true;
+      let routesToUse = inFlightDataRoutes || dataRoutes;
+      let normalizedPath = normalizeTo(state.location, state.matches, basename, future.v7_prependBasename, href, future.v7_relativeSplatPath, routeId, opts == null ? void 0 : opts.relative);
+      let matches = matchRoutes(routesToUse, normalizedPath, basename);
+      let fogOfWar = checkFogOfWar(matches, routesToUse, normalizedPath);
+      if (fogOfWar.active && fogOfWar.matches) {
+        matches = fogOfWar.matches;
+      }
+      if (!matches) {
+        setFetcherError(key, routeId, getInternalRouterError(404, {
+          pathname: normalizedPath
+        }), {
+          flushSync
+        });
+        return;
+      }
+      let {
+        path,
+        submission,
+        error
+      } = normalizeNavigateOptions(future.v7_normalizeFormMethod, true, normalizedPath, opts);
+      if (error) {
+        setFetcherError(key, routeId, error, {
+          flushSync
+        });
+        return;
+      }
+      let match = getTargetMatch(matches, path);
+      let preventScrollReset = (opts && opts.preventScrollReset) === true;
+      if (submission && isMutationMethod(submission.formMethod)) {
+        handleFetcherAction(key, routeId, path, match, matches, fogOfWar.active, flushSync, preventScrollReset, submission);
+        return;
+      }
+
+      // Store off the match so we can call it's shouldRevalidate on subsequent
+      // revalidations
+      fetchLoadMatches.set(key, {
+        routeId,
+        path
+      });
+      handleFetcherLoader(key, routeId, path, match, matches, fogOfWar.active, flushSync, preventScrollReset, submission);
+    }
+
+    // Call the action for the matched fetcher.submit(), and then handle redirects,
+    // errors, and revalidation
+    async function handleFetcherAction(key, routeId, path, match, requestMatches, isFogOfWar, flushSync, preventScrollReset, submission) {
+      interruptActiveLoads();
+      fetchLoadMatches.delete(key);
+      function detectAndHandle405Error(m) {
+        if (!m.route.action && !m.route.lazy) {
+          let error = getInternalRouterError(405, {
+            method: submission.formMethod,
+            pathname: path,
+            routeId: routeId
+          });
+          setFetcherError(key, routeId, error, {
+            flushSync
+          });
+          return true;
+        }
+        return false;
+      }
+      if (!isFogOfWar && detectAndHandle405Error(match)) {
+        return;
+      }
+
+      // Put this fetcher into it's submitting state
+      let existingFetcher = state.fetchers.get(key);
+      updateFetcherState(key, getSubmittingFetcher(submission, existingFetcher), {
+        flushSync
+      });
+      let abortController = new AbortController();
+      let fetchRequest = createClientSideRequest(init.history, path, abortController.signal, submission);
+      if (isFogOfWar) {
+        let discoverResult = await discoverRoutes(requestMatches, new URL(fetchRequest.url).pathname, fetchRequest.signal, key);
+        if (discoverResult.type === "aborted") {
+          return;
+        } else if (discoverResult.type === "error") {
+          setFetcherError(key, routeId, discoverResult.error, {
+            flushSync
+          });
+          return;
+        } else if (!discoverResult.matches) {
+          setFetcherError(key, routeId, getInternalRouterError(404, {
+            pathname: path
+          }), {
+            flushSync
+          });
+          return;
+        } else {
+          requestMatches = discoverResult.matches;
+          match = getTargetMatch(requestMatches, path);
+          if (detectAndHandle405Error(match)) {
+            return;
+          }
+        }
+      }
+
+      // Call the action for the fetcher
+      fetchControllers.set(key, abortController);
+      let originatingLoadId = incrementingLoadId;
+      let actionResults = await callDataStrategy("action", state, fetchRequest, [match], requestMatches, key);
+      let actionResult = actionResults[match.route.id];
+      if (fetchRequest.signal.aborted) {
+        // We can delete this so long as we weren't aborted by our own fetcher
+        // re-submit which would have put _new_ controller is in fetchControllers
+        if (fetchControllers.get(key) === abortController) {
+          fetchControllers.delete(key);
+        }
+        return;
+      }
+
+      // When using v7_fetcherPersist, we don't want errors bubbling up to the UI
+      // or redirects processed for unmounted fetchers so we just revert them to
+      // idle
+      if (future.v7_fetcherPersist && deletedFetchers.has(key)) {
+        if (isRedirectResult(actionResult) || isErrorResult(actionResult)) {
+          updateFetcherState(key, getDoneFetcher(undefined));
+          return;
+        }
+        // Let SuccessResult's fall through for revalidation
+      } else {
+        if (isRedirectResult(actionResult)) {
+          fetchControllers.delete(key);
+          if (pendingNavigationLoadId > originatingLoadId) {
+            // A new navigation was kicked off after our action started, so that
+            // should take precedence over this redirect navigation.  We already
+            // set isRevalidationRequired so all loaders for the new route should
+            // fire unless opted out via shouldRevalidate
+            updateFetcherState(key, getDoneFetcher(undefined));
+            return;
+          } else {
+            fetchRedirectIds.add(key);
+            updateFetcherState(key, getLoadingFetcher(submission));
+            return startRedirectNavigation(fetchRequest, actionResult, false, {
+              fetcherSubmission: submission,
+              preventScrollReset
+            });
+          }
+        }
+
+        // Process any non-redirect errors thrown
+        if (isErrorResult(actionResult)) {
+          setFetcherError(key, routeId, actionResult.error);
+          return;
+        }
+      }
+      if (isDeferredResult(actionResult)) {
+        throw getInternalRouterError(400, {
+          type: "defer-action"
+        });
+      }
+
+      // Start the data load for current matches, or the next location if we're
+      // in the middle of a navigation
+      let nextLocation = state.navigation.location || state.location;
+      let revalidationRequest = createClientSideRequest(init.history, nextLocation, abortController.signal);
+      let routesToUse = inFlightDataRoutes || dataRoutes;
+      let matches = state.navigation.state !== "idle" ? matchRoutes(routesToUse, state.navigation.location, basename) : state.matches;
+      invariant(matches, "Didn't find any matches after fetcher action");
+      let loadId = ++incrementingLoadId;
+      fetchReloadIds.set(key, loadId);
+      let loadFetcher = getLoadingFetcher(submission, actionResult.data);
+      state.fetchers.set(key, loadFetcher);
+      let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(init.history, state, matches, submission, nextLocation, false, future.v7_skipActionErrorRevalidation, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, deletedFetchers, fetchLoadMatches, fetchRedirectIds, routesToUse, basename, [match.route.id, actionResult]);
+
+      // Put all revalidating fetchers into the loading state, except for the
+      // current fetcher which we want to keep in it's current loading state which
+      // contains it's action submission info + action data
+      revalidatingFetchers.filter(rf => rf.key !== key).forEach(rf => {
+        let staleKey = rf.key;
+        let existingFetcher = state.fetchers.get(staleKey);
+        let revalidatingFetcher = getLoadingFetcher(undefined, existingFetcher ? existingFetcher.data : undefined);
+        state.fetchers.set(staleKey, revalidatingFetcher);
+        abortFetcher(staleKey);
+        if (rf.controller) {
+          fetchControllers.set(staleKey, rf.controller);
+        }
+      });
+      updateState({
+        fetchers: new Map(state.fetchers)
+      });
+      let abortPendingFetchRevalidations = () => revalidatingFetchers.forEach(rf => abortFetcher(rf.key));
+      abortController.signal.addEventListener("abort", abortPendingFetchRevalidations);
+      let {
+        loaderResults,
+        fetcherResults
+      } = await callLoadersAndMaybeResolveData(state, matches, matchesToLoad, revalidatingFetchers, revalidationRequest);
+      if (abortController.signal.aborted) {
+        return;
+      }
+      abortController.signal.removeEventListener("abort", abortPendingFetchRevalidations);
+      fetchReloadIds.delete(key);
+      fetchControllers.delete(key);
+      revalidatingFetchers.forEach(r => fetchControllers.delete(r.key));
+      let redirect = findRedirect(loaderResults);
+      if (redirect) {
+        return startRedirectNavigation(revalidationRequest, redirect.result, false, {
+          preventScrollReset
+        });
+      }
+      redirect = findRedirect(fetcherResults);
+      if (redirect) {
+        // If this redirect came from a fetcher make sure we mark it in
+        // fetchRedirectIds so it doesn't get revalidated on the next set of
+        // loader executions
+        fetchRedirectIds.add(redirect.key);
+        return startRedirectNavigation(revalidationRequest, redirect.result, false, {
+          preventScrollReset
+        });
+      }
+
+      // Process and commit output from loaders
+      let {
+        loaderData,
+        errors
+      } = processLoaderData(state, matches, loaderResults, undefined, revalidatingFetchers, fetcherResults, activeDeferreds);
+
+      // Since we let revalidations complete even if the submitting fetcher was
+      // deleted, only put it back to idle if it hasn't been deleted
+      if (state.fetchers.has(key)) {
+        let doneFetcher = getDoneFetcher(actionResult.data);
+        state.fetchers.set(key, doneFetcher);
+      }
+      abortStaleFetchLoads(loadId);
+
+      // If we are currently in a navigation loading state and this fetcher is
+      // more recent than the navigation, we want the newer data so abort the
+      // navigation and complete it with the fetcher data
+      if (state.navigation.state === "loading" && loadId > pendingNavigationLoadId) {
+        invariant(pendingAction, "Expected pending action");
+        pendingNavigationController && pendingNavigationController.abort();
+        completeNavigation(state.navigation.location, {
+          matches,
+          loaderData,
+          errors,
+          fetchers: new Map(state.fetchers)
+        });
+      } else {
+        // otherwise just update with the fetcher data, preserving any existing
+        // loaderData for loaders that did not need to reload.  We have to
+        // manually merge here since we aren't going through completeNavigation
+        updateState({
+          errors,
+          loaderData: mergeLoaderData(state.loaderData, loaderData, matches, errors),
+          fetchers: new Map(state.fetchers)
+        });
+        isRevalidationRequired = false;
+      }
+    }
+
+    // Call the matched loader for fetcher.load(), handling redirects, errors, etc.
+    async function handleFetcherLoader(key, routeId, path, match, matches, isFogOfWar, flushSync, preventScrollReset, submission) {
+      let existingFetcher = state.fetchers.get(key);
+      updateFetcherState(key, getLoadingFetcher(submission, existingFetcher ? existingFetcher.data : undefined), {
+        flushSync
+      });
+      let abortController = new AbortController();
+      let fetchRequest = createClientSideRequest(init.history, path, abortController.signal);
+      if (isFogOfWar) {
+        let discoverResult = await discoverRoutes(matches, new URL(fetchRequest.url).pathname, fetchRequest.signal, key);
+        if (discoverResult.type === "aborted") {
+          return;
+        } else if (discoverResult.type === "error") {
+          setFetcherError(key, routeId, discoverResult.error, {
+            flushSync
+          });
+          return;
+        } else if (!discoverResult.matches) {
+          setFetcherError(key, routeId, getInternalRouterError(404, {
+            pathname: path
+          }), {
+            flushSync
+          });
+          return;
+        } else {
+          matches = discoverResult.matches;
+          match = getTargetMatch(matches, path);
+        }
+      }
+
+      // Call the loader for this fetcher route match
+      fetchControllers.set(key, abortController);
+      let originatingLoadId = incrementingLoadId;
+      let results = await callDataStrategy("loader", state, fetchRequest, [match], matches, key);
+      let result = results[match.route.id];
+
+      // Deferred isn't supported for fetcher loads, await everything and treat it
+      // as a normal load.  resolveDeferredData will return undefined if this
+      // fetcher gets aborted, so we just leave result untouched and short circuit
+      // below if that happens
+      if (isDeferredResult(result)) {
+        result = (await resolveDeferredData(result, fetchRequest.signal, true)) || result;
+      }
+
+      // We can delete this so long as we weren't aborted by our our own fetcher
+      // re-load which would have put _new_ controller is in fetchControllers
+      if (fetchControllers.get(key) === abortController) {
+        fetchControllers.delete(key);
+      }
+      if (fetchRequest.signal.aborted) {
+        return;
+      }
+
+      // We don't want errors bubbling up or redirects followed for unmounted
+      // fetchers, so short circuit here if it was removed from the UI
+      if (deletedFetchers.has(key)) {
+        updateFetcherState(key, getDoneFetcher(undefined));
+        return;
+      }
+
+      // If the loader threw a redirect Response, start a new REPLACE navigation
+      if (isRedirectResult(result)) {
+        if (pendingNavigationLoadId > originatingLoadId) {
+          // A new navigation was kicked off after our loader started, so that
+          // should take precedence over this redirect navigation
+          updateFetcherState(key, getDoneFetcher(undefined));
+          return;
+        } else {
+          fetchRedirectIds.add(key);
+          await startRedirectNavigation(fetchRequest, result, false, {
+            preventScrollReset
+          });
+          return;
+        }
+      }
+
+      // Process any non-redirect errors thrown
+      if (isErrorResult(result)) {
+        setFetcherError(key, routeId, result.error);
+        return;
+      }
+      invariant(!isDeferredResult(result), "Unhandled fetcher deferred data");
+
+      // Put the fetcher back into an idle state
+      updateFetcherState(key, getDoneFetcher(result.data));
+    }
+
+    /**
+     * Utility function to handle redirects returned from an action or loader.
+     * Normally, a redirect "replaces" the navigation that triggered it.  So, for
+     * example:
+     *
+     *  - user is on /a
+     *  - user clicks a link to /b
+     *  - loader for /b redirects to /c
+     *
+     * In a non-JS app the browser would track the in-flight navigation to /b and
+     * then replace it with /c when it encountered the redirect response.  In
+     * the end it would only ever update the URL bar with /c.
+     *
+     * In client-side routing using pushState/replaceState, we aim to emulate
+     * this behavior and we also do not update history until the end of the
+     * navigation (including processed redirects).  This means that we never
+     * actually touch history until we've processed redirects, so we just use
+     * the history action from the original navigation (PUSH or REPLACE).
+     */
+    async function startRedirectNavigation(request, redirect, isNavigation, _temp2) {
+      let {
+        submission,
+        fetcherSubmission,
+        preventScrollReset,
+        replace
+      } = _temp2 === void 0 ? {} : _temp2;
+      if (redirect.response.headers.has("X-Remix-Revalidate")) {
+        isRevalidationRequired = true;
+      }
+      let location = redirect.response.headers.get("Location");
+      invariant(location, "Expected a Location header on the redirect Response");
+      location = normalizeRedirectLocation(location, new URL(request.url), basename, init.history);
+      let redirectLocation = createLocation(state.location, location, {
+        _isRedirect: true
+      });
+      if (isBrowser) {
+        let isDocumentReload = false;
+        if (redirect.response.headers.has("X-Remix-Reload-Document")) {
+          // Hard reload if the response contained X-Remix-Reload-Document
+          isDocumentReload = true;
+        } else if (ABSOLUTE_URL_REGEX.test(location)) {
+          const url = init.history.createURL(location);
+          isDocumentReload =
+          // Hard reload if it's an absolute URL to a new origin
+          url.origin !== routerWindow.location.origin ||
+          // Hard reload if it's an absolute URL that does not match our basename
+          stripBasename(url.pathname, basename) == null;
+        }
+        if (isDocumentReload) {
+          if (replace) {
+            routerWindow.location.replace(location);
+          } else {
+            routerWindow.location.assign(location);
+          }
+          return;
+        }
+      }
+
+      // There's no need to abort on redirects, since we don't detect the
+      // redirect until the action/loaders have settled
+      pendingNavigationController = null;
+      let redirectHistoryAction = replace === true || redirect.response.headers.has("X-Remix-Replace") ? Action.Replace : Action.Push;
+
+      // Use the incoming submission if provided, fallback on the active one in
+      // state.navigation
+      let {
+        formMethod,
+        formAction,
+        formEncType
+      } = state.navigation;
+      if (!submission && !fetcherSubmission && formMethod && formAction && formEncType) {
+        submission = getSubmissionFromNavigation(state.navigation);
+      }
+
+      // If this was a 307/308 submission we want to preserve the HTTP method and
+      // re-submit the GET/POST/PUT/PATCH/DELETE as a submission navigation to the
+      // redirected location
+      let activeSubmission = submission || fetcherSubmission;
+      if (redirectPreserveMethodStatusCodes.has(redirect.response.status) && activeSubmission && isMutationMethod(activeSubmission.formMethod)) {
+        await startNavigation(redirectHistoryAction, redirectLocation, {
+          submission: _extends({}, activeSubmission, {
+            formAction: location
+          }),
+          // Preserve these flags across redirects
+          preventScrollReset: preventScrollReset || pendingPreventScrollReset,
+          enableViewTransition: isNavigation ? pendingViewTransitionEnabled : undefined
+        });
+      } else {
+        // If we have a navigation submission, we will preserve it through the
+        // redirect navigation
+        let overrideNavigation = getLoadingNavigation(redirectLocation, submission);
+        await startNavigation(redirectHistoryAction, redirectLocation, {
+          overrideNavigation,
+          // Send fetcher submissions through for shouldRevalidate
+          fetcherSubmission,
+          // Preserve these flags across redirects
+          preventScrollReset: preventScrollReset || pendingPreventScrollReset,
+          enableViewTransition: isNavigation ? pendingViewTransitionEnabled : undefined
+        });
+      }
+    }
+
+    // Utility wrapper for calling dataStrategy client-side without having to
+    // pass around the manifest, mapRouteProperties, etc.
+    async function callDataStrategy(type, state, request, matchesToLoad, matches, fetcherKey) {
+      let results;
+      let dataResults = {};
+      try {
+        results = await callDataStrategyImpl(dataStrategyImpl, type, state, request, matchesToLoad, matches, fetcherKey, manifest, mapRouteProperties);
+      } catch (e) {
+        // If the outer dataStrategy method throws, just return the error for all
+        // matches - and it'll naturally bubble to the root
+        matchesToLoad.forEach(m => {
+          dataResults[m.route.id] = {
+            type: ResultType.error,
+            error: e
+          };
+        });
+        return dataResults;
+      }
+      for (let [routeId, result] of Object.entries(results)) {
+        if (isRedirectDataStrategyResultResult(result)) {
+          let response = result.result;
+          dataResults[routeId] = {
+            type: ResultType.redirect,
+            response: normalizeRelativeRoutingRedirectResponse(response, request, routeId, matches, basename, future.v7_relativeSplatPath)
+          };
+        } else {
+          dataResults[routeId] = await convertDataStrategyResultToDataResult(result);
+        }
+      }
+      return dataResults;
+    }
+    async function callLoadersAndMaybeResolveData(state, matches, matchesToLoad, fetchersToLoad, request) {
+      let currentMatches = state.matches;
+
+      // Kick off loaders and fetchers in parallel
+      let loaderResultsPromise = callDataStrategy("loader", state, request, matchesToLoad, matches, null);
+      let fetcherResultsPromise = Promise.all(fetchersToLoad.map(async f => {
+        if (f.matches && f.match && f.controller) {
+          let results = await callDataStrategy("loader", state, createClientSideRequest(init.history, f.path, f.controller.signal), [f.match], f.matches, f.key);
+          let result = results[f.match.route.id];
+          // Fetcher results are keyed by fetcher key from here on out, not routeId
+          return {
+            [f.key]: result
+          };
+        } else {
+          return Promise.resolve({
+            [f.key]: {
+              type: ResultType.error,
+              error: getInternalRouterError(404, {
+                pathname: f.path
+              })
+            }
+          });
+        }
+      }));
+      let loaderResults = await loaderResultsPromise;
+      let fetcherResults = (await fetcherResultsPromise).reduce((acc, r) => Object.assign(acc, r), {});
+      await Promise.all([resolveNavigationDeferredResults(matches, loaderResults, request.signal, currentMatches, state.loaderData), resolveFetcherDeferredResults(matches, fetcherResults, fetchersToLoad)]);
+      return {
+        loaderResults,
+        fetcherResults
+      };
+    }
+    function interruptActiveLoads() {
+      // Every interruption triggers a revalidation
+      isRevalidationRequired = true;
+
+      // Cancel pending route-level deferreds and mark cancelled routes for
+      // revalidation
+      cancelledDeferredRoutes.push(...cancelActiveDeferreds());
+
+      // Abort in-flight fetcher loads
+      fetchLoadMatches.forEach((_, key) => {
+        if (fetchControllers.has(key)) {
+          cancelledFetcherLoads.add(key);
+        }
+        abortFetcher(key);
+      });
+    }
+    function updateFetcherState(key, fetcher, opts) {
+      if (opts === void 0) {
+        opts = {};
+      }
+      state.fetchers.set(key, fetcher);
+      updateState({
+        fetchers: new Map(state.fetchers)
+      }, {
+        flushSync: (opts && opts.flushSync) === true
+      });
+    }
+    function setFetcherError(key, routeId, error, opts) {
+      if (opts === void 0) {
+        opts = {};
+      }
+      let boundaryMatch = findNearestBoundary(state.matches, routeId);
+      deleteFetcher(key);
+      updateState({
+        errors: {
+          [boundaryMatch.route.id]: error
+        },
+        fetchers: new Map(state.fetchers)
+      }, {
+        flushSync: (opts && opts.flushSync) === true
+      });
+    }
+    function getFetcher(key) {
+      activeFetchers.set(key, (activeFetchers.get(key) || 0) + 1);
+      // If this fetcher was previously marked for deletion, unmark it since we
+      // have a new instance
+      if (deletedFetchers.has(key)) {
+        deletedFetchers.delete(key);
+      }
+      return state.fetchers.get(key) || IDLE_FETCHER;
+    }
+    function deleteFetcher(key) {
+      let fetcher = state.fetchers.get(key);
+      // Don't abort the controller if this is a deletion of a fetcher.submit()
+      // in it's loading phase since - we don't want to abort the corresponding
+      // revalidation and want them to complete and land
+      if (fetchControllers.has(key) && !(fetcher && fetcher.state === "loading" && fetchReloadIds.has(key))) {
+        abortFetcher(key);
+      }
+      fetchLoadMatches.delete(key);
+      fetchReloadIds.delete(key);
+      fetchRedirectIds.delete(key);
+
+      // If we opted into the flag we can clear this now since we're calling
+      // deleteFetcher() at the end of updateState() and we've already handed the
+      // deleted fetcher keys off to the data layer.
+      // If not, we're eagerly calling deleteFetcher() and we need to keep this
+      // Set populated until the next updateState call, and we'll clear
+      // `deletedFetchers` then
+      if (future.v7_fetcherPersist) {
+        deletedFetchers.delete(key);
+      }
+      cancelledFetcherLoads.delete(key);
+      state.fetchers.delete(key);
+    }
+    function deleteFetcherAndUpdateState(key) {
+      let count = (activeFetchers.get(key) || 0) - 1;
+      if (count <= 0) {
+        activeFetchers.delete(key);
+        deletedFetchers.add(key);
+        if (!future.v7_fetcherPersist) {
+          deleteFetcher(key);
+        }
+      } else {
+        activeFetchers.set(key, count);
+      }
+      updateState({
+        fetchers: new Map(state.fetchers)
+      });
+    }
+    function abortFetcher(key) {
+      let controller = fetchControllers.get(key);
+      if (controller) {
+        controller.abort();
+        fetchControllers.delete(key);
+      }
+    }
+    function markFetchersDone(keys) {
+      for (let key of keys) {
+        let fetcher = getFetcher(key);
+        let doneFetcher = getDoneFetcher(fetcher.data);
+        state.fetchers.set(key, doneFetcher);
+      }
+    }
+    function markFetchRedirectsDone() {
+      let doneKeys = [];
+      let updatedFetchers = false;
+      for (let key of fetchRedirectIds) {
+        let fetcher = state.fetchers.get(key);
+        invariant(fetcher, "Expected fetcher: " + key);
+        if (fetcher.state === "loading") {
+          fetchRedirectIds.delete(key);
+          doneKeys.push(key);
+          updatedFetchers = true;
+        }
+      }
+      markFetchersDone(doneKeys);
+      return updatedFetchers;
+    }
+    function abortStaleFetchLoads(landedId) {
+      let yeetedKeys = [];
+      for (let [key, id] of fetchReloadIds) {
+        if (id < landedId) {
+          let fetcher = state.fetchers.get(key);
+          invariant(fetcher, "Expected fetcher: " + key);
+          if (fetcher.state === "loading") {
+            abortFetcher(key);
+            fetchReloadIds.delete(key);
+            yeetedKeys.push(key);
+          }
+        }
+      }
+      markFetchersDone(yeetedKeys);
+      return yeetedKeys.length > 0;
+    }
+    function getBlocker(key, fn) {
+      let blocker = state.blockers.get(key) || IDLE_BLOCKER;
+      if (blockerFunctions.get(key) !== fn) {
+        blockerFunctions.set(key, fn);
+      }
+      return blocker;
+    }
+    function deleteBlocker(key) {
+      state.blockers.delete(key);
+      blockerFunctions.delete(key);
+    }
+
+    // Utility function to update blockers, ensuring valid state transitions
+    function updateBlocker(key, newBlocker) {
+      let blocker = state.blockers.get(key) || IDLE_BLOCKER;
+
+      // Poor mans state machine :)
+      // https://mermaid.live/edit#pako:eNqVkc9OwzAMxl8l8nnjAYrEtDIOHEBIgwvKJTReGy3_lDpIqO27k6awMG0XcrLlnz87nwdonESogKXXBuE79rq75XZO3-yHds0RJVuv70YrPlUrCEe2HfrORS3rubqZfuhtpg5C9wk5tZ4VKcRUq88q9Z8RS0-48cE1iHJkL0ugbHuFLus9L6spZy8nX9MP2CNdomVaposqu3fGayT8T8-jJQwhepo_UtpgBQaDEUom04dZhAN1aJBDlUKJBxE1ceB2Smj0Mln-IBW5AFU2dwUiktt_2Qaq2dBfaKdEup85UV7Yd-dKjlnkabl2Pvr0DTkTreM
+      invariant(blocker.state === "unblocked" && newBlocker.state === "blocked" || blocker.state === "blocked" && newBlocker.state === "blocked" || blocker.state === "blocked" && newBlocker.state === "proceeding" || blocker.state === "blocked" && newBlocker.state === "unblocked" || blocker.state === "proceeding" && newBlocker.state === "unblocked", "Invalid blocker state transition: " + blocker.state + " -> " + newBlocker.state);
+      let blockers = new Map(state.blockers);
+      blockers.set(key, newBlocker);
+      updateState({
+        blockers
+      });
+    }
+    function shouldBlockNavigation(_ref2) {
+      let {
+        currentLocation,
+        nextLocation,
+        historyAction
+      } = _ref2;
+      if (blockerFunctions.size === 0) {
+        return;
+      }
+
+      // We ony support a single active blocker at the moment since we don't have
+      // any compelling use cases for multi-blocker yet
+      if (blockerFunctions.size > 1) {
+        warning(false, "A router only supports one blocker at a time");
+      }
+      let entries = Array.from(blockerFunctions.entries());
+      let [blockerKey, blockerFunction] = entries[entries.length - 1];
+      let blocker = state.blockers.get(blockerKey);
+      if (blocker && blocker.state === "proceeding") {
+        // If the blocker is currently proceeding, we don't need to re-check
+        // it and can let this navigation continue
+        return;
+      }
+
+      // At this point, we know we're unblocked/blocked so we need to check the
+      // user-provided blocker function
+      if (blockerFunction({
+        currentLocation,
+        nextLocation,
+        historyAction
+      })) {
+        return blockerKey;
+      }
+    }
+    function handleNavigational404(pathname) {
+      let error = getInternalRouterError(404, {
+        pathname
+      });
+      let routesToUse = inFlightDataRoutes || dataRoutes;
+      let {
+        matches,
+        route
+      } = getShortCircuitMatches(routesToUse);
+
+      // Cancel all pending deferred on 404s since we don't keep any routes
+      cancelActiveDeferreds();
+      return {
+        notFoundMatches: matches,
+        route,
+        error
+      };
+    }
+    function cancelActiveDeferreds(predicate) {
+      let cancelledRouteIds = [];
+      activeDeferreds.forEach((dfd, routeId) => {
+        if (!predicate || predicate(routeId)) {
+          // Cancel the deferred - but do not remove from activeDeferreds here -
+          // we rely on the subscribers to do that so our tests can assert proper
+          // cleanup via _internalActiveDeferreds
+          dfd.cancel();
+          cancelledRouteIds.push(routeId);
+          activeDeferreds.delete(routeId);
+        }
+      });
+      return cancelledRouteIds;
+    }
+
+    // Opt in to capturing and reporting scroll positions during navigations,
+    // used by the <ScrollRestoration> component
+    function enableScrollRestoration(positions, getPosition, getKey) {
+      savedScrollPositions = positions;
+      getScrollPosition = getPosition;
+      getScrollRestorationKey = getKey || null;
+
+      // Perform initial hydration scroll restoration, since we miss the boat on
+      // the initial updateState() because we've not yet rendered <ScrollRestoration/>
+      // and therefore have no savedScrollPositions available
+      if (!initialScrollRestored && state.navigation === IDLE_NAVIGATION) {
+        initialScrollRestored = true;
+        let y = getSavedScrollPosition(state.location, state.matches);
+        if (y != null) {
+          updateState({
+            restoreScrollPosition: y
+          });
+        }
+      }
+      return () => {
+        savedScrollPositions = null;
+        getScrollPosition = null;
+        getScrollRestorationKey = null;
+      };
+    }
+    function getScrollKey(location, matches) {
+      if (getScrollRestorationKey) {
+        let key = getScrollRestorationKey(location, matches.map(m => convertRouteMatchToUiMatch(m, state.loaderData)));
+        return key || location.key;
+      }
+      return location.key;
+    }
+    function saveScrollPosition(location, matches) {
+      if (savedScrollPositions && getScrollPosition) {
+        let key = getScrollKey(location, matches);
+        savedScrollPositions[key] = getScrollPosition();
+      }
+    }
+    function getSavedScrollPosition(location, matches) {
+      if (savedScrollPositions) {
+        let key = getScrollKey(location, matches);
+        let y = savedScrollPositions[key];
+        if (typeof y === "number") {
+          return y;
+        }
+      }
+      return null;
+    }
+    function checkFogOfWar(matches, routesToUse, pathname) {
+      if (patchRoutesOnNavigationImpl) {
+        if (!matches) {
+          let fogMatches = matchRoutesImpl(routesToUse, pathname, basename, true);
+          return {
+            active: true,
+            matches: fogMatches || []
+          };
+        } else {
+          if (Object.keys(matches[0].params).length > 0) {
+            // If we matched a dynamic param or a splat, it might only be because
+            // we haven't yet discovered other routes that would match with a
+            // higher score.  Call patchRoutesOnNavigation just to be sure
+            let partialMatches = matchRoutesImpl(routesToUse, pathname, basename, true);
+            return {
+              active: true,
+              matches: partialMatches
+            };
+          }
+        }
+      }
+      return {
+        active: false,
+        matches: null
+      };
+    }
+    async function discoverRoutes(matches, pathname, signal, fetcherKey) {
+      if (!patchRoutesOnNavigationImpl) {
+        return {
+          type: "success",
+          matches
+        };
+      }
+      let partialMatches = matches;
+      while (true) {
+        let isNonHMR = inFlightDataRoutes == null;
+        let routesToUse = inFlightDataRoutes || dataRoutes;
+        let localManifest = manifest;
+        try {
+          await patchRoutesOnNavigationImpl({
+            signal,
+            path: pathname,
+            matches: partialMatches,
+            fetcherKey,
+            patch: (routeId, children) => {
+              if (signal.aborted) return;
+              patchRoutesImpl(routeId, children, routesToUse, localManifest, mapRouteProperties);
+            }
+          });
+        } catch (e) {
+          return {
+            type: "error",
+            error: e,
+            partialMatches
+          };
+        } finally {
+          // If we are not in the middle of an HMR revalidation and we changed the
+          // routes, provide a new identity so when we `updateState` at the end of
+          // this navigation/fetch `router.routes` will be a new identity and
+          // trigger a re-run of memoized `router.routes` dependencies.
+          // HMR will already update the identity and reflow when it lands
+          // `inFlightDataRoutes` in `completeNavigation`
+          if (isNonHMR && !signal.aborted) {
+            dataRoutes = [...dataRoutes];
+          }
+        }
+        if (signal.aborted) {
+          return {
+            type: "aborted"
+          };
+        }
+        let newMatches = matchRoutes(routesToUse, pathname, basename);
+        if (newMatches) {
+          return {
+            type: "success",
+            matches: newMatches
+          };
+        }
+        let newPartialMatches = matchRoutesImpl(routesToUse, pathname, basename, true);
+
+        // Avoid loops if the second pass results in the same partial matches
+        if (!newPartialMatches || partialMatches.length === newPartialMatches.length && partialMatches.every((m, i) => m.route.id === newPartialMatches[i].route.id)) {
+          return {
+            type: "success",
+            matches: null
+          };
+        }
+        partialMatches = newPartialMatches;
+      }
+    }
+    function _internalSetRoutes(newRoutes) {
+      manifest = {};
+      inFlightDataRoutes = convertRoutesToDataRoutes(newRoutes, mapRouteProperties, undefined, manifest);
+    }
+    function patchRoutes(routeId, children) {
+      let isNonHMR = inFlightDataRoutes == null;
+      let routesToUse = inFlightDataRoutes || dataRoutes;
+      patchRoutesImpl(routeId, children, routesToUse, manifest, mapRouteProperties);
+
+      // If we are not in the middle of an HMR revalidation and we changed the
+      // routes, provide a new identity and trigger a reflow via `updateState`
+      // to re-run memoized `router.routes` dependencies.
+      // HMR will already update the identity and reflow when it lands
+      // `inFlightDataRoutes` in `completeNavigation`
+      if (isNonHMR) {
+        dataRoutes = [...dataRoutes];
+        updateState({});
+      }
+    }
+    router = {
+      get basename() {
+        return basename;
+      },
+      get future() {
+        return future;
+      },
+      get state() {
+        return state;
+      },
+      get routes() {
+        return dataRoutes;
+      },
+      get window() {
+        return routerWindow;
+      },
+      initialize,
+      subscribe,
+      enableScrollRestoration,
+      navigate,
+      fetch,
+      revalidate,
+      // Passthrough to history-aware createHref used by useHref so we get proper
+      // hash-aware URLs in DOM paths
+      createHref: to => init.history.createHref(to),
+      encodeLocation: to => init.history.encodeLocation(to),
+      getFetcher,
+      deleteFetcher: deleteFetcherAndUpdateState,
+      dispose,
+      getBlocker,
+      deleteBlocker,
+      patchRoutes,
+      _internalFetchControllers: fetchControllers,
+      _internalActiveDeferreds: activeDeferreds,
+      // TODO: Remove setRoutes, it's temporary to avoid dealing with
+      // updating the tree while validating the update algorithm.
+      _internalSetRoutes
+    };
+    return router;
+  }
+  //#endregion
+
+  ////////////////////////////////////////////////////////////////////////////////
+  //#region createStaticHandler
+  ////////////////////////////////////////////////////////////////////////////////
+
+  const UNSAFE_DEFERRED_SYMBOL = Symbol("deferred");
+
+  /**
+   * Future flags to toggle new feature behavior
+   */
+
+  function createStaticHandler(routes, opts) {
+    invariant(routes.length > 0, "You must provide a non-empty routes array to createStaticHandler");
+    let manifest = {};
+    let basename = (opts ? opts.basename : null) || "/";
+    let mapRouteProperties;
+    if (opts != null && opts.mapRouteProperties) {
+      mapRouteProperties = opts.mapRouteProperties;
+    } else if (opts != null && opts.detectErrorBoundary) {
+      // If they are still using the deprecated version, wrap it with the new API
+      let detectErrorBoundary = opts.detectErrorBoundary;
+      mapRouteProperties = route => ({
+        hasErrorBoundary: detectErrorBoundary(route)
+      });
+    } else {
+      mapRouteProperties = defaultMapRouteProperties;
+    }
+    // Config driven behavior flags
+    let future = _extends({
+      v7_relativeSplatPath: false,
+      v7_throwAbortReason: false
+    }, opts ? opts.future : null);
+    let dataRoutes = convertRoutesToDataRoutes(routes, mapRouteProperties, undefined, manifest);
+
+    /**
+     * The query() method is intended for document requests, in which we want to
+     * call an optional action and potentially multiple loaders for all nested
+     * routes.  It returns a StaticHandlerContext object, which is very similar
+     * to the router state (location, loaderData, actionData, errors, etc.) and
+     * also adds SSR-specific information such as the statusCode and headers
+     * from action/loaders Responses.
+     *
+     * It _should_ never throw and should report all errors through the
+     * returned context.errors object, properly associating errors to their error
+     * boundary.  Additionally, it tracks _deepestRenderedBoundaryId which can be
+     * used to emulate React error boundaries during SSr by performing a second
+     * pass only down to the boundaryId.
+     *
+     * The one exception where we do not return a StaticHandlerContext is when a
+     * redirect response is returned or thrown from any action/loader.  We
+     * propagate that out and return the raw Response so the HTTP server can
+     * return it directly.
+     *
+     * - `opts.requestContext` is an optional server context that will be passed
+     *   to actions/loaders in the `context` parameter
+     * - `opts.skipLoaderErrorBubbling` is an optional parameter that will prevent
+     *   the bubbling of errors which allows single-fetch-type implementations
+     *   where the client will handle the bubbling and we may need to return data
+     *   for the handling route
+     */
+    async function query(request, _temp3) {
+      let {
+        requestContext,
+        skipLoaderErrorBubbling,
+        dataStrategy
+      } = _temp3 === void 0 ? {} : _temp3;
+      let url = new URL(request.url);
+      let method = request.method;
+      let location = createLocation("", createPath(url), null, "default");
+      let matches = matchRoutes(dataRoutes, location, basename);
+
+      // SSR supports HEAD requests while SPA doesn't
+      if (!isValidMethod(method) && method !== "HEAD") {
+        let error = getInternalRouterError(405, {
+          method
+        });
+        let {
+          matches: methodNotAllowedMatches,
+          route
+        } = getShortCircuitMatches(dataRoutes);
+        return {
+          basename,
+          location,
+          matches: methodNotAllowedMatches,
+          loaderData: {},
+          actionData: null,
+          errors: {
+            [route.id]: error
+          },
+          statusCode: error.status,
+          loaderHeaders: {},
+          actionHeaders: {},
+          activeDeferreds: null
+        };
+      } else if (!matches) {
+        let error = getInternalRouterError(404, {
+          pathname: location.pathname
+        });
+        let {
+          matches: notFoundMatches,
+          route
+        } = getShortCircuitMatches(dataRoutes);
+        return {
+          basename,
+          location,
+          matches: notFoundMatches,
+          loaderData: {},
+          actionData: null,
+          errors: {
+            [route.id]: error
+          },
+          statusCode: error.status,
+          loaderHeaders: {},
+          actionHeaders: {},
+          activeDeferreds: null
+        };
+      }
+      let result = await queryImpl(request, location, matches, requestContext, dataStrategy || null, skipLoaderErrorBubbling === true, null);
+      if (isResponse(result)) {
+        return result;
+      }
+
+      // When returning StaticHandlerContext, we patch back in the location here
+      // since we need it for React Context.  But this helps keep our submit and
+      // loadRouteData operating on a Request instead of a Location
+      return _extends({
+        location,
+        basename
+      }, result);
+    }
+
+    /**
+     * The queryRoute() method is intended for targeted route requests, either
+     * for fetch ?_data requests or resource route requests.  In this case, we
+     * are only ever calling a single action or loader, and we are returning the
+     * returned value directly.  In most cases, this will be a Response returned
+     * from the action/loader, but it may be a primitive or other value as well -
+     * and in such cases the calling context should handle that accordingly.
+     *
+     * We do respect the throw/return differentiation, so if an action/loader
+     * throws, then this method will throw the value.  This is important so we
+     * can do proper boundary identification in Remix where a thrown Response
+     * must go to the Catch Boundary but a returned Response is happy-path.
+     *
+     * One thing to note is that any Router-initiated Errors that make sense
+     * to associate with a status code will be thrown as an ErrorResponse
+     * instance which include the raw Error, such that the calling context can
+     * serialize the error as they see fit while including the proper response
+     * code.  Examples here are 404 and 405 errors that occur prior to reaching
+     * any user-defined loaders.
+     *
+     * - `opts.routeId` allows you to specify the specific route handler to call.
+     *   If not provided the handler will determine the proper route by matching
+     *   against `request.url`
+     * - `opts.requestContext` is an optional server context that will be passed
+     *    to actions/loaders in the `context` parameter
+     */
+    async function queryRoute(request, _temp4) {
+      let {
+        routeId,
+        requestContext,
+        dataStrategy
+      } = _temp4 === void 0 ? {} : _temp4;
+      let url = new URL(request.url);
+      let method = request.method;
+      let location = createLocation("", createPath(url), null, "default");
+      let matches = matchRoutes(dataRoutes, location, basename);
+
+      // SSR supports HEAD requests while SPA doesn't
+      if (!isValidMethod(method) && method !== "HEAD" && method !== "OPTIONS") {
+        throw getInternalRouterError(405, {
+          method
+        });
+      } else if (!matches) {
+        throw getInternalRouterError(404, {
+          pathname: location.pathname
+        });
+      }
+      let match = routeId ? matches.find(m => m.route.id === routeId) : getTargetMatch(matches, location);
+      if (routeId && !match) {
+        throw getInternalRouterError(403, {
+          pathname: location.pathname,
+          routeId
+        });
+      } else if (!match) {
+        // This should never hit I don't think?
+        throw getInternalRouterError(404, {
+          pathname: location.pathname
+        });
+      }
+      let result = await queryImpl(request, location, matches, requestContext, dataStrategy || null, false, match);
+      if (isResponse(result)) {
+        return result;
+      }
+      let error = result.errors ? Object.values(result.errors)[0] : undefined;
+      if (error !== undefined) {
+        // If we got back result.errors, that means the loader/action threw
+        // _something_ that wasn't a Response, but it's not guaranteed/required
+        // to be an `instanceof Error` either, so we have to use throw here to
+        // preserve the "error" state outside of queryImpl.
+        throw error;
+      }
+
+      // Pick off the right state value to return
+      if (result.actionData) {
+        return Object.values(result.actionData)[0];
+      }
+      if (result.loaderData) {
+        var _result$activeDeferre;
+        let data = Object.values(result.loaderData)[0];
+        if ((_result$activeDeferre = result.activeDeferreds) != null && _result$activeDeferre[match.route.id]) {
+          data[UNSAFE_DEFERRED_SYMBOL] = result.activeDeferreds[match.route.id];
+        }
+        return data;
+      }
+      return undefined;
+    }
+    async function queryImpl(request, location, matches, requestContext, dataStrategy, skipLoaderErrorBubbling, routeMatch) {
+      invariant(request.signal, "query()/queryRoute() requests must contain an AbortController signal");
+      try {
+        if (isMutationMethod(request.method.toLowerCase())) {
+          let result = await submit(request, matches, routeMatch || getTargetMatch(matches, location), requestContext, dataStrategy, skipLoaderErrorBubbling, routeMatch != null);
+          return result;
+        }
+        let result = await loadRouteData(request, matches, requestContext, dataStrategy, skipLoaderErrorBubbling, routeMatch);
+        return isResponse(result) ? result : _extends({}, result, {
+          actionData: null,
+          actionHeaders: {}
+        });
+      } catch (e) {
+        // If the user threw/returned a Response in callLoaderOrAction for a
+        // `queryRoute` call, we throw the `DataStrategyResult` to bail out early
+        // and then return or throw the raw Response here accordingly
+        if (isDataStrategyResult(e) && isResponse(e.result)) {
+          if (e.type === ResultType.error) {
+            throw e.result;
+          }
+          return e.result;
+        }
+        // Redirects are always returned since they don't propagate to catch
+        // boundaries
+        if (isRedirectResponse(e)) {
+          return e;
+        }
+        throw e;
+      }
+    }
+    async function submit(request, matches, actionMatch, requestContext, dataStrategy, skipLoaderErrorBubbling, isRouteRequest) {
+      let result;
+      if (!actionMatch.route.action && !actionMatch.route.lazy) {
+        let error = getInternalRouterError(405, {
+          method: request.method,
+          pathname: new URL(request.url).pathname,
+          routeId: actionMatch.route.id
+        });
+        if (isRouteRequest) {
+          throw error;
+        }
+        result = {
+          type: ResultType.error,
+          error
+        };
+      } else {
+        let results = await callDataStrategy("action", request, [actionMatch], matches, isRouteRequest, requestContext, dataStrategy);
+        result = results[actionMatch.route.id];
+        if (request.signal.aborted) {
+          throwStaticHandlerAbortedError(request, isRouteRequest, future);
+        }
+      }
+      if (isRedirectResult(result)) {
+        // Uhhhh - this should never happen, we should always throw these from
+        // callLoaderOrAction, but the type narrowing here keeps TS happy and we
+        // can get back on the "throw all redirect responses" train here should
+        // this ever happen :/
+        throw new Response(null, {
+          status: result.response.status,
+          headers: {
+            Location: result.response.headers.get("Location")
+          }
+        });
+      }
+      if (isDeferredResult(result)) {
+        let error = getInternalRouterError(400, {
+          type: "defer-action"
+        });
+        if (isRouteRequest) {
+          throw error;
+        }
+        result = {
+          type: ResultType.error,
+          error
+        };
+      }
+      if (isRouteRequest) {
+        // Note: This should only be non-Response values if we get here, since
+        // isRouteRequest should throw any Response received in callLoaderOrAction
+        if (isErrorResult(result)) {
+          throw result.error;
+        }
+        return {
+          matches: [actionMatch],
+          loaderData: {},
+          actionData: {
+            [actionMatch.route.id]: result.data
+          },
+          errors: null,
+          // Note: statusCode + headers are unused here since queryRoute will
+          // return the raw Response or value
+          statusCode: 200,
+          loaderHeaders: {},
+          actionHeaders: {},
+          activeDeferreds: null
+        };
+      }
+
+      // Create a GET request for the loaders
+      let loaderRequest = new Request(request.url, {
+        headers: request.headers,
+        redirect: request.redirect,
+        signal: request.signal
+      });
+      if (isErrorResult(result)) {
+        // Store off the pending error - we use it to determine which loaders
+        // to call and will commit it when we complete the navigation
+        let boundaryMatch = skipLoaderErrorBubbling ? actionMatch : findNearestBoundary(matches, actionMatch.route.id);
+        let context = await loadRouteData(loaderRequest, matches, requestContext, dataStrategy, skipLoaderErrorBubbling, null, [boundaryMatch.route.id, result]);
+
+        // action status codes take precedence over loader status codes
+        return _extends({}, context, {
+          statusCode: isRouteErrorResponse(result.error) ? result.error.status : result.statusCode != null ? result.statusCode : 500,
+          actionData: null,
+          actionHeaders: _extends({}, result.headers ? {
+            [actionMatch.route.id]: result.headers
+          } : {})
+        });
+      }
+      let context = await loadRouteData(loaderRequest, matches, requestContext, dataStrategy, skipLoaderErrorBubbling, null);
+      return _extends({}, context, {
+        actionData: {
+          [actionMatch.route.id]: result.data
+        }
+      }, result.statusCode ? {
+        statusCode: result.statusCode
+      } : {}, {
+        actionHeaders: result.headers ? {
+          [actionMatch.route.id]: result.headers
+        } : {}
+      });
+    }
+    async function loadRouteData(request, matches, requestContext, dataStrategy, skipLoaderErrorBubbling, routeMatch, pendingActionResult) {
+      let isRouteRequest = routeMatch != null;
+
+      // Short circuit if we have no loaders to run (queryRoute())
+      if (isRouteRequest && !(routeMatch != null && routeMatch.route.loader) && !(routeMatch != null && routeMatch.route.lazy)) {
+        throw getInternalRouterError(400, {
+          method: request.method,
+          pathname: new URL(request.url).pathname,
+          routeId: routeMatch == null ? void 0 : routeMatch.route.id
+        });
+      }
+      let requestMatches = routeMatch ? [routeMatch] : pendingActionResult && isErrorResult(pendingActionResult[1]) ? getLoaderMatchesUntilBoundary(matches, pendingActionResult[0]) : matches;
+      let matchesToLoad = requestMatches.filter(m => m.route.loader || m.route.lazy);
+
+      // Short circuit if we have no loaders to run (query())
+      if (matchesToLoad.length === 0) {
+        return {
+          matches,
+          // Add a null for all matched routes for proper revalidation on the client
+          loaderData: matches.reduce((acc, m) => Object.assign(acc, {
+            [m.route.id]: null
+          }), {}),
+          errors: pendingActionResult && isErrorResult(pendingActionResult[1]) ? {
+            [pendingActionResult[0]]: pendingActionResult[1].error
+          } : null,
+          statusCode: 200,
+          loaderHeaders: {},
+          activeDeferreds: null
+        };
+      }
+      let results = await callDataStrategy("loader", request, matchesToLoad, matches, isRouteRequest, requestContext, dataStrategy);
+      if (request.signal.aborted) {
+        throwStaticHandlerAbortedError(request, isRouteRequest, future);
+      }
+
+      // Process and commit output from loaders
+      let activeDeferreds = new Map();
+      let context = processRouteLoaderData(matches, results, pendingActionResult, activeDeferreds, skipLoaderErrorBubbling);
+
+      // Add a null for any non-loader matches for proper revalidation on the client
+      let executedLoaders = new Set(matchesToLoad.map(match => match.route.id));
+      matches.forEach(match => {
+        if (!executedLoaders.has(match.route.id)) {
+          context.loaderData[match.route.id] = null;
+        }
+      });
+      return _extends({}, context, {
+        matches,
+        activeDeferreds: activeDeferreds.size > 0 ? Object.fromEntries(activeDeferreds.entries()) : null
+      });
+    }
+
+    // Utility wrapper for calling dataStrategy server-side without having to
+    // pass around the manifest, mapRouteProperties, etc.
+    async function callDataStrategy(type, request, matchesToLoad, matches, isRouteRequest, requestContext, dataStrategy) {
+      let results = await callDataStrategyImpl(dataStrategy || defaultDataStrategy, type, null, request, matchesToLoad, matches, null, manifest, mapRouteProperties, requestContext);
+      let dataResults = {};
+      await Promise.all(matches.map(async match => {
+        if (!(match.route.id in results)) {
+          return;
+        }
+        let result = results[match.route.id];
+        if (isRedirectDataStrategyResultResult(result)) {
+          let response = result.result;
+          // Throw redirects and let the server handle them with an HTTP redirect
+          throw normalizeRelativeRoutingRedirectResponse(response, request, match.route.id, matches, basename, future.v7_relativeSplatPath);
+        }
+        if (isResponse(result.result) && isRouteRequest) {
+          // For SSR single-route requests, we want to hand Responses back
+          // directly without unwrapping
+          throw result;
+        }
+        dataResults[match.route.id] = await convertDataStrategyResultToDataResult(result);
+      }));
+      return dataResults;
+    }
+    return {
+      dataRoutes,
+      query,
+      queryRoute
+    };
+  }
+
+  //#endregion
+
+  ////////////////////////////////////////////////////////////////////////////////
+  //#region Helpers
+  ////////////////////////////////////////////////////////////////////////////////
+
+  /**
+   * Given an existing StaticHandlerContext and an error thrown at render time,
+   * provide an updated StaticHandlerContext suitable for a second SSR render
+   */
+  function getStaticContextFromError(routes, context, error) {
+    let newContext = _extends({}, context, {
+      statusCode: isRouteErrorResponse(error) ? error.status : 500,
+      errors: {
+        [context._deepestRenderedBoundaryId || routes[0].id]: error
+      }
+    });
+    return newContext;
+  }
+  function throwStaticHandlerAbortedError(request, isRouteRequest, future) {
+    if (future.v7_throwAbortReason && request.signal.reason !== undefined) {
+      throw request.signal.reason;
+    }
+    let method = isRouteRequest ? "queryRoute" : "query";
+    throw new Error(method + "() call aborted: " + request.method + " " + request.url);
+  }
+  function isSubmissionNavigation(opts) {
+    return opts != null && ("formData" in opts && opts.formData != null || "body" in opts && opts.body !== undefined);
+  }
+  function normalizeTo(location, matches, basename, prependBasename, to, v7_relativeSplatPath, fromRouteId, relative) {
+    let contextualMatches;
+    let activeRouteMatch;
+    if (fromRouteId) {
+      // Grab matches up to the calling route so our route-relative logic is
+      // relative to the correct source route
+      contextualMatches = [];
+      for (let match of matches) {
+        contextualMatches.push(match);
+        if (match.route.id === fromRouteId) {
+          activeRouteMatch = match;
+          break;
+        }
+      }
+    } else {
+      contextualMatches = matches;
+      activeRouteMatch = matches[matches.length - 1];
+    }
+
+    // Resolve the relative path
+    let path = resolveTo(to ? to : ".", getResolveToMatches(contextualMatches, v7_relativeSplatPath), stripBasename(location.pathname, basename) || location.pathname, relative === "path");
+
+    // When `to` is not specified we inherit search/hash from the current
+    // location, unlike when to="." and we just inherit the path.
+    // See https://github.com/remix-run/remix/issues/927
+    if (to == null) {
+      path.search = location.search;
+      path.hash = location.hash;
+    }
+
+    // Account for `?index` params when routing to the current location
+    if ((to == null || to === "" || to === ".") && activeRouteMatch) {
+      let nakedIndex = hasNakedIndexQuery(path.search);
+      if (activeRouteMatch.route.index && !nakedIndex) {
+        // Add one when we're targeting an index route
+        path.search = path.search ? path.search.replace(/^\?/, "?index&") : "?index";
+      } else if (!activeRouteMatch.route.index && nakedIndex) {
+        // Remove existing ones when we're not
+        let params = new URLSearchParams(path.search);
+        let indexValues = params.getAll("index");
+        params.delete("index");
+        indexValues.filter(v => v).forEach(v => params.append("index", v));
+        let qs = params.toString();
+        path.search = qs ? "?" + qs : "";
+      }
+    }
+
+    // If we're operating within a basename, prepend it to the pathname.  If
+    // this is a root navigation, then just use the raw basename which allows
+    // the basename to have full control over the presence of a trailing slash
+    // on root actions
+    if (prependBasename && basename !== "/") {
+      path.pathname = path.pathname === "/" ? basename : joinPaths([basename, path.pathname]);
+    }
+    return createPath(path);
+  }
+
+  // Normalize navigation options by converting formMethod=GET formData objects to
+  // URLSearchParams so they behave identically to links with query params
+  function normalizeNavigateOptions(normalizeFormMethod, isFetcher, path, opts) {
+    // Return location verbatim on non-submission navigations
+    if (!opts || !isSubmissionNavigation(opts)) {
+      return {
+        path
+      };
+    }
+    if (opts.formMethod && !isValidMethod(opts.formMethod)) {
+      return {
+        path,
+        error: getInternalRouterError(405, {
+          method: opts.formMethod
+        })
+      };
+    }
+    let getInvalidBodyError = () => ({
+      path,
+      error: getInternalRouterError(400, {
+        type: "invalid-body"
+      })
+    });
+
+    // Create a Submission on non-GET navigations
+    let rawFormMethod = opts.formMethod || "get";
+    let formMethod = normalizeFormMethod ? rawFormMethod.toUpperCase() : rawFormMethod.toLowerCase();
+    let formAction = stripHashFromPath(path);
+    if (opts.body !== undefined) {
+      if (opts.formEncType === "text/plain") {
+        // text only support POST/PUT/PATCH/DELETE submissions
+        if (!isMutationMethod(formMethod)) {
+          return getInvalidBodyError();
+        }
+        let text = typeof opts.body === "string" ? opts.body : opts.body instanceof FormData || opts.body instanceof URLSearchParams ?
+        // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#plain-text-form-data
+        Array.from(opts.body.entries()).reduce((acc, _ref3) => {
+          let [name, value] = _ref3;
+          return "" + acc + name + "=" + value + "\n";
+        }, "") : String(opts.body);
+        return {
+          path,
+          submission: {
+            formMethod,
+            formAction,
+            formEncType: opts.formEncType,
+            formData: undefined,
+            json: undefined,
+            text
+          }
+        };
+      } else if (opts.formEncType === "application/json") {
+        // json only supports POST/PUT/PATCH/DELETE submissions
+        if (!isMutationMethod(formMethod)) {
+          return getInvalidBodyError();
+        }
+        try {
+          let json = typeof opts.body === "string" ? JSON.parse(opts.body) : opts.body;
+          return {
+            path,
+            submission: {
+              formMethod,
+              formAction,
+              formEncType: opts.formEncType,
+              formData: undefined,
+              json,
+              text: undefined
+            }
+          };
+        } catch (e) {
+          return getInvalidBodyError();
+        }
+      }
+    }
+    invariant(typeof FormData === "function", "FormData is not available in this environment");
+    let searchParams;
+    let formData;
+    if (opts.formData) {
+      searchParams = convertFormDataToSearchParams(opts.formData);
+      formData = opts.formData;
+    } else if (opts.body instanceof FormData) {
+      searchParams = convertFormDataToSearchParams(opts.body);
+      formData = opts.body;
+    } else if (opts.body instanceof URLSearchParams) {
+      searchParams = opts.body;
+      formData = convertSearchParamsToFormData(searchParams);
+    } else if (opts.body == null) {
+      searchParams = new URLSearchParams();
+      formData = new FormData();
+    } else {
+      try {
+        searchParams = new URLSearchParams(opts.body);
+        formData = convertSearchParamsToFormData(searchParams);
+      } catch (e) {
+        return getInvalidBodyError();
+      }
+    }
+    let submission = {
+      formMethod,
+      formAction,
+      formEncType: opts && opts.formEncType || "application/x-www-form-urlencoded",
+      formData,
+      json: undefined,
+      text: undefined
+    };
+    if (isMutationMethod(submission.formMethod)) {
+      return {
+        path,
+        submission
+      };
+    }
+
+    // Flatten submission onto URLSearchParams for GET submissions
+    let parsedPath = parsePath(path);
+    // On GET navigation submissions we can drop the ?index param from the
+    // resulting location since all loaders will run.  But fetcher GET submissions
+    // only run a single loader so we need to preserve any incoming ?index params
+    if (isFetcher && parsedPath.search && hasNakedIndexQuery(parsedPath.search)) {
+      searchParams.append("index", "");
+    }
+    parsedPath.search = "?" + searchParams;
+    return {
+      path: createPath(parsedPath),
+      submission
+    };
+  }
+
+  // Filter out all routes at/below any caught error as they aren't going to
+  // render so we don't need to load them
+  function getLoaderMatchesUntilBoundary(matches, boundaryId, includeBoundary) {
+    if (includeBoundary === void 0) {
+      includeBoundary = false;
+    }
+    let index = matches.findIndex(m => m.route.id === boundaryId);
+    if (index >= 0) {
+      return matches.slice(0, includeBoundary ? index + 1 : index);
+    }
+    return matches;
+  }
+  function getMatchesToLoad(history, state, matches, submission, location, initialHydration, skipActionErrorRevalidation, isRevalidationRequired, cancelledDeferredRoutes, cancelledFetcherLoads, deletedFetchers, fetchLoadMatches, fetchRedirectIds, routesToUse, basename, pendingActionResult) {
+    let actionResult = pendingActionResult ? isErrorResult(pendingActionResult[1]) ? pendingActionResult[1].error : pendingActionResult[1].data : undefined;
+    let currentUrl = history.createURL(state.location);
+    let nextUrl = history.createURL(location);
+
+    // Pick navigation matches that are net-new or qualify for revalidation
+    let boundaryMatches = matches;
+    if (initialHydration && state.errors) {
+      // On initial hydration, only consider matches up to _and including_ the boundary.
+      // This is inclusive to handle cases where a server loader ran successfully,
+      // a child server loader bubbled up to this route, but this route has
+      // `clientLoader.hydrate` so we want to still run the `clientLoader` so that
+      // we have a complete version of `loaderData`
+      boundaryMatches = getLoaderMatchesUntilBoundary(matches, Object.keys(state.errors)[0], true);
+    } else if (pendingActionResult && isErrorResult(pendingActionResult[1])) {
+      // If an action threw an error, we call loaders up to, but not including the
+      // boundary
+      boundaryMatches = getLoaderMatchesUntilBoundary(matches, pendingActionResult[0]);
+    }
+
+    // Don't revalidate loaders by default after action 4xx/5xx responses
+    // when the flag is enabled.  They can still opt-into revalidation via
+    // `shouldRevalidate` via `actionResult`
+    let actionStatus = pendingActionResult ? pendingActionResult[1].statusCode : undefined;
+    let shouldSkipRevalidation = skipActionErrorRevalidation && actionStatus && actionStatus >= 400;
+    let navigationMatches = boundaryMatches.filter((match, index) => {
+      let {
+        route
+      } = match;
+      if (route.lazy) {
+        // We haven't loaded this route yet so we don't know if it's got a loader!
+        return true;
+      }
+      if (route.loader == null) {
+        return false;
+      }
+      if (initialHydration) {
+        return shouldLoadRouteOnHydration(route, state.loaderData, state.errors);
+      }
+
+      // Always call the loader on new route instances and pending defer cancellations
+      if (isNewLoader(state.loaderData, state.matches[index], match) || cancelledDeferredRoutes.some(id => id === match.route.id)) {
+        return true;
+      }
+
+      // This is the default implementation for when we revalidate.  If the route
+      // provides it's own implementation, then we give them full control but
+      // provide this value so they can leverage it if needed after they check
+      // their own specific use cases
+      let currentRouteMatch = state.matches[index];
+      let nextRouteMatch = match;
+      return shouldRevalidateLoader(match, _extends({
+        currentUrl,
+        currentParams: currentRouteMatch.params,
+        nextUrl,
+        nextParams: nextRouteMatch.params
+      }, submission, {
+        actionResult,
+        actionStatus,
+        defaultShouldRevalidate: shouldSkipRevalidation ? false :
+        // Forced revalidation due to submission, useRevalidator, or X-Remix-Revalidate
+        isRevalidationRequired || currentUrl.pathname + currentUrl.search === nextUrl.pathname + nextUrl.search ||
+        // Search params affect all loaders
+        currentUrl.search !== nextUrl.search || isNewRouteInstance(currentRouteMatch, nextRouteMatch)
+      }));
+    });
+
+    // Pick fetcher.loads that need to be revalidated
+    let revalidatingFetchers = [];
+    fetchLoadMatches.forEach((f, key) => {
+      // Don't revalidate:
+      //  - on initial hydration (shouldn't be any fetchers then anyway)
+      //  - if fetcher won't be present in the subsequent render
+      //    - no longer matches the URL (v7_fetcherPersist=false)
+      //    - was unmounted but persisted due to v7_fetcherPersist=true
+      if (initialHydration || !matches.some(m => m.route.id === f.routeId) || deletedFetchers.has(key)) {
+        return;
+      }
+      let fetcherMatches = matchRoutes(routesToUse, f.path, basename);
+
+      // If the fetcher path no longer matches, push it in with null matches so
+      // we can trigger a 404 in callLoadersAndMaybeResolveData.  Note this is
+      // currently only a use-case for Remix HMR where the route tree can change
+      // at runtime and remove a route previously loaded via a fetcher
+      if (!fetcherMatches) {
+        revalidatingFetchers.push({
+          key,
+          routeId: f.routeId,
+          path: f.path,
+          matches: null,
+          match: null,
+          controller: null
+        });
+        return;
+      }
+
+      // Revalidating fetchers are decoupled from the route matches since they
+      // load from a static href.  They revalidate based on explicit revalidation
+      // (submission, useRevalidator, or X-Remix-Revalidate)
+      let fetcher = state.fetchers.get(key);
+      let fetcherMatch = getTargetMatch(fetcherMatches, f.path);
+      let shouldRevalidate = false;
+      if (fetchRedirectIds.has(key)) {
+        // Never trigger a revalidation of an actively redirecting fetcher
+        shouldRevalidate = false;
+      } else if (cancelledFetcherLoads.has(key)) {
+        // Always mark for revalidation if the fetcher was cancelled
+        cancelledFetcherLoads.delete(key);
+        shouldRevalidate = true;
+      } else if (fetcher && fetcher.state !== "idle" && fetcher.data === undefined) {
+        // If the fetcher hasn't ever completed loading yet, then this isn't a
+        // revalidation, it would just be a brand new load if an explicit
+        // revalidation is required
+        shouldRevalidate = isRevalidationRequired;
+      } else {
+        // Otherwise fall back on any user-defined shouldRevalidate, defaulting
+        // to explicit revalidations only
+        shouldRevalidate = shouldRevalidateLoader(fetcherMatch, _extends({
+          currentUrl,
+          currentParams: state.matches[state.matches.length - 1].params,
+          nextUrl,
+          nextParams: matches[matches.length - 1].params
+        }, submission, {
+          actionResult,
+          actionStatus,
+          defaultShouldRevalidate: shouldSkipRevalidation ? false : isRevalidationRequired
+        }));
+      }
+      if (shouldRevalidate) {
+        revalidatingFetchers.push({
+          key,
+          routeId: f.routeId,
+          path: f.path,
+          matches: fetcherMatches,
+          match: fetcherMatch,
+          controller: new AbortController()
+        });
+      }
+    });
+    return [navigationMatches, revalidatingFetchers];
+  }
+  function shouldLoadRouteOnHydration(route, loaderData, errors) {
+    // We dunno if we have a loader - gotta find out!
+    if (route.lazy) {
+      return true;
+    }
+
+    // No loader, nothing to initialize
+    if (!route.loader) {
+      return false;
+    }
+    let hasData = loaderData != null && loaderData[route.id] !== undefined;
+    let hasError = errors != null && errors[route.id] !== undefined;
+
+    // Don't run if we error'd during SSR
+    if (!hasData && hasError) {
+      return false;
+    }
+
+    // Explicitly opting-in to running on hydration
+    if (typeof route.loader === "function" && route.loader.hydrate === true) {
+      return true;
+    }
+
+    // Otherwise, run if we're not yet initialized with anything
+    return !hasData && !hasError;
+  }
+  function isNewLoader(currentLoaderData, currentMatch, match) {
+    let isNew =
+    // [a] -> [a, b]
+    !currentMatch ||
+    // [a, b] -> [a, c]
+    match.route.id !== currentMatch.route.id;
+
+    // Handle the case that we don't have data for a re-used route, potentially
+    // from a prior error or from a cancelled pending deferred
+    let isMissingData = currentLoaderData[match.route.id] === undefined;
+
+    // Always load if this is a net-new route or we don't yet have data
+    return isNew || isMissingData;
+  }
+  function isNewRouteInstance(currentMatch, match) {
+    let currentPath = currentMatch.route.path;
+    return (
+      // param change for this match, /users/123 -> /users/456
+      currentMatch.pathname !== match.pathname ||
+      // splat param changed, which is not present in match.path
+      // e.g. /files/images/avatar.jpg -> files/finances.xls
+      currentPath != null && currentPath.endsWith("*") && currentMatch.params["*"] !== match.params["*"]
+    );
+  }
+  function shouldRevalidateLoader(loaderMatch, arg) {
+    if (loaderMatch.route.shouldRevalidate) {
+      let routeChoice = loaderMatch.route.shouldRevalidate(arg);
+      if (typeof routeChoice === "boolean") {
+        return routeChoice;
+      }
+    }
+    return arg.defaultShouldRevalidate;
+  }
+  function patchRoutesImpl(routeId, children, routesToUse, manifest, mapRouteProperties) {
+    var _childrenToPatch;
+    let childrenToPatch;
+    if (routeId) {
+      let route = manifest[routeId];
+      invariant(route, "No route found to patch children into: routeId = " + routeId);
+      if (!route.children) {
+        route.children = [];
+      }
+      childrenToPatch = route.children;
+    } else {
+      childrenToPatch = routesToUse;
+    }
+
+    // Don't patch in routes we already know about so that `patch` is idempotent
+    // to simplify user-land code. This is useful because we re-call the
+    // `patchRoutesOnNavigation` function for matched routes with params.
+    let uniqueChildren = children.filter(newRoute => !childrenToPatch.some(existingRoute => isSameRoute(newRoute, existingRoute)));
+    let newRoutes = convertRoutesToDataRoutes(uniqueChildren, mapRouteProperties, [routeId || "_", "patch", String(((_childrenToPatch = childrenToPatch) == null ? void 0 : _childrenToPatch.length) || "0")], manifest);
+    childrenToPatch.push(...newRoutes);
+  }
+  function isSameRoute(newRoute, existingRoute) {
+    // Most optimal check is by id
+    if ("id" in newRoute && "id" in existingRoute && newRoute.id === existingRoute.id) {
+      return true;
+    }
+
+    // Second is by pathing differences
+    if (!(newRoute.index === existingRoute.index && newRoute.path === existingRoute.path && newRoute.caseSensitive === existingRoute.caseSensitive)) {
+      return false;
+    }
+
+    // Pathless layout routes are trickier since we need to check children.
+    // If they have no children then they're the same as far as we can tell
+    if ((!newRoute.children || newRoute.children.length === 0) && (!existingRoute.children || existingRoute.children.length === 0)) {
+      return true;
+    }
+
+    // Otherwise, we look to see if every child in the new route is already
+    // represented in the existing route's children
+    return newRoute.children.every((aChild, i) => {
+      var _existingRoute$childr;
+      return (_existingRoute$childr = existingRoute.children) == null ? void 0 : _existingRoute$childr.some(bChild => isSameRoute(aChild, bChild));
+    });
+  }
+
+  /**
+   * Execute route.lazy() methods to lazily load route modules (loader, action,
+   * shouldRevalidate) and update the routeManifest in place which shares objects
+   * with dataRoutes so those get updated as well.
+   */
+  async function loadLazyRouteModule(route, mapRouteProperties, manifest) {
+    if (!route.lazy) {
+      return;
+    }
+    let lazyRoute = await route.lazy();
+
+    // If the lazy route function was executed and removed by another parallel
+    // call then we can return - first lazy() to finish wins because the return
+    // value of lazy is expected to be static
+    if (!route.lazy) {
+      return;
+    }
+    let routeToUpdate = manifest[route.id];
+    invariant(routeToUpdate, "No route found in manifest");
+
+    // Update the route in place.  This should be safe because there's no way
+    // we could yet be sitting on this route as we can't get there without
+    // resolving lazy() first.
+    //
+    // This is different than the HMR "update" use-case where we may actively be
+    // on the route being updated.  The main concern boils down to "does this
+    // mutation affect any ongoing navigations or any current state.matches
+    // values?".  If not, it should be safe to update in place.
+    let routeUpdates = {};
+    for (let lazyRouteProperty in lazyRoute) {
+      let staticRouteValue = routeToUpdate[lazyRouteProperty];
+      let isPropertyStaticallyDefined = staticRouteValue !== undefined &&
+      // This property isn't static since it should always be updated based
+      // on the route updates
+      lazyRouteProperty !== "hasErrorBoundary";
+      warning(!isPropertyStaticallyDefined, "Route \"" + routeToUpdate.id + "\" has a static property \"" + lazyRouteProperty + "\" " + "defined but its lazy function is also returning a value for this property. " + ("The lazy route property \"" + lazyRouteProperty + "\" will be ignored."));
+      if (!isPropertyStaticallyDefined && !immutableRouteKeys.has(lazyRouteProperty)) {
+        routeUpdates[lazyRouteProperty] = lazyRoute[lazyRouteProperty];
+      }
+    }
+
+    // Mutate the route with the provided updates.  Do this first so we pass
+    // the updated version to mapRouteProperties
+    Object.assign(routeToUpdate, routeUpdates);
+
+    // Mutate the `hasErrorBoundary` property on the route based on the route
+    // updates and remove the `lazy` function so we don't resolve the lazy
+    // route again.
+    Object.assign(routeToUpdate, _extends({}, mapRouteProperties(routeToUpdate), {
+      lazy: undefined
+    }));
+  }
+
+  // Default implementation of `dataStrategy` which fetches all loaders in parallel
+  async function defaultDataStrategy(_ref4) {
+    let {
+      matches
+    } = _ref4;
+    let matchesToLoad = matches.filter(m => m.shouldLoad);
+    let results = await Promise.all(matchesToLoad.map(m => m.resolve()));
+    return results.reduce((acc, result, i) => Object.assign(acc, {
+      [matchesToLoad[i].route.id]: result
+    }), {});
+  }
+  async function callDataStrategyImpl(dataStrategyImpl, type, state, request, matchesToLoad, matches, fetcherKey, manifest, mapRouteProperties, requestContext) {
+    let loadRouteDefinitionsPromises = matches.map(m => m.route.lazy ? loadLazyRouteModule(m.route, mapRouteProperties, manifest) : undefined);
+    let dsMatches = matches.map((match, i) => {
+      let loadRoutePromise = loadRouteDefinitionsPromises[i];
+      let shouldLoad = matchesToLoad.some(m => m.route.id === match.route.id);
+      // `resolve` encapsulates route.lazy(), executing the loader/action,
+      // and mapping return values/thrown errors to a `DataStrategyResult`.  Users
+      // can pass a callback to take fine-grained control over the execution
+      // of the loader/action
+      let resolve = async handlerOverride => {
+        if (handlerOverride && request.method === "GET" && (match.route.lazy || match.route.loader)) {
+          shouldLoad = true;
+        }
+        return shouldLoad ? callLoaderOrAction(type, request, match, loadRoutePromise, handlerOverride, requestContext) : Promise.resolve({
+          type: ResultType.data,
+          result: undefined
+        });
+      };
+      return _extends({}, match, {
+        shouldLoad,
+        resolve
+      });
+    });
+
+    // Send all matches here to allow for a middleware-type implementation.
+    // handler will be a no-op for unneeded routes and we filter those results
+    // back out below.
+    let results = await dataStrategyImpl({
+      matches: dsMatches,
+      request,
+      params: matches[0].params,
+      fetcherKey,
+      context: requestContext
+    });
+
+    // Wait for all routes to load here but 'swallow the error since we want
+    // it to bubble up from the `await loadRoutePromise` in `callLoaderOrAction` -
+    // called from `match.resolve()`
+    try {
+      await Promise.all(loadRouteDefinitionsPromises);
+    } catch (e) {
+      // No-op
+    }
+    return results;
+  }
+
+  // Default logic for calling a loader/action is the user has no specified a dataStrategy
+  async function callLoaderOrAction(type, request, match, loadRoutePromise, handlerOverride, staticContext) {
+    let result;
+    let onReject;
+    let runHandler = handler => {
+      // Setup a promise we can race against so that abort signals short circuit
+      let reject;
+      // This will never resolve so safe to type it as Promise<DataStrategyResult> to
+      // satisfy the function return value
+      let abortPromise = new Promise((_, r) => reject = r);
+      onReject = () => reject();
+      request.signal.addEventListener("abort", onReject);
+      let actualHandler = ctx => {
+        if (typeof handler !== "function") {
+          return Promise.reject(new Error("You cannot call the handler for a route which defines a boolean " + ("\"" + type + "\" [routeId: " + match.route.id + "]")));
+        }
+        return handler({
+          request,
+          params: match.params,
+          context: staticContext
+        }, ...(ctx !== undefined ? [ctx] : []));
+      };
+      let handlerPromise = (async () => {
+        try {
+          let val = await (handlerOverride ? handlerOverride(ctx => actualHandler(ctx)) : actualHandler());
+          return {
+            type: "data",
+            result: val
+          };
+        } catch (e) {
+          return {
+            type: "error",
+            result: e
+          };
+        }
+      })();
+      return Promise.race([handlerPromise, abortPromise]);
+    };
+    try {
+      let handler = match.route[type];
+
+      // If we have a route.lazy promise, await that first
+      if (loadRoutePromise) {
+        if (handler) {
+          // Run statically defined handler in parallel with lazy()
+          let handlerError;
+          let [value] = await Promise.all([
+          // If the handler throws, don't let it immediately bubble out,
+          // since we need to let the lazy() execution finish so we know if this
+          // route has a boundary that can handle the error
+          runHandler(handler).catch(e => {
+            handlerError = e;
+          }), loadRoutePromise]);
+          if (handlerError !== undefined) {
+            throw handlerError;
+          }
+          result = value;
+        } else {
+          // Load lazy route module, then run any returned handler
+          await loadRoutePromise;
+          handler = match.route[type];
+          if (handler) {
+            // Handler still runs even if we got interrupted to maintain consistency
+            // with un-abortable behavior of handler execution on non-lazy or
+            // previously-lazy-loaded routes
+            result = await runHandler(handler);
+          } else if (type === "action") {
+            let url = new URL(request.url);
+            let pathname = url.pathname + url.search;
+            throw getInternalRouterError(405, {
+              method: request.method,
+              pathname,
+              routeId: match.route.id
+            });
+          } else {
+            // lazy() route has no loader to run.  Short circuit here so we don't
+            // hit the invariant below that errors on returning undefined.
+            return {
+              type: ResultType.data,
+              result: undefined
+            };
+          }
+        }
+      } else if (!handler) {
+        let url = new URL(request.url);
+        let pathname = url.pathname + url.search;
+        throw getInternalRouterError(404, {
+          pathname
+        });
+      } else {
+        result = await runHandler(handler);
+      }
+      invariant(result.result !== undefined, "You defined " + (type === "action" ? "an action" : "a loader") + " for route " + ("\"" + match.route.id + "\" but didn't return anything from your `" + type + "` ") + "function. Please return a value or `null`.");
+    } catch (e) {
+      // We should already be catching and converting normal handler executions to
+      // DataStrategyResults and returning them, so anything that throws here is an
+      // unexpected error we still need to wrap
+      return {
+        type: ResultType.error,
+        result: e
+      };
+    } finally {
+      if (onReject) {
+        request.signal.removeEventListener("abort", onReject);
+      }
+    }
+    return result;
+  }
+  async function convertDataStrategyResultToDataResult(dataStrategyResult) {
+    let {
+      result,
+      type
+    } = dataStrategyResult;
+    if (isResponse(result)) {
+      let data;
+      try {
+        let contentType = result.headers.get("Content-Type");
+        // Check between word boundaries instead of startsWith() due to the last
+        // paragraph of https://httpwg.org/specs/rfc9110.html#field.content-type
+        if (contentType && /\bapplication\/json\b/.test(contentType)) {
+          if (result.body == null) {
+            data = null;
+          } else {
+            data = await result.json();
+          }
+        } else {
+          data = await result.text();
+        }
+      } catch (e) {
+        return {
+          type: ResultType.error,
+          error: e
+        };
+      }
+      if (type === ResultType.error) {
+        return {
+          type: ResultType.error,
+          error: new ErrorResponseImpl(result.status, result.statusText, data),
+          statusCode: result.status,
+          headers: result.headers
+        };
+      }
+      return {
+        type: ResultType.data,
+        data,
+        statusCode: result.status,
+        headers: result.headers
+      };
+    }
+    if (type === ResultType.error) {
+      if (isDataWithResponseInit(result)) {
+        var _result$init3, _result$init4;
+        if (result.data instanceof Error) {
+          var _result$init, _result$init2;
+          return {
+            type: ResultType.error,
+            error: result.data,
+            statusCode: (_result$init = result.init) == null ? void 0 : _result$init.status,
+            headers: (_result$init2 = result.init) != null && _result$init2.headers ? new Headers(result.init.headers) : undefined
+          };
+        }
+
+        // Convert thrown data() to ErrorResponse instances
+        return {
+          type: ResultType.error,
+          error: new ErrorResponseImpl(((_result$init3 = result.init) == null ? void 0 : _result$init3.status) || 500, undefined, result.data),
+          statusCode: isRouteErrorResponse(result) ? result.status : undefined,
+          headers: (_result$init4 = result.init) != null && _result$init4.headers ? new Headers(result.init.headers) : undefined
+        };
+      }
+      return {
+        type: ResultType.error,
+        error: result,
+        statusCode: isRouteErrorResponse(result) ? result.status : undefined
+      };
+    }
+    if (isDeferredData(result)) {
+      var _result$init5, _result$init6;
+      return {
+        type: ResultType.deferred,
+        deferredData: result,
+        statusCode: (_result$init5 = result.init) == null ? void 0 : _result$init5.status,
+        headers: ((_result$init6 = result.init) == null ? void 0 : _result$init6.headers) && new Headers(result.init.headers)
+      };
+    }
+    if (isDataWithResponseInit(result)) {
+      var _result$init7, _result$init8;
+      return {
+        type: ResultType.data,
+        data: result.data,
+        statusCode: (_result$init7 = result.init) == null ? void 0 : _result$init7.status,
+        headers: (_result$init8 = result.init) != null && _result$init8.headers ? new Headers(result.init.headers) : undefined
+      };
+    }
+    return {
+      type: ResultType.data,
+      data: result
+    };
+  }
+
+  // Support relative routing in internal redirects
+  function normalizeRelativeRoutingRedirectResponse(response, request, routeId, matches, basename, v7_relativeSplatPath) {
+    let location = response.headers.get("Location");
+    invariant(location, "Redirects returned/thrown from loaders/actions must have a Location header");
+    if (!ABSOLUTE_URL_REGEX.test(location)) {
+      let trimmedMatches = matches.slice(0, matches.findIndex(m => m.route.id === routeId) + 1);
+      location = normalizeTo(new URL(request.url), trimmedMatches, basename, true, location, v7_relativeSplatPath);
+      response.headers.set("Location", location);
+    }
+    return response;
+  }
+  function normalizeRedirectLocation(location, currentUrl, basename, historyInstance) {
+    // Match Chrome's behavior:
+    // https://github.com/chromium/chromium/blob/216dbeb61db0c667e62082e5f5400a32d6983df3/content/public/common/url_utils.cc#L82
+    let invalidProtocols = ["about:", "blob:", "chrome:", "chrome-untrusted:", "content:", "data:", "devtools:", "file:", "filesystem:",
+    // eslint-disable-next-line no-script-url
+    "javascript:"];
+    if (ABSOLUTE_URL_REGEX.test(location)) {
+      // Strip off the protocol+origin for same-origin + same-basename absolute redirects
+      let normalizedLocation = location;
+      let url = normalizedLocation.startsWith("//") ? new URL(currentUrl.protocol + normalizedLocation) : new URL(normalizedLocation);
+      if (invalidProtocols.includes(url.protocol)) {
+        throw new Error("Invalid redirect location");
+      }
+      let isSameBasename = stripBasename(url.pathname, basename) != null;
+      if (url.origin === currentUrl.origin && isSameBasename) {
+        return url.pathname + url.search + url.hash;
+      }
+    }
+    try {
+      let url = historyInstance.createURL(location);
+      if (invalidProtocols.includes(url.protocol)) {
+        throw new Error("Invalid redirect location");
+      }
+    } catch (e) {}
+    return location;
+  }
+
+  // Utility method for creating the Request instances for loaders/actions during
+  // client-side navigations and fetches.  During SSR we will always have a
+  // Request instance from the static handler (query/queryRoute)
+  function createClientSideRequest(history, location, signal, submission) {
+    let url = history.createURL(stripHashFromPath(location)).toString();
+    let init = {
+      signal
+    };
+    if (submission && isMutationMethod(submission.formMethod)) {
+      let {
+        formMethod,
+        formEncType
+      } = submission;
+      // Didn't think we needed this but it turns out unlike other methods, patch
+      // won't be properly normalized to uppercase and results in a 405 error.
+      // See: https://fetch.spec.whatwg.org/#concept-method
+      init.method = formMethod.toUpperCase();
+      if (formEncType === "application/json") {
+        init.headers = new Headers({
+          "Content-Type": formEncType
+        });
+        init.body = JSON.stringify(submission.json);
+      } else if (formEncType === "text/plain") {
+        // Content-Type is inferred (https://fetch.spec.whatwg.org/#dom-request)
+        init.body = submission.text;
+      } else if (formEncType === "application/x-www-form-urlencoded" && submission.formData) {
+        // Content-Type is inferred (https://fetch.spec.whatwg.org/#dom-request)
+        init.body = convertFormDataToSearchParams(submission.formData);
+      } else {
+        // Content-Type is inferred (https://fetch.spec.whatwg.org/#dom-request)
+        init.body = submission.formData;
+      }
+    }
+    return new Request(url, init);
+  }
+  function convertFormDataToSearchParams(formData) {
+    let searchParams = new URLSearchParams();
+    for (let [key, value] of formData.entries()) {
+      // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#converting-an-entry-list-to-a-list-of-name-value-pairs
+      searchParams.append(key, typeof value === "string" ? value : value.name);
+    }
+    return searchParams;
+  }
+  function convertSearchParamsToFormData(searchParams) {
+    let formData = new FormData();
+    for (let [key, value] of searchParams.entries()) {
+      formData.append(key, value);
+    }
+    return formData;
+  }
+  function processRouteLoaderData(matches, results, pendingActionResult, activeDeferreds, skipLoaderErrorBubbling) {
+    // Fill in loaderData/errors from our loaders
+    let loaderData = {};
+    let errors = null;
+    let statusCode;
+    let foundError = false;
+    let loaderHeaders = {};
+    let pendingError = pendingActionResult && isErrorResult(pendingActionResult[1]) ? pendingActionResult[1].error : undefined;
+
+    // Process loader results into state.loaderData/state.errors
+    matches.forEach(match => {
+      if (!(match.route.id in results)) {
+        return;
+      }
+      let id = match.route.id;
+      let result = results[id];
+      invariant(!isRedirectResult(result), "Cannot handle redirect results in processLoaderData");
+      if (isErrorResult(result)) {
+        let error = result.error;
+        // If we have a pending action error, we report it at the highest-route
+        // that throws a loader error, and then clear it out to indicate that
+        // it was consumed
+        if (pendingError !== undefined) {
+          error = pendingError;
+          pendingError = undefined;
+        }
+        errors = errors || {};
+        if (skipLoaderErrorBubbling) {
+          errors[id] = error;
+        } else {
+          // Look upwards from the matched route for the closest ancestor error
+          // boundary, defaulting to the root match.  Prefer higher error values
+          // if lower errors bubble to the same boundary
+          let boundaryMatch = findNearestBoundary(matches, id);
+          if (errors[boundaryMatch.route.id] == null) {
+            errors[boundaryMatch.route.id] = error;
+          }
+        }
+
+        // Clear our any prior loaderData for the throwing route
+        loaderData[id] = undefined;
+
+        // Once we find our first (highest) error, we set the status code and
+        // prevent deeper status codes from overriding
+        if (!foundError) {
+          foundError = true;
+          statusCode = isRouteErrorResponse(result.error) ? result.error.status : 500;
+        }
+        if (result.headers) {
+          loaderHeaders[id] = result.headers;
+        }
+      } else {
+        if (isDeferredResult(result)) {
+          activeDeferreds.set(id, result.deferredData);
+          loaderData[id] = result.deferredData.data;
+          // Error status codes always override success status codes, but if all
+          // loaders are successful we take the deepest status code.
+          if (result.statusCode != null && result.statusCode !== 200 && !foundError) {
+            statusCode = result.statusCode;
+          }
+          if (result.headers) {
+            loaderHeaders[id] = result.headers;
+          }
+        } else {
+          loaderData[id] = result.data;
+          // Error status codes always override success status codes, but if all
+          // loaders are successful we take the deepest status code.
+          if (result.statusCode && result.statusCode !== 200 && !foundError) {
+            statusCode = result.statusCode;
+          }
+          if (result.headers) {
+            loaderHeaders[id] = result.headers;
+          }
+        }
+      }
+    });
+
+    // If we didn't consume the pending action error (i.e., all loaders
+    // resolved), then consume it here.  Also clear out any loaderData for the
+    // throwing route
+    if (pendingError !== undefined && pendingActionResult) {
+      errors = {
+        [pendingActionResult[0]]: pendingError
+      };
+      loaderData[pendingActionResult[0]] = undefined;
+    }
+    return {
+      loaderData,
+      errors,
+      statusCode: statusCode || 200,
+      loaderHeaders
+    };
+  }
+  function processLoaderData(state, matches, results, pendingActionResult, revalidatingFetchers, fetcherResults, activeDeferreds) {
+    let {
+      loaderData,
+      errors
+    } = processRouteLoaderData(matches, results, pendingActionResult, activeDeferreds, false // This method is only called client side so we always want to bubble
+    );
+
+    // Process results from our revalidating fetchers
+    revalidatingFetchers.forEach(rf => {
+      let {
+        key,
+        match,
+        controller
+      } = rf;
+      let result = fetcherResults[key];
+      invariant(result, "Did not find corresponding fetcher result");
+
+      // Process fetcher non-redirect errors
+      if (controller && controller.signal.aborted) {
+        // Nothing to do for aborted fetchers
+        return;
+      } else if (isErrorResult(result)) {
+        let boundaryMatch = findNearestBoundary(state.matches, match == null ? void 0 : match.route.id);
+        if (!(errors && errors[boundaryMatch.route.id])) {
+          errors = _extends({}, errors, {
+            [boundaryMatch.route.id]: result.error
+          });
+        }
+        state.fetchers.delete(key);
+      } else if (isRedirectResult(result)) {
+        // Should never get here, redirects should get processed above, but we
+        // keep this to type narrow to a success result in the else
+        invariant(false, "Unhandled fetcher revalidation redirect");
+      } else if (isDeferredResult(result)) {
+        // Should never get here, deferred data should be awaited for fetchers
+        // in resolveDeferredResults
+        invariant(false, "Unhandled fetcher deferred data");
+      } else {
+        let doneFetcher = getDoneFetcher(result.data);
+        state.fetchers.set(key, doneFetcher);
+      }
+    });
+    return {
+      loaderData,
+      errors
+    };
+  }
+  function mergeLoaderData(loaderData, newLoaderData, matches, errors) {
+    let mergedLoaderData = _extends({}, newLoaderData);
+    for (let match of matches) {
+      let id = match.route.id;
+      if (newLoaderData.hasOwnProperty(id)) {
+        if (newLoaderData[id] !== undefined) {
+          mergedLoaderData[id] = newLoaderData[id];
+        }
+      } else if (loaderData[id] !== undefined && match.route.loader) {
+        // Preserve existing keys not included in newLoaderData and where a loader
+        // wasn't removed by HMR
+        mergedLoaderData[id] = loaderData[id];
+      }
+      if (errors && errors.hasOwnProperty(id)) {
+        // Don't keep any loader data below the boundary
+        break;
+      }
+    }
+    return mergedLoaderData;
+  }
+  function getActionDataForCommit(pendingActionResult) {
+    if (!pendingActionResult) {
+      return {};
+    }
+    return isErrorResult(pendingActionResult[1]) ? {
+      // Clear out prior actionData on errors
+      actionData: {}
+    } : {
+      actionData: {
+        [pendingActionResult[0]]: pendingActionResult[1].data
+      }
+    };
+  }
+
+  // Find the nearest error boundary, looking upwards from the leaf route (or the
+  // route specified by routeId) for the closest ancestor error boundary,
+  // defaulting to the root match
+  function findNearestBoundary(matches, routeId) {
+    let eligibleMatches = routeId ? matches.slice(0, matches.findIndex(m => m.route.id === routeId) + 1) : [...matches];
+    return eligibleMatches.reverse().find(m => m.route.hasErrorBoundary === true) || matches[0];
+  }
+  function getShortCircuitMatches(routes) {
+    // Prefer a root layout route if present, otherwise shim in a route object
+    let route = routes.length === 1 ? routes[0] : routes.find(r => r.index || !r.path || r.path === "/") || {
+      id: "__shim-error-route__"
+    };
+    return {
+      matches: [{
+        params: {},
+        pathname: "",
+        pathnameBase: "",
+        route
+      }],
+      route
+    };
+  }
+  function getInternalRouterError(status, _temp5) {
+    let {
+      pathname,
+      routeId,
+      method,
+      type,
+      message
+    } = _temp5 === void 0 ? {} : _temp5;
+    let statusText = "Unknown Server Error";
+    let errorMessage = "Unknown @remix-run/router error";
+    if (status === 400) {
+      statusText = "Bad Request";
+      if (method && pathname && routeId) {
+        errorMessage = "You made a " + method + " request to \"" + pathname + "\" but " + ("did not provide a `loader` for route \"" + routeId + "\", ") + "so there is no way to handle the request.";
+      } else if (type === "defer-action") {
+        errorMessage = "defer() is not supported in actions";
+      } else if (type === "invalid-body") {
+        errorMessage = "Unable to encode submission body";
+      }
+    } else if (status === 403) {
+      statusText = "Forbidden";
+      errorMessage = "Route \"" + routeId + "\" does not match URL \"" + pathname + "\"";
+    } else if (status === 404) {
+      statusText = "Not Found";
+      errorMessage = "No route matches URL \"" + pathname + "\"";
+    } else if (status === 405) {
+      statusText = "Method Not Allowed";
+      if (method && pathname && routeId) {
+        errorMessage = "You made a " + method.toUpperCase() + " request to \"" + pathname + "\" but " + ("did not provide an `action` for route \"" + routeId + "\", ") + "so there is no way to handle the request.";
+      } else if (method) {
+        errorMessage = "Invalid request method \"" + method.toUpperCase() + "\"";
+      }
+    }
+    return new ErrorResponseImpl(status || 500, statusText, new Error(errorMessage), true);
+  }
+
+  // Find any returned redirect errors, starting from the lowest match
+  function findRedirect(results) {
+    let entries = Object.entries(results);
+    for (let i = entries.length - 1; i >= 0; i--) {
+      let [key, result] = entries[i];
+      if (isRedirectResult(result)) {
+        return {
+          key,
+          result
+        };
+      }
+    }
+  }
+  function stripHashFromPath(path) {
+    let parsedPath = typeof path === "string" ? parsePath(path) : path;
+    return createPath(_extends({}, parsedPath, {
+      hash: ""
+    }));
+  }
+  function isHashChangeOnly(a, b) {
+    if (a.pathname !== b.pathname || a.search !== b.search) {
+      return false;
+    }
+    if (a.hash === "") {
+      // /page -> /page#hash
+      return b.hash !== "";
+    } else if (a.hash === b.hash) {
+      // /page#hash -> /page#hash
+      return true;
+    } else if (b.hash !== "") {
+      // /page#hash -> /page#other
+      return true;
+    }
+
+    // If the hash is removed the browser will re-perform a request to the server
+    // /page#hash -> /page
+    return false;
+  }
+  function isDataStrategyResult(result) {
+    return result != null && typeof result === "object" && "type" in result && "result" in result && (result.type === ResultType.data || result.type === ResultType.error);
+  }
+  function isRedirectDataStrategyResultResult(result) {
+    return isResponse(result.result) && redirectStatusCodes.has(result.result.status);
+  }
+  function isDeferredResult(result) {
+    return result.type === ResultType.deferred;
+  }
+  function isErrorResult(result) {
+    return result.type === ResultType.error;
+  }
+  function isRedirectResult(result) {
+    return (result && result.type) === ResultType.redirect;
+  }
+  function isDataWithResponseInit(value) {
+    return typeof value === "object" && value != null && "type" in value && "data" in value && "init" in value && value.type === "DataWithResponseInit";
+  }
+  function isDeferredData(value) {
+    let deferred = value;
+    return deferred && typeof deferred === "object" && typeof deferred.data === "object" && typeof deferred.subscribe === "function" && typeof deferred.cancel === "function" && typeof deferred.resolveData === "function";
+  }
+  function isResponse(value) {
+    return value != null && typeof value.status === "number" && typeof value.statusText === "string" && typeof value.headers === "object" && typeof value.body !== "undefined";
+  }
+  function isRedirectResponse(result) {
+    if (!isResponse(result)) {
+      return false;
+    }
+    let status = result.status;
+    let location = result.headers.get("Location");
+    return status >= 300 && status <= 399 && location != null;
+  }
+  function isValidMethod(method) {
+    return validRequestMethods.has(method.toLowerCase());
+  }
+  function isMutationMethod(method) {
+    return validMutationMethods.has(method.toLowerCase());
+  }
+  async function resolveNavigationDeferredResults(matches, results, signal, currentMatches, currentLoaderData) {
+    let entries = Object.entries(results);
+    for (let index = 0; index < entries.length; index++) {
+      let [routeId, result] = entries[index];
+      let match = matches.find(m => (m == null ? void 0 : m.route.id) === routeId);
+      // If we don't have a match, then we can have a deferred result to do
+      // anything with.  This is for revalidating fetchers where the route was
+      // removed during HMR
+      if (!match) {
+        continue;
+      }
+      let currentMatch = currentMatches.find(m => m.route.id === match.route.id);
+      let isRevalidatingLoader = currentMatch != null && !isNewRouteInstance(currentMatch, match) && (currentLoaderData && currentLoaderData[match.route.id]) !== undefined;
+      if (isDeferredResult(result) && isRevalidatingLoader) {
+        // Note: we do not have to touch activeDeferreds here since we race them
+        // against the signal in resolveDeferredData and they'll get aborted
+        // there if needed
+        await resolveDeferredData(result, signal, false).then(result => {
+          if (result) {
+            results[routeId] = result;
+          }
+        });
+      }
+    }
+  }
+  async function resolveFetcherDeferredResults(matches, results, revalidatingFetchers) {
+    for (let index = 0; index < revalidatingFetchers.length; index++) {
+      let {
+        key,
+        routeId,
+        controller
+      } = revalidatingFetchers[index];
+      let result = results[key];
+      let match = matches.find(m => (m == null ? void 0 : m.route.id) === routeId);
+      // If we don't have a match, then we can have a deferred result to do
+      // anything with.  This is for revalidating fetchers where the route was
+      // removed during HMR
+      if (!match) {
+        continue;
+      }
+      if (isDeferredResult(result)) {
+        // Note: we do not have to touch activeDeferreds here since we race them
+        // against the signal in resolveDeferredData and they'll get aborted
+        // there if needed
+        invariant(controller, "Expected an AbortController for revalidating fetcher deferred result");
+        await resolveDeferredData(result, controller.signal, true).then(result => {
+          if (result) {
+            results[key] = result;
+          }
+        });
+      }
+    }
+  }
+  async function resolveDeferredData(result, signal, unwrap) {
+    if (unwrap === void 0) {
+      unwrap = false;
+    }
+    let aborted = await result.deferredData.resolveData(signal);
+    if (aborted) {
+      return;
+    }
+    if (unwrap) {
+      try {
+        return {
+          type: ResultType.data,
+          data: result.deferredData.unwrappedData
+        };
+      } catch (e) {
+        // Handle any TrackedPromise._error values encountered while unwrapping
+        return {
+          type: ResultType.error,
+          error: e
+        };
+      }
+    }
+    return {
+      type: ResultType.data,
+      data: result.deferredData.data
+    };
+  }
+  function hasNakedIndexQuery(search) {
+    return new URLSearchParams(search).getAll("index").some(v => v === "");
+  }
+  function getTargetMatch(matches, location) {
+    let search = typeof location === "string" ? parsePath(location).search : location.search;
+    if (matches[matches.length - 1].route.index && hasNakedIndexQuery(search || "")) {
+      // Return the leaf index route when index is present
+      return matches[matches.length - 1];
+    }
+    // Otherwise grab the deepest "path contributing" match (ignoring index and
+    // pathless layout routes)
+    let pathMatches = getPathContributingMatches(matches);
+    return pathMatches[pathMatches.length - 1];
+  }
+  function getSubmissionFromNavigation(navigation) {
+    let {
+      formMethod,
+      formAction,
+      formEncType,
+      text,
+      formData,
+      json
+    } = navigation;
+    if (!formMethod || !formAction || !formEncType) {
+      return;
+    }
+    if (text != null) {
+      return {
+        formMethod,
+        formAction,
+        formEncType,
+        formData: undefined,
+        json: undefined,
+        text
+      };
+    } else if (formData != null) {
+      return {
+        formMethod,
+        formAction,
+        formEncType,
+        formData,
+        json: undefined,
+        text: undefined
+      };
+    } else if (json !== undefined) {
+      return {
+        formMethod,
+        formAction,
+        formEncType,
+        formData: undefined,
+        json,
+        text: undefined
+      };
+    }
+  }
+  function getLoadingNavigation(location, submission) {
+    if (submission) {
+      let navigation = {
+        state: "loading",
+        location,
+        formMethod: submission.formMethod,
+        formAction: submission.formAction,
+        formEncType: submission.formEncType,
+        formData: submission.formData,
+        json: submission.json,
+        text: submission.text
+      };
+      return navigation;
+    } else {
+      let navigation = {
+        state: "loading",
+        location,
+        formMethod: undefined,
+        formAction: undefined,
+        formEncType: undefined,
+        formData: undefined,
+        json: undefined,
+        text: undefined
+      };
+      return navigation;
+    }
+  }
+  function getSubmittingNavigation(location, submission) {
+    let navigation = {
+      state: "submitting",
+      location,
+      formMethod: submission.formMethod,
+      formAction: submission.formAction,
+      formEncType: submission.formEncType,
+      formData: submission.formData,
+      json: submission.json,
+      text: submission.text
+    };
+    return navigation;
+  }
+  function getLoadingFetcher(submission, data) {
+    if (submission) {
+      let fetcher = {
+        state: "loading",
+        formMethod: submission.formMethod,
+        formAction: submission.formAction,
+        formEncType: submission.formEncType,
+        formData: submission.formData,
+        json: submission.json,
+        text: submission.text,
+        data
+      };
+      return fetcher;
+    } else {
+      let fetcher = {
+        state: "loading",
+        formMethod: undefined,
+        formAction: undefined,
+        formEncType: undefined,
+        formData: undefined,
+        json: undefined,
+        text: undefined,
+        data
+      };
+      return fetcher;
+    }
+  }
+  function getSubmittingFetcher(submission, existingFetcher) {
+    let fetcher = {
+      state: "submitting",
+      formMethod: submission.formMethod,
+      formAction: submission.formAction,
+      formEncType: submission.formEncType,
+      formData: submission.formData,
+      json: submission.json,
+      text: submission.text,
+      data: existingFetcher ? existingFetcher.data : undefined
+    };
+    return fetcher;
+  }
+  function getDoneFetcher(data) {
+    let fetcher = {
+      state: "idle",
+      formMethod: undefined,
+      formAction: undefined,
+      formEncType: undefined,
+      formData: undefined,
+      json: undefined,
+      text: undefined,
+      data
+    };
+    return fetcher;
+  }
+  function restoreAppliedTransitions(_window, transitions) {
+    try {
+      let sessionPositions = _window.sessionStorage.getItem(TRANSITIONS_STORAGE_KEY);
+      if (sessionPositions) {
+        let json = JSON.parse(sessionPositions);
+        for (let [k, v] of Object.entries(json || {})) {
+          if (v && Array.isArray(v)) {
+            transitions.set(k, new Set(v || []));
+          }
+        }
+      }
+    } catch (e) {
+      // no-op, use default empty object
+    }
+  }
+  function persistAppliedTransitions(_window, transitions) {
+    if (transitions.size > 0) {
+      let json = {};
+      for (let [k, v] of transitions) {
+        json[k] = [...v];
+      }
+      try {
+        _window.sessionStorage.setItem(TRANSITIONS_STORAGE_KEY, JSON.stringify(json));
+      } catch (error) {
+        warning(false, "Failed to save applied view transitions in sessionStorage (" + error + ").");
+      }
+    }
+  }
+  //#endregion
+
+  exports.AbortedDeferredError = AbortedDeferredError;
+  exports.Action = Action;
+  exports.IDLE_BLOCKER = IDLE_BLOCKER;
+  exports.IDLE_FETCHER = IDLE_FETCHER;
+  exports.IDLE_NAVIGATION = IDLE_NAVIGATION;
+  exports.UNSAFE_DEFERRED_SYMBOL = UNSAFE_DEFERRED_SYMBOL;
+  exports.UNSAFE_DeferredData = DeferredData;
+  exports.UNSAFE_ErrorResponseImpl = ErrorResponseImpl;
+  exports.UNSAFE_convertRouteMatchToUiMatch = convertRouteMatchToUiMatch;
+  exports.UNSAFE_convertRoutesToDataRoutes = convertRoutesToDataRoutes;
+  exports.UNSAFE_decodePath = decodePath;
+  exports.UNSAFE_getResolveToMatches = getResolveToMatches;
+  exports.UNSAFE_invariant = invariant;
+  exports.UNSAFE_warning = warning;
+  exports.createBrowserHistory = createBrowserHistory;
+  exports.createHashHistory = createHashHistory;
+  exports.createMemoryHistory = createMemoryHistory;
+  exports.createPath = createPath;
+  exports.createRouter = createRouter;
+  exports.createStaticHandler = createStaticHandler;
+  exports.data = data;
+  exports.defer = defer;
+  exports.generatePath = generatePath;
+  exports.getStaticContextFromError = getStaticContextFromError;
+  exports.getToPathname = getToPathname;
+  exports.isDataWithResponseInit = isDataWithResponseInit;
+  exports.isDeferredData = isDeferredData;
+  exports.isRouteErrorResponse = isRouteErrorResponse;
+  exports.joinPaths = joinPaths;
+  exports.json = json;
+  exports.matchPath = matchPath;
+  exports.matchRoutes = matchRoutes;
+  exports.normalizePathname = normalizePathname;
+  exports.parsePath = parsePath;
+  exports.redirect = redirect;
+  exports.redirectDocument = redirectDocument;
+  exports.replace = replace;
+  exports.resolvePath = resolvePath;
+  exports.resolveTo = resolveTo;
+  exports.stripBasename = stripBasename;
+
+  Object.defineProperty(exports, '__esModule', { value: true });
+
+}));
+//# sourceMappingURL=router.umd.js.map
Index: frontend/node_modules/@remix-run/router/dist/router.umd.js.map
===================================================================
--- frontend/node_modules/@remix-run/router/dist/router.umd.js.map	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/@remix-run/router/dist/router.umd.js.map	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,1 @@
+{"version":3,"file":"router.umd.js","sources":["../history.ts","../utils.ts","../router.ts"],"sourcesContent":["////////////////////////////////////////////////////////////////////////////////\n//#region Types and Constants\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * Actions represent the type of change to a location value.\n */\nexport enum Action {\n  /**\n   * A POP indicates a change to an arbitrary index in the history stack, such\n   * as a back or forward navigation. It does not describe the direction of the\n   * navigation, only that the current index changed.\n   *\n   * Note: This is the default action for newly created history objects.\n   */\n  Pop = \"POP\",\n\n  /**\n   * A PUSH indicates a new entry being added to the history stack, such as when\n   * a link is clicked and a new page loads. When this happens, all subsequent\n   * entries in the stack are lost.\n   */\n  Push = \"PUSH\",\n\n  /**\n   * A REPLACE indicates the entry at the current index in the history stack\n   * being replaced by a new one.\n   */\n  Replace = \"REPLACE\",\n}\n\n/**\n * The pathname, search, and hash values of a URL.\n */\nexport interface Path {\n  /**\n   * A URL pathname, beginning with a /.\n   */\n  pathname: string;\n\n  /**\n   * A URL search string, beginning with a ?.\n   */\n  search: string;\n\n  /**\n   * A URL fragment identifier, beginning with a #.\n   */\n  hash: string;\n}\n\n// TODO: (v7) Change the Location generic default from `any` to `unknown` and\n// remove Remix `useLocation` wrapper.\n\n/**\n * An entry in a history stack. A location contains information about the\n * URL path, as well as possibly some arbitrary state and a key.\n */\nexport interface Location<State = any> extends Path {\n  /**\n   * A value of arbitrary data associated with this location.\n   */\n  state: State;\n\n  /**\n   * A unique string associated with this location. May be used to safely store\n   * and retrieve data in some other storage API, like `localStorage`.\n   *\n   * Note: This value is always \"default\" on the initial location.\n   */\n  key: string;\n}\n\n/**\n * A change to the current location.\n */\nexport interface Update {\n  /**\n   * The action that triggered the change.\n   */\n  action: Action;\n\n  /**\n   * The new location.\n   */\n  location: Location;\n\n  /**\n   * The delta between this location and the former location in the history stack\n   */\n  delta: number | null;\n}\n\n/**\n * A function that receives notifications about location changes.\n */\nexport interface Listener {\n  (update: Update): void;\n}\n\n/**\n * Describes a location that is the destination of some navigation, either via\n * `history.push` or `history.replace`. This may be either a URL or the pieces\n * of a URL path.\n */\nexport type To = string | Partial<Path>;\n\n/**\n * A history is an interface to the navigation stack. The history serves as the\n * source of truth for the current location, as well as provides a set of\n * methods that may be used to change it.\n *\n * It is similar to the DOM's `window.history` object, but with a smaller, more\n * focused API.\n */\nexport interface History {\n  /**\n   * The last action that modified the current location. This will always be\n   * Action.Pop when a history instance is first created. This value is mutable.\n   */\n  readonly action: Action;\n\n  /**\n   * The current location. This value is mutable.\n   */\n  readonly location: Location;\n\n  /**\n   * Returns a valid href for the given `to` value that may be used as\n   * the value of an <a href> attribute.\n   *\n   * @param to - The destination URL\n   */\n  createHref(to: To): string;\n\n  /**\n   * Returns a URL for the given `to` value\n   *\n   * @param to - The destination URL\n   */\n  createURL(to: To): URL;\n\n  /**\n   * Encode a location the same way window.history would do (no-op for memory\n   * history) so we ensure our PUSH/REPLACE navigations for data routers\n   * behave the same as POP\n   *\n   * @param to Unencoded path\n   */\n  encodeLocation(to: To): Path;\n\n  /**\n   * Pushes a new location onto the history stack, increasing its length by one.\n   * If there were any entries in the stack after the current one, they are\n   * lost.\n   *\n   * @param to - The new URL\n   * @param state - Data to associate with the new location\n   */\n  push(to: To, state?: any): void;\n\n  /**\n   * Replaces the current location in the history stack with a new one.  The\n   * location that was replaced will no longer be available.\n   *\n   * @param to - The new URL\n   * @param state - Data to associate with the new location\n   */\n  replace(to: To, state?: any): void;\n\n  /**\n   * Navigates `n` entries backward/forward in the history stack relative to the\n   * current index. For example, a \"back\" navigation would use go(-1).\n   *\n   * @param delta - The delta in the stack index\n   */\n  go(delta: number): void;\n\n  /**\n   * Sets up a listener that will be called whenever the current location\n   * changes.\n   *\n   * @param listener - A function that will be called when the location changes\n   * @returns unlisten - A function that may be used to stop listening\n   */\n  listen(listener: Listener): () => void;\n}\n\ntype HistoryState = {\n  usr: any;\n  key?: string;\n  idx: number;\n};\n\nconst PopStateEventType = \"popstate\";\n//#endregion\n\n////////////////////////////////////////////////////////////////////////////////\n//#region Memory History\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * A user-supplied object that describes a location. Used when providing\n * entries to `createMemoryHistory` via its `initialEntries` option.\n */\nexport type InitialEntry = string | Partial<Location>;\n\nexport type MemoryHistoryOptions = {\n  initialEntries?: InitialEntry[];\n  initialIndex?: number;\n  v5Compat?: boolean;\n};\n\n/**\n * A memory history stores locations in memory. This is useful in stateful\n * environments where there is no web browser, such as node tests or React\n * Native.\n */\nexport interface MemoryHistory extends History {\n  /**\n   * The current index in the history stack.\n   */\n  readonly index: number;\n}\n\n/**\n * Memory history stores the current location in memory. It is designed for use\n * in stateful non-browser environments like tests and React Native.\n */\nexport function createMemoryHistory(\n  options: MemoryHistoryOptions = {}\n): MemoryHistory {\n  let { initialEntries = [\"/\"], initialIndex, v5Compat = false } = options;\n  let entries: Location[]; // Declare so we can access from createMemoryLocation\n  entries = initialEntries.map((entry, index) =>\n    createMemoryLocation(\n      entry,\n      typeof entry === \"string\" ? null : entry.state,\n      index === 0 ? \"default\" : undefined\n    )\n  );\n  let index = clampIndex(\n    initialIndex == null ? entries.length - 1 : initialIndex\n  );\n  let action = Action.Pop;\n  let listener: Listener | null = null;\n\n  function clampIndex(n: number): number {\n    return Math.min(Math.max(n, 0), entries.length - 1);\n  }\n  function getCurrentLocation(): Location {\n    return entries[index];\n  }\n  function createMemoryLocation(\n    to: To,\n    state: any = null,\n    key?: string\n  ): Location {\n    let location = createLocation(\n      entries ? getCurrentLocation().pathname : \"/\",\n      to,\n      state,\n      key\n    );\n    warning(\n      location.pathname.charAt(0) === \"/\",\n      `relative pathnames are not supported in memory history: ${JSON.stringify(\n        to\n      )}`\n    );\n    return location;\n  }\n\n  function createHref(to: To) {\n    return typeof to === \"string\" ? to : createPath(to);\n  }\n\n  let history: MemoryHistory = {\n    get index() {\n      return index;\n    },\n    get action() {\n      return action;\n    },\n    get location() {\n      return getCurrentLocation();\n    },\n    createHref,\n    createURL(to) {\n      return new URL(createHref(to), \"http://localhost\");\n    },\n    encodeLocation(to: To) {\n      let path = typeof to === \"string\" ? parsePath(to) : to;\n      return {\n        pathname: path.pathname || \"\",\n        search: path.search || \"\",\n        hash: path.hash || \"\",\n      };\n    },\n    push(to, state) {\n      action = Action.Push;\n      let nextLocation = createMemoryLocation(to, state);\n      index += 1;\n      entries.splice(index, entries.length, nextLocation);\n      if (v5Compat && listener) {\n        listener({ action, location: nextLocation, delta: 1 });\n      }\n    },\n    replace(to, state) {\n      action = Action.Replace;\n      let nextLocation = createMemoryLocation(to, state);\n      entries[index] = nextLocation;\n      if (v5Compat && listener) {\n        listener({ action, location: nextLocation, delta: 0 });\n      }\n    },\n    go(delta) {\n      action = Action.Pop;\n      let nextIndex = clampIndex(index + delta);\n      let nextLocation = entries[nextIndex];\n      index = nextIndex;\n      if (listener) {\n        listener({ action, location: nextLocation, delta });\n      }\n    },\n    listen(fn: Listener) {\n      listener = fn;\n      return () => {\n        listener = null;\n      };\n    },\n  };\n\n  return history;\n}\n//#endregion\n\n////////////////////////////////////////////////////////////////////////////////\n//#region Browser History\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * A browser history stores the current location in regular URLs in a web\n * browser environment. This is the standard for most web apps and provides the\n * cleanest URLs the browser's address bar.\n *\n * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#browserhistory\n */\nexport interface BrowserHistory extends UrlHistory {}\n\nexport type BrowserHistoryOptions = UrlHistoryOptions;\n\n/**\n * Browser history stores the location in regular URLs. This is the standard for\n * most web apps, but it requires some configuration on the server to ensure you\n * serve the same app at multiple URLs.\n *\n * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createbrowserhistory\n */\nexport function createBrowserHistory(\n  options: BrowserHistoryOptions = {}\n): BrowserHistory {\n  function createBrowserLocation(\n    window: Window,\n    globalHistory: Window[\"history\"]\n  ) {\n    let { pathname, search, hash } = window.location;\n    return createLocation(\n      \"\",\n      { pathname, search, hash },\n      // state defaults to `null` because `window.history.state` does\n      (globalHistory.state && globalHistory.state.usr) || null,\n      (globalHistory.state && globalHistory.state.key) || \"default\"\n    );\n  }\n\n  function createBrowserHref(window: Window, to: To) {\n    return typeof to === \"string\" ? to : createPath(to);\n  }\n\n  return getUrlBasedHistory(\n    createBrowserLocation,\n    createBrowserHref,\n    null,\n    options\n  );\n}\n//#endregion\n\n////////////////////////////////////////////////////////////////////////////////\n//#region Hash History\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * A hash history stores the current location in the fragment identifier portion\n * of the URL in a web browser environment.\n *\n * This is ideal for apps that do not control the server for some reason\n * (because the fragment identifier is never sent to the server), including some\n * shared hosting environments that do not provide fine-grained controls over\n * which pages are served at which URLs.\n *\n * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#hashhistory\n */\nexport interface HashHistory extends UrlHistory {}\n\nexport type HashHistoryOptions = UrlHistoryOptions;\n\n/**\n * Hash history stores the location in window.location.hash. This makes it ideal\n * for situations where you don't want to send the location to the server for\n * some reason, either because you do cannot configure it or the URL space is\n * reserved for something else.\n *\n * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createhashhistory\n */\nexport function createHashHistory(\n  options: HashHistoryOptions = {}\n): HashHistory {\n  function createHashLocation(\n    window: Window,\n    globalHistory: Window[\"history\"]\n  ) {\n    let {\n      pathname = \"/\",\n      search = \"\",\n      hash = \"\",\n    } = parsePath(window.location.hash.substr(1));\n\n    // Hash URL should always have a leading / just like window.location.pathname\n    // does, so if an app ends up at a route like /#something then we add a\n    // leading slash so all of our path-matching behaves the same as if it would\n    // in a browser router.  This is particularly important when there exists a\n    // root splat route (<Route path=\"*\">) since that matches internally against\n    // \"/*\" and we'd expect /#something to 404 in a hash router app.\n    if (!pathname.startsWith(\"/\") && !pathname.startsWith(\".\")) {\n      pathname = \"/\" + pathname;\n    }\n\n    return createLocation(\n      \"\",\n      { pathname, search, hash },\n      // state defaults to `null` because `window.history.state` does\n      (globalHistory.state && globalHistory.state.usr) || null,\n      (globalHistory.state && globalHistory.state.key) || \"default\"\n    );\n  }\n\n  function createHashHref(window: Window, to: To) {\n    let base = window.document.querySelector(\"base\");\n    let href = \"\";\n\n    if (base && base.getAttribute(\"href\")) {\n      let url = window.location.href;\n      let hashIndex = url.indexOf(\"#\");\n      href = hashIndex === -1 ? url : url.slice(0, hashIndex);\n    }\n\n    return href + \"#\" + (typeof to === \"string\" ? to : createPath(to));\n  }\n\n  function validateHashLocation(location: Location, to: To) {\n    warning(\n      location.pathname.charAt(0) === \"/\",\n      `relative pathnames are not supported in hash history.push(${JSON.stringify(\n        to\n      )})`\n    );\n  }\n\n  return getUrlBasedHistory(\n    createHashLocation,\n    createHashHref,\n    validateHashLocation,\n    options\n  );\n}\n//#endregion\n\n////////////////////////////////////////////////////////////////////////////////\n//#region UTILS\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * @private\n */\nexport function invariant(value: boolean, message?: string): asserts value;\nexport function invariant<T>(\n  value: T | null | undefined,\n  message?: string\n): asserts value is T;\nexport function invariant(value: any, message?: string) {\n  if (value === false || value === null || typeof value === \"undefined\") {\n    throw new Error(message);\n  }\n}\n\nexport function warning(cond: any, message: string) {\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 history!\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\nfunction createKey() {\n  return Math.random().toString(36).substr(2, 8);\n}\n\n/**\n * For browser-based histories, we combine the state and key into an object\n */\nfunction getHistoryState(location: Location, index: number): HistoryState {\n  return {\n    usr: location.state,\n    key: location.key,\n    idx: index,\n  };\n}\n\n/**\n * Creates a Location object with a unique key from the given Path\n */\nexport function createLocation(\n  current: string | Location,\n  to: To,\n  state: any = null,\n  key?: string\n): Readonly<Location> {\n  let location: Readonly<Location> = {\n    pathname: typeof current === \"string\" ? current : current.pathname,\n    search: \"\",\n    hash: \"\",\n    ...(typeof to === \"string\" ? parsePath(to) : to),\n    state,\n    // TODO: This could be cleaned up.  push/replace should probably just take\n    // full Locations now and avoid the need to run through this flow at all\n    // But that's a pretty big refactor to the current test suite so going to\n    // keep as is for the time being and just let any incoming keys take precedence\n    key: (to && (to as Location).key) || key || createKey(),\n  };\n  return location;\n}\n\n/**\n * Creates a string URL path from the given pathname, search, and hash components.\n */\nexport function createPath({\n  pathname = \"/\",\n  search = \"\",\n  hash = \"\",\n}: Partial<Path>) {\n  if (search && search !== \"?\")\n    pathname += search.charAt(0) === \"?\" ? search : \"?\" + search;\n  if (hash && hash !== \"#\")\n    pathname += hash.charAt(0) === \"#\" ? hash : \"#\" + hash;\n  return pathname;\n}\n\n/**\n * Parses a string URL path into its separate pathname, search, and hash components.\n */\nexport function parsePath(path: string): Partial<Path> {\n  let parsedPath: Partial<Path> = {};\n\n  if (path) {\n    let hashIndex = path.indexOf(\"#\");\n    if (hashIndex >= 0) {\n      parsedPath.hash = path.substr(hashIndex);\n      path = path.substr(0, hashIndex);\n    }\n\n    let searchIndex = path.indexOf(\"?\");\n    if (searchIndex >= 0) {\n      parsedPath.search = path.substr(searchIndex);\n      path = path.substr(0, searchIndex);\n    }\n\n    if (path) {\n      parsedPath.pathname = path;\n    }\n  }\n\n  return parsedPath;\n}\n\nexport interface UrlHistory extends History {}\n\nexport type UrlHistoryOptions = {\n  window?: Window;\n  v5Compat?: boolean;\n};\n\nfunction getUrlBasedHistory(\n  getLocation: (window: Window, globalHistory: Window[\"history\"]) => Location,\n  createHref: (window: Window, to: To) => string,\n  validateLocation: ((location: Location, to: To) => void) | null,\n  options: UrlHistoryOptions = {}\n): UrlHistory {\n  let { window = document.defaultView!, v5Compat = false } = options;\n  let globalHistory = window.history;\n  let action = Action.Pop;\n  let listener: Listener | null = null;\n\n  let index = getIndex()!;\n  // Index should only be null when we initialize. If not, it's because the\n  // user called history.pushState or history.replaceState directly, in which\n  // case we should log a warning as it will result in bugs.\n  if (index == null) {\n    index = 0;\n    globalHistory.replaceState({ ...globalHistory.state, idx: index }, \"\");\n  }\n\n  function getIndex(): number {\n    let state = globalHistory.state || { idx: null };\n    return state.idx;\n  }\n\n  function handlePop() {\n    action = Action.Pop;\n    let nextIndex = getIndex();\n    let delta = nextIndex == null ? null : nextIndex - index;\n    index = nextIndex;\n    if (listener) {\n      listener({ action, location: history.location, delta });\n    }\n  }\n\n  function push(to: To, state?: any) {\n    action = Action.Push;\n    let location = createLocation(history.location, to, state);\n    if (validateLocation) validateLocation(location, to);\n\n    index = getIndex() + 1;\n    let historyState = getHistoryState(location, index);\n    let url = history.createHref(location);\n\n    // try...catch because iOS limits us to 100 pushState calls :/\n    try {\n      globalHistory.pushState(historyState, \"\", url);\n    } catch (error) {\n      // If the exception is because `state` can't be serialized, let that throw\n      // outwards just like a replace call would so the dev knows the cause\n      // https://html.spec.whatwg.org/multipage/nav-history-apis.html#shared-history-push/replace-state-steps\n      // https://html.spec.whatwg.org/multipage/structured-data.html#structuredserializeinternal\n      if (error instanceof DOMException && error.name === \"DataCloneError\") {\n        throw error;\n      }\n      // They are going to lose state here, but there is no real\n      // way to warn them about it since the page will refresh...\n      window.location.assign(url);\n    }\n\n    if (v5Compat && listener) {\n      listener({ action, location: history.location, delta: 1 });\n    }\n  }\n\n  function replace(to: To, state?: any) {\n    action = Action.Replace;\n    let location = createLocation(history.location, to, state);\n    if (validateLocation) validateLocation(location, to);\n\n    index = getIndex();\n    let historyState = getHistoryState(location, index);\n    let url = history.createHref(location);\n    globalHistory.replaceState(historyState, \"\", url);\n\n    if (v5Compat && listener) {\n      listener({ action, location: history.location, delta: 0 });\n    }\n  }\n\n  function createURL(to: To): URL {\n    // window.location.origin is \"null\" (the literal string value) in Firefox\n    // under certain conditions, notably when serving from a local HTML file\n    // See https://bugzilla.mozilla.org/show_bug.cgi?id=878297\n    let base =\n      window.location.origin !== \"null\"\n        ? window.location.origin\n        : window.location.href;\n\n    let href = typeof to === \"string\" ? to : createPath(to);\n    // Treating this as a full URL will strip any trailing spaces so we need to\n    // pre-encode them since they might be part of a matching splat param from\n    // an ancestor route\n    href = href.replace(/ $/, \"%20\");\n    invariant(\n      base,\n      `No window.location.(origin|href) available to create URL for href: ${href}`\n    );\n    return new URL(href, base);\n  }\n\n  let history: History = {\n    get action() {\n      return action;\n    },\n    get location() {\n      return getLocation(window, globalHistory);\n    },\n    listen(fn: Listener) {\n      if (listener) {\n        throw new Error(\"A history only accepts one active listener\");\n      }\n      window.addEventListener(PopStateEventType, handlePop);\n      listener = fn;\n\n      return () => {\n        window.removeEventListener(PopStateEventType, handlePop);\n        listener = null;\n      };\n    },\n    createHref(to) {\n      return createHref(window, to);\n    },\n    createURL,\n    encodeLocation(to) {\n      // Encode a Location the same way window.location would\n      let url = createURL(to);\n      return {\n        pathname: url.pathname,\n        search: url.search,\n        hash: url.hash,\n      };\n    },\n    push,\n    replace,\n    go(n) {\n      return globalHistory.go(n);\n    },\n  };\n\n  return history;\n}\n\n//#endregion\n","import type { Location, Path, To } from \"./history\";\nimport { invariant, parsePath, warning } from \"./history\";\n\n/**\n * Map of routeId -> data returned from a loader/action/error\n */\nexport interface RouteData {\n  [routeId: string]: any;\n}\n\nexport enum ResultType {\n  data = \"data\",\n  deferred = \"deferred\",\n  redirect = \"redirect\",\n  error = \"error\",\n}\n\n/**\n * Successful result from a loader or action\n */\nexport interface SuccessResult {\n  type: ResultType.data;\n  data: unknown;\n  statusCode?: number;\n  headers?: Headers;\n}\n\n/**\n * Successful defer() result from a loader or action\n */\nexport interface DeferredResult {\n  type: ResultType.deferred;\n  deferredData: DeferredData;\n  statusCode?: number;\n  headers?: Headers;\n}\n\n/**\n * Redirect result from a loader or action\n */\nexport interface RedirectResult {\n  type: ResultType.redirect;\n  // We keep the raw Response for redirects so we can return it verbatim\n  response: Response;\n}\n\n/**\n * Unsuccessful result from a loader or action\n */\nexport interface ErrorResult {\n  type: ResultType.error;\n  error: unknown;\n  statusCode?: number;\n  headers?: Headers;\n}\n\n/**\n * Result from a loader or action - potentially successful or unsuccessful\n */\nexport type DataResult =\n  | SuccessResult\n  | DeferredResult\n  | RedirectResult\n  | ErrorResult;\n\ntype LowerCaseFormMethod = \"get\" | \"post\" | \"put\" | \"patch\" | \"delete\";\ntype UpperCaseFormMethod = Uppercase<LowerCaseFormMethod>;\n\n/**\n * Users can specify either lowercase or uppercase form methods on `<Form>`,\n * useSubmit(), `<fetcher.Form>`, etc.\n */\nexport type HTMLFormMethod = LowerCaseFormMethod | UpperCaseFormMethod;\n\n/**\n * Active navigation/fetcher form methods are exposed in lowercase on the\n * RouterState\n */\nexport type FormMethod = LowerCaseFormMethod;\nexport type MutationFormMethod = Exclude<FormMethod, \"get\">;\n\n/**\n * In v7, active navigation/fetcher form methods are exposed in uppercase on the\n * RouterState.  This is to align with the normalization done via fetch().\n */\nexport type V7_FormMethod = UpperCaseFormMethod;\nexport type V7_MutationFormMethod = Exclude<V7_FormMethod, \"GET\">;\n\nexport type FormEncType =\n  | \"application/x-www-form-urlencoded\"\n  | \"multipart/form-data\"\n  | \"application/json\"\n  | \"text/plain\";\n\n// Thanks https://github.com/sindresorhus/type-fest!\ntype JsonObject = { [Key in string]: JsonValue } & {\n  [Key in string]?: JsonValue | undefined;\n};\ntype JsonArray = JsonValue[] | readonly JsonValue[];\ntype JsonPrimitive = string | number | boolean | null;\ntype JsonValue = JsonPrimitive | JsonObject | JsonArray;\n\n/**\n * @private\n * Internal interface to pass around for action submissions, not intended for\n * external consumption\n */\nexport type Submission =\n  | {\n      formMethod: FormMethod | V7_FormMethod;\n      formAction: string;\n      formEncType: FormEncType;\n      formData: FormData;\n      json: undefined;\n      text: undefined;\n    }\n  | {\n      formMethod: FormMethod | V7_FormMethod;\n      formAction: string;\n      formEncType: FormEncType;\n      formData: undefined;\n      json: JsonValue;\n      text: undefined;\n    }\n  | {\n      formMethod: FormMethod | V7_FormMethod;\n      formAction: string;\n      formEncType: FormEncType;\n      formData: undefined;\n      json: undefined;\n      text: string;\n    };\n\n/**\n * @private\n * Arguments passed to route loader/action functions.  Same for now but we keep\n * this as a private implementation detail in case they diverge in the future.\n */\ninterface DataFunctionArgs<Context> {\n  request: Request;\n  params: Params;\n  context?: Context;\n}\n\n// TODO: (v7) Change the defaults from any to unknown in and remove Remix wrappers:\n//   ActionFunction, ActionFunctionArgs, LoaderFunction, LoaderFunctionArgs\n//   Also, make them a type alias instead of an interface\n\n/**\n * Arguments passed to loader functions\n */\nexport interface LoaderFunctionArgs<Context = any>\n  extends DataFunctionArgs<Context> {}\n\n/**\n * Arguments passed to action functions\n */\nexport interface ActionFunctionArgs<Context = any>\n  extends DataFunctionArgs<Context> {}\n\n/**\n * Loaders and actions can return anything except `undefined` (`null` is a\n * valid return value if there is no data to return).  Responses are preferred\n * and will ease any future migration to Remix\n */\ntype DataFunctionValue = Response | NonNullable<unknown> | null;\n\ntype DataFunctionReturnValue = Promise<DataFunctionValue> | DataFunctionValue;\n\n/**\n * Route loader function signature\n */\nexport type LoaderFunction<Context = any> = {\n  (\n    args: LoaderFunctionArgs<Context>,\n    handlerCtx?: unknown\n  ): DataFunctionReturnValue;\n} & { hydrate?: boolean };\n\n/**\n * Route action function signature\n */\nexport interface ActionFunction<Context = any> {\n  (\n    args: ActionFunctionArgs<Context>,\n    handlerCtx?: unknown\n  ): DataFunctionReturnValue;\n}\n\n/**\n * Arguments passed to shouldRevalidate function\n */\nexport interface ShouldRevalidateFunctionArgs {\n  currentUrl: URL;\n  currentParams: AgnosticDataRouteMatch[\"params\"];\n  nextUrl: URL;\n  nextParams: AgnosticDataRouteMatch[\"params\"];\n  formMethod?: Submission[\"formMethod\"];\n  formAction?: Submission[\"formAction\"];\n  formEncType?: Submission[\"formEncType\"];\n  text?: Submission[\"text\"];\n  formData?: Submission[\"formData\"];\n  json?: Submission[\"json\"];\n  actionStatus?: number;\n  actionResult?: any;\n  defaultShouldRevalidate: boolean;\n}\n\n/**\n * Route shouldRevalidate function signature.  This runs after any submission\n * (navigation or fetcher), so we flatten the navigation/fetcher submission\n * onto the arguments.  It shouldn't matter whether it came from a navigation\n * or a fetcher, what really matters is the URLs and the formData since loaders\n * have to re-run based on the data models that were potentially mutated.\n */\nexport interface ShouldRevalidateFunction {\n  (args: ShouldRevalidateFunctionArgs): boolean;\n}\n\n/**\n * Function provided by the framework-aware layers to set `hasErrorBoundary`\n * from the framework-aware `errorElement` prop\n *\n * @deprecated Use `mapRouteProperties` instead\n */\nexport interface DetectErrorBoundaryFunction {\n  (route: AgnosticRouteObject): boolean;\n}\n\nexport interface DataStrategyMatch\n  extends AgnosticRouteMatch<string, AgnosticDataRouteObject> {\n  shouldLoad: boolean;\n  resolve: (\n    handlerOverride?: (\n      handler: (ctx?: unknown) => DataFunctionReturnValue\n    ) => DataFunctionReturnValue\n  ) => Promise<DataStrategyResult>;\n}\n\nexport interface DataStrategyFunctionArgs<Context = any>\n  extends DataFunctionArgs<Context> {\n  matches: DataStrategyMatch[];\n  fetcherKey: string | null;\n}\n\n/**\n * Result from a loader or action called via dataStrategy\n */\nexport interface DataStrategyResult {\n  type: \"data\" | \"error\";\n  result: unknown; // data, Error, Response, DeferredData, DataWithResponseInit\n}\n\nexport interface DataStrategyFunction {\n  (args: DataStrategyFunctionArgs): Promise<Record<string, DataStrategyResult>>;\n}\n\nexport type AgnosticPatchRoutesOnNavigationFunctionArgs<\n  O extends AgnosticRouteObject = AgnosticRouteObject,\n  M extends AgnosticRouteMatch = AgnosticRouteMatch\n> = {\n  signal: AbortSignal;\n  path: string;\n  matches: M[];\n  fetcherKey: string | undefined;\n  patch: (routeId: string | null, children: O[]) => void;\n};\n\nexport type AgnosticPatchRoutesOnNavigationFunction<\n  O extends AgnosticRouteObject = AgnosticRouteObject,\n  M extends AgnosticRouteMatch = AgnosticRouteMatch\n> = (\n  opts: AgnosticPatchRoutesOnNavigationFunctionArgs<O, M>\n) => void | Promise<void>;\n\n/**\n * Function provided by the framework-aware layers to set any framework-specific\n * properties from framework-agnostic properties\n */\nexport interface MapRoutePropertiesFunction {\n  (route: AgnosticRouteObject): {\n    hasErrorBoundary: boolean;\n  } & Record<string, any>;\n}\n\n/**\n * Keys we cannot change from within a lazy() function. We spread all other keys\n * onto the route. Either they're meaningful to the router, or they'll get\n * ignored.\n */\nexport type ImmutableRouteKey =\n  | \"lazy\"\n  | \"caseSensitive\"\n  | \"path\"\n  | \"id\"\n  | \"index\"\n  | \"children\";\n\nexport const immutableRouteKeys = new Set<ImmutableRouteKey>([\n  \"lazy\",\n  \"caseSensitive\",\n  \"path\",\n  \"id\",\n  \"index\",\n  \"children\",\n]);\n\ntype RequireOne<T, Key = keyof T> = Exclude<\n  {\n    [K in keyof T]: K extends Key ? Omit<T, K> & Required<Pick<T, K>> : never;\n  }[keyof T],\n  undefined\n>;\n\n/**\n * lazy() function to load a route definition, which can add non-matching\n * related properties to a route\n */\nexport interface LazyRouteFunction<R extends AgnosticRouteObject> {\n  (): Promise<RequireOne<Omit<R, ImmutableRouteKey>>>;\n}\n\n/**\n * Base RouteObject with common props shared by all types of routes\n */\ntype AgnosticBaseRouteObject = {\n  caseSensitive?: boolean;\n  path?: string;\n  id?: string;\n  loader?: LoaderFunction | boolean;\n  action?: ActionFunction | boolean;\n  hasErrorBoundary?: boolean;\n  shouldRevalidate?: ShouldRevalidateFunction;\n  handle?: any;\n  lazy?: LazyRouteFunction<AgnosticBaseRouteObject>;\n};\n\n/**\n * Index routes must not have children\n */\nexport type AgnosticIndexRouteObject = AgnosticBaseRouteObject & {\n  children?: undefined;\n  index: true;\n};\n\n/**\n * Non-index routes may have children, but cannot have index\n */\nexport type AgnosticNonIndexRouteObject = AgnosticBaseRouteObject & {\n  children?: AgnosticRouteObject[];\n  index?: false;\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 type AgnosticRouteObject =\n  | AgnosticIndexRouteObject\n  | AgnosticNonIndexRouteObject;\n\nexport type AgnosticDataIndexRouteObject = AgnosticIndexRouteObject & {\n  id: string;\n};\n\nexport type AgnosticDataNonIndexRouteObject = AgnosticNonIndexRouteObject & {\n  children?: AgnosticDataRouteObject[];\n  id: string;\n};\n\n/**\n * A data route object, which is just a RouteObject with a required unique ID\n */\nexport type AgnosticDataRouteObject =\n  | AgnosticDataIndexRouteObject\n  | AgnosticDataNonIndexRouteObject;\n\nexport type RouteManifest = Record<string, AgnosticDataRouteObject | undefined>;\n\n// Recursive helper for finding path parameters in the absence of wildcards\ntype _PathParam<Path extends string> =\n  // split path into individual path segments\n  Path extends `${infer L}/${infer R}`\n    ? _PathParam<L> | _PathParam<R>\n    : // find params after `:`\n    Path extends `:${infer Param}`\n    ? Param extends `${infer Optional}?`\n      ? Optional\n      : Param\n    : // otherwise, there aren't any params present\n      never;\n\n/**\n * Examples:\n * \"/a/b/*\" -> \"*\"\n * \":a\" -> \"a\"\n * \"/a/:b\" -> \"b\"\n * \"/a/blahblahblah:b\" -> \"b\"\n * \"/:a/:b\" -> \"a\" | \"b\"\n * \"/:a/b/:c/*\" -> \"a\" | \"c\" | \"*\"\n */\nexport type PathParam<Path extends string> =\n  // check if path is just a wildcard\n  Path extends \"*\" | \"/*\"\n    ? \"*\"\n    : // look for wildcard at the end of the path\n    Path extends `${infer Rest}/*`\n    ? \"*\" | _PathParam<Rest>\n    : // look for params in the absence of wildcards\n      _PathParam<Path>;\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.\nexport type ParamParseKey<Segment extends string> =\n  // if you could not find path params, fallback to `string`\n  [PathParam<Segment>] extends [never] ? string : PathParam<Segment>;\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 RouteMatch contains info about how a route matched a URL.\n */\nexport interface AgnosticRouteMatch<\n  ParamKey extends string = string,\n  RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject\n> {\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: RouteObjectType;\n}\n\nexport interface AgnosticDataRouteMatch\n  extends AgnosticRouteMatch<string, AgnosticDataRouteObject> {}\n\nfunction isIndexRoute(\n  route: AgnosticRouteObject\n): route is AgnosticIndexRouteObject {\n  return route.index === true;\n}\n\n// Walk the route tree generating unique IDs where necessary, so we are working\n// solely with AgnosticDataRouteObject's within the Router\nexport function convertRoutesToDataRoutes(\n  routes: AgnosticRouteObject[],\n  mapRouteProperties: MapRoutePropertiesFunction,\n  parentPath: string[] = [],\n  manifest: RouteManifest = {}\n): AgnosticDataRouteObject[] {\n  return routes.map((route, index) => {\n    let treePath = [...parentPath, String(index)];\n    let id = typeof route.id === \"string\" ? route.id : treePath.join(\"-\");\n    invariant(\n      route.index !== true || !route.children,\n      `Cannot specify children on an index route`\n    );\n    invariant(\n      !manifest[id],\n      `Found a route id collision on id \"${id}\".  Route ` +\n        \"id's must be globally unique within Data Router usages\"\n    );\n\n    if (isIndexRoute(route)) {\n      let indexRoute: AgnosticDataIndexRouteObject = {\n        ...route,\n        ...mapRouteProperties(route),\n        id,\n      };\n      manifest[id] = indexRoute;\n      return indexRoute;\n    } else {\n      let pathOrLayoutRoute: AgnosticDataNonIndexRouteObject = {\n        ...route,\n        ...mapRouteProperties(route),\n        id,\n        children: undefined,\n      };\n      manifest[id] = pathOrLayoutRoute;\n\n      if (route.children) {\n        pathOrLayoutRoute.children = convertRoutesToDataRoutes(\n          route.children,\n          mapRouteProperties,\n          treePath,\n          manifest\n        );\n      }\n\n      return pathOrLayoutRoute;\n    }\n  });\n}\n\n/**\n * Matches the given routes to a location and returns the match data.\n *\n * @see https://reactrouter.com/v6/utils/match-routes\n */\nexport function matchRoutes<\n  RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject\n>(\n  routes: RouteObjectType[],\n  locationArg: Partial<Location> | string,\n  basename = \"/\"\n): AgnosticRouteMatch<string, RouteObjectType>[] | null {\n  return matchRoutesImpl(routes, locationArg, basename, false);\n}\n\nexport function matchRoutesImpl<\n  RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject\n>(\n  routes: RouteObjectType[],\n  locationArg: Partial<Location> | string,\n  basename: string,\n  allowPartial: boolean\n): AgnosticRouteMatch<string, RouteObjectType>[] | 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    // Incoming pathnames are generally encoded from either window.location\n    // or from router.navigate, but we want to match against the unencoded\n    // paths in the route definitions.  Memory router locations won't be\n    // encoded here but there also shouldn't be anything to decode so this\n    // should be a safe operation.  This avoids needing matchRoutes to be\n    // history-aware.\n    let decoded = decodePath(pathname);\n    matches = matchRouteBranch<string, RouteObjectType>(\n      branches[i],\n      decoded,\n      allowPartial\n    );\n  }\n\n  return matches;\n}\n\nexport interface UIMatch<Data = unknown, Handle = unknown> {\n  id: string;\n  pathname: string;\n  params: AgnosticRouteMatch[\"params\"];\n  data: Data;\n  handle: Handle;\n}\n\nexport function convertRouteMatchToUiMatch(\n  match: AgnosticDataRouteMatch,\n  loaderData: RouteData\n): UIMatch {\n  let { route, pathname, params } = match;\n  return {\n    id: route.id,\n    pathname,\n    params,\n    data: loaderData[route.id],\n    handle: route.handle,\n  };\n}\n\ninterface RouteMeta<\n  RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject\n> {\n  relativePath: string;\n  caseSensitive: boolean;\n  childrenIndex: number;\n  route: RouteObjectType;\n}\n\ninterface RouteBranch<\n  RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject\n> {\n  path: string;\n  score: number;\n  routesMeta: RouteMeta<RouteObjectType>[];\n}\n\nfunction flattenRoutes<\n  RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject\n>(\n  routes: RouteObjectType[],\n  branches: RouteBranch<RouteObjectType>[] = [],\n  parentsMeta: RouteMeta<RouteObjectType>[] = [],\n  parentPath = \"\"\n): RouteBranch<RouteObjectType>[] {\n  let flattenRoute = (\n    route: RouteObjectType,\n    index: number,\n    relativePath?: string\n  ) => {\n    let meta: RouteMeta<RouteObjectType> = {\n      relativePath:\n        relativePath === undefined ? route.path || \"\" : relativePath,\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        // Our types know better, but runtime JS may not!\n        // @ts-expect-error\n        route.index !== true,\n        `Index routes must not have child routes. Please remove ` +\n          `all child routes from route path \"${path}\".`\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({\n      path,\n      score: computeScore(path, route.index),\n      routesMeta,\n    });\n  };\n  routes.forEach((route, index) => {\n    // coarse-grain check for optional params\n    if (route.path === \"\" || !route.path?.includes(\"?\")) {\n      flattenRoute(route, index);\n    } else {\n      for (let exploded of explodeOptionalSegments(route.path)) {\n        flattenRoute(route, index, exploded);\n      }\n    }\n  });\n\n  return branches;\n}\n\n/**\n * Computes all combinations of optional path segments for a given path,\n * excluding combinations that are ambiguous and of lower priority.\n *\n * For example, `/one/:two?/three/:four?/:five?` explodes to:\n * - `/one/three`\n * - `/one/:two/three`\n * - `/one/three/:four`\n * - `/one/three/:five`\n * - `/one/:two/three/:four`\n * - `/one/:two/three/:five`\n * - `/one/three/:four/:five`\n * - `/one/:two/three/:four/:five`\n */\nfunction explodeOptionalSegments(path: string): string[] {\n  let segments = path.split(\"/\");\n  if (segments.length === 0) return [];\n\n  let [first, ...rest] = segments;\n\n  // Optional path segments are denoted by a trailing `?`\n  let isOptional = first.endsWith(\"?\");\n  // Compute the corresponding required segment: `foo?` -> `foo`\n  let required = first.replace(/\\?$/, \"\");\n\n  if (rest.length === 0) {\n    // Intepret empty string as omitting an optional segment\n    // `[\"one\", \"\", \"three\"]` corresponds to omitting `:two` from `/one/:two?/three` -> `/one/three`\n    return isOptional ? [required, \"\"] : [required];\n  }\n\n  let restExploded = explodeOptionalSegments(rest.join(\"/\"));\n\n  let result: string[] = [];\n\n  // All child paths with the prefix.  Do this for all children before the\n  // optional version for all children, so we get consistent ordering where the\n  // parent optional aspect is preferred as required.  Otherwise, we can get\n  // child sections interspersed where deeper optional segments are higher than\n  // parent optional segments, where for example, /:two would explode _earlier_\n  // then /:one.  By always including the parent as required _for all children_\n  // first, we avoid this issue\n  result.push(\n    ...restExploded.map((subpath) =>\n      subpath === \"\" ? required : [required, subpath].join(\"/\")\n    )\n  );\n\n  // Then, if this is an optional value, add all child versions without\n  if (isOptional) {\n    result.push(...restExploded);\n  }\n\n  // for absolute paths, ensure `/` instead of empty segment\n  return result.map((exploded) =>\n    path.startsWith(\"/\") && exploded === \"\" ? \"/\" : exploded\n  );\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<\n  ParamKey extends string = string,\n  RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject\n>(\n  branch: RouteBranch<RouteObjectType>,\n  pathname: string,\n  allowPartial = false\n): AgnosticRouteMatch<ParamKey, RouteObjectType>[] | null {\n  let { routesMeta } = branch;\n\n  let matchedParams = {};\n  let matchedPathname = \"/\";\n  let matches: AgnosticRouteMatch<ParamKey, RouteObjectType>[] = [];\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    let route = meta.route;\n\n    if (\n      !match &&\n      end &&\n      allowPartial &&\n      !routesMeta[routesMeta.length - 1].route.index\n    ) {\n      match = matchPath(\n        {\n          path: meta.relativePath,\n          caseSensitive: meta.caseSensitive,\n          end: false,\n        },\n        remainingPathname\n      );\n    }\n\n    if (!match) {\n      return null;\n    }\n\n    Object.assign(matchedParams, match.params);\n\n    matches.push({\n      // TODO: Can this as be avoided?\n      params: matchedParams as Params<ParamKey>,\n      pathname: joinPaths([matchedPathname, match.pathname]),\n      pathnameBase: normalizePathname(\n        joinPaths([matchedPathname, match.pathnameBase])\n      ),\n      route,\n    });\n\n    if (match.pathnameBase !== \"/\") {\n      matchedPathname = joinPaths([matchedPathname, match.pathnameBase]);\n    }\n  }\n\n  return matches;\n}\n\n/**\n * Returns a path with params interpolated.\n *\n * @see https://reactrouter.com/v6/utils/generate-path\n */\nexport function generatePath<Path extends string>(\n  originalPath: Path,\n  params: {\n    [key in PathParam<Path>]: string | null;\n  } = {} as any\n): string {\n  let path: string = originalPath;\n  if (path.endsWith(\"*\") && path !== \"*\" && !path.endsWith(\"/*\")) {\n    warning(\n      false,\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    path = path.replace(/\\*$/, \"/*\") as Path;\n  }\n\n  // ensure `/` is added at the beginning if the path is absolute\n  const prefix = path.startsWith(\"/\") ? \"/\" : \"\";\n\n  const stringify = (p: any) =>\n    p == null ? \"\" : typeof p === \"string\" ? p : String(p);\n\n  const segments = path\n    .split(/\\/+/)\n    .map((segment, index, array) => {\n      const isLastSegment = index === array.length - 1;\n\n      // only apply the splat if it's the last segment\n      if (isLastSegment && segment === \"*\") {\n        const star = \"*\" as PathParam<Path>;\n        // Apply the splat\n        return stringify(params[star]);\n      }\n\n      const keyMatch = segment.match(/^:([\\w-]+)(\\??)$/);\n      if (keyMatch) {\n        const [, key, optional] = keyMatch;\n        let param = params[key as PathParam<Path>];\n        invariant(optional === \"?\" || param != null, `Missing \":${key}\" param`);\n        return stringify(param);\n      }\n\n      // Remove any optional markers from optional static segments\n      return segment.replace(/\\?$/g, \"\");\n    })\n    // Remove empty segments\n    .filter((segment) => !!segment);\n\n  return prefix + segments.join(\"/\");\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/v6/utils/match-path\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, compiledParams] = 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 = compiledParams.reduce<Mutable<Params>>(\n    (memo, { paramName, isOptional }, 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      const value = captureGroups[index];\n      if (isOptional && !value) {\n        memo[paramName] = undefined;\n      } else {\n        memo[paramName] = (value || \"\").replace(/%2F/g, \"/\");\n      }\n      return memo;\n    },\n    {}\n  );\n\n  return {\n    params,\n    pathname: matchedPathname,\n    pathnameBase,\n    pattern,\n  };\n}\n\ntype CompiledPathParam = { paramName: string; isOptional?: boolean };\n\nfunction compilePath(\n  path: string,\n  caseSensitive = false,\n  end = true\n): [RegExp, CompiledPathParam[]] {\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 params: CompiledPathParam[] = [];\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(\n        /\\/:([\\w-]+)(\\?)?/g,\n        (_: string, paramName: string, isOptional) => {\n          params.push({ paramName, isOptional: isOptional != null });\n          return isOptional ? \"/?([^\\\\/]+)?\" : \"/([^\\\\/]+)\";\n        }\n      );\n\n  if (path.endsWith(\"*\")) {\n    params.push({ paramName: \"*\" });\n    regexpSource +=\n      path === \"*\" || path === \"/*\"\n        ? \"(.*)$\" // Already matched the initial /, just match the rest\n        : \"(?:\\\\/(.+)|\\\\/*)$\"; // Don't include the / in params[\"*\"]\n  } else if (end) {\n    // When matching to the end, ignore trailing slashes\n    regexpSource += \"\\\\/*$\";\n  } else if (path !== \"\" && path !== \"/\") {\n    // If our path is non-empty and contains anything beyond an initial slash,\n    // then we have _some_ form of path in our regex, so we should expect to\n    // match only if we find the end of this path segment.  Look for an optional\n    // non-captured trailing slash (to match a portion of the URL) or the end\n    // of the path (if we've matched to the end).  We used to do this with a\n    // word boundary but that gives false positives on routes like\n    // /user-preferences since `-` counts as a word boundary.\n    regexpSource += \"(?:(?=\\\\/|$))\";\n  } else {\n    // Nothing to match for \"\" or \"/\"\n  }\n\n  let matcher = new RegExp(regexpSource, caseSensitive ? undefined : \"i\");\n\n  return [matcher, params];\n}\n\nexport function decodePath(value: string) {\n  try {\n    return value\n      .split(\"/\")\n      .map((v) => decodeURIComponent(v).replace(/\\//g, \"%2F\"))\n      .join(\"/\");\n  } catch (error) {\n    warning(\n      false,\n      `The URL path \"${value}\" could not be decoded because it is is a ` +\n        `malformed URL segment. This is probably due to a bad percent ` +\n        `encoding (${error}).`\n    );\n\n    return value;\n  }\n}\n\n/**\n * @private\n */\nexport function stripBasename(\n  pathname: string,\n  basename: string\n): string | null {\n  if (basename === \"/\") return pathname;\n\n  if (!pathname.toLowerCase().startsWith(basename.toLowerCase())) {\n    return null;\n  }\n\n  // We want to leave trailing slash behavior in the user's control, so if they\n  // specify a basename with a trailing slash, we should support it\n  let startIndex = basename.endsWith(\"/\")\n    ? basename.length - 1\n    : basename.length;\n  let nextChar = pathname.charAt(startIndex);\n  if (nextChar && nextChar !== \"/\") {\n    // pathname does not start with basename/\n    return null;\n  }\n\n  return pathname.slice(startIndex) || \"/\";\n}\n\nconst ABSOLUTE_URL_REGEX = /^(?:[a-z][a-z0-9+.-]*:|\\/\\/)/i;\nexport const isAbsoluteUrl = (url: string) => ABSOLUTE_URL_REGEX.test(url);\n\n/**\n * Returns a resolved path object relative to the given pathname.\n *\n * @see https://reactrouter.com/v6/utils/resolve-path\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: string;\n  if (toPathname) {\n    if (isAbsoluteUrl(toPathname)) {\n      pathname = toPathname;\n    } else {\n      if (toPathname.includes(\"//\")) {\n        let oldPathname = toPathname;\n        toPathname = toPathname.replace(/\\/\\/+/g, \"/\");\n        warning(\n          false,\n          `Pathnames cannot have embedded double slashes - normalizing ` +\n            `${oldPathname} -> ${toPathname}`\n        );\n      }\n      if (toPathname.startsWith(\"/\")) {\n        pathname = resolvePathname(toPathname.substring(1), \"/\");\n      } else {\n        pathname = resolvePathname(toPathname, fromPathname);\n      }\n    }\n  } else {\n    pathname = fromPathname;\n  }\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 getInvalidPathError(\n  char: string,\n  field: string,\n  dest: string,\n  path: Partial<Path>\n) {\n  return (\n    `Cannot include a '${char}' character in a manually specified ` +\n    `\\`to.${field}\\` field [${JSON.stringify(\n      path\n    )}].  Please separate it out to the ` +\n    `\\`to.${dest}\\` field. Alternatively you may provide the full path as ` +\n    `a string in <Link to=\"...\"> and the router will parse it for you.`\n  );\n}\n\n/**\n * @private\n *\n * When processing relative navigation we want to ignore ancestor routes that\n * do not contribute to the path, such that index/pathless layout routes don't\n * interfere.\n *\n * For example, when moving a route element into an index route and/or a\n * pathless layout route, relative link behavior contained within should stay\n * the same.  Both of the following examples should link back to the root:\n *\n *   <Route path=\"/\">\n *     <Route path=\"accounts\" element={<Link to=\"..\"}>\n *   </Route>\n *\n *   <Route path=\"/\">\n *     <Route path=\"accounts\">\n *       <Route element={<AccountsLayout />}>       // <-- Does not contribute\n *         <Route index element={<Link to=\"..\"} />  // <-- Does not contribute\n *       </Route\n *     </Route>\n *   </Route>\n */\nexport function getPathContributingMatches<\n  T extends AgnosticRouteMatch = AgnosticRouteMatch\n>(matches: T[]) {\n  return matches.filter(\n    (match, index) =>\n      index === 0 || (match.route.path && match.route.path.length > 0)\n  );\n}\n\n// Return the array of pathnames for the current route matches - used to\n// generate the routePathnames input for resolveTo()\nexport function getResolveToMatches<\n  T extends AgnosticRouteMatch = AgnosticRouteMatch\n>(matches: T[], v7_relativeSplatPath: boolean) {\n  let pathMatches = getPathContributingMatches(matches);\n\n  // When v7_relativeSplatPath is enabled, use the full pathname for the leaf\n  // match so we include splat values for \".\" links.  See:\n  // https://github.com/remix-run/react-router/issues/11052#issuecomment-1836589329\n  if (v7_relativeSplatPath) {\n    return pathMatches.map((match, idx) =>\n      idx === pathMatches.length - 1 ? match.pathname : match.pathnameBase\n    );\n  }\n\n  return pathMatches.map((match) => match.pathnameBase);\n}\n\n/**\n * @private\n */\nexport function resolveTo(\n  toArg: To,\n  routePathnames: string[],\n  locationPathname: string,\n  isPathRelative = false\n): Path {\n  let to: Partial<Path>;\n  if (typeof toArg === \"string\") {\n    to = parsePath(toArg);\n  } else {\n    to = { ...toArg };\n\n    invariant(\n      !to.pathname || !to.pathname.includes(\"?\"),\n      getInvalidPathError(\"?\", \"pathname\", \"search\", to)\n    );\n    invariant(\n      !to.pathname || !to.pathname.includes(\"#\"),\n      getInvalidPathError(\"#\", \"pathname\", \"hash\", to)\n    );\n    invariant(\n      !to.search || !to.search.includes(\"#\"),\n      getInvalidPathError(\"#\", \"search\", \"hash\", to)\n    );\n  }\n\n  let isEmptyPath = toArg === \"\" || to.pathname === \"\";\n  let toPathname = isEmptyPath ? \"/\" : to.pathname;\n\n  let from: string;\n\n  // Routing is relative to the current pathname if explicitly requested.\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  if (toPathname == null) {\n    from = locationPathname;\n  } else {\n    let routePathnameIndex = routePathnames.length - 1;\n\n    // With relative=\"route\" (the default), each leading .. segment means\n    // \"go up one route\" instead of \"go up one URL segment\".  This is a key\n    // difference from how <a href> works and a major reason we call this a\n    // \"to\" value instead of a \"href\".\n    if (!isPathRelative && toPathname.startsWith(\"..\")) {\n      let toSegments = toPathname.split(\"/\");\n\n      while (toSegments[0] === \"..\") {\n        toSegments.shift();\n        routePathnameIndex -= 1;\n      }\n\n      to.pathname = toSegments.join(\"/\");\n    }\n\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\" had one\n  let hasExplicitTrailingSlash =\n    toPathname && toPathname !== \"/\" && toPathname.endsWith(\"/\");\n  // Or if this was a link to the current path which has a trailing slash\n  let hasCurrentTrailingSlash =\n    (isEmptyPath || toPathname === \".\") && locationPathname.endsWith(\"/\");\n  if (\n    !path.pathname.endsWith(\"/\") &&\n    (hasExplicitTrailingSlash || hasCurrentTrailingSlash)\n  ) {\n    path.pathname += \"/\";\n  }\n\n  return path;\n}\n\n/**\n * @private\n */\nexport function 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\n/**\n * @private\n */\nexport const joinPaths = (paths: string[]): string =>\n  paths.join(\"/\").replace(/\\/\\/+/g, \"/\");\n\n/**\n * @private\n */\nexport const normalizePathname = (pathname: string): string =>\n  pathname.replace(/\\/+$/, \"\").replace(/^\\/*/, \"/\");\n\n/**\n * @private\n */\nexport const normalizeSearch = (search: string): string =>\n  !search || search === \"?\"\n    ? \"\"\n    : search.startsWith(\"?\")\n    ? search\n    : \"?\" + search;\n\n/**\n * @private\n */\nexport const normalizeHash = (hash: string): string =>\n  !hash || hash === \"#\" ? \"\" : hash.startsWith(\"#\") ? hash : \"#\" + hash;\n\nexport type JsonFunction = <Data>(\n  data: Data,\n  init?: number | ResponseInit\n) => Response;\n\n/**\n * This is a shortcut for creating `application/json` responses. Converts `data`\n * to JSON and sets the `Content-Type` header.\n *\n * @deprecated The `json` method is deprecated in favor of returning raw objects.\n * This method will be removed in v7.\n */\nexport const json: JsonFunction = (data, init = {}) => {\n  let responseInit = typeof init === \"number\" ? { status: init } : init;\n\n  let headers = new Headers(responseInit.headers);\n  if (!headers.has(\"Content-Type\")) {\n    headers.set(\"Content-Type\", \"application/json; charset=utf-8\");\n  }\n\n  return new Response(JSON.stringify(data), {\n    ...responseInit,\n    headers,\n  });\n};\n\nexport class DataWithResponseInit<D> {\n  type: string = \"DataWithResponseInit\";\n  data: D;\n  init: ResponseInit | null;\n\n  constructor(data: D, init?: ResponseInit) {\n    this.data = data;\n    this.init = init || null;\n  }\n}\n\n/**\n * Create \"responses\" that contain `status`/`headers` without forcing\n * serialization into an actual `Response` - used by Remix single fetch\n */\nexport function data<D>(data: D, init?: number | ResponseInit) {\n  return new DataWithResponseInit(\n    data,\n    typeof init === \"number\" ? { status: init } : init\n  );\n}\n\nexport interface TrackedPromise extends Promise<any> {\n  _tracked?: boolean;\n  _data?: any;\n  _error?: any;\n}\n\nexport class AbortedDeferredError extends Error {}\n\nexport class DeferredData {\n  private pendingKeysSet: Set<string> = new Set<string>();\n  private controller: AbortController;\n  private abortPromise: Promise<void>;\n  private unlistenAbortSignal: () => void;\n  private subscribers: Set<(aborted: boolean, settledKey?: string) => void> =\n    new Set();\n  data: Record<string, unknown>;\n  init?: ResponseInit;\n  deferredKeys: string[] = [];\n\n  constructor(data: Record<string, unknown>, responseInit?: ResponseInit) {\n    invariant(\n      data && typeof data === \"object\" && !Array.isArray(data),\n      \"defer() only accepts plain objects\"\n    );\n\n    // Set up an AbortController + Promise we can race against to exit early\n    // cancellation\n    let reject: (e: AbortedDeferredError) => void;\n    this.abortPromise = new Promise((_, r) => (reject = r));\n    this.controller = new AbortController();\n    let onAbort = () =>\n      reject(new AbortedDeferredError(\"Deferred data aborted\"));\n    this.unlistenAbortSignal = () =>\n      this.controller.signal.removeEventListener(\"abort\", onAbort);\n    this.controller.signal.addEventListener(\"abort\", onAbort);\n\n    this.data = Object.entries(data).reduce(\n      (acc, [key, value]) =>\n        Object.assign(acc, {\n          [key]: this.trackPromise(key, value),\n        }),\n      {}\n    );\n\n    if (this.done) {\n      // All incoming values were resolved\n      this.unlistenAbortSignal();\n    }\n\n    this.init = responseInit;\n  }\n\n  private trackPromise(\n    key: string,\n    value: Promise<unknown> | unknown\n  ): TrackedPromise | unknown {\n    if (!(value instanceof Promise)) {\n      return value;\n    }\n\n    this.deferredKeys.push(key);\n    this.pendingKeysSet.add(key);\n\n    // We store a little wrapper promise that will be extended with\n    // _data/_error props upon resolve/reject\n    let promise: TrackedPromise = Promise.race([value, this.abortPromise]).then(\n      (data) => this.onSettle(promise, key, undefined, data as unknown),\n      (error) => this.onSettle(promise, key, error as unknown)\n    );\n\n    // Register rejection listeners to avoid uncaught promise rejections on\n    // errors or aborted deferred values\n    promise.catch(() => {});\n\n    Object.defineProperty(promise, \"_tracked\", { get: () => true });\n    return promise;\n  }\n\n  private onSettle(\n    promise: TrackedPromise,\n    key: string,\n    error: unknown,\n    data?: unknown\n  ): unknown {\n    if (\n      this.controller.signal.aborted &&\n      error instanceof AbortedDeferredError\n    ) {\n      this.unlistenAbortSignal();\n      Object.defineProperty(promise, \"_error\", { get: () => error });\n      return Promise.reject(error);\n    }\n\n    this.pendingKeysSet.delete(key);\n\n    if (this.done) {\n      // Nothing left to abort!\n      this.unlistenAbortSignal();\n    }\n\n    // If the promise was resolved/rejected with undefined, we'll throw an error as you\n    // should always resolve with a value or null\n    if (error === undefined && data === undefined) {\n      let undefinedError = new Error(\n        `Deferred data for key \"${key}\" resolved/rejected with \\`undefined\\`, ` +\n          `you must resolve/reject with a value or \\`null\\`.`\n      );\n      Object.defineProperty(promise, \"_error\", { get: () => undefinedError });\n      this.emit(false, key);\n      return Promise.reject(undefinedError);\n    }\n\n    if (data === undefined) {\n      Object.defineProperty(promise, \"_error\", { get: () => error });\n      this.emit(false, key);\n      return Promise.reject(error);\n    }\n\n    Object.defineProperty(promise, \"_data\", { get: () => data });\n    this.emit(false, key);\n    return data;\n  }\n\n  private emit(aborted: boolean, settledKey?: string) {\n    this.subscribers.forEach((subscriber) => subscriber(aborted, settledKey));\n  }\n\n  subscribe(fn: (aborted: boolean, settledKey?: string) => void) {\n    this.subscribers.add(fn);\n    return () => this.subscribers.delete(fn);\n  }\n\n  cancel() {\n    this.controller.abort();\n    this.pendingKeysSet.forEach((v, k) => this.pendingKeysSet.delete(k));\n    this.emit(true);\n  }\n\n  async resolveData(signal: AbortSignal) {\n    let aborted = false;\n    if (!this.done) {\n      let onAbort = () => this.cancel();\n      signal.addEventListener(\"abort\", onAbort);\n      aborted = await new Promise((resolve) => {\n        this.subscribe((aborted) => {\n          signal.removeEventListener(\"abort\", onAbort);\n          if (aborted || this.done) {\n            resolve(aborted);\n          }\n        });\n      });\n    }\n    return aborted;\n  }\n\n  get done() {\n    return this.pendingKeysSet.size === 0;\n  }\n\n  get unwrappedData() {\n    invariant(\n      this.data !== null && this.done,\n      \"Can only unwrap data on initialized and settled deferreds\"\n    );\n\n    return Object.entries(this.data).reduce(\n      (acc, [key, value]) =>\n        Object.assign(acc, {\n          [key]: unwrapTrackedPromise(value),\n        }),\n      {}\n    );\n  }\n\n  get pendingKeys() {\n    return Array.from(this.pendingKeysSet);\n  }\n}\n\nfunction isTrackedPromise(value: any): value is TrackedPromise {\n  return (\n    value instanceof Promise && (value as TrackedPromise)._tracked === true\n  );\n}\n\nfunction unwrapTrackedPromise(value: any) {\n  if (!isTrackedPromise(value)) {\n    return value;\n  }\n\n  if (value._error) {\n    throw value._error;\n  }\n  return value._data;\n}\n\nexport type DeferFunction = (\n  data: Record<string, unknown>,\n  init?: number | ResponseInit\n) => DeferredData;\n\n/**\n * @deprecated The `defer` method is deprecated in favor of returning raw\n * objects. This method will be removed in v7.\n */\nexport const defer: DeferFunction = (data, init = {}) => {\n  let responseInit = typeof init === \"number\" ? { status: init } : init;\n\n  return new DeferredData(data, responseInit);\n};\n\nexport type RedirectFunction = (\n  url: string,\n  init?: number | ResponseInit\n) => Response;\n\n/**\n * A redirect response. Sets the status code and the `Location` header.\n * Defaults to \"302 Found\".\n */\nexport const redirect: RedirectFunction = (url, init = 302) => {\n  let responseInit = init;\n  if (typeof responseInit === \"number\") {\n    responseInit = { status: responseInit };\n  } else if (typeof responseInit.status === \"undefined\") {\n    responseInit.status = 302;\n  }\n\n  let headers = new Headers(responseInit.headers);\n  headers.set(\"Location\", url);\n\n  return new Response(null, {\n    ...responseInit,\n    headers,\n  });\n};\n\n/**\n * A redirect response that will force a document reload to the new location.\n * Sets the status code and the `Location` header.\n * Defaults to \"302 Found\".\n */\nexport const redirectDocument: RedirectFunction = (url, init) => {\n  let response = redirect(url, init);\n  response.headers.set(\"X-Remix-Reload-Document\", \"true\");\n  return response;\n};\n\n/**\n * A redirect response that will perform a `history.replaceState` instead of a\n * `history.pushState` for client-side navigation redirects.\n * Sets the status code and the `Location` header.\n * Defaults to \"302 Found\".\n */\nexport const replace: RedirectFunction = (url, init) => {\n  let response = redirect(url, init);\n  response.headers.set(\"X-Remix-Replace\", \"true\");\n  return response;\n};\n\nexport type ErrorResponse = {\n  status: number;\n  statusText: string;\n  data: any;\n};\n\n/**\n * @private\n * Utility class we use to hold auto-unwrapped 4xx/5xx Response bodies\n *\n * We don't export the class for public use since it's an implementation\n * detail, but we export the interface above so folks can build their own\n * abstractions around instances via isRouteErrorResponse()\n */\nexport class ErrorResponseImpl implements ErrorResponse {\n  status: number;\n  statusText: string;\n  data: any;\n  private error?: Error;\n  private internal: boolean;\n\n  constructor(\n    status: number,\n    statusText: string | undefined,\n    data: any,\n    internal = false\n  ) {\n    this.status = status;\n    this.statusText = statusText || \"\";\n    this.internal = internal;\n    if (data instanceof Error) {\n      this.data = data.toString();\n      this.error = data;\n    } else {\n      this.data = data;\n    }\n  }\n}\n\n/**\n * Check if the given error is an ErrorResponse generated from a 4xx/5xx\n * Response thrown from an action/loader\n */\nexport function isRouteErrorResponse(error: any): error is ErrorResponse {\n  return (\n    error != null &&\n    typeof error.status === \"number\" &&\n    typeof error.statusText === \"string\" &&\n    typeof error.internal === \"boolean\" &&\n    \"data\" in error\n  );\n}\n","import type { History, Location, Path, To } from \"./history\";\nimport {\n  Action as HistoryAction,\n  createLocation,\n  createPath,\n  invariant,\n  parsePath,\n  warning,\n} from \"./history\";\nimport type {\n  AgnosticDataRouteMatch,\n  AgnosticDataRouteObject,\n  DataStrategyMatch,\n  AgnosticRouteObject,\n  DataResult,\n  DataStrategyFunction,\n  DataStrategyFunctionArgs,\n  DeferredData,\n  DeferredResult,\n  DetectErrorBoundaryFunction,\n  ErrorResult,\n  FormEncType,\n  FormMethod,\n  HTMLFormMethod,\n  DataStrategyResult,\n  ImmutableRouteKey,\n  MapRoutePropertiesFunction,\n  MutationFormMethod,\n  RedirectResult,\n  RouteData,\n  RouteManifest,\n  ShouldRevalidateFunctionArgs,\n  Submission,\n  SuccessResult,\n  UIMatch,\n  V7_FormMethod,\n  V7_MutationFormMethod,\n  AgnosticPatchRoutesOnNavigationFunction,\n  DataWithResponseInit,\n} from \"./utils\";\nimport {\n  ErrorResponseImpl,\n  ResultType,\n  convertRouteMatchToUiMatch,\n  convertRoutesToDataRoutes,\n  getPathContributingMatches,\n  getResolveToMatches,\n  immutableRouteKeys,\n  isRouteErrorResponse,\n  joinPaths,\n  matchRoutes,\n  matchRoutesImpl,\n  resolveTo,\n  stripBasename,\n} from \"./utils\";\n\n////////////////////////////////////////////////////////////////////////////////\n//#region Types and Constants\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * A Router instance manages all navigation and data loading/mutations\n */\nexport interface Router {\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Return the basename for the router\n   */\n  get basename(): RouterInit[\"basename\"];\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Return the future config for the router\n   */\n  get future(): FutureConfig;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Return the current state of the router\n   */\n  get state(): RouterState;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Return the routes for this router instance\n   */\n  get routes(): AgnosticDataRouteObject[];\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Return the window associated with the router\n   */\n  get window(): RouterInit[\"window\"];\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Initialize the router, including adding history listeners and kicking off\n   * initial data fetches.  Returns a function to cleanup listeners and abort\n   * any in-progress loads\n   */\n  initialize(): Router;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Subscribe to router.state updates\n   *\n   * @param fn function to call with the new state\n   */\n  subscribe(fn: RouterSubscriber): () => void;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Enable scroll restoration behavior in the router\n   *\n   * @param savedScrollPositions Object that will manage positions, in case\n   *                             it's being restored from sessionStorage\n   * @param getScrollPosition    Function to get the active Y scroll position\n   * @param getKey               Function to get the key to use for restoration\n   */\n  enableScrollRestoration(\n    savedScrollPositions: Record<string, number>,\n    getScrollPosition: GetScrollPositionFunction,\n    getKey?: GetScrollRestorationKeyFunction\n  ): () => void;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Navigate forward/backward in the history stack\n   * @param to Delta to move in the history stack\n   */\n  navigate(to: number): Promise<void>;\n\n  /**\n   * Navigate to the given path\n   * @param to Path to navigate to\n   * @param opts Navigation options (method, submission, etc.)\n   */\n  navigate(to: To | null, opts?: RouterNavigateOptions): Promise<void>;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Trigger a fetcher load/submission\n   *\n   * @param key     Fetcher key\n   * @param routeId Route that owns the fetcher\n   * @param href    href to fetch\n   * @param opts    Fetcher options, (method, submission, etc.)\n   */\n  fetch(\n    key: string,\n    routeId: string,\n    href: string | null,\n    opts?: RouterFetchOptions\n  ): void;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Trigger a revalidation of all current route loaders and fetcher loads\n   */\n  revalidate(): void;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Utility function to create an href for the given location\n   * @param location\n   */\n  createHref(location: Location | URL): string;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Utility function to URL encode a destination path according to the internal\n   * history implementation\n   * @param to\n   */\n  encodeLocation(to: To): Path;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Get/create a fetcher for the given key\n   * @param key\n   */\n  getFetcher<TData = any>(key: string): Fetcher<TData>;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Delete the fetcher for a given key\n   * @param key\n   */\n  deleteFetcher(key: string): void;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Cleanup listeners and abort any in-progress loads\n   */\n  dispose(): void;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Get a navigation blocker\n   * @param key The identifier for the blocker\n   * @param fn The blocker function implementation\n   */\n  getBlocker(key: string, fn: BlockerFunction): Blocker;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Delete a navigation blocker\n   * @param key The identifier for the blocker\n   */\n  deleteBlocker(key: string): void;\n\n  /**\n   * @internal\n   * PRIVATE DO NOT USE\n   *\n   * Patch additional children routes into an existing parent route\n   * @param routeId The parent route id or a callback function accepting `patch`\n   *                to perform batch patching\n   * @param children The additional children routes\n   */\n  patchRoutes(routeId: string | null, children: AgnosticRouteObject[]): void;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * HMR needs to pass in-flight route updates to React Router\n   * TODO: Replace this with granular route update APIs (addRoute, updateRoute, deleteRoute)\n   */\n  _internalSetRoutes(routes: AgnosticRouteObject[]): void;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Internal fetch AbortControllers accessed by unit tests\n   */\n  _internalFetchControllers: Map<string, AbortController>;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Internal pending DeferredData instances accessed by unit tests\n   */\n  _internalActiveDeferreds: Map<string, DeferredData>;\n}\n\n/**\n * State maintained internally by the router.  During a navigation, all states\n * reflect the the \"old\" location unless otherwise noted.\n */\nexport interface RouterState {\n  /**\n   * The action of the most recent navigation\n   */\n  historyAction: HistoryAction;\n\n  /**\n   * The current location reflected by the router\n   */\n  location: Location;\n\n  /**\n   * The current set of route matches\n   */\n  matches: AgnosticDataRouteMatch[];\n\n  /**\n   * Tracks whether we've completed our initial data load\n   */\n  initialized: boolean;\n\n  /**\n   * Current scroll position we should start at for a new view\n   *  - number -> scroll position to restore to\n   *  - false -> do not restore scroll at all (used during submissions)\n   *  - null -> don't have a saved position, scroll to hash or top of page\n   */\n  restoreScrollPosition: number | false | null;\n\n  /**\n   * Indicate whether this navigation should skip resetting the scroll position\n   * if we are unable to restore the scroll position\n   */\n  preventScrollReset: boolean;\n\n  /**\n   * Tracks the state of the current navigation\n   */\n  navigation: Navigation;\n\n  /**\n   * Tracks any in-progress revalidations\n   */\n  revalidation: RevalidationState;\n\n  /**\n   * Data from the loaders for the current matches\n   */\n  loaderData: RouteData;\n\n  /**\n   * Data from the action for the current matches\n   */\n  actionData: RouteData | null;\n\n  /**\n   * Errors caught from loaders for the current matches\n   */\n  errors: RouteData | null;\n\n  /**\n   * Map of current fetchers\n   */\n  fetchers: Map<string, Fetcher>;\n\n  /**\n   * Map of current blockers\n   */\n  blockers: Map<string, Blocker>;\n}\n\n/**\n * Data that can be passed into hydrate a Router from SSR\n */\nexport type HydrationState = Partial<\n  Pick<RouterState, \"loaderData\" | \"actionData\" | \"errors\">\n>;\n\n/**\n * Future flags to toggle new feature behavior\n */\nexport interface FutureConfig {\n  v7_fetcherPersist: boolean;\n  v7_normalizeFormMethod: boolean;\n  v7_partialHydration: boolean;\n  v7_prependBasename: boolean;\n  v7_relativeSplatPath: boolean;\n  v7_skipActionErrorRevalidation: boolean;\n}\n\n/**\n * Initialization options for createRouter\n */\nexport interface RouterInit {\n  routes: AgnosticRouteObject[];\n  history: History;\n  basename?: string;\n  /**\n   * @deprecated Use `mapRouteProperties` instead\n   */\n  detectErrorBoundary?: DetectErrorBoundaryFunction;\n  mapRouteProperties?: MapRoutePropertiesFunction;\n  future?: Partial<FutureConfig>;\n  hydrationData?: HydrationState;\n  window?: Window;\n  dataStrategy?: DataStrategyFunction;\n  patchRoutesOnNavigation?: AgnosticPatchRoutesOnNavigationFunction;\n}\n\n/**\n * State returned from a server-side query() call\n */\nexport interface StaticHandlerContext {\n  basename: Router[\"basename\"];\n  location: RouterState[\"location\"];\n  matches: RouterState[\"matches\"];\n  loaderData: RouterState[\"loaderData\"];\n  actionData: RouterState[\"actionData\"];\n  errors: RouterState[\"errors\"];\n  statusCode: number;\n  loaderHeaders: Record<string, Headers>;\n  actionHeaders: Record<string, Headers>;\n  activeDeferreds: Record<string, DeferredData> | null;\n  _deepestRenderedBoundaryId?: string | null;\n}\n\n/**\n * A StaticHandler instance manages a singular SSR navigation/fetch event\n */\nexport interface StaticHandler {\n  dataRoutes: AgnosticDataRouteObject[];\n  query(\n    request: Request,\n    opts?: {\n      requestContext?: unknown;\n      skipLoaderErrorBubbling?: boolean;\n      dataStrategy?: DataStrategyFunction;\n    }\n  ): Promise<StaticHandlerContext | Response>;\n  queryRoute(\n    request: Request,\n    opts?: {\n      routeId?: string;\n      requestContext?: unknown;\n      dataStrategy?: DataStrategyFunction;\n    }\n  ): Promise<any>;\n}\n\ntype ViewTransitionOpts = {\n  currentLocation: Location;\n  nextLocation: Location;\n};\n\n/**\n * Subscriber function signature for changes to router state\n */\nexport interface RouterSubscriber {\n  (\n    state: RouterState,\n    opts: {\n      deletedFetchers: string[];\n      viewTransitionOpts?: ViewTransitionOpts;\n      flushSync: boolean;\n    }\n  ): void;\n}\n\n/**\n * Function signature for determining the key to be used in scroll restoration\n * for a given location\n */\nexport interface GetScrollRestorationKeyFunction {\n  (location: Location, matches: UIMatch[]): string | null;\n}\n\n/**\n * Function signature for determining the current scroll position\n */\nexport interface GetScrollPositionFunction {\n  (): number;\n}\n\nexport type RelativeRoutingType = \"route\" | \"path\";\n\n// Allowed for any navigation or fetch\ntype BaseNavigateOrFetchOptions = {\n  preventScrollReset?: boolean;\n  relative?: RelativeRoutingType;\n  flushSync?: boolean;\n};\n\n// Only allowed for navigations\ntype BaseNavigateOptions = BaseNavigateOrFetchOptions & {\n  replace?: boolean;\n  state?: any;\n  fromRouteId?: string;\n  viewTransition?: boolean;\n};\n\n// Only allowed for submission navigations\ntype BaseSubmissionOptions = {\n  formMethod?: HTMLFormMethod;\n  formEncType?: FormEncType;\n} & (\n  | { formData: FormData; body?: undefined }\n  | { formData?: undefined; body: any }\n);\n\n/**\n * Options for a navigate() call for a normal (non-submission) navigation\n */\ntype LinkNavigateOptions = BaseNavigateOptions;\n\n/**\n * Options for a navigate() call for a submission navigation\n */\ntype SubmissionNavigateOptions = BaseNavigateOptions & BaseSubmissionOptions;\n\n/**\n * Options to pass to navigate() for a navigation\n */\nexport type RouterNavigateOptions =\n  | LinkNavigateOptions\n  | SubmissionNavigateOptions;\n\n/**\n * Options for a fetch() load\n */\ntype LoadFetchOptions = BaseNavigateOrFetchOptions;\n\n/**\n * Options for a fetch() submission\n */\ntype SubmitFetchOptions = BaseNavigateOrFetchOptions & BaseSubmissionOptions;\n\n/**\n * Options to pass to fetch()\n */\nexport type RouterFetchOptions = LoadFetchOptions | SubmitFetchOptions;\n\n/**\n * Potential states for state.navigation\n */\nexport type NavigationStates = {\n  Idle: {\n    state: \"idle\";\n    location: undefined;\n    formMethod: undefined;\n    formAction: undefined;\n    formEncType: undefined;\n    formData: undefined;\n    json: undefined;\n    text: undefined;\n  };\n  Loading: {\n    state: \"loading\";\n    location: Location;\n    formMethod: Submission[\"formMethod\"] | undefined;\n    formAction: Submission[\"formAction\"] | undefined;\n    formEncType: Submission[\"formEncType\"] | undefined;\n    formData: Submission[\"formData\"] | undefined;\n    json: Submission[\"json\"] | undefined;\n    text: Submission[\"text\"] | undefined;\n  };\n  Submitting: {\n    state: \"submitting\";\n    location: Location;\n    formMethod: Submission[\"formMethod\"];\n    formAction: Submission[\"formAction\"];\n    formEncType: Submission[\"formEncType\"];\n    formData: Submission[\"formData\"];\n    json: Submission[\"json\"];\n    text: Submission[\"text\"];\n  };\n};\n\nexport type Navigation = NavigationStates[keyof NavigationStates];\n\nexport type RevalidationState = \"idle\" | \"loading\";\n\n/**\n * Potential states for fetchers\n */\ntype FetcherStates<TData = any> = {\n  Idle: {\n    state: \"idle\";\n    formMethod: undefined;\n    formAction: undefined;\n    formEncType: undefined;\n    text: undefined;\n    formData: undefined;\n    json: undefined;\n    data: TData | undefined;\n  };\n  Loading: {\n    state: \"loading\";\n    formMethod: Submission[\"formMethod\"] | undefined;\n    formAction: Submission[\"formAction\"] | undefined;\n    formEncType: Submission[\"formEncType\"] | undefined;\n    text: Submission[\"text\"] | undefined;\n    formData: Submission[\"formData\"] | undefined;\n    json: Submission[\"json\"] | undefined;\n    data: TData | undefined;\n  };\n  Submitting: {\n    state: \"submitting\";\n    formMethod: Submission[\"formMethod\"];\n    formAction: Submission[\"formAction\"];\n    formEncType: Submission[\"formEncType\"];\n    text: Submission[\"text\"];\n    formData: Submission[\"formData\"];\n    json: Submission[\"json\"];\n    data: TData | undefined;\n  };\n};\n\nexport type Fetcher<TData = any> =\n  FetcherStates<TData>[keyof FetcherStates<TData>];\n\ninterface BlockerBlocked {\n  state: \"blocked\";\n  reset(): void;\n  proceed(): void;\n  location: Location;\n}\n\ninterface BlockerUnblocked {\n  state: \"unblocked\";\n  reset: undefined;\n  proceed: undefined;\n  location: undefined;\n}\n\ninterface BlockerProceeding {\n  state: \"proceeding\";\n  reset: undefined;\n  proceed: undefined;\n  location: Location;\n}\n\nexport type Blocker = BlockerUnblocked | BlockerBlocked | BlockerProceeding;\n\nexport type BlockerFunction = (args: {\n  currentLocation: Location;\n  nextLocation: Location;\n  historyAction: HistoryAction;\n}) => boolean;\n\ninterface ShortCircuitable {\n  /**\n   * startNavigation does not need to complete the navigation because we\n   * redirected or got interrupted\n   */\n  shortCircuited?: boolean;\n}\n\ntype PendingActionResult = [string, SuccessResult | ErrorResult];\n\ninterface HandleActionResult extends ShortCircuitable {\n  /**\n   * Route matches which may have been updated from fog of war discovery\n   */\n  matches?: RouterState[\"matches\"];\n  /**\n   * Tuple for the returned or thrown value from the current action.  The routeId\n   * is the action route for success and the bubbled boundary route for errors.\n   */\n  pendingActionResult?: PendingActionResult;\n}\n\ninterface HandleLoadersResult extends ShortCircuitable {\n  /**\n   * Route matches which may have been updated from fog of war discovery\n   */\n  matches?: RouterState[\"matches\"];\n  /**\n   * loaderData returned from the current set of loaders\n   */\n  loaderData?: RouterState[\"loaderData\"];\n  /**\n   * errors thrown from the current set of loaders\n   */\n  errors?: RouterState[\"errors\"];\n}\n\n/**\n * Cached info for active fetcher.load() instances so they can participate\n * in revalidation\n */\ninterface FetchLoadMatch {\n  routeId: string;\n  path: string;\n}\n\n/**\n * Identified fetcher.load() calls that need to be revalidated\n */\ninterface RevalidatingFetcher extends FetchLoadMatch {\n  key: string;\n  match: AgnosticDataRouteMatch | null;\n  matches: AgnosticDataRouteMatch[] | null;\n  controller: AbortController | null;\n}\n\nconst validMutationMethodsArr: MutationFormMethod[] = [\n  \"post\",\n  \"put\",\n  \"patch\",\n  \"delete\",\n];\nconst validMutationMethods = new Set<MutationFormMethod>(\n  validMutationMethodsArr\n);\n\nconst validRequestMethodsArr: FormMethod[] = [\n  \"get\",\n  ...validMutationMethodsArr,\n];\nconst validRequestMethods = new Set<FormMethod>(validRequestMethodsArr);\n\nconst redirectStatusCodes = new Set([301, 302, 303, 307, 308]);\nconst redirectPreserveMethodStatusCodes = new Set([307, 308]);\n\nexport const IDLE_NAVIGATION: NavigationStates[\"Idle\"] = {\n  state: \"idle\",\n  location: undefined,\n  formMethod: undefined,\n  formAction: undefined,\n  formEncType: undefined,\n  formData: undefined,\n  json: undefined,\n  text: undefined,\n};\n\nexport const IDLE_FETCHER: FetcherStates[\"Idle\"] = {\n  state: \"idle\",\n  data: undefined,\n  formMethod: undefined,\n  formAction: undefined,\n  formEncType: undefined,\n  formData: undefined,\n  json: undefined,\n  text: undefined,\n};\n\nexport const IDLE_BLOCKER: BlockerUnblocked = {\n  state: \"unblocked\",\n  proceed: undefined,\n  reset: undefined,\n  location: undefined,\n};\n\nconst ABSOLUTE_URL_REGEX = /^(?:[a-z][a-z0-9+.-]*:|\\/\\/)/i;\n\nconst defaultMapRouteProperties: MapRoutePropertiesFunction = (route) => ({\n  hasErrorBoundary: Boolean(route.hasErrorBoundary),\n});\n\nconst TRANSITIONS_STORAGE_KEY = \"remix-router-transitions\";\n\n//#endregion\n\n////////////////////////////////////////////////////////////////////////////////\n//#region createRouter\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * Create a router and listen to history POP navigations\n */\nexport function createRouter(init: RouterInit): Router {\n  const routerWindow = init.window\n    ? init.window\n    : typeof window !== \"undefined\"\n    ? window\n    : undefined;\n  const isBrowser =\n    typeof routerWindow !== \"undefined\" &&\n    typeof routerWindow.document !== \"undefined\" &&\n    typeof routerWindow.document.createElement !== \"undefined\";\n  const isServer = !isBrowser;\n\n  invariant(\n    init.routes.length > 0,\n    \"You must provide a non-empty routes array to createRouter\"\n  );\n\n  let mapRouteProperties: MapRoutePropertiesFunction;\n  if (init.mapRouteProperties) {\n    mapRouteProperties = init.mapRouteProperties;\n  } else if (init.detectErrorBoundary) {\n    // If they are still using the deprecated version, wrap it with the new API\n    let detectErrorBoundary = init.detectErrorBoundary;\n    mapRouteProperties = (route) => ({\n      hasErrorBoundary: detectErrorBoundary(route),\n    });\n  } else {\n    mapRouteProperties = defaultMapRouteProperties;\n  }\n\n  // Routes keyed by ID\n  let manifest: RouteManifest = {};\n  // Routes in tree format for matching\n  let dataRoutes = convertRoutesToDataRoutes(\n    init.routes,\n    mapRouteProperties,\n    undefined,\n    manifest\n  );\n  let inFlightDataRoutes: AgnosticDataRouteObject[] | undefined;\n  let basename = init.basename || \"/\";\n  let dataStrategyImpl = init.dataStrategy || defaultDataStrategy;\n  let patchRoutesOnNavigationImpl = init.patchRoutesOnNavigation;\n\n  // Config driven behavior flags\n  let future: FutureConfig = {\n    v7_fetcherPersist: false,\n    v7_normalizeFormMethod: false,\n    v7_partialHydration: false,\n    v7_prependBasename: false,\n    v7_relativeSplatPath: false,\n    v7_skipActionErrorRevalidation: false,\n    ...init.future,\n  };\n  // Cleanup function for history\n  let unlistenHistory: (() => void) | null = null;\n  // Externally-provided functions to call on all state changes\n  let subscribers = new Set<RouterSubscriber>();\n  // Externally-provided object to hold scroll restoration locations during routing\n  let savedScrollPositions: Record<string, number> | null = null;\n  // Externally-provided function to get scroll restoration keys\n  let getScrollRestorationKey: GetScrollRestorationKeyFunction | null = null;\n  // Externally-provided function to get current scroll position\n  let getScrollPosition: GetScrollPositionFunction | null = null;\n  // One-time flag to control the initial hydration scroll restoration.  Because\n  // we don't get the saved positions from <ScrollRestoration /> until _after_\n  // the initial render, we need to manually trigger a separate updateState to\n  // send along the restoreScrollPosition\n  // Set to true if we have `hydrationData` since we assume we were SSR'd and that\n  // SSR did the initial scroll restoration.\n  let initialScrollRestored = init.hydrationData != null;\n\n  let initialMatches = matchRoutes(dataRoutes, init.history.location, basename);\n  let initialMatchesIsFOW = false;\n  let initialErrors: RouteData | null = null;\n\n  if (initialMatches == null && !patchRoutesOnNavigationImpl) {\n    // If we do not match a user-provided-route, fall back to the root\n    // to allow the error boundary to take over\n    let error = getInternalRouterError(404, {\n      pathname: init.history.location.pathname,\n    });\n    let { matches, route } = getShortCircuitMatches(dataRoutes);\n    initialMatches = matches;\n    initialErrors = { [route.id]: error };\n  }\n\n  // In SPA apps, if the user provided a patchRoutesOnNavigation implementation and\n  // our initial match is a splat route, clear them out so we run through lazy\n  // discovery on hydration in case there's a more accurate lazy route match.\n  // In SSR apps (with `hydrationData`), we expect that the server will send\n  // up the proper matched routes so we don't want to run lazy discovery on\n  // initial hydration and want to hydrate into the splat route.\n  if (initialMatches && !init.hydrationData) {\n    let fogOfWar = checkFogOfWar(\n      initialMatches,\n      dataRoutes,\n      init.history.location.pathname\n    );\n    if (fogOfWar.active) {\n      initialMatches = null;\n    }\n  }\n\n  let initialized: boolean;\n  if (!initialMatches) {\n    initialized = false;\n    initialMatches = [];\n\n    // If partial hydration and fog of war is enabled, we will be running\n    // `patchRoutesOnNavigation` during hydration so include any partial matches as\n    // the initial matches so we can properly render `HydrateFallback`'s\n    if (future.v7_partialHydration) {\n      let fogOfWar = checkFogOfWar(\n        null,\n        dataRoutes,\n        init.history.location.pathname\n      );\n      if (fogOfWar.active && fogOfWar.matches) {\n        initialMatchesIsFOW = true;\n        initialMatches = fogOfWar.matches;\n      }\n    }\n  } else if (initialMatches.some((m) => m.route.lazy)) {\n    // All initialMatches need to be loaded before we're ready.  If we have lazy\n    // functions around still then we'll need to run them in initialize()\n    initialized = false;\n  } else if (!initialMatches.some((m) => m.route.loader)) {\n    // If we've got no loaders to run, then we're good to go\n    initialized = true;\n  } else if (future.v7_partialHydration) {\n    // If partial hydration is enabled, we're initialized so long as we were\n    // provided with hydrationData for every route with a loader, and no loaders\n    // were marked for explicit hydration\n    let loaderData = init.hydrationData ? init.hydrationData.loaderData : null;\n    let errors = init.hydrationData ? init.hydrationData.errors : null;\n    // If errors exist, don't consider routes below the boundary\n    if (errors) {\n      let idx = initialMatches.findIndex(\n        (m) => errors![m.route.id] !== undefined\n      );\n      initialized = initialMatches\n        .slice(0, idx + 1)\n        .every((m) => !shouldLoadRouteOnHydration(m.route, loaderData, errors));\n    } else {\n      initialized = initialMatches.every(\n        (m) => !shouldLoadRouteOnHydration(m.route, loaderData, errors)\n      );\n    }\n  } else {\n    // Without partial hydration - we're initialized if we were provided any\n    // hydrationData - which is expected to be complete\n    initialized = init.hydrationData != null;\n  }\n\n  let router: Router;\n  let state: RouterState = {\n    historyAction: init.history.action,\n    location: init.history.location,\n    matches: initialMatches,\n    initialized,\n    navigation: IDLE_NAVIGATION,\n    // Don't restore on initial updateState() if we were SSR'd\n    restoreScrollPosition: init.hydrationData != null ? false : null,\n    preventScrollReset: false,\n    revalidation: \"idle\",\n    loaderData: (init.hydrationData && init.hydrationData.loaderData) || {},\n    actionData: (init.hydrationData && init.hydrationData.actionData) || null,\n    errors: (init.hydrationData && init.hydrationData.errors) || initialErrors,\n    fetchers: new Map(),\n    blockers: new Map(),\n  };\n\n  // -- Stateful internal variables to manage navigations --\n  // Current navigation in progress (to be committed in completeNavigation)\n  let pendingAction: HistoryAction = HistoryAction.Pop;\n\n  // Should the current navigation prevent the scroll reset if scroll cannot\n  // be restored?\n  let pendingPreventScrollReset = false;\n\n  // AbortController for the active navigation\n  let pendingNavigationController: AbortController | null;\n\n  // Should the current navigation enable document.startViewTransition?\n  let pendingViewTransitionEnabled = false;\n\n  // Store applied view transitions so we can apply them on POP\n  let appliedViewTransitions: Map<string, Set<string>> = new Map<\n    string,\n    Set<string>\n  >();\n\n  // Cleanup function for persisting applied transitions to sessionStorage\n  let removePageHideEventListener: (() => void) | null = null;\n\n  // We use this to avoid touching history in completeNavigation if a\n  // revalidation is entirely uninterrupted\n  let isUninterruptedRevalidation = false;\n\n  // Use this internal flag to force revalidation of all loaders:\n  //  - submissions (completed or interrupted)\n  //  - useRevalidator()\n  //  - X-Remix-Revalidate (from redirect)\n  let isRevalidationRequired = false;\n\n  // Use this internal array to capture routes that require revalidation due\n  // to a cancelled deferred on action submission\n  let cancelledDeferredRoutes: string[] = [];\n\n  // Use this internal array to capture fetcher loads that were cancelled by an\n  // action navigation and require revalidation\n  let cancelledFetcherLoads: Set<string> = new Set();\n\n  // AbortControllers for any in-flight fetchers\n  let fetchControllers = new Map<string, AbortController>();\n\n  // Track loads based on the order in which they started\n  let incrementingLoadId = 0;\n\n  // Track the outstanding pending navigation data load to be compared against\n  // the globally incrementing load when a fetcher load lands after a completed\n  // navigation\n  let pendingNavigationLoadId = -1;\n\n  // Fetchers that triggered data reloads as a result of their actions\n  let fetchReloadIds = new Map<string, number>();\n\n  // Fetchers that triggered redirect navigations\n  let fetchRedirectIds = new Set<string>();\n\n  // Most recent href/match for fetcher.load calls for fetchers\n  let fetchLoadMatches = new Map<string, FetchLoadMatch>();\n\n  // Ref-count mounted fetchers so we know when it's ok to clean them up\n  let activeFetchers = new Map<string, number>();\n\n  // Fetchers that have requested a delete when using v7_fetcherPersist,\n  // they'll be officially removed after they return to idle\n  let deletedFetchers = new Set<string>();\n\n  // Store DeferredData instances for active route matches.  When a\n  // route loader returns defer() we stick one in here.  Then, when a nested\n  // promise resolves we update loaderData.  If a new navigation starts we\n  // cancel active deferreds for eliminated routes.\n  let activeDeferreds = new Map<string, DeferredData>();\n\n  // Store blocker functions in a separate Map outside of router state since\n  // we don't need to update UI state if they change\n  let blockerFunctions = new Map<string, BlockerFunction>();\n\n  // Map of pending patchRoutesOnNavigation() promises (keyed by path/matches) so\n  // that we only kick them off once for a given combo\n  let pendingPatchRoutes = new Map<\n    string,\n    ReturnType<AgnosticPatchRoutesOnNavigationFunction>\n  >();\n\n  // Flag to ignore the next history update, so we can revert the URL change on\n  // a POP navigation that was blocked by the user without touching router state\n  let unblockBlockerHistoryUpdate: (() => void) | undefined = undefined;\n\n  // Initialize the router, all side effects should be kicked off from here.\n  // Implemented as a Fluent API for ease of:\n  //   let router = createRouter(init).initialize();\n  function initialize() {\n    // If history informs us of a POP navigation, start the navigation but do not update\n    // state.  We'll update our own state once the navigation completes\n    unlistenHistory = init.history.listen(\n      ({ action: historyAction, location, delta }) => {\n        // Ignore this event if it was just us resetting the URL from a\n        // blocked POP navigation\n        if (unblockBlockerHistoryUpdate) {\n          unblockBlockerHistoryUpdate();\n          unblockBlockerHistoryUpdate = undefined;\n          return;\n        }\n\n        warning(\n          blockerFunctions.size === 0 || delta != null,\n          \"You are trying to use a blocker on a POP navigation to a location \" +\n            \"that was not created by @remix-run/router. This will fail silently in \" +\n            \"production. This can happen if you are navigating outside the router \" +\n            \"via `window.history.pushState`/`window.location.hash` instead of using \" +\n            \"router navigation APIs.  This can also happen if you are using \" +\n            \"createHashRouter and the user manually changes the URL.\"\n        );\n\n        let blockerKey = shouldBlockNavigation({\n          currentLocation: state.location,\n          nextLocation: location,\n          historyAction,\n        });\n\n        if (blockerKey && delta != null) {\n          // Restore the URL to match the current UI, but don't update router state\n          let nextHistoryUpdatePromise = new Promise<void>((resolve) => {\n            unblockBlockerHistoryUpdate = resolve;\n          });\n          init.history.go(delta * -1);\n\n          // Put the blocker into a blocked state\n          updateBlocker(blockerKey, {\n            state: \"blocked\",\n            location,\n            proceed() {\n              updateBlocker(blockerKey!, {\n                state: \"proceeding\",\n                proceed: undefined,\n                reset: undefined,\n                location,\n              });\n              // Re-do the same POP navigation we just blocked, after the url\n              // restoration is also complete.  See:\n              // https://github.com/remix-run/react-router/issues/11613\n              nextHistoryUpdatePromise.then(() => init.history.go(delta));\n            },\n            reset() {\n              let blockers = new Map(state.blockers);\n              blockers.set(blockerKey!, IDLE_BLOCKER);\n              updateState({ blockers });\n            },\n          });\n          return;\n        }\n\n        return startNavigation(historyAction, location);\n      }\n    );\n\n    if (isBrowser) {\n      // FIXME: This feels gross.  How can we cleanup the lines between\n      // scrollRestoration/appliedTransitions persistance?\n      restoreAppliedTransitions(routerWindow, appliedViewTransitions);\n      let _saveAppliedTransitions = () =>\n        persistAppliedTransitions(routerWindow, appliedViewTransitions);\n      routerWindow.addEventListener(\"pagehide\", _saveAppliedTransitions);\n      removePageHideEventListener = () =>\n        routerWindow.removeEventListener(\"pagehide\", _saveAppliedTransitions);\n    }\n\n    // Kick off initial data load if needed.  Use Pop to avoid modifying history\n    // Note we don't do any handling of lazy here.  For SPA's it'll get handled\n    // in the normal navigation flow.  For SSR it's expected that lazy modules are\n    // resolved prior to router creation since we can't go into a fallbackElement\n    // UI for SSR'd apps\n    if (!state.initialized) {\n      startNavigation(HistoryAction.Pop, state.location, {\n        initialHydration: true,\n      });\n    }\n\n    return router;\n  }\n\n  // Clean up a router and it's side effects\n  function dispose() {\n    if (unlistenHistory) {\n      unlistenHistory();\n    }\n    if (removePageHideEventListener) {\n      removePageHideEventListener();\n    }\n    subscribers.clear();\n    pendingNavigationController && pendingNavigationController.abort();\n    state.fetchers.forEach((_, key) => deleteFetcher(key));\n    state.blockers.forEach((_, key) => deleteBlocker(key));\n  }\n\n  // Subscribe to state updates for the router\n  function subscribe(fn: RouterSubscriber) {\n    subscribers.add(fn);\n    return () => subscribers.delete(fn);\n  }\n\n  // Update our state and notify the calling context of the change\n  function updateState(\n    newState: Partial<RouterState>,\n    opts: {\n      flushSync?: boolean;\n      viewTransitionOpts?: ViewTransitionOpts;\n    } = {}\n  ): void {\n    state = {\n      ...state,\n      ...newState,\n    };\n\n    // Prep fetcher cleanup so we can tell the UI which fetcher data entries\n    // can be removed\n    let completedFetchers: string[] = [];\n    let deletedFetchersKeys: string[] = [];\n\n    if (future.v7_fetcherPersist) {\n      state.fetchers.forEach((fetcher, key) => {\n        if (fetcher.state === \"idle\") {\n          if (deletedFetchers.has(key)) {\n            // Unmounted from the UI and can be totally removed\n            deletedFetchersKeys.push(key);\n          } else {\n            // Returned to idle but still mounted in the UI, so semi-remains for\n            // revalidations and such\n            completedFetchers.push(key);\n          }\n        }\n      });\n    }\n\n    // Remove any lingering deleted fetchers that have already been removed\n    // from state.fetchers\n    deletedFetchers.forEach((key) => {\n      if (!state.fetchers.has(key) && !fetchControllers.has(key)) {\n        deletedFetchersKeys.push(key);\n      }\n    });\n\n    // Iterate over a local copy so that if flushSync is used and we end up\n    // removing and adding a new subscriber due to the useCallback dependencies,\n    // we don't get ourselves into a loop calling the new subscriber immediately\n    [...subscribers].forEach((subscriber) =>\n      subscriber(state, {\n        deletedFetchers: deletedFetchersKeys,\n        viewTransitionOpts: opts.viewTransitionOpts,\n        flushSync: opts.flushSync === true,\n      })\n    );\n\n    // Remove idle fetchers from state since we only care about in-flight fetchers.\n    if (future.v7_fetcherPersist) {\n      completedFetchers.forEach((key) => state.fetchers.delete(key));\n      deletedFetchersKeys.forEach((key) => deleteFetcher(key));\n    } else {\n      // We already called deleteFetcher() on these, can remove them from this\n      // Set now that we've handed the keys off to the data layer\n      deletedFetchersKeys.forEach((key) => deletedFetchers.delete(key));\n    }\n  }\n\n  // Complete a navigation returning the state.navigation back to the IDLE_NAVIGATION\n  // and setting state.[historyAction/location/matches] to the new route.\n  // - Location is a required param\n  // - Navigation will always be set to IDLE_NAVIGATION\n  // - Can pass any other state in newState\n  function completeNavigation(\n    location: Location,\n    newState: Partial<Omit<RouterState, \"action\" | \"location\" | \"navigation\">>,\n    { flushSync }: { flushSync?: boolean } = {}\n  ): void {\n    // Deduce if we're in a loading/actionReload state:\n    // - We have committed actionData in the store\n    // - The current navigation was a mutation submission\n    // - We're past the submitting state and into the loading state\n    // - The location being loaded is not the result of a redirect\n    let isActionReload =\n      state.actionData != null &&\n      state.navigation.formMethod != null &&\n      isMutationMethod(state.navigation.formMethod) &&\n      state.navigation.state === \"loading\" &&\n      location.state?._isRedirect !== true;\n\n    let actionData: RouteData | null;\n    if (newState.actionData) {\n      if (Object.keys(newState.actionData).length > 0) {\n        actionData = newState.actionData;\n      } else {\n        // Empty actionData -> clear prior actionData due to an action error\n        actionData = null;\n      }\n    } else if (isActionReload) {\n      // Keep the current data if we're wrapping up the action reload\n      actionData = state.actionData;\n    } else {\n      // Clear actionData on any other completed navigations\n      actionData = null;\n    }\n\n    // Always preserve any existing loaderData from re-used routes\n    let loaderData = newState.loaderData\n      ? mergeLoaderData(\n          state.loaderData,\n          newState.loaderData,\n          newState.matches || [],\n          newState.errors\n        )\n      : state.loaderData;\n\n    // On a successful navigation we can assume we got through all blockers\n    // so we can start fresh\n    let blockers = state.blockers;\n    if (blockers.size > 0) {\n      blockers = new Map(blockers);\n      blockers.forEach((_, k) => blockers.set(k, IDLE_BLOCKER));\n    }\n\n    // Always respect the user flag.  Otherwise don't reset on mutation\n    // submission navigations unless they redirect\n    let preventScrollReset =\n      pendingPreventScrollReset === true ||\n      (state.navigation.formMethod != null &&\n        isMutationMethod(state.navigation.formMethod) &&\n        location.state?._isRedirect !== true);\n\n    // Commit any in-flight routes at the end of the HMR revalidation \"navigation\"\n    if (inFlightDataRoutes) {\n      dataRoutes = inFlightDataRoutes;\n      inFlightDataRoutes = undefined;\n    }\n\n    if (isUninterruptedRevalidation) {\n      // If this was an uninterrupted revalidation then do not touch history\n    } else if (pendingAction === HistoryAction.Pop) {\n      // Do nothing for POP - URL has already been updated\n    } else if (pendingAction === HistoryAction.Push) {\n      init.history.push(location, location.state);\n    } else if (pendingAction === HistoryAction.Replace) {\n      init.history.replace(location, location.state);\n    }\n\n    let viewTransitionOpts: ViewTransitionOpts | undefined;\n\n    // On POP, enable transitions if they were enabled on the original navigation\n    if (pendingAction === HistoryAction.Pop) {\n      // Forward takes precedence so they behave like the original navigation\n      let priorPaths = appliedViewTransitions.get(state.location.pathname);\n      if (priorPaths && priorPaths.has(location.pathname)) {\n        viewTransitionOpts = {\n          currentLocation: state.location,\n          nextLocation: location,\n        };\n      } else if (appliedViewTransitions.has(location.pathname)) {\n        // If we don't have a previous forward nav, assume we're popping back to\n        // the new location and enable if that location previously enabled\n        viewTransitionOpts = {\n          currentLocation: location,\n          nextLocation: state.location,\n        };\n      }\n    } else if (pendingViewTransitionEnabled) {\n      // Store the applied transition on PUSH/REPLACE\n      let toPaths = appliedViewTransitions.get(state.location.pathname);\n      if (toPaths) {\n        toPaths.add(location.pathname);\n      } else {\n        toPaths = new Set<string>([location.pathname]);\n        appliedViewTransitions.set(state.location.pathname, toPaths);\n      }\n      viewTransitionOpts = {\n        currentLocation: state.location,\n        nextLocation: location,\n      };\n    }\n\n    updateState(\n      {\n        ...newState, // matches, errors, fetchers go through as-is\n        actionData,\n        loaderData,\n        historyAction: pendingAction,\n        location,\n        initialized: true,\n        navigation: IDLE_NAVIGATION,\n        revalidation: \"idle\",\n        restoreScrollPosition: getSavedScrollPosition(\n          location,\n          newState.matches || state.matches\n        ),\n        preventScrollReset,\n        blockers,\n      },\n      {\n        viewTransitionOpts,\n        flushSync: flushSync === true,\n      }\n    );\n\n    // Reset stateful navigation vars\n    pendingAction = HistoryAction.Pop;\n    pendingPreventScrollReset = false;\n    pendingViewTransitionEnabled = false;\n    isUninterruptedRevalidation = false;\n    isRevalidationRequired = false;\n    cancelledDeferredRoutes = [];\n  }\n\n  // Trigger a navigation event, which can either be a numerical POP or a PUSH\n  // replace with an optional submission\n  async function navigate(\n    to: number | To | null,\n    opts?: RouterNavigateOptions\n  ): Promise<void> {\n    if (typeof to === \"number\") {\n      init.history.go(to);\n      return;\n    }\n\n    let normalizedPath = normalizeTo(\n      state.location,\n      state.matches,\n      basename,\n      future.v7_prependBasename,\n      to,\n      future.v7_relativeSplatPath,\n      opts?.fromRouteId,\n      opts?.relative\n    );\n    let { path, submission, error } = normalizeNavigateOptions(\n      future.v7_normalizeFormMethod,\n      false,\n      normalizedPath,\n      opts\n    );\n\n    let currentLocation = state.location;\n    let nextLocation = createLocation(state.location, path, opts && opts.state);\n\n    // When using navigate as a PUSH/REPLACE we aren't reading an already-encoded\n    // URL from window.location, so we need to encode it here so the behavior\n    // remains the same as POP and non-data-router usages.  new URL() does all\n    // the same encoding we'd get from a history.pushState/window.location read\n    // without having to touch history\n    nextLocation = {\n      ...nextLocation,\n      ...init.history.encodeLocation(nextLocation),\n    };\n\n    let userReplace = opts && opts.replace != null ? opts.replace : undefined;\n\n    let historyAction = HistoryAction.Push;\n\n    if (userReplace === true) {\n      historyAction = HistoryAction.Replace;\n    } else if (userReplace === false) {\n      // no-op\n    } else if (\n      submission != null &&\n      isMutationMethod(submission.formMethod) &&\n      submission.formAction === state.location.pathname + state.location.search\n    ) {\n      // By default on submissions to the current location we REPLACE so that\n      // users don't have to double-click the back button to get to the prior\n      // location.  If the user redirects to a different location from the\n      // action/loader this will be ignored and the redirect will be a PUSH\n      historyAction = HistoryAction.Replace;\n    }\n\n    let preventScrollReset =\n      opts && \"preventScrollReset\" in opts\n        ? opts.preventScrollReset === true\n        : undefined;\n\n    let flushSync = (opts && opts.flushSync) === true;\n\n    let blockerKey = shouldBlockNavigation({\n      currentLocation,\n      nextLocation,\n      historyAction,\n    });\n\n    if (blockerKey) {\n      // Put the blocker into a blocked state\n      updateBlocker(blockerKey, {\n        state: \"blocked\",\n        location: nextLocation,\n        proceed() {\n          updateBlocker(blockerKey!, {\n            state: \"proceeding\",\n            proceed: undefined,\n            reset: undefined,\n            location: nextLocation,\n          });\n          // Send the same navigation through\n          navigate(to, opts);\n        },\n        reset() {\n          let blockers = new Map(state.blockers);\n          blockers.set(blockerKey!, IDLE_BLOCKER);\n          updateState({ blockers });\n        },\n      });\n      return;\n    }\n\n    return await startNavigation(historyAction, nextLocation, {\n      submission,\n      // Send through the formData serialization error if we have one so we can\n      // render at the right error boundary after we match routes\n      pendingError: error,\n      preventScrollReset,\n      replace: opts && opts.replace,\n      enableViewTransition: opts && opts.viewTransition,\n      flushSync,\n    });\n  }\n\n  // Revalidate all current loaders.  If a navigation is in progress or if this\n  // is interrupted by a navigation, allow this to \"succeed\" by calling all\n  // loaders during the next loader round\n  function revalidate() {\n    interruptActiveLoads();\n    updateState({ revalidation: \"loading\" });\n\n    // If we're currently submitting an action, we don't need to start a new\n    // navigation, we'll just let the follow up loader execution call all loaders\n    if (state.navigation.state === \"submitting\") {\n      return;\n    }\n\n    // If we're currently in an idle state, start a new navigation for the current\n    // action/location and mark it as uninterrupted, which will skip the history\n    // update in completeNavigation\n    if (state.navigation.state === \"idle\") {\n      startNavigation(state.historyAction, state.location, {\n        startUninterruptedRevalidation: true,\n      });\n      return;\n    }\n\n    // Otherwise, if we're currently in a loading state, just start a new\n    // navigation to the navigation.location but do not trigger an uninterrupted\n    // revalidation so that history correctly updates once the navigation completes\n    startNavigation(\n      pendingAction || state.historyAction,\n      state.navigation.location,\n      {\n        overrideNavigation: state.navigation,\n        // Proxy through any rending view transition\n        enableViewTransition: pendingViewTransitionEnabled === true,\n      }\n    );\n  }\n\n  // Start a navigation to the given action/location.  Can optionally provide a\n  // overrideNavigation which will override the normalLoad in the case of a redirect\n  // navigation\n  async function startNavigation(\n    historyAction: HistoryAction,\n    location: Location,\n    opts?: {\n      initialHydration?: boolean;\n      submission?: Submission;\n      fetcherSubmission?: Submission;\n      overrideNavigation?: Navigation;\n      pendingError?: ErrorResponseImpl;\n      startUninterruptedRevalidation?: boolean;\n      preventScrollReset?: boolean;\n      replace?: boolean;\n      enableViewTransition?: boolean;\n      flushSync?: boolean;\n    }\n  ): Promise<void> {\n    // Abort any in-progress navigations and start a new one. Unset any ongoing\n    // uninterrupted revalidations unless told otherwise, since we want this\n    // new navigation to update history normally\n    pendingNavigationController && pendingNavigationController.abort();\n    pendingNavigationController = null;\n    pendingAction = historyAction;\n    isUninterruptedRevalidation =\n      (opts && opts.startUninterruptedRevalidation) === true;\n\n    // Save the current scroll position every time we start a new navigation,\n    // and track whether we should reset scroll on completion\n    saveScrollPosition(state.location, state.matches);\n    pendingPreventScrollReset = (opts && opts.preventScrollReset) === true;\n\n    pendingViewTransitionEnabled = (opts && opts.enableViewTransition) === true;\n\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    let loadingNavigation = opts && opts.overrideNavigation;\n    let matches =\n      opts?.initialHydration &&\n      state.matches &&\n      state.matches.length > 0 &&\n      !initialMatchesIsFOW\n        ? // `matchRoutes()` has already been called if we're in here via `router.initialize()`\n          state.matches\n        : matchRoutes(routesToUse, location, basename);\n    let flushSync = (opts && opts.flushSync) === true;\n\n    // Short circuit if it's only a hash change and not a revalidation or\n    // mutation submission.\n    //\n    // Ignore on initial page loads because since the initial hydration will always\n    // be \"same hash\".  For example, on /page#hash and submit a <Form method=\"post\">\n    // which will default to a navigation to /page\n    if (\n      matches &&\n      state.initialized &&\n      !isRevalidationRequired &&\n      isHashChangeOnly(state.location, location) &&\n      !(opts && opts.submission && isMutationMethod(opts.submission.formMethod))\n    ) {\n      completeNavigation(location, { matches }, { flushSync });\n      return;\n    }\n\n    let fogOfWar = checkFogOfWar(matches, routesToUse, location.pathname);\n    if (fogOfWar.active && fogOfWar.matches) {\n      matches = fogOfWar.matches;\n    }\n\n    // Short circuit with a 404 on the root error boundary if we match nothing\n    if (!matches) {\n      let { error, notFoundMatches, route } = handleNavigational404(\n        location.pathname\n      );\n      completeNavigation(\n        location,\n        {\n          matches: notFoundMatches,\n          loaderData: {},\n          errors: {\n            [route.id]: error,\n          },\n        },\n        { flushSync }\n      );\n      return;\n    }\n\n    // Create a controller/Request for this navigation\n    pendingNavigationController = new AbortController();\n    let request = createClientSideRequest(\n      init.history,\n      location,\n      pendingNavigationController.signal,\n      opts && opts.submission\n    );\n    let pendingActionResult: PendingActionResult | undefined;\n\n    if (opts && opts.pendingError) {\n      // If we have a pendingError, it means the user attempted a GET submission\n      // with binary FormData so assign here and skip to handleLoaders.  That\n      // way we handle calling loaders above the boundary etc.  It's not really\n      // different from an actionError in that sense.\n      pendingActionResult = [\n        findNearestBoundary(matches).route.id,\n        { type: ResultType.error, error: opts.pendingError },\n      ];\n    } else if (\n      opts &&\n      opts.submission &&\n      isMutationMethod(opts.submission.formMethod)\n    ) {\n      // Call action if we received an action submission\n      let actionResult = await handleAction(\n        request,\n        location,\n        opts.submission,\n        matches,\n        fogOfWar.active,\n        { replace: opts.replace, flushSync }\n      );\n\n      if (actionResult.shortCircuited) {\n        return;\n      }\n\n      // If we received a 404 from handleAction, it's because we couldn't lazily\n      // discover the destination route so we don't want to call loaders\n      if (actionResult.pendingActionResult) {\n        let [routeId, result] = actionResult.pendingActionResult;\n        if (\n          isErrorResult(result) &&\n          isRouteErrorResponse(result.error) &&\n          result.error.status === 404\n        ) {\n          pendingNavigationController = null;\n\n          completeNavigation(location, {\n            matches: actionResult.matches,\n            loaderData: {},\n            errors: {\n              [routeId]: result.error,\n            },\n          });\n          return;\n        }\n      }\n\n      matches = actionResult.matches || matches;\n      pendingActionResult = actionResult.pendingActionResult;\n      loadingNavigation = getLoadingNavigation(location, opts.submission);\n      flushSync = false;\n      // No need to do fog of war matching again on loader execution\n      fogOfWar.active = false;\n\n      // Create a GET request for the loaders\n      request = createClientSideRequest(\n        init.history,\n        request.url,\n        request.signal\n      );\n    }\n\n    // Call loaders\n    let {\n      shortCircuited,\n      matches: updatedMatches,\n      loaderData,\n      errors,\n    } = await handleLoaders(\n      request,\n      location,\n      matches,\n      fogOfWar.active,\n      loadingNavigation,\n      opts && opts.submission,\n      opts && opts.fetcherSubmission,\n      opts && opts.replace,\n      opts && opts.initialHydration === true,\n      flushSync,\n      pendingActionResult\n    );\n\n    if (shortCircuited) {\n      return;\n    }\n\n    // Clean up now that the action/loaders have completed.  Don't clean up if\n    // we short circuited because pendingNavigationController will have already\n    // been assigned to a new controller for the next navigation\n    pendingNavigationController = null;\n\n    completeNavigation(location, {\n      matches: updatedMatches || matches,\n      ...getActionDataForCommit(pendingActionResult),\n      loaderData,\n      errors,\n    });\n  }\n\n  // Call the action matched by the leaf route for this navigation and handle\n  // redirects/errors\n  async function handleAction(\n    request: Request,\n    location: Location,\n    submission: Submission,\n    matches: AgnosticDataRouteMatch[],\n    isFogOfWar: boolean,\n    opts: { replace?: boolean; flushSync?: boolean } = {}\n  ): Promise<HandleActionResult> {\n    interruptActiveLoads();\n\n    // Put us in a submitting state\n    let navigation = getSubmittingNavigation(location, submission);\n    updateState({ navigation }, { flushSync: opts.flushSync === true });\n\n    if (isFogOfWar) {\n      let discoverResult = await discoverRoutes(\n        matches,\n        location.pathname,\n        request.signal\n      );\n      if (discoverResult.type === \"aborted\") {\n        return { shortCircuited: true };\n      } else if (discoverResult.type === \"error\") {\n        let boundaryId = findNearestBoundary(discoverResult.partialMatches)\n          .route.id;\n        return {\n          matches: discoverResult.partialMatches,\n          pendingActionResult: [\n            boundaryId,\n            {\n              type: ResultType.error,\n              error: discoverResult.error,\n            },\n          ],\n        };\n      } else if (!discoverResult.matches) {\n        let { notFoundMatches, error, route } = handleNavigational404(\n          location.pathname\n        );\n        return {\n          matches: notFoundMatches,\n          pendingActionResult: [\n            route.id,\n            {\n              type: ResultType.error,\n              error,\n            },\n          ],\n        };\n      } else {\n        matches = discoverResult.matches;\n      }\n    }\n\n    // Call our action and get the result\n    let result: DataResult;\n    let actionMatch = getTargetMatch(matches, location);\n\n    if (!actionMatch.route.action && !actionMatch.route.lazy) {\n      result = {\n        type: ResultType.error,\n        error: getInternalRouterError(405, {\n          method: request.method,\n          pathname: location.pathname,\n          routeId: actionMatch.route.id,\n        }),\n      };\n    } else {\n      let results = await callDataStrategy(\n        \"action\",\n        state,\n        request,\n        [actionMatch],\n        matches,\n        null\n      );\n      result = results[actionMatch.route.id];\n\n      if (request.signal.aborted) {\n        return { shortCircuited: true };\n      }\n    }\n\n    if (isRedirectResult(result)) {\n      let replace: boolean;\n      if (opts && opts.replace != null) {\n        replace = opts.replace;\n      } else {\n        // If the user didn't explicity indicate replace behavior, replace if\n        // we redirected to the exact same location we're currently at to avoid\n        // double back-buttons\n        let location = normalizeRedirectLocation(\n          result.response.headers.get(\"Location\")!,\n          new URL(request.url),\n          basename,\n          init.history,\n        );\n        replace = location === state.location.pathname + state.location.search;\n      }\n      await startRedirectNavigation(request, result, true, {\n        submission,\n        replace,\n      });\n      return { shortCircuited: true };\n    }\n\n    if (isDeferredResult(result)) {\n      throw getInternalRouterError(400, { type: \"defer-action\" });\n    }\n\n    if (isErrorResult(result)) {\n      // Store off the pending error - we use it to determine which loaders\n      // to call and will commit it when we complete the navigation\n      let boundaryMatch = findNearestBoundary(matches, actionMatch.route.id);\n\n      // By default, all submissions to the current location are REPLACE\n      // navigations, but if the action threw an error that'll be rendered in\n      // an errorElement, we fall back to PUSH so that the user can use the\n      // back button to get back to the pre-submission form location to try\n      // again\n      if ((opts && opts.replace) !== true) {\n        pendingAction = HistoryAction.Push;\n      }\n\n      return {\n        matches,\n        pendingActionResult: [boundaryMatch.route.id, result],\n      };\n    }\n\n    return {\n      matches,\n      pendingActionResult: [actionMatch.route.id, result],\n    };\n  }\n\n  // Call all applicable loaders for the given matches, handling redirects,\n  // errors, etc.\n  async function handleLoaders(\n    request: Request,\n    location: Location,\n    matches: AgnosticDataRouteMatch[],\n    isFogOfWar: boolean,\n    overrideNavigation?: Navigation,\n    submission?: Submission,\n    fetcherSubmission?: Submission,\n    replace?: boolean,\n    initialHydration?: boolean,\n    flushSync?: boolean,\n    pendingActionResult?: PendingActionResult\n  ): Promise<HandleLoadersResult> {\n    // Figure out the right navigation we want to use for data loading\n    let loadingNavigation =\n      overrideNavigation || getLoadingNavigation(location, submission);\n\n    // If this was a redirect from an action we don't have a \"submission\" but\n    // we have it on the loading navigation so use that if available\n    let activeSubmission =\n      submission ||\n      fetcherSubmission ||\n      getSubmissionFromNavigation(loadingNavigation);\n\n    // If this is an uninterrupted revalidation, we remain in our current idle\n    // state.  If not, we need to switch to our loading state and load data,\n    // preserving any new action data or existing action data (in the case of\n    // a revalidation interrupting an actionReload)\n    // If we have partialHydration enabled, then don't update the state for the\n    // initial data load since it's not a \"navigation\"\n    let shouldUpdateNavigationState =\n      !isUninterruptedRevalidation &&\n      (!future.v7_partialHydration || !initialHydration);\n\n    // When fog of war is enabled, we enter our `loading` state earlier so we\n    // can discover new routes during the `loading` state.  We skip this if\n    // we've already run actions since we would have done our matching already.\n    // If the children() function threw then, we want to proceed with the\n    // partial matches it discovered.\n    if (isFogOfWar) {\n      if (shouldUpdateNavigationState) {\n        let actionData = getUpdatedActionData(pendingActionResult);\n        updateState(\n          {\n            navigation: loadingNavigation,\n            ...(actionData !== undefined ? { actionData } : {}),\n          },\n          {\n            flushSync,\n          }\n        );\n      }\n\n      let discoverResult = await discoverRoutes(\n        matches,\n        location.pathname,\n        request.signal\n      );\n\n      if (discoverResult.type === \"aborted\") {\n        return { shortCircuited: true };\n      } else if (discoverResult.type === \"error\") {\n        let boundaryId = findNearestBoundary(discoverResult.partialMatches)\n          .route.id;\n        return {\n          matches: discoverResult.partialMatches,\n          loaderData: {},\n          errors: {\n            [boundaryId]: discoverResult.error,\n          },\n        };\n      } else if (!discoverResult.matches) {\n        let { error, notFoundMatches, route } = handleNavigational404(\n          location.pathname\n        );\n        return {\n          matches: notFoundMatches,\n          loaderData: {},\n          errors: {\n            [route.id]: error,\n          },\n        };\n      } else {\n        matches = discoverResult.matches;\n      }\n    }\n\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(\n      init.history,\n      state,\n      matches,\n      activeSubmission,\n      location,\n      future.v7_partialHydration && initialHydration === true,\n      future.v7_skipActionErrorRevalidation,\n      isRevalidationRequired,\n      cancelledDeferredRoutes,\n      cancelledFetcherLoads,\n      deletedFetchers,\n      fetchLoadMatches,\n      fetchRedirectIds,\n      routesToUse,\n      basename,\n      pendingActionResult\n    );\n\n    // Cancel pending deferreds for no-longer-matched routes or routes we're\n    // about to reload.  Note that if this is an action reload we would have\n    // already cancelled all pending deferreds so this would be a no-op\n    cancelActiveDeferreds(\n      (routeId) =>\n        !(matches && matches.some((m) => m.route.id === routeId)) ||\n        (matchesToLoad && matchesToLoad.some((m) => m.route.id === routeId))\n    );\n\n    pendingNavigationLoadId = ++incrementingLoadId;\n\n    // Short circuit if we have no loaders to run\n    if (matchesToLoad.length === 0 && revalidatingFetchers.length === 0) {\n      let updatedFetchers = markFetchRedirectsDone();\n      completeNavigation(\n        location,\n        {\n          matches,\n          loaderData: {},\n          // Commit pending error if we're short circuiting\n          errors:\n            pendingActionResult && isErrorResult(pendingActionResult[1])\n              ? { [pendingActionResult[0]]: pendingActionResult[1].error }\n              : null,\n          ...getActionDataForCommit(pendingActionResult),\n          ...(updatedFetchers ? { fetchers: new Map(state.fetchers) } : {}),\n        },\n        { flushSync }\n      );\n      return { shortCircuited: true };\n    }\n\n    if (shouldUpdateNavigationState) {\n      let updates: Partial<RouterState> = {};\n      if (!isFogOfWar) {\n        // Only update navigation/actionNData if we didn't already do it above\n        updates.navigation = loadingNavigation;\n        let actionData = getUpdatedActionData(pendingActionResult);\n        if (actionData !== undefined) {\n          updates.actionData = actionData;\n        }\n      }\n      if (revalidatingFetchers.length > 0) {\n        updates.fetchers = getUpdatedRevalidatingFetchers(revalidatingFetchers);\n      }\n      updateState(updates, { flushSync });\n    }\n\n    revalidatingFetchers.forEach((rf) => {\n      abortFetcher(rf.key);\n      if (rf.controller) {\n        // Fetchers use an independent AbortController so that aborting a fetcher\n        // (via deleteFetcher) does not abort the triggering navigation that\n        // triggered the revalidation\n        fetchControllers.set(rf.key, rf.controller);\n      }\n    });\n\n    // Proxy navigation abort through to revalidation fetchers\n    let abortPendingFetchRevalidations = () =>\n      revalidatingFetchers.forEach((f) => abortFetcher(f.key));\n    if (pendingNavigationController) {\n      pendingNavigationController.signal.addEventListener(\n        \"abort\",\n        abortPendingFetchRevalidations\n      );\n    }\n\n    let { loaderResults, fetcherResults } =\n      await callLoadersAndMaybeResolveData(\n        state,\n        matches,\n        matchesToLoad,\n        revalidatingFetchers,\n        request\n      );\n\n    if (request.signal.aborted) {\n      return { shortCircuited: true };\n    }\n\n    // Clean up _after_ loaders have completed.  Don't clean up if we short\n    // circuited because fetchControllers would have been aborted and\n    // reassigned to new controllers for the next navigation\n    if (pendingNavigationController) {\n      pendingNavigationController.signal.removeEventListener(\n        \"abort\",\n        abortPendingFetchRevalidations\n      );\n    }\n\n    revalidatingFetchers.forEach((rf) => fetchControllers.delete(rf.key));\n\n    // If any loaders returned a redirect Response, start a new REPLACE navigation\n    let redirect = findRedirect(loaderResults);\n    if (redirect) {\n      await startRedirectNavigation(request, redirect.result, true, {\n        replace,\n      });\n      return { shortCircuited: true };\n    }\n\n    redirect = findRedirect(fetcherResults);\n    if (redirect) {\n      // If this redirect came from a fetcher make sure we mark it in\n      // fetchRedirectIds so it doesn't get revalidated on the next set of\n      // loader executions\n      fetchRedirectIds.add(redirect.key);\n      await startRedirectNavigation(request, redirect.result, true, {\n        replace,\n      });\n      return { shortCircuited: true };\n    }\n\n    // Process and commit output from loaders\n    let { loaderData, errors } = processLoaderData(\n      state,\n      matches,\n      loaderResults,\n      pendingActionResult,\n      revalidatingFetchers,\n      fetcherResults,\n      activeDeferreds\n    );\n\n    // Wire up subscribers to update loaderData as promises settle\n    activeDeferreds.forEach((deferredData, routeId) => {\n      deferredData.subscribe((aborted) => {\n        // Note: No need to updateState here since the TrackedPromise on\n        // loaderData is stable across resolve/reject\n        // Remove this instance if we were aborted or if promises have settled\n        if (aborted || deferredData.done) {\n          activeDeferreds.delete(routeId);\n        }\n      });\n    });\n\n    // Preserve SSR errors during partial hydration\n    if (future.v7_partialHydration && initialHydration && state.errors) {\n      errors = { ...state.errors, ...errors };\n    }\n\n    let updatedFetchers = markFetchRedirectsDone();\n    let didAbortFetchLoads = abortStaleFetchLoads(pendingNavigationLoadId);\n    let shouldUpdateFetchers =\n      updatedFetchers || didAbortFetchLoads || revalidatingFetchers.length > 0;\n\n    return {\n      matches,\n      loaderData,\n      errors,\n      ...(shouldUpdateFetchers ? { fetchers: new Map(state.fetchers) } : {}),\n    };\n  }\n\n  function getUpdatedActionData(\n    pendingActionResult: PendingActionResult | undefined\n  ): Record<string, RouteData> | null | undefined {\n    if (pendingActionResult && !isErrorResult(pendingActionResult[1])) {\n      // This is cast to `any` currently because `RouteData`uses any and it\n      // would be a breaking change to use any.\n      // TODO: v7 - change `RouteData` to use `unknown` instead of `any`\n      return {\n        [pendingActionResult[0]]: pendingActionResult[1].data as any,\n      };\n    } else if (state.actionData) {\n      if (Object.keys(state.actionData).length === 0) {\n        return null;\n      } else {\n        return state.actionData;\n      }\n    }\n  }\n\n  function getUpdatedRevalidatingFetchers(\n    revalidatingFetchers: RevalidatingFetcher[]\n  ) {\n    revalidatingFetchers.forEach((rf) => {\n      let fetcher = state.fetchers.get(rf.key);\n      let revalidatingFetcher = getLoadingFetcher(\n        undefined,\n        fetcher ? fetcher.data : undefined\n      );\n      state.fetchers.set(rf.key, revalidatingFetcher);\n    });\n    return new Map(state.fetchers);\n  }\n\n  // Trigger a fetcher load/submit for the given fetcher key\n  function fetch(\n    key: string,\n    routeId: string,\n    href: string | null,\n    opts?: RouterFetchOptions\n  ) {\n    if (isServer) {\n      throw new Error(\n        \"router.fetch() was called during the server render, but it shouldn't be. \" +\n          \"You are likely calling a useFetcher() method in the body of your component. \" +\n          \"Try moving it to a useEffect or a callback.\"\n      );\n    }\n\n    abortFetcher(key);\n\n    let flushSync = (opts && opts.flushSync) === true;\n\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    let normalizedPath = normalizeTo(\n      state.location,\n      state.matches,\n      basename,\n      future.v7_prependBasename,\n      href,\n      future.v7_relativeSplatPath,\n      routeId,\n      opts?.relative\n    );\n    let matches = matchRoutes(routesToUse, normalizedPath, basename);\n\n    let fogOfWar = checkFogOfWar(matches, routesToUse, normalizedPath);\n    if (fogOfWar.active && fogOfWar.matches) {\n      matches = fogOfWar.matches;\n    }\n\n    if (!matches) {\n      setFetcherError(\n        key,\n        routeId,\n        getInternalRouterError(404, { pathname: normalizedPath }),\n        { flushSync }\n      );\n      return;\n    }\n\n    let { path, submission, error } = normalizeNavigateOptions(\n      future.v7_normalizeFormMethod,\n      true,\n      normalizedPath,\n      opts\n    );\n\n    if (error) {\n      setFetcherError(key, routeId, error, { flushSync });\n      return;\n    }\n\n    let match = getTargetMatch(matches, path);\n\n    let preventScrollReset = (opts && opts.preventScrollReset) === true;\n\n    if (submission && isMutationMethod(submission.formMethod)) {\n      handleFetcherAction(\n        key,\n        routeId,\n        path,\n        match,\n        matches,\n        fogOfWar.active,\n        flushSync,\n        preventScrollReset,\n        submission\n      );\n      return;\n    }\n\n    // Store off the match so we can call it's shouldRevalidate on subsequent\n    // revalidations\n    fetchLoadMatches.set(key, { routeId, path });\n    handleFetcherLoader(\n      key,\n      routeId,\n      path,\n      match,\n      matches,\n      fogOfWar.active,\n      flushSync,\n      preventScrollReset,\n      submission\n    );\n  }\n\n  // Call the action for the matched fetcher.submit(), and then handle redirects,\n  // errors, and revalidation\n  async function handleFetcherAction(\n    key: string,\n    routeId: string,\n    path: string,\n    match: AgnosticDataRouteMatch,\n    requestMatches: AgnosticDataRouteMatch[],\n    isFogOfWar: boolean,\n    flushSync: boolean,\n    preventScrollReset: boolean,\n    submission: Submission\n  ) {\n    interruptActiveLoads();\n    fetchLoadMatches.delete(key);\n\n    function detectAndHandle405Error(m: AgnosticDataRouteMatch) {\n      if (!m.route.action && !m.route.lazy) {\n        let error = getInternalRouterError(405, {\n          method: submission.formMethod,\n          pathname: path,\n          routeId: routeId,\n        });\n        setFetcherError(key, routeId, error, { flushSync });\n        return true;\n      }\n      return false;\n    }\n\n    if (!isFogOfWar && detectAndHandle405Error(match)) {\n      return;\n    }\n\n    // Put this fetcher into it's submitting state\n    let existingFetcher = state.fetchers.get(key);\n    updateFetcherState(key, getSubmittingFetcher(submission, existingFetcher), {\n      flushSync,\n    });\n\n    let abortController = new AbortController();\n    let fetchRequest = createClientSideRequest(\n      init.history,\n      path,\n      abortController.signal,\n      submission\n    );\n\n    if (isFogOfWar) {\n      let discoverResult = await discoverRoutes(\n        requestMatches,\n        new URL(fetchRequest.url).pathname,\n        fetchRequest.signal,\n        key\n      );\n\n      if (discoverResult.type === \"aborted\") {\n        return;\n      } else if (discoverResult.type === \"error\") {\n        setFetcherError(key, routeId, discoverResult.error, { flushSync });\n        return;\n      } else if (!discoverResult.matches) {\n        setFetcherError(\n          key,\n          routeId,\n          getInternalRouterError(404, { pathname: path }),\n          { flushSync }\n        );\n        return;\n      } else {\n        requestMatches = discoverResult.matches;\n        match = getTargetMatch(requestMatches, path);\n\n        if (detectAndHandle405Error(match)) {\n          return;\n        }\n      }\n    }\n\n    // Call the action for the fetcher\n    fetchControllers.set(key, abortController);\n\n    let originatingLoadId = incrementingLoadId;\n    let actionResults = await callDataStrategy(\n      \"action\",\n      state,\n      fetchRequest,\n      [match],\n      requestMatches,\n      key\n    );\n    let actionResult = actionResults[match.route.id];\n\n    if (fetchRequest.signal.aborted) {\n      // We can delete this so long as we weren't aborted by our own fetcher\n      // re-submit which would have put _new_ controller is in fetchControllers\n      if (fetchControllers.get(key) === abortController) {\n        fetchControllers.delete(key);\n      }\n      return;\n    }\n\n    // When using v7_fetcherPersist, we don't want errors bubbling up to the UI\n    // or redirects processed for unmounted fetchers so we just revert them to\n    // idle\n    if (future.v7_fetcherPersist && deletedFetchers.has(key)) {\n      if (isRedirectResult(actionResult) || isErrorResult(actionResult)) {\n        updateFetcherState(key, getDoneFetcher(undefined));\n        return;\n      }\n      // Let SuccessResult's fall through for revalidation\n    } else {\n      if (isRedirectResult(actionResult)) {\n        fetchControllers.delete(key);\n        if (pendingNavigationLoadId > originatingLoadId) {\n          // A new navigation was kicked off after our action started, so that\n          // should take precedence over this redirect navigation.  We already\n          // set isRevalidationRequired so all loaders for the new route should\n          // fire unless opted out via shouldRevalidate\n          updateFetcherState(key, getDoneFetcher(undefined));\n          return;\n        } else {\n          fetchRedirectIds.add(key);\n          updateFetcherState(key, getLoadingFetcher(submission));\n          return startRedirectNavigation(fetchRequest, actionResult, false, {\n            fetcherSubmission: submission,\n            preventScrollReset,\n          });\n        }\n      }\n\n      // Process any non-redirect errors thrown\n      if (isErrorResult(actionResult)) {\n        setFetcherError(key, routeId, actionResult.error);\n        return;\n      }\n    }\n\n    if (isDeferredResult(actionResult)) {\n      throw getInternalRouterError(400, { type: \"defer-action\" });\n    }\n\n    // Start the data load for current matches, or the next location if we're\n    // in the middle of a navigation\n    let nextLocation = state.navigation.location || state.location;\n    let revalidationRequest = createClientSideRequest(\n      init.history,\n      nextLocation,\n      abortController.signal\n    );\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    let matches =\n      state.navigation.state !== \"idle\"\n        ? matchRoutes(routesToUse, state.navigation.location, basename)\n        : state.matches;\n\n    invariant(matches, \"Didn't find any matches after fetcher action\");\n\n    let loadId = ++incrementingLoadId;\n    fetchReloadIds.set(key, loadId);\n\n    let loadFetcher = getLoadingFetcher(submission, actionResult.data);\n    state.fetchers.set(key, loadFetcher);\n\n    let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(\n      init.history,\n      state,\n      matches,\n      submission,\n      nextLocation,\n      false,\n      future.v7_skipActionErrorRevalidation,\n      isRevalidationRequired,\n      cancelledDeferredRoutes,\n      cancelledFetcherLoads,\n      deletedFetchers,\n      fetchLoadMatches,\n      fetchRedirectIds,\n      routesToUse,\n      basename,\n      [match.route.id, actionResult]\n    );\n\n    // Put all revalidating fetchers into the loading state, except for the\n    // current fetcher which we want to keep in it's current loading state which\n    // contains it's action submission info + action data\n    revalidatingFetchers\n      .filter((rf) => rf.key !== key)\n      .forEach((rf) => {\n        let staleKey = rf.key;\n        let existingFetcher = state.fetchers.get(staleKey);\n        let revalidatingFetcher = getLoadingFetcher(\n          undefined,\n          existingFetcher ? existingFetcher.data : undefined\n        );\n        state.fetchers.set(staleKey, revalidatingFetcher);\n        abortFetcher(staleKey);\n        if (rf.controller) {\n          fetchControllers.set(staleKey, rf.controller);\n        }\n      });\n\n    updateState({ fetchers: new Map(state.fetchers) });\n\n    let abortPendingFetchRevalidations = () =>\n      revalidatingFetchers.forEach((rf) => abortFetcher(rf.key));\n\n    abortController.signal.addEventListener(\n      \"abort\",\n      abortPendingFetchRevalidations\n    );\n\n    let { loaderResults, fetcherResults } =\n      await callLoadersAndMaybeResolveData(\n        state,\n        matches,\n        matchesToLoad,\n        revalidatingFetchers,\n        revalidationRequest\n      );\n\n    if (abortController.signal.aborted) {\n      return;\n    }\n\n    abortController.signal.removeEventListener(\n      \"abort\",\n      abortPendingFetchRevalidations\n    );\n\n    fetchReloadIds.delete(key);\n    fetchControllers.delete(key);\n    revalidatingFetchers.forEach((r) => fetchControllers.delete(r.key));\n\n    let redirect = findRedirect(loaderResults);\n    if (redirect) {\n      return startRedirectNavigation(\n        revalidationRequest,\n        redirect.result,\n        false,\n        { preventScrollReset }\n      );\n    }\n\n    redirect = findRedirect(fetcherResults);\n    if (redirect) {\n      // If this redirect came from a fetcher make sure we mark it in\n      // fetchRedirectIds so it doesn't get revalidated on the next set of\n      // loader executions\n      fetchRedirectIds.add(redirect.key);\n      return startRedirectNavigation(\n        revalidationRequest,\n        redirect.result,\n        false,\n        { preventScrollReset }\n      );\n    }\n\n    // Process and commit output from loaders\n    let { loaderData, errors } = processLoaderData(\n      state,\n      matches,\n      loaderResults,\n      undefined,\n      revalidatingFetchers,\n      fetcherResults,\n      activeDeferreds\n    );\n\n    // Since we let revalidations complete even if the submitting fetcher was\n    // deleted, only put it back to idle if it hasn't been deleted\n    if (state.fetchers.has(key)) {\n      let doneFetcher = getDoneFetcher(actionResult.data);\n      state.fetchers.set(key, doneFetcher);\n    }\n\n    abortStaleFetchLoads(loadId);\n\n    // If we are currently in a navigation loading state and this fetcher is\n    // more recent than the navigation, we want the newer data so abort the\n    // navigation and complete it with the fetcher data\n    if (\n      state.navigation.state === \"loading\" &&\n      loadId > pendingNavigationLoadId\n    ) {\n      invariant(pendingAction, \"Expected pending action\");\n      pendingNavigationController && pendingNavigationController.abort();\n\n      completeNavigation(state.navigation.location, {\n        matches,\n        loaderData,\n        errors,\n        fetchers: new Map(state.fetchers),\n      });\n    } else {\n      // otherwise just update with the fetcher data, preserving any existing\n      // loaderData for loaders that did not need to reload.  We have to\n      // manually merge here since we aren't going through completeNavigation\n      updateState({\n        errors,\n        loaderData: mergeLoaderData(\n          state.loaderData,\n          loaderData,\n          matches,\n          errors\n        ),\n        fetchers: new Map(state.fetchers),\n      });\n      isRevalidationRequired = false;\n    }\n  }\n\n  // Call the matched loader for fetcher.load(), handling redirects, errors, etc.\n  async function handleFetcherLoader(\n    key: string,\n    routeId: string,\n    path: string,\n    match: AgnosticDataRouteMatch,\n    matches: AgnosticDataRouteMatch[],\n    isFogOfWar: boolean,\n    flushSync: boolean,\n    preventScrollReset: boolean,\n    submission?: Submission\n  ) {\n    let existingFetcher = state.fetchers.get(key);\n    updateFetcherState(\n      key,\n      getLoadingFetcher(\n        submission,\n        existingFetcher ? existingFetcher.data : undefined\n      ),\n      { flushSync }\n    );\n\n    let abortController = new AbortController();\n    let fetchRequest = createClientSideRequest(\n      init.history,\n      path,\n      abortController.signal\n    );\n\n    if (isFogOfWar) {\n      let discoverResult = await discoverRoutes(\n        matches,\n        new URL(fetchRequest.url).pathname,\n        fetchRequest.signal,\n        key\n      );\n\n      if (discoverResult.type === \"aborted\") {\n        return;\n      } else if (discoverResult.type === \"error\") {\n        setFetcherError(key, routeId, discoverResult.error, { flushSync });\n        return;\n      } else if (!discoverResult.matches) {\n        setFetcherError(\n          key,\n          routeId,\n          getInternalRouterError(404, { pathname: path }),\n          { flushSync }\n        );\n        return;\n      } else {\n        matches = discoverResult.matches;\n        match = getTargetMatch(matches, path);\n      }\n    }\n\n    // Call the loader for this fetcher route match\n    fetchControllers.set(key, abortController);\n\n    let originatingLoadId = incrementingLoadId;\n    let results = await callDataStrategy(\n      \"loader\",\n      state,\n      fetchRequest,\n      [match],\n      matches,\n      key\n    );\n    let result = results[match.route.id];\n\n    // Deferred isn't supported for fetcher loads, await everything and treat it\n    // as a normal load.  resolveDeferredData will return undefined if this\n    // fetcher gets aborted, so we just leave result untouched and short circuit\n    // below if that happens\n    if (isDeferredResult(result)) {\n      result =\n        (await resolveDeferredData(result, fetchRequest.signal, true)) ||\n        result;\n    }\n\n    // We can delete this so long as we weren't aborted by our our own fetcher\n    // re-load which would have put _new_ controller is in fetchControllers\n    if (fetchControllers.get(key) === abortController) {\n      fetchControllers.delete(key);\n    }\n\n    if (fetchRequest.signal.aborted) {\n      return;\n    }\n\n    // We don't want errors bubbling up or redirects followed for unmounted\n    // fetchers, so short circuit here if it was removed from the UI\n    if (deletedFetchers.has(key)) {\n      updateFetcherState(key, getDoneFetcher(undefined));\n      return;\n    }\n\n    // If the loader threw a redirect Response, start a new REPLACE navigation\n    if (isRedirectResult(result)) {\n      if (pendingNavigationLoadId > originatingLoadId) {\n        // A new navigation was kicked off after our loader started, so that\n        // should take precedence over this redirect navigation\n        updateFetcherState(key, getDoneFetcher(undefined));\n        return;\n      } else {\n        fetchRedirectIds.add(key);\n        await startRedirectNavigation(fetchRequest, result, false, {\n          preventScrollReset,\n        });\n        return;\n      }\n    }\n\n    // Process any non-redirect errors thrown\n    if (isErrorResult(result)) {\n      setFetcherError(key, routeId, result.error);\n      return;\n    }\n\n    invariant(!isDeferredResult(result), \"Unhandled fetcher deferred data\");\n\n    // Put the fetcher back into an idle state\n    updateFetcherState(key, getDoneFetcher(result.data));\n  }\n\n  /**\n   * Utility function to handle redirects returned from an action or loader.\n   * Normally, a redirect \"replaces\" the navigation that triggered it.  So, for\n   * example:\n   *\n   *  - user is on /a\n   *  - user clicks a link to /b\n   *  - loader for /b redirects to /c\n   *\n   * In a non-JS app the browser would track the in-flight navigation to /b and\n   * then replace it with /c when it encountered the redirect response.  In\n   * the end it would only ever update the URL bar with /c.\n   *\n   * In client-side routing using pushState/replaceState, we aim to emulate\n   * this behavior and we also do not update history until the end of the\n   * navigation (including processed redirects).  This means that we never\n   * actually touch history until we've processed redirects, so we just use\n   * the history action from the original navigation (PUSH or REPLACE).\n   */\n  async function startRedirectNavigation(\n    request: Request,\n    redirect: RedirectResult,\n    isNavigation: boolean,\n    {\n      submission,\n      fetcherSubmission,\n      preventScrollReset,\n      replace,\n    }: {\n      submission?: Submission;\n      fetcherSubmission?: Submission;\n      preventScrollReset?: boolean;\n      replace?: boolean;\n    } = {}\n  ) {\n    if (redirect.response.headers.has(\"X-Remix-Revalidate\")) {\n      isRevalidationRequired = true;\n    }\n\n    let location = redirect.response.headers.get(\"Location\");\n    invariant(location, \"Expected a Location header on the redirect Response\");\n    location = normalizeRedirectLocation(\n      location,\n      new URL(request.url),\n      basename,\n      init.history,\n    );\n    let redirectLocation = createLocation(state.location, location, {\n      _isRedirect: true,\n    });\n\n    if (isBrowser) {\n      let isDocumentReload = false;\n\n      if (redirect.response.headers.has(\"X-Remix-Reload-Document\")) {\n        // Hard reload if the response contained X-Remix-Reload-Document\n        isDocumentReload = true;\n      } else if (ABSOLUTE_URL_REGEX.test(location)) {\n        const url = init.history.createURL(location);\n        isDocumentReload =\n          // Hard reload if it's an absolute URL to a new origin\n          url.origin !== routerWindow.location.origin ||\n          // Hard reload if it's an absolute URL that does not match our basename\n          stripBasename(url.pathname, basename) == null;\n      }\n\n      if (isDocumentReload) {\n        if (replace) {\n          routerWindow.location.replace(location);\n        } else {\n          routerWindow.location.assign(location);\n        }\n        return;\n      }\n    }\n\n    // There's no need to abort on redirects, since we don't detect the\n    // redirect until the action/loaders have settled\n    pendingNavigationController = null;\n\n    let redirectHistoryAction =\n      replace === true || redirect.response.headers.has(\"X-Remix-Replace\")\n        ? HistoryAction.Replace\n        : HistoryAction.Push;\n\n    // Use the incoming submission if provided, fallback on the active one in\n    // state.navigation\n    let { formMethod, formAction, formEncType } = state.navigation;\n    if (\n      !submission &&\n      !fetcherSubmission &&\n      formMethod &&\n      formAction &&\n      formEncType\n    ) {\n      submission = getSubmissionFromNavigation(state.navigation);\n    }\n\n    // If this was a 307/308 submission we want to preserve the HTTP method and\n    // re-submit the GET/POST/PUT/PATCH/DELETE as a submission navigation to the\n    // redirected location\n    let activeSubmission = submission || fetcherSubmission;\n    if (\n      redirectPreserveMethodStatusCodes.has(redirect.response.status) &&\n      activeSubmission &&\n      isMutationMethod(activeSubmission.formMethod)\n    ) {\n      await startNavigation(redirectHistoryAction, redirectLocation, {\n        submission: {\n          ...activeSubmission,\n          formAction: location,\n        },\n        // Preserve these flags across redirects\n        preventScrollReset: preventScrollReset || pendingPreventScrollReset,\n        enableViewTransition: isNavigation\n          ? pendingViewTransitionEnabled\n          : undefined,\n      });\n    } else {\n      // If we have a navigation submission, we will preserve it through the\n      // redirect navigation\n      let overrideNavigation = getLoadingNavigation(\n        redirectLocation,\n        submission\n      );\n      await startNavigation(redirectHistoryAction, redirectLocation, {\n        overrideNavigation,\n        // Send fetcher submissions through for shouldRevalidate\n        fetcherSubmission,\n        // Preserve these flags across redirects\n        preventScrollReset: preventScrollReset || pendingPreventScrollReset,\n        enableViewTransition: isNavigation\n          ? pendingViewTransitionEnabled\n          : undefined,\n      });\n    }\n  }\n\n  // Utility wrapper for calling dataStrategy client-side without having to\n  // pass around the manifest, mapRouteProperties, etc.\n  async function callDataStrategy(\n    type: \"loader\" | \"action\",\n    state: RouterState,\n    request: Request,\n    matchesToLoad: AgnosticDataRouteMatch[],\n    matches: AgnosticDataRouteMatch[],\n    fetcherKey: string | null\n  ): Promise<Record<string, DataResult>> {\n    let results: Record<string, DataStrategyResult>;\n    let dataResults: Record<string, DataResult> = {};\n    try {\n      results = await callDataStrategyImpl(\n        dataStrategyImpl,\n        type,\n        state,\n        request,\n        matchesToLoad,\n        matches,\n        fetcherKey,\n        manifest,\n        mapRouteProperties\n      );\n    } catch (e) {\n      // If the outer dataStrategy method throws, just return the error for all\n      // matches - and it'll naturally bubble to the root\n      matchesToLoad.forEach((m) => {\n        dataResults[m.route.id] = {\n          type: ResultType.error,\n          error: e,\n        };\n      });\n      return dataResults;\n    }\n\n    for (let [routeId, result] of Object.entries(results)) {\n      if (isRedirectDataStrategyResultResult(result)) {\n        let response = result.result as Response;\n        dataResults[routeId] = {\n          type: ResultType.redirect,\n          response: normalizeRelativeRoutingRedirectResponse(\n            response,\n            request,\n            routeId,\n            matches,\n            basename,\n            future.v7_relativeSplatPath\n          ),\n        };\n      } else {\n        dataResults[routeId] = await convertDataStrategyResultToDataResult(\n          result\n        );\n      }\n    }\n\n    return dataResults;\n  }\n\n  async function callLoadersAndMaybeResolveData(\n    state: RouterState,\n    matches: AgnosticDataRouteMatch[],\n    matchesToLoad: AgnosticDataRouteMatch[],\n    fetchersToLoad: RevalidatingFetcher[],\n    request: Request\n  ) {\n    let currentMatches = state.matches;\n\n    // Kick off loaders and fetchers in parallel\n    let loaderResultsPromise = callDataStrategy(\n      \"loader\",\n      state,\n      request,\n      matchesToLoad,\n      matches,\n      null\n    );\n\n    let fetcherResultsPromise = Promise.all(\n      fetchersToLoad.map(async (f) => {\n        if (f.matches && f.match && f.controller) {\n          let results = await callDataStrategy(\n            \"loader\",\n            state,\n            createClientSideRequest(init.history, f.path, f.controller.signal),\n            [f.match],\n            f.matches,\n            f.key\n          );\n          let result = results[f.match.route.id];\n          // Fetcher results are keyed by fetcher key from here on out, not routeId\n          return { [f.key]: result };\n        } else {\n          return Promise.resolve({\n            [f.key]: {\n              type: ResultType.error,\n              error: getInternalRouterError(404, {\n                pathname: f.path,\n              }),\n            } as ErrorResult,\n          });\n        }\n      })\n    );\n\n    let loaderResults = await loaderResultsPromise;\n    let fetcherResults = (await fetcherResultsPromise).reduce(\n      (acc, r) => Object.assign(acc, r),\n      {}\n    );\n\n    await Promise.all([\n      resolveNavigationDeferredResults(\n        matches,\n        loaderResults,\n        request.signal,\n        currentMatches,\n        state.loaderData\n      ),\n      resolveFetcherDeferredResults(matches, fetcherResults, fetchersToLoad),\n    ]);\n\n    return {\n      loaderResults,\n      fetcherResults,\n    };\n  }\n\n  function interruptActiveLoads() {\n    // Every interruption triggers a revalidation\n    isRevalidationRequired = true;\n\n    // Cancel pending route-level deferreds and mark cancelled routes for\n    // revalidation\n    cancelledDeferredRoutes.push(...cancelActiveDeferreds());\n\n    // Abort in-flight fetcher loads\n    fetchLoadMatches.forEach((_, key) => {\n      if (fetchControllers.has(key)) {\n        cancelledFetcherLoads.add(key);\n      }\n      abortFetcher(key);\n    });\n  }\n\n  function updateFetcherState(\n    key: string,\n    fetcher: Fetcher,\n    opts: { flushSync?: boolean } = {}\n  ) {\n    state.fetchers.set(key, fetcher);\n    updateState(\n      { fetchers: new Map(state.fetchers) },\n      { flushSync: (opts && opts.flushSync) === true }\n    );\n  }\n\n  function setFetcherError(\n    key: string,\n    routeId: string,\n    error: any,\n    opts: { flushSync?: boolean } = {}\n  ) {\n    let boundaryMatch = findNearestBoundary(state.matches, routeId);\n    deleteFetcher(key);\n    updateState(\n      {\n        errors: {\n          [boundaryMatch.route.id]: error,\n        },\n        fetchers: new Map(state.fetchers),\n      },\n      { flushSync: (opts && opts.flushSync) === true }\n    );\n  }\n\n  function getFetcher<TData = any>(key: string): Fetcher<TData> {\n    activeFetchers.set(key, (activeFetchers.get(key) || 0) + 1);\n    // If this fetcher was previously marked for deletion, unmark it since we\n    // have a new instance\n    if (deletedFetchers.has(key)) {\n      deletedFetchers.delete(key);\n    }\n    return state.fetchers.get(key) || IDLE_FETCHER;\n  }\n\n  function deleteFetcher(key: string): void {\n    let fetcher = state.fetchers.get(key);\n    // Don't abort the controller if this is a deletion of a fetcher.submit()\n    // in it's loading phase since - we don't want to abort the corresponding\n    // revalidation and want them to complete and land\n    if (\n      fetchControllers.has(key) &&\n      !(fetcher && fetcher.state === \"loading\" && fetchReloadIds.has(key))\n    ) {\n      abortFetcher(key);\n    }\n    fetchLoadMatches.delete(key);\n    fetchReloadIds.delete(key);\n    fetchRedirectIds.delete(key);\n\n    // If we opted into the flag we can clear this now since we're calling\n    // deleteFetcher() at the end of updateState() and we've already handed the\n    // deleted fetcher keys off to the data layer.\n    // If not, we're eagerly calling deleteFetcher() and we need to keep this\n    // Set populated until the next updateState call, and we'll clear\n    // `deletedFetchers` then\n    if (future.v7_fetcherPersist) {\n      deletedFetchers.delete(key);\n    }\n\n    cancelledFetcherLoads.delete(key);\n    state.fetchers.delete(key);\n  }\n\n  function deleteFetcherAndUpdateState(key: string): void {\n    let count = (activeFetchers.get(key) || 0) - 1;\n    if (count <= 0) {\n      activeFetchers.delete(key);\n      deletedFetchers.add(key);\n      if (!future.v7_fetcherPersist) {\n        deleteFetcher(key);\n      }\n    } else {\n      activeFetchers.set(key, count);\n    }\n\n    updateState({ fetchers: new Map(state.fetchers) });\n  }\n\n  function abortFetcher(key: string) {\n    let controller = fetchControllers.get(key);\n    if (controller) {\n      controller.abort();\n      fetchControllers.delete(key);\n    }\n  }\n\n  function markFetchersDone(keys: string[]) {\n    for (let key of keys) {\n      let fetcher = getFetcher(key);\n      let doneFetcher = getDoneFetcher(fetcher.data);\n      state.fetchers.set(key, doneFetcher);\n    }\n  }\n\n  function markFetchRedirectsDone(): boolean {\n    let doneKeys = [];\n    let updatedFetchers = false;\n    for (let key of fetchRedirectIds) {\n      let fetcher = state.fetchers.get(key);\n      invariant(fetcher, `Expected fetcher: ${key}`);\n      if (fetcher.state === \"loading\") {\n        fetchRedirectIds.delete(key);\n        doneKeys.push(key);\n        updatedFetchers = true;\n      }\n    }\n    markFetchersDone(doneKeys);\n    return updatedFetchers;\n  }\n\n  function abortStaleFetchLoads(landedId: number): boolean {\n    let yeetedKeys = [];\n    for (let [key, id] of fetchReloadIds) {\n      if (id < landedId) {\n        let fetcher = state.fetchers.get(key);\n        invariant(fetcher, `Expected fetcher: ${key}`);\n        if (fetcher.state === \"loading\") {\n          abortFetcher(key);\n          fetchReloadIds.delete(key);\n          yeetedKeys.push(key);\n        }\n      }\n    }\n    markFetchersDone(yeetedKeys);\n    return yeetedKeys.length > 0;\n  }\n\n  function getBlocker(key: string, fn: BlockerFunction) {\n    let blocker: Blocker = state.blockers.get(key) || IDLE_BLOCKER;\n\n    if (blockerFunctions.get(key) !== fn) {\n      blockerFunctions.set(key, fn);\n    }\n\n    return blocker;\n  }\n\n  function deleteBlocker(key: string) {\n    state.blockers.delete(key);\n    blockerFunctions.delete(key);\n  }\n\n  // Utility function to update blockers, ensuring valid state transitions\n  function updateBlocker(key: string, newBlocker: Blocker) {\n    let blocker = state.blockers.get(key) || IDLE_BLOCKER;\n\n    // Poor mans state machine :)\n    // https://mermaid.live/edit#pako:eNqVkc9OwzAMxl8l8nnjAYrEtDIOHEBIgwvKJTReGy3_lDpIqO27k6awMG0XcrLlnz87nwdonESogKXXBuE79rq75XZO3-yHds0RJVuv70YrPlUrCEe2HfrORS3rubqZfuhtpg5C9wk5tZ4VKcRUq88q9Z8RS0-48cE1iHJkL0ugbHuFLus9L6spZy8nX9MP2CNdomVaposqu3fGayT8T8-jJQwhepo_UtpgBQaDEUom04dZhAN1aJBDlUKJBxE1ceB2Smj0Mln-IBW5AFU2dwUiktt_2Qaq2dBfaKdEup85UV7Yd-dKjlnkabl2Pvr0DTkTreM\n    invariant(\n      (blocker.state === \"unblocked\" && newBlocker.state === \"blocked\") ||\n        (blocker.state === \"blocked\" && newBlocker.state === \"blocked\") ||\n        (blocker.state === \"blocked\" && newBlocker.state === \"proceeding\") ||\n        (blocker.state === \"blocked\" && newBlocker.state === \"unblocked\") ||\n        (blocker.state === \"proceeding\" && newBlocker.state === \"unblocked\"),\n      `Invalid blocker state transition: ${blocker.state} -> ${newBlocker.state}`\n    );\n\n    let blockers = new Map(state.blockers);\n    blockers.set(key, newBlocker);\n    updateState({ blockers });\n  }\n\n  function shouldBlockNavigation({\n    currentLocation,\n    nextLocation,\n    historyAction,\n  }: {\n    currentLocation: Location;\n    nextLocation: Location;\n    historyAction: HistoryAction;\n  }): string | undefined {\n    if (blockerFunctions.size === 0) {\n      return;\n    }\n\n    // We ony support a single active blocker at the moment since we don't have\n    // any compelling use cases for multi-blocker yet\n    if (blockerFunctions.size > 1) {\n      warning(false, \"A router only supports one blocker at a time\");\n    }\n\n    let entries = Array.from(blockerFunctions.entries());\n    let [blockerKey, blockerFunction] = entries[entries.length - 1];\n    let blocker = state.blockers.get(blockerKey);\n\n    if (blocker && blocker.state === \"proceeding\") {\n      // If the blocker is currently proceeding, we don't need to re-check\n      // it and can let this navigation continue\n      return;\n    }\n\n    // At this point, we know we're unblocked/blocked so we need to check the\n    // user-provided blocker function\n    if (blockerFunction({ currentLocation, nextLocation, historyAction })) {\n      return blockerKey;\n    }\n  }\n\n  function handleNavigational404(pathname: string) {\n    let error = getInternalRouterError(404, { pathname });\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    let { matches, route } = getShortCircuitMatches(routesToUse);\n\n    // Cancel all pending deferred on 404s since we don't keep any routes\n    cancelActiveDeferreds();\n\n    return { notFoundMatches: matches, route, error };\n  }\n\n  function cancelActiveDeferreds(\n    predicate?: (routeId: string) => boolean\n  ): string[] {\n    let cancelledRouteIds: string[] = [];\n    activeDeferreds.forEach((dfd, routeId) => {\n      if (!predicate || predicate(routeId)) {\n        // Cancel the deferred - but do not remove from activeDeferreds here -\n        // we rely on the subscribers to do that so our tests can assert proper\n        // cleanup via _internalActiveDeferreds\n        dfd.cancel();\n        cancelledRouteIds.push(routeId);\n        activeDeferreds.delete(routeId);\n      }\n    });\n    return cancelledRouteIds;\n  }\n\n  // Opt in to capturing and reporting scroll positions during navigations,\n  // used by the <ScrollRestoration> component\n  function enableScrollRestoration(\n    positions: Record<string, number>,\n    getPosition: GetScrollPositionFunction,\n    getKey?: GetScrollRestorationKeyFunction\n  ) {\n    savedScrollPositions = positions;\n    getScrollPosition = getPosition;\n    getScrollRestorationKey = getKey || null;\n\n    // Perform initial hydration scroll restoration, since we miss the boat on\n    // the initial updateState() because we've not yet rendered <ScrollRestoration/>\n    // and therefore have no savedScrollPositions available\n    if (!initialScrollRestored && state.navigation === IDLE_NAVIGATION) {\n      initialScrollRestored = true;\n      let y = getSavedScrollPosition(state.location, state.matches);\n      if (y != null) {\n        updateState({ restoreScrollPosition: y });\n      }\n    }\n\n    return () => {\n      savedScrollPositions = null;\n      getScrollPosition = null;\n      getScrollRestorationKey = null;\n    };\n  }\n\n  function getScrollKey(location: Location, matches: AgnosticDataRouteMatch[]) {\n    if (getScrollRestorationKey) {\n      let key = getScrollRestorationKey(\n        location,\n        matches.map((m) => convertRouteMatchToUiMatch(m, state.loaderData))\n      );\n      return key || location.key;\n    }\n    return location.key;\n  }\n\n  function saveScrollPosition(\n    location: Location,\n    matches: AgnosticDataRouteMatch[]\n  ): void {\n    if (savedScrollPositions && getScrollPosition) {\n      let key = getScrollKey(location, matches);\n      savedScrollPositions[key] = getScrollPosition();\n    }\n  }\n\n  function getSavedScrollPosition(\n    location: Location,\n    matches: AgnosticDataRouteMatch[]\n  ): number | null {\n    if (savedScrollPositions) {\n      let key = getScrollKey(location, matches);\n      let y = savedScrollPositions[key];\n      if (typeof y === \"number\") {\n        return y;\n      }\n    }\n    return null;\n  }\n\n  function checkFogOfWar(\n    matches: AgnosticDataRouteMatch[] | null,\n    routesToUse: AgnosticDataRouteObject[],\n    pathname: string\n  ): { active: boolean; matches: AgnosticDataRouteMatch[] | null } {\n    if (patchRoutesOnNavigationImpl) {\n      if (!matches) {\n        let fogMatches = matchRoutesImpl<AgnosticDataRouteObject>(\n          routesToUse,\n          pathname,\n          basename,\n          true\n        );\n\n        return { active: true, matches: fogMatches || [] };\n      } else {\n        if (Object.keys(matches[0].params).length > 0) {\n          // If we matched a dynamic param or a splat, it might only be because\n          // we haven't yet discovered other routes that would match with a\n          // higher score.  Call patchRoutesOnNavigation just to be sure\n          let partialMatches = matchRoutesImpl<AgnosticDataRouteObject>(\n            routesToUse,\n            pathname,\n            basename,\n            true\n          );\n          return { active: true, matches: partialMatches };\n        }\n      }\n    }\n\n    return { active: false, matches: null };\n  }\n\n  type DiscoverRoutesSuccessResult = {\n    type: \"success\";\n    matches: AgnosticDataRouteMatch[] | null;\n  };\n  type DiscoverRoutesErrorResult = {\n    type: \"error\";\n    error: any;\n    partialMatches: AgnosticDataRouteMatch[];\n  };\n  type DiscoverRoutesAbortedResult = { type: \"aborted\" };\n  type DiscoverRoutesResult =\n    | DiscoverRoutesSuccessResult\n    | DiscoverRoutesErrorResult\n    | DiscoverRoutesAbortedResult;\n\n  async function discoverRoutes(\n    matches: AgnosticDataRouteMatch[],\n    pathname: string,\n    signal: AbortSignal,\n    fetcherKey?: string\n  ): Promise<DiscoverRoutesResult> {\n    if (!patchRoutesOnNavigationImpl) {\n      return { type: \"success\", matches };\n    }\n\n    let partialMatches: AgnosticDataRouteMatch[] | null = matches;\n    while (true) {\n      let isNonHMR = inFlightDataRoutes == null;\n      let routesToUse = inFlightDataRoutes || dataRoutes;\n      let localManifest = manifest;\n      try {\n        await patchRoutesOnNavigationImpl({\n          signal,\n          path: pathname,\n          matches: partialMatches,\n          fetcherKey,\n          patch: (routeId, children) => {\n            if (signal.aborted) return;\n            patchRoutesImpl(\n              routeId,\n              children,\n              routesToUse,\n              localManifest,\n              mapRouteProperties\n            );\n          },\n        });\n      } catch (e) {\n        return { type: \"error\", error: e, partialMatches };\n      } finally {\n        // If we are not in the middle of an HMR revalidation and we changed the\n        // routes, provide a new identity so when we `updateState` at the end of\n        // this navigation/fetch `router.routes` will be a new identity and\n        // trigger a re-run of memoized `router.routes` dependencies.\n        // HMR will already update the identity and reflow when it lands\n        // `inFlightDataRoutes` in `completeNavigation`\n        if (isNonHMR && !signal.aborted) {\n          dataRoutes = [...dataRoutes];\n        }\n      }\n\n      if (signal.aborted) {\n        return { type: \"aborted\" };\n      }\n\n      let newMatches = matchRoutes(routesToUse, pathname, basename);\n      if (newMatches) {\n        return { type: \"success\", matches: newMatches };\n      }\n\n      let newPartialMatches = matchRoutesImpl<AgnosticDataRouteObject>(\n        routesToUse,\n        pathname,\n        basename,\n        true\n      );\n\n      // Avoid loops if the second pass results in the same partial matches\n      if (\n        !newPartialMatches ||\n        (partialMatches.length === newPartialMatches.length &&\n          partialMatches.every(\n            (m, i) => m.route.id === newPartialMatches![i].route.id\n          ))\n      ) {\n        return { type: \"success\", matches: null };\n      }\n\n      partialMatches = newPartialMatches;\n    }\n  }\n\n  function _internalSetRoutes(newRoutes: AgnosticDataRouteObject[]) {\n    manifest = {};\n    inFlightDataRoutes = convertRoutesToDataRoutes(\n      newRoutes,\n      mapRouteProperties,\n      undefined,\n      manifest\n    );\n  }\n\n  function patchRoutes(\n    routeId: string | null,\n    children: AgnosticRouteObject[]\n  ): void {\n    let isNonHMR = inFlightDataRoutes == null;\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    patchRoutesImpl(\n      routeId,\n      children,\n      routesToUse,\n      manifest,\n      mapRouteProperties\n    );\n\n    // If we are not in the middle of an HMR revalidation and we changed the\n    // routes, provide a new identity and trigger a reflow via `updateState`\n    // to re-run memoized `router.routes` dependencies.\n    // HMR will already update the identity and reflow when it lands\n    // `inFlightDataRoutes` in `completeNavigation`\n    if (isNonHMR) {\n      dataRoutes = [...dataRoutes];\n      updateState({});\n    }\n  }\n\n  router = {\n    get basename() {\n      return basename;\n    },\n    get future() {\n      return future;\n    },\n    get state() {\n      return state;\n    },\n    get routes() {\n      return dataRoutes;\n    },\n    get window() {\n      return routerWindow;\n    },\n    initialize,\n    subscribe,\n    enableScrollRestoration,\n    navigate,\n    fetch,\n    revalidate,\n    // Passthrough to history-aware createHref used by useHref so we get proper\n    // hash-aware URLs in DOM paths\n    createHref: (to: To) => init.history.createHref(to),\n    encodeLocation: (to: To) => init.history.encodeLocation(to),\n    getFetcher,\n    deleteFetcher: deleteFetcherAndUpdateState,\n    dispose,\n    getBlocker,\n    deleteBlocker,\n    patchRoutes,\n    _internalFetchControllers: fetchControllers,\n    _internalActiveDeferreds: activeDeferreds,\n    // TODO: Remove setRoutes, it's temporary to avoid dealing with\n    // updating the tree while validating the update algorithm.\n    _internalSetRoutes,\n  };\n\n  return router;\n}\n//#endregion\n\n////////////////////////////////////////////////////////////////////////////////\n//#region createStaticHandler\n////////////////////////////////////////////////////////////////////////////////\n\nexport const UNSAFE_DEFERRED_SYMBOL = Symbol(\"deferred\");\n\n/**\n * Future flags to toggle new feature behavior\n */\nexport interface StaticHandlerFutureConfig {\n  v7_relativeSplatPath: boolean;\n  v7_throwAbortReason: boolean;\n}\n\nexport interface CreateStaticHandlerOptions {\n  basename?: string;\n  /**\n   * @deprecated Use `mapRouteProperties` instead\n   */\n  detectErrorBoundary?: DetectErrorBoundaryFunction;\n  mapRouteProperties?: MapRoutePropertiesFunction;\n  future?: Partial<StaticHandlerFutureConfig>;\n}\n\nexport function createStaticHandler(\n  routes: AgnosticRouteObject[],\n  opts?: CreateStaticHandlerOptions\n): StaticHandler {\n  invariant(\n    routes.length > 0,\n    \"You must provide a non-empty routes array to createStaticHandler\"\n  );\n\n  let manifest: RouteManifest = {};\n  let basename = (opts ? opts.basename : null) || \"/\";\n  let mapRouteProperties: MapRoutePropertiesFunction;\n  if (opts?.mapRouteProperties) {\n    mapRouteProperties = opts.mapRouteProperties;\n  } else if (opts?.detectErrorBoundary) {\n    // If they are still using the deprecated version, wrap it with the new API\n    let detectErrorBoundary = opts.detectErrorBoundary;\n    mapRouteProperties = (route) => ({\n      hasErrorBoundary: detectErrorBoundary(route),\n    });\n  } else {\n    mapRouteProperties = defaultMapRouteProperties;\n  }\n  // Config driven behavior flags\n  let future: StaticHandlerFutureConfig = {\n    v7_relativeSplatPath: false,\n    v7_throwAbortReason: false,\n    ...(opts ? opts.future : null),\n  };\n\n  let dataRoutes = convertRoutesToDataRoutes(\n    routes,\n    mapRouteProperties,\n    undefined,\n    manifest\n  );\n\n  /**\n   * The query() method is intended for document requests, in which we want to\n   * call an optional action and potentially multiple loaders for all nested\n   * routes.  It returns a StaticHandlerContext object, which is very similar\n   * to the router state (location, loaderData, actionData, errors, etc.) and\n   * also adds SSR-specific information such as the statusCode and headers\n   * from action/loaders Responses.\n   *\n   * It _should_ never throw and should report all errors through the\n   * returned context.errors object, properly associating errors to their error\n   * boundary.  Additionally, it tracks _deepestRenderedBoundaryId which can be\n   * used to emulate React error boundaries during SSr by performing a second\n   * pass only down to the boundaryId.\n   *\n   * The one exception where we do not return a StaticHandlerContext is when a\n   * redirect response is returned or thrown from any action/loader.  We\n   * propagate that out and return the raw Response so the HTTP server can\n   * return it directly.\n   *\n   * - `opts.requestContext` is an optional server context that will be passed\n   *   to actions/loaders in the `context` parameter\n   * - `opts.skipLoaderErrorBubbling` is an optional parameter that will prevent\n   *   the bubbling of errors which allows single-fetch-type implementations\n   *   where the client will handle the bubbling and we may need to return data\n   *   for the handling route\n   */\n  async function query(\n    request: Request,\n    {\n      requestContext,\n      skipLoaderErrorBubbling,\n      dataStrategy,\n    }: {\n      requestContext?: unknown;\n      skipLoaderErrorBubbling?: boolean;\n      dataStrategy?: DataStrategyFunction;\n    } = {}\n  ): Promise<StaticHandlerContext | Response> {\n    let url = new URL(request.url);\n    let method = request.method;\n    let location = createLocation(\"\", createPath(url), null, \"default\");\n    let matches = matchRoutes(dataRoutes, location, basename);\n\n    // SSR supports HEAD requests while SPA doesn't\n    if (!isValidMethod(method) && method !== \"HEAD\") {\n      let error = getInternalRouterError(405, { method });\n      let { matches: methodNotAllowedMatches, route } =\n        getShortCircuitMatches(dataRoutes);\n      return {\n        basename,\n        location,\n        matches: methodNotAllowedMatches,\n        loaderData: {},\n        actionData: null,\n        errors: {\n          [route.id]: error,\n        },\n        statusCode: error.status,\n        loaderHeaders: {},\n        actionHeaders: {},\n        activeDeferreds: null,\n      };\n    } else if (!matches) {\n      let error = getInternalRouterError(404, { pathname: location.pathname });\n      let { matches: notFoundMatches, route } =\n        getShortCircuitMatches(dataRoutes);\n      return {\n        basename,\n        location,\n        matches: notFoundMatches,\n        loaderData: {},\n        actionData: null,\n        errors: {\n          [route.id]: error,\n        },\n        statusCode: error.status,\n        loaderHeaders: {},\n        actionHeaders: {},\n        activeDeferreds: null,\n      };\n    }\n\n    let result = await queryImpl(\n      request,\n      location,\n      matches,\n      requestContext,\n      dataStrategy || null,\n      skipLoaderErrorBubbling === true,\n      null\n    );\n    if (isResponse(result)) {\n      return result;\n    }\n\n    // When returning StaticHandlerContext, we patch back in the location here\n    // since we need it for React Context.  But this helps keep our submit and\n    // loadRouteData operating on a Request instead of a Location\n    return { location, basename, ...result };\n  }\n\n  /**\n   * The queryRoute() method is intended for targeted route requests, either\n   * for fetch ?_data requests or resource route requests.  In this case, we\n   * are only ever calling a single action or loader, and we are returning the\n   * returned value directly.  In most cases, this will be a Response returned\n   * from the action/loader, but it may be a primitive or other value as well -\n   * and in such cases the calling context should handle that accordingly.\n   *\n   * We do respect the throw/return differentiation, so if an action/loader\n   * throws, then this method will throw the value.  This is important so we\n   * can do proper boundary identification in Remix where a thrown Response\n   * must go to the Catch Boundary but a returned Response is happy-path.\n   *\n   * One thing to note is that any Router-initiated Errors that make sense\n   * to associate with a status code will be thrown as an ErrorResponse\n   * instance which include the raw Error, such that the calling context can\n   * serialize the error as they see fit while including the proper response\n   * code.  Examples here are 404 and 405 errors that occur prior to reaching\n   * any user-defined loaders.\n   *\n   * - `opts.routeId` allows you to specify the specific route handler to call.\n   *   If not provided the handler will determine the proper route by matching\n   *   against `request.url`\n   * - `opts.requestContext` is an optional server context that will be passed\n   *    to actions/loaders in the `context` parameter\n   */\n  async function queryRoute(\n    request: Request,\n    {\n      routeId,\n      requestContext,\n      dataStrategy,\n    }: {\n      requestContext?: unknown;\n      routeId?: string;\n      dataStrategy?: DataStrategyFunction;\n    } = {}\n  ): Promise<any> {\n    let url = new URL(request.url);\n    let method = request.method;\n    let location = createLocation(\"\", createPath(url), null, \"default\");\n    let matches = matchRoutes(dataRoutes, location, basename);\n\n    // SSR supports HEAD requests while SPA doesn't\n    if (!isValidMethod(method) && method !== \"HEAD\" && method !== \"OPTIONS\") {\n      throw getInternalRouterError(405, { method });\n    } else if (!matches) {\n      throw getInternalRouterError(404, { pathname: location.pathname });\n    }\n\n    let match = routeId\n      ? matches.find((m) => m.route.id === routeId)\n      : getTargetMatch(matches, location);\n\n    if (routeId && !match) {\n      throw getInternalRouterError(403, {\n        pathname: location.pathname,\n        routeId,\n      });\n    } else if (!match) {\n      // This should never hit I don't think?\n      throw getInternalRouterError(404, { pathname: location.pathname });\n    }\n\n    let result = await queryImpl(\n      request,\n      location,\n      matches,\n      requestContext,\n      dataStrategy || null,\n      false,\n      match\n    );\n\n    if (isResponse(result)) {\n      return result;\n    }\n\n    let error = result.errors ? Object.values(result.errors)[0] : undefined;\n    if (error !== undefined) {\n      // If we got back result.errors, that means the loader/action threw\n      // _something_ that wasn't a Response, but it's not guaranteed/required\n      // to be an `instanceof Error` either, so we have to use throw here to\n      // preserve the \"error\" state outside of queryImpl.\n      throw error;\n    }\n\n    // Pick off the right state value to return\n    if (result.actionData) {\n      return Object.values(result.actionData)[0];\n    }\n\n    if (result.loaderData) {\n      let data = Object.values(result.loaderData)[0];\n      if (result.activeDeferreds?.[match.route.id]) {\n        data[UNSAFE_DEFERRED_SYMBOL] = result.activeDeferreds[match.route.id];\n      }\n      return data;\n    }\n\n    return undefined;\n  }\n\n  async function queryImpl(\n    request: Request,\n    location: Location,\n    matches: AgnosticDataRouteMatch[],\n    requestContext: unknown,\n    dataStrategy: DataStrategyFunction | null,\n    skipLoaderErrorBubbling: boolean,\n    routeMatch: AgnosticDataRouteMatch | null\n  ): Promise<Omit<StaticHandlerContext, \"location\" | \"basename\"> | Response> {\n    invariant(\n      request.signal,\n      \"query()/queryRoute() requests must contain an AbortController signal\"\n    );\n\n    try {\n      if (isMutationMethod(request.method.toLowerCase())) {\n        let result = await submit(\n          request,\n          matches,\n          routeMatch || getTargetMatch(matches, location),\n          requestContext,\n          dataStrategy,\n          skipLoaderErrorBubbling,\n          routeMatch != null\n        );\n        return result;\n      }\n\n      let result = await loadRouteData(\n        request,\n        matches,\n        requestContext,\n        dataStrategy,\n        skipLoaderErrorBubbling,\n        routeMatch\n      );\n      return isResponse(result)\n        ? result\n        : {\n            ...result,\n            actionData: null,\n            actionHeaders: {},\n          };\n    } catch (e) {\n      // If the user threw/returned a Response in callLoaderOrAction for a\n      // `queryRoute` call, we throw the `DataStrategyResult` to bail out early\n      // and then return or throw the raw Response here accordingly\n      if (isDataStrategyResult(e) && isResponse(e.result)) {\n        if (e.type === ResultType.error) {\n          throw e.result;\n        }\n        return e.result;\n      }\n      // Redirects are always returned since they don't propagate to catch\n      // boundaries\n      if (isRedirectResponse(e)) {\n        return e;\n      }\n      throw e;\n    }\n  }\n\n  async function submit(\n    request: Request,\n    matches: AgnosticDataRouteMatch[],\n    actionMatch: AgnosticDataRouteMatch,\n    requestContext: unknown,\n    dataStrategy: DataStrategyFunction | null,\n    skipLoaderErrorBubbling: boolean,\n    isRouteRequest: boolean\n  ): Promise<Omit<StaticHandlerContext, \"location\" | \"basename\"> | Response> {\n    let result: DataResult;\n\n    if (!actionMatch.route.action && !actionMatch.route.lazy) {\n      let error = getInternalRouterError(405, {\n        method: request.method,\n        pathname: new URL(request.url).pathname,\n        routeId: actionMatch.route.id,\n      });\n      if (isRouteRequest) {\n        throw error;\n      }\n      result = {\n        type: ResultType.error,\n        error,\n      };\n    } else {\n      let results = await callDataStrategy(\n        \"action\",\n        request,\n        [actionMatch],\n        matches,\n        isRouteRequest,\n        requestContext,\n        dataStrategy\n      );\n      result = results[actionMatch.route.id];\n\n      if (request.signal.aborted) {\n        throwStaticHandlerAbortedError(request, isRouteRequest, future);\n      }\n    }\n\n    if (isRedirectResult(result)) {\n      // Uhhhh - this should never happen, we should always throw these from\n      // callLoaderOrAction, but the type narrowing here keeps TS happy and we\n      // can get back on the \"throw all redirect responses\" train here should\n      // this ever happen :/\n      throw new Response(null, {\n        status: result.response.status,\n        headers: {\n          Location: result.response.headers.get(\"Location\")!,\n        },\n      });\n    }\n\n    if (isDeferredResult(result)) {\n      let error = getInternalRouterError(400, { type: \"defer-action\" });\n      if (isRouteRequest) {\n        throw error;\n      }\n      result = {\n        type: ResultType.error,\n        error,\n      };\n    }\n\n    if (isRouteRequest) {\n      // Note: This should only be non-Response values if we get here, since\n      // isRouteRequest should throw any Response received in callLoaderOrAction\n      if (isErrorResult(result)) {\n        throw result.error;\n      }\n\n      return {\n        matches: [actionMatch],\n        loaderData: {},\n        actionData: { [actionMatch.route.id]: result.data },\n        errors: null,\n        // Note: statusCode + headers are unused here since queryRoute will\n        // return the raw Response or value\n        statusCode: 200,\n        loaderHeaders: {},\n        actionHeaders: {},\n        activeDeferreds: null,\n      };\n    }\n\n    // Create a GET request for the loaders\n    let loaderRequest = new Request(request.url, {\n      headers: request.headers,\n      redirect: request.redirect,\n      signal: request.signal,\n    });\n\n    if (isErrorResult(result)) {\n      // Store off the pending error - we use it to determine which loaders\n      // to call and will commit it when we complete the navigation\n      let boundaryMatch = skipLoaderErrorBubbling\n        ? actionMatch\n        : findNearestBoundary(matches, actionMatch.route.id);\n\n      let context = await loadRouteData(\n        loaderRequest,\n        matches,\n        requestContext,\n        dataStrategy,\n        skipLoaderErrorBubbling,\n        null,\n        [boundaryMatch.route.id, result]\n      );\n\n      // action status codes take precedence over loader status codes\n      return {\n        ...context,\n        statusCode: isRouteErrorResponse(result.error)\n          ? result.error.status\n          : result.statusCode != null\n          ? result.statusCode\n          : 500,\n        actionData: null,\n        actionHeaders: {\n          ...(result.headers ? { [actionMatch.route.id]: result.headers } : {}),\n        },\n      };\n    }\n\n    let context = await loadRouteData(\n      loaderRequest,\n      matches,\n      requestContext,\n      dataStrategy,\n      skipLoaderErrorBubbling,\n      null\n    );\n\n    return {\n      ...context,\n      actionData: {\n        [actionMatch.route.id]: result.data,\n      },\n      // action status codes take precedence over loader status codes\n      ...(result.statusCode ? { statusCode: result.statusCode } : {}),\n      actionHeaders: result.headers\n        ? { [actionMatch.route.id]: result.headers }\n        : {},\n    };\n  }\n\n  async function loadRouteData(\n    request: Request,\n    matches: AgnosticDataRouteMatch[],\n    requestContext: unknown,\n    dataStrategy: DataStrategyFunction | null,\n    skipLoaderErrorBubbling: boolean,\n    routeMatch: AgnosticDataRouteMatch | null,\n    pendingActionResult?: PendingActionResult\n  ): Promise<\n    | Omit<\n        StaticHandlerContext,\n        \"location\" | \"basename\" | \"actionData\" | \"actionHeaders\"\n      >\n    | Response\n  > {\n    let isRouteRequest = routeMatch != null;\n\n    // Short circuit if we have no loaders to run (queryRoute())\n    if (\n      isRouteRequest &&\n      !routeMatch?.route.loader &&\n      !routeMatch?.route.lazy\n    ) {\n      throw getInternalRouterError(400, {\n        method: request.method,\n        pathname: new URL(request.url).pathname,\n        routeId: routeMatch?.route.id,\n      });\n    }\n\n    let requestMatches = routeMatch\n      ? [routeMatch]\n      : pendingActionResult && isErrorResult(pendingActionResult[1])\n      ? getLoaderMatchesUntilBoundary(matches, pendingActionResult[0])\n      : matches;\n    let matchesToLoad = requestMatches.filter(\n      (m) => m.route.loader || m.route.lazy\n    );\n\n    // Short circuit if we have no loaders to run (query())\n    if (matchesToLoad.length === 0) {\n      return {\n        matches,\n        // Add a null for all matched routes for proper revalidation on the client\n        loaderData: matches.reduce(\n          (acc, m) => Object.assign(acc, { [m.route.id]: null }),\n          {}\n        ),\n        errors:\n          pendingActionResult && isErrorResult(pendingActionResult[1])\n            ? {\n                [pendingActionResult[0]]: pendingActionResult[1].error,\n              }\n            : null,\n        statusCode: 200,\n        loaderHeaders: {},\n        activeDeferreds: null,\n      };\n    }\n\n    let results = await callDataStrategy(\n      \"loader\",\n      request,\n      matchesToLoad,\n      matches,\n      isRouteRequest,\n      requestContext,\n      dataStrategy\n    );\n\n    if (request.signal.aborted) {\n      throwStaticHandlerAbortedError(request, isRouteRequest, future);\n    }\n\n    // Process and commit output from loaders\n    let activeDeferreds = new Map<string, DeferredData>();\n    let context = processRouteLoaderData(\n      matches,\n      results,\n      pendingActionResult,\n      activeDeferreds,\n      skipLoaderErrorBubbling\n    );\n\n    // Add a null for any non-loader matches for proper revalidation on the client\n    let executedLoaders = new Set<string>(\n      matchesToLoad.map((match) => match.route.id)\n    );\n    matches.forEach((match) => {\n      if (!executedLoaders.has(match.route.id)) {\n        context.loaderData[match.route.id] = null;\n      }\n    });\n\n    return {\n      ...context,\n      matches,\n      activeDeferreds:\n        activeDeferreds.size > 0\n          ? Object.fromEntries(activeDeferreds.entries())\n          : null,\n    };\n  }\n\n  // Utility wrapper for calling dataStrategy server-side without having to\n  // pass around the manifest, mapRouteProperties, etc.\n  async function callDataStrategy(\n    type: \"loader\" | \"action\",\n    request: Request,\n    matchesToLoad: AgnosticDataRouteMatch[],\n    matches: AgnosticDataRouteMatch[],\n    isRouteRequest: boolean,\n    requestContext: unknown,\n    dataStrategy: DataStrategyFunction | null\n  ): Promise<Record<string, DataResult>> {\n    let results = await callDataStrategyImpl(\n      dataStrategy || defaultDataStrategy,\n      type,\n      null,\n      request,\n      matchesToLoad,\n      matches,\n      null,\n      manifest,\n      mapRouteProperties,\n      requestContext\n    );\n\n    let dataResults: Record<string, DataResult> = {};\n    await Promise.all(\n      matches.map(async (match) => {\n        if (!(match.route.id in results)) {\n          return;\n        }\n        let result = results[match.route.id];\n        if (isRedirectDataStrategyResultResult(result)) {\n          let response = result.result as Response;\n          // Throw redirects and let the server handle them with an HTTP redirect\n          throw normalizeRelativeRoutingRedirectResponse(\n            response,\n            request,\n            match.route.id,\n            matches,\n            basename,\n            future.v7_relativeSplatPath\n          );\n        }\n        if (isResponse(result.result) && isRouteRequest) {\n          // For SSR single-route requests, we want to hand Responses back\n          // directly without unwrapping\n          throw result;\n        }\n\n        dataResults[match.route.id] =\n          await convertDataStrategyResultToDataResult(result);\n      })\n    );\n    return dataResults;\n  }\n\n  return {\n    dataRoutes,\n    query,\n    queryRoute,\n  };\n}\n\n//#endregion\n\n////////////////////////////////////////////////////////////////////////////////\n//#region Helpers\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * Given an existing StaticHandlerContext and an error thrown at render time,\n * provide an updated StaticHandlerContext suitable for a second SSR render\n */\nexport function getStaticContextFromError(\n  routes: AgnosticDataRouteObject[],\n  context: StaticHandlerContext,\n  error: any\n) {\n  let newContext: StaticHandlerContext = {\n    ...context,\n    statusCode: isRouteErrorResponse(error) ? error.status : 500,\n    errors: {\n      [context._deepestRenderedBoundaryId || routes[0].id]: error,\n    },\n  };\n  return newContext;\n}\n\nfunction throwStaticHandlerAbortedError(\n  request: Request,\n  isRouteRequest: boolean,\n  future: StaticHandlerFutureConfig\n) {\n  if (future.v7_throwAbortReason && request.signal.reason !== undefined) {\n    throw request.signal.reason;\n  }\n\n  let method = isRouteRequest ? \"queryRoute\" : \"query\";\n  throw new Error(`${method}() call aborted: ${request.method} ${request.url}`);\n}\n\nfunction isSubmissionNavigation(\n  opts: BaseNavigateOrFetchOptions\n): opts is SubmissionNavigateOptions {\n  return (\n    opts != null &&\n    ((\"formData\" in opts && opts.formData != null) ||\n      (\"body\" in opts && opts.body !== undefined))\n  );\n}\n\nfunction normalizeTo(\n  location: Path,\n  matches: AgnosticDataRouteMatch[],\n  basename: string,\n  prependBasename: boolean,\n  to: To | null,\n  v7_relativeSplatPath: boolean,\n  fromRouteId?: string,\n  relative?: RelativeRoutingType\n) {\n  let contextualMatches: AgnosticDataRouteMatch[];\n  let activeRouteMatch: AgnosticDataRouteMatch | undefined;\n  if (fromRouteId) {\n    // Grab matches up to the calling route so our route-relative logic is\n    // relative to the correct source route\n    contextualMatches = [];\n    for (let match of matches) {\n      contextualMatches.push(match);\n      if (match.route.id === fromRouteId) {\n        activeRouteMatch = match;\n        break;\n      }\n    }\n  } else {\n    contextualMatches = matches;\n    activeRouteMatch = matches[matches.length - 1];\n  }\n\n  // Resolve the relative path\n  let path = resolveTo(\n    to ? to : \".\",\n    getResolveToMatches(contextualMatches, v7_relativeSplatPath),\n    stripBasename(location.pathname, basename) || location.pathname,\n    relative === \"path\"\n  );\n\n  // When `to` is not specified we inherit search/hash from the current\n  // location, unlike when to=\".\" and we just inherit the path.\n  // See https://github.com/remix-run/remix/issues/927\n  if (to == null) {\n    path.search = location.search;\n    path.hash = location.hash;\n  }\n\n  // Account for `?index` params when routing to the current location\n  if ((to == null || to === \"\" || to === \".\") && activeRouteMatch) {\n    let nakedIndex = hasNakedIndexQuery(path.search);\n    if (activeRouteMatch.route.index && !nakedIndex) {\n      // Add one when we're targeting an index route\n      path.search = path.search\n        ? path.search.replace(/^\\?/, \"?index&\")\n        : \"?index\";\n    } else if (!activeRouteMatch.route.index && nakedIndex) {\n      // Remove existing ones when we're not\n      let params = new URLSearchParams(path.search);\n      let indexValues = params.getAll(\"index\");\n      params.delete(\"index\");\n      indexValues.filter((v) => v).forEach((v) => params.append(\"index\", v));\n      let qs = params.toString();\n      path.search = qs ? `?${qs}` : \"\";\n    }\n  }\n\n  // If we're operating within a basename, prepend it to the pathname.  If\n  // this is a root navigation, then just use the raw basename which allows\n  // the basename to have full control over the presence of a trailing slash\n  // on root actions\n  if (prependBasename && basename !== \"/\") {\n    path.pathname =\n      path.pathname === \"/\" ? basename : joinPaths([basename, path.pathname]);\n  }\n\n  return createPath(path);\n}\n\n// Normalize navigation options by converting formMethod=GET formData objects to\n// URLSearchParams so they behave identically to links with query params\nfunction normalizeNavigateOptions(\n  normalizeFormMethod: boolean,\n  isFetcher: boolean,\n  path: string,\n  opts?: BaseNavigateOrFetchOptions\n): {\n  path: string;\n  submission?: Submission;\n  error?: ErrorResponseImpl;\n} {\n  // Return location verbatim on non-submission navigations\n  if (!opts || !isSubmissionNavigation(opts)) {\n    return { path };\n  }\n\n  if (opts.formMethod && !isValidMethod(opts.formMethod)) {\n    return {\n      path,\n      error: getInternalRouterError(405, { method: opts.formMethod }),\n    };\n  }\n\n  let getInvalidBodyError = () => ({\n    path,\n    error: getInternalRouterError(400, { type: \"invalid-body\" }),\n  });\n\n  // Create a Submission on non-GET navigations\n  let rawFormMethod = opts.formMethod || \"get\";\n  let formMethod = normalizeFormMethod\n    ? (rawFormMethod.toUpperCase() as V7_FormMethod)\n    : (rawFormMethod.toLowerCase() as FormMethod);\n  let formAction = stripHashFromPath(path);\n\n  if (opts.body !== undefined) {\n    if (opts.formEncType === \"text/plain\") {\n      // text only support POST/PUT/PATCH/DELETE submissions\n      if (!isMutationMethod(formMethod)) {\n        return getInvalidBodyError();\n      }\n\n      let text =\n        typeof opts.body === \"string\"\n          ? opts.body\n          : opts.body instanceof FormData ||\n            opts.body instanceof URLSearchParams\n          ? // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#plain-text-form-data\n            Array.from(opts.body.entries()).reduce(\n              (acc, [name, value]) => `${acc}${name}=${value}\\n`,\n              \"\"\n            )\n          : String(opts.body);\n\n      return {\n        path,\n        submission: {\n          formMethod,\n          formAction,\n          formEncType: opts.formEncType,\n          formData: undefined,\n          json: undefined,\n          text,\n        },\n      };\n    } else if (opts.formEncType === \"application/json\") {\n      // json only supports POST/PUT/PATCH/DELETE submissions\n      if (!isMutationMethod(formMethod)) {\n        return getInvalidBodyError();\n      }\n\n      try {\n        let json =\n          typeof opts.body === \"string\" ? JSON.parse(opts.body) : opts.body;\n\n        return {\n          path,\n          submission: {\n            formMethod,\n            formAction,\n            formEncType: opts.formEncType,\n            formData: undefined,\n            json,\n            text: undefined,\n          },\n        };\n      } catch (e) {\n        return getInvalidBodyError();\n      }\n    }\n  }\n\n  invariant(\n    typeof FormData === \"function\",\n    \"FormData is not available in this environment\"\n  );\n\n  let searchParams: URLSearchParams;\n  let formData: FormData;\n\n  if (opts.formData) {\n    searchParams = convertFormDataToSearchParams(opts.formData);\n    formData = opts.formData;\n  } else if (opts.body instanceof FormData) {\n    searchParams = convertFormDataToSearchParams(opts.body);\n    formData = opts.body;\n  } else if (opts.body instanceof URLSearchParams) {\n    searchParams = opts.body;\n    formData = convertSearchParamsToFormData(searchParams);\n  } else if (opts.body == null) {\n    searchParams = new URLSearchParams();\n    formData = new FormData();\n  } else {\n    try {\n      searchParams = new URLSearchParams(opts.body);\n      formData = convertSearchParamsToFormData(searchParams);\n    } catch (e) {\n      return getInvalidBodyError();\n    }\n  }\n\n  let submission: Submission = {\n    formMethod,\n    formAction,\n    formEncType:\n      (opts && opts.formEncType) || \"application/x-www-form-urlencoded\",\n    formData,\n    json: undefined,\n    text: undefined,\n  };\n\n  if (isMutationMethod(submission.formMethod)) {\n    return { path, submission };\n  }\n\n  // Flatten submission onto URLSearchParams for GET submissions\n  let parsedPath = parsePath(path);\n  // On GET navigation submissions we can drop the ?index param from the\n  // resulting location since all loaders will run.  But fetcher GET submissions\n  // only run a single loader so we need to preserve any incoming ?index params\n  if (isFetcher && parsedPath.search && hasNakedIndexQuery(parsedPath.search)) {\n    searchParams.append(\"index\", \"\");\n  }\n  parsedPath.search = `?${searchParams}`;\n\n  return { path: createPath(parsedPath), submission };\n}\n\n// Filter out all routes at/below any caught error as they aren't going to\n// render so we don't need to load them\nfunction getLoaderMatchesUntilBoundary(\n  matches: AgnosticDataRouteMatch[],\n  boundaryId: string,\n  includeBoundary = false\n) {\n  let index = matches.findIndex((m) => m.route.id === boundaryId);\n  if (index >= 0) {\n    return matches.slice(0, includeBoundary ? index + 1 : index);\n  }\n  return matches;\n}\n\nfunction getMatchesToLoad(\n  history: History,\n  state: RouterState,\n  matches: AgnosticDataRouteMatch[],\n  submission: Submission | undefined,\n  location: Location,\n  initialHydration: boolean,\n  skipActionErrorRevalidation: boolean,\n  isRevalidationRequired: boolean,\n  cancelledDeferredRoutes: string[],\n  cancelledFetcherLoads: Set<string>,\n  deletedFetchers: Set<string>,\n  fetchLoadMatches: Map<string, FetchLoadMatch>,\n  fetchRedirectIds: Set<string>,\n  routesToUse: AgnosticDataRouteObject[],\n  basename: string | undefined,\n  pendingActionResult?: PendingActionResult\n): [AgnosticDataRouteMatch[], RevalidatingFetcher[]] {\n  let actionResult = pendingActionResult\n    ? isErrorResult(pendingActionResult[1])\n      ? pendingActionResult[1].error\n      : pendingActionResult[1].data\n    : undefined;\n  let currentUrl = history.createURL(state.location);\n  let nextUrl = history.createURL(location);\n\n  // Pick navigation matches that are net-new or qualify for revalidation\n  let boundaryMatches = matches;\n  if (initialHydration && state.errors) {\n    // On initial hydration, only consider matches up to _and including_ the boundary.\n    // This is inclusive to handle cases where a server loader ran successfully,\n    // a child server loader bubbled up to this route, but this route has\n    // `clientLoader.hydrate` so we want to still run the `clientLoader` so that\n    // we have a complete version of `loaderData`\n    boundaryMatches = getLoaderMatchesUntilBoundary(\n      matches,\n      Object.keys(state.errors)[0],\n      true\n    );\n  } else if (pendingActionResult && isErrorResult(pendingActionResult[1])) {\n    // If an action threw an error, we call loaders up to, but not including the\n    // boundary\n    boundaryMatches = getLoaderMatchesUntilBoundary(\n      matches,\n      pendingActionResult[0]\n    );\n  }\n\n  // Don't revalidate loaders by default after action 4xx/5xx responses\n  // when the flag is enabled.  They can still opt-into revalidation via\n  // `shouldRevalidate` via `actionResult`\n  let actionStatus = pendingActionResult\n    ? pendingActionResult[1].statusCode\n    : undefined;\n  let shouldSkipRevalidation =\n    skipActionErrorRevalidation && actionStatus && actionStatus >= 400;\n\n  let navigationMatches = boundaryMatches.filter((match, index) => {\n    let { route } = match;\n    if (route.lazy) {\n      // We haven't loaded this route yet so we don't know if it's got a loader!\n      return true;\n    }\n\n    if (route.loader == null) {\n      return false;\n    }\n\n    if (initialHydration) {\n      return shouldLoadRouteOnHydration(route, state.loaderData, state.errors);\n    }\n\n    // Always call the loader on new route instances and pending defer cancellations\n    if (\n      isNewLoader(state.loaderData, state.matches[index], match) ||\n      cancelledDeferredRoutes.some((id) => id === match.route.id)\n    ) {\n      return true;\n    }\n\n    // This is the default implementation for when we revalidate.  If the route\n    // provides it's own implementation, then we give them full control but\n    // provide this value so they can leverage it if needed after they check\n    // their own specific use cases\n    let currentRouteMatch = state.matches[index];\n    let nextRouteMatch = match;\n\n    return shouldRevalidateLoader(match, {\n      currentUrl,\n      currentParams: currentRouteMatch.params,\n      nextUrl,\n      nextParams: nextRouteMatch.params,\n      ...submission,\n      actionResult,\n      actionStatus,\n      defaultShouldRevalidate: shouldSkipRevalidation\n        ? false\n        : // Forced revalidation due to submission, useRevalidator, or X-Remix-Revalidate\n          isRevalidationRequired ||\n          currentUrl.pathname + currentUrl.search ===\n            nextUrl.pathname + nextUrl.search ||\n          // Search params affect all loaders\n          currentUrl.search !== nextUrl.search ||\n          isNewRouteInstance(currentRouteMatch, nextRouteMatch),\n    });\n  });\n\n  // Pick fetcher.loads that need to be revalidated\n  let revalidatingFetchers: RevalidatingFetcher[] = [];\n  fetchLoadMatches.forEach((f, key) => {\n    // Don't revalidate:\n    //  - on initial hydration (shouldn't be any fetchers then anyway)\n    //  - if fetcher won't be present in the subsequent render\n    //    - no longer matches the URL (v7_fetcherPersist=false)\n    //    - was unmounted but persisted due to v7_fetcherPersist=true\n    if (\n      initialHydration ||\n      !matches.some((m) => m.route.id === f.routeId) ||\n      deletedFetchers.has(key)\n    ) {\n      return;\n    }\n\n    let fetcherMatches = matchRoutes(routesToUse, f.path, basename);\n\n    // If the fetcher path no longer matches, push it in with null matches so\n    // we can trigger a 404 in callLoadersAndMaybeResolveData.  Note this is\n    // currently only a use-case for Remix HMR where the route tree can change\n    // at runtime and remove a route previously loaded via a fetcher\n    if (!fetcherMatches) {\n      revalidatingFetchers.push({\n        key,\n        routeId: f.routeId,\n        path: f.path,\n        matches: null,\n        match: null,\n        controller: null,\n      });\n      return;\n    }\n\n    // Revalidating fetchers are decoupled from the route matches since they\n    // load from a static href.  They revalidate based on explicit revalidation\n    // (submission, useRevalidator, or X-Remix-Revalidate)\n    let fetcher = state.fetchers.get(key);\n    let fetcherMatch = getTargetMatch(fetcherMatches, f.path);\n\n    let shouldRevalidate = false;\n    if (fetchRedirectIds.has(key)) {\n      // Never trigger a revalidation of an actively redirecting fetcher\n      shouldRevalidate = false;\n    } else if (cancelledFetcherLoads.has(key)) {\n      // Always mark for revalidation if the fetcher was cancelled\n      cancelledFetcherLoads.delete(key);\n      shouldRevalidate = true;\n    } else if (\n      fetcher &&\n      fetcher.state !== \"idle\" &&\n      fetcher.data === undefined\n    ) {\n      // If the fetcher hasn't ever completed loading yet, then this isn't a\n      // revalidation, it would just be a brand new load if an explicit\n      // revalidation is required\n      shouldRevalidate = isRevalidationRequired;\n    } else {\n      // Otherwise fall back on any user-defined shouldRevalidate, defaulting\n      // to explicit revalidations only\n      shouldRevalidate = shouldRevalidateLoader(fetcherMatch, {\n        currentUrl,\n        currentParams: state.matches[state.matches.length - 1].params,\n        nextUrl,\n        nextParams: matches[matches.length - 1].params,\n        ...submission,\n        actionResult,\n        actionStatus,\n        defaultShouldRevalidate: shouldSkipRevalidation\n          ? false\n          : isRevalidationRequired,\n      });\n    }\n\n    if (shouldRevalidate) {\n      revalidatingFetchers.push({\n        key,\n        routeId: f.routeId,\n        path: f.path,\n        matches: fetcherMatches,\n        match: fetcherMatch,\n        controller: new AbortController(),\n      });\n    }\n  });\n\n  return [navigationMatches, revalidatingFetchers];\n}\n\nfunction shouldLoadRouteOnHydration(\n  route: AgnosticDataRouteObject,\n  loaderData: RouteData | null | undefined,\n  errors: RouteData | null | undefined\n) {\n  // We dunno if we have a loader - gotta find out!\n  if (route.lazy) {\n    return true;\n  }\n\n  // No loader, nothing to initialize\n  if (!route.loader) {\n    return false;\n  }\n\n  let hasData = loaderData != null && loaderData[route.id] !== undefined;\n  let hasError = errors != null && errors[route.id] !== undefined;\n\n  // Don't run if we error'd during SSR\n  if (!hasData && hasError) {\n    return false;\n  }\n\n  // Explicitly opting-in to running on hydration\n  if (typeof route.loader === \"function\" && route.loader.hydrate === true) {\n    return true;\n  }\n\n  // Otherwise, run if we're not yet initialized with anything\n  return !hasData && !hasError;\n}\n\nfunction isNewLoader(\n  currentLoaderData: RouteData,\n  currentMatch: AgnosticDataRouteMatch,\n  match: AgnosticDataRouteMatch\n) {\n  let isNew =\n    // [a] -> [a, b]\n    !currentMatch ||\n    // [a, b] -> [a, c]\n    match.route.id !== currentMatch.route.id;\n\n  // Handle the case that we don't have data for a re-used route, potentially\n  // from a prior error or from a cancelled pending deferred\n  let isMissingData = currentLoaderData[match.route.id] === undefined;\n\n  // Always load if this is a net-new route or we don't yet have data\n  return isNew || isMissingData;\n}\n\nfunction isNewRouteInstance(\n  currentMatch: AgnosticDataRouteMatch,\n  match: AgnosticDataRouteMatch\n) {\n  let currentPath = currentMatch.route.path;\n  return (\n    // param change for this match, /users/123 -> /users/456\n    currentMatch.pathname !== match.pathname ||\n    // splat param changed, which is not present in match.path\n    // e.g. /files/images/avatar.jpg -> files/finances.xls\n    (currentPath != null &&\n      currentPath.endsWith(\"*\") &&\n      currentMatch.params[\"*\"] !== match.params[\"*\"])\n  );\n}\n\nfunction shouldRevalidateLoader(\n  loaderMatch: AgnosticDataRouteMatch,\n  arg: ShouldRevalidateFunctionArgs\n) {\n  if (loaderMatch.route.shouldRevalidate) {\n    let routeChoice = loaderMatch.route.shouldRevalidate(arg);\n    if (typeof routeChoice === \"boolean\") {\n      return routeChoice;\n    }\n  }\n\n  return arg.defaultShouldRevalidate;\n}\n\nfunction patchRoutesImpl(\n  routeId: string | null,\n  children: AgnosticRouteObject[],\n  routesToUse: AgnosticDataRouteObject[],\n  manifest: RouteManifest,\n  mapRouteProperties: MapRoutePropertiesFunction\n) {\n  let childrenToPatch: AgnosticDataRouteObject[];\n  if (routeId) {\n    let route = manifest[routeId];\n    invariant(\n      route,\n      `No route found to patch children into: routeId = ${routeId}`\n    );\n    if (!route.children) {\n      route.children = [];\n    }\n    childrenToPatch = route.children;\n  } else {\n    childrenToPatch = routesToUse;\n  }\n\n  // Don't patch in routes we already know about so that `patch` is idempotent\n  // to simplify user-land code. This is useful because we re-call the\n  // `patchRoutesOnNavigation` function for matched routes with params.\n  let uniqueChildren = children.filter(\n    (newRoute) =>\n      !childrenToPatch.some((existingRoute) =>\n        isSameRoute(newRoute, existingRoute)\n      )\n  );\n\n  let newRoutes = convertRoutesToDataRoutes(\n    uniqueChildren,\n    mapRouteProperties,\n    [routeId || \"_\", \"patch\", String(childrenToPatch?.length || \"0\")],\n    manifest\n  );\n\n  childrenToPatch.push(...newRoutes);\n}\n\nfunction isSameRoute(\n  newRoute: AgnosticRouteObject,\n  existingRoute: AgnosticRouteObject\n): boolean {\n  // Most optimal check is by id\n  if (\n    \"id\" in newRoute &&\n    \"id\" in existingRoute &&\n    newRoute.id === existingRoute.id\n  ) {\n    return true;\n  }\n\n  // Second is by pathing differences\n  if (\n    !(\n      newRoute.index === existingRoute.index &&\n      newRoute.path === existingRoute.path &&\n      newRoute.caseSensitive === existingRoute.caseSensitive\n    )\n  ) {\n    return false;\n  }\n\n  // Pathless layout routes are trickier since we need to check children.\n  // If they have no children then they're the same as far as we can tell\n  if (\n    (!newRoute.children || newRoute.children.length === 0) &&\n    (!existingRoute.children || existingRoute.children.length === 0)\n  ) {\n    return true;\n  }\n\n  // Otherwise, we look to see if every child in the new route is already\n  // represented in the existing route's children\n  return newRoute.children!.every((aChild, i) =>\n    existingRoute.children?.some((bChild) => isSameRoute(aChild, bChild))\n  );\n}\n\n/**\n * Execute route.lazy() methods to lazily load route modules (loader, action,\n * shouldRevalidate) and update the routeManifest in place which shares objects\n * with dataRoutes so those get updated as well.\n */\nasync function loadLazyRouteModule(\n  route: AgnosticDataRouteObject,\n  mapRouteProperties: MapRoutePropertiesFunction,\n  manifest: RouteManifest\n) {\n  if (!route.lazy) {\n    return;\n  }\n\n  let lazyRoute = await route.lazy();\n\n  // If the lazy route function was executed and removed by another parallel\n  // call then we can return - first lazy() to finish wins because the return\n  // value of lazy is expected to be static\n  if (!route.lazy) {\n    return;\n  }\n\n  let routeToUpdate = manifest[route.id];\n  invariant(routeToUpdate, \"No route found in manifest\");\n\n  // Update the route in place.  This should be safe because there's no way\n  // we could yet be sitting on this route as we can't get there without\n  // resolving lazy() first.\n  //\n  // This is different than the HMR \"update\" use-case where we may actively be\n  // on the route being updated.  The main concern boils down to \"does this\n  // mutation affect any ongoing navigations or any current state.matches\n  // values?\".  If not, it should be safe to update in place.\n  let routeUpdates: Record<string, any> = {};\n  for (let lazyRouteProperty in lazyRoute) {\n    let staticRouteValue =\n      routeToUpdate[lazyRouteProperty as keyof typeof routeToUpdate];\n\n    let isPropertyStaticallyDefined =\n      staticRouteValue !== undefined &&\n      // This property isn't static since it should always be updated based\n      // on the route updates\n      lazyRouteProperty !== \"hasErrorBoundary\";\n\n    warning(\n      !isPropertyStaticallyDefined,\n      `Route \"${routeToUpdate.id}\" has a static property \"${lazyRouteProperty}\" ` +\n        `defined but its lazy function is also returning a value for this property. ` +\n        `The lazy route property \"${lazyRouteProperty}\" will be ignored.`\n    );\n\n    if (\n      !isPropertyStaticallyDefined &&\n      !immutableRouteKeys.has(lazyRouteProperty as ImmutableRouteKey)\n    ) {\n      routeUpdates[lazyRouteProperty] =\n        lazyRoute[lazyRouteProperty as keyof typeof lazyRoute];\n    }\n  }\n\n  // Mutate the route with the provided updates.  Do this first so we pass\n  // the updated version to mapRouteProperties\n  Object.assign(routeToUpdate, routeUpdates);\n\n  // Mutate the `hasErrorBoundary` property on the route based on the route\n  // updates and remove the `lazy` function so we don't resolve the lazy\n  // route again.\n  Object.assign(routeToUpdate, {\n    // To keep things framework agnostic, we use the provided\n    // `mapRouteProperties` (or wrapped `detectErrorBoundary`) function to\n    // set the framework-aware properties (`element`/`hasErrorBoundary`) since\n    // the logic will differ between frameworks.\n    ...mapRouteProperties(routeToUpdate),\n    lazy: undefined,\n  });\n}\n\n// Default implementation of `dataStrategy` which fetches all loaders in parallel\nasync function defaultDataStrategy({\n  matches,\n}: DataStrategyFunctionArgs): ReturnType<DataStrategyFunction> {\n  let matchesToLoad = matches.filter((m) => m.shouldLoad);\n  let results = await Promise.all(matchesToLoad.map((m) => m.resolve()));\n  return results.reduce(\n    (acc, result, i) =>\n      Object.assign(acc, { [matchesToLoad[i].route.id]: result }),\n    {}\n  );\n}\n\nasync function callDataStrategyImpl(\n  dataStrategyImpl: DataStrategyFunction,\n  type: \"loader\" | \"action\",\n  state: RouterState | null,\n  request: Request,\n  matchesToLoad: AgnosticDataRouteMatch[],\n  matches: AgnosticDataRouteMatch[],\n  fetcherKey: string | null,\n  manifest: RouteManifest,\n  mapRouteProperties: MapRoutePropertiesFunction,\n  requestContext?: unknown\n): Promise<Record<string, DataStrategyResult>> {\n  let loadRouteDefinitionsPromises = matches.map((m) =>\n    m.route.lazy\n      ? loadLazyRouteModule(m.route, mapRouteProperties, manifest)\n      : undefined\n  );\n\n  let dsMatches = matches.map((match, i) => {\n    let loadRoutePromise = loadRouteDefinitionsPromises[i];\n    let shouldLoad = matchesToLoad.some((m) => m.route.id === match.route.id);\n    // `resolve` encapsulates route.lazy(), executing the loader/action,\n    // and mapping return values/thrown errors to a `DataStrategyResult`.  Users\n    // can pass a callback to take fine-grained control over the execution\n    // of the loader/action\n    let resolve: DataStrategyMatch[\"resolve\"] = async (handlerOverride) => {\n      if (\n        handlerOverride &&\n        request.method === \"GET\" &&\n        (match.route.lazy || match.route.loader)\n      ) {\n        shouldLoad = true;\n      }\n      return shouldLoad\n        ? callLoaderOrAction(\n            type,\n            request,\n            match,\n            loadRoutePromise,\n            handlerOverride,\n            requestContext\n          )\n        : Promise.resolve({ type: ResultType.data, result: undefined });\n    };\n\n    return {\n      ...match,\n      shouldLoad,\n      resolve,\n    };\n  });\n\n  // Send all matches here to allow for a middleware-type implementation.\n  // handler will be a no-op for unneeded routes and we filter those results\n  // back out below.\n  let results = await dataStrategyImpl({\n    matches: dsMatches,\n    request,\n    params: matches[0].params,\n    fetcherKey,\n    context: requestContext,\n  });\n\n  // Wait for all routes to load here but 'swallow the error since we want\n  // it to bubble up from the `await loadRoutePromise` in `callLoaderOrAction` -\n  // called from `match.resolve()`\n  try {\n    await Promise.all(loadRouteDefinitionsPromises);\n  } catch (e) {\n    // No-op\n  }\n\n  return results;\n}\n\n// Default logic for calling a loader/action is the user has no specified a dataStrategy\nasync function callLoaderOrAction(\n  type: \"loader\" | \"action\",\n  request: Request,\n  match: AgnosticDataRouteMatch,\n  loadRoutePromise: Promise<void> | undefined,\n  handlerOverride: Parameters<DataStrategyMatch[\"resolve\"]>[0],\n  staticContext?: unknown\n): Promise<DataStrategyResult> {\n  let result: DataStrategyResult;\n  let onReject: (() => void) | undefined;\n\n  let runHandler = (\n    handler: AgnosticRouteObject[\"loader\"] | AgnosticRouteObject[\"action\"]\n  ): Promise<DataStrategyResult> => {\n    // Setup a promise we can race against so that abort signals short circuit\n    let reject: () => void;\n    // This will never resolve so safe to type it as Promise<DataStrategyResult> to\n    // satisfy the function return value\n    let abortPromise = new Promise<DataStrategyResult>((_, r) => (reject = r));\n    onReject = () => reject();\n    request.signal.addEventListener(\"abort\", onReject);\n\n    let actualHandler = (ctx?: unknown) => {\n      if (typeof handler !== \"function\") {\n        return Promise.reject(\n          new Error(\n            `You cannot call the handler for a route which defines a boolean ` +\n              `\"${type}\" [routeId: ${match.route.id}]`\n          )\n        );\n      }\n      return handler(\n        {\n          request,\n          params: match.params,\n          context: staticContext,\n        },\n        ...(ctx !== undefined ? [ctx] : [])\n      );\n    };\n\n    let handlerPromise: Promise<DataStrategyResult> = (async () => {\n      try {\n        let val = await (handlerOverride\n          ? handlerOverride((ctx: unknown) => actualHandler(ctx))\n          : actualHandler());\n        return { type: \"data\", result: val };\n      } catch (e) {\n        return { type: \"error\", result: e };\n      }\n    })();\n\n    return Promise.race([handlerPromise, abortPromise]);\n  };\n\n  try {\n    let handler = match.route[type];\n\n    // If we have a route.lazy promise, await that first\n    if (loadRoutePromise) {\n      if (handler) {\n        // Run statically defined handler in parallel with lazy()\n        let handlerError;\n        let [value] = await Promise.all([\n          // If the handler throws, don't let it immediately bubble out,\n          // since we need to let the lazy() execution finish so we know if this\n          // route has a boundary that can handle the error\n          runHandler(handler).catch((e) => {\n            handlerError = e;\n          }),\n          loadRoutePromise,\n        ]);\n        if (handlerError !== undefined) {\n          throw handlerError;\n        }\n        result = value!;\n      } else {\n        // Load lazy route module, then run any returned handler\n        await loadRoutePromise;\n\n        handler = match.route[type];\n        if (handler) {\n          // Handler still runs even if we got interrupted to maintain consistency\n          // with un-abortable behavior of handler execution on non-lazy or\n          // previously-lazy-loaded routes\n          result = await runHandler(handler);\n        } else if (type === \"action\") {\n          let url = new URL(request.url);\n          let pathname = url.pathname + url.search;\n          throw getInternalRouterError(405, {\n            method: request.method,\n            pathname,\n            routeId: match.route.id,\n          });\n        } else {\n          // lazy() route has no loader to run.  Short circuit here so we don't\n          // hit the invariant below that errors on returning undefined.\n          return { type: ResultType.data, result: undefined };\n        }\n      }\n    } else if (!handler) {\n      let url = new URL(request.url);\n      let pathname = url.pathname + url.search;\n      throw getInternalRouterError(404, {\n        pathname,\n      });\n    } else {\n      result = await runHandler(handler);\n    }\n\n    invariant(\n      result.result !== undefined,\n      `You defined ${type === \"action\" ? \"an action\" : \"a loader\"} for route ` +\n        `\"${match.route.id}\" but didn't return anything from your \\`${type}\\` ` +\n        `function. Please return a value or \\`null\\`.`\n    );\n  } catch (e) {\n    // We should already be catching and converting normal handler executions to\n    // DataStrategyResults and returning them, so anything that throws here is an\n    // unexpected error we still need to wrap\n    return { type: ResultType.error, result: e };\n  } finally {\n    if (onReject) {\n      request.signal.removeEventListener(\"abort\", onReject);\n    }\n  }\n\n  return result;\n}\n\nasync function convertDataStrategyResultToDataResult(\n  dataStrategyResult: DataStrategyResult\n): Promise<DataResult> {\n  let { result, type } = dataStrategyResult;\n\n  if (isResponse(result)) {\n    let data: any;\n\n    try {\n      let contentType = result.headers.get(\"Content-Type\");\n      // Check between word boundaries instead of startsWith() due to the last\n      // paragraph of https://httpwg.org/specs/rfc9110.html#field.content-type\n      if (contentType && /\\bapplication\\/json\\b/.test(contentType)) {\n        if (result.body == null) {\n          data = null;\n        } else {\n          data = await result.json();\n        }\n      } else {\n        data = await result.text();\n      }\n    } catch (e) {\n      return { type: ResultType.error, error: e };\n    }\n\n    if (type === ResultType.error) {\n      return {\n        type: ResultType.error,\n        error: new ErrorResponseImpl(result.status, result.statusText, data),\n        statusCode: result.status,\n        headers: result.headers,\n      };\n    }\n\n    return {\n      type: ResultType.data,\n      data,\n      statusCode: result.status,\n      headers: result.headers,\n    };\n  }\n\n  if (type === ResultType.error) {\n    if (isDataWithResponseInit(result)) {\n      if (result.data instanceof Error) {\n        return {\n          type: ResultType.error,\n          error: result.data,\n          statusCode: result.init?.status,\n          headers: result.init?.headers\n            ? new Headers(result.init.headers)\n            : undefined,\n        };\n      }\n\n      // Convert thrown data() to ErrorResponse instances\n      return {\n        type: ResultType.error,\n        error: new ErrorResponseImpl(\n          result.init?.status || 500,\n          undefined,\n          result.data\n        ),\n        statusCode: isRouteErrorResponse(result) ? result.status : undefined,\n        headers: result.init?.headers\n          ? new Headers(result.init.headers)\n          : undefined,\n      };\n    }\n    return {\n      type: ResultType.error,\n      error: result,\n      statusCode: isRouteErrorResponse(result) ? result.status : undefined,\n    };\n  }\n\n  if (isDeferredData(result)) {\n    return {\n      type: ResultType.deferred,\n      deferredData: result,\n      statusCode: result.init?.status,\n      headers: result.init?.headers && new Headers(result.init.headers),\n    };\n  }\n\n  if (isDataWithResponseInit(result)) {\n    return {\n      type: ResultType.data,\n      data: result.data,\n      statusCode: result.init?.status,\n      headers: result.init?.headers\n        ? new Headers(result.init.headers)\n        : undefined,\n    };\n  }\n\n  return { type: ResultType.data, data: result };\n}\n\n// Support relative routing in internal redirects\nfunction normalizeRelativeRoutingRedirectResponse(\n  response: Response,\n  request: Request,\n  routeId: string,\n  matches: AgnosticDataRouteMatch[],\n  basename: string,\n  v7_relativeSplatPath: boolean\n) {\n  let location = response.headers.get(\"Location\");\n  invariant(\n    location,\n    \"Redirects returned/thrown from loaders/actions must have a Location header\"\n  );\n\n  if (!ABSOLUTE_URL_REGEX.test(location)) {\n    let trimmedMatches = matches.slice(\n      0,\n      matches.findIndex((m) => m.route.id === routeId) + 1\n    );\n    location = normalizeTo(\n      new URL(request.url),\n      trimmedMatches,\n      basename,\n      true,\n      location,\n      v7_relativeSplatPath\n    );\n    response.headers.set(\"Location\", location);\n  }\n\n  return response;\n}\n\nfunction normalizeRedirectLocation(\n  location: string,\n  currentUrl: URL,\n  basename: string,\n  historyInstance: History,\n): string {\n  // Match Chrome's behavior:\n  // https://github.com/chromium/chromium/blob/216dbeb61db0c667e62082e5f5400a32d6983df3/content/public/common/url_utils.cc#L82\n  let invalidProtocols = [\n    \"about:\",\n    \"blob:\",\n    \"chrome:\",\n    \"chrome-untrusted:\",\n    \"content:\",\n    \"data:\",\n    \"devtools:\",\n    \"file:\",\n    \"filesystem:\",\n    // eslint-disable-next-line no-script-url\n    \"javascript:\",\n  ];\n\n  if (ABSOLUTE_URL_REGEX.test(location)) {\n    // Strip off the protocol+origin for same-origin + same-basename absolute redirects\n    let normalizedLocation = location;\n    let url = normalizedLocation.startsWith(\"//\")\n      ? new URL(currentUrl.protocol + normalizedLocation)\n      : new URL(normalizedLocation);\n    if (invalidProtocols.includes(url.protocol)) {\n      throw new Error(\"Invalid redirect location\");\n    }\n    let isSameBasename = stripBasename(url.pathname, basename) != null;\n    if (url.origin === currentUrl.origin && isSameBasename) {\n      return url.pathname + url.search + url.hash;\n    }\n  }\n\n  try {\n    let url = historyInstance.createURL(location);\n    if (invalidProtocols.includes(url.protocol)) {\n      throw new Error(\"Invalid redirect location\");\n    }\n  } catch (e) {}\n\n  return location;\n}\n\n// Utility method for creating the Request instances for loaders/actions during\n// client-side navigations and fetches.  During SSR we will always have a\n// Request instance from the static handler (query/queryRoute)\nfunction createClientSideRequest(\n  history: History,\n  location: string | Location,\n  signal: AbortSignal,\n  submission?: Submission\n): Request {\n  let url = history.createURL(stripHashFromPath(location)).toString();\n  let init: RequestInit = { signal };\n\n  if (submission && isMutationMethod(submission.formMethod)) {\n    let { formMethod, formEncType } = submission;\n    // Didn't think we needed this but it turns out unlike other methods, patch\n    // won't be properly normalized to uppercase and results in a 405 error.\n    // See: https://fetch.spec.whatwg.org/#concept-method\n    init.method = formMethod.toUpperCase();\n\n    if (formEncType === \"application/json\") {\n      init.headers = new Headers({ \"Content-Type\": formEncType });\n      init.body = JSON.stringify(submission.json);\n    } else if (formEncType === \"text/plain\") {\n      // Content-Type is inferred (https://fetch.spec.whatwg.org/#dom-request)\n      init.body = submission.text;\n    } else if (\n      formEncType === \"application/x-www-form-urlencoded\" &&\n      submission.formData\n    ) {\n      // Content-Type is inferred (https://fetch.spec.whatwg.org/#dom-request)\n      init.body = convertFormDataToSearchParams(submission.formData);\n    } else {\n      // Content-Type is inferred (https://fetch.spec.whatwg.org/#dom-request)\n      init.body = submission.formData;\n    }\n  }\n\n  return new Request(url, init);\n}\n\nfunction convertFormDataToSearchParams(formData: FormData): URLSearchParams {\n  let searchParams = new URLSearchParams();\n\n  for (let [key, value] of formData.entries()) {\n    // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#converting-an-entry-list-to-a-list-of-name-value-pairs\n    searchParams.append(key, typeof value === \"string\" ? value : value.name);\n  }\n\n  return searchParams;\n}\n\nfunction convertSearchParamsToFormData(\n  searchParams: URLSearchParams\n): FormData {\n  let formData = new FormData();\n  for (let [key, value] of searchParams.entries()) {\n    formData.append(key, value);\n  }\n  return formData;\n}\n\nfunction processRouteLoaderData(\n  matches: AgnosticDataRouteMatch[],\n  results: Record<string, DataResult>,\n  pendingActionResult: PendingActionResult | undefined,\n  activeDeferreds: Map<string, DeferredData>,\n  skipLoaderErrorBubbling: boolean\n): {\n  loaderData: RouterState[\"loaderData\"];\n  errors: RouterState[\"errors\"] | null;\n  statusCode: number;\n  loaderHeaders: Record<string, Headers>;\n} {\n  // Fill in loaderData/errors from our loaders\n  let loaderData: RouterState[\"loaderData\"] = {};\n  let errors: RouterState[\"errors\"] | null = null;\n  let statusCode: number | undefined;\n  let foundError = false;\n  let loaderHeaders: Record<string, Headers> = {};\n  let pendingError =\n    pendingActionResult && isErrorResult(pendingActionResult[1])\n      ? pendingActionResult[1].error\n      : undefined;\n\n  // Process loader results into state.loaderData/state.errors\n  matches.forEach((match) => {\n    if (!(match.route.id in results)) {\n      return;\n    }\n    let id = match.route.id;\n    let result = results[id];\n    invariant(\n      !isRedirectResult(result),\n      \"Cannot handle redirect results in processLoaderData\"\n    );\n    if (isErrorResult(result)) {\n      let error = result.error;\n      // If we have a pending action error, we report it at the highest-route\n      // that throws a loader error, and then clear it out to indicate that\n      // it was consumed\n      if (pendingError !== undefined) {\n        error = pendingError;\n        pendingError = undefined;\n      }\n\n      errors = errors || {};\n\n      if (skipLoaderErrorBubbling) {\n        errors[id] = error;\n      } else {\n        // Look upwards from the matched route for the closest ancestor error\n        // boundary, defaulting to the root match.  Prefer higher error values\n        // if lower errors bubble to the same boundary\n        let boundaryMatch = findNearestBoundary(matches, id);\n        if (errors[boundaryMatch.route.id] == null) {\n          errors[boundaryMatch.route.id] = error;\n        }\n      }\n\n      // Clear our any prior loaderData for the throwing route\n      loaderData[id] = undefined;\n\n      // Once we find our first (highest) error, we set the status code and\n      // prevent deeper status codes from overriding\n      if (!foundError) {\n        foundError = true;\n        statusCode = isRouteErrorResponse(result.error)\n          ? result.error.status\n          : 500;\n      }\n      if (result.headers) {\n        loaderHeaders[id] = result.headers;\n      }\n    } else {\n      if (isDeferredResult(result)) {\n        activeDeferreds.set(id, result.deferredData);\n        loaderData[id] = result.deferredData.data;\n        // Error status codes always override success status codes, but if all\n        // loaders are successful we take the deepest status code.\n        if (\n          result.statusCode != null &&\n          result.statusCode !== 200 &&\n          !foundError\n        ) {\n          statusCode = result.statusCode;\n        }\n        if (result.headers) {\n          loaderHeaders[id] = result.headers;\n        }\n      } else {\n        loaderData[id] = result.data;\n        // Error status codes always override success status codes, but if all\n        // loaders are successful we take the deepest status code.\n        if (result.statusCode && result.statusCode !== 200 && !foundError) {\n          statusCode = result.statusCode;\n        }\n        if (result.headers) {\n          loaderHeaders[id] = result.headers;\n        }\n      }\n    }\n  });\n\n  // If we didn't consume the pending action error (i.e., all loaders\n  // resolved), then consume it here.  Also clear out any loaderData for the\n  // throwing route\n  if (pendingError !== undefined && pendingActionResult) {\n    errors = { [pendingActionResult[0]]: pendingError };\n    loaderData[pendingActionResult[0]] = undefined;\n  }\n\n  return {\n    loaderData,\n    errors,\n    statusCode: statusCode || 200,\n    loaderHeaders,\n  };\n}\n\nfunction processLoaderData(\n  state: RouterState,\n  matches: AgnosticDataRouteMatch[],\n  results: Record<string, DataResult>,\n  pendingActionResult: PendingActionResult | undefined,\n  revalidatingFetchers: RevalidatingFetcher[],\n  fetcherResults: Record<string, DataResult>,\n  activeDeferreds: Map<string, DeferredData>\n): {\n  loaderData: RouterState[\"loaderData\"];\n  errors?: RouterState[\"errors\"];\n} {\n  let { loaderData, errors } = processRouteLoaderData(\n    matches,\n    results,\n    pendingActionResult,\n    activeDeferreds,\n    false // This method is only called client side so we always want to bubble\n  );\n\n  // Process results from our revalidating fetchers\n  revalidatingFetchers.forEach((rf) => {\n    let { key, match, controller } = rf;\n    let result = fetcherResults[key];\n    invariant(result, \"Did not find corresponding fetcher result\");\n\n    // Process fetcher non-redirect errors\n    if (controller && controller.signal.aborted) {\n      // Nothing to do for aborted fetchers\n      return;\n    } else if (isErrorResult(result)) {\n      let boundaryMatch = findNearestBoundary(state.matches, match?.route.id);\n      if (!(errors && errors[boundaryMatch.route.id])) {\n        errors = {\n          ...errors,\n          [boundaryMatch.route.id]: result.error,\n        };\n      }\n      state.fetchers.delete(key);\n    } else if (isRedirectResult(result)) {\n      // Should never get here, redirects should get processed above, but we\n      // keep this to type narrow to a success result in the else\n      invariant(false, \"Unhandled fetcher revalidation redirect\");\n    } else if (isDeferredResult(result)) {\n      // Should never get here, deferred data should be awaited for fetchers\n      // in resolveDeferredResults\n      invariant(false, \"Unhandled fetcher deferred data\");\n    } else {\n      let doneFetcher = getDoneFetcher(result.data);\n      state.fetchers.set(key, doneFetcher);\n    }\n  });\n\n  return { loaderData, errors };\n}\n\nfunction mergeLoaderData(\n  loaderData: RouteData,\n  newLoaderData: RouteData,\n  matches: AgnosticDataRouteMatch[],\n  errors: RouteData | null | undefined\n): RouteData {\n  let mergedLoaderData = { ...newLoaderData };\n  for (let match of matches) {\n    let id = match.route.id;\n    if (newLoaderData.hasOwnProperty(id)) {\n      if (newLoaderData[id] !== undefined) {\n        mergedLoaderData[id] = newLoaderData[id];\n      } else {\n        // No-op - this is so we ignore existing data if we have a key in the\n        // incoming object with an undefined value, which is how we unset a prior\n        // loaderData if we encounter a loader error\n      }\n    } else if (loaderData[id] !== undefined && match.route.loader) {\n      // Preserve existing keys not included in newLoaderData and where a loader\n      // wasn't removed by HMR\n      mergedLoaderData[id] = loaderData[id];\n    }\n\n    if (errors && errors.hasOwnProperty(id)) {\n      // Don't keep any loader data below the boundary\n      break;\n    }\n  }\n  return mergedLoaderData;\n}\n\nfunction getActionDataForCommit(\n  pendingActionResult: PendingActionResult | undefined\n) {\n  if (!pendingActionResult) {\n    return {};\n  }\n  return isErrorResult(pendingActionResult[1])\n    ? {\n        // Clear out prior actionData on errors\n        actionData: {},\n      }\n    : {\n        actionData: {\n          [pendingActionResult[0]]: pendingActionResult[1].data,\n        },\n      };\n}\n\n// Find the nearest error boundary, looking upwards from the leaf route (or the\n// route specified by routeId) for the closest ancestor error boundary,\n// defaulting to the root match\nfunction findNearestBoundary(\n  matches: AgnosticDataRouteMatch[],\n  routeId?: string\n): AgnosticDataRouteMatch {\n  let eligibleMatches = routeId\n    ? matches.slice(0, matches.findIndex((m) => m.route.id === routeId) + 1)\n    : [...matches];\n  return (\n    eligibleMatches.reverse().find((m) => m.route.hasErrorBoundary === true) ||\n    matches[0]\n  );\n}\n\nfunction getShortCircuitMatches(routes: AgnosticDataRouteObject[]): {\n  matches: AgnosticDataRouteMatch[];\n  route: AgnosticDataRouteObject;\n} {\n  // Prefer a root layout route if present, otherwise shim in a route object\n  let route =\n    routes.length === 1\n      ? routes[0]\n      : routes.find((r) => r.index || !r.path || r.path === \"/\") || {\n          id: `__shim-error-route__`,\n        };\n\n  return {\n    matches: [\n      {\n        params: {},\n        pathname: \"\",\n        pathnameBase: \"\",\n        route,\n      },\n    ],\n    route,\n  };\n}\n\nfunction getInternalRouterError(\n  status: number,\n  {\n    pathname,\n    routeId,\n    method,\n    type,\n    message,\n  }: {\n    pathname?: string;\n    routeId?: string;\n    method?: string;\n    type?: \"defer-action\" | \"invalid-body\";\n    message?: string;\n  } = {}\n) {\n  let statusText = \"Unknown Server Error\";\n  let errorMessage = \"Unknown @remix-run/router error\";\n\n  if (status === 400) {\n    statusText = \"Bad Request\";\n    if (method && pathname && routeId) {\n      errorMessage =\n        `You made a ${method} request to \"${pathname}\" but ` +\n        `did not provide a \\`loader\\` for route \"${routeId}\", ` +\n        `so there is no way to handle the request.`;\n    } else if (type === \"defer-action\") {\n      errorMessage = \"defer() is not supported in actions\";\n    } else if (type === \"invalid-body\") {\n      errorMessage = \"Unable to encode submission body\";\n    }\n  } else if (status === 403) {\n    statusText = \"Forbidden\";\n    errorMessage = `Route \"${routeId}\" does not match URL \"${pathname}\"`;\n  } else if (status === 404) {\n    statusText = \"Not Found\";\n    errorMessage = `No route matches URL \"${pathname}\"`;\n  } else if (status === 405) {\n    statusText = \"Method Not Allowed\";\n    if (method && pathname && routeId) {\n      errorMessage =\n        `You made a ${method.toUpperCase()} request to \"${pathname}\" but ` +\n        `did not provide an \\`action\\` for route \"${routeId}\", ` +\n        `so there is no way to handle the request.`;\n    } else if (method) {\n      errorMessage = `Invalid request method \"${method.toUpperCase()}\"`;\n    }\n  }\n\n  return new ErrorResponseImpl(\n    status || 500,\n    statusText,\n    new Error(errorMessage),\n    true\n  );\n}\n\n// Find any returned redirect errors, starting from the lowest match\nfunction findRedirect(\n  results: Record<string, DataResult>\n): { key: string; result: RedirectResult } | undefined {\n  let entries = Object.entries(results);\n  for (let i = entries.length - 1; i >= 0; i--) {\n    let [key, result] = entries[i];\n    if (isRedirectResult(result)) {\n      return { key, result };\n    }\n  }\n}\n\nfunction stripHashFromPath(path: To) {\n  let parsedPath = typeof path === \"string\" ? parsePath(path) : path;\n  return createPath({ ...parsedPath, hash: \"\" });\n}\n\nfunction isHashChangeOnly(a: Location, b: Location): boolean {\n  if (a.pathname !== b.pathname || a.search !== b.search) {\n    return false;\n  }\n\n  if (a.hash === \"\") {\n    // /page -> /page#hash\n    return b.hash !== \"\";\n  } else if (a.hash === b.hash) {\n    // /page#hash -> /page#hash\n    return true;\n  } else if (b.hash !== \"\") {\n    // /page#hash -> /page#other\n    return true;\n  }\n\n  // If the hash is removed the browser will re-perform a request to the server\n  // /page#hash -> /page\n  return false;\n}\n\nfunction isPromise<T = unknown>(val: unknown): val is Promise<T> {\n  return typeof val === \"object\" && val != null && \"then\" in val;\n}\n\nfunction isDataStrategyResult(result: unknown): result is DataStrategyResult {\n  return (\n    result != null &&\n    typeof result === \"object\" &&\n    \"type\" in result &&\n    \"result\" in result &&\n    (result.type === ResultType.data || result.type === ResultType.error)\n  );\n}\n\nfunction isRedirectDataStrategyResultResult(result: DataStrategyResult) {\n  return (\n    isResponse(result.result) && redirectStatusCodes.has(result.result.status)\n  );\n}\n\nfunction isDeferredResult(result: DataResult): result is DeferredResult {\n  return result.type === ResultType.deferred;\n}\n\nfunction isErrorResult(result: DataResult): result is ErrorResult {\n  return result.type === ResultType.error;\n}\n\nfunction isRedirectResult(result?: DataResult): result is RedirectResult {\n  return (result && result.type) === ResultType.redirect;\n}\n\nexport function isDataWithResponseInit(\n  value: any\n): value is DataWithResponseInit<unknown> {\n  return (\n    typeof value === \"object\" &&\n    value != null &&\n    \"type\" in value &&\n    \"data\" in value &&\n    \"init\" in value &&\n    value.type === \"DataWithResponseInit\"\n  );\n}\n\nexport function isDeferredData(value: any): value is DeferredData {\n  let deferred: DeferredData = value;\n  return (\n    deferred &&\n    typeof deferred === \"object\" &&\n    typeof deferred.data === \"object\" &&\n    typeof deferred.subscribe === \"function\" &&\n    typeof deferred.cancel === \"function\" &&\n    typeof deferred.resolveData === \"function\"\n  );\n}\n\nfunction isResponse(value: any): value is Response {\n  return (\n    value != null &&\n    typeof value.status === \"number\" &&\n    typeof value.statusText === \"string\" &&\n    typeof value.headers === \"object\" &&\n    typeof value.body !== \"undefined\"\n  );\n}\n\nfunction isRedirectResponse(result: any): result is Response {\n  if (!isResponse(result)) {\n    return false;\n  }\n\n  let status = result.status;\n  let location = result.headers.get(\"Location\");\n  return status >= 300 && status <= 399 && location != null;\n}\n\nfunction isValidMethod(method: string): method is FormMethod | V7_FormMethod {\n  return validRequestMethods.has(method.toLowerCase() as FormMethod);\n}\n\nfunction isMutationMethod(\n  method: string\n): method is MutationFormMethod | V7_MutationFormMethod {\n  return validMutationMethods.has(method.toLowerCase() as MutationFormMethod);\n}\n\nasync function resolveNavigationDeferredResults(\n  matches: (AgnosticDataRouteMatch | null)[],\n  results: Record<string, DataResult>,\n  signal: AbortSignal,\n  currentMatches: AgnosticDataRouteMatch[],\n  currentLoaderData: RouteData\n) {\n  let entries = Object.entries(results);\n  for (let index = 0; index < entries.length; index++) {\n    let [routeId, result] = entries[index];\n    let match = matches.find((m) => m?.route.id === routeId);\n    // If we don't have a match, then we can have a deferred result to do\n    // anything with.  This is for revalidating fetchers where the route was\n    // removed during HMR\n    if (!match) {\n      continue;\n    }\n\n    let currentMatch = currentMatches.find(\n      (m) => m.route.id === match!.route.id\n    );\n    let isRevalidatingLoader =\n      currentMatch != null &&\n      !isNewRouteInstance(currentMatch, match) &&\n      (currentLoaderData && currentLoaderData[match.route.id]) !== undefined;\n\n    if (isDeferredResult(result) && isRevalidatingLoader) {\n      // Note: we do not have to touch activeDeferreds here since we race them\n      // against the signal in resolveDeferredData and they'll get aborted\n      // there if needed\n      await resolveDeferredData(result, signal, false).then((result) => {\n        if (result) {\n          results[routeId] = result;\n        }\n      });\n    }\n  }\n}\n\nasync function resolveFetcherDeferredResults(\n  matches: (AgnosticDataRouteMatch | null)[],\n  results: Record<string, DataResult>,\n  revalidatingFetchers: RevalidatingFetcher[]\n) {\n  for (let index = 0; index < revalidatingFetchers.length; index++) {\n    let { key, routeId, controller } = revalidatingFetchers[index];\n    let result = results[key];\n    let match = matches.find((m) => m?.route.id === routeId);\n    // If we don't have a match, then we can have a deferred result to do\n    // anything with.  This is for revalidating fetchers where the route was\n    // removed during HMR\n    if (!match) {\n      continue;\n    }\n\n    if (isDeferredResult(result)) {\n      // Note: we do not have to touch activeDeferreds here since we race them\n      // against the signal in resolveDeferredData and they'll get aborted\n      // there if needed\n      invariant(\n        controller,\n        \"Expected an AbortController for revalidating fetcher deferred result\"\n      );\n      await resolveDeferredData(result, controller.signal, true).then(\n        (result) => {\n          if (result) {\n            results[key] = result;\n          }\n        }\n      );\n    }\n  }\n}\n\nasync function resolveDeferredData(\n  result: DeferredResult,\n  signal: AbortSignal,\n  unwrap = false\n): Promise<SuccessResult | ErrorResult | undefined> {\n  let aborted = await result.deferredData.resolveData(signal);\n  if (aborted) {\n    return;\n  }\n\n  if (unwrap) {\n    try {\n      return {\n        type: ResultType.data,\n        data: result.deferredData.unwrappedData,\n      };\n    } catch (e) {\n      // Handle any TrackedPromise._error values encountered while unwrapping\n      return {\n        type: ResultType.error,\n        error: e,\n      };\n    }\n  }\n\n  return {\n    type: ResultType.data,\n    data: result.deferredData.data,\n  };\n}\n\nfunction hasNakedIndexQuery(search: string): boolean {\n  return new URLSearchParams(search).getAll(\"index\").some((v) => v === \"\");\n}\n\nfunction getTargetMatch(\n  matches: AgnosticDataRouteMatch[],\n  location: Location | string\n) {\n  let search =\n    typeof location === \"string\" ? parsePath(location).search : location.search;\n  if (\n    matches[matches.length - 1].route.index &&\n    hasNakedIndexQuery(search || \"\")\n  ) {\n    // Return the leaf index route when index is present\n    return matches[matches.length - 1];\n  }\n  // Otherwise grab the deepest \"path contributing\" match (ignoring index and\n  // pathless layout routes)\n  let pathMatches = getPathContributingMatches(matches);\n  return pathMatches[pathMatches.length - 1];\n}\n\nfunction getSubmissionFromNavigation(\n  navigation: Navigation\n): Submission | undefined {\n  let { formMethod, formAction, formEncType, text, formData, json } =\n    navigation;\n  if (!formMethod || !formAction || !formEncType) {\n    return;\n  }\n\n  if (text != null) {\n    return {\n      formMethod,\n      formAction,\n      formEncType,\n      formData: undefined,\n      json: undefined,\n      text,\n    };\n  } else if (formData != null) {\n    return {\n      formMethod,\n      formAction,\n      formEncType,\n      formData,\n      json: undefined,\n      text: undefined,\n    };\n  } else if (json !== undefined) {\n    return {\n      formMethod,\n      formAction,\n      formEncType,\n      formData: undefined,\n      json,\n      text: undefined,\n    };\n  }\n}\n\nfunction getLoadingNavigation(\n  location: Location,\n  submission?: Submission\n): NavigationStates[\"Loading\"] {\n  if (submission) {\n    let navigation: NavigationStates[\"Loading\"] = {\n      state: \"loading\",\n      location,\n      formMethod: submission.formMethod,\n      formAction: submission.formAction,\n      formEncType: submission.formEncType,\n      formData: submission.formData,\n      json: submission.json,\n      text: submission.text,\n    };\n    return navigation;\n  } else {\n    let navigation: NavigationStates[\"Loading\"] = {\n      state: \"loading\",\n      location,\n      formMethod: undefined,\n      formAction: undefined,\n      formEncType: undefined,\n      formData: undefined,\n      json: undefined,\n      text: undefined,\n    };\n    return navigation;\n  }\n}\n\nfunction getSubmittingNavigation(\n  location: Location,\n  submission: Submission\n): NavigationStates[\"Submitting\"] {\n  let navigation: NavigationStates[\"Submitting\"] = {\n    state: \"submitting\",\n    location,\n    formMethod: submission.formMethod,\n    formAction: submission.formAction,\n    formEncType: submission.formEncType,\n    formData: submission.formData,\n    json: submission.json,\n    text: submission.text,\n  };\n  return navigation;\n}\n\nfunction getLoadingFetcher(\n  submission?: Submission,\n  data?: Fetcher[\"data\"]\n): FetcherStates[\"Loading\"] {\n  if (submission) {\n    let fetcher: FetcherStates[\"Loading\"] = {\n      state: \"loading\",\n      formMethod: submission.formMethod,\n      formAction: submission.formAction,\n      formEncType: submission.formEncType,\n      formData: submission.formData,\n      json: submission.json,\n      text: submission.text,\n      data,\n    };\n    return fetcher;\n  } else {\n    let fetcher: FetcherStates[\"Loading\"] = {\n      state: \"loading\",\n      formMethod: undefined,\n      formAction: undefined,\n      formEncType: undefined,\n      formData: undefined,\n      json: undefined,\n      text: undefined,\n      data,\n    };\n    return fetcher;\n  }\n}\n\nfunction getSubmittingFetcher(\n  submission: Submission,\n  existingFetcher?: Fetcher\n): FetcherStates[\"Submitting\"] {\n  let fetcher: FetcherStates[\"Submitting\"] = {\n    state: \"submitting\",\n    formMethod: submission.formMethod,\n    formAction: submission.formAction,\n    formEncType: submission.formEncType,\n    formData: submission.formData,\n    json: submission.json,\n    text: submission.text,\n    data: existingFetcher ? existingFetcher.data : undefined,\n  };\n  return fetcher;\n}\n\nfunction getDoneFetcher(data: Fetcher[\"data\"]): FetcherStates[\"Idle\"] {\n  let fetcher: FetcherStates[\"Idle\"] = {\n    state: \"idle\",\n    formMethod: undefined,\n    formAction: undefined,\n    formEncType: undefined,\n    formData: undefined,\n    json: undefined,\n    text: undefined,\n    data,\n  };\n  return fetcher;\n}\n\nfunction restoreAppliedTransitions(\n  _window: Window,\n  transitions: Map<string, Set<string>>\n) {\n  try {\n    let sessionPositions = _window.sessionStorage.getItem(\n      TRANSITIONS_STORAGE_KEY\n    );\n    if (sessionPositions) {\n      let json = JSON.parse(sessionPositions);\n      for (let [k, v] of Object.entries(json || {})) {\n        if (v && Array.isArray(v)) {\n          transitions.set(k, new Set(v || []));\n        }\n      }\n    }\n  } catch (e) {\n    // no-op, use default empty object\n  }\n}\n\nfunction persistAppliedTransitions(\n  _window: Window,\n  transitions: Map<string, Set<string>>\n) {\n  if (transitions.size > 0) {\n    let json: Record<string, string[]> = {};\n    for (let [k, v] of transitions) {\n      json[k] = [...v];\n    }\n    try {\n      _window.sessionStorage.setItem(\n        TRANSITIONS_STORAGE_KEY,\n        JSON.stringify(json)\n      );\n    } catch (error) {\n      warning(\n        false,\n        `Failed to save applied view transitions in sessionStorage (${error}).`\n      );\n    }\n  }\n}\n//#endregion\n"],"names":["Action","PopStateEventType","createMemoryHistory","options","initialEntries","initialIndex","v5Compat","entries","map","entry","index","createMemoryLocation","state","undefined","clampIndex","length","action","Pop","listener","n","Math","min","max","getCurrentLocation","to","key","location","createLocation","pathname","warning","charAt","JSON","stringify","createHref","createPath","history","createURL","URL","encodeLocation","path","parsePath","search","hash","push","Push","nextLocation","splice","delta","replace","Replace","go","nextIndex","listen","fn","createBrowserHistory","createBrowserLocation","window","globalHistory","usr","createBrowserHref","getUrlBasedHistory","createHashHistory","createHashLocation","substr","startsWith","createHashHref","base","document","querySelector","href","getAttribute","url","hashIndex","indexOf","slice","validateHashLocation","invariant","value","message","Error","cond","console","warn","e","createKey","random","toString","getHistoryState","idx","current","_extends","_ref","parsedPath","searchIndex","getLocation","validateLocation","defaultView","getIndex","replaceState","handlePop","historyState","pushState","error","DOMException","name","assign","origin","addEventListener","removeEventListener","ResultType","immutableRouteKeys","Set","isIndexRoute","route","convertRoutesToDataRoutes","routes","mapRouteProperties","parentPath","manifest","treePath","String","id","join","children","indexRoute","pathOrLayoutRoute","matchRoutes","locationArg","basename","matchRoutesImpl","allowPartial","stripBasename","branches","flattenRoutes","rankRouteBranches","matches","i","decoded","decodePath","matchRouteBranch","convertRouteMatchToUiMatch","match","loaderData","params","data","handle","parentsMeta","flattenRoute","relativePath","meta","caseSensitive","childrenIndex","joinPaths","routesMeta","concat","score","computeScore","forEach","_route$path","includes","exploded","explodeOptionalSegments","segments","split","first","rest","isOptional","endsWith","required","restExploded","result","subpath","sort","a","b","compareIndexes","paramRe","dynamicSegmentValue","indexRouteValue","emptySegmentValue","staticSegmentValue","splatPenalty","isSplat","s","initialScore","some","filter","reduce","segment","test","siblings","every","branch","matchedParams","matchedPathname","end","remainingPathname","matchPath","Object","pathnameBase","normalizePathname","generatePath","originalPath","prefix","p","array","isLastSegment","star","keyMatch","optional","param","pattern","matcher","compiledParams","compilePath","captureGroups","memo","paramName","splatValue","regexpSource","_","RegExp","v","decodeURIComponent","toLowerCase","startIndex","nextChar","ABSOLUTE_URL_REGEX","isAbsoluteUrl","resolvePath","fromPathname","toPathname","oldPathname","resolvePathname","substring","normalizeSearch","normalizeHash","relativeSegments","pop","getInvalidPathError","char","field","dest","getPathContributingMatches","getResolveToMatches","v7_relativeSplatPath","pathMatches","resolveTo","toArg","routePathnames","locationPathname","isPathRelative","isEmptyPath","from","routePathnameIndex","toSegments","shift","hasExplicitTrailingSlash","hasCurrentTrailingSlash","getToPathname","paths","json","init","responseInit","status","headers","Headers","has","set","Response","DataWithResponseInit","constructor","type","AbortedDeferredError","DeferredData","pendingKeysSet","subscribers","deferredKeys","Array","isArray","reject","abortPromise","Promise","r","controller","AbortController","onAbort","unlistenAbortSignal","signal","acc","_ref2","trackPromise","done","add","promise","race","then","onSettle","catch","defineProperty","get","aborted","delete","undefinedError","emit","settledKey","subscriber","subscribe","cancel","abort","k","resolveData","resolve","size","unwrappedData","_ref3","unwrapTrackedPromise","pendingKeys","isTrackedPromise","_tracked","_error","_data","defer","redirect","redirectDocument","response","ErrorResponseImpl","statusText","internal","isRouteErrorResponse","validMutationMethodsArr","validMutationMethods","validRequestMethodsArr","validRequestMethods","redirectStatusCodes","redirectPreserveMethodStatusCodes","IDLE_NAVIGATION","formMethod","formAction","formEncType","formData","text","IDLE_FETCHER","IDLE_BLOCKER","proceed","reset","defaultMapRouteProperties","hasErrorBoundary","Boolean","TRANSITIONS_STORAGE_KEY","createRouter","routerWindow","isBrowser","createElement","isServer","detectErrorBoundary","dataRoutes","inFlightDataRoutes","dataStrategyImpl","dataStrategy","defaultDataStrategy","patchRoutesOnNavigationImpl","patchRoutesOnNavigation","future","v7_fetcherPersist","v7_normalizeFormMethod","v7_partialHydration","v7_prependBasename","v7_skipActionErrorRevalidation","unlistenHistory","savedScrollPositions","getScrollRestorationKey","getScrollPosition","initialScrollRestored","hydrationData","initialMatches","initialMatchesIsFOW","initialErrors","getInternalRouterError","getShortCircuitMatches","fogOfWar","checkFogOfWar","active","initialized","m","lazy","loader","errors","findIndex","shouldLoadRouteOnHydration","router","historyAction","navigation","restoreScrollPosition","preventScrollReset","revalidation","actionData","fetchers","Map","blockers","pendingAction","HistoryAction","pendingPreventScrollReset","pendingNavigationController","pendingViewTransitionEnabled","appliedViewTransitions","removePageHideEventListener","isUninterruptedRevalidation","isRevalidationRequired","cancelledDeferredRoutes","cancelledFetcherLoads","fetchControllers","incrementingLoadId","pendingNavigationLoadId","fetchReloadIds","fetchRedirectIds","fetchLoadMatches","activeFetchers","deletedFetchers","activeDeferreds","blockerFunctions","unblockBlockerHistoryUpdate","initialize","blockerKey","shouldBlockNavigation","currentLocation","nextHistoryUpdatePromise","updateBlocker","updateState","startNavigation","restoreAppliedTransitions","_saveAppliedTransitions","persistAppliedTransitions","initialHydration","dispose","clear","deleteFetcher","deleteBlocker","newState","opts","completedFetchers","deletedFetchersKeys","fetcher","viewTransitionOpts","flushSync","completeNavigation","_temp","_location$state","_location$state2","isActionReload","isMutationMethod","_isRedirect","keys","mergeLoaderData","priorPaths","toPaths","getSavedScrollPosition","navigate","normalizedPath","normalizeTo","fromRouteId","relative","submission","normalizeNavigateOptions","userReplace","pendingError","enableViewTransition","viewTransition","revalidate","interruptActiveLoads","startUninterruptedRevalidation","overrideNavigation","saveScrollPosition","routesToUse","loadingNavigation","isHashChangeOnly","notFoundMatches","handleNavigational404","request","createClientSideRequest","pendingActionResult","findNearestBoundary","actionResult","handleAction","shortCircuited","routeId","isErrorResult","getLoadingNavigation","updatedMatches","handleLoaders","fetcherSubmission","getActionDataForCommit","isFogOfWar","getSubmittingNavigation","discoverResult","discoverRoutes","boundaryId","partialMatches","actionMatch","getTargetMatch","method","results","callDataStrategy","isRedirectResult","normalizeRedirectLocation","startRedirectNavigation","isDeferredResult","boundaryMatch","activeSubmission","getSubmissionFromNavigation","shouldUpdateNavigationState","getUpdatedActionData","matchesToLoad","revalidatingFetchers","getMatchesToLoad","cancelActiveDeferreds","updatedFetchers","markFetchRedirectsDone","updates","getUpdatedRevalidatingFetchers","rf","abortFetcher","abortPendingFetchRevalidations","f","loaderResults","fetcherResults","callLoadersAndMaybeResolveData","findRedirect","processLoaderData","deferredData","didAbortFetchLoads","abortStaleFetchLoads","shouldUpdateFetchers","revalidatingFetcher","getLoadingFetcher","fetch","setFetcherError","handleFetcherAction","handleFetcherLoader","requestMatches","detectAndHandle405Error","existingFetcher","updateFetcherState","getSubmittingFetcher","abortController","fetchRequest","originatingLoadId","actionResults","getDoneFetcher","revalidationRequest","loadId","loadFetcher","staleKey","doneFetcher","resolveDeferredData","isNavigation","_temp2","redirectLocation","isDocumentReload","redirectHistoryAction","fetcherKey","dataResults","callDataStrategyImpl","isRedirectDataStrategyResultResult","normalizeRelativeRoutingRedirectResponse","convertDataStrategyResultToDataResult","fetchersToLoad","currentMatches","loaderResultsPromise","fetcherResultsPromise","all","resolveNavigationDeferredResults","resolveFetcherDeferredResults","getFetcher","deleteFetcherAndUpdateState","count","markFetchersDone","doneKeys","landedId","yeetedKeys","getBlocker","blocker","newBlocker","blockerFunction","predicate","cancelledRouteIds","dfd","enableScrollRestoration","positions","getPosition","getKey","y","getScrollKey","fogMatches","isNonHMR","localManifest","patch","patchRoutesImpl","newMatches","newPartialMatches","_internalSetRoutes","newRoutes","patchRoutes","_internalFetchControllers","_internalActiveDeferreds","UNSAFE_DEFERRED_SYMBOL","Symbol","createStaticHandler","v7_throwAbortReason","query","_temp3","requestContext","skipLoaderErrorBubbling","isValidMethod","methodNotAllowedMatches","statusCode","loaderHeaders","actionHeaders","queryImpl","isResponse","queryRoute","_temp4","find","values","_result$activeDeferre","routeMatch","submit","loadRouteData","isDataStrategyResult","isRedirectResponse","isRouteRequest","throwStaticHandlerAbortedError","Location","loaderRequest","Request","context","getLoaderMatchesUntilBoundary","processRouteLoaderData","executedLoaders","fromEntries","getStaticContextFromError","newContext","_deepestRenderedBoundaryId","reason","isSubmissionNavigation","body","prependBasename","contextualMatches","activeRouteMatch","nakedIndex","hasNakedIndexQuery","URLSearchParams","indexValues","getAll","append","qs","normalizeFormMethod","isFetcher","getInvalidBodyError","rawFormMethod","toUpperCase","stripHashFromPath","FormData","parse","searchParams","convertFormDataToSearchParams","convertSearchParamsToFormData","includeBoundary","skipActionErrorRevalidation","currentUrl","nextUrl","boundaryMatches","actionStatus","shouldSkipRevalidation","navigationMatches","isNewLoader","currentRouteMatch","nextRouteMatch","shouldRevalidateLoader","currentParams","nextParams","defaultShouldRevalidate","isNewRouteInstance","fetcherMatches","fetcherMatch","shouldRevalidate","hasData","hasError","hydrate","currentLoaderData","currentMatch","isNew","isMissingData","currentPath","loaderMatch","arg","routeChoice","_childrenToPatch","childrenToPatch","uniqueChildren","newRoute","existingRoute","isSameRoute","aChild","_existingRoute$childr","bChild","loadLazyRouteModule","lazyRoute","routeToUpdate","routeUpdates","lazyRouteProperty","staticRouteValue","isPropertyStaticallyDefined","_ref4","shouldLoad","loadRouteDefinitionsPromises","dsMatches","loadRoutePromise","handlerOverride","callLoaderOrAction","staticContext","onReject","runHandler","handler","actualHandler","ctx","handlerPromise","val","handlerError","dataStrategyResult","contentType","isDataWithResponseInit","_result$init3","_result$init4","_result$init","_result$init2","isDeferredData","_result$init5","_result$init6","deferred","_result$init7","_result$init8","trimmedMatches","historyInstance","invalidProtocols","normalizedLocation","protocol","isSameBasename","foundError","newLoaderData","mergedLoaderData","hasOwnProperty","eligibleMatches","reverse","_temp5","errorMessage","isRevalidatingLoader","unwrap","_window","transitions","sessionPositions","sessionStorage","getItem","setItem"],"mappings":"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"}
Index: frontend/node_modules/@remix-run/router/dist/router.umd.min.js
===================================================================
--- frontend/node_modules/@remix-run/router/dist/router.umd.min.js	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/@remix-run/router/dist/router.umd.min.js	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,12 @@
+/**
+ * @remix-run/router v1.23.2
+ *
+ * Copyright (c) Remix Software Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE.md file in the root directory of this source tree.
+ *
+ * @license MIT
+ */
+!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?t(exports):"function"==typeof define&&define.amd?define(["exports"],t):t((e="undefined"!=typeof globalThis?globalThis:e||self).RemixRouter={})}(this,(function(e){"use strict";function t(){return t=Object.assign?Object.assign.bind():function(e){for(var t=1;t<arguments.length;t++){var r=arguments[t];for(var a in r)Object.prototype.hasOwnProperty.call(r,a)&&(e[a]=r[a])}return e},t.apply(this,arguments)}let r=function(e){return e.Pop="POP",e.Push="PUSH",e.Replace="REPLACE",e}({});const a="popstate";function n(e,t){if(!1===e||null==e)throw new Error(t)}function o(e,t){if(!e){"undefined"!=typeof console&&console.warn(t);try{throw new Error(t)}catch(e){}}}function i(e,t){return{usr:e.state,key:e.key,idx:t}}function s(e,r,a,n){return void 0===a&&(a=null),t({pathname:"string"==typeof e?e:e.pathname,search:"",hash:""},"string"==typeof r?u(r):r,{state:a,key:r&&r.key||n||Math.random().toString(36).substr(2,8)})}function l(e){let{pathname:t="/",search:r="",hash:a=""}=e;return r&&"?"!==r&&(t+="?"===r.charAt(0)?r:"?"+r),a&&"#"!==a&&(t+="#"===a.charAt(0)?a:"#"+a),t}function u(e){let t={};if(e){let r=e.indexOf("#");r>=0&&(t.hash=e.substr(r),e=e.substr(0,r));let a=e.indexOf("?");a>=0&&(t.search=e.substr(a),e=e.substr(0,a)),e&&(t.pathname=e)}return t}function c(e,o,u,c){void 0===c&&(c={});let{window:d=document.defaultView,v5Compat:h=!1}=c,f=d.history,p=r.Pop,m=null,y=v();function v(){return(f.state||{idx:null}).idx}function g(){p=r.Pop;let e=v(),t=null==e?null:e-y;y=e,m&&m({action:p,location:w.location,delta:t})}function b(e){let t="null"!==d.location.origin?d.location.origin:d.location.href,r="string"==typeof e?e:l(e);return r=r.replace(/ $/,"%20"),n(t,"No window.location.(origin|href) available to create URL for href: "+r),new URL(r,t)}null==y&&(y=0,f.replaceState(t({},f.state,{idx:y}),""));let w={get action(){return p},get location(){return e(d,f)},listen(e){if(m)throw new Error("A history only accepts one active listener");return d.addEventListener(a,g),m=e,()=>{d.removeEventListener(a,g),m=null}},createHref:e=>o(d,e),createURL:b,encodeLocation(e){let t=b(e);return{pathname:t.pathname,search:t.search,hash:t.hash}},push:function(e,t){p=r.Push;let a=s(w.location,e,t);u&&u(a,e),y=v()+1;let n=i(a,y),o=w.createHref(a);try{f.pushState(n,"",o)}catch(e){if(e instanceof DOMException&&"DataCloneError"===e.name)throw e;d.location.assign(o)}h&&m&&m({action:p,location:w.location,delta:1})},replace:function(e,t){p=r.Replace;let a=s(w.location,e,t);u&&u(a,e),y=v();let n=i(a,y),o=w.createHref(a);f.replaceState(n,"",o),h&&m&&m({action:p,location:w.location,delta:0})},go:e=>f.go(e)};return w}let d=function(e){return e.data="data",e.deferred="deferred",e.redirect="redirect",e.error="error",e}({});const h=new Set(["lazy","caseSensitive","path","id","index","children"]);function f(e,r,a,o){return void 0===a&&(a=[]),void 0===o&&(o={}),e.map(((e,i)=>{let s=[...a,String(i)],l="string"==typeof e.id?e.id:s.join("-");if(n(!0!==e.index||!e.children,"Cannot specify children on an index route"),n(!o[l],'Found a route id collision on id "'+l+"\".  Route id's must be globally unique within Data Router usages"),function(e){return!0===e.index}(e)){let a=t({},e,r(e),{id:l});return o[l]=a,a}{let a=t({},e,r(e),{id:l,children:void 0});return o[l]=a,e.children&&(a.children=f(e.children,r,s,o)),a}}))}function p(e,t,r){return void 0===r&&(r="/"),m(e,t,r,!1)}function m(e,t,r,a){let n=P(("string"==typeof t?u(t):t).pathname||"/",r);if(null==n)return null;let o=v(e);!function(e){e.sort(((e,t)=>e.score!==t.score?t.score-e.score:function(e,t){return e.length===t.length&&e.slice(0,-1).every(((e,r)=>e===t[r]))?e[e.length-1]-t[t.length-1]:0}(e.routesMeta.map((e=>e.childrenIndex)),t.routesMeta.map((e=>e.childrenIndex)))))}(o);let i=null;for(let e=0;null==i&&e<o.length;++e){let t=E(n);i=D(o[e],t,a)}return i}function y(e,t){let{route:r,pathname:a,params:n}=e;return{id:r.id,pathname:a,params:n,data:t[r.id],handle:r.handle}}function v(e,t,r,a){void 0===t&&(t=[]),void 0===r&&(r=[]),void 0===a&&(a="");let o=(e,o,i)=>{let s={relativePath:void 0===i?e.path||"":i,caseSensitive:!0===e.caseSensitive,childrenIndex:o,route:e};s.relativePath.startsWith("/")&&(n(s.relativePath.startsWith(a),'Absolute route path "'+s.relativePath+'" nested under path "'+a+'" is not valid. An absolute child route path must start with the combined path of all its parent routes.'),s.relativePath=s.relativePath.slice(a.length));let l=_([a,s.relativePath]),u=r.concat(s);e.children&&e.children.length>0&&(n(!0!==e.index,'Index routes must not have child routes. Please remove all child routes from route path "'+l+'".'),v(e.children,t,u,l)),(null!=e.path||e.index)&&t.push({path:l,score:S(l,e.index),routesMeta:u})};return e.forEach(((e,t)=>{var r;if(""!==e.path&&null!=(r=e.path)&&r.includes("?"))for(let r of g(e.path))o(e,t,r);else o(e,t)})),t}function g(e){let t=e.split("/");if(0===t.length)return[];let[r,...a]=t,n=r.endsWith("?"),o=r.replace(/\?$/,"");if(0===a.length)return n?[o,""]:[o];let i=g(a.join("/")),s=[];return s.push(...i.map((e=>""===e?o:[o,e].join("/")))),n&&s.push(...i),s.map((t=>e.startsWith("/")&&""===t?"/":t))}const b=/^:[\w-]+$/,w=e=>"*"===e;function S(e,t){let r=e.split("/"),a=r.length;return r.some(w)&&(a+=-2),t&&(a+=2),r.filter((e=>!w(e))).reduce(((e,t)=>e+(b.test(t)?3:""===t?1:10)),a)}function D(e,t,r){void 0===r&&(r=!1);let{routesMeta:a}=e,n={},o="/",i=[];for(let e=0;e<a.length;++e){let s=a[e],l=e===a.length-1,u="/"===o?t:t.slice(o.length)||"/",c=R({path:s.relativePath,caseSensitive:s.caseSensitive,end:l},u),d=s.route;if(!c&&l&&r&&!a[a.length-1].route.index&&(c=R({path:s.relativePath,caseSensitive:s.caseSensitive,end:!1},u)),!c)return null;Object.assign(n,c.params),i.push({params:n,pathname:_([o,c.pathname]),pathnameBase:T(_([o,c.pathnameBase])),route:d}),"/"!==c.pathnameBase&&(o=_([o,c.pathnameBase]))}return i}function R(e,t){"string"==typeof e&&(e={path:e,caseSensitive:!1,end:!0});let[r,a]=function(e,t,r){void 0===t&&(t=!1);void 0===r&&(r=!0);o("*"===e||!e.endsWith("*")||e.endsWith("/*"),'Route path "'+e+'" will be treated as if it were "'+e.replace(/\*$/,"/*")+'" because the `*` character must always follow a `/` in the pattern. To get rid of this warning, please change the route path to "'+e.replace(/\*$/,"/*")+'".');let a=[],n="^"+e.replace(/\/*\*?$/,"").replace(/^\/*/,"/").replace(/[\\.*+^${}|()[\]]/g,"\\$&").replace(/\/:([\w-]+)(\?)?/g,((e,t,r)=>(a.push({paramName:t,isOptional:null!=r}),r?"/?([^\\/]+)?":"/([^\\/]+)")));e.endsWith("*")?(a.push({paramName:"*"}),n+="*"===e||"/*"===e?"(.*)$":"(?:\\/(.+)|\\/*)$"):r?n+="\\/*$":""!==e&&"/"!==e&&(n+="(?:(?=\\/|$))");return[new RegExp(n,t?void 0:"i"),a]}(e.path,e.caseSensitive,e.end),n=t.match(r);if(!n)return null;let i=n[0],s=i.replace(/(.)\/+$/,"$1"),l=n.slice(1);return{params:a.reduce(((e,t,r)=>{let{paramName:a,isOptional:n}=t;if("*"===a){let e=l[r]||"";s=i.slice(0,i.length-e.length).replace(/(.)\/+$/,"$1")}const o=l[r];return e[a]=n&&!o?void 0:(o||"").replace(/%2F/g,"/"),e}),{}),pathname:i,pathnameBase:s,pattern:e}}function E(e){try{return e.split("/").map((e=>decodeURIComponent(e).replace(/\//g,"%2F"))).join("/")}catch(t){return o(!1,'The URL path "'+e+'" could not be decoded because it is is a malformed URL segment. This is probably due to a bad percent encoding ('+t+")."),e}}function P(e,t){if("/"===t)return e;if(!e.toLowerCase().startsWith(t.toLowerCase()))return null;let r=t.endsWith("/")?t.length-1:t.length,a=e.charAt(r);return a&&"/"!==a?null:e.slice(r)||"/"}const x=/^(?:[a-z][a-z0-9+.-]*:|\/\/)/i;function L(e,t){void 0===t&&(t="/");let r,{pathname:a,search:n="",hash:i=""}="string"==typeof e?u(e):e;if(a)if(s=a,x.test(s))r=a;else{if(a.includes("//")){let e=a;a=a.replace(/\/\/+/g,"/"),o(!1,"Pathnames cannot have embedded double slashes - normalizing "+e+" -> "+a)}r=a.startsWith("/")?A(a.substring(1),"/"):A(a,t)}else r=t;var s;return{pathname:r,search:U(n),hash:O(i)}}function A(e,t){let r=t.replace(/\/+$/,"").split("/");return e.split("/").forEach((e=>{".."===e?r.length>1&&r.pop():"."!==e&&r.push(e)})),r.length>1?r.join("/"):"/"}function M(e,t,r,a){return"Cannot include a '"+e+"' character in a manually specified `to."+t+"` field ["+JSON.stringify(a)+"].  Please separate it out to the `to."+r+'` field. Alternatively you may provide the full path as a string in <Link to="..."> and the router will parse it for you.'}function j(e){return e.filter(((e,t)=>0===t||e.route.path&&e.route.path.length>0))}function k(e,t){let r=j(e);return t?r.map(((e,t)=>t===r.length-1?e.pathname:e.pathnameBase)):r.map((e=>e.pathnameBase))}function C(e,r,a,o){let i;void 0===o&&(o=!1),"string"==typeof e?i=u(e):(i=t({},e),n(!i.pathname||!i.pathname.includes("?"),M("?","pathname","search",i)),n(!i.pathname||!i.pathname.includes("#"),M("#","pathname","hash",i)),n(!i.search||!i.search.includes("#"),M("#","search","hash",i)));let s,l=""===e||""===i.pathname,c=l?"/":i.pathname;if(null==c)s=a;else{let e=r.length-1;if(!o&&c.startsWith("..")){let t=c.split("/");for(;".."===t[0];)t.shift(),e-=1;i.pathname=t.join("/")}s=e>=0?r[e]:"/"}let d=L(i,s),h=c&&"/"!==c&&c.endsWith("/"),f=(l||"."===c)&&a.endsWith("/");return d.pathname.endsWith("/")||!h&&!f||(d.pathname+="/"),d}const _=e=>e.join("/").replace(/\/\/+/g,"/"),T=e=>e.replace(/\/+$/,"").replace(/^\/*/,"/"),U=e=>e&&"?"!==e?e.startsWith("?")?e:"?"+e:"",O=e=>e&&"#"!==e?e.startsWith("#")?e:"#"+e:"";class I{constructor(e,t){this.type="DataWithResponseInit",this.data=e,this.init=t||null}}class H extends Error{}class z{constructor(e,t){let r;this.pendingKeysSet=new Set,this.subscribers=new Set,this.deferredKeys=[],n(e&&"object"==typeof e&&!Array.isArray(e),"defer() only accepts plain objects"),this.abortPromise=new Promise(((e,t)=>r=t)),this.controller=new AbortController;let a=()=>r(new H("Deferred data aborted"));this.unlistenAbortSignal=()=>this.controller.signal.removeEventListener("abort",a),this.controller.signal.addEventListener("abort",a),this.data=Object.entries(e).reduce(((e,t)=>{let[r,a]=t;return Object.assign(e,{[r]:this.trackPromise(r,a)})}),{}),this.done&&this.unlistenAbortSignal(),this.init=t}trackPromise(e,t){if(!(t instanceof Promise))return t;this.deferredKeys.push(e),this.pendingKeysSet.add(e);let r=Promise.race([t,this.abortPromise]).then((t=>this.onSettle(r,e,void 0,t)),(t=>this.onSettle(r,e,t)));return r.catch((()=>{})),Object.defineProperty(r,"_tracked",{get:()=>!0}),r}onSettle(e,t,r,a){if(this.controller.signal.aborted&&r instanceof H)return this.unlistenAbortSignal(),Object.defineProperty(e,"_error",{get:()=>r}),Promise.reject(r);if(this.pendingKeysSet.delete(t),this.done&&this.unlistenAbortSignal(),void 0===r&&void 0===a){let r=new Error('Deferred data for key "'+t+'" resolved/rejected with `undefined`, you must resolve/reject with a value or `null`.');return Object.defineProperty(e,"_error",{get:()=>r}),this.emit(!1,t),Promise.reject(r)}return void 0===a?(Object.defineProperty(e,"_error",{get:()=>r}),this.emit(!1,t),Promise.reject(r)):(Object.defineProperty(e,"_data",{get:()=>a}),this.emit(!1,t),a)}emit(e,t){this.subscribers.forEach((r=>r(e,t)))}subscribe(e){return this.subscribers.add(e),()=>this.subscribers.delete(e)}cancel(){this.controller.abort(),this.pendingKeysSet.forEach(((e,t)=>this.pendingKeysSet.delete(t))),this.emit(!0)}async resolveData(e){let t=!1;if(!this.done){let r=()=>this.cancel();e.addEventListener("abort",r),t=await new Promise((t=>{this.subscribe((a=>{e.removeEventListener("abort",r),(a||this.done)&&t(a)}))}))}return t}get done(){return 0===this.pendingKeysSet.size}get unwrappedData(){return n(null!==this.data&&this.done,"Can only unwrap data on initialized and settled deferreds"),Object.entries(this.data).reduce(((e,t)=>{let[r,a]=t;return Object.assign(e,{[r]:F(a)})}),{})}get pendingKeys(){return Array.from(this.pendingKeysSet)}}function F(e){if(!function(e){return e instanceof Promise&&!0===e._tracked}(e))return e;if(e._error)throw e._error;return e._data}const N=function(e,r){void 0===r&&(r=302);let a=r;"number"==typeof a?a={status:a}:void 0===a.status&&(a.status=302);let n=new Headers(a.headers);return n.set("Location",e),new Response(null,t({},a,{headers:n}))};class B{constructor(e,t,r,a){void 0===a&&(a=!1),this.status=e,this.statusText=t||"",this.internal=a,r instanceof Error?(this.data=r.toString(),this.error=r):this.data=r}}function W(e){return null!=e&&"number"==typeof e.status&&"string"==typeof e.statusText&&"boolean"==typeof e.internal&&"data"in e}const $=["post","put","patch","delete"],q=new Set($),K=["get",...$],Y=new Set(K),J=new Set([301,302,303,307,308]),V=new Set([307,308]),X={state:"idle",location:void 0,formMethod:void 0,formAction:void 0,formEncType:void 0,formData:void 0,json:void 0,text:void 0},G={state:"idle",data:void 0,formMethod:void 0,formAction:void 0,formEncType:void 0,formData:void 0,json:void 0,text:void 0},Q={state:"unblocked",proceed:void 0,reset:void 0,location:void 0},Z=/^(?:[a-z][a-z0-9+.-]*:|\/\/)/i,ee=e=>({hasErrorBoundary:Boolean(e.hasErrorBoundary)}),te="remix-router-transitions";const re=Symbol("deferred");function ae(e,t,r){if(r.v7_throwAbortReason&&void 0!==e.signal.reason)throw e.signal.reason;throw new Error((t?"queryRoute":"query")+"() call aborted: "+e.method+" "+e.url)}function ne(e,t,r,a,n,o,i,s){let u,c;if(i){u=[];for(let e of t)if(u.push(e),e.route.id===i){c=e;break}}else u=t,c=t[t.length-1];let d=C(n||".",k(u,o),P(e.pathname,r)||e.pathname,"path"===s);if(null==n&&(d.search=e.search,d.hash=e.hash),(null==n||""===n||"."===n)&&c){let e=Be(d.search);if(c.route.index&&!e)d.search=d.search?d.search.replace(/^\?/,"?index&"):"?index";else if(!c.route.index&&e){let e=new URLSearchParams(d.search),t=e.getAll("index");e.delete("index"),t.filter((e=>e)).forEach((t=>e.append("index",t)));let r=e.toString();d.search=r?"?"+r:""}}return a&&"/"!==r&&(d.pathname="/"===d.pathname?r:_([r,d.pathname])),l(d)}function oe(e,t,r,a){if(!a||!function(e){return null!=e&&("formData"in e&&null!=e.formData||"body"in e&&void 0!==e.body)}(a))return{path:r};if(a.formMethod&&!Ie(a.formMethod))return{path:r,error:Le(405,{method:a.formMethod})};let o,i,s=()=>({path:r,error:Le(400,{type:"invalid-body"})}),c=a.formMethod||"get",d=e?c.toUpperCase():c.toLowerCase(),h=Me(r);if(void 0!==a.body){if("text/plain"===a.formEncType){if(!He(d))return s();let e="string"==typeof a.body?a.body:a.body instanceof FormData||a.body instanceof URLSearchParams?Array.from(a.body.entries()).reduce(((e,t)=>{let[r,a]=t;return""+e+r+"="+a+"\n"}),""):String(a.body);return{path:r,submission:{formMethod:d,formAction:h,formEncType:a.formEncType,formData:void 0,json:void 0,text:e}}}if("application/json"===a.formEncType){if(!He(d))return s();try{let e="string"==typeof a.body?JSON.parse(a.body):a.body;return{path:r,submission:{formMethod:d,formAction:h,formEncType:a.formEncType,formData:void 0,json:e,text:void 0}}}catch(e){return s()}}}if(n("function"==typeof FormData,"FormData is not available in this environment"),a.formData)o=be(a.formData),i=a.formData;else if(a.body instanceof FormData)o=be(a.body),i=a.body;else if(a.body instanceof URLSearchParams)o=a.body,i=we(o);else if(null==a.body)o=new URLSearchParams,i=new FormData;else try{o=new URLSearchParams(a.body),i=we(o)}catch(e){return s()}let f={formMethod:d,formAction:h,formEncType:a&&a.formEncType||"application/x-www-form-urlencoded",formData:i,json:void 0,text:void 0};if(He(f.formMethod))return{path:r,submission:f};let p=u(r);return t&&p.search&&Be(p.search)&&o.append("index",""),p.search="?"+o,{path:l(p),submission:f}}function ie(e,t,r){void 0===r&&(r=!1);let a=e.findIndex((e=>e.route.id===t));return a>=0?e.slice(0,r?a+1:a):e}function se(e,r,a,n,o,i,s,l,u,c,d,h,f,m,y,v){let g=v?Ce(v[1])?v[1].error:v[1].data:void 0,b=e.createURL(r.location),w=e.createURL(o),S=a;i&&r.errors?S=ie(a,Object.keys(r.errors)[0],!0):v&&Ce(v[1])&&(S=ie(a,v[0]));let D=v?v[1].statusCode:void 0,R=s&&D&&D>=400,E=S.filter(((e,a)=>{let{route:o}=e;if(o.lazy)return!0;if(null==o.loader)return!1;if(i)return le(o,r.loaderData,r.errors);if(function(e,t,r){let a=!t||r.route.id!==t.route.id,n=void 0===e[r.route.id];return a||n}(r.loaderData,r.matches[a],e)||u.some((t=>t===e.route.id)))return!0;let s=r.matches[a],c=e;return ce(e,t({currentUrl:b,currentParams:s.params,nextUrl:w,nextParams:c.params},n,{actionResult:g,actionStatus:D,defaultShouldRevalidate:!R&&(l||b.pathname+b.search===w.pathname+w.search||b.search!==w.search||ue(s,c))}))})),P=[];return h.forEach(((e,o)=>{if(i||!a.some((t=>t.route.id===e.routeId))||d.has(o))return;let s=p(m,e.path,y);if(!s)return void P.push({key:o,routeId:e.routeId,path:e.path,matches:null,match:null,controller:null});let u=r.fetchers.get(o),h=We(s,e.path),v=!1;f.has(o)?v=!1:c.has(o)?(c.delete(o),v=!0):v=u&&"idle"!==u.state&&void 0===u.data?l:ce(h,t({currentUrl:b,currentParams:r.matches[r.matches.length-1].params,nextUrl:w,nextParams:a[a.length-1].params},n,{actionResult:g,actionStatus:D,defaultShouldRevalidate:!R&&l})),v&&P.push({key:o,routeId:e.routeId,path:e.path,matches:s,match:h,controller:new AbortController})})),[E,P]}function le(e,t,r){if(e.lazy)return!0;if(!e.loader)return!1;let a=null!=t&&void 0!==t[e.id],n=null!=r&&void 0!==r[e.id];return!(!a&&n)&&("function"==typeof e.loader&&!0===e.loader.hydrate||!a&&!n)}function ue(e,t){let r=e.route.path;return e.pathname!==t.pathname||null!=r&&r.endsWith("*")&&e.params["*"]!==t.params["*"]}function ce(e,t){if(e.route.shouldRevalidate){let r=e.route.shouldRevalidate(t);if("boolean"==typeof r)return r}return t.defaultShouldRevalidate}function de(e,t,r,a,o){var i;let s;if(e){let t=a[e];n(t,"No route found to patch children into: routeId = "+e),t.children||(t.children=[]),s=t.children}else s=r;let l=f(t.filter((e=>!s.some((t=>he(e,t))))),o,[e||"_","patch",String((null==(i=s)?void 0:i.length)||"0")],a);s.push(...l)}function he(e,t){return"id"in e&&"id"in t&&e.id===t.id||e.index===t.index&&e.path===t.path&&e.caseSensitive===t.caseSensitive&&(!(e.children&&0!==e.children.length||t.children&&0!==t.children.length)||e.children.every(((e,r)=>{var a;return null==(a=t.children)?void 0:a.some((t=>he(e,t)))})))}async function fe(e){let{matches:t}=e,r=t.filter((e=>e.shouldLoad));return(await Promise.all(r.map((e=>e.resolve())))).reduce(((e,t,a)=>Object.assign(e,{[r[a].route.id]:t})),{})}async function pe(e,r,a,i,s,l,u,c,f,p){let m=l.map((e=>e.route.lazy?async function(e,r,a){if(!e.lazy)return;let i=await e.lazy();if(!e.lazy)return;let s=a[e.id];n(s,"No route found in manifest");let l={};for(let e in i){let t=void 0!==s[e]&&"hasErrorBoundary"!==e;o(!t,'Route "'+s.id+'" has a static property "'+e+'" defined but its lazy function is also returning a value for this property. The lazy route property "'+e+'" will be ignored.'),t||h.has(e)||(l[e]=i[e])}Object.assign(s,l),Object.assign(s,t({},r(s),{lazy:void 0}))}(e.route,f,c):void 0)),y=l.map(((e,a)=>{let o=m[a],l=s.some((t=>t.route.id===e.route.id));return t({},e,{shouldLoad:l,resolve:async t=>(t&&"GET"===i.method&&(e.route.lazy||e.route.loader)&&(l=!0),l?async function(e,t,r,a,o,i){let s,l,u=a=>{let n,s=new Promise(((e,t)=>n=t));l=()=>n(),t.signal.addEventListener("abort",l);let u=n=>"function"!=typeof a?Promise.reject(new Error('You cannot call the handler for a route which defines a boolean "'+e+'" [routeId: '+r.route.id+"]")):a({request:t,params:r.params,context:i},...void 0!==n?[n]:[]),c=(async()=>{try{return{type:"data",result:await(o?o((e=>u(e))):u())}}catch(e){return{type:"error",result:e}}})();return Promise.race([c,s])};try{let o=r.route[e];if(a)if(o){let e,[t]=await Promise.all([u(o).catch((t=>{e=t})),a]);if(void 0!==e)throw e;s=t}else{if(await a,o=r.route[e],!o){if("action"===e){let e=new URL(t.url),a=e.pathname+e.search;throw Le(405,{method:t.method,pathname:a,routeId:r.route.id})}return{type:d.data,result:void 0}}s=await u(o)}else{if(!o){let e=new URL(t.url);throw Le(404,{pathname:e.pathname+e.search})}s=await u(o)}n(void 0!==s.result,"You defined "+("action"===e?"an action":"a loader")+' for route "'+r.route.id+"\" but didn't return anything from your `"+e+"` function. Please return a value or `null`.")}catch(e){return{type:d.error,result:e}}finally{l&&t.signal.removeEventListener("abort",l)}return s}(r,i,e,o,t,p):Promise.resolve({type:d.data,result:void 0}))})})),v=await e({matches:y,request:i,params:l[0].params,fetcherKey:u,context:p});try{await Promise.all(m)}catch(e){}return v}async function me(e){let{result:t,type:r}=e;if(Oe(t)){let e;try{let r=t.headers.get("Content-Type");e=r&&/\bapplication\/json\b/.test(r)?null==t.body?null:await t.json():await t.text()}catch(e){return{type:d.error,error:e}}return r===d.error?{type:d.error,error:new B(t.status,t.statusText,e),statusCode:t.status,headers:t.headers}:{type:d.data,data:e,statusCode:t.status,headers:t.headers}}var a,n,o,i,s,l,u,c;return r===d.error?Te(t)?t.data instanceof Error?{type:d.error,error:t.data,statusCode:null==(o=t.init)?void 0:o.status,headers:null!=(i=t.init)&&i.headers?new Headers(t.init.headers):void 0}:{type:d.error,error:new B((null==(a=t.init)?void 0:a.status)||500,void 0,t.data),statusCode:W(t)?t.status:void 0,headers:null!=(n=t.init)&&n.headers?new Headers(t.init.headers):void 0}:{type:d.error,error:t,statusCode:W(t)?t.status:void 0}:Ue(t)?{type:d.deferred,deferredData:t,statusCode:null==(s=t.init)?void 0:s.status,headers:(null==(l=t.init)?void 0:l.headers)&&new Headers(t.init.headers)}:Te(t)?{type:d.data,data:t.data,statusCode:null==(u=t.init)?void 0:u.status,headers:null!=(c=t.init)&&c.headers?new Headers(t.init.headers):void 0}:{type:d.data,data:t}}function ye(e,t,r,a,o,i){let s=e.headers.get("Location");if(n(s,"Redirects returned/thrown from loaders/actions must have a Location header"),!Z.test(s)){let n=a.slice(0,a.findIndex((e=>e.route.id===r))+1);s=ne(new URL(t.url),n,o,!0,s,i),e.headers.set("Location",s)}return e}function ve(e,t,r,a){let n=["about:","blob:","chrome:","chrome-untrusted:","content:","data:","devtools:","file:","filesystem:","javascript:"];if(Z.test(e)){let a=e,o=a.startsWith("//")?new URL(t.protocol+a):new URL(a);if(n.includes(o.protocol))throw new Error("Invalid redirect location");let i=null!=P(o.pathname,r);if(o.origin===t.origin&&i)return o.pathname+o.search+o.hash}try{let t=a.createURL(e);if(n.includes(t.protocol))throw new Error("Invalid redirect location")}catch(e){}return e}function ge(e,t,r,a){let n=e.createURL(Me(t)).toString(),o={signal:r};if(a&&He(a.formMethod)){let{formMethod:e,formEncType:t}=a;o.method=e.toUpperCase(),"application/json"===t?(o.headers=new Headers({"Content-Type":t}),o.body=JSON.stringify(a.json)):"text/plain"===t?o.body=a.text:"application/x-www-form-urlencoded"===t&&a.formData?o.body=be(a.formData):o.body=a.formData}return new Request(n,o)}function be(e){let t=new URLSearchParams;for(let[r,a]of e.entries())t.append(r,"string"==typeof a?a:a.name);return t}function we(e){let t=new FormData;for(let[r,a]of e.entries())t.append(r,a);return t}function Se(e,t,r,a,o){let i,s={},l=null,u=!1,c={},d=r&&Ce(r[1])?r[1].error:void 0;return e.forEach((r=>{if(!(r.route.id in t))return;let h=r.route.id,f=t[h];if(n(!_e(f),"Cannot handle redirect results in processLoaderData"),Ce(f)){let t=f.error;if(void 0!==d&&(t=d,d=void 0),l=l||{},o)l[h]=t;else{let r=Pe(e,h);null==l[r.route.id]&&(l[r.route.id]=t)}s[h]=void 0,u||(u=!0,i=W(f.error)?f.error.status:500),f.headers&&(c[h]=f.headers)}else ke(f)?(a.set(h,f.deferredData),s[h]=f.deferredData.data,null==f.statusCode||200===f.statusCode||u||(i=f.statusCode),f.headers&&(c[h]=f.headers)):(s[h]=f.data,f.statusCode&&200!==f.statusCode&&!u&&(i=f.statusCode),f.headers&&(c[h]=f.headers))})),void 0!==d&&r&&(l={[r[0]]:d},s[r[0]]=void 0),{loaderData:s,errors:l,statusCode:i||200,loaderHeaders:c}}function De(e,r,a,o,i,s,l){let{loaderData:u,errors:c}=Se(r,a,o,l,!1);return i.forEach((r=>{let{key:a,match:o,controller:i}=r,l=s[a];if(n(l,"Did not find corresponding fetcher result"),!i||!i.signal.aborted)if(Ce(l)){let r=Pe(e.matches,null==o?void 0:o.route.id);c&&c[r.route.id]||(c=t({},c,{[r.route.id]:l.error})),e.fetchers.delete(a)}else if(_e(l))n(!1,"Unhandled fetcher revalidation redirect");else if(ke(l))n(!1,"Unhandled fetcher deferred data");else{let t=Je(l.data);e.fetchers.set(a,t)}})),{loaderData:u,errors:c}}function Re(e,r,a,n){let o=t({},r);for(let t of a){let a=t.route.id;if(r.hasOwnProperty(a)?void 0!==r[a]&&(o[a]=r[a]):void 0!==e[a]&&t.route.loader&&(o[a]=e[a]),n&&n.hasOwnProperty(a))break}return o}function Ee(e){return e?Ce(e[1])?{actionData:{}}:{actionData:{[e[0]]:e[1].data}}:{}}function Pe(e,t){return(t?e.slice(0,e.findIndex((e=>e.route.id===t))+1):[...e]).reverse().find((e=>!0===e.route.hasErrorBoundary))||e[0]}function xe(e){let t=1===e.length?e[0]:e.find((e=>e.index||!e.path||"/"===e.path))||{id:"__shim-error-route__"};return{matches:[{params:{},pathname:"",pathnameBase:"",route:t}],route:t}}function Le(e,t){let{pathname:r,routeId:a,method:n,type:o,message:i}=void 0===t?{}:t,s="Unknown Server Error",l="Unknown @remix-run/router error";return 400===e?(s="Bad Request",n&&r&&a?l="You made a "+n+' request to "'+r+'" but did not provide a `loader` for route "'+a+'", so there is no way to handle the request.':"defer-action"===o?l="defer() is not supported in actions":"invalid-body"===o&&(l="Unable to encode submission body")):403===e?(s="Forbidden",l='Route "'+a+'" does not match URL "'+r+'"'):404===e?(s="Not Found",l='No route matches URL "'+r+'"'):405===e&&(s="Method Not Allowed",n&&r&&a?l="You made a "+n.toUpperCase()+' request to "'+r+'" but did not provide an `action` for route "'+a+'", so there is no way to handle the request.':n&&(l='Invalid request method "'+n.toUpperCase()+'"')),new B(e||500,s,new Error(l),!0)}function Ae(e){let t=Object.entries(e);for(let e=t.length-1;e>=0;e--){let[r,a]=t[e];if(_e(a))return{key:r,result:a}}}function Me(e){return l(t({},"string"==typeof e?u(e):e,{hash:""}))}function je(e){return Oe(e.result)&&J.has(e.result.status)}function ke(e){return e.type===d.deferred}function Ce(e){return e.type===d.error}function _e(e){return(e&&e.type)===d.redirect}function Te(e){return"object"==typeof e&&null!=e&&"type"in e&&"data"in e&&"init"in e&&"DataWithResponseInit"===e.type}function Ue(e){let t=e;return t&&"object"==typeof t&&"object"==typeof t.data&&"function"==typeof t.subscribe&&"function"==typeof t.cancel&&"function"==typeof t.resolveData}function Oe(e){return null!=e&&"number"==typeof e.status&&"string"==typeof e.statusText&&"object"==typeof e.headers&&void 0!==e.body}function Ie(e){return Y.has(e.toLowerCase())}function He(e){return q.has(e.toLowerCase())}async function ze(e,t,r,a,n){let o=Object.entries(t);for(let i=0;i<o.length;i++){let[s,l]=o[i],u=e.find((e=>(null==e?void 0:e.route.id)===s));if(!u)continue;let c=a.find((e=>e.route.id===u.route.id)),d=null!=c&&!ue(c,u)&&void 0!==(n&&n[u.route.id]);ke(l)&&d&&await Ne(l,r,!1).then((e=>{e&&(t[s]=e)}))}}async function Fe(e,t,r){for(let a=0;a<r.length;a++){let{key:o,routeId:i,controller:s}=r[a],l=t[o];e.find((e=>(null==e?void 0:e.route.id)===i))&&(ke(l)&&(n(s,"Expected an AbortController for revalidating fetcher deferred result"),await Ne(l,s.signal,!0).then((e=>{e&&(t[o]=e)}))))}}async function Ne(e,t,r){if(void 0===r&&(r=!1),!await e.deferredData.resolveData(t)){if(r)try{return{type:d.data,data:e.deferredData.unwrappedData}}catch(e){return{type:d.error,error:e}}return{type:d.data,data:e.deferredData.data}}}function Be(e){return new URLSearchParams(e).getAll("index").some((e=>""===e))}function We(e,t){let r="string"==typeof t?u(t).search:t.search;if(e[e.length-1].route.index&&Be(r||""))return e[e.length-1];let a=j(e);return a[a.length-1]}function $e(e){let{formMethod:t,formAction:r,formEncType:a,text:n,formData:o,json:i}=e;if(t&&r&&a)return null!=n?{formMethod:t,formAction:r,formEncType:a,formData:void 0,json:void 0,text:n}:null!=o?{formMethod:t,formAction:r,formEncType:a,formData:o,json:void 0,text:void 0}:void 0!==i?{formMethod:t,formAction:r,formEncType:a,formData:void 0,json:i,text:void 0}:void 0}function qe(e,t){if(t){return{state:"loading",location:e,formMethod:t.formMethod,formAction:t.formAction,formEncType:t.formEncType,formData:t.formData,json:t.json,text:t.text}}return{state:"loading",location:e,formMethod:void 0,formAction:void 0,formEncType:void 0,formData:void 0,json:void 0,text:void 0}}function Ke(e,t){return{state:"submitting",location:e,formMethod:t.formMethod,formAction:t.formAction,formEncType:t.formEncType,formData:t.formData,json:t.json,text:t.text}}function Ye(e,t){if(e){return{state:"loading",formMethod:e.formMethod,formAction:e.formAction,formEncType:e.formEncType,formData:e.formData,json:e.json,text:e.text,data:t}}return{state:"loading",formMethod:void 0,formAction:void 0,formEncType:void 0,formData:void 0,json:void 0,text:void 0,data:t}}function Je(e){return{state:"idle",formMethod:void 0,formAction:void 0,formEncType:void 0,formData:void 0,json:void 0,text:void 0,data:e}}e.AbortedDeferredError=H,e.Action=r,e.IDLE_BLOCKER=Q,e.IDLE_FETCHER=G,e.IDLE_NAVIGATION=X,e.UNSAFE_DEFERRED_SYMBOL=re,e.UNSAFE_DeferredData=z,e.UNSAFE_ErrorResponseImpl=B,e.UNSAFE_convertRouteMatchToUiMatch=y,e.UNSAFE_convertRoutesToDataRoutes=f,e.UNSAFE_decodePath=E,e.UNSAFE_getResolveToMatches=k,e.UNSAFE_invariant=n,e.UNSAFE_warning=o,e.createBrowserHistory=function(e){return void 0===e&&(e={}),c((function(e,t){let{pathname:r,search:a,hash:n}=e.location;return s("",{pathname:r,search:a,hash:n},t.state&&t.state.usr||null,t.state&&t.state.key||"default")}),(function(e,t){return"string"==typeof t?t:l(t)}),null,e)},e.createHashHistory=function(e){return void 0===e&&(e={}),c((function(e,t){let{pathname:r="/",search:a="",hash:n=""}=u(e.location.hash.substr(1));return r.startsWith("/")||r.startsWith(".")||(r="/"+r),s("",{pathname:r,search:a,hash:n},t.state&&t.state.usr||null,t.state&&t.state.key||"default")}),(function(e,t){let r=e.document.querySelector("base"),a="";if(r&&r.getAttribute("href")){let t=e.location.href,r=t.indexOf("#");a=-1===r?t:t.slice(0,r)}return a+"#"+("string"==typeof t?t:l(t))}),(function(e,t){o("/"===e.pathname.charAt(0),"relative pathnames are not supported in hash history.push("+JSON.stringify(t)+")")}),e)},e.createMemoryHistory=function(e){void 0===e&&(e={});let t,{initialEntries:a=["/"],initialIndex:n,v5Compat:i=!1}=e;t=a.map(((e,t)=>m(e,"string"==typeof e?null:e.state,0===t?"default":void 0)));let c=f(null==n?t.length-1:n),d=r.Pop,h=null;function f(e){return Math.min(Math.max(e,0),t.length-1)}function p(){return t[c]}function m(e,r,a){void 0===r&&(r=null);let n=s(t?p().pathname:"/",e,r,a);return o("/"===n.pathname.charAt(0),"relative pathnames are not supported in memory history: "+JSON.stringify(e)),n}function y(e){return"string"==typeof e?e:l(e)}return{get index(){return c},get action(){return d},get location(){return p()},createHref:y,createURL:e=>new URL(y(e),"http://localhost"),encodeLocation(e){let t="string"==typeof e?u(e):e;return{pathname:t.pathname||"",search:t.search||"",hash:t.hash||""}},push(e,a){d=r.Push;let n=m(e,a);c+=1,t.splice(c,t.length,n),i&&h&&h({action:d,location:n,delta:1})},replace(e,a){d=r.Replace;let n=m(e,a);t[c]=n,i&&h&&h({action:d,location:n,delta:0})},go(e){d=r.Pop;let a=f(c+e),n=t[a];c=a,h&&h({action:d,location:n,delta:e})},listen:e=>(h=e,()=>{h=null})}},e.createPath=l,e.createRouter=function(e){const a=e.window?e.window:"undefined"!=typeof window?window:void 0,i=void 0!==a&&void 0!==a.document&&void 0!==a.document.createElement,l=!i;let u;if(n(e.routes.length>0,"You must provide a non-empty routes array to createRouter"),e.mapRouteProperties)u=e.mapRouteProperties;else if(e.detectErrorBoundary){let t=e.detectErrorBoundary;u=e=>({hasErrorBoundary:t(e)})}else u=ee;let c,h,v,g={},b=f(e.routes,u,void 0,g),w=e.basename||"/",S=e.dataStrategy||fe,D=e.patchRoutesOnNavigation,R=t({v7_fetcherPersist:!1,v7_normalizeFormMethod:!1,v7_partialHydration:!1,v7_prependBasename:!1,v7_relativeSplatPath:!1,v7_skipActionErrorRevalidation:!1},e.future),E=null,x=new Set,L=null,A=null,M=null,j=null!=e.hydrationData,k=p(b,e.history.location,w),C=!1,_=null;if(null==k&&!D){let t=Le(404,{pathname:e.history.location.pathname}),{matches:r,route:a}=xe(b);k=r,_={[a.id]:t}}if(k&&!e.hydrationData){dt(k,b,e.history.location.pathname).active&&(k=null)}if(k)if(k.some((e=>e.route.lazy)))h=!1;else if(k.some((e=>e.route.loader)))if(R.v7_partialHydration){let t=e.hydrationData?e.hydrationData.loaderData:null,r=e.hydrationData?e.hydrationData.errors:null;if(r){let e=k.findIndex((e=>void 0!==r[e.route.id]));h=k.slice(0,e+1).every((e=>!le(e.route,t,r)))}else h=k.every((e=>!le(e.route,t,r)))}else h=null!=e.hydrationData;else h=!0;else if(h=!1,k=[],R.v7_partialHydration){let t=dt(null,b,e.history.location.pathname);t.active&&t.matches&&(C=!0,k=t.matches)}let T,U,O={historyAction:e.history.action,location:e.history.location,matches:k,initialized:h,navigation:X,restoreScrollPosition:null==e.hydrationData&&null,preventScrollReset:!1,revalidation:"idle",loaderData:e.hydrationData&&e.hydrationData.loaderData||{},actionData:e.hydrationData&&e.hydrationData.actionData||null,errors:e.hydrationData&&e.hydrationData.errors||_,fetchers:new Map,blockers:new Map},I=r.Pop,H=!1,z=!1,F=new Map,N=null,B=!1,$=!1,q=[],K=new Set,Y=new Map,J=0,re=-1,ae=new Map,ie=new Set,ue=new Map,ce=new Map,he=new Set,be=new Map,we=new Map;function Se(e,r){void 0===r&&(r={}),O=t({},O,e);let a=[],n=[];R.v7_fetcherPersist&&O.fetchers.forEach(((e,t)=>{"idle"===e.state&&(he.has(t)?n.push(t):a.push(t))})),he.forEach((e=>{O.fetchers.has(e)||Y.has(e)||n.push(e)})),[...x].forEach((e=>e(O,{deletedFetchers:n,viewTransitionOpts:r.viewTransitionOpts,flushSync:!0===r.flushSync}))),R.v7_fetcherPersist?(a.forEach((e=>O.fetchers.delete(e))),n.forEach((e=>Ze(e)))):n.forEach((e=>he.delete(e)))}function Me(a,n,o){var i,s;let l,{flushSync:u}=void 0===o?{}:o,d=null!=O.actionData&&null!=O.navigation.formMethod&&He(O.navigation.formMethod)&&"loading"===O.navigation.state&&!0!==(null==(i=a.state)?void 0:i._isRedirect);l=n.actionData?Object.keys(n.actionData).length>0?n.actionData:null:d?O.actionData:null;let h=n.loaderData?Re(O.loaderData,n.loaderData,n.matches||[],n.errors):O.loaderData,f=O.blockers;f.size>0&&(f=new Map(f),f.forEach(((e,t)=>f.set(t,Q))));let p,m=!0===H||null!=O.navigation.formMethod&&He(O.navigation.formMethod)&&!0!==(null==(s=a.state)?void 0:s._isRedirect);if(c&&(b=c,c=void 0),B||I===r.Pop||(I===r.Push?e.history.push(a,a.state):I===r.Replace&&e.history.replace(a,a.state)),I===r.Pop){let e=F.get(O.location.pathname);e&&e.has(a.pathname)?p={currentLocation:O.location,nextLocation:a}:F.has(a.pathname)&&(p={currentLocation:a,nextLocation:O.location})}else if(z){let e=F.get(O.location.pathname);e?e.add(a.pathname):(e=new Set([a.pathname]),F.set(O.location.pathname,e)),p={currentLocation:O.location,nextLocation:a}}Se(t({},n,{actionData:l,loaderData:h,historyAction:I,location:a,initialized:!0,navigation:X,revalidation:"idle",restoreScrollPosition:ct(a,n.matches||O.matches),preventScrollReset:m,blockers:f}),{viewTransitionOpts:p,flushSync:!0===u}),I=r.Pop,H=!1,z=!1,B=!1,$=!1,q=[]}async function Te(a,n,o){T&&T.abort(),T=null,I=a,B=!0===(o&&o.startUninterruptedRevalidation),function(e,t){if(L&&M){let r=ut(e,t);L[r]=M()}}(O.location,O.matches),H=!0===(o&&o.preventScrollReset),z=!0===(o&&o.enableViewTransition);let i=c||b,s=o&&o.overrideNavigation,l=null!=o&&o.initialHydration&&O.matches&&O.matches.length>0&&!C?O.matches:p(i,n,w),u=!0===(o&&o.flushSync);if(l&&O.initialized&&!$&&function(e,t){if(e.pathname!==t.pathname||e.search!==t.search)return!1;if(""===e.hash)return""!==t.hash;if(e.hash===t.hash)return!0;if(""!==t.hash)return!0;return!1}(O.location,n)&&!(o&&o.submission&&He(o.submission.formMethod)))return void Me(n,{matches:l},{flushSync:u});let h=dt(l,i,n.pathname);if(h.active&&h.matches&&(l=h.matches),!l){let{error:e,notFoundMatches:t,route:r}=st(n.pathname);return void Me(n,{matches:t,loaderData:{},errors:{[r.id]:e}},{flushSync:u})}T=new AbortController;let f,m=ge(e.history,n,T.signal,o&&o.submission);if(o&&o.pendingError)f=[Pe(l).route.id,{type:d.error,error:o.pendingError}];else if(o&&o.submission&&He(o.submission.formMethod)){let t=await async function(t,a,n,o,i,s){void 0===s&&(s={});let l;if(Ve(),Se({navigation:Ke(a,n)},{flushSync:!0===s.flushSync}),i){let e=await ht(o,a.pathname,t.signal);if("aborted"===e.type)return{shortCircuited:!0};if("error"===e.type){let t=Pe(e.partialMatches).route.id;return{matches:e.partialMatches,pendingActionResult:[t,{type:d.error,error:e.error}]}}if(!e.matches){let{notFoundMatches:e,error:t,route:r}=st(a.pathname);return{matches:e,pendingActionResult:[r.id,{type:d.error,error:t}]}}o=e.matches}let u=We(o,a);if(u.route.action||u.route.lazy){if(l=(await Ie("action",O,t,[u],o,null))[u.route.id],t.signal.aborted)return{shortCircuited:!0}}else l={type:d.error,error:Le(405,{method:t.method,pathname:a.pathname,routeId:u.route.id})};if(_e(l)){let r;if(s&&null!=s.replace)r=s.replace;else{r=ve(l.response.headers.get("Location"),new URL(t.url),w,e.history)===O.location.pathname+O.location.search}return await Oe(t,l,!0,{submission:n,replace:r}),{shortCircuited:!0}}if(ke(l))throw Le(400,{type:"defer-action"});if(Ce(l)){let e=Pe(o,u.route.id);return!0!==(s&&s.replace)&&(I=r.Push),{matches:o,pendingActionResult:[e.route.id,l]}}return{matches:o,pendingActionResult:[u.route.id,l]}}(m,n,o.submission,l,h.active,{replace:o.replace,flushSync:u});if(t.shortCircuited)return;if(t.pendingActionResult){let[e,r]=t.pendingActionResult;if(Ce(r)&&W(r.error)&&404===r.error.status)return T=null,void Me(n,{matches:t.matches,loaderData:{},errors:{[e]:r.error}})}l=t.matches||l,f=t.pendingActionResult,s=qe(n,o.submission),u=!1,h.active=!1,m=ge(e.history,m.url,m.signal)}let{shortCircuited:y,matches:v,loaderData:g,errors:S}=await async function(r,a,n,o,i,s,l,u,d,h,f){let p=i||qe(a,s),m=s||l||$e(p),y=!(B||R.v7_partialHydration&&d);if(o){if(y){let e=Ue(f);Se(t({navigation:p},void 0!==e?{actionData:e}:{}),{flushSync:h})}let e=await ht(n,a.pathname,r.signal);if("aborted"===e.type)return{shortCircuited:!0};if("error"===e.type){let t=Pe(e.partialMatches).route.id;return{matches:e.partialMatches,loaderData:{},errors:{[t]:e.error}}}if(!e.matches){let{error:e,notFoundMatches:t,route:r}=st(a.pathname);return{matches:t,loaderData:{},errors:{[r.id]:e}}}n=e.matches}let v=c||b,[g,S]=se(e.history,O,n,m,a,R.v7_partialHydration&&!0===d,R.v7_skipActionErrorRevalidation,$,q,K,he,ue,ie,v,w,f);if(lt((e=>!(n&&n.some((t=>t.route.id===e)))||g&&g.some((t=>t.route.id===e)))),re=++J,0===g.length&&0===S.length){let e=rt();return Me(a,t({matches:n,loaderData:{},errors:f&&Ce(f[1])?{[f[0]]:f[1].error}:null},Ee(f),e?{fetchers:new Map(O.fetchers)}:{}),{flushSync:h}),{shortCircuited:!0}}if(y){let e={};if(!o){e.navigation=p;let t=Ue(f);void 0!==t&&(e.actionData=t)}S.length>0&&(e.fetchers=function(e){return e.forEach((e=>{let t=O.fetchers.get(e.key),r=Ye(void 0,t?t.data:void 0);O.fetchers.set(e.key,r)})),new Map(O.fetchers)}(S)),Se(e,{flushSync:h})}S.forEach((e=>{et(e.key),e.controller&&Y.set(e.key,e.controller)}));let D=()=>S.forEach((e=>et(e.key)));T&&T.signal.addEventListener("abort",D);let{loaderResults:E,fetcherResults:P}=await Be(O,n,g,S,r);if(r.signal.aborted)return{shortCircuited:!0};T&&T.signal.removeEventListener("abort",D);S.forEach((e=>Y.delete(e.key)));let x=Ae(E);if(x)return await Oe(r,x.result,!0,{replace:u}),{shortCircuited:!0};if(x=Ae(P),x)return ie.add(x.key),await Oe(r,x.result,!0,{replace:u}),{shortCircuited:!0};let{loaderData:L,errors:A}=De(O,n,E,f,S,P,be);be.forEach(((e,t)=>{e.subscribe((r=>{(r||e.done)&&be.delete(t)}))})),R.v7_partialHydration&&d&&O.errors&&(A=t({},O.errors,A));let M=rt(),j=at(re),k=M||j||S.length>0;return t({matches:n,loaderData:L,errors:A},k?{fetchers:new Map(O.fetchers)}:{})}(m,n,l,h.active,s,o&&o.submission,o&&o.fetcherSubmission,o&&o.replace,o&&!0===o.initialHydration,u,f);y||(T=null,Me(n,t({matches:v||l},Ee(f),{loaderData:g,errors:S})))}function Ue(e){return e&&!Ce(e[1])?{[e[0]]:e[1].data}:O.actionData?0===Object.keys(O.actionData).length?null:O.actionData:void 0}async function Oe(o,l,u,c){let{submission:d,fetcherSubmission:h,preventScrollReset:f,replace:p}=void 0===c?{}:c;l.response.headers.has("X-Remix-Revalidate")&&($=!0);let m=l.response.headers.get("Location");n(m,"Expected a Location header on the redirect Response"),m=ve(m,new URL(o.url),w,e.history);let y=s(O.location,m,{_isRedirect:!0});if(i){let t=!1;if(l.response.headers.has("X-Remix-Reload-Document"))t=!0;else if(Z.test(m)){const r=e.history.createURL(m);t=r.origin!==a.location.origin||null==P(r.pathname,w)}if(t)return void(p?a.location.replace(m):a.location.assign(m))}T=null;let v=!0===p||l.response.headers.has("X-Remix-Replace")?r.Replace:r.Push,{formMethod:g,formAction:b,formEncType:S}=O.navigation;!d&&!h&&g&&b&&S&&(d=$e(O.navigation));let D=d||h;if(V.has(l.response.status)&&D&&He(D.formMethod))await Te(v,y,{submission:t({},D,{formAction:m}),preventScrollReset:f||H,enableViewTransition:u?z:void 0});else{let e=qe(y,d);await Te(v,y,{overrideNavigation:e,fetcherSubmission:h,preventScrollReset:f||H,enableViewTransition:u?z:void 0})}}async function Ie(e,t,r,a,n,o){let i,s={};try{i=await pe(S,e,t,r,a,n,o,g,u)}catch(e){return a.forEach((t=>{s[t.route.id]={type:d.error,error:e}})),s}for(let[e,t]of Object.entries(i))if(je(t)){let a=t.result;s[e]={type:d.redirect,response:ye(a,r,e,n,w,R.v7_relativeSplatPath)}}else s[e]=await me(t);return s}async function Be(t,r,a,n,o){let i=t.matches,s=Ie("loader",t,o,a,r,null),l=Promise.all(n.map((async r=>{if(r.matches&&r.match&&r.controller){let a=(await Ie("loader",t,ge(e.history,r.path,r.controller.signal),[r.match],r.matches,r.key))[r.match.route.id];return{[r.key]:a}}return Promise.resolve({[r.key]:{type:d.error,error:Le(404,{pathname:r.path})}})}))),u=await s,c=(await l).reduce(((e,t)=>Object.assign(e,t)),{});return await Promise.all([ze(r,u,o.signal,i,t.loaderData),Fe(r,c,n)]),{loaderResults:u,fetcherResults:c}}function Ve(){$=!0,q.push(...lt()),ue.forEach(((e,t)=>{Y.has(t)&&K.add(t),et(t)}))}function Xe(e,t,r){void 0===r&&(r={}),O.fetchers.set(e,t),Se({fetchers:new Map(O.fetchers)},{flushSync:!0===(r&&r.flushSync)})}function Ge(e,t,r,a){void 0===a&&(a={});let n=Pe(O.matches,t);Ze(e),Se({errors:{[n.route.id]:r},fetchers:new Map(O.fetchers)},{flushSync:!0===(a&&a.flushSync)})}function Qe(e){return ce.set(e,(ce.get(e)||0)+1),he.has(e)&&he.delete(e),O.fetchers.get(e)||G}function Ze(e){let t=O.fetchers.get(e);!Y.has(e)||t&&"loading"===t.state&&ae.has(e)||et(e),ue.delete(e),ae.delete(e),ie.delete(e),R.v7_fetcherPersist&&he.delete(e),K.delete(e),O.fetchers.delete(e)}function et(e){let t=Y.get(e);t&&(t.abort(),Y.delete(e))}function tt(e){for(let t of e){let e=Je(Qe(t).data);O.fetchers.set(t,e)}}function rt(){let e=[],t=!1;for(let r of ie){let a=O.fetchers.get(r);n(a,"Expected fetcher: "+r),"loading"===a.state&&(ie.delete(r),e.push(r),t=!0)}return tt(e),t}function at(e){let t=[];for(let[r,a]of ae)if(a<e){let e=O.fetchers.get(r);n(e,"Expected fetcher: "+r),"loading"===e.state&&(et(r),ae.delete(r),t.push(r))}return tt(t),t.length>0}function nt(e){O.blockers.delete(e),we.delete(e)}function ot(e,t){let r=O.blockers.get(e)||Q;n("unblocked"===r.state&&"blocked"===t.state||"blocked"===r.state&&"blocked"===t.state||"blocked"===r.state&&"proceeding"===t.state||"blocked"===r.state&&"unblocked"===t.state||"proceeding"===r.state&&"unblocked"===t.state,"Invalid blocker state transition: "+r.state+" -> "+t.state);let a=new Map(O.blockers);a.set(e,t),Se({blockers:a})}function it(e){let{currentLocation:t,nextLocation:r,historyAction:a}=e;if(0===we.size)return;we.size>1&&o(!1,"A router only supports one blocker at a time");let n=Array.from(we.entries()),[i,s]=n[n.length-1],l=O.blockers.get(i);return l&&"proceeding"===l.state?void 0:s({currentLocation:t,nextLocation:r,historyAction:a})?i:void 0}function st(e){let t=Le(404,{pathname:e}),r=c||b,{matches:a,route:n}=xe(r);return lt(),{notFoundMatches:a,route:n,error:t}}function lt(e){let t=[];return be.forEach(((r,a)=>{e&&!e(a)||(r.cancel(),t.push(a),be.delete(a))})),t}function ut(e,t){if(A){return A(e,t.map((e=>y(e,O.loaderData))))||e.key}return e.key}function ct(e,t){if(L){let r=ut(e,t),a=L[r];if("number"==typeof a)return a}return null}function dt(e,t,r){if(D){if(!e){return{active:!0,matches:m(t,r,w,!0)||[]}}if(Object.keys(e[0].params).length>0){return{active:!0,matches:m(t,r,w,!0)}}}return{active:!1,matches:null}}async function ht(e,t,r,a){if(!D)return{type:"success",matches:e};let n=e;for(;;){let e=null==c,o=c||b,i=g;try{await D({signal:r,path:t,matches:n,fetcherKey:a,patch:(e,t)=>{r.aborted||de(e,t,o,i,u)}})}catch(e){return{type:"error",error:e,partialMatches:n}}finally{e&&!r.aborted&&(b=[...b])}if(r.aborted)return{type:"aborted"};let s=p(o,t,w);if(s)return{type:"success",matches:s};let l=m(o,t,w,!0);if(!l||n.length===l.length&&n.every(((e,t)=>e.route.id===l[t].route.id)))return{type:"success",matches:null};n=l}}return v={get basename(){return w},get future(){return R},get state(){return O},get routes(){return b},get window(){return a},initialize:function(){if(E=e.history.listen((t=>{let{action:r,location:a,delta:n}=t;if(U)return U(),void(U=void 0);o(0===we.size||null!=n,"You are trying to use a blocker on a POP navigation to a location that was not created by @remix-run/router. This will fail silently in production. This can happen if you are navigating outside the router via `window.history.pushState`/`window.location.hash` instead of using router navigation APIs.  This can also happen if you are using createHashRouter and the user manually changes the URL.");let i=it({currentLocation:O.location,nextLocation:a,historyAction:r});if(i&&null!=n){let t=new Promise((e=>{U=e}));return e.history.go(-1*n),void ot(i,{state:"blocked",location:a,proceed(){ot(i,{state:"proceeding",proceed:void 0,reset:void 0,location:a}),t.then((()=>e.history.go(n)))},reset(){let e=new Map(O.blockers);e.set(i,Q),Se({blockers:e})}})}return Te(r,a)})),i){!function(e,t){try{let r=e.sessionStorage.getItem(te);if(r){let e=JSON.parse(r);for(let[r,a]of Object.entries(e||{}))a&&Array.isArray(a)&&t.set(r,new Set(a||[]))}}catch(e){}}(a,F);let e=()=>function(e,t){if(t.size>0){let r={};for(let[e,a]of t)r[e]=[...a];try{e.sessionStorage.setItem(te,JSON.stringify(r))}catch(e){o(!1,"Failed to save applied view transitions in sessionStorage ("+e+").")}}}(a,F);a.addEventListener("pagehide",e),N=()=>a.removeEventListener("pagehide",e)}return O.initialized||Te(r.Pop,O.location,{initialHydration:!0}),v},subscribe:function(e){return x.add(e),()=>x.delete(e)},enableScrollRestoration:function(e,t,r){if(L=e,M=t,A=r||null,!j&&O.navigation===X){j=!0;let e=ct(O.location,O.matches);null!=e&&Se({restoreScrollPosition:e})}return()=>{L=null,M=null,A=null}},navigate:async function a(n,o){if("number"==typeof n)return void e.history.go(n);let i=ne(O.location,O.matches,w,R.v7_prependBasename,n,R.v7_relativeSplatPath,null==o?void 0:o.fromRouteId,null==o?void 0:o.relative),{path:l,submission:u,error:c}=oe(R.v7_normalizeFormMethod,!1,i,o),d=O.location,h=s(O.location,l,o&&o.state);h=t({},h,e.history.encodeLocation(h));let f=o&&null!=o.replace?o.replace:void 0,p=r.Push;!0===f?p=r.Replace:!1===f||null!=u&&He(u.formMethod)&&u.formAction===O.location.pathname+O.location.search&&(p=r.Replace);let m=o&&"preventScrollReset"in o?!0===o.preventScrollReset:void 0,y=!0===(o&&o.flushSync),v=it({currentLocation:d,nextLocation:h,historyAction:p});if(!v)return await Te(p,h,{submission:u,pendingError:c,preventScrollReset:m,replace:o&&o.replace,enableViewTransition:o&&o.viewTransition,flushSync:y});ot(v,{state:"blocked",location:h,proceed(){ot(v,{state:"proceeding",proceed:void 0,reset:void 0,location:h}),a(n,o)},reset(){let e=new Map(O.blockers);e.set(v,Q),Se({blockers:e})}})},fetch:function(t,r,a,o){if(l)throw new Error("router.fetch() was called during the server render, but it shouldn't be. You are likely calling a useFetcher() method in the body of your component. Try moving it to a useEffect or a callback.");et(t);let i=!0===(o&&o.flushSync),s=c||b,u=ne(O.location,O.matches,w,R.v7_prependBasename,a,R.v7_relativeSplatPath,r,null==o?void 0:o.relative),d=p(s,u,w),h=dt(d,s,u);if(h.active&&h.matches&&(d=h.matches),!d)return void Ge(t,r,Le(404,{pathname:u}),{flushSync:i});let{path:f,submission:m,error:y}=oe(R.v7_normalizeFormMethod,!0,u,o);if(y)return void Ge(t,r,y,{flushSync:i});let v=We(d,f),g=!0===(o&&o.preventScrollReset);m&&He(m.formMethod)?async function(t,r,a,o,i,s,l,u,d){function h(e){if(!e.route.action&&!e.route.lazy){let e=Le(405,{method:d.formMethod,pathname:a,routeId:r});return Ge(t,r,e,{flushSync:l}),!0}return!1}if(Ve(),ue.delete(t),!s&&h(o))return;let f=O.fetchers.get(t);Xe(t,function(e,t){return{state:"submitting",formMethod:e.formMethod,formAction:e.formAction,formEncType:e.formEncType,formData:e.formData,json:e.json,text:e.text,data:t?t.data:void 0}}(d,f),{flushSync:l});let m=new AbortController,y=ge(e.history,a,m.signal,d);if(s){let e=await ht(i,new URL(y.url).pathname,y.signal,t);if("aborted"===e.type)return;if("error"===e.type)return void Ge(t,r,e.error,{flushSync:l});if(!e.matches)return void Ge(t,r,Le(404,{pathname:a}),{flushSync:l});if(h(o=We(i=e.matches,a)))return}Y.set(t,m);let v=J,g=(await Ie("action",O,y,[o],i,t))[o.route.id];if(y.signal.aborted)return void(Y.get(t)===m&&Y.delete(t));if(R.v7_fetcherPersist&&he.has(t)){if(_e(g)||Ce(g))return void Xe(t,Je(void 0))}else{if(_e(g))return Y.delete(t),re>v?void Xe(t,Je(void 0)):(ie.add(t),Xe(t,Ye(d)),Oe(y,g,!1,{fetcherSubmission:d,preventScrollReset:u}));if(Ce(g))return void Ge(t,r,g.error)}if(ke(g))throw Le(400,{type:"defer-action"});let S=O.navigation.location||O.location,D=ge(e.history,S,m.signal),E=c||b,P="idle"!==O.navigation.state?p(E,O.navigation.location,w):O.matches;n(P,"Didn't find any matches after fetcher action");let x=++J;ae.set(t,x);let L=Ye(d,g.data);O.fetchers.set(t,L);let[A,M]=se(e.history,O,P,d,S,!1,R.v7_skipActionErrorRevalidation,$,q,K,he,ue,ie,E,w,[o.route.id,g]);M.filter((e=>e.key!==t)).forEach((e=>{let t=e.key,r=O.fetchers.get(t),a=Ye(void 0,r?r.data:void 0);O.fetchers.set(t,a),et(t),e.controller&&Y.set(t,e.controller)})),Se({fetchers:new Map(O.fetchers)});let j=()=>M.forEach((e=>et(e.key)));m.signal.addEventListener("abort",j);let{loaderResults:k,fetcherResults:C}=await Be(O,P,A,M,D);if(m.signal.aborted)return;m.signal.removeEventListener("abort",j),ae.delete(t),Y.delete(t),M.forEach((e=>Y.delete(e.key)));let _=Ae(k);if(_)return Oe(D,_.result,!1,{preventScrollReset:u});if(_=Ae(C),_)return ie.add(_.key),Oe(D,_.result,!1,{preventScrollReset:u});let{loaderData:U,errors:H}=De(O,P,k,void 0,M,C,be);if(O.fetchers.has(t)){let e=Je(g.data);O.fetchers.set(t,e)}at(x),"loading"===O.navigation.state&&x>re?(n(I,"Expected pending action"),T&&T.abort(),Me(O.navigation.location,{matches:P,loaderData:U,errors:H,fetchers:new Map(O.fetchers)})):(Se({errors:H,loaderData:Re(O.loaderData,U,P,H),fetchers:new Map(O.fetchers)}),$=!1)}(t,r,f,v,d,h.active,i,g,m):(ue.set(t,{routeId:r,path:f}),async function(t,r,a,o,i,s,l,u,c){let d=O.fetchers.get(t);Xe(t,Ye(c,d?d.data:void 0),{flushSync:l});let h=new AbortController,f=ge(e.history,a,h.signal);if(s){let e=await ht(i,new URL(f.url).pathname,f.signal,t);if("aborted"===e.type)return;if("error"===e.type)return void Ge(t,r,e.error,{flushSync:l});if(!e.matches)return void Ge(t,r,Le(404,{pathname:a}),{flushSync:l});o=We(i=e.matches,a)}Y.set(t,h);let p=J,m=(await Ie("loader",O,f,[o],i,t))[o.route.id];ke(m)&&(m=await Ne(m,f.signal,!0)||m);Y.get(t)===h&&Y.delete(t);if(f.signal.aborted)return;if(he.has(t))return void Xe(t,Je(void 0));if(_e(m))return re>p?void Xe(t,Je(void 0)):(ie.add(t),void await Oe(f,m,!1,{preventScrollReset:u}));if(Ce(m))return void Ge(t,r,m.error);n(!ke(m),"Unhandled fetcher deferred data"),Xe(t,Je(m.data))}(t,r,f,v,d,h.active,i,g,m))},revalidate:function(){Ve(),Se({revalidation:"loading"}),"submitting"!==O.navigation.state&&("idle"!==O.navigation.state?Te(I||O.historyAction,O.navigation.location,{overrideNavigation:O.navigation,enableViewTransition:!0===z}):Te(O.historyAction,O.location,{startUninterruptedRevalidation:!0}))},createHref:t=>e.history.createHref(t),encodeLocation:t=>e.history.encodeLocation(t),getFetcher:Qe,deleteFetcher:function(e){let t=(ce.get(e)||0)-1;t<=0?(ce.delete(e),he.add(e),R.v7_fetcherPersist||Ze(e)):ce.set(e,t),Se({fetchers:new Map(O.fetchers)})},dispose:function(){E&&E(),N&&N(),x.clear(),T&&T.abort(),O.fetchers.forEach(((e,t)=>Ze(t))),O.blockers.forEach(((e,t)=>nt(t)))},getBlocker:function(e,t){let r=O.blockers.get(e)||Q;return we.get(e)!==t&&we.set(e,t),r},deleteBlocker:nt,patchRoutes:function(e,t){let r=null==c;de(e,t,c||b,g,u),r&&(b=[...b],Se({}))},_internalFetchControllers:Y,_internalActiveDeferreds:be,_internalSetRoutes:function(e){g={},c=f(e,u,void 0,g)}},v},e.createStaticHandler=function(e,r){n(e.length>0,"You must provide a non-empty routes array to createStaticHandler");let a,o={},i=(r?r.basename:null)||"/";if(null!=r&&r.mapRouteProperties)a=r.mapRouteProperties;else if(null!=r&&r.detectErrorBoundary){let e=r.detectErrorBoundary;a=t=>({hasErrorBoundary:e(t)})}else a=ee;let u=t({v7_relativeSplatPath:!1,v7_throwAbortReason:!1},r?r.future:null),c=f(e,a,void 0,o);async function h(e,r,a,o,i,s,l){n(e.signal,"query()/queryRoute() requests must contain an AbortController signal");try{if(He(e.method.toLowerCase())){let n=await async function(e,r,a,n,o,i,s){let l;if(a.route.action||a.route.lazy){l=(await y("action",e,[a],r,s,n,o))[a.route.id],e.signal.aborted&&ae(e,s,u)}else{let t=Le(405,{method:e.method,pathname:new URL(e.url).pathname,routeId:a.route.id});if(s)throw t;l={type:d.error,error:t}}if(_e(l))throw new Response(null,{status:l.response.status,headers:{Location:l.response.headers.get("Location")}});if(ke(l)){let e=Le(400,{type:"defer-action"});if(s)throw e;l={type:d.error,error:e}}if(s){if(Ce(l))throw l.error;return{matches:[a],loaderData:{},actionData:{[a.route.id]:l.data},errors:null,statusCode:200,loaderHeaders:{},actionHeaders:{},activeDeferreds:null}}let c=new Request(e.url,{headers:e.headers,redirect:e.redirect,signal:e.signal});if(Ce(l)){let e=i?a:Pe(r,a.route.id);return t({},await m(c,r,n,o,i,null,[e.route.id,l]),{statusCode:W(l.error)?l.error.status:null!=l.statusCode?l.statusCode:500,actionData:null,actionHeaders:t({},l.headers?{[a.route.id]:l.headers}:{})})}return t({},await m(c,r,n,o,i,null),{actionData:{[a.route.id]:l.data}},l.statusCode?{statusCode:l.statusCode}:{},{actionHeaders:l.headers?{[a.route.id]:l.headers}:{}})}(e,a,l||We(a,r),o,i,s,null!=l);return n}let n=await m(e,a,o,i,s,l);return Oe(n)?n:t({},n,{actionData:null,actionHeaders:{}})}catch(e){if(function(e){return null!=e&&"object"==typeof e&&"type"in e&&"result"in e&&(e.type===d.data||e.type===d.error)}(e)&&Oe(e.result)){if(e.type===d.error)throw e.result;return e.result}if(function(e){if(!Oe(e))return!1;let t=e.status,r=e.headers.get("Location");return t>=300&&t<=399&&null!=r}(e))return e;throw e}}async function m(e,r,a,n,o,i,s){let l=null!=i;if(l&&(null==i||!i.route.loader)&&(null==i||!i.route.lazy))throw Le(400,{method:e.method,pathname:new URL(e.url).pathname,routeId:null==i?void 0:i.route.id});let c=(i?[i]:s&&Ce(s[1])?ie(r,s[0]):r).filter((e=>e.route.loader||e.route.lazy));if(0===c.length)return{matches:r,loaderData:r.reduce(((e,t)=>Object.assign(e,{[t.route.id]:null})),{}),errors:s&&Ce(s[1])?{[s[0]]:s[1].error}:null,statusCode:200,loaderHeaders:{},activeDeferreds:null};let d=await y("loader",e,c,r,l,a,n);e.signal.aborted&&ae(e,l,u);let h=new Map,f=Se(r,d,s,h,o),p=new Set(c.map((e=>e.route.id)));return r.forEach((e=>{p.has(e.route.id)||(f.loaderData[e.route.id]=null)})),t({},f,{matches:r,activeDeferreds:h.size>0?Object.fromEntries(h.entries()):null})}async function y(e,t,r,n,s,l,c){let d=await pe(c||fe,e,null,t,r,n,null,o,a,l),h={};return await Promise.all(n.map((async e=>{if(!(e.route.id in d))return;let r=d[e.route.id];if(je(r)){throw ye(r.result,t,e.route.id,n,i,u.v7_relativeSplatPath)}if(Oe(r.result)&&s)throw r;h[e.route.id]=await me(r)}))),h}return{dataRoutes:c,query:async function(e,r){let{requestContext:a,skipLoaderErrorBubbling:n,dataStrategy:o}=void 0===r?{}:r,u=new URL(e.url),d=e.method,f=s("",l(u),null,"default"),m=p(c,f,i);if(!Ie(d)&&"HEAD"!==d){let e=Le(405,{method:d}),{matches:t,route:r}=xe(c);return{basename:i,location:f,matches:t,loaderData:{},actionData:null,errors:{[r.id]:e},statusCode:e.status,loaderHeaders:{},actionHeaders:{},activeDeferreds:null}}if(!m){let e=Le(404,{pathname:f.pathname}),{matches:t,route:r}=xe(c);return{basename:i,location:f,matches:t,loaderData:{},actionData:null,errors:{[r.id]:e},statusCode:e.status,loaderHeaders:{},actionHeaders:{},activeDeferreds:null}}let y=await h(e,f,m,a,o||null,!0===n,null);return Oe(y)?y:t({location:f,basename:i},y)},queryRoute:async function(e,t){let{routeId:r,requestContext:a,dataStrategy:n}=void 0===t?{}:t,o=new URL(e.url),u=e.method,d=s("",l(o),null,"default"),f=p(c,d,i);if(!Ie(u)&&"HEAD"!==u&&"OPTIONS"!==u)throw Le(405,{method:u});if(!f)throw Le(404,{pathname:d.pathname});let m=r?f.find((e=>e.route.id===r)):We(f,d);if(r&&!m)throw Le(403,{pathname:d.pathname,routeId:r});if(!m)throw Le(404,{pathname:d.pathname});let y=await h(e,d,f,a,n||null,!1,m);if(Oe(y))return y;let v=y.errors?Object.values(y.errors)[0]:void 0;if(void 0!==v)throw v;if(y.actionData)return Object.values(y.actionData)[0];if(y.loaderData){var g;let e=Object.values(y.loaderData)[0];return null!=(g=y.activeDeferreds)&&g[m.route.id]&&(e[re]=y.activeDeferreds[m.route.id]),e}}}},e.data=function(e,t){return new I(e,"number"==typeof t?{status:t}:t)},e.defer=function(e,t){return void 0===t&&(t={}),new z(e,"number"==typeof t?{status:t}:t)},e.generatePath=function(e,t){void 0===t&&(t={});let r=e;r.endsWith("*")&&"*"!==r&&!r.endsWith("/*")&&(o(!1,'Route path "'+r+'" will be treated as if it were "'+r.replace(/\*$/,"/*")+'" because the `*` character must always follow a `/` in the pattern. To get rid of this warning, please change the route path to "'+r.replace(/\*$/,"/*")+'".'),r=r.replace(/\*$/,"/*"));const a=r.startsWith("/")?"/":"",i=e=>null==e?"":"string"==typeof e?e:String(e);return a+r.split(/\/+/).map(((e,r,a)=>{if(r===a.length-1&&"*"===e){return i(t["*"])}const o=e.match(/^:([\w-]+)(\??)$/);if(o){const[,e,r]=o;let a=t[e];return n("?"===r||null!=a,'Missing ":'+e+'" param'),i(a)}return e.replace(/\?$/g,"")})).filter((e=>!!e)).join("/")},e.getStaticContextFromError=function(e,r,a){return t({},r,{statusCode:W(a)?a.status:500,errors:{[r._deepestRenderedBoundaryId||e[0].id]:a}})},e.getToPathname=function(e){return""===e||""===e.pathname?"/":"string"==typeof e?u(e).pathname:e.pathname},e.isDataWithResponseInit=Te,e.isDeferredData=Ue,e.isRouteErrorResponse=W,e.joinPaths=_,e.json=function(e,r){void 0===r&&(r={});let a="number"==typeof r?{status:r}:r,n=new Headers(a.headers);return n.has("Content-Type")||n.set("Content-Type","application/json; charset=utf-8"),new Response(JSON.stringify(e),t({},a,{headers:n}))},e.matchPath=R,e.matchRoutes=p,e.normalizePathname=T,e.parsePath=u,e.redirect=N,e.redirectDocument=(e,t)=>{let r=N(e,t);return r.headers.set("X-Remix-Reload-Document","true"),r},e.replace=(e,t)=>{let r=N(e,t);return r.headers.set("X-Remix-Replace","true"),r},e.resolvePath=L,e.resolveTo=C,e.stripBasename=P,Object.defineProperty(e,"__esModule",{value:!0})}));
+//# sourceMappingURL=router.umd.min.js.map
Index: frontend/node_modules/@remix-run/router/dist/router.umd.min.js.map
===================================================================
--- frontend/node_modules/@remix-run/router/dist/router.umd.min.js.map	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/@remix-run/router/dist/router.umd.min.js.map	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,1 @@
+{"version":3,"file":"router.umd.min.js","sources":["../history.ts","../utils.ts","../router.ts"],"sourcesContent":["////////////////////////////////////////////////////////////////////////////////\n//#region Types and Constants\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * Actions represent the type of change to a location value.\n */\nexport enum Action {\n  /**\n   * A POP indicates a change to an arbitrary index in the history stack, such\n   * as a back or forward navigation. It does not describe the direction of the\n   * navigation, only that the current index changed.\n   *\n   * Note: This is the default action for newly created history objects.\n   */\n  Pop = \"POP\",\n\n  /**\n   * A PUSH indicates a new entry being added to the history stack, such as when\n   * a link is clicked and a new page loads. When this happens, all subsequent\n   * entries in the stack are lost.\n   */\n  Push = \"PUSH\",\n\n  /**\n   * A REPLACE indicates the entry at the current index in the history stack\n   * being replaced by a new one.\n   */\n  Replace = \"REPLACE\",\n}\n\n/**\n * The pathname, search, and hash values of a URL.\n */\nexport interface Path {\n  /**\n   * A URL pathname, beginning with a /.\n   */\n  pathname: string;\n\n  /**\n   * A URL search string, beginning with a ?.\n   */\n  search: string;\n\n  /**\n   * A URL fragment identifier, beginning with a #.\n   */\n  hash: string;\n}\n\n// TODO: (v7) Change the Location generic default from `any` to `unknown` and\n// remove Remix `useLocation` wrapper.\n\n/**\n * An entry in a history stack. A location contains information about the\n * URL path, as well as possibly some arbitrary state and a key.\n */\nexport interface Location<State = any> extends Path {\n  /**\n   * A value of arbitrary data associated with this location.\n   */\n  state: State;\n\n  /**\n   * A unique string associated with this location. May be used to safely store\n   * and retrieve data in some other storage API, like `localStorage`.\n   *\n   * Note: This value is always \"default\" on the initial location.\n   */\n  key: string;\n}\n\n/**\n * A change to the current location.\n */\nexport interface Update {\n  /**\n   * The action that triggered the change.\n   */\n  action: Action;\n\n  /**\n   * The new location.\n   */\n  location: Location;\n\n  /**\n   * The delta between this location and the former location in the history stack\n   */\n  delta: number | null;\n}\n\n/**\n * A function that receives notifications about location changes.\n */\nexport interface Listener {\n  (update: Update): void;\n}\n\n/**\n * Describes a location that is the destination of some navigation, either via\n * `history.push` or `history.replace`. This may be either a URL or the pieces\n * of a URL path.\n */\nexport type To = string | Partial<Path>;\n\n/**\n * A history is an interface to the navigation stack. The history serves as the\n * source of truth for the current location, as well as provides a set of\n * methods that may be used to change it.\n *\n * It is similar to the DOM's `window.history` object, but with a smaller, more\n * focused API.\n */\nexport interface History {\n  /**\n   * The last action that modified the current location. This will always be\n   * Action.Pop when a history instance is first created. This value is mutable.\n   */\n  readonly action: Action;\n\n  /**\n   * The current location. This value is mutable.\n   */\n  readonly location: Location;\n\n  /**\n   * Returns a valid href for the given `to` value that may be used as\n   * the value of an <a href> attribute.\n   *\n   * @param to - The destination URL\n   */\n  createHref(to: To): string;\n\n  /**\n   * Returns a URL for the given `to` value\n   *\n   * @param to - The destination URL\n   */\n  createURL(to: To): URL;\n\n  /**\n   * Encode a location the same way window.history would do (no-op for memory\n   * history) so we ensure our PUSH/REPLACE navigations for data routers\n   * behave the same as POP\n   *\n   * @param to Unencoded path\n   */\n  encodeLocation(to: To): Path;\n\n  /**\n   * Pushes a new location onto the history stack, increasing its length by one.\n   * If there were any entries in the stack after the current one, they are\n   * lost.\n   *\n   * @param to - The new URL\n   * @param state - Data to associate with the new location\n   */\n  push(to: To, state?: any): void;\n\n  /**\n   * Replaces the current location in the history stack with a new one.  The\n   * location that was replaced will no longer be available.\n   *\n   * @param to - The new URL\n   * @param state - Data to associate with the new location\n   */\n  replace(to: To, state?: any): void;\n\n  /**\n   * Navigates `n` entries backward/forward in the history stack relative to the\n   * current index. For example, a \"back\" navigation would use go(-1).\n   *\n   * @param delta - The delta in the stack index\n   */\n  go(delta: number): void;\n\n  /**\n   * Sets up a listener that will be called whenever the current location\n   * changes.\n   *\n   * @param listener - A function that will be called when the location changes\n   * @returns unlisten - A function that may be used to stop listening\n   */\n  listen(listener: Listener): () => void;\n}\n\ntype HistoryState = {\n  usr: any;\n  key?: string;\n  idx: number;\n};\n\nconst PopStateEventType = \"popstate\";\n//#endregion\n\n////////////////////////////////////////////////////////////////////////////////\n//#region Memory History\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * A user-supplied object that describes a location. Used when providing\n * entries to `createMemoryHistory` via its `initialEntries` option.\n */\nexport type InitialEntry = string | Partial<Location>;\n\nexport type MemoryHistoryOptions = {\n  initialEntries?: InitialEntry[];\n  initialIndex?: number;\n  v5Compat?: boolean;\n};\n\n/**\n * A memory history stores locations in memory. This is useful in stateful\n * environments where there is no web browser, such as node tests or React\n * Native.\n */\nexport interface MemoryHistory extends History {\n  /**\n   * The current index in the history stack.\n   */\n  readonly index: number;\n}\n\n/**\n * Memory history stores the current location in memory. It is designed for use\n * in stateful non-browser environments like tests and React Native.\n */\nexport function createMemoryHistory(\n  options: MemoryHistoryOptions = {}\n): MemoryHistory {\n  let { initialEntries = [\"/\"], initialIndex, v5Compat = false } = options;\n  let entries: Location[]; // Declare so we can access from createMemoryLocation\n  entries = initialEntries.map((entry, index) =>\n    createMemoryLocation(\n      entry,\n      typeof entry === \"string\" ? null : entry.state,\n      index === 0 ? \"default\" : undefined\n    )\n  );\n  let index = clampIndex(\n    initialIndex == null ? entries.length - 1 : initialIndex\n  );\n  let action = Action.Pop;\n  let listener: Listener | null = null;\n\n  function clampIndex(n: number): number {\n    return Math.min(Math.max(n, 0), entries.length - 1);\n  }\n  function getCurrentLocation(): Location {\n    return entries[index];\n  }\n  function createMemoryLocation(\n    to: To,\n    state: any = null,\n    key?: string\n  ): Location {\n    let location = createLocation(\n      entries ? getCurrentLocation().pathname : \"/\",\n      to,\n      state,\n      key\n    );\n    warning(\n      location.pathname.charAt(0) === \"/\",\n      `relative pathnames are not supported in memory history: ${JSON.stringify(\n        to\n      )}`\n    );\n    return location;\n  }\n\n  function createHref(to: To) {\n    return typeof to === \"string\" ? to : createPath(to);\n  }\n\n  let history: MemoryHistory = {\n    get index() {\n      return index;\n    },\n    get action() {\n      return action;\n    },\n    get location() {\n      return getCurrentLocation();\n    },\n    createHref,\n    createURL(to) {\n      return new URL(createHref(to), \"http://localhost\");\n    },\n    encodeLocation(to: To) {\n      let path = typeof to === \"string\" ? parsePath(to) : to;\n      return {\n        pathname: path.pathname || \"\",\n        search: path.search || \"\",\n        hash: path.hash || \"\",\n      };\n    },\n    push(to, state) {\n      action = Action.Push;\n      let nextLocation = createMemoryLocation(to, state);\n      index += 1;\n      entries.splice(index, entries.length, nextLocation);\n      if (v5Compat && listener) {\n        listener({ action, location: nextLocation, delta: 1 });\n      }\n    },\n    replace(to, state) {\n      action = Action.Replace;\n      let nextLocation = createMemoryLocation(to, state);\n      entries[index] = nextLocation;\n      if (v5Compat && listener) {\n        listener({ action, location: nextLocation, delta: 0 });\n      }\n    },\n    go(delta) {\n      action = Action.Pop;\n      let nextIndex = clampIndex(index + delta);\n      let nextLocation = entries[nextIndex];\n      index = nextIndex;\n      if (listener) {\n        listener({ action, location: nextLocation, delta });\n      }\n    },\n    listen(fn: Listener) {\n      listener = fn;\n      return () => {\n        listener = null;\n      };\n    },\n  };\n\n  return history;\n}\n//#endregion\n\n////////////////////////////////////////////////////////////////////////////////\n//#region Browser History\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * A browser history stores the current location in regular URLs in a web\n * browser environment. This is the standard for most web apps and provides the\n * cleanest URLs the browser's address bar.\n *\n * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#browserhistory\n */\nexport interface BrowserHistory extends UrlHistory {}\n\nexport type BrowserHistoryOptions = UrlHistoryOptions;\n\n/**\n * Browser history stores the location in regular URLs. This is the standard for\n * most web apps, but it requires some configuration on the server to ensure you\n * serve the same app at multiple URLs.\n *\n * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createbrowserhistory\n */\nexport function createBrowserHistory(\n  options: BrowserHistoryOptions = {}\n): BrowserHistory {\n  function createBrowserLocation(\n    window: Window,\n    globalHistory: Window[\"history\"]\n  ) {\n    let { pathname, search, hash } = window.location;\n    return createLocation(\n      \"\",\n      { pathname, search, hash },\n      // state defaults to `null` because `window.history.state` does\n      (globalHistory.state && globalHistory.state.usr) || null,\n      (globalHistory.state && globalHistory.state.key) || \"default\"\n    );\n  }\n\n  function createBrowserHref(window: Window, to: To) {\n    return typeof to === \"string\" ? to : createPath(to);\n  }\n\n  return getUrlBasedHistory(\n    createBrowserLocation,\n    createBrowserHref,\n    null,\n    options\n  );\n}\n//#endregion\n\n////////////////////////////////////////////////////////////////////////////////\n//#region Hash History\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * A hash history stores the current location in the fragment identifier portion\n * of the URL in a web browser environment.\n *\n * This is ideal for apps that do not control the server for some reason\n * (because the fragment identifier is never sent to the server), including some\n * shared hosting environments that do not provide fine-grained controls over\n * which pages are served at which URLs.\n *\n * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#hashhistory\n */\nexport interface HashHistory extends UrlHistory {}\n\nexport type HashHistoryOptions = UrlHistoryOptions;\n\n/**\n * Hash history stores the location in window.location.hash. This makes it ideal\n * for situations where you don't want to send the location to the server for\n * some reason, either because you do cannot configure it or the URL space is\n * reserved for something else.\n *\n * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createhashhistory\n */\nexport function createHashHistory(\n  options: HashHistoryOptions = {}\n): HashHistory {\n  function createHashLocation(\n    window: Window,\n    globalHistory: Window[\"history\"]\n  ) {\n    let {\n      pathname = \"/\",\n      search = \"\",\n      hash = \"\",\n    } = parsePath(window.location.hash.substr(1));\n\n    // Hash URL should always have a leading / just like window.location.pathname\n    // does, so if an app ends up at a route like /#something then we add a\n    // leading slash so all of our path-matching behaves the same as if it would\n    // in a browser router.  This is particularly important when there exists a\n    // root splat route (<Route path=\"*\">) since that matches internally against\n    // \"/*\" and we'd expect /#something to 404 in a hash router app.\n    if (!pathname.startsWith(\"/\") && !pathname.startsWith(\".\")) {\n      pathname = \"/\" + pathname;\n    }\n\n    return createLocation(\n      \"\",\n      { pathname, search, hash },\n      // state defaults to `null` because `window.history.state` does\n      (globalHistory.state && globalHistory.state.usr) || null,\n      (globalHistory.state && globalHistory.state.key) || \"default\"\n    );\n  }\n\n  function createHashHref(window: Window, to: To) {\n    let base = window.document.querySelector(\"base\");\n    let href = \"\";\n\n    if (base && base.getAttribute(\"href\")) {\n      let url = window.location.href;\n      let hashIndex = url.indexOf(\"#\");\n      href = hashIndex === -1 ? url : url.slice(0, hashIndex);\n    }\n\n    return href + \"#\" + (typeof to === \"string\" ? to : createPath(to));\n  }\n\n  function validateHashLocation(location: Location, to: To) {\n    warning(\n      location.pathname.charAt(0) === \"/\",\n      `relative pathnames are not supported in hash history.push(${JSON.stringify(\n        to\n      )})`\n    );\n  }\n\n  return getUrlBasedHistory(\n    createHashLocation,\n    createHashHref,\n    validateHashLocation,\n    options\n  );\n}\n//#endregion\n\n////////////////////////////////////////////////////////////////////////////////\n//#region UTILS\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * @private\n */\nexport function invariant(value: boolean, message?: string): asserts value;\nexport function invariant<T>(\n  value: T | null | undefined,\n  message?: string\n): asserts value is T;\nexport function invariant(value: any, message?: string) {\n  if (value === false || value === null || typeof value === \"undefined\") {\n    throw new Error(message);\n  }\n}\n\nexport function warning(cond: any, message: string) {\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 history!\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\nfunction createKey() {\n  return Math.random().toString(36).substr(2, 8);\n}\n\n/**\n * For browser-based histories, we combine the state and key into an object\n */\nfunction getHistoryState(location: Location, index: number): HistoryState {\n  return {\n    usr: location.state,\n    key: location.key,\n    idx: index,\n  };\n}\n\n/**\n * Creates a Location object with a unique key from the given Path\n */\nexport function createLocation(\n  current: string | Location,\n  to: To,\n  state: any = null,\n  key?: string\n): Readonly<Location> {\n  let location: Readonly<Location> = {\n    pathname: typeof current === \"string\" ? current : current.pathname,\n    search: \"\",\n    hash: \"\",\n    ...(typeof to === \"string\" ? parsePath(to) : to),\n    state,\n    // TODO: This could be cleaned up.  push/replace should probably just take\n    // full Locations now and avoid the need to run through this flow at all\n    // But that's a pretty big refactor to the current test suite so going to\n    // keep as is for the time being and just let any incoming keys take precedence\n    key: (to && (to as Location).key) || key || createKey(),\n  };\n  return location;\n}\n\n/**\n * Creates a string URL path from the given pathname, search, and hash components.\n */\nexport function createPath({\n  pathname = \"/\",\n  search = \"\",\n  hash = \"\",\n}: Partial<Path>) {\n  if (search && search !== \"?\")\n    pathname += search.charAt(0) === \"?\" ? search : \"?\" + search;\n  if (hash && hash !== \"#\")\n    pathname += hash.charAt(0) === \"#\" ? hash : \"#\" + hash;\n  return pathname;\n}\n\n/**\n * Parses a string URL path into its separate pathname, search, and hash components.\n */\nexport function parsePath(path: string): Partial<Path> {\n  let parsedPath: Partial<Path> = {};\n\n  if (path) {\n    let hashIndex = path.indexOf(\"#\");\n    if (hashIndex >= 0) {\n      parsedPath.hash = path.substr(hashIndex);\n      path = path.substr(0, hashIndex);\n    }\n\n    let searchIndex = path.indexOf(\"?\");\n    if (searchIndex >= 0) {\n      parsedPath.search = path.substr(searchIndex);\n      path = path.substr(0, searchIndex);\n    }\n\n    if (path) {\n      parsedPath.pathname = path;\n    }\n  }\n\n  return parsedPath;\n}\n\nexport interface UrlHistory extends History {}\n\nexport type UrlHistoryOptions = {\n  window?: Window;\n  v5Compat?: boolean;\n};\n\nfunction getUrlBasedHistory(\n  getLocation: (window: Window, globalHistory: Window[\"history\"]) => Location,\n  createHref: (window: Window, to: To) => string,\n  validateLocation: ((location: Location, to: To) => void) | null,\n  options: UrlHistoryOptions = {}\n): UrlHistory {\n  let { window = document.defaultView!, v5Compat = false } = options;\n  let globalHistory = window.history;\n  let action = Action.Pop;\n  let listener: Listener | null = null;\n\n  let index = getIndex()!;\n  // Index should only be null when we initialize. If not, it's because the\n  // user called history.pushState or history.replaceState directly, in which\n  // case we should log a warning as it will result in bugs.\n  if (index == null) {\n    index = 0;\n    globalHistory.replaceState({ ...globalHistory.state, idx: index }, \"\");\n  }\n\n  function getIndex(): number {\n    let state = globalHistory.state || { idx: null };\n    return state.idx;\n  }\n\n  function handlePop() {\n    action = Action.Pop;\n    let nextIndex = getIndex();\n    let delta = nextIndex == null ? null : nextIndex - index;\n    index = nextIndex;\n    if (listener) {\n      listener({ action, location: history.location, delta });\n    }\n  }\n\n  function push(to: To, state?: any) {\n    action = Action.Push;\n    let location = createLocation(history.location, to, state);\n    if (validateLocation) validateLocation(location, to);\n\n    index = getIndex() + 1;\n    let historyState = getHistoryState(location, index);\n    let url = history.createHref(location);\n\n    // try...catch because iOS limits us to 100 pushState calls :/\n    try {\n      globalHistory.pushState(historyState, \"\", url);\n    } catch (error) {\n      // If the exception is because `state` can't be serialized, let that throw\n      // outwards just like a replace call would so the dev knows the cause\n      // https://html.spec.whatwg.org/multipage/nav-history-apis.html#shared-history-push/replace-state-steps\n      // https://html.spec.whatwg.org/multipage/structured-data.html#structuredserializeinternal\n      if (error instanceof DOMException && error.name === \"DataCloneError\") {\n        throw error;\n      }\n      // They are going to lose state here, but there is no real\n      // way to warn them about it since the page will refresh...\n      window.location.assign(url);\n    }\n\n    if (v5Compat && listener) {\n      listener({ action, location: history.location, delta: 1 });\n    }\n  }\n\n  function replace(to: To, state?: any) {\n    action = Action.Replace;\n    let location = createLocation(history.location, to, state);\n    if (validateLocation) validateLocation(location, to);\n\n    index = getIndex();\n    let historyState = getHistoryState(location, index);\n    let url = history.createHref(location);\n    globalHistory.replaceState(historyState, \"\", url);\n\n    if (v5Compat && listener) {\n      listener({ action, location: history.location, delta: 0 });\n    }\n  }\n\n  function createURL(to: To): URL {\n    // window.location.origin is \"null\" (the literal string value) in Firefox\n    // under certain conditions, notably when serving from a local HTML file\n    // See https://bugzilla.mozilla.org/show_bug.cgi?id=878297\n    let base =\n      window.location.origin !== \"null\"\n        ? window.location.origin\n        : window.location.href;\n\n    let href = typeof to === \"string\" ? to : createPath(to);\n    // Treating this as a full URL will strip any trailing spaces so we need to\n    // pre-encode them since they might be part of a matching splat param from\n    // an ancestor route\n    href = href.replace(/ $/, \"%20\");\n    invariant(\n      base,\n      `No window.location.(origin|href) available to create URL for href: ${href}`\n    );\n    return new URL(href, base);\n  }\n\n  let history: History = {\n    get action() {\n      return action;\n    },\n    get location() {\n      return getLocation(window, globalHistory);\n    },\n    listen(fn: Listener) {\n      if (listener) {\n        throw new Error(\"A history only accepts one active listener\");\n      }\n      window.addEventListener(PopStateEventType, handlePop);\n      listener = fn;\n\n      return () => {\n        window.removeEventListener(PopStateEventType, handlePop);\n        listener = null;\n      };\n    },\n    createHref(to) {\n      return createHref(window, to);\n    },\n    createURL,\n    encodeLocation(to) {\n      // Encode a Location the same way window.location would\n      let url = createURL(to);\n      return {\n        pathname: url.pathname,\n        search: url.search,\n        hash: url.hash,\n      };\n    },\n    push,\n    replace,\n    go(n) {\n      return globalHistory.go(n);\n    },\n  };\n\n  return history;\n}\n\n//#endregion\n","import type { Location, Path, To } from \"./history\";\nimport { invariant, parsePath, warning } from \"./history\";\n\n/**\n * Map of routeId -> data returned from a loader/action/error\n */\nexport interface RouteData {\n  [routeId: string]: any;\n}\n\nexport enum ResultType {\n  data = \"data\",\n  deferred = \"deferred\",\n  redirect = \"redirect\",\n  error = \"error\",\n}\n\n/**\n * Successful result from a loader or action\n */\nexport interface SuccessResult {\n  type: ResultType.data;\n  data: unknown;\n  statusCode?: number;\n  headers?: Headers;\n}\n\n/**\n * Successful defer() result from a loader or action\n */\nexport interface DeferredResult {\n  type: ResultType.deferred;\n  deferredData: DeferredData;\n  statusCode?: number;\n  headers?: Headers;\n}\n\n/**\n * Redirect result from a loader or action\n */\nexport interface RedirectResult {\n  type: ResultType.redirect;\n  // We keep the raw Response for redirects so we can return it verbatim\n  response: Response;\n}\n\n/**\n * Unsuccessful result from a loader or action\n */\nexport interface ErrorResult {\n  type: ResultType.error;\n  error: unknown;\n  statusCode?: number;\n  headers?: Headers;\n}\n\n/**\n * Result from a loader or action - potentially successful or unsuccessful\n */\nexport type DataResult =\n  | SuccessResult\n  | DeferredResult\n  | RedirectResult\n  | ErrorResult;\n\ntype LowerCaseFormMethod = \"get\" | \"post\" | \"put\" | \"patch\" | \"delete\";\ntype UpperCaseFormMethod = Uppercase<LowerCaseFormMethod>;\n\n/**\n * Users can specify either lowercase or uppercase form methods on `<Form>`,\n * useSubmit(), `<fetcher.Form>`, etc.\n */\nexport type HTMLFormMethod = LowerCaseFormMethod | UpperCaseFormMethod;\n\n/**\n * Active navigation/fetcher form methods are exposed in lowercase on the\n * RouterState\n */\nexport type FormMethod = LowerCaseFormMethod;\nexport type MutationFormMethod = Exclude<FormMethod, \"get\">;\n\n/**\n * In v7, active navigation/fetcher form methods are exposed in uppercase on the\n * RouterState.  This is to align with the normalization done via fetch().\n */\nexport type V7_FormMethod = UpperCaseFormMethod;\nexport type V7_MutationFormMethod = Exclude<V7_FormMethod, \"GET\">;\n\nexport type FormEncType =\n  | \"application/x-www-form-urlencoded\"\n  | \"multipart/form-data\"\n  | \"application/json\"\n  | \"text/plain\";\n\n// Thanks https://github.com/sindresorhus/type-fest!\ntype JsonObject = { [Key in string]: JsonValue } & {\n  [Key in string]?: JsonValue | undefined;\n};\ntype JsonArray = JsonValue[] | readonly JsonValue[];\ntype JsonPrimitive = string | number | boolean | null;\ntype JsonValue = JsonPrimitive | JsonObject | JsonArray;\n\n/**\n * @private\n * Internal interface to pass around for action submissions, not intended for\n * external consumption\n */\nexport type Submission =\n  | {\n      formMethod: FormMethod | V7_FormMethod;\n      formAction: string;\n      formEncType: FormEncType;\n      formData: FormData;\n      json: undefined;\n      text: undefined;\n    }\n  | {\n      formMethod: FormMethod | V7_FormMethod;\n      formAction: string;\n      formEncType: FormEncType;\n      formData: undefined;\n      json: JsonValue;\n      text: undefined;\n    }\n  | {\n      formMethod: FormMethod | V7_FormMethod;\n      formAction: string;\n      formEncType: FormEncType;\n      formData: undefined;\n      json: undefined;\n      text: string;\n    };\n\n/**\n * @private\n * Arguments passed to route loader/action functions.  Same for now but we keep\n * this as a private implementation detail in case they diverge in the future.\n */\ninterface DataFunctionArgs<Context> {\n  request: Request;\n  params: Params;\n  context?: Context;\n}\n\n// TODO: (v7) Change the defaults from any to unknown in and remove Remix wrappers:\n//   ActionFunction, ActionFunctionArgs, LoaderFunction, LoaderFunctionArgs\n//   Also, make them a type alias instead of an interface\n\n/**\n * Arguments passed to loader functions\n */\nexport interface LoaderFunctionArgs<Context = any>\n  extends DataFunctionArgs<Context> {}\n\n/**\n * Arguments passed to action functions\n */\nexport interface ActionFunctionArgs<Context = any>\n  extends DataFunctionArgs<Context> {}\n\n/**\n * Loaders and actions can return anything except `undefined` (`null` is a\n * valid return value if there is no data to return).  Responses are preferred\n * and will ease any future migration to Remix\n */\ntype DataFunctionValue = Response | NonNullable<unknown> | null;\n\ntype DataFunctionReturnValue = Promise<DataFunctionValue> | DataFunctionValue;\n\n/**\n * Route loader function signature\n */\nexport type LoaderFunction<Context = any> = {\n  (\n    args: LoaderFunctionArgs<Context>,\n    handlerCtx?: unknown\n  ): DataFunctionReturnValue;\n} & { hydrate?: boolean };\n\n/**\n * Route action function signature\n */\nexport interface ActionFunction<Context = any> {\n  (\n    args: ActionFunctionArgs<Context>,\n    handlerCtx?: unknown\n  ): DataFunctionReturnValue;\n}\n\n/**\n * Arguments passed to shouldRevalidate function\n */\nexport interface ShouldRevalidateFunctionArgs {\n  currentUrl: URL;\n  currentParams: AgnosticDataRouteMatch[\"params\"];\n  nextUrl: URL;\n  nextParams: AgnosticDataRouteMatch[\"params\"];\n  formMethod?: Submission[\"formMethod\"];\n  formAction?: Submission[\"formAction\"];\n  formEncType?: Submission[\"formEncType\"];\n  text?: Submission[\"text\"];\n  formData?: Submission[\"formData\"];\n  json?: Submission[\"json\"];\n  actionStatus?: number;\n  actionResult?: any;\n  defaultShouldRevalidate: boolean;\n}\n\n/**\n * Route shouldRevalidate function signature.  This runs after any submission\n * (navigation or fetcher), so we flatten the navigation/fetcher submission\n * onto the arguments.  It shouldn't matter whether it came from a navigation\n * or a fetcher, what really matters is the URLs and the formData since loaders\n * have to re-run based on the data models that were potentially mutated.\n */\nexport interface ShouldRevalidateFunction {\n  (args: ShouldRevalidateFunctionArgs): boolean;\n}\n\n/**\n * Function provided by the framework-aware layers to set `hasErrorBoundary`\n * from the framework-aware `errorElement` prop\n *\n * @deprecated Use `mapRouteProperties` instead\n */\nexport interface DetectErrorBoundaryFunction {\n  (route: AgnosticRouteObject): boolean;\n}\n\nexport interface DataStrategyMatch\n  extends AgnosticRouteMatch<string, AgnosticDataRouteObject> {\n  shouldLoad: boolean;\n  resolve: (\n    handlerOverride?: (\n      handler: (ctx?: unknown) => DataFunctionReturnValue\n    ) => DataFunctionReturnValue\n  ) => Promise<DataStrategyResult>;\n}\n\nexport interface DataStrategyFunctionArgs<Context = any>\n  extends DataFunctionArgs<Context> {\n  matches: DataStrategyMatch[];\n  fetcherKey: string | null;\n}\n\n/**\n * Result from a loader or action called via dataStrategy\n */\nexport interface DataStrategyResult {\n  type: \"data\" | \"error\";\n  result: unknown; // data, Error, Response, DeferredData, DataWithResponseInit\n}\n\nexport interface DataStrategyFunction {\n  (args: DataStrategyFunctionArgs): Promise<Record<string, DataStrategyResult>>;\n}\n\nexport type AgnosticPatchRoutesOnNavigationFunctionArgs<\n  O extends AgnosticRouteObject = AgnosticRouteObject,\n  M extends AgnosticRouteMatch = AgnosticRouteMatch\n> = {\n  signal: AbortSignal;\n  path: string;\n  matches: M[];\n  fetcherKey: string | undefined;\n  patch: (routeId: string | null, children: O[]) => void;\n};\n\nexport type AgnosticPatchRoutesOnNavigationFunction<\n  O extends AgnosticRouteObject = AgnosticRouteObject,\n  M extends AgnosticRouteMatch = AgnosticRouteMatch\n> = (\n  opts: AgnosticPatchRoutesOnNavigationFunctionArgs<O, M>\n) => void | Promise<void>;\n\n/**\n * Function provided by the framework-aware layers to set any framework-specific\n * properties from framework-agnostic properties\n */\nexport interface MapRoutePropertiesFunction {\n  (route: AgnosticRouteObject): {\n    hasErrorBoundary: boolean;\n  } & Record<string, any>;\n}\n\n/**\n * Keys we cannot change from within a lazy() function. We spread all other keys\n * onto the route. Either they're meaningful to the router, or they'll get\n * ignored.\n */\nexport type ImmutableRouteKey =\n  | \"lazy\"\n  | \"caseSensitive\"\n  | \"path\"\n  | \"id\"\n  | \"index\"\n  | \"children\";\n\nexport const immutableRouteKeys = new Set<ImmutableRouteKey>([\n  \"lazy\",\n  \"caseSensitive\",\n  \"path\",\n  \"id\",\n  \"index\",\n  \"children\",\n]);\n\ntype RequireOne<T, Key = keyof T> = Exclude<\n  {\n    [K in keyof T]: K extends Key ? Omit<T, K> & Required<Pick<T, K>> : never;\n  }[keyof T],\n  undefined\n>;\n\n/**\n * lazy() function to load a route definition, which can add non-matching\n * related properties to a route\n */\nexport interface LazyRouteFunction<R extends AgnosticRouteObject> {\n  (): Promise<RequireOne<Omit<R, ImmutableRouteKey>>>;\n}\n\n/**\n * Base RouteObject with common props shared by all types of routes\n */\ntype AgnosticBaseRouteObject = {\n  caseSensitive?: boolean;\n  path?: string;\n  id?: string;\n  loader?: LoaderFunction | boolean;\n  action?: ActionFunction | boolean;\n  hasErrorBoundary?: boolean;\n  shouldRevalidate?: ShouldRevalidateFunction;\n  handle?: any;\n  lazy?: LazyRouteFunction<AgnosticBaseRouteObject>;\n};\n\n/**\n * Index routes must not have children\n */\nexport type AgnosticIndexRouteObject = AgnosticBaseRouteObject & {\n  children?: undefined;\n  index: true;\n};\n\n/**\n * Non-index routes may have children, but cannot have index\n */\nexport type AgnosticNonIndexRouteObject = AgnosticBaseRouteObject & {\n  children?: AgnosticRouteObject[];\n  index?: false;\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 type AgnosticRouteObject =\n  | AgnosticIndexRouteObject\n  | AgnosticNonIndexRouteObject;\n\nexport type AgnosticDataIndexRouteObject = AgnosticIndexRouteObject & {\n  id: string;\n};\n\nexport type AgnosticDataNonIndexRouteObject = AgnosticNonIndexRouteObject & {\n  children?: AgnosticDataRouteObject[];\n  id: string;\n};\n\n/**\n * A data route object, which is just a RouteObject with a required unique ID\n */\nexport type AgnosticDataRouteObject =\n  | AgnosticDataIndexRouteObject\n  | AgnosticDataNonIndexRouteObject;\n\nexport type RouteManifest = Record<string, AgnosticDataRouteObject | undefined>;\n\n// Recursive helper for finding path parameters in the absence of wildcards\ntype _PathParam<Path extends string> =\n  // split path into individual path segments\n  Path extends `${infer L}/${infer R}`\n    ? _PathParam<L> | _PathParam<R>\n    : // find params after `:`\n    Path extends `:${infer Param}`\n    ? Param extends `${infer Optional}?`\n      ? Optional\n      : Param\n    : // otherwise, there aren't any params present\n      never;\n\n/**\n * Examples:\n * \"/a/b/*\" -> \"*\"\n * \":a\" -> \"a\"\n * \"/a/:b\" -> \"b\"\n * \"/a/blahblahblah:b\" -> \"b\"\n * \"/:a/:b\" -> \"a\" | \"b\"\n * \"/:a/b/:c/*\" -> \"a\" | \"c\" | \"*\"\n */\nexport type PathParam<Path extends string> =\n  // check if path is just a wildcard\n  Path extends \"*\" | \"/*\"\n    ? \"*\"\n    : // look for wildcard at the end of the path\n    Path extends `${infer Rest}/*`\n    ? \"*\" | _PathParam<Rest>\n    : // look for params in the absence of wildcards\n      _PathParam<Path>;\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.\nexport type ParamParseKey<Segment extends string> =\n  // if you could not find path params, fallback to `string`\n  [PathParam<Segment>] extends [never] ? string : PathParam<Segment>;\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 RouteMatch contains info about how a route matched a URL.\n */\nexport interface AgnosticRouteMatch<\n  ParamKey extends string = string,\n  RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject\n> {\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: RouteObjectType;\n}\n\nexport interface AgnosticDataRouteMatch\n  extends AgnosticRouteMatch<string, AgnosticDataRouteObject> {}\n\nfunction isIndexRoute(\n  route: AgnosticRouteObject\n): route is AgnosticIndexRouteObject {\n  return route.index === true;\n}\n\n// Walk the route tree generating unique IDs where necessary, so we are working\n// solely with AgnosticDataRouteObject's within the Router\nexport function convertRoutesToDataRoutes(\n  routes: AgnosticRouteObject[],\n  mapRouteProperties: MapRoutePropertiesFunction,\n  parentPath: string[] = [],\n  manifest: RouteManifest = {}\n): AgnosticDataRouteObject[] {\n  return routes.map((route, index) => {\n    let treePath = [...parentPath, String(index)];\n    let id = typeof route.id === \"string\" ? route.id : treePath.join(\"-\");\n    invariant(\n      route.index !== true || !route.children,\n      `Cannot specify children on an index route`\n    );\n    invariant(\n      !manifest[id],\n      `Found a route id collision on id \"${id}\".  Route ` +\n        \"id's must be globally unique within Data Router usages\"\n    );\n\n    if (isIndexRoute(route)) {\n      let indexRoute: AgnosticDataIndexRouteObject = {\n        ...route,\n        ...mapRouteProperties(route),\n        id,\n      };\n      manifest[id] = indexRoute;\n      return indexRoute;\n    } else {\n      let pathOrLayoutRoute: AgnosticDataNonIndexRouteObject = {\n        ...route,\n        ...mapRouteProperties(route),\n        id,\n        children: undefined,\n      };\n      manifest[id] = pathOrLayoutRoute;\n\n      if (route.children) {\n        pathOrLayoutRoute.children = convertRoutesToDataRoutes(\n          route.children,\n          mapRouteProperties,\n          treePath,\n          manifest\n        );\n      }\n\n      return pathOrLayoutRoute;\n    }\n  });\n}\n\n/**\n * Matches the given routes to a location and returns the match data.\n *\n * @see https://reactrouter.com/v6/utils/match-routes\n */\nexport function matchRoutes<\n  RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject\n>(\n  routes: RouteObjectType[],\n  locationArg: Partial<Location> | string,\n  basename = \"/\"\n): AgnosticRouteMatch<string, RouteObjectType>[] | null {\n  return matchRoutesImpl(routes, locationArg, basename, false);\n}\n\nexport function matchRoutesImpl<\n  RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject\n>(\n  routes: RouteObjectType[],\n  locationArg: Partial<Location> | string,\n  basename: string,\n  allowPartial: boolean\n): AgnosticRouteMatch<string, RouteObjectType>[] | 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    // Incoming pathnames are generally encoded from either window.location\n    // or from router.navigate, but we want to match against the unencoded\n    // paths in the route definitions.  Memory router locations won't be\n    // encoded here but there also shouldn't be anything to decode so this\n    // should be a safe operation.  This avoids needing matchRoutes to be\n    // history-aware.\n    let decoded = decodePath(pathname);\n    matches = matchRouteBranch<string, RouteObjectType>(\n      branches[i],\n      decoded,\n      allowPartial\n    );\n  }\n\n  return matches;\n}\n\nexport interface UIMatch<Data = unknown, Handle = unknown> {\n  id: string;\n  pathname: string;\n  params: AgnosticRouteMatch[\"params\"];\n  data: Data;\n  handle: Handle;\n}\n\nexport function convertRouteMatchToUiMatch(\n  match: AgnosticDataRouteMatch,\n  loaderData: RouteData\n): UIMatch {\n  let { route, pathname, params } = match;\n  return {\n    id: route.id,\n    pathname,\n    params,\n    data: loaderData[route.id],\n    handle: route.handle,\n  };\n}\n\ninterface RouteMeta<\n  RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject\n> {\n  relativePath: string;\n  caseSensitive: boolean;\n  childrenIndex: number;\n  route: RouteObjectType;\n}\n\ninterface RouteBranch<\n  RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject\n> {\n  path: string;\n  score: number;\n  routesMeta: RouteMeta<RouteObjectType>[];\n}\n\nfunction flattenRoutes<\n  RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject\n>(\n  routes: RouteObjectType[],\n  branches: RouteBranch<RouteObjectType>[] = [],\n  parentsMeta: RouteMeta<RouteObjectType>[] = [],\n  parentPath = \"\"\n): RouteBranch<RouteObjectType>[] {\n  let flattenRoute = (\n    route: RouteObjectType,\n    index: number,\n    relativePath?: string\n  ) => {\n    let meta: RouteMeta<RouteObjectType> = {\n      relativePath:\n        relativePath === undefined ? route.path || \"\" : relativePath,\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        // Our types know better, but runtime JS may not!\n        // @ts-expect-error\n        route.index !== true,\n        `Index routes must not have child routes. Please remove ` +\n          `all child routes from route path \"${path}\".`\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({\n      path,\n      score: computeScore(path, route.index),\n      routesMeta,\n    });\n  };\n  routes.forEach((route, index) => {\n    // coarse-grain check for optional params\n    if (route.path === \"\" || !route.path?.includes(\"?\")) {\n      flattenRoute(route, index);\n    } else {\n      for (let exploded of explodeOptionalSegments(route.path)) {\n        flattenRoute(route, index, exploded);\n      }\n    }\n  });\n\n  return branches;\n}\n\n/**\n * Computes all combinations of optional path segments for a given path,\n * excluding combinations that are ambiguous and of lower priority.\n *\n * For example, `/one/:two?/three/:four?/:five?` explodes to:\n * - `/one/three`\n * - `/one/:two/three`\n * - `/one/three/:four`\n * - `/one/three/:five`\n * - `/one/:two/three/:four`\n * - `/one/:two/three/:five`\n * - `/one/three/:four/:five`\n * - `/one/:two/three/:four/:five`\n */\nfunction explodeOptionalSegments(path: string): string[] {\n  let segments = path.split(\"/\");\n  if (segments.length === 0) return [];\n\n  let [first, ...rest] = segments;\n\n  // Optional path segments are denoted by a trailing `?`\n  let isOptional = first.endsWith(\"?\");\n  // Compute the corresponding required segment: `foo?` -> `foo`\n  let required = first.replace(/\\?$/, \"\");\n\n  if (rest.length === 0) {\n    // Intepret empty string as omitting an optional segment\n    // `[\"one\", \"\", \"three\"]` corresponds to omitting `:two` from `/one/:two?/three` -> `/one/three`\n    return isOptional ? [required, \"\"] : [required];\n  }\n\n  let restExploded = explodeOptionalSegments(rest.join(\"/\"));\n\n  let result: string[] = [];\n\n  // All child paths with the prefix.  Do this for all children before the\n  // optional version for all children, so we get consistent ordering where the\n  // parent optional aspect is preferred as required.  Otherwise, we can get\n  // child sections interspersed where deeper optional segments are higher than\n  // parent optional segments, where for example, /:two would explode _earlier_\n  // then /:one.  By always including the parent as required _for all children_\n  // first, we avoid this issue\n  result.push(\n    ...restExploded.map((subpath) =>\n      subpath === \"\" ? required : [required, subpath].join(\"/\")\n    )\n  );\n\n  // Then, if this is an optional value, add all child versions without\n  if (isOptional) {\n    result.push(...restExploded);\n  }\n\n  // for absolute paths, ensure `/` instead of empty segment\n  return result.map((exploded) =>\n    path.startsWith(\"/\") && exploded === \"\" ? \"/\" : exploded\n  );\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<\n  ParamKey extends string = string,\n  RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject\n>(\n  branch: RouteBranch<RouteObjectType>,\n  pathname: string,\n  allowPartial = false\n): AgnosticRouteMatch<ParamKey, RouteObjectType>[] | null {\n  let { routesMeta } = branch;\n\n  let matchedParams = {};\n  let matchedPathname = \"/\";\n  let matches: AgnosticRouteMatch<ParamKey, RouteObjectType>[] = [];\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    let route = meta.route;\n\n    if (\n      !match &&\n      end &&\n      allowPartial &&\n      !routesMeta[routesMeta.length - 1].route.index\n    ) {\n      match = matchPath(\n        {\n          path: meta.relativePath,\n          caseSensitive: meta.caseSensitive,\n          end: false,\n        },\n        remainingPathname\n      );\n    }\n\n    if (!match) {\n      return null;\n    }\n\n    Object.assign(matchedParams, match.params);\n\n    matches.push({\n      // TODO: Can this as be avoided?\n      params: matchedParams as Params<ParamKey>,\n      pathname: joinPaths([matchedPathname, match.pathname]),\n      pathnameBase: normalizePathname(\n        joinPaths([matchedPathname, match.pathnameBase])\n      ),\n      route,\n    });\n\n    if (match.pathnameBase !== \"/\") {\n      matchedPathname = joinPaths([matchedPathname, match.pathnameBase]);\n    }\n  }\n\n  return matches;\n}\n\n/**\n * Returns a path with params interpolated.\n *\n * @see https://reactrouter.com/v6/utils/generate-path\n */\nexport function generatePath<Path extends string>(\n  originalPath: Path,\n  params: {\n    [key in PathParam<Path>]: string | null;\n  } = {} as any\n): string {\n  let path: string = originalPath;\n  if (path.endsWith(\"*\") && path !== \"*\" && !path.endsWith(\"/*\")) {\n    warning(\n      false,\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    path = path.replace(/\\*$/, \"/*\") as Path;\n  }\n\n  // ensure `/` is added at the beginning if the path is absolute\n  const prefix = path.startsWith(\"/\") ? \"/\" : \"\";\n\n  const stringify = (p: any) =>\n    p == null ? \"\" : typeof p === \"string\" ? p : String(p);\n\n  const segments = path\n    .split(/\\/+/)\n    .map((segment, index, array) => {\n      const isLastSegment = index === array.length - 1;\n\n      // only apply the splat if it's the last segment\n      if (isLastSegment && segment === \"*\") {\n        const star = \"*\" as PathParam<Path>;\n        // Apply the splat\n        return stringify(params[star]);\n      }\n\n      const keyMatch = segment.match(/^:([\\w-]+)(\\??)$/);\n      if (keyMatch) {\n        const [, key, optional] = keyMatch;\n        let param = params[key as PathParam<Path>];\n        invariant(optional === \"?\" || param != null, `Missing \":${key}\" param`);\n        return stringify(param);\n      }\n\n      // Remove any optional markers from optional static segments\n      return segment.replace(/\\?$/g, \"\");\n    })\n    // Remove empty segments\n    .filter((segment) => !!segment);\n\n  return prefix + segments.join(\"/\");\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/v6/utils/match-path\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, compiledParams] = 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 = compiledParams.reduce<Mutable<Params>>(\n    (memo, { paramName, isOptional }, 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      const value = captureGroups[index];\n      if (isOptional && !value) {\n        memo[paramName] = undefined;\n      } else {\n        memo[paramName] = (value || \"\").replace(/%2F/g, \"/\");\n      }\n      return memo;\n    },\n    {}\n  );\n\n  return {\n    params,\n    pathname: matchedPathname,\n    pathnameBase,\n    pattern,\n  };\n}\n\ntype CompiledPathParam = { paramName: string; isOptional?: boolean };\n\nfunction compilePath(\n  path: string,\n  caseSensitive = false,\n  end = true\n): [RegExp, CompiledPathParam[]] {\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 params: CompiledPathParam[] = [];\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(\n        /\\/:([\\w-]+)(\\?)?/g,\n        (_: string, paramName: string, isOptional) => {\n          params.push({ paramName, isOptional: isOptional != null });\n          return isOptional ? \"/?([^\\\\/]+)?\" : \"/([^\\\\/]+)\";\n        }\n      );\n\n  if (path.endsWith(\"*\")) {\n    params.push({ paramName: \"*\" });\n    regexpSource +=\n      path === \"*\" || path === \"/*\"\n        ? \"(.*)$\" // Already matched the initial /, just match the rest\n        : \"(?:\\\\/(.+)|\\\\/*)$\"; // Don't include the / in params[\"*\"]\n  } else if (end) {\n    // When matching to the end, ignore trailing slashes\n    regexpSource += \"\\\\/*$\";\n  } else if (path !== \"\" && path !== \"/\") {\n    // If our path is non-empty and contains anything beyond an initial slash,\n    // then we have _some_ form of path in our regex, so we should expect to\n    // match only if we find the end of this path segment.  Look for an optional\n    // non-captured trailing slash (to match a portion of the URL) or the end\n    // of the path (if we've matched to the end).  We used to do this with a\n    // word boundary but that gives false positives on routes like\n    // /user-preferences since `-` counts as a word boundary.\n    regexpSource += \"(?:(?=\\\\/|$))\";\n  } else {\n    // Nothing to match for \"\" or \"/\"\n  }\n\n  let matcher = new RegExp(regexpSource, caseSensitive ? undefined : \"i\");\n\n  return [matcher, params];\n}\n\nexport function decodePath(value: string) {\n  try {\n    return value\n      .split(\"/\")\n      .map((v) => decodeURIComponent(v).replace(/\\//g, \"%2F\"))\n      .join(\"/\");\n  } catch (error) {\n    warning(\n      false,\n      `The URL path \"${value}\" could not be decoded because it is is a ` +\n        `malformed URL segment. This is probably due to a bad percent ` +\n        `encoding (${error}).`\n    );\n\n    return value;\n  }\n}\n\n/**\n * @private\n */\nexport function stripBasename(\n  pathname: string,\n  basename: string\n): string | null {\n  if (basename === \"/\") return pathname;\n\n  if (!pathname.toLowerCase().startsWith(basename.toLowerCase())) {\n    return null;\n  }\n\n  // We want to leave trailing slash behavior in the user's control, so if they\n  // specify a basename with a trailing slash, we should support it\n  let startIndex = basename.endsWith(\"/\")\n    ? basename.length - 1\n    : basename.length;\n  let nextChar = pathname.charAt(startIndex);\n  if (nextChar && nextChar !== \"/\") {\n    // pathname does not start with basename/\n    return null;\n  }\n\n  return pathname.slice(startIndex) || \"/\";\n}\n\nconst ABSOLUTE_URL_REGEX = /^(?:[a-z][a-z0-9+.-]*:|\\/\\/)/i;\nexport const isAbsoluteUrl = (url: string) => ABSOLUTE_URL_REGEX.test(url);\n\n/**\n * Returns a resolved path object relative to the given pathname.\n *\n * @see https://reactrouter.com/v6/utils/resolve-path\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: string;\n  if (toPathname) {\n    if (isAbsoluteUrl(toPathname)) {\n      pathname = toPathname;\n    } else {\n      if (toPathname.includes(\"//\")) {\n        let oldPathname = toPathname;\n        toPathname = toPathname.replace(/\\/\\/+/g, \"/\");\n        warning(\n          false,\n          `Pathnames cannot have embedded double slashes - normalizing ` +\n            `${oldPathname} -> ${toPathname}`\n        );\n      }\n      if (toPathname.startsWith(\"/\")) {\n        pathname = resolvePathname(toPathname.substring(1), \"/\");\n      } else {\n        pathname = resolvePathname(toPathname, fromPathname);\n      }\n    }\n  } else {\n    pathname = fromPathname;\n  }\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 getInvalidPathError(\n  char: string,\n  field: string,\n  dest: string,\n  path: Partial<Path>\n) {\n  return (\n    `Cannot include a '${char}' character in a manually specified ` +\n    `\\`to.${field}\\` field [${JSON.stringify(\n      path\n    )}].  Please separate it out to the ` +\n    `\\`to.${dest}\\` field. Alternatively you may provide the full path as ` +\n    `a string in <Link to=\"...\"> and the router will parse it for you.`\n  );\n}\n\n/**\n * @private\n *\n * When processing relative navigation we want to ignore ancestor routes that\n * do not contribute to the path, such that index/pathless layout routes don't\n * interfere.\n *\n * For example, when moving a route element into an index route and/or a\n * pathless layout route, relative link behavior contained within should stay\n * the same.  Both of the following examples should link back to the root:\n *\n *   <Route path=\"/\">\n *     <Route path=\"accounts\" element={<Link to=\"..\"}>\n *   </Route>\n *\n *   <Route path=\"/\">\n *     <Route path=\"accounts\">\n *       <Route element={<AccountsLayout />}>       // <-- Does not contribute\n *         <Route index element={<Link to=\"..\"} />  // <-- Does not contribute\n *       </Route\n *     </Route>\n *   </Route>\n */\nexport function getPathContributingMatches<\n  T extends AgnosticRouteMatch = AgnosticRouteMatch\n>(matches: T[]) {\n  return matches.filter(\n    (match, index) =>\n      index === 0 || (match.route.path && match.route.path.length > 0)\n  );\n}\n\n// Return the array of pathnames for the current route matches - used to\n// generate the routePathnames input for resolveTo()\nexport function getResolveToMatches<\n  T extends AgnosticRouteMatch = AgnosticRouteMatch\n>(matches: T[], v7_relativeSplatPath: boolean) {\n  let pathMatches = getPathContributingMatches(matches);\n\n  // When v7_relativeSplatPath is enabled, use the full pathname for the leaf\n  // match so we include splat values for \".\" links.  See:\n  // https://github.com/remix-run/react-router/issues/11052#issuecomment-1836589329\n  if (v7_relativeSplatPath) {\n    return pathMatches.map((match, idx) =>\n      idx === pathMatches.length - 1 ? match.pathname : match.pathnameBase\n    );\n  }\n\n  return pathMatches.map((match) => match.pathnameBase);\n}\n\n/**\n * @private\n */\nexport function resolveTo(\n  toArg: To,\n  routePathnames: string[],\n  locationPathname: string,\n  isPathRelative = false\n): Path {\n  let to: Partial<Path>;\n  if (typeof toArg === \"string\") {\n    to = parsePath(toArg);\n  } else {\n    to = { ...toArg };\n\n    invariant(\n      !to.pathname || !to.pathname.includes(\"?\"),\n      getInvalidPathError(\"?\", \"pathname\", \"search\", to)\n    );\n    invariant(\n      !to.pathname || !to.pathname.includes(\"#\"),\n      getInvalidPathError(\"#\", \"pathname\", \"hash\", to)\n    );\n    invariant(\n      !to.search || !to.search.includes(\"#\"),\n      getInvalidPathError(\"#\", \"search\", \"hash\", to)\n    );\n  }\n\n  let isEmptyPath = toArg === \"\" || to.pathname === \"\";\n  let toPathname = isEmptyPath ? \"/\" : to.pathname;\n\n  let from: string;\n\n  // Routing is relative to the current pathname if explicitly requested.\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  if (toPathname == null) {\n    from = locationPathname;\n  } else {\n    let routePathnameIndex = routePathnames.length - 1;\n\n    // With relative=\"route\" (the default), each leading .. segment means\n    // \"go up one route\" instead of \"go up one URL segment\".  This is a key\n    // difference from how <a href> works and a major reason we call this a\n    // \"to\" value instead of a \"href\".\n    if (!isPathRelative && toPathname.startsWith(\"..\")) {\n      let toSegments = toPathname.split(\"/\");\n\n      while (toSegments[0] === \"..\") {\n        toSegments.shift();\n        routePathnameIndex -= 1;\n      }\n\n      to.pathname = toSegments.join(\"/\");\n    }\n\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\" had one\n  let hasExplicitTrailingSlash =\n    toPathname && toPathname !== \"/\" && toPathname.endsWith(\"/\");\n  // Or if this was a link to the current path which has a trailing slash\n  let hasCurrentTrailingSlash =\n    (isEmptyPath || toPathname === \".\") && locationPathname.endsWith(\"/\");\n  if (\n    !path.pathname.endsWith(\"/\") &&\n    (hasExplicitTrailingSlash || hasCurrentTrailingSlash)\n  ) {\n    path.pathname += \"/\";\n  }\n\n  return path;\n}\n\n/**\n * @private\n */\nexport function 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\n/**\n * @private\n */\nexport const joinPaths = (paths: string[]): string =>\n  paths.join(\"/\").replace(/\\/\\/+/g, \"/\");\n\n/**\n * @private\n */\nexport const normalizePathname = (pathname: string): string =>\n  pathname.replace(/\\/+$/, \"\").replace(/^\\/*/, \"/\");\n\n/**\n * @private\n */\nexport const normalizeSearch = (search: string): string =>\n  !search || search === \"?\"\n    ? \"\"\n    : search.startsWith(\"?\")\n    ? search\n    : \"?\" + search;\n\n/**\n * @private\n */\nexport const normalizeHash = (hash: string): string =>\n  !hash || hash === \"#\" ? \"\" : hash.startsWith(\"#\") ? hash : \"#\" + hash;\n\nexport type JsonFunction = <Data>(\n  data: Data,\n  init?: number | ResponseInit\n) => Response;\n\n/**\n * This is a shortcut for creating `application/json` responses. Converts `data`\n * to JSON and sets the `Content-Type` header.\n *\n * @deprecated The `json` method is deprecated in favor of returning raw objects.\n * This method will be removed in v7.\n */\nexport const json: JsonFunction = (data, init = {}) => {\n  let responseInit = typeof init === \"number\" ? { status: init } : init;\n\n  let headers = new Headers(responseInit.headers);\n  if (!headers.has(\"Content-Type\")) {\n    headers.set(\"Content-Type\", \"application/json; charset=utf-8\");\n  }\n\n  return new Response(JSON.stringify(data), {\n    ...responseInit,\n    headers,\n  });\n};\n\nexport class DataWithResponseInit<D> {\n  type: string = \"DataWithResponseInit\";\n  data: D;\n  init: ResponseInit | null;\n\n  constructor(data: D, init?: ResponseInit) {\n    this.data = data;\n    this.init = init || null;\n  }\n}\n\n/**\n * Create \"responses\" that contain `status`/`headers` without forcing\n * serialization into an actual `Response` - used by Remix single fetch\n */\nexport function data<D>(data: D, init?: number | ResponseInit) {\n  return new DataWithResponseInit(\n    data,\n    typeof init === \"number\" ? { status: init } : init\n  );\n}\n\nexport interface TrackedPromise extends Promise<any> {\n  _tracked?: boolean;\n  _data?: any;\n  _error?: any;\n}\n\nexport class AbortedDeferredError extends Error {}\n\nexport class DeferredData {\n  private pendingKeysSet: Set<string> = new Set<string>();\n  private controller: AbortController;\n  private abortPromise: Promise<void>;\n  private unlistenAbortSignal: () => void;\n  private subscribers: Set<(aborted: boolean, settledKey?: string) => void> =\n    new Set();\n  data: Record<string, unknown>;\n  init?: ResponseInit;\n  deferredKeys: string[] = [];\n\n  constructor(data: Record<string, unknown>, responseInit?: ResponseInit) {\n    invariant(\n      data && typeof data === \"object\" && !Array.isArray(data),\n      \"defer() only accepts plain objects\"\n    );\n\n    // Set up an AbortController + Promise we can race against to exit early\n    // cancellation\n    let reject: (e: AbortedDeferredError) => void;\n    this.abortPromise = new Promise((_, r) => (reject = r));\n    this.controller = new AbortController();\n    let onAbort = () =>\n      reject(new AbortedDeferredError(\"Deferred data aborted\"));\n    this.unlistenAbortSignal = () =>\n      this.controller.signal.removeEventListener(\"abort\", onAbort);\n    this.controller.signal.addEventListener(\"abort\", onAbort);\n\n    this.data = Object.entries(data).reduce(\n      (acc, [key, value]) =>\n        Object.assign(acc, {\n          [key]: this.trackPromise(key, value),\n        }),\n      {}\n    );\n\n    if (this.done) {\n      // All incoming values were resolved\n      this.unlistenAbortSignal();\n    }\n\n    this.init = responseInit;\n  }\n\n  private trackPromise(\n    key: string,\n    value: Promise<unknown> | unknown\n  ): TrackedPromise | unknown {\n    if (!(value instanceof Promise)) {\n      return value;\n    }\n\n    this.deferredKeys.push(key);\n    this.pendingKeysSet.add(key);\n\n    // We store a little wrapper promise that will be extended with\n    // _data/_error props upon resolve/reject\n    let promise: TrackedPromise = Promise.race([value, this.abortPromise]).then(\n      (data) => this.onSettle(promise, key, undefined, data as unknown),\n      (error) => this.onSettle(promise, key, error as unknown)\n    );\n\n    // Register rejection listeners to avoid uncaught promise rejections on\n    // errors or aborted deferred values\n    promise.catch(() => {});\n\n    Object.defineProperty(promise, \"_tracked\", { get: () => true });\n    return promise;\n  }\n\n  private onSettle(\n    promise: TrackedPromise,\n    key: string,\n    error: unknown,\n    data?: unknown\n  ): unknown {\n    if (\n      this.controller.signal.aborted &&\n      error instanceof AbortedDeferredError\n    ) {\n      this.unlistenAbortSignal();\n      Object.defineProperty(promise, \"_error\", { get: () => error });\n      return Promise.reject(error);\n    }\n\n    this.pendingKeysSet.delete(key);\n\n    if (this.done) {\n      // Nothing left to abort!\n      this.unlistenAbortSignal();\n    }\n\n    // If the promise was resolved/rejected with undefined, we'll throw an error as you\n    // should always resolve with a value or null\n    if (error === undefined && data === undefined) {\n      let undefinedError = new Error(\n        `Deferred data for key \"${key}\" resolved/rejected with \\`undefined\\`, ` +\n          `you must resolve/reject with a value or \\`null\\`.`\n      );\n      Object.defineProperty(promise, \"_error\", { get: () => undefinedError });\n      this.emit(false, key);\n      return Promise.reject(undefinedError);\n    }\n\n    if (data === undefined) {\n      Object.defineProperty(promise, \"_error\", { get: () => error });\n      this.emit(false, key);\n      return Promise.reject(error);\n    }\n\n    Object.defineProperty(promise, \"_data\", { get: () => data });\n    this.emit(false, key);\n    return data;\n  }\n\n  private emit(aborted: boolean, settledKey?: string) {\n    this.subscribers.forEach((subscriber) => subscriber(aborted, settledKey));\n  }\n\n  subscribe(fn: (aborted: boolean, settledKey?: string) => void) {\n    this.subscribers.add(fn);\n    return () => this.subscribers.delete(fn);\n  }\n\n  cancel() {\n    this.controller.abort();\n    this.pendingKeysSet.forEach((v, k) => this.pendingKeysSet.delete(k));\n    this.emit(true);\n  }\n\n  async resolveData(signal: AbortSignal) {\n    let aborted = false;\n    if (!this.done) {\n      let onAbort = () => this.cancel();\n      signal.addEventListener(\"abort\", onAbort);\n      aborted = await new Promise((resolve) => {\n        this.subscribe((aborted) => {\n          signal.removeEventListener(\"abort\", onAbort);\n          if (aborted || this.done) {\n            resolve(aborted);\n          }\n        });\n      });\n    }\n    return aborted;\n  }\n\n  get done() {\n    return this.pendingKeysSet.size === 0;\n  }\n\n  get unwrappedData() {\n    invariant(\n      this.data !== null && this.done,\n      \"Can only unwrap data on initialized and settled deferreds\"\n    );\n\n    return Object.entries(this.data).reduce(\n      (acc, [key, value]) =>\n        Object.assign(acc, {\n          [key]: unwrapTrackedPromise(value),\n        }),\n      {}\n    );\n  }\n\n  get pendingKeys() {\n    return Array.from(this.pendingKeysSet);\n  }\n}\n\nfunction isTrackedPromise(value: any): value is TrackedPromise {\n  return (\n    value instanceof Promise && (value as TrackedPromise)._tracked === true\n  );\n}\n\nfunction unwrapTrackedPromise(value: any) {\n  if (!isTrackedPromise(value)) {\n    return value;\n  }\n\n  if (value._error) {\n    throw value._error;\n  }\n  return value._data;\n}\n\nexport type DeferFunction = (\n  data: Record<string, unknown>,\n  init?: number | ResponseInit\n) => DeferredData;\n\n/**\n * @deprecated The `defer` method is deprecated in favor of returning raw\n * objects. This method will be removed in v7.\n */\nexport const defer: DeferFunction = (data, init = {}) => {\n  let responseInit = typeof init === \"number\" ? { status: init } : init;\n\n  return new DeferredData(data, responseInit);\n};\n\nexport type RedirectFunction = (\n  url: string,\n  init?: number | ResponseInit\n) => Response;\n\n/**\n * A redirect response. Sets the status code and the `Location` header.\n * Defaults to \"302 Found\".\n */\nexport const redirect: RedirectFunction = (url, init = 302) => {\n  let responseInit = init;\n  if (typeof responseInit === \"number\") {\n    responseInit = { status: responseInit };\n  } else if (typeof responseInit.status === \"undefined\") {\n    responseInit.status = 302;\n  }\n\n  let headers = new Headers(responseInit.headers);\n  headers.set(\"Location\", url);\n\n  return new Response(null, {\n    ...responseInit,\n    headers,\n  });\n};\n\n/**\n * A redirect response that will force a document reload to the new location.\n * Sets the status code and the `Location` header.\n * Defaults to \"302 Found\".\n */\nexport const redirectDocument: RedirectFunction = (url, init) => {\n  let response = redirect(url, init);\n  response.headers.set(\"X-Remix-Reload-Document\", \"true\");\n  return response;\n};\n\n/**\n * A redirect response that will perform a `history.replaceState` instead of a\n * `history.pushState` for client-side navigation redirects.\n * Sets the status code and the `Location` header.\n * Defaults to \"302 Found\".\n */\nexport const replace: RedirectFunction = (url, init) => {\n  let response = redirect(url, init);\n  response.headers.set(\"X-Remix-Replace\", \"true\");\n  return response;\n};\n\nexport type ErrorResponse = {\n  status: number;\n  statusText: string;\n  data: any;\n};\n\n/**\n * @private\n * Utility class we use to hold auto-unwrapped 4xx/5xx Response bodies\n *\n * We don't export the class for public use since it's an implementation\n * detail, but we export the interface above so folks can build their own\n * abstractions around instances via isRouteErrorResponse()\n */\nexport class ErrorResponseImpl implements ErrorResponse {\n  status: number;\n  statusText: string;\n  data: any;\n  private error?: Error;\n  private internal: boolean;\n\n  constructor(\n    status: number,\n    statusText: string | undefined,\n    data: any,\n    internal = false\n  ) {\n    this.status = status;\n    this.statusText = statusText || \"\";\n    this.internal = internal;\n    if (data instanceof Error) {\n      this.data = data.toString();\n      this.error = data;\n    } else {\n      this.data = data;\n    }\n  }\n}\n\n/**\n * Check if the given error is an ErrorResponse generated from a 4xx/5xx\n * Response thrown from an action/loader\n */\nexport function isRouteErrorResponse(error: any): error is ErrorResponse {\n  return (\n    error != null &&\n    typeof error.status === \"number\" &&\n    typeof error.statusText === \"string\" &&\n    typeof error.internal === \"boolean\" &&\n    \"data\" in error\n  );\n}\n","import type { History, Location, Path, To } from \"./history\";\nimport {\n  Action as HistoryAction,\n  createLocation,\n  createPath,\n  invariant,\n  parsePath,\n  warning,\n} from \"./history\";\nimport type {\n  AgnosticDataRouteMatch,\n  AgnosticDataRouteObject,\n  DataStrategyMatch,\n  AgnosticRouteObject,\n  DataResult,\n  DataStrategyFunction,\n  DataStrategyFunctionArgs,\n  DeferredData,\n  DeferredResult,\n  DetectErrorBoundaryFunction,\n  ErrorResult,\n  FormEncType,\n  FormMethod,\n  HTMLFormMethod,\n  DataStrategyResult,\n  ImmutableRouteKey,\n  MapRoutePropertiesFunction,\n  MutationFormMethod,\n  RedirectResult,\n  RouteData,\n  RouteManifest,\n  ShouldRevalidateFunctionArgs,\n  Submission,\n  SuccessResult,\n  UIMatch,\n  V7_FormMethod,\n  V7_MutationFormMethod,\n  AgnosticPatchRoutesOnNavigationFunction,\n  DataWithResponseInit,\n} from \"./utils\";\nimport {\n  ErrorResponseImpl,\n  ResultType,\n  convertRouteMatchToUiMatch,\n  convertRoutesToDataRoutes,\n  getPathContributingMatches,\n  getResolveToMatches,\n  immutableRouteKeys,\n  isRouteErrorResponse,\n  joinPaths,\n  matchRoutes,\n  matchRoutesImpl,\n  resolveTo,\n  stripBasename,\n} from \"./utils\";\n\n////////////////////////////////////////////////////////////////////////////////\n//#region Types and Constants\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * A Router instance manages all navigation and data loading/mutations\n */\nexport interface Router {\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Return the basename for the router\n   */\n  get basename(): RouterInit[\"basename\"];\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Return the future config for the router\n   */\n  get future(): FutureConfig;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Return the current state of the router\n   */\n  get state(): RouterState;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Return the routes for this router instance\n   */\n  get routes(): AgnosticDataRouteObject[];\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Return the window associated with the router\n   */\n  get window(): RouterInit[\"window\"];\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Initialize the router, including adding history listeners and kicking off\n   * initial data fetches.  Returns a function to cleanup listeners and abort\n   * any in-progress loads\n   */\n  initialize(): Router;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Subscribe to router.state updates\n   *\n   * @param fn function to call with the new state\n   */\n  subscribe(fn: RouterSubscriber): () => void;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Enable scroll restoration behavior in the router\n   *\n   * @param savedScrollPositions Object that will manage positions, in case\n   *                             it's being restored from sessionStorage\n   * @param getScrollPosition    Function to get the active Y scroll position\n   * @param getKey               Function to get the key to use for restoration\n   */\n  enableScrollRestoration(\n    savedScrollPositions: Record<string, number>,\n    getScrollPosition: GetScrollPositionFunction,\n    getKey?: GetScrollRestorationKeyFunction\n  ): () => void;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Navigate forward/backward in the history stack\n   * @param to Delta to move in the history stack\n   */\n  navigate(to: number): Promise<void>;\n\n  /**\n   * Navigate to the given path\n   * @param to Path to navigate to\n   * @param opts Navigation options (method, submission, etc.)\n   */\n  navigate(to: To | null, opts?: RouterNavigateOptions): Promise<void>;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Trigger a fetcher load/submission\n   *\n   * @param key     Fetcher key\n   * @param routeId Route that owns the fetcher\n   * @param href    href to fetch\n   * @param opts    Fetcher options, (method, submission, etc.)\n   */\n  fetch(\n    key: string,\n    routeId: string,\n    href: string | null,\n    opts?: RouterFetchOptions\n  ): void;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Trigger a revalidation of all current route loaders and fetcher loads\n   */\n  revalidate(): void;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Utility function to create an href for the given location\n   * @param location\n   */\n  createHref(location: Location | URL): string;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Utility function to URL encode a destination path according to the internal\n   * history implementation\n   * @param to\n   */\n  encodeLocation(to: To): Path;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Get/create a fetcher for the given key\n   * @param key\n   */\n  getFetcher<TData = any>(key: string): Fetcher<TData>;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Delete the fetcher for a given key\n   * @param key\n   */\n  deleteFetcher(key: string): void;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Cleanup listeners and abort any in-progress loads\n   */\n  dispose(): void;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Get a navigation blocker\n   * @param key The identifier for the blocker\n   * @param fn The blocker function implementation\n   */\n  getBlocker(key: string, fn: BlockerFunction): Blocker;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Delete a navigation blocker\n   * @param key The identifier for the blocker\n   */\n  deleteBlocker(key: string): void;\n\n  /**\n   * @internal\n   * PRIVATE DO NOT USE\n   *\n   * Patch additional children routes into an existing parent route\n   * @param routeId The parent route id or a callback function accepting `patch`\n   *                to perform batch patching\n   * @param children The additional children routes\n   */\n  patchRoutes(routeId: string | null, children: AgnosticRouteObject[]): void;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * HMR needs to pass in-flight route updates to React Router\n   * TODO: Replace this with granular route update APIs (addRoute, updateRoute, deleteRoute)\n   */\n  _internalSetRoutes(routes: AgnosticRouteObject[]): void;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Internal fetch AbortControllers accessed by unit tests\n   */\n  _internalFetchControllers: Map<string, AbortController>;\n\n  /**\n   * @internal\n   * PRIVATE - DO NOT USE\n   *\n   * Internal pending DeferredData instances accessed by unit tests\n   */\n  _internalActiveDeferreds: Map<string, DeferredData>;\n}\n\n/**\n * State maintained internally by the router.  During a navigation, all states\n * reflect the the \"old\" location unless otherwise noted.\n */\nexport interface RouterState {\n  /**\n   * The action of the most recent navigation\n   */\n  historyAction: HistoryAction;\n\n  /**\n   * The current location reflected by the router\n   */\n  location: Location;\n\n  /**\n   * The current set of route matches\n   */\n  matches: AgnosticDataRouteMatch[];\n\n  /**\n   * Tracks whether we've completed our initial data load\n   */\n  initialized: boolean;\n\n  /**\n   * Current scroll position we should start at for a new view\n   *  - number -> scroll position to restore to\n   *  - false -> do not restore scroll at all (used during submissions)\n   *  - null -> don't have a saved position, scroll to hash or top of page\n   */\n  restoreScrollPosition: number | false | null;\n\n  /**\n   * Indicate whether this navigation should skip resetting the scroll position\n   * if we are unable to restore the scroll position\n   */\n  preventScrollReset: boolean;\n\n  /**\n   * Tracks the state of the current navigation\n   */\n  navigation: Navigation;\n\n  /**\n   * Tracks any in-progress revalidations\n   */\n  revalidation: RevalidationState;\n\n  /**\n   * Data from the loaders for the current matches\n   */\n  loaderData: RouteData;\n\n  /**\n   * Data from the action for the current matches\n   */\n  actionData: RouteData | null;\n\n  /**\n   * Errors caught from loaders for the current matches\n   */\n  errors: RouteData | null;\n\n  /**\n   * Map of current fetchers\n   */\n  fetchers: Map<string, Fetcher>;\n\n  /**\n   * Map of current blockers\n   */\n  blockers: Map<string, Blocker>;\n}\n\n/**\n * Data that can be passed into hydrate a Router from SSR\n */\nexport type HydrationState = Partial<\n  Pick<RouterState, \"loaderData\" | \"actionData\" | \"errors\">\n>;\n\n/**\n * Future flags to toggle new feature behavior\n */\nexport interface FutureConfig {\n  v7_fetcherPersist: boolean;\n  v7_normalizeFormMethod: boolean;\n  v7_partialHydration: boolean;\n  v7_prependBasename: boolean;\n  v7_relativeSplatPath: boolean;\n  v7_skipActionErrorRevalidation: boolean;\n}\n\n/**\n * Initialization options for createRouter\n */\nexport interface RouterInit {\n  routes: AgnosticRouteObject[];\n  history: History;\n  basename?: string;\n  /**\n   * @deprecated Use `mapRouteProperties` instead\n   */\n  detectErrorBoundary?: DetectErrorBoundaryFunction;\n  mapRouteProperties?: MapRoutePropertiesFunction;\n  future?: Partial<FutureConfig>;\n  hydrationData?: HydrationState;\n  window?: Window;\n  dataStrategy?: DataStrategyFunction;\n  patchRoutesOnNavigation?: AgnosticPatchRoutesOnNavigationFunction;\n}\n\n/**\n * State returned from a server-side query() call\n */\nexport interface StaticHandlerContext {\n  basename: Router[\"basename\"];\n  location: RouterState[\"location\"];\n  matches: RouterState[\"matches\"];\n  loaderData: RouterState[\"loaderData\"];\n  actionData: RouterState[\"actionData\"];\n  errors: RouterState[\"errors\"];\n  statusCode: number;\n  loaderHeaders: Record<string, Headers>;\n  actionHeaders: Record<string, Headers>;\n  activeDeferreds: Record<string, DeferredData> | null;\n  _deepestRenderedBoundaryId?: string | null;\n}\n\n/**\n * A StaticHandler instance manages a singular SSR navigation/fetch event\n */\nexport interface StaticHandler {\n  dataRoutes: AgnosticDataRouteObject[];\n  query(\n    request: Request,\n    opts?: {\n      requestContext?: unknown;\n      skipLoaderErrorBubbling?: boolean;\n      dataStrategy?: DataStrategyFunction;\n    }\n  ): Promise<StaticHandlerContext | Response>;\n  queryRoute(\n    request: Request,\n    opts?: {\n      routeId?: string;\n      requestContext?: unknown;\n      dataStrategy?: DataStrategyFunction;\n    }\n  ): Promise<any>;\n}\n\ntype ViewTransitionOpts = {\n  currentLocation: Location;\n  nextLocation: Location;\n};\n\n/**\n * Subscriber function signature for changes to router state\n */\nexport interface RouterSubscriber {\n  (\n    state: RouterState,\n    opts: {\n      deletedFetchers: string[];\n      viewTransitionOpts?: ViewTransitionOpts;\n      flushSync: boolean;\n    }\n  ): void;\n}\n\n/**\n * Function signature for determining the key to be used in scroll restoration\n * for a given location\n */\nexport interface GetScrollRestorationKeyFunction {\n  (location: Location, matches: UIMatch[]): string | null;\n}\n\n/**\n * Function signature for determining the current scroll position\n */\nexport interface GetScrollPositionFunction {\n  (): number;\n}\n\nexport type RelativeRoutingType = \"route\" | \"path\";\n\n// Allowed for any navigation or fetch\ntype BaseNavigateOrFetchOptions = {\n  preventScrollReset?: boolean;\n  relative?: RelativeRoutingType;\n  flushSync?: boolean;\n};\n\n// Only allowed for navigations\ntype BaseNavigateOptions = BaseNavigateOrFetchOptions & {\n  replace?: boolean;\n  state?: any;\n  fromRouteId?: string;\n  viewTransition?: boolean;\n};\n\n// Only allowed for submission navigations\ntype BaseSubmissionOptions = {\n  formMethod?: HTMLFormMethod;\n  formEncType?: FormEncType;\n} & (\n  | { formData: FormData; body?: undefined }\n  | { formData?: undefined; body: any }\n);\n\n/**\n * Options for a navigate() call for a normal (non-submission) navigation\n */\ntype LinkNavigateOptions = BaseNavigateOptions;\n\n/**\n * Options for a navigate() call for a submission navigation\n */\ntype SubmissionNavigateOptions = BaseNavigateOptions & BaseSubmissionOptions;\n\n/**\n * Options to pass to navigate() for a navigation\n */\nexport type RouterNavigateOptions =\n  | LinkNavigateOptions\n  | SubmissionNavigateOptions;\n\n/**\n * Options for a fetch() load\n */\ntype LoadFetchOptions = BaseNavigateOrFetchOptions;\n\n/**\n * Options for a fetch() submission\n */\ntype SubmitFetchOptions = BaseNavigateOrFetchOptions & BaseSubmissionOptions;\n\n/**\n * Options to pass to fetch()\n */\nexport type RouterFetchOptions = LoadFetchOptions | SubmitFetchOptions;\n\n/**\n * Potential states for state.navigation\n */\nexport type NavigationStates = {\n  Idle: {\n    state: \"idle\";\n    location: undefined;\n    formMethod: undefined;\n    formAction: undefined;\n    formEncType: undefined;\n    formData: undefined;\n    json: undefined;\n    text: undefined;\n  };\n  Loading: {\n    state: \"loading\";\n    location: Location;\n    formMethod: Submission[\"formMethod\"] | undefined;\n    formAction: Submission[\"formAction\"] | undefined;\n    formEncType: Submission[\"formEncType\"] | undefined;\n    formData: Submission[\"formData\"] | undefined;\n    json: Submission[\"json\"] | undefined;\n    text: Submission[\"text\"] | undefined;\n  };\n  Submitting: {\n    state: \"submitting\";\n    location: Location;\n    formMethod: Submission[\"formMethod\"];\n    formAction: Submission[\"formAction\"];\n    formEncType: Submission[\"formEncType\"];\n    formData: Submission[\"formData\"];\n    json: Submission[\"json\"];\n    text: Submission[\"text\"];\n  };\n};\n\nexport type Navigation = NavigationStates[keyof NavigationStates];\n\nexport type RevalidationState = \"idle\" | \"loading\";\n\n/**\n * Potential states for fetchers\n */\ntype FetcherStates<TData = any> = {\n  Idle: {\n    state: \"idle\";\n    formMethod: undefined;\n    formAction: undefined;\n    formEncType: undefined;\n    text: undefined;\n    formData: undefined;\n    json: undefined;\n    data: TData | undefined;\n  };\n  Loading: {\n    state: \"loading\";\n    formMethod: Submission[\"formMethod\"] | undefined;\n    formAction: Submission[\"formAction\"] | undefined;\n    formEncType: Submission[\"formEncType\"] | undefined;\n    text: Submission[\"text\"] | undefined;\n    formData: Submission[\"formData\"] | undefined;\n    json: Submission[\"json\"] | undefined;\n    data: TData | undefined;\n  };\n  Submitting: {\n    state: \"submitting\";\n    formMethod: Submission[\"formMethod\"];\n    formAction: Submission[\"formAction\"];\n    formEncType: Submission[\"formEncType\"];\n    text: Submission[\"text\"];\n    formData: Submission[\"formData\"];\n    json: Submission[\"json\"];\n    data: TData | undefined;\n  };\n};\n\nexport type Fetcher<TData = any> =\n  FetcherStates<TData>[keyof FetcherStates<TData>];\n\ninterface BlockerBlocked {\n  state: \"blocked\";\n  reset(): void;\n  proceed(): void;\n  location: Location;\n}\n\ninterface BlockerUnblocked {\n  state: \"unblocked\";\n  reset: undefined;\n  proceed: undefined;\n  location: undefined;\n}\n\ninterface BlockerProceeding {\n  state: \"proceeding\";\n  reset: undefined;\n  proceed: undefined;\n  location: Location;\n}\n\nexport type Blocker = BlockerUnblocked | BlockerBlocked | BlockerProceeding;\n\nexport type BlockerFunction = (args: {\n  currentLocation: Location;\n  nextLocation: Location;\n  historyAction: HistoryAction;\n}) => boolean;\n\ninterface ShortCircuitable {\n  /**\n   * startNavigation does not need to complete the navigation because we\n   * redirected or got interrupted\n   */\n  shortCircuited?: boolean;\n}\n\ntype PendingActionResult = [string, SuccessResult | ErrorResult];\n\ninterface HandleActionResult extends ShortCircuitable {\n  /**\n   * Route matches which may have been updated from fog of war discovery\n   */\n  matches?: RouterState[\"matches\"];\n  /**\n   * Tuple for the returned or thrown value from the current action.  The routeId\n   * is the action route for success and the bubbled boundary route for errors.\n   */\n  pendingActionResult?: PendingActionResult;\n}\n\ninterface HandleLoadersResult extends ShortCircuitable {\n  /**\n   * Route matches which may have been updated from fog of war discovery\n   */\n  matches?: RouterState[\"matches\"];\n  /**\n   * loaderData returned from the current set of loaders\n   */\n  loaderData?: RouterState[\"loaderData\"];\n  /**\n   * errors thrown from the current set of loaders\n   */\n  errors?: RouterState[\"errors\"];\n}\n\n/**\n * Cached info for active fetcher.load() instances so they can participate\n * in revalidation\n */\ninterface FetchLoadMatch {\n  routeId: string;\n  path: string;\n}\n\n/**\n * Identified fetcher.load() calls that need to be revalidated\n */\ninterface RevalidatingFetcher extends FetchLoadMatch {\n  key: string;\n  match: AgnosticDataRouteMatch | null;\n  matches: AgnosticDataRouteMatch[] | null;\n  controller: AbortController | null;\n}\n\nconst validMutationMethodsArr: MutationFormMethod[] = [\n  \"post\",\n  \"put\",\n  \"patch\",\n  \"delete\",\n];\nconst validMutationMethods = new Set<MutationFormMethod>(\n  validMutationMethodsArr\n);\n\nconst validRequestMethodsArr: FormMethod[] = [\n  \"get\",\n  ...validMutationMethodsArr,\n];\nconst validRequestMethods = new Set<FormMethod>(validRequestMethodsArr);\n\nconst redirectStatusCodes = new Set([301, 302, 303, 307, 308]);\nconst redirectPreserveMethodStatusCodes = new Set([307, 308]);\n\nexport const IDLE_NAVIGATION: NavigationStates[\"Idle\"] = {\n  state: \"idle\",\n  location: undefined,\n  formMethod: undefined,\n  formAction: undefined,\n  formEncType: undefined,\n  formData: undefined,\n  json: undefined,\n  text: undefined,\n};\n\nexport const IDLE_FETCHER: FetcherStates[\"Idle\"] = {\n  state: \"idle\",\n  data: undefined,\n  formMethod: undefined,\n  formAction: undefined,\n  formEncType: undefined,\n  formData: undefined,\n  json: undefined,\n  text: undefined,\n};\n\nexport const IDLE_BLOCKER: BlockerUnblocked = {\n  state: \"unblocked\",\n  proceed: undefined,\n  reset: undefined,\n  location: undefined,\n};\n\nconst ABSOLUTE_URL_REGEX = /^(?:[a-z][a-z0-9+.-]*:|\\/\\/)/i;\n\nconst defaultMapRouteProperties: MapRoutePropertiesFunction = (route) => ({\n  hasErrorBoundary: Boolean(route.hasErrorBoundary),\n});\n\nconst TRANSITIONS_STORAGE_KEY = \"remix-router-transitions\";\n\n//#endregion\n\n////////////////////////////////////////////////////////////////////////////////\n//#region createRouter\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * Create a router and listen to history POP navigations\n */\nexport function createRouter(init: RouterInit): Router {\n  const routerWindow = init.window\n    ? init.window\n    : typeof window !== \"undefined\"\n    ? window\n    : undefined;\n  const isBrowser =\n    typeof routerWindow !== \"undefined\" &&\n    typeof routerWindow.document !== \"undefined\" &&\n    typeof routerWindow.document.createElement !== \"undefined\";\n  const isServer = !isBrowser;\n\n  invariant(\n    init.routes.length > 0,\n    \"You must provide a non-empty routes array to createRouter\"\n  );\n\n  let mapRouteProperties: MapRoutePropertiesFunction;\n  if (init.mapRouteProperties) {\n    mapRouteProperties = init.mapRouteProperties;\n  } else if (init.detectErrorBoundary) {\n    // If they are still using the deprecated version, wrap it with the new API\n    let detectErrorBoundary = init.detectErrorBoundary;\n    mapRouteProperties = (route) => ({\n      hasErrorBoundary: detectErrorBoundary(route),\n    });\n  } else {\n    mapRouteProperties = defaultMapRouteProperties;\n  }\n\n  // Routes keyed by ID\n  let manifest: RouteManifest = {};\n  // Routes in tree format for matching\n  let dataRoutes = convertRoutesToDataRoutes(\n    init.routes,\n    mapRouteProperties,\n    undefined,\n    manifest\n  );\n  let inFlightDataRoutes: AgnosticDataRouteObject[] | undefined;\n  let basename = init.basename || \"/\";\n  let dataStrategyImpl = init.dataStrategy || defaultDataStrategy;\n  let patchRoutesOnNavigationImpl = init.patchRoutesOnNavigation;\n\n  // Config driven behavior flags\n  let future: FutureConfig = {\n    v7_fetcherPersist: false,\n    v7_normalizeFormMethod: false,\n    v7_partialHydration: false,\n    v7_prependBasename: false,\n    v7_relativeSplatPath: false,\n    v7_skipActionErrorRevalidation: false,\n    ...init.future,\n  };\n  // Cleanup function for history\n  let unlistenHistory: (() => void) | null = null;\n  // Externally-provided functions to call on all state changes\n  let subscribers = new Set<RouterSubscriber>();\n  // Externally-provided object to hold scroll restoration locations during routing\n  let savedScrollPositions: Record<string, number> | null = null;\n  // Externally-provided function to get scroll restoration keys\n  let getScrollRestorationKey: GetScrollRestorationKeyFunction | null = null;\n  // Externally-provided function to get current scroll position\n  let getScrollPosition: GetScrollPositionFunction | null = null;\n  // One-time flag to control the initial hydration scroll restoration.  Because\n  // we don't get the saved positions from <ScrollRestoration /> until _after_\n  // the initial render, we need to manually trigger a separate updateState to\n  // send along the restoreScrollPosition\n  // Set to true if we have `hydrationData` since we assume we were SSR'd and that\n  // SSR did the initial scroll restoration.\n  let initialScrollRestored = init.hydrationData != null;\n\n  let initialMatches = matchRoutes(dataRoutes, init.history.location, basename);\n  let initialMatchesIsFOW = false;\n  let initialErrors: RouteData | null = null;\n\n  if (initialMatches == null && !patchRoutesOnNavigationImpl) {\n    // If we do not match a user-provided-route, fall back to the root\n    // to allow the error boundary to take over\n    let error = getInternalRouterError(404, {\n      pathname: init.history.location.pathname,\n    });\n    let { matches, route } = getShortCircuitMatches(dataRoutes);\n    initialMatches = matches;\n    initialErrors = { [route.id]: error };\n  }\n\n  // In SPA apps, if the user provided a patchRoutesOnNavigation implementation and\n  // our initial match is a splat route, clear them out so we run through lazy\n  // discovery on hydration in case there's a more accurate lazy route match.\n  // In SSR apps (with `hydrationData`), we expect that the server will send\n  // up the proper matched routes so we don't want to run lazy discovery on\n  // initial hydration and want to hydrate into the splat route.\n  if (initialMatches && !init.hydrationData) {\n    let fogOfWar = checkFogOfWar(\n      initialMatches,\n      dataRoutes,\n      init.history.location.pathname\n    );\n    if (fogOfWar.active) {\n      initialMatches = null;\n    }\n  }\n\n  let initialized: boolean;\n  if (!initialMatches) {\n    initialized = false;\n    initialMatches = [];\n\n    // If partial hydration and fog of war is enabled, we will be running\n    // `patchRoutesOnNavigation` during hydration so include any partial matches as\n    // the initial matches so we can properly render `HydrateFallback`'s\n    if (future.v7_partialHydration) {\n      let fogOfWar = checkFogOfWar(\n        null,\n        dataRoutes,\n        init.history.location.pathname\n      );\n      if (fogOfWar.active && fogOfWar.matches) {\n        initialMatchesIsFOW = true;\n        initialMatches = fogOfWar.matches;\n      }\n    }\n  } else if (initialMatches.some((m) => m.route.lazy)) {\n    // All initialMatches need to be loaded before we're ready.  If we have lazy\n    // functions around still then we'll need to run them in initialize()\n    initialized = false;\n  } else if (!initialMatches.some((m) => m.route.loader)) {\n    // If we've got no loaders to run, then we're good to go\n    initialized = true;\n  } else if (future.v7_partialHydration) {\n    // If partial hydration is enabled, we're initialized so long as we were\n    // provided with hydrationData for every route with a loader, and no loaders\n    // were marked for explicit hydration\n    let loaderData = init.hydrationData ? init.hydrationData.loaderData : null;\n    let errors = init.hydrationData ? init.hydrationData.errors : null;\n    // If errors exist, don't consider routes below the boundary\n    if (errors) {\n      let idx = initialMatches.findIndex(\n        (m) => errors![m.route.id] !== undefined\n      );\n      initialized = initialMatches\n        .slice(0, idx + 1)\n        .every((m) => !shouldLoadRouteOnHydration(m.route, loaderData, errors));\n    } else {\n      initialized = initialMatches.every(\n        (m) => !shouldLoadRouteOnHydration(m.route, loaderData, errors)\n      );\n    }\n  } else {\n    // Without partial hydration - we're initialized if we were provided any\n    // hydrationData - which is expected to be complete\n    initialized = init.hydrationData != null;\n  }\n\n  let router: Router;\n  let state: RouterState = {\n    historyAction: init.history.action,\n    location: init.history.location,\n    matches: initialMatches,\n    initialized,\n    navigation: IDLE_NAVIGATION,\n    // Don't restore on initial updateState() if we were SSR'd\n    restoreScrollPosition: init.hydrationData != null ? false : null,\n    preventScrollReset: false,\n    revalidation: \"idle\",\n    loaderData: (init.hydrationData && init.hydrationData.loaderData) || {},\n    actionData: (init.hydrationData && init.hydrationData.actionData) || null,\n    errors: (init.hydrationData && init.hydrationData.errors) || initialErrors,\n    fetchers: new Map(),\n    blockers: new Map(),\n  };\n\n  // -- Stateful internal variables to manage navigations --\n  // Current navigation in progress (to be committed in completeNavigation)\n  let pendingAction: HistoryAction = HistoryAction.Pop;\n\n  // Should the current navigation prevent the scroll reset if scroll cannot\n  // be restored?\n  let pendingPreventScrollReset = false;\n\n  // AbortController for the active navigation\n  let pendingNavigationController: AbortController | null;\n\n  // Should the current navigation enable document.startViewTransition?\n  let pendingViewTransitionEnabled = false;\n\n  // Store applied view transitions so we can apply them on POP\n  let appliedViewTransitions: Map<string, Set<string>> = new Map<\n    string,\n    Set<string>\n  >();\n\n  // Cleanup function for persisting applied transitions to sessionStorage\n  let removePageHideEventListener: (() => void) | null = null;\n\n  // We use this to avoid touching history in completeNavigation if a\n  // revalidation is entirely uninterrupted\n  let isUninterruptedRevalidation = false;\n\n  // Use this internal flag to force revalidation of all loaders:\n  //  - submissions (completed or interrupted)\n  //  - useRevalidator()\n  //  - X-Remix-Revalidate (from redirect)\n  let isRevalidationRequired = false;\n\n  // Use this internal array to capture routes that require revalidation due\n  // to a cancelled deferred on action submission\n  let cancelledDeferredRoutes: string[] = [];\n\n  // Use this internal array to capture fetcher loads that were cancelled by an\n  // action navigation and require revalidation\n  let cancelledFetcherLoads: Set<string> = new Set();\n\n  // AbortControllers for any in-flight fetchers\n  let fetchControllers = new Map<string, AbortController>();\n\n  // Track loads based on the order in which they started\n  let incrementingLoadId = 0;\n\n  // Track the outstanding pending navigation data load to be compared against\n  // the globally incrementing load when a fetcher load lands after a completed\n  // navigation\n  let pendingNavigationLoadId = -1;\n\n  // Fetchers that triggered data reloads as a result of their actions\n  let fetchReloadIds = new Map<string, number>();\n\n  // Fetchers that triggered redirect navigations\n  let fetchRedirectIds = new Set<string>();\n\n  // Most recent href/match for fetcher.load calls for fetchers\n  let fetchLoadMatches = new Map<string, FetchLoadMatch>();\n\n  // Ref-count mounted fetchers so we know when it's ok to clean them up\n  let activeFetchers = new Map<string, number>();\n\n  // Fetchers that have requested a delete when using v7_fetcherPersist,\n  // they'll be officially removed after they return to idle\n  let deletedFetchers = new Set<string>();\n\n  // Store DeferredData instances for active route matches.  When a\n  // route loader returns defer() we stick one in here.  Then, when a nested\n  // promise resolves we update loaderData.  If a new navigation starts we\n  // cancel active deferreds for eliminated routes.\n  let activeDeferreds = new Map<string, DeferredData>();\n\n  // Store blocker functions in a separate Map outside of router state since\n  // we don't need to update UI state if they change\n  let blockerFunctions = new Map<string, BlockerFunction>();\n\n  // Map of pending patchRoutesOnNavigation() promises (keyed by path/matches) so\n  // that we only kick them off once for a given combo\n  let pendingPatchRoutes = new Map<\n    string,\n    ReturnType<AgnosticPatchRoutesOnNavigationFunction>\n  >();\n\n  // Flag to ignore the next history update, so we can revert the URL change on\n  // a POP navigation that was blocked by the user without touching router state\n  let unblockBlockerHistoryUpdate: (() => void) | undefined = undefined;\n\n  // Initialize the router, all side effects should be kicked off from here.\n  // Implemented as a Fluent API for ease of:\n  //   let router = createRouter(init).initialize();\n  function initialize() {\n    // If history informs us of a POP navigation, start the navigation but do not update\n    // state.  We'll update our own state once the navigation completes\n    unlistenHistory = init.history.listen(\n      ({ action: historyAction, location, delta }) => {\n        // Ignore this event if it was just us resetting the URL from a\n        // blocked POP navigation\n        if (unblockBlockerHistoryUpdate) {\n          unblockBlockerHistoryUpdate();\n          unblockBlockerHistoryUpdate = undefined;\n          return;\n        }\n\n        warning(\n          blockerFunctions.size === 0 || delta != null,\n          \"You are trying to use a blocker on a POP navigation to a location \" +\n            \"that was not created by @remix-run/router. This will fail silently in \" +\n            \"production. This can happen if you are navigating outside the router \" +\n            \"via `window.history.pushState`/`window.location.hash` instead of using \" +\n            \"router navigation APIs.  This can also happen if you are using \" +\n            \"createHashRouter and the user manually changes the URL.\"\n        );\n\n        let blockerKey = shouldBlockNavigation({\n          currentLocation: state.location,\n          nextLocation: location,\n          historyAction,\n        });\n\n        if (blockerKey && delta != null) {\n          // Restore the URL to match the current UI, but don't update router state\n          let nextHistoryUpdatePromise = new Promise<void>((resolve) => {\n            unblockBlockerHistoryUpdate = resolve;\n          });\n          init.history.go(delta * -1);\n\n          // Put the blocker into a blocked state\n          updateBlocker(blockerKey, {\n            state: \"blocked\",\n            location,\n            proceed() {\n              updateBlocker(blockerKey!, {\n                state: \"proceeding\",\n                proceed: undefined,\n                reset: undefined,\n                location,\n              });\n              // Re-do the same POP navigation we just blocked, after the url\n              // restoration is also complete.  See:\n              // https://github.com/remix-run/react-router/issues/11613\n              nextHistoryUpdatePromise.then(() => init.history.go(delta));\n            },\n            reset() {\n              let blockers = new Map(state.blockers);\n              blockers.set(blockerKey!, IDLE_BLOCKER);\n              updateState({ blockers });\n            },\n          });\n          return;\n        }\n\n        return startNavigation(historyAction, location);\n      }\n    );\n\n    if (isBrowser) {\n      // FIXME: This feels gross.  How can we cleanup the lines between\n      // scrollRestoration/appliedTransitions persistance?\n      restoreAppliedTransitions(routerWindow, appliedViewTransitions);\n      let _saveAppliedTransitions = () =>\n        persistAppliedTransitions(routerWindow, appliedViewTransitions);\n      routerWindow.addEventListener(\"pagehide\", _saveAppliedTransitions);\n      removePageHideEventListener = () =>\n        routerWindow.removeEventListener(\"pagehide\", _saveAppliedTransitions);\n    }\n\n    // Kick off initial data load if needed.  Use Pop to avoid modifying history\n    // Note we don't do any handling of lazy here.  For SPA's it'll get handled\n    // in the normal navigation flow.  For SSR it's expected that lazy modules are\n    // resolved prior to router creation since we can't go into a fallbackElement\n    // UI for SSR'd apps\n    if (!state.initialized) {\n      startNavigation(HistoryAction.Pop, state.location, {\n        initialHydration: true,\n      });\n    }\n\n    return router;\n  }\n\n  // Clean up a router and it's side effects\n  function dispose() {\n    if (unlistenHistory) {\n      unlistenHistory();\n    }\n    if (removePageHideEventListener) {\n      removePageHideEventListener();\n    }\n    subscribers.clear();\n    pendingNavigationController && pendingNavigationController.abort();\n    state.fetchers.forEach((_, key) => deleteFetcher(key));\n    state.blockers.forEach((_, key) => deleteBlocker(key));\n  }\n\n  // Subscribe to state updates for the router\n  function subscribe(fn: RouterSubscriber) {\n    subscribers.add(fn);\n    return () => subscribers.delete(fn);\n  }\n\n  // Update our state and notify the calling context of the change\n  function updateState(\n    newState: Partial<RouterState>,\n    opts: {\n      flushSync?: boolean;\n      viewTransitionOpts?: ViewTransitionOpts;\n    } = {}\n  ): void {\n    state = {\n      ...state,\n      ...newState,\n    };\n\n    // Prep fetcher cleanup so we can tell the UI which fetcher data entries\n    // can be removed\n    let completedFetchers: string[] = [];\n    let deletedFetchersKeys: string[] = [];\n\n    if (future.v7_fetcherPersist) {\n      state.fetchers.forEach((fetcher, key) => {\n        if (fetcher.state === \"idle\") {\n          if (deletedFetchers.has(key)) {\n            // Unmounted from the UI and can be totally removed\n            deletedFetchersKeys.push(key);\n          } else {\n            // Returned to idle but still mounted in the UI, so semi-remains for\n            // revalidations and such\n            completedFetchers.push(key);\n          }\n        }\n      });\n    }\n\n    // Remove any lingering deleted fetchers that have already been removed\n    // from state.fetchers\n    deletedFetchers.forEach((key) => {\n      if (!state.fetchers.has(key) && !fetchControllers.has(key)) {\n        deletedFetchersKeys.push(key);\n      }\n    });\n\n    // Iterate over a local copy so that if flushSync is used and we end up\n    // removing and adding a new subscriber due to the useCallback dependencies,\n    // we don't get ourselves into a loop calling the new subscriber immediately\n    [...subscribers].forEach((subscriber) =>\n      subscriber(state, {\n        deletedFetchers: deletedFetchersKeys,\n        viewTransitionOpts: opts.viewTransitionOpts,\n        flushSync: opts.flushSync === true,\n      })\n    );\n\n    // Remove idle fetchers from state since we only care about in-flight fetchers.\n    if (future.v7_fetcherPersist) {\n      completedFetchers.forEach((key) => state.fetchers.delete(key));\n      deletedFetchersKeys.forEach((key) => deleteFetcher(key));\n    } else {\n      // We already called deleteFetcher() on these, can remove them from this\n      // Set now that we've handed the keys off to the data layer\n      deletedFetchersKeys.forEach((key) => deletedFetchers.delete(key));\n    }\n  }\n\n  // Complete a navigation returning the state.navigation back to the IDLE_NAVIGATION\n  // and setting state.[historyAction/location/matches] to the new route.\n  // - Location is a required param\n  // - Navigation will always be set to IDLE_NAVIGATION\n  // - Can pass any other state in newState\n  function completeNavigation(\n    location: Location,\n    newState: Partial<Omit<RouterState, \"action\" | \"location\" | \"navigation\">>,\n    { flushSync }: { flushSync?: boolean } = {}\n  ): void {\n    // Deduce if we're in a loading/actionReload state:\n    // - We have committed actionData in the store\n    // - The current navigation was a mutation submission\n    // - We're past the submitting state and into the loading state\n    // - The location being loaded is not the result of a redirect\n    let isActionReload =\n      state.actionData != null &&\n      state.navigation.formMethod != null &&\n      isMutationMethod(state.navigation.formMethod) &&\n      state.navigation.state === \"loading\" &&\n      location.state?._isRedirect !== true;\n\n    let actionData: RouteData | null;\n    if (newState.actionData) {\n      if (Object.keys(newState.actionData).length > 0) {\n        actionData = newState.actionData;\n      } else {\n        // Empty actionData -> clear prior actionData due to an action error\n        actionData = null;\n      }\n    } else if (isActionReload) {\n      // Keep the current data if we're wrapping up the action reload\n      actionData = state.actionData;\n    } else {\n      // Clear actionData on any other completed navigations\n      actionData = null;\n    }\n\n    // Always preserve any existing loaderData from re-used routes\n    let loaderData = newState.loaderData\n      ? mergeLoaderData(\n          state.loaderData,\n          newState.loaderData,\n          newState.matches || [],\n          newState.errors\n        )\n      : state.loaderData;\n\n    // On a successful navigation we can assume we got through all blockers\n    // so we can start fresh\n    let blockers = state.blockers;\n    if (blockers.size > 0) {\n      blockers = new Map(blockers);\n      blockers.forEach((_, k) => blockers.set(k, IDLE_BLOCKER));\n    }\n\n    // Always respect the user flag.  Otherwise don't reset on mutation\n    // submission navigations unless they redirect\n    let preventScrollReset =\n      pendingPreventScrollReset === true ||\n      (state.navigation.formMethod != null &&\n        isMutationMethod(state.navigation.formMethod) &&\n        location.state?._isRedirect !== true);\n\n    // Commit any in-flight routes at the end of the HMR revalidation \"navigation\"\n    if (inFlightDataRoutes) {\n      dataRoutes = inFlightDataRoutes;\n      inFlightDataRoutes = undefined;\n    }\n\n    if (isUninterruptedRevalidation) {\n      // If this was an uninterrupted revalidation then do not touch history\n    } else if (pendingAction === HistoryAction.Pop) {\n      // Do nothing for POP - URL has already been updated\n    } else if (pendingAction === HistoryAction.Push) {\n      init.history.push(location, location.state);\n    } else if (pendingAction === HistoryAction.Replace) {\n      init.history.replace(location, location.state);\n    }\n\n    let viewTransitionOpts: ViewTransitionOpts | undefined;\n\n    // On POP, enable transitions if they were enabled on the original navigation\n    if (pendingAction === HistoryAction.Pop) {\n      // Forward takes precedence so they behave like the original navigation\n      let priorPaths = appliedViewTransitions.get(state.location.pathname);\n      if (priorPaths && priorPaths.has(location.pathname)) {\n        viewTransitionOpts = {\n          currentLocation: state.location,\n          nextLocation: location,\n        };\n      } else if (appliedViewTransitions.has(location.pathname)) {\n        // If we don't have a previous forward nav, assume we're popping back to\n        // the new location and enable if that location previously enabled\n        viewTransitionOpts = {\n          currentLocation: location,\n          nextLocation: state.location,\n        };\n      }\n    } else if (pendingViewTransitionEnabled) {\n      // Store the applied transition on PUSH/REPLACE\n      let toPaths = appliedViewTransitions.get(state.location.pathname);\n      if (toPaths) {\n        toPaths.add(location.pathname);\n      } else {\n        toPaths = new Set<string>([location.pathname]);\n        appliedViewTransitions.set(state.location.pathname, toPaths);\n      }\n      viewTransitionOpts = {\n        currentLocation: state.location,\n        nextLocation: location,\n      };\n    }\n\n    updateState(\n      {\n        ...newState, // matches, errors, fetchers go through as-is\n        actionData,\n        loaderData,\n        historyAction: pendingAction,\n        location,\n        initialized: true,\n        navigation: IDLE_NAVIGATION,\n        revalidation: \"idle\",\n        restoreScrollPosition: getSavedScrollPosition(\n          location,\n          newState.matches || state.matches\n        ),\n        preventScrollReset,\n        blockers,\n      },\n      {\n        viewTransitionOpts,\n        flushSync: flushSync === true,\n      }\n    );\n\n    // Reset stateful navigation vars\n    pendingAction = HistoryAction.Pop;\n    pendingPreventScrollReset = false;\n    pendingViewTransitionEnabled = false;\n    isUninterruptedRevalidation = false;\n    isRevalidationRequired = false;\n    cancelledDeferredRoutes = [];\n  }\n\n  // Trigger a navigation event, which can either be a numerical POP or a PUSH\n  // replace with an optional submission\n  async function navigate(\n    to: number | To | null,\n    opts?: RouterNavigateOptions\n  ): Promise<void> {\n    if (typeof to === \"number\") {\n      init.history.go(to);\n      return;\n    }\n\n    let normalizedPath = normalizeTo(\n      state.location,\n      state.matches,\n      basename,\n      future.v7_prependBasename,\n      to,\n      future.v7_relativeSplatPath,\n      opts?.fromRouteId,\n      opts?.relative\n    );\n    let { path, submission, error } = normalizeNavigateOptions(\n      future.v7_normalizeFormMethod,\n      false,\n      normalizedPath,\n      opts\n    );\n\n    let currentLocation = state.location;\n    let nextLocation = createLocation(state.location, path, opts && opts.state);\n\n    // When using navigate as a PUSH/REPLACE we aren't reading an already-encoded\n    // URL from window.location, so we need to encode it here so the behavior\n    // remains the same as POP and non-data-router usages.  new URL() does all\n    // the same encoding we'd get from a history.pushState/window.location read\n    // without having to touch history\n    nextLocation = {\n      ...nextLocation,\n      ...init.history.encodeLocation(nextLocation),\n    };\n\n    let userReplace = opts && opts.replace != null ? opts.replace : undefined;\n\n    let historyAction = HistoryAction.Push;\n\n    if (userReplace === true) {\n      historyAction = HistoryAction.Replace;\n    } else if (userReplace === false) {\n      // no-op\n    } else if (\n      submission != null &&\n      isMutationMethod(submission.formMethod) &&\n      submission.formAction === state.location.pathname + state.location.search\n    ) {\n      // By default on submissions to the current location we REPLACE so that\n      // users don't have to double-click the back button to get to the prior\n      // location.  If the user redirects to a different location from the\n      // action/loader this will be ignored and the redirect will be a PUSH\n      historyAction = HistoryAction.Replace;\n    }\n\n    let preventScrollReset =\n      opts && \"preventScrollReset\" in opts\n        ? opts.preventScrollReset === true\n        : undefined;\n\n    let flushSync = (opts && opts.flushSync) === true;\n\n    let blockerKey = shouldBlockNavigation({\n      currentLocation,\n      nextLocation,\n      historyAction,\n    });\n\n    if (blockerKey) {\n      // Put the blocker into a blocked state\n      updateBlocker(blockerKey, {\n        state: \"blocked\",\n        location: nextLocation,\n        proceed() {\n          updateBlocker(blockerKey!, {\n            state: \"proceeding\",\n            proceed: undefined,\n            reset: undefined,\n            location: nextLocation,\n          });\n          // Send the same navigation through\n          navigate(to, opts);\n        },\n        reset() {\n          let blockers = new Map(state.blockers);\n          blockers.set(blockerKey!, IDLE_BLOCKER);\n          updateState({ blockers });\n        },\n      });\n      return;\n    }\n\n    return await startNavigation(historyAction, nextLocation, {\n      submission,\n      // Send through the formData serialization error if we have one so we can\n      // render at the right error boundary after we match routes\n      pendingError: error,\n      preventScrollReset,\n      replace: opts && opts.replace,\n      enableViewTransition: opts && opts.viewTransition,\n      flushSync,\n    });\n  }\n\n  // Revalidate all current loaders.  If a navigation is in progress or if this\n  // is interrupted by a navigation, allow this to \"succeed\" by calling all\n  // loaders during the next loader round\n  function revalidate() {\n    interruptActiveLoads();\n    updateState({ revalidation: \"loading\" });\n\n    // If we're currently submitting an action, we don't need to start a new\n    // navigation, we'll just let the follow up loader execution call all loaders\n    if (state.navigation.state === \"submitting\") {\n      return;\n    }\n\n    // If we're currently in an idle state, start a new navigation for the current\n    // action/location and mark it as uninterrupted, which will skip the history\n    // update in completeNavigation\n    if (state.navigation.state === \"idle\") {\n      startNavigation(state.historyAction, state.location, {\n        startUninterruptedRevalidation: true,\n      });\n      return;\n    }\n\n    // Otherwise, if we're currently in a loading state, just start a new\n    // navigation to the navigation.location but do not trigger an uninterrupted\n    // revalidation so that history correctly updates once the navigation completes\n    startNavigation(\n      pendingAction || state.historyAction,\n      state.navigation.location,\n      {\n        overrideNavigation: state.navigation,\n        // Proxy through any rending view transition\n        enableViewTransition: pendingViewTransitionEnabled === true,\n      }\n    );\n  }\n\n  // Start a navigation to the given action/location.  Can optionally provide a\n  // overrideNavigation which will override the normalLoad in the case of a redirect\n  // navigation\n  async function startNavigation(\n    historyAction: HistoryAction,\n    location: Location,\n    opts?: {\n      initialHydration?: boolean;\n      submission?: Submission;\n      fetcherSubmission?: Submission;\n      overrideNavigation?: Navigation;\n      pendingError?: ErrorResponseImpl;\n      startUninterruptedRevalidation?: boolean;\n      preventScrollReset?: boolean;\n      replace?: boolean;\n      enableViewTransition?: boolean;\n      flushSync?: boolean;\n    }\n  ): Promise<void> {\n    // Abort any in-progress navigations and start a new one. Unset any ongoing\n    // uninterrupted revalidations unless told otherwise, since we want this\n    // new navigation to update history normally\n    pendingNavigationController && pendingNavigationController.abort();\n    pendingNavigationController = null;\n    pendingAction = historyAction;\n    isUninterruptedRevalidation =\n      (opts && opts.startUninterruptedRevalidation) === true;\n\n    // Save the current scroll position every time we start a new navigation,\n    // and track whether we should reset scroll on completion\n    saveScrollPosition(state.location, state.matches);\n    pendingPreventScrollReset = (opts && opts.preventScrollReset) === true;\n\n    pendingViewTransitionEnabled = (opts && opts.enableViewTransition) === true;\n\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    let loadingNavigation = opts && opts.overrideNavigation;\n    let matches =\n      opts?.initialHydration &&\n      state.matches &&\n      state.matches.length > 0 &&\n      !initialMatchesIsFOW\n        ? // `matchRoutes()` has already been called if we're in here via `router.initialize()`\n          state.matches\n        : matchRoutes(routesToUse, location, basename);\n    let flushSync = (opts && opts.flushSync) === true;\n\n    // Short circuit if it's only a hash change and not a revalidation or\n    // mutation submission.\n    //\n    // Ignore on initial page loads because since the initial hydration will always\n    // be \"same hash\".  For example, on /page#hash and submit a <Form method=\"post\">\n    // which will default to a navigation to /page\n    if (\n      matches &&\n      state.initialized &&\n      !isRevalidationRequired &&\n      isHashChangeOnly(state.location, location) &&\n      !(opts && opts.submission && isMutationMethod(opts.submission.formMethod))\n    ) {\n      completeNavigation(location, { matches }, { flushSync });\n      return;\n    }\n\n    let fogOfWar = checkFogOfWar(matches, routesToUse, location.pathname);\n    if (fogOfWar.active && fogOfWar.matches) {\n      matches = fogOfWar.matches;\n    }\n\n    // Short circuit with a 404 on the root error boundary if we match nothing\n    if (!matches) {\n      let { error, notFoundMatches, route } = handleNavigational404(\n        location.pathname\n      );\n      completeNavigation(\n        location,\n        {\n          matches: notFoundMatches,\n          loaderData: {},\n          errors: {\n            [route.id]: error,\n          },\n        },\n        { flushSync }\n      );\n      return;\n    }\n\n    // Create a controller/Request for this navigation\n    pendingNavigationController = new AbortController();\n    let request = createClientSideRequest(\n      init.history,\n      location,\n      pendingNavigationController.signal,\n      opts && opts.submission\n    );\n    let pendingActionResult: PendingActionResult | undefined;\n\n    if (opts && opts.pendingError) {\n      // If we have a pendingError, it means the user attempted a GET submission\n      // with binary FormData so assign here and skip to handleLoaders.  That\n      // way we handle calling loaders above the boundary etc.  It's not really\n      // different from an actionError in that sense.\n      pendingActionResult = [\n        findNearestBoundary(matches).route.id,\n        { type: ResultType.error, error: opts.pendingError },\n      ];\n    } else if (\n      opts &&\n      opts.submission &&\n      isMutationMethod(opts.submission.formMethod)\n    ) {\n      // Call action if we received an action submission\n      let actionResult = await handleAction(\n        request,\n        location,\n        opts.submission,\n        matches,\n        fogOfWar.active,\n        { replace: opts.replace, flushSync }\n      );\n\n      if (actionResult.shortCircuited) {\n        return;\n      }\n\n      // If we received a 404 from handleAction, it's because we couldn't lazily\n      // discover the destination route so we don't want to call loaders\n      if (actionResult.pendingActionResult) {\n        let [routeId, result] = actionResult.pendingActionResult;\n        if (\n          isErrorResult(result) &&\n          isRouteErrorResponse(result.error) &&\n          result.error.status === 404\n        ) {\n          pendingNavigationController = null;\n\n          completeNavigation(location, {\n            matches: actionResult.matches,\n            loaderData: {},\n            errors: {\n              [routeId]: result.error,\n            },\n          });\n          return;\n        }\n      }\n\n      matches = actionResult.matches || matches;\n      pendingActionResult = actionResult.pendingActionResult;\n      loadingNavigation = getLoadingNavigation(location, opts.submission);\n      flushSync = false;\n      // No need to do fog of war matching again on loader execution\n      fogOfWar.active = false;\n\n      // Create a GET request for the loaders\n      request = createClientSideRequest(\n        init.history,\n        request.url,\n        request.signal\n      );\n    }\n\n    // Call loaders\n    let {\n      shortCircuited,\n      matches: updatedMatches,\n      loaderData,\n      errors,\n    } = await handleLoaders(\n      request,\n      location,\n      matches,\n      fogOfWar.active,\n      loadingNavigation,\n      opts && opts.submission,\n      opts && opts.fetcherSubmission,\n      opts && opts.replace,\n      opts && opts.initialHydration === true,\n      flushSync,\n      pendingActionResult\n    );\n\n    if (shortCircuited) {\n      return;\n    }\n\n    // Clean up now that the action/loaders have completed.  Don't clean up if\n    // we short circuited because pendingNavigationController will have already\n    // been assigned to a new controller for the next navigation\n    pendingNavigationController = null;\n\n    completeNavigation(location, {\n      matches: updatedMatches || matches,\n      ...getActionDataForCommit(pendingActionResult),\n      loaderData,\n      errors,\n    });\n  }\n\n  // Call the action matched by the leaf route for this navigation and handle\n  // redirects/errors\n  async function handleAction(\n    request: Request,\n    location: Location,\n    submission: Submission,\n    matches: AgnosticDataRouteMatch[],\n    isFogOfWar: boolean,\n    opts: { replace?: boolean; flushSync?: boolean } = {}\n  ): Promise<HandleActionResult> {\n    interruptActiveLoads();\n\n    // Put us in a submitting state\n    let navigation = getSubmittingNavigation(location, submission);\n    updateState({ navigation }, { flushSync: opts.flushSync === true });\n\n    if (isFogOfWar) {\n      let discoverResult = await discoverRoutes(\n        matches,\n        location.pathname,\n        request.signal\n      );\n      if (discoverResult.type === \"aborted\") {\n        return { shortCircuited: true };\n      } else if (discoverResult.type === \"error\") {\n        let boundaryId = findNearestBoundary(discoverResult.partialMatches)\n          .route.id;\n        return {\n          matches: discoverResult.partialMatches,\n          pendingActionResult: [\n            boundaryId,\n            {\n              type: ResultType.error,\n              error: discoverResult.error,\n            },\n          ],\n        };\n      } else if (!discoverResult.matches) {\n        let { notFoundMatches, error, route } = handleNavigational404(\n          location.pathname\n        );\n        return {\n          matches: notFoundMatches,\n          pendingActionResult: [\n            route.id,\n            {\n              type: ResultType.error,\n              error,\n            },\n          ],\n        };\n      } else {\n        matches = discoverResult.matches;\n      }\n    }\n\n    // Call our action and get the result\n    let result: DataResult;\n    let actionMatch = getTargetMatch(matches, location);\n\n    if (!actionMatch.route.action && !actionMatch.route.lazy) {\n      result = {\n        type: ResultType.error,\n        error: getInternalRouterError(405, {\n          method: request.method,\n          pathname: location.pathname,\n          routeId: actionMatch.route.id,\n        }),\n      };\n    } else {\n      let results = await callDataStrategy(\n        \"action\",\n        state,\n        request,\n        [actionMatch],\n        matches,\n        null\n      );\n      result = results[actionMatch.route.id];\n\n      if (request.signal.aborted) {\n        return { shortCircuited: true };\n      }\n    }\n\n    if (isRedirectResult(result)) {\n      let replace: boolean;\n      if (opts && opts.replace != null) {\n        replace = opts.replace;\n      } else {\n        // If the user didn't explicity indicate replace behavior, replace if\n        // we redirected to the exact same location we're currently at to avoid\n        // double back-buttons\n        let location = normalizeRedirectLocation(\n          result.response.headers.get(\"Location\")!,\n          new URL(request.url),\n          basename,\n          init.history,\n        );\n        replace = location === state.location.pathname + state.location.search;\n      }\n      await startRedirectNavigation(request, result, true, {\n        submission,\n        replace,\n      });\n      return { shortCircuited: true };\n    }\n\n    if (isDeferredResult(result)) {\n      throw getInternalRouterError(400, { type: \"defer-action\" });\n    }\n\n    if (isErrorResult(result)) {\n      // Store off the pending error - we use it to determine which loaders\n      // to call and will commit it when we complete the navigation\n      let boundaryMatch = findNearestBoundary(matches, actionMatch.route.id);\n\n      // By default, all submissions to the current location are REPLACE\n      // navigations, but if the action threw an error that'll be rendered in\n      // an errorElement, we fall back to PUSH so that the user can use the\n      // back button to get back to the pre-submission form location to try\n      // again\n      if ((opts && opts.replace) !== true) {\n        pendingAction = HistoryAction.Push;\n      }\n\n      return {\n        matches,\n        pendingActionResult: [boundaryMatch.route.id, result],\n      };\n    }\n\n    return {\n      matches,\n      pendingActionResult: [actionMatch.route.id, result],\n    };\n  }\n\n  // Call all applicable loaders for the given matches, handling redirects,\n  // errors, etc.\n  async function handleLoaders(\n    request: Request,\n    location: Location,\n    matches: AgnosticDataRouteMatch[],\n    isFogOfWar: boolean,\n    overrideNavigation?: Navigation,\n    submission?: Submission,\n    fetcherSubmission?: Submission,\n    replace?: boolean,\n    initialHydration?: boolean,\n    flushSync?: boolean,\n    pendingActionResult?: PendingActionResult\n  ): Promise<HandleLoadersResult> {\n    // Figure out the right navigation we want to use for data loading\n    let loadingNavigation =\n      overrideNavigation || getLoadingNavigation(location, submission);\n\n    // If this was a redirect from an action we don't have a \"submission\" but\n    // we have it on the loading navigation so use that if available\n    let activeSubmission =\n      submission ||\n      fetcherSubmission ||\n      getSubmissionFromNavigation(loadingNavigation);\n\n    // If this is an uninterrupted revalidation, we remain in our current idle\n    // state.  If not, we need to switch to our loading state and load data,\n    // preserving any new action data or existing action data (in the case of\n    // a revalidation interrupting an actionReload)\n    // If we have partialHydration enabled, then don't update the state for the\n    // initial data load since it's not a \"navigation\"\n    let shouldUpdateNavigationState =\n      !isUninterruptedRevalidation &&\n      (!future.v7_partialHydration || !initialHydration);\n\n    // When fog of war is enabled, we enter our `loading` state earlier so we\n    // can discover new routes during the `loading` state.  We skip this if\n    // we've already run actions since we would have done our matching already.\n    // If the children() function threw then, we want to proceed with the\n    // partial matches it discovered.\n    if (isFogOfWar) {\n      if (shouldUpdateNavigationState) {\n        let actionData = getUpdatedActionData(pendingActionResult);\n        updateState(\n          {\n            navigation: loadingNavigation,\n            ...(actionData !== undefined ? { actionData } : {}),\n          },\n          {\n            flushSync,\n          }\n        );\n      }\n\n      let discoverResult = await discoverRoutes(\n        matches,\n        location.pathname,\n        request.signal\n      );\n\n      if (discoverResult.type === \"aborted\") {\n        return { shortCircuited: true };\n      } else if (discoverResult.type === \"error\") {\n        let boundaryId = findNearestBoundary(discoverResult.partialMatches)\n          .route.id;\n        return {\n          matches: discoverResult.partialMatches,\n          loaderData: {},\n          errors: {\n            [boundaryId]: discoverResult.error,\n          },\n        };\n      } else if (!discoverResult.matches) {\n        let { error, notFoundMatches, route } = handleNavigational404(\n          location.pathname\n        );\n        return {\n          matches: notFoundMatches,\n          loaderData: {},\n          errors: {\n            [route.id]: error,\n          },\n        };\n      } else {\n        matches = discoverResult.matches;\n      }\n    }\n\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(\n      init.history,\n      state,\n      matches,\n      activeSubmission,\n      location,\n      future.v7_partialHydration && initialHydration === true,\n      future.v7_skipActionErrorRevalidation,\n      isRevalidationRequired,\n      cancelledDeferredRoutes,\n      cancelledFetcherLoads,\n      deletedFetchers,\n      fetchLoadMatches,\n      fetchRedirectIds,\n      routesToUse,\n      basename,\n      pendingActionResult\n    );\n\n    // Cancel pending deferreds for no-longer-matched routes or routes we're\n    // about to reload.  Note that if this is an action reload we would have\n    // already cancelled all pending deferreds so this would be a no-op\n    cancelActiveDeferreds(\n      (routeId) =>\n        !(matches && matches.some((m) => m.route.id === routeId)) ||\n        (matchesToLoad && matchesToLoad.some((m) => m.route.id === routeId))\n    );\n\n    pendingNavigationLoadId = ++incrementingLoadId;\n\n    // Short circuit if we have no loaders to run\n    if (matchesToLoad.length === 0 && revalidatingFetchers.length === 0) {\n      let updatedFetchers = markFetchRedirectsDone();\n      completeNavigation(\n        location,\n        {\n          matches,\n          loaderData: {},\n          // Commit pending error if we're short circuiting\n          errors:\n            pendingActionResult && isErrorResult(pendingActionResult[1])\n              ? { [pendingActionResult[0]]: pendingActionResult[1].error }\n              : null,\n          ...getActionDataForCommit(pendingActionResult),\n          ...(updatedFetchers ? { fetchers: new Map(state.fetchers) } : {}),\n        },\n        { flushSync }\n      );\n      return { shortCircuited: true };\n    }\n\n    if (shouldUpdateNavigationState) {\n      let updates: Partial<RouterState> = {};\n      if (!isFogOfWar) {\n        // Only update navigation/actionNData if we didn't already do it above\n        updates.navigation = loadingNavigation;\n        let actionData = getUpdatedActionData(pendingActionResult);\n        if (actionData !== undefined) {\n          updates.actionData = actionData;\n        }\n      }\n      if (revalidatingFetchers.length > 0) {\n        updates.fetchers = getUpdatedRevalidatingFetchers(revalidatingFetchers);\n      }\n      updateState(updates, { flushSync });\n    }\n\n    revalidatingFetchers.forEach((rf) => {\n      abortFetcher(rf.key);\n      if (rf.controller) {\n        // Fetchers use an independent AbortController so that aborting a fetcher\n        // (via deleteFetcher) does not abort the triggering navigation that\n        // triggered the revalidation\n        fetchControllers.set(rf.key, rf.controller);\n      }\n    });\n\n    // Proxy navigation abort through to revalidation fetchers\n    let abortPendingFetchRevalidations = () =>\n      revalidatingFetchers.forEach((f) => abortFetcher(f.key));\n    if (pendingNavigationController) {\n      pendingNavigationController.signal.addEventListener(\n        \"abort\",\n        abortPendingFetchRevalidations\n      );\n    }\n\n    let { loaderResults, fetcherResults } =\n      await callLoadersAndMaybeResolveData(\n        state,\n        matches,\n        matchesToLoad,\n        revalidatingFetchers,\n        request\n      );\n\n    if (request.signal.aborted) {\n      return { shortCircuited: true };\n    }\n\n    // Clean up _after_ loaders have completed.  Don't clean up if we short\n    // circuited because fetchControllers would have been aborted and\n    // reassigned to new controllers for the next navigation\n    if (pendingNavigationController) {\n      pendingNavigationController.signal.removeEventListener(\n        \"abort\",\n        abortPendingFetchRevalidations\n      );\n    }\n\n    revalidatingFetchers.forEach((rf) => fetchControllers.delete(rf.key));\n\n    // If any loaders returned a redirect Response, start a new REPLACE navigation\n    let redirect = findRedirect(loaderResults);\n    if (redirect) {\n      await startRedirectNavigation(request, redirect.result, true, {\n        replace,\n      });\n      return { shortCircuited: true };\n    }\n\n    redirect = findRedirect(fetcherResults);\n    if (redirect) {\n      // If this redirect came from a fetcher make sure we mark it in\n      // fetchRedirectIds so it doesn't get revalidated on the next set of\n      // loader executions\n      fetchRedirectIds.add(redirect.key);\n      await startRedirectNavigation(request, redirect.result, true, {\n        replace,\n      });\n      return { shortCircuited: true };\n    }\n\n    // Process and commit output from loaders\n    let { loaderData, errors } = processLoaderData(\n      state,\n      matches,\n      loaderResults,\n      pendingActionResult,\n      revalidatingFetchers,\n      fetcherResults,\n      activeDeferreds\n    );\n\n    // Wire up subscribers to update loaderData as promises settle\n    activeDeferreds.forEach((deferredData, routeId) => {\n      deferredData.subscribe((aborted) => {\n        // Note: No need to updateState here since the TrackedPromise on\n        // loaderData is stable across resolve/reject\n        // Remove this instance if we were aborted or if promises have settled\n        if (aborted || deferredData.done) {\n          activeDeferreds.delete(routeId);\n        }\n      });\n    });\n\n    // Preserve SSR errors during partial hydration\n    if (future.v7_partialHydration && initialHydration && state.errors) {\n      errors = { ...state.errors, ...errors };\n    }\n\n    let updatedFetchers = markFetchRedirectsDone();\n    let didAbortFetchLoads = abortStaleFetchLoads(pendingNavigationLoadId);\n    let shouldUpdateFetchers =\n      updatedFetchers || didAbortFetchLoads || revalidatingFetchers.length > 0;\n\n    return {\n      matches,\n      loaderData,\n      errors,\n      ...(shouldUpdateFetchers ? { fetchers: new Map(state.fetchers) } : {}),\n    };\n  }\n\n  function getUpdatedActionData(\n    pendingActionResult: PendingActionResult | undefined\n  ): Record<string, RouteData> | null | undefined {\n    if (pendingActionResult && !isErrorResult(pendingActionResult[1])) {\n      // This is cast to `any` currently because `RouteData`uses any and it\n      // would be a breaking change to use any.\n      // TODO: v7 - change `RouteData` to use `unknown` instead of `any`\n      return {\n        [pendingActionResult[0]]: pendingActionResult[1].data as any,\n      };\n    } else if (state.actionData) {\n      if (Object.keys(state.actionData).length === 0) {\n        return null;\n      } else {\n        return state.actionData;\n      }\n    }\n  }\n\n  function getUpdatedRevalidatingFetchers(\n    revalidatingFetchers: RevalidatingFetcher[]\n  ) {\n    revalidatingFetchers.forEach((rf) => {\n      let fetcher = state.fetchers.get(rf.key);\n      let revalidatingFetcher = getLoadingFetcher(\n        undefined,\n        fetcher ? fetcher.data : undefined\n      );\n      state.fetchers.set(rf.key, revalidatingFetcher);\n    });\n    return new Map(state.fetchers);\n  }\n\n  // Trigger a fetcher load/submit for the given fetcher key\n  function fetch(\n    key: string,\n    routeId: string,\n    href: string | null,\n    opts?: RouterFetchOptions\n  ) {\n    if (isServer) {\n      throw new Error(\n        \"router.fetch() was called during the server render, but it shouldn't be. \" +\n          \"You are likely calling a useFetcher() method in the body of your component. \" +\n          \"Try moving it to a useEffect or a callback.\"\n      );\n    }\n\n    abortFetcher(key);\n\n    let flushSync = (opts && opts.flushSync) === true;\n\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    let normalizedPath = normalizeTo(\n      state.location,\n      state.matches,\n      basename,\n      future.v7_prependBasename,\n      href,\n      future.v7_relativeSplatPath,\n      routeId,\n      opts?.relative\n    );\n    let matches = matchRoutes(routesToUse, normalizedPath, basename);\n\n    let fogOfWar = checkFogOfWar(matches, routesToUse, normalizedPath);\n    if (fogOfWar.active && fogOfWar.matches) {\n      matches = fogOfWar.matches;\n    }\n\n    if (!matches) {\n      setFetcherError(\n        key,\n        routeId,\n        getInternalRouterError(404, { pathname: normalizedPath }),\n        { flushSync }\n      );\n      return;\n    }\n\n    let { path, submission, error } = normalizeNavigateOptions(\n      future.v7_normalizeFormMethod,\n      true,\n      normalizedPath,\n      opts\n    );\n\n    if (error) {\n      setFetcherError(key, routeId, error, { flushSync });\n      return;\n    }\n\n    let match = getTargetMatch(matches, path);\n\n    let preventScrollReset = (opts && opts.preventScrollReset) === true;\n\n    if (submission && isMutationMethod(submission.formMethod)) {\n      handleFetcherAction(\n        key,\n        routeId,\n        path,\n        match,\n        matches,\n        fogOfWar.active,\n        flushSync,\n        preventScrollReset,\n        submission\n      );\n      return;\n    }\n\n    // Store off the match so we can call it's shouldRevalidate on subsequent\n    // revalidations\n    fetchLoadMatches.set(key, { routeId, path });\n    handleFetcherLoader(\n      key,\n      routeId,\n      path,\n      match,\n      matches,\n      fogOfWar.active,\n      flushSync,\n      preventScrollReset,\n      submission\n    );\n  }\n\n  // Call the action for the matched fetcher.submit(), and then handle redirects,\n  // errors, and revalidation\n  async function handleFetcherAction(\n    key: string,\n    routeId: string,\n    path: string,\n    match: AgnosticDataRouteMatch,\n    requestMatches: AgnosticDataRouteMatch[],\n    isFogOfWar: boolean,\n    flushSync: boolean,\n    preventScrollReset: boolean,\n    submission: Submission\n  ) {\n    interruptActiveLoads();\n    fetchLoadMatches.delete(key);\n\n    function detectAndHandle405Error(m: AgnosticDataRouteMatch) {\n      if (!m.route.action && !m.route.lazy) {\n        let error = getInternalRouterError(405, {\n          method: submission.formMethod,\n          pathname: path,\n          routeId: routeId,\n        });\n        setFetcherError(key, routeId, error, { flushSync });\n        return true;\n      }\n      return false;\n    }\n\n    if (!isFogOfWar && detectAndHandle405Error(match)) {\n      return;\n    }\n\n    // Put this fetcher into it's submitting state\n    let existingFetcher = state.fetchers.get(key);\n    updateFetcherState(key, getSubmittingFetcher(submission, existingFetcher), {\n      flushSync,\n    });\n\n    let abortController = new AbortController();\n    let fetchRequest = createClientSideRequest(\n      init.history,\n      path,\n      abortController.signal,\n      submission\n    );\n\n    if (isFogOfWar) {\n      let discoverResult = await discoverRoutes(\n        requestMatches,\n        new URL(fetchRequest.url).pathname,\n        fetchRequest.signal,\n        key\n      );\n\n      if (discoverResult.type === \"aborted\") {\n        return;\n      } else if (discoverResult.type === \"error\") {\n        setFetcherError(key, routeId, discoverResult.error, { flushSync });\n        return;\n      } else if (!discoverResult.matches) {\n        setFetcherError(\n          key,\n          routeId,\n          getInternalRouterError(404, { pathname: path }),\n          { flushSync }\n        );\n        return;\n      } else {\n        requestMatches = discoverResult.matches;\n        match = getTargetMatch(requestMatches, path);\n\n        if (detectAndHandle405Error(match)) {\n          return;\n        }\n      }\n    }\n\n    // Call the action for the fetcher\n    fetchControllers.set(key, abortController);\n\n    let originatingLoadId = incrementingLoadId;\n    let actionResults = await callDataStrategy(\n      \"action\",\n      state,\n      fetchRequest,\n      [match],\n      requestMatches,\n      key\n    );\n    let actionResult = actionResults[match.route.id];\n\n    if (fetchRequest.signal.aborted) {\n      // We can delete this so long as we weren't aborted by our own fetcher\n      // re-submit which would have put _new_ controller is in fetchControllers\n      if (fetchControllers.get(key) === abortController) {\n        fetchControllers.delete(key);\n      }\n      return;\n    }\n\n    // When using v7_fetcherPersist, we don't want errors bubbling up to the UI\n    // or redirects processed for unmounted fetchers so we just revert them to\n    // idle\n    if (future.v7_fetcherPersist && deletedFetchers.has(key)) {\n      if (isRedirectResult(actionResult) || isErrorResult(actionResult)) {\n        updateFetcherState(key, getDoneFetcher(undefined));\n        return;\n      }\n      // Let SuccessResult's fall through for revalidation\n    } else {\n      if (isRedirectResult(actionResult)) {\n        fetchControllers.delete(key);\n        if (pendingNavigationLoadId > originatingLoadId) {\n          // A new navigation was kicked off after our action started, so that\n          // should take precedence over this redirect navigation.  We already\n          // set isRevalidationRequired so all loaders for the new route should\n          // fire unless opted out via shouldRevalidate\n          updateFetcherState(key, getDoneFetcher(undefined));\n          return;\n        } else {\n          fetchRedirectIds.add(key);\n          updateFetcherState(key, getLoadingFetcher(submission));\n          return startRedirectNavigation(fetchRequest, actionResult, false, {\n            fetcherSubmission: submission,\n            preventScrollReset,\n          });\n        }\n      }\n\n      // Process any non-redirect errors thrown\n      if (isErrorResult(actionResult)) {\n        setFetcherError(key, routeId, actionResult.error);\n        return;\n      }\n    }\n\n    if (isDeferredResult(actionResult)) {\n      throw getInternalRouterError(400, { type: \"defer-action\" });\n    }\n\n    // Start the data load for current matches, or the next location if we're\n    // in the middle of a navigation\n    let nextLocation = state.navigation.location || state.location;\n    let revalidationRequest = createClientSideRequest(\n      init.history,\n      nextLocation,\n      abortController.signal\n    );\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    let matches =\n      state.navigation.state !== \"idle\"\n        ? matchRoutes(routesToUse, state.navigation.location, basename)\n        : state.matches;\n\n    invariant(matches, \"Didn't find any matches after fetcher action\");\n\n    let loadId = ++incrementingLoadId;\n    fetchReloadIds.set(key, loadId);\n\n    let loadFetcher = getLoadingFetcher(submission, actionResult.data);\n    state.fetchers.set(key, loadFetcher);\n\n    let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(\n      init.history,\n      state,\n      matches,\n      submission,\n      nextLocation,\n      false,\n      future.v7_skipActionErrorRevalidation,\n      isRevalidationRequired,\n      cancelledDeferredRoutes,\n      cancelledFetcherLoads,\n      deletedFetchers,\n      fetchLoadMatches,\n      fetchRedirectIds,\n      routesToUse,\n      basename,\n      [match.route.id, actionResult]\n    );\n\n    // Put all revalidating fetchers into the loading state, except for the\n    // current fetcher which we want to keep in it's current loading state which\n    // contains it's action submission info + action data\n    revalidatingFetchers\n      .filter((rf) => rf.key !== key)\n      .forEach((rf) => {\n        let staleKey = rf.key;\n        let existingFetcher = state.fetchers.get(staleKey);\n        let revalidatingFetcher = getLoadingFetcher(\n          undefined,\n          existingFetcher ? existingFetcher.data : undefined\n        );\n        state.fetchers.set(staleKey, revalidatingFetcher);\n        abortFetcher(staleKey);\n        if (rf.controller) {\n          fetchControllers.set(staleKey, rf.controller);\n        }\n      });\n\n    updateState({ fetchers: new Map(state.fetchers) });\n\n    let abortPendingFetchRevalidations = () =>\n      revalidatingFetchers.forEach((rf) => abortFetcher(rf.key));\n\n    abortController.signal.addEventListener(\n      \"abort\",\n      abortPendingFetchRevalidations\n    );\n\n    let { loaderResults, fetcherResults } =\n      await callLoadersAndMaybeResolveData(\n        state,\n        matches,\n        matchesToLoad,\n        revalidatingFetchers,\n        revalidationRequest\n      );\n\n    if (abortController.signal.aborted) {\n      return;\n    }\n\n    abortController.signal.removeEventListener(\n      \"abort\",\n      abortPendingFetchRevalidations\n    );\n\n    fetchReloadIds.delete(key);\n    fetchControllers.delete(key);\n    revalidatingFetchers.forEach((r) => fetchControllers.delete(r.key));\n\n    let redirect = findRedirect(loaderResults);\n    if (redirect) {\n      return startRedirectNavigation(\n        revalidationRequest,\n        redirect.result,\n        false,\n        { preventScrollReset }\n      );\n    }\n\n    redirect = findRedirect(fetcherResults);\n    if (redirect) {\n      // If this redirect came from a fetcher make sure we mark it in\n      // fetchRedirectIds so it doesn't get revalidated on the next set of\n      // loader executions\n      fetchRedirectIds.add(redirect.key);\n      return startRedirectNavigation(\n        revalidationRequest,\n        redirect.result,\n        false,\n        { preventScrollReset }\n      );\n    }\n\n    // Process and commit output from loaders\n    let { loaderData, errors } = processLoaderData(\n      state,\n      matches,\n      loaderResults,\n      undefined,\n      revalidatingFetchers,\n      fetcherResults,\n      activeDeferreds\n    );\n\n    // Since we let revalidations complete even if the submitting fetcher was\n    // deleted, only put it back to idle if it hasn't been deleted\n    if (state.fetchers.has(key)) {\n      let doneFetcher = getDoneFetcher(actionResult.data);\n      state.fetchers.set(key, doneFetcher);\n    }\n\n    abortStaleFetchLoads(loadId);\n\n    // If we are currently in a navigation loading state and this fetcher is\n    // more recent than the navigation, we want the newer data so abort the\n    // navigation and complete it with the fetcher data\n    if (\n      state.navigation.state === \"loading\" &&\n      loadId > pendingNavigationLoadId\n    ) {\n      invariant(pendingAction, \"Expected pending action\");\n      pendingNavigationController && pendingNavigationController.abort();\n\n      completeNavigation(state.navigation.location, {\n        matches,\n        loaderData,\n        errors,\n        fetchers: new Map(state.fetchers),\n      });\n    } else {\n      // otherwise just update with the fetcher data, preserving any existing\n      // loaderData for loaders that did not need to reload.  We have to\n      // manually merge here since we aren't going through completeNavigation\n      updateState({\n        errors,\n        loaderData: mergeLoaderData(\n          state.loaderData,\n          loaderData,\n          matches,\n          errors\n        ),\n        fetchers: new Map(state.fetchers),\n      });\n      isRevalidationRequired = false;\n    }\n  }\n\n  // Call the matched loader for fetcher.load(), handling redirects, errors, etc.\n  async function handleFetcherLoader(\n    key: string,\n    routeId: string,\n    path: string,\n    match: AgnosticDataRouteMatch,\n    matches: AgnosticDataRouteMatch[],\n    isFogOfWar: boolean,\n    flushSync: boolean,\n    preventScrollReset: boolean,\n    submission?: Submission\n  ) {\n    let existingFetcher = state.fetchers.get(key);\n    updateFetcherState(\n      key,\n      getLoadingFetcher(\n        submission,\n        existingFetcher ? existingFetcher.data : undefined\n      ),\n      { flushSync }\n    );\n\n    let abortController = new AbortController();\n    let fetchRequest = createClientSideRequest(\n      init.history,\n      path,\n      abortController.signal\n    );\n\n    if (isFogOfWar) {\n      let discoverResult = await discoverRoutes(\n        matches,\n        new URL(fetchRequest.url).pathname,\n        fetchRequest.signal,\n        key\n      );\n\n      if (discoverResult.type === \"aborted\") {\n        return;\n      } else if (discoverResult.type === \"error\") {\n        setFetcherError(key, routeId, discoverResult.error, { flushSync });\n        return;\n      } else if (!discoverResult.matches) {\n        setFetcherError(\n          key,\n          routeId,\n          getInternalRouterError(404, { pathname: path }),\n          { flushSync }\n        );\n        return;\n      } else {\n        matches = discoverResult.matches;\n        match = getTargetMatch(matches, path);\n      }\n    }\n\n    // Call the loader for this fetcher route match\n    fetchControllers.set(key, abortController);\n\n    let originatingLoadId = incrementingLoadId;\n    let results = await callDataStrategy(\n      \"loader\",\n      state,\n      fetchRequest,\n      [match],\n      matches,\n      key\n    );\n    let result = results[match.route.id];\n\n    // Deferred isn't supported for fetcher loads, await everything and treat it\n    // as a normal load.  resolveDeferredData will return undefined if this\n    // fetcher gets aborted, so we just leave result untouched and short circuit\n    // below if that happens\n    if (isDeferredResult(result)) {\n      result =\n        (await resolveDeferredData(result, fetchRequest.signal, true)) ||\n        result;\n    }\n\n    // We can delete this so long as we weren't aborted by our our own fetcher\n    // re-load which would have put _new_ controller is in fetchControllers\n    if (fetchControllers.get(key) === abortController) {\n      fetchControllers.delete(key);\n    }\n\n    if (fetchRequest.signal.aborted) {\n      return;\n    }\n\n    // We don't want errors bubbling up or redirects followed for unmounted\n    // fetchers, so short circuit here if it was removed from the UI\n    if (deletedFetchers.has(key)) {\n      updateFetcherState(key, getDoneFetcher(undefined));\n      return;\n    }\n\n    // If the loader threw a redirect Response, start a new REPLACE navigation\n    if (isRedirectResult(result)) {\n      if (pendingNavigationLoadId > originatingLoadId) {\n        // A new navigation was kicked off after our loader started, so that\n        // should take precedence over this redirect navigation\n        updateFetcherState(key, getDoneFetcher(undefined));\n        return;\n      } else {\n        fetchRedirectIds.add(key);\n        await startRedirectNavigation(fetchRequest, result, false, {\n          preventScrollReset,\n        });\n        return;\n      }\n    }\n\n    // Process any non-redirect errors thrown\n    if (isErrorResult(result)) {\n      setFetcherError(key, routeId, result.error);\n      return;\n    }\n\n    invariant(!isDeferredResult(result), \"Unhandled fetcher deferred data\");\n\n    // Put the fetcher back into an idle state\n    updateFetcherState(key, getDoneFetcher(result.data));\n  }\n\n  /**\n   * Utility function to handle redirects returned from an action or loader.\n   * Normally, a redirect \"replaces\" the navigation that triggered it.  So, for\n   * example:\n   *\n   *  - user is on /a\n   *  - user clicks a link to /b\n   *  - loader for /b redirects to /c\n   *\n   * In a non-JS app the browser would track the in-flight navigation to /b and\n   * then replace it with /c when it encountered the redirect response.  In\n   * the end it would only ever update the URL bar with /c.\n   *\n   * In client-side routing using pushState/replaceState, we aim to emulate\n   * this behavior and we also do not update history until the end of the\n   * navigation (including processed redirects).  This means that we never\n   * actually touch history until we've processed redirects, so we just use\n   * the history action from the original navigation (PUSH or REPLACE).\n   */\n  async function startRedirectNavigation(\n    request: Request,\n    redirect: RedirectResult,\n    isNavigation: boolean,\n    {\n      submission,\n      fetcherSubmission,\n      preventScrollReset,\n      replace,\n    }: {\n      submission?: Submission;\n      fetcherSubmission?: Submission;\n      preventScrollReset?: boolean;\n      replace?: boolean;\n    } = {}\n  ) {\n    if (redirect.response.headers.has(\"X-Remix-Revalidate\")) {\n      isRevalidationRequired = true;\n    }\n\n    let location = redirect.response.headers.get(\"Location\");\n    invariant(location, \"Expected a Location header on the redirect Response\");\n    location = normalizeRedirectLocation(\n      location,\n      new URL(request.url),\n      basename,\n      init.history,\n    );\n    let redirectLocation = createLocation(state.location, location, {\n      _isRedirect: true,\n    });\n\n    if (isBrowser) {\n      let isDocumentReload = false;\n\n      if (redirect.response.headers.has(\"X-Remix-Reload-Document\")) {\n        // Hard reload if the response contained X-Remix-Reload-Document\n        isDocumentReload = true;\n      } else if (ABSOLUTE_URL_REGEX.test(location)) {\n        const url = init.history.createURL(location);\n        isDocumentReload =\n          // Hard reload if it's an absolute URL to a new origin\n          url.origin !== routerWindow.location.origin ||\n          // Hard reload if it's an absolute URL that does not match our basename\n          stripBasename(url.pathname, basename) == null;\n      }\n\n      if (isDocumentReload) {\n        if (replace) {\n          routerWindow.location.replace(location);\n        } else {\n          routerWindow.location.assign(location);\n        }\n        return;\n      }\n    }\n\n    // There's no need to abort on redirects, since we don't detect the\n    // redirect until the action/loaders have settled\n    pendingNavigationController = null;\n\n    let redirectHistoryAction =\n      replace === true || redirect.response.headers.has(\"X-Remix-Replace\")\n        ? HistoryAction.Replace\n        : HistoryAction.Push;\n\n    // Use the incoming submission if provided, fallback on the active one in\n    // state.navigation\n    let { formMethod, formAction, formEncType } = state.navigation;\n    if (\n      !submission &&\n      !fetcherSubmission &&\n      formMethod &&\n      formAction &&\n      formEncType\n    ) {\n      submission = getSubmissionFromNavigation(state.navigation);\n    }\n\n    // If this was a 307/308 submission we want to preserve the HTTP method and\n    // re-submit the GET/POST/PUT/PATCH/DELETE as a submission navigation to the\n    // redirected location\n    let activeSubmission = submission || fetcherSubmission;\n    if (\n      redirectPreserveMethodStatusCodes.has(redirect.response.status) &&\n      activeSubmission &&\n      isMutationMethod(activeSubmission.formMethod)\n    ) {\n      await startNavigation(redirectHistoryAction, redirectLocation, {\n        submission: {\n          ...activeSubmission,\n          formAction: location,\n        },\n        // Preserve these flags across redirects\n        preventScrollReset: preventScrollReset || pendingPreventScrollReset,\n        enableViewTransition: isNavigation\n          ? pendingViewTransitionEnabled\n          : undefined,\n      });\n    } else {\n      // If we have a navigation submission, we will preserve it through the\n      // redirect navigation\n      let overrideNavigation = getLoadingNavigation(\n        redirectLocation,\n        submission\n      );\n      await startNavigation(redirectHistoryAction, redirectLocation, {\n        overrideNavigation,\n        // Send fetcher submissions through for shouldRevalidate\n        fetcherSubmission,\n        // Preserve these flags across redirects\n        preventScrollReset: preventScrollReset || pendingPreventScrollReset,\n        enableViewTransition: isNavigation\n          ? pendingViewTransitionEnabled\n          : undefined,\n      });\n    }\n  }\n\n  // Utility wrapper for calling dataStrategy client-side without having to\n  // pass around the manifest, mapRouteProperties, etc.\n  async function callDataStrategy(\n    type: \"loader\" | \"action\",\n    state: RouterState,\n    request: Request,\n    matchesToLoad: AgnosticDataRouteMatch[],\n    matches: AgnosticDataRouteMatch[],\n    fetcherKey: string | null\n  ): Promise<Record<string, DataResult>> {\n    let results: Record<string, DataStrategyResult>;\n    let dataResults: Record<string, DataResult> = {};\n    try {\n      results = await callDataStrategyImpl(\n        dataStrategyImpl,\n        type,\n        state,\n        request,\n        matchesToLoad,\n        matches,\n        fetcherKey,\n        manifest,\n        mapRouteProperties\n      );\n    } catch (e) {\n      // If the outer dataStrategy method throws, just return the error for all\n      // matches - and it'll naturally bubble to the root\n      matchesToLoad.forEach((m) => {\n        dataResults[m.route.id] = {\n          type: ResultType.error,\n          error: e,\n        };\n      });\n      return dataResults;\n    }\n\n    for (let [routeId, result] of Object.entries(results)) {\n      if (isRedirectDataStrategyResultResult(result)) {\n        let response = result.result as Response;\n        dataResults[routeId] = {\n          type: ResultType.redirect,\n          response: normalizeRelativeRoutingRedirectResponse(\n            response,\n            request,\n            routeId,\n            matches,\n            basename,\n            future.v7_relativeSplatPath\n          ),\n        };\n      } else {\n        dataResults[routeId] = await convertDataStrategyResultToDataResult(\n          result\n        );\n      }\n    }\n\n    return dataResults;\n  }\n\n  async function callLoadersAndMaybeResolveData(\n    state: RouterState,\n    matches: AgnosticDataRouteMatch[],\n    matchesToLoad: AgnosticDataRouteMatch[],\n    fetchersToLoad: RevalidatingFetcher[],\n    request: Request\n  ) {\n    let currentMatches = state.matches;\n\n    // Kick off loaders and fetchers in parallel\n    let loaderResultsPromise = callDataStrategy(\n      \"loader\",\n      state,\n      request,\n      matchesToLoad,\n      matches,\n      null\n    );\n\n    let fetcherResultsPromise = Promise.all(\n      fetchersToLoad.map(async (f) => {\n        if (f.matches && f.match && f.controller) {\n          let results = await callDataStrategy(\n            \"loader\",\n            state,\n            createClientSideRequest(init.history, f.path, f.controller.signal),\n            [f.match],\n            f.matches,\n            f.key\n          );\n          let result = results[f.match.route.id];\n          // Fetcher results are keyed by fetcher key from here on out, not routeId\n          return { [f.key]: result };\n        } else {\n          return Promise.resolve({\n            [f.key]: {\n              type: ResultType.error,\n              error: getInternalRouterError(404, {\n                pathname: f.path,\n              }),\n            } as ErrorResult,\n          });\n        }\n      })\n    );\n\n    let loaderResults = await loaderResultsPromise;\n    let fetcherResults = (await fetcherResultsPromise).reduce(\n      (acc, r) => Object.assign(acc, r),\n      {}\n    );\n\n    await Promise.all([\n      resolveNavigationDeferredResults(\n        matches,\n        loaderResults,\n        request.signal,\n        currentMatches,\n        state.loaderData\n      ),\n      resolveFetcherDeferredResults(matches, fetcherResults, fetchersToLoad),\n    ]);\n\n    return {\n      loaderResults,\n      fetcherResults,\n    };\n  }\n\n  function interruptActiveLoads() {\n    // Every interruption triggers a revalidation\n    isRevalidationRequired = true;\n\n    // Cancel pending route-level deferreds and mark cancelled routes for\n    // revalidation\n    cancelledDeferredRoutes.push(...cancelActiveDeferreds());\n\n    // Abort in-flight fetcher loads\n    fetchLoadMatches.forEach((_, key) => {\n      if (fetchControllers.has(key)) {\n        cancelledFetcherLoads.add(key);\n      }\n      abortFetcher(key);\n    });\n  }\n\n  function updateFetcherState(\n    key: string,\n    fetcher: Fetcher,\n    opts: { flushSync?: boolean } = {}\n  ) {\n    state.fetchers.set(key, fetcher);\n    updateState(\n      { fetchers: new Map(state.fetchers) },\n      { flushSync: (opts && opts.flushSync) === true }\n    );\n  }\n\n  function setFetcherError(\n    key: string,\n    routeId: string,\n    error: any,\n    opts: { flushSync?: boolean } = {}\n  ) {\n    let boundaryMatch = findNearestBoundary(state.matches, routeId);\n    deleteFetcher(key);\n    updateState(\n      {\n        errors: {\n          [boundaryMatch.route.id]: error,\n        },\n        fetchers: new Map(state.fetchers),\n      },\n      { flushSync: (opts && opts.flushSync) === true }\n    );\n  }\n\n  function getFetcher<TData = any>(key: string): Fetcher<TData> {\n    activeFetchers.set(key, (activeFetchers.get(key) || 0) + 1);\n    // If this fetcher was previously marked for deletion, unmark it since we\n    // have a new instance\n    if (deletedFetchers.has(key)) {\n      deletedFetchers.delete(key);\n    }\n    return state.fetchers.get(key) || IDLE_FETCHER;\n  }\n\n  function deleteFetcher(key: string): void {\n    let fetcher = state.fetchers.get(key);\n    // Don't abort the controller if this is a deletion of a fetcher.submit()\n    // in it's loading phase since - we don't want to abort the corresponding\n    // revalidation and want them to complete and land\n    if (\n      fetchControllers.has(key) &&\n      !(fetcher && fetcher.state === \"loading\" && fetchReloadIds.has(key))\n    ) {\n      abortFetcher(key);\n    }\n    fetchLoadMatches.delete(key);\n    fetchReloadIds.delete(key);\n    fetchRedirectIds.delete(key);\n\n    // If we opted into the flag we can clear this now since we're calling\n    // deleteFetcher() at the end of updateState() and we've already handed the\n    // deleted fetcher keys off to the data layer.\n    // If not, we're eagerly calling deleteFetcher() and we need to keep this\n    // Set populated until the next updateState call, and we'll clear\n    // `deletedFetchers` then\n    if (future.v7_fetcherPersist) {\n      deletedFetchers.delete(key);\n    }\n\n    cancelledFetcherLoads.delete(key);\n    state.fetchers.delete(key);\n  }\n\n  function deleteFetcherAndUpdateState(key: string): void {\n    let count = (activeFetchers.get(key) || 0) - 1;\n    if (count <= 0) {\n      activeFetchers.delete(key);\n      deletedFetchers.add(key);\n      if (!future.v7_fetcherPersist) {\n        deleteFetcher(key);\n      }\n    } else {\n      activeFetchers.set(key, count);\n    }\n\n    updateState({ fetchers: new Map(state.fetchers) });\n  }\n\n  function abortFetcher(key: string) {\n    let controller = fetchControllers.get(key);\n    if (controller) {\n      controller.abort();\n      fetchControllers.delete(key);\n    }\n  }\n\n  function markFetchersDone(keys: string[]) {\n    for (let key of keys) {\n      let fetcher = getFetcher(key);\n      let doneFetcher = getDoneFetcher(fetcher.data);\n      state.fetchers.set(key, doneFetcher);\n    }\n  }\n\n  function markFetchRedirectsDone(): boolean {\n    let doneKeys = [];\n    let updatedFetchers = false;\n    for (let key of fetchRedirectIds) {\n      let fetcher = state.fetchers.get(key);\n      invariant(fetcher, `Expected fetcher: ${key}`);\n      if (fetcher.state === \"loading\") {\n        fetchRedirectIds.delete(key);\n        doneKeys.push(key);\n        updatedFetchers = true;\n      }\n    }\n    markFetchersDone(doneKeys);\n    return updatedFetchers;\n  }\n\n  function abortStaleFetchLoads(landedId: number): boolean {\n    let yeetedKeys = [];\n    for (let [key, id] of fetchReloadIds) {\n      if (id < landedId) {\n        let fetcher = state.fetchers.get(key);\n        invariant(fetcher, `Expected fetcher: ${key}`);\n        if (fetcher.state === \"loading\") {\n          abortFetcher(key);\n          fetchReloadIds.delete(key);\n          yeetedKeys.push(key);\n        }\n      }\n    }\n    markFetchersDone(yeetedKeys);\n    return yeetedKeys.length > 0;\n  }\n\n  function getBlocker(key: string, fn: BlockerFunction) {\n    let blocker: Blocker = state.blockers.get(key) || IDLE_BLOCKER;\n\n    if (blockerFunctions.get(key) !== fn) {\n      blockerFunctions.set(key, fn);\n    }\n\n    return blocker;\n  }\n\n  function deleteBlocker(key: string) {\n    state.blockers.delete(key);\n    blockerFunctions.delete(key);\n  }\n\n  // Utility function to update blockers, ensuring valid state transitions\n  function updateBlocker(key: string, newBlocker: Blocker) {\n    let blocker = state.blockers.get(key) || IDLE_BLOCKER;\n\n    // Poor mans state machine :)\n    // https://mermaid.live/edit#pako:eNqVkc9OwzAMxl8l8nnjAYrEtDIOHEBIgwvKJTReGy3_lDpIqO27k6awMG0XcrLlnz87nwdonESogKXXBuE79rq75XZO3-yHds0RJVuv70YrPlUrCEe2HfrORS3rubqZfuhtpg5C9wk5tZ4VKcRUq88q9Z8RS0-48cE1iHJkL0ugbHuFLus9L6spZy8nX9MP2CNdomVaposqu3fGayT8T8-jJQwhepo_UtpgBQaDEUom04dZhAN1aJBDlUKJBxE1ceB2Smj0Mln-IBW5AFU2dwUiktt_2Qaq2dBfaKdEup85UV7Yd-dKjlnkabl2Pvr0DTkTreM\n    invariant(\n      (blocker.state === \"unblocked\" && newBlocker.state === \"blocked\") ||\n        (blocker.state === \"blocked\" && newBlocker.state === \"blocked\") ||\n        (blocker.state === \"blocked\" && newBlocker.state === \"proceeding\") ||\n        (blocker.state === \"blocked\" && newBlocker.state === \"unblocked\") ||\n        (blocker.state === \"proceeding\" && newBlocker.state === \"unblocked\"),\n      `Invalid blocker state transition: ${blocker.state} -> ${newBlocker.state}`\n    );\n\n    let blockers = new Map(state.blockers);\n    blockers.set(key, newBlocker);\n    updateState({ blockers });\n  }\n\n  function shouldBlockNavigation({\n    currentLocation,\n    nextLocation,\n    historyAction,\n  }: {\n    currentLocation: Location;\n    nextLocation: Location;\n    historyAction: HistoryAction;\n  }): string | undefined {\n    if (blockerFunctions.size === 0) {\n      return;\n    }\n\n    // We ony support a single active blocker at the moment since we don't have\n    // any compelling use cases for multi-blocker yet\n    if (blockerFunctions.size > 1) {\n      warning(false, \"A router only supports one blocker at a time\");\n    }\n\n    let entries = Array.from(blockerFunctions.entries());\n    let [blockerKey, blockerFunction] = entries[entries.length - 1];\n    let blocker = state.blockers.get(blockerKey);\n\n    if (blocker && blocker.state === \"proceeding\") {\n      // If the blocker is currently proceeding, we don't need to re-check\n      // it and can let this navigation continue\n      return;\n    }\n\n    // At this point, we know we're unblocked/blocked so we need to check the\n    // user-provided blocker function\n    if (blockerFunction({ currentLocation, nextLocation, historyAction })) {\n      return blockerKey;\n    }\n  }\n\n  function handleNavigational404(pathname: string) {\n    let error = getInternalRouterError(404, { pathname });\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    let { matches, route } = getShortCircuitMatches(routesToUse);\n\n    // Cancel all pending deferred on 404s since we don't keep any routes\n    cancelActiveDeferreds();\n\n    return { notFoundMatches: matches, route, error };\n  }\n\n  function cancelActiveDeferreds(\n    predicate?: (routeId: string) => boolean\n  ): string[] {\n    let cancelledRouteIds: string[] = [];\n    activeDeferreds.forEach((dfd, routeId) => {\n      if (!predicate || predicate(routeId)) {\n        // Cancel the deferred - but do not remove from activeDeferreds here -\n        // we rely on the subscribers to do that so our tests can assert proper\n        // cleanup via _internalActiveDeferreds\n        dfd.cancel();\n        cancelledRouteIds.push(routeId);\n        activeDeferreds.delete(routeId);\n      }\n    });\n    return cancelledRouteIds;\n  }\n\n  // Opt in to capturing and reporting scroll positions during navigations,\n  // used by the <ScrollRestoration> component\n  function enableScrollRestoration(\n    positions: Record<string, number>,\n    getPosition: GetScrollPositionFunction,\n    getKey?: GetScrollRestorationKeyFunction\n  ) {\n    savedScrollPositions = positions;\n    getScrollPosition = getPosition;\n    getScrollRestorationKey = getKey || null;\n\n    // Perform initial hydration scroll restoration, since we miss the boat on\n    // the initial updateState() because we've not yet rendered <ScrollRestoration/>\n    // and therefore have no savedScrollPositions available\n    if (!initialScrollRestored && state.navigation === IDLE_NAVIGATION) {\n      initialScrollRestored = true;\n      let y = getSavedScrollPosition(state.location, state.matches);\n      if (y != null) {\n        updateState({ restoreScrollPosition: y });\n      }\n    }\n\n    return () => {\n      savedScrollPositions = null;\n      getScrollPosition = null;\n      getScrollRestorationKey = null;\n    };\n  }\n\n  function getScrollKey(location: Location, matches: AgnosticDataRouteMatch[]) {\n    if (getScrollRestorationKey) {\n      let key = getScrollRestorationKey(\n        location,\n        matches.map((m) => convertRouteMatchToUiMatch(m, state.loaderData))\n      );\n      return key || location.key;\n    }\n    return location.key;\n  }\n\n  function saveScrollPosition(\n    location: Location,\n    matches: AgnosticDataRouteMatch[]\n  ): void {\n    if (savedScrollPositions && getScrollPosition) {\n      let key = getScrollKey(location, matches);\n      savedScrollPositions[key] = getScrollPosition();\n    }\n  }\n\n  function getSavedScrollPosition(\n    location: Location,\n    matches: AgnosticDataRouteMatch[]\n  ): number | null {\n    if (savedScrollPositions) {\n      let key = getScrollKey(location, matches);\n      let y = savedScrollPositions[key];\n      if (typeof y === \"number\") {\n        return y;\n      }\n    }\n    return null;\n  }\n\n  function checkFogOfWar(\n    matches: AgnosticDataRouteMatch[] | null,\n    routesToUse: AgnosticDataRouteObject[],\n    pathname: string\n  ): { active: boolean; matches: AgnosticDataRouteMatch[] | null } {\n    if (patchRoutesOnNavigationImpl) {\n      if (!matches) {\n        let fogMatches = matchRoutesImpl<AgnosticDataRouteObject>(\n          routesToUse,\n          pathname,\n          basename,\n          true\n        );\n\n        return { active: true, matches: fogMatches || [] };\n      } else {\n        if (Object.keys(matches[0].params).length > 0) {\n          // If we matched a dynamic param or a splat, it might only be because\n          // we haven't yet discovered other routes that would match with a\n          // higher score.  Call patchRoutesOnNavigation just to be sure\n          let partialMatches = matchRoutesImpl<AgnosticDataRouteObject>(\n            routesToUse,\n            pathname,\n            basename,\n            true\n          );\n          return { active: true, matches: partialMatches };\n        }\n      }\n    }\n\n    return { active: false, matches: null };\n  }\n\n  type DiscoverRoutesSuccessResult = {\n    type: \"success\";\n    matches: AgnosticDataRouteMatch[] | null;\n  };\n  type DiscoverRoutesErrorResult = {\n    type: \"error\";\n    error: any;\n    partialMatches: AgnosticDataRouteMatch[];\n  };\n  type DiscoverRoutesAbortedResult = { type: \"aborted\" };\n  type DiscoverRoutesResult =\n    | DiscoverRoutesSuccessResult\n    | DiscoverRoutesErrorResult\n    | DiscoverRoutesAbortedResult;\n\n  async function discoverRoutes(\n    matches: AgnosticDataRouteMatch[],\n    pathname: string,\n    signal: AbortSignal,\n    fetcherKey?: string\n  ): Promise<DiscoverRoutesResult> {\n    if (!patchRoutesOnNavigationImpl) {\n      return { type: \"success\", matches };\n    }\n\n    let partialMatches: AgnosticDataRouteMatch[] | null = matches;\n    while (true) {\n      let isNonHMR = inFlightDataRoutes == null;\n      let routesToUse = inFlightDataRoutes || dataRoutes;\n      let localManifest = manifest;\n      try {\n        await patchRoutesOnNavigationImpl({\n          signal,\n          path: pathname,\n          matches: partialMatches,\n          fetcherKey,\n          patch: (routeId, children) => {\n            if (signal.aborted) return;\n            patchRoutesImpl(\n              routeId,\n              children,\n              routesToUse,\n              localManifest,\n              mapRouteProperties\n            );\n          },\n        });\n      } catch (e) {\n        return { type: \"error\", error: e, partialMatches };\n      } finally {\n        // If we are not in the middle of an HMR revalidation and we changed the\n        // routes, provide a new identity so when we `updateState` at the end of\n        // this navigation/fetch `router.routes` will be a new identity and\n        // trigger a re-run of memoized `router.routes` dependencies.\n        // HMR will already update the identity and reflow when it lands\n        // `inFlightDataRoutes` in `completeNavigation`\n        if (isNonHMR && !signal.aborted) {\n          dataRoutes = [...dataRoutes];\n        }\n      }\n\n      if (signal.aborted) {\n        return { type: \"aborted\" };\n      }\n\n      let newMatches = matchRoutes(routesToUse, pathname, basename);\n      if (newMatches) {\n        return { type: \"success\", matches: newMatches };\n      }\n\n      let newPartialMatches = matchRoutesImpl<AgnosticDataRouteObject>(\n        routesToUse,\n        pathname,\n        basename,\n        true\n      );\n\n      // Avoid loops if the second pass results in the same partial matches\n      if (\n        !newPartialMatches ||\n        (partialMatches.length === newPartialMatches.length &&\n          partialMatches.every(\n            (m, i) => m.route.id === newPartialMatches![i].route.id\n          ))\n      ) {\n        return { type: \"success\", matches: null };\n      }\n\n      partialMatches = newPartialMatches;\n    }\n  }\n\n  function _internalSetRoutes(newRoutes: AgnosticDataRouteObject[]) {\n    manifest = {};\n    inFlightDataRoutes = convertRoutesToDataRoutes(\n      newRoutes,\n      mapRouteProperties,\n      undefined,\n      manifest\n    );\n  }\n\n  function patchRoutes(\n    routeId: string | null,\n    children: AgnosticRouteObject[]\n  ): void {\n    let isNonHMR = inFlightDataRoutes == null;\n    let routesToUse = inFlightDataRoutes || dataRoutes;\n    patchRoutesImpl(\n      routeId,\n      children,\n      routesToUse,\n      manifest,\n      mapRouteProperties\n    );\n\n    // If we are not in the middle of an HMR revalidation and we changed the\n    // routes, provide a new identity and trigger a reflow via `updateState`\n    // to re-run memoized `router.routes` dependencies.\n    // HMR will already update the identity and reflow when it lands\n    // `inFlightDataRoutes` in `completeNavigation`\n    if (isNonHMR) {\n      dataRoutes = [...dataRoutes];\n      updateState({});\n    }\n  }\n\n  router = {\n    get basename() {\n      return basename;\n    },\n    get future() {\n      return future;\n    },\n    get state() {\n      return state;\n    },\n    get routes() {\n      return dataRoutes;\n    },\n    get window() {\n      return routerWindow;\n    },\n    initialize,\n    subscribe,\n    enableScrollRestoration,\n    navigate,\n    fetch,\n    revalidate,\n    // Passthrough to history-aware createHref used by useHref so we get proper\n    // hash-aware URLs in DOM paths\n    createHref: (to: To) => init.history.createHref(to),\n    encodeLocation: (to: To) => init.history.encodeLocation(to),\n    getFetcher,\n    deleteFetcher: deleteFetcherAndUpdateState,\n    dispose,\n    getBlocker,\n    deleteBlocker,\n    patchRoutes,\n    _internalFetchControllers: fetchControllers,\n    _internalActiveDeferreds: activeDeferreds,\n    // TODO: Remove setRoutes, it's temporary to avoid dealing with\n    // updating the tree while validating the update algorithm.\n    _internalSetRoutes,\n  };\n\n  return router;\n}\n//#endregion\n\n////////////////////////////////////////////////////////////////////////////////\n//#region createStaticHandler\n////////////////////////////////////////////////////////////////////////////////\n\nexport const UNSAFE_DEFERRED_SYMBOL = Symbol(\"deferred\");\n\n/**\n * Future flags to toggle new feature behavior\n */\nexport interface StaticHandlerFutureConfig {\n  v7_relativeSplatPath: boolean;\n  v7_throwAbortReason: boolean;\n}\n\nexport interface CreateStaticHandlerOptions {\n  basename?: string;\n  /**\n   * @deprecated Use `mapRouteProperties` instead\n   */\n  detectErrorBoundary?: DetectErrorBoundaryFunction;\n  mapRouteProperties?: MapRoutePropertiesFunction;\n  future?: Partial<StaticHandlerFutureConfig>;\n}\n\nexport function createStaticHandler(\n  routes: AgnosticRouteObject[],\n  opts?: CreateStaticHandlerOptions\n): StaticHandler {\n  invariant(\n    routes.length > 0,\n    \"You must provide a non-empty routes array to createStaticHandler\"\n  );\n\n  let manifest: RouteManifest = {};\n  let basename = (opts ? opts.basename : null) || \"/\";\n  let mapRouteProperties: MapRoutePropertiesFunction;\n  if (opts?.mapRouteProperties) {\n    mapRouteProperties = opts.mapRouteProperties;\n  } else if (opts?.detectErrorBoundary) {\n    // If they are still using the deprecated version, wrap it with the new API\n    let detectErrorBoundary = opts.detectErrorBoundary;\n    mapRouteProperties = (route) => ({\n      hasErrorBoundary: detectErrorBoundary(route),\n    });\n  } else {\n    mapRouteProperties = defaultMapRouteProperties;\n  }\n  // Config driven behavior flags\n  let future: StaticHandlerFutureConfig = {\n    v7_relativeSplatPath: false,\n    v7_throwAbortReason: false,\n    ...(opts ? opts.future : null),\n  };\n\n  let dataRoutes = convertRoutesToDataRoutes(\n    routes,\n    mapRouteProperties,\n    undefined,\n    manifest\n  );\n\n  /**\n   * The query() method is intended for document requests, in which we want to\n   * call an optional action and potentially multiple loaders for all nested\n   * routes.  It returns a StaticHandlerContext object, which is very similar\n   * to the router state (location, loaderData, actionData, errors, etc.) and\n   * also adds SSR-specific information such as the statusCode and headers\n   * from action/loaders Responses.\n   *\n   * It _should_ never throw and should report all errors through the\n   * returned context.errors object, properly associating errors to their error\n   * boundary.  Additionally, it tracks _deepestRenderedBoundaryId which can be\n   * used to emulate React error boundaries during SSr by performing a second\n   * pass only down to the boundaryId.\n   *\n   * The one exception where we do not return a StaticHandlerContext is when a\n   * redirect response is returned or thrown from any action/loader.  We\n   * propagate that out and return the raw Response so the HTTP server can\n   * return it directly.\n   *\n   * - `opts.requestContext` is an optional server context that will be passed\n   *   to actions/loaders in the `context` parameter\n   * - `opts.skipLoaderErrorBubbling` is an optional parameter that will prevent\n   *   the bubbling of errors which allows single-fetch-type implementations\n   *   where the client will handle the bubbling and we may need to return data\n   *   for the handling route\n   */\n  async function query(\n    request: Request,\n    {\n      requestContext,\n      skipLoaderErrorBubbling,\n      dataStrategy,\n    }: {\n      requestContext?: unknown;\n      skipLoaderErrorBubbling?: boolean;\n      dataStrategy?: DataStrategyFunction;\n    } = {}\n  ): Promise<StaticHandlerContext | Response> {\n    let url = new URL(request.url);\n    let method = request.method;\n    let location = createLocation(\"\", createPath(url), null, \"default\");\n    let matches = matchRoutes(dataRoutes, location, basename);\n\n    // SSR supports HEAD requests while SPA doesn't\n    if (!isValidMethod(method) && method !== \"HEAD\") {\n      let error = getInternalRouterError(405, { method });\n      let { matches: methodNotAllowedMatches, route } =\n        getShortCircuitMatches(dataRoutes);\n      return {\n        basename,\n        location,\n        matches: methodNotAllowedMatches,\n        loaderData: {},\n        actionData: null,\n        errors: {\n          [route.id]: error,\n        },\n        statusCode: error.status,\n        loaderHeaders: {},\n        actionHeaders: {},\n        activeDeferreds: null,\n      };\n    } else if (!matches) {\n      let error = getInternalRouterError(404, { pathname: location.pathname });\n      let { matches: notFoundMatches, route } =\n        getShortCircuitMatches(dataRoutes);\n      return {\n        basename,\n        location,\n        matches: notFoundMatches,\n        loaderData: {},\n        actionData: null,\n        errors: {\n          [route.id]: error,\n        },\n        statusCode: error.status,\n        loaderHeaders: {},\n        actionHeaders: {},\n        activeDeferreds: null,\n      };\n    }\n\n    let result = await queryImpl(\n      request,\n      location,\n      matches,\n      requestContext,\n      dataStrategy || null,\n      skipLoaderErrorBubbling === true,\n      null\n    );\n    if (isResponse(result)) {\n      return result;\n    }\n\n    // When returning StaticHandlerContext, we patch back in the location here\n    // since we need it for React Context.  But this helps keep our submit and\n    // loadRouteData operating on a Request instead of a Location\n    return { location, basename, ...result };\n  }\n\n  /**\n   * The queryRoute() method is intended for targeted route requests, either\n   * for fetch ?_data requests or resource route requests.  In this case, we\n   * are only ever calling a single action or loader, and we are returning the\n   * returned value directly.  In most cases, this will be a Response returned\n   * from the action/loader, but it may be a primitive or other value as well -\n   * and in such cases the calling context should handle that accordingly.\n   *\n   * We do respect the throw/return differentiation, so if an action/loader\n   * throws, then this method will throw the value.  This is important so we\n   * can do proper boundary identification in Remix where a thrown Response\n   * must go to the Catch Boundary but a returned Response is happy-path.\n   *\n   * One thing to note is that any Router-initiated Errors that make sense\n   * to associate with a status code will be thrown as an ErrorResponse\n   * instance which include the raw Error, such that the calling context can\n   * serialize the error as they see fit while including the proper response\n   * code.  Examples here are 404 and 405 errors that occur prior to reaching\n   * any user-defined loaders.\n   *\n   * - `opts.routeId` allows you to specify the specific route handler to call.\n   *   If not provided the handler will determine the proper route by matching\n   *   against `request.url`\n   * - `opts.requestContext` is an optional server context that will be passed\n   *    to actions/loaders in the `context` parameter\n   */\n  async function queryRoute(\n    request: Request,\n    {\n      routeId,\n      requestContext,\n      dataStrategy,\n    }: {\n      requestContext?: unknown;\n      routeId?: string;\n      dataStrategy?: DataStrategyFunction;\n    } = {}\n  ): Promise<any> {\n    let url = new URL(request.url);\n    let method = request.method;\n    let location = createLocation(\"\", createPath(url), null, \"default\");\n    let matches = matchRoutes(dataRoutes, location, basename);\n\n    // SSR supports HEAD requests while SPA doesn't\n    if (!isValidMethod(method) && method !== \"HEAD\" && method !== \"OPTIONS\") {\n      throw getInternalRouterError(405, { method });\n    } else if (!matches) {\n      throw getInternalRouterError(404, { pathname: location.pathname });\n    }\n\n    let match = routeId\n      ? matches.find((m) => m.route.id === routeId)\n      : getTargetMatch(matches, location);\n\n    if (routeId && !match) {\n      throw getInternalRouterError(403, {\n        pathname: location.pathname,\n        routeId,\n      });\n    } else if (!match) {\n      // This should never hit I don't think?\n      throw getInternalRouterError(404, { pathname: location.pathname });\n    }\n\n    let result = await queryImpl(\n      request,\n      location,\n      matches,\n      requestContext,\n      dataStrategy || null,\n      false,\n      match\n    );\n\n    if (isResponse(result)) {\n      return result;\n    }\n\n    let error = result.errors ? Object.values(result.errors)[0] : undefined;\n    if (error !== undefined) {\n      // If we got back result.errors, that means the loader/action threw\n      // _something_ that wasn't a Response, but it's not guaranteed/required\n      // to be an `instanceof Error` either, so we have to use throw here to\n      // preserve the \"error\" state outside of queryImpl.\n      throw error;\n    }\n\n    // Pick off the right state value to return\n    if (result.actionData) {\n      return Object.values(result.actionData)[0];\n    }\n\n    if (result.loaderData) {\n      let data = Object.values(result.loaderData)[0];\n      if (result.activeDeferreds?.[match.route.id]) {\n        data[UNSAFE_DEFERRED_SYMBOL] = result.activeDeferreds[match.route.id];\n      }\n      return data;\n    }\n\n    return undefined;\n  }\n\n  async function queryImpl(\n    request: Request,\n    location: Location,\n    matches: AgnosticDataRouteMatch[],\n    requestContext: unknown,\n    dataStrategy: DataStrategyFunction | null,\n    skipLoaderErrorBubbling: boolean,\n    routeMatch: AgnosticDataRouteMatch | null\n  ): Promise<Omit<StaticHandlerContext, \"location\" | \"basename\"> | Response> {\n    invariant(\n      request.signal,\n      \"query()/queryRoute() requests must contain an AbortController signal\"\n    );\n\n    try {\n      if (isMutationMethod(request.method.toLowerCase())) {\n        let result = await submit(\n          request,\n          matches,\n          routeMatch || getTargetMatch(matches, location),\n          requestContext,\n          dataStrategy,\n          skipLoaderErrorBubbling,\n          routeMatch != null\n        );\n        return result;\n      }\n\n      let result = await loadRouteData(\n        request,\n        matches,\n        requestContext,\n        dataStrategy,\n        skipLoaderErrorBubbling,\n        routeMatch\n      );\n      return isResponse(result)\n        ? result\n        : {\n            ...result,\n            actionData: null,\n            actionHeaders: {},\n          };\n    } catch (e) {\n      // If the user threw/returned a Response in callLoaderOrAction for a\n      // `queryRoute` call, we throw the `DataStrategyResult` to bail out early\n      // and then return or throw the raw Response here accordingly\n      if (isDataStrategyResult(e) && isResponse(e.result)) {\n        if (e.type === ResultType.error) {\n          throw e.result;\n        }\n        return e.result;\n      }\n      // Redirects are always returned since they don't propagate to catch\n      // boundaries\n      if (isRedirectResponse(e)) {\n        return e;\n      }\n      throw e;\n    }\n  }\n\n  async function submit(\n    request: Request,\n    matches: AgnosticDataRouteMatch[],\n    actionMatch: AgnosticDataRouteMatch,\n    requestContext: unknown,\n    dataStrategy: DataStrategyFunction | null,\n    skipLoaderErrorBubbling: boolean,\n    isRouteRequest: boolean\n  ): Promise<Omit<StaticHandlerContext, \"location\" | \"basename\"> | Response> {\n    let result: DataResult;\n\n    if (!actionMatch.route.action && !actionMatch.route.lazy) {\n      let error = getInternalRouterError(405, {\n        method: request.method,\n        pathname: new URL(request.url).pathname,\n        routeId: actionMatch.route.id,\n      });\n      if (isRouteRequest) {\n        throw error;\n      }\n      result = {\n        type: ResultType.error,\n        error,\n      };\n    } else {\n      let results = await callDataStrategy(\n        \"action\",\n        request,\n        [actionMatch],\n        matches,\n        isRouteRequest,\n        requestContext,\n        dataStrategy\n      );\n      result = results[actionMatch.route.id];\n\n      if (request.signal.aborted) {\n        throwStaticHandlerAbortedError(request, isRouteRequest, future);\n      }\n    }\n\n    if (isRedirectResult(result)) {\n      // Uhhhh - this should never happen, we should always throw these from\n      // callLoaderOrAction, but the type narrowing here keeps TS happy and we\n      // can get back on the \"throw all redirect responses\" train here should\n      // this ever happen :/\n      throw new Response(null, {\n        status: result.response.status,\n        headers: {\n          Location: result.response.headers.get(\"Location\")!,\n        },\n      });\n    }\n\n    if (isDeferredResult(result)) {\n      let error = getInternalRouterError(400, { type: \"defer-action\" });\n      if (isRouteRequest) {\n        throw error;\n      }\n      result = {\n        type: ResultType.error,\n        error,\n      };\n    }\n\n    if (isRouteRequest) {\n      // Note: This should only be non-Response values if we get here, since\n      // isRouteRequest should throw any Response received in callLoaderOrAction\n      if (isErrorResult(result)) {\n        throw result.error;\n      }\n\n      return {\n        matches: [actionMatch],\n        loaderData: {},\n        actionData: { [actionMatch.route.id]: result.data },\n        errors: null,\n        // Note: statusCode + headers are unused here since queryRoute will\n        // return the raw Response or value\n        statusCode: 200,\n        loaderHeaders: {},\n        actionHeaders: {},\n        activeDeferreds: null,\n      };\n    }\n\n    // Create a GET request for the loaders\n    let loaderRequest = new Request(request.url, {\n      headers: request.headers,\n      redirect: request.redirect,\n      signal: request.signal,\n    });\n\n    if (isErrorResult(result)) {\n      // Store off the pending error - we use it to determine which loaders\n      // to call and will commit it when we complete the navigation\n      let boundaryMatch = skipLoaderErrorBubbling\n        ? actionMatch\n        : findNearestBoundary(matches, actionMatch.route.id);\n\n      let context = await loadRouteData(\n        loaderRequest,\n        matches,\n        requestContext,\n        dataStrategy,\n        skipLoaderErrorBubbling,\n        null,\n        [boundaryMatch.route.id, result]\n      );\n\n      // action status codes take precedence over loader status codes\n      return {\n        ...context,\n        statusCode: isRouteErrorResponse(result.error)\n          ? result.error.status\n          : result.statusCode != null\n          ? result.statusCode\n          : 500,\n        actionData: null,\n        actionHeaders: {\n          ...(result.headers ? { [actionMatch.route.id]: result.headers } : {}),\n        },\n      };\n    }\n\n    let context = await loadRouteData(\n      loaderRequest,\n      matches,\n      requestContext,\n      dataStrategy,\n      skipLoaderErrorBubbling,\n      null\n    );\n\n    return {\n      ...context,\n      actionData: {\n        [actionMatch.route.id]: result.data,\n      },\n      // action status codes take precedence over loader status codes\n      ...(result.statusCode ? { statusCode: result.statusCode } : {}),\n      actionHeaders: result.headers\n        ? { [actionMatch.route.id]: result.headers }\n        : {},\n    };\n  }\n\n  async function loadRouteData(\n    request: Request,\n    matches: AgnosticDataRouteMatch[],\n    requestContext: unknown,\n    dataStrategy: DataStrategyFunction | null,\n    skipLoaderErrorBubbling: boolean,\n    routeMatch: AgnosticDataRouteMatch | null,\n    pendingActionResult?: PendingActionResult\n  ): Promise<\n    | Omit<\n        StaticHandlerContext,\n        \"location\" | \"basename\" | \"actionData\" | \"actionHeaders\"\n      >\n    | Response\n  > {\n    let isRouteRequest = routeMatch != null;\n\n    // Short circuit if we have no loaders to run (queryRoute())\n    if (\n      isRouteRequest &&\n      !routeMatch?.route.loader &&\n      !routeMatch?.route.lazy\n    ) {\n      throw getInternalRouterError(400, {\n        method: request.method,\n        pathname: new URL(request.url).pathname,\n        routeId: routeMatch?.route.id,\n      });\n    }\n\n    let requestMatches = routeMatch\n      ? [routeMatch]\n      : pendingActionResult && isErrorResult(pendingActionResult[1])\n      ? getLoaderMatchesUntilBoundary(matches, pendingActionResult[0])\n      : matches;\n    let matchesToLoad = requestMatches.filter(\n      (m) => m.route.loader || m.route.lazy\n    );\n\n    // Short circuit if we have no loaders to run (query())\n    if (matchesToLoad.length === 0) {\n      return {\n        matches,\n        // Add a null for all matched routes for proper revalidation on the client\n        loaderData: matches.reduce(\n          (acc, m) => Object.assign(acc, { [m.route.id]: null }),\n          {}\n        ),\n        errors:\n          pendingActionResult && isErrorResult(pendingActionResult[1])\n            ? {\n                [pendingActionResult[0]]: pendingActionResult[1].error,\n              }\n            : null,\n        statusCode: 200,\n        loaderHeaders: {},\n        activeDeferreds: null,\n      };\n    }\n\n    let results = await callDataStrategy(\n      \"loader\",\n      request,\n      matchesToLoad,\n      matches,\n      isRouteRequest,\n      requestContext,\n      dataStrategy\n    );\n\n    if (request.signal.aborted) {\n      throwStaticHandlerAbortedError(request, isRouteRequest, future);\n    }\n\n    // Process and commit output from loaders\n    let activeDeferreds = new Map<string, DeferredData>();\n    let context = processRouteLoaderData(\n      matches,\n      results,\n      pendingActionResult,\n      activeDeferreds,\n      skipLoaderErrorBubbling\n    );\n\n    // Add a null for any non-loader matches for proper revalidation on the client\n    let executedLoaders = new Set<string>(\n      matchesToLoad.map((match) => match.route.id)\n    );\n    matches.forEach((match) => {\n      if (!executedLoaders.has(match.route.id)) {\n        context.loaderData[match.route.id] = null;\n      }\n    });\n\n    return {\n      ...context,\n      matches,\n      activeDeferreds:\n        activeDeferreds.size > 0\n          ? Object.fromEntries(activeDeferreds.entries())\n          : null,\n    };\n  }\n\n  // Utility wrapper for calling dataStrategy server-side without having to\n  // pass around the manifest, mapRouteProperties, etc.\n  async function callDataStrategy(\n    type: \"loader\" | \"action\",\n    request: Request,\n    matchesToLoad: AgnosticDataRouteMatch[],\n    matches: AgnosticDataRouteMatch[],\n    isRouteRequest: boolean,\n    requestContext: unknown,\n    dataStrategy: DataStrategyFunction | null\n  ): Promise<Record<string, DataResult>> {\n    let results = await callDataStrategyImpl(\n      dataStrategy || defaultDataStrategy,\n      type,\n      null,\n      request,\n      matchesToLoad,\n      matches,\n      null,\n      manifest,\n      mapRouteProperties,\n      requestContext\n    );\n\n    let dataResults: Record<string, DataResult> = {};\n    await Promise.all(\n      matches.map(async (match) => {\n        if (!(match.route.id in results)) {\n          return;\n        }\n        let result = results[match.route.id];\n        if (isRedirectDataStrategyResultResult(result)) {\n          let response = result.result as Response;\n          // Throw redirects and let the server handle them with an HTTP redirect\n          throw normalizeRelativeRoutingRedirectResponse(\n            response,\n            request,\n            match.route.id,\n            matches,\n            basename,\n            future.v7_relativeSplatPath\n          );\n        }\n        if (isResponse(result.result) && isRouteRequest) {\n          // For SSR single-route requests, we want to hand Responses back\n          // directly without unwrapping\n          throw result;\n        }\n\n        dataResults[match.route.id] =\n          await convertDataStrategyResultToDataResult(result);\n      })\n    );\n    return dataResults;\n  }\n\n  return {\n    dataRoutes,\n    query,\n    queryRoute,\n  };\n}\n\n//#endregion\n\n////////////////////////////////////////////////////////////////////////////////\n//#region Helpers\n////////////////////////////////////////////////////////////////////////////////\n\n/**\n * Given an existing StaticHandlerContext and an error thrown at render time,\n * provide an updated StaticHandlerContext suitable for a second SSR render\n */\nexport function getStaticContextFromError(\n  routes: AgnosticDataRouteObject[],\n  context: StaticHandlerContext,\n  error: any\n) {\n  let newContext: StaticHandlerContext = {\n    ...context,\n    statusCode: isRouteErrorResponse(error) ? error.status : 500,\n    errors: {\n      [context._deepestRenderedBoundaryId || routes[0].id]: error,\n    },\n  };\n  return newContext;\n}\n\nfunction throwStaticHandlerAbortedError(\n  request: Request,\n  isRouteRequest: boolean,\n  future: StaticHandlerFutureConfig\n) {\n  if (future.v7_throwAbortReason && request.signal.reason !== undefined) {\n    throw request.signal.reason;\n  }\n\n  let method = isRouteRequest ? \"queryRoute\" : \"query\";\n  throw new Error(`${method}() call aborted: ${request.method} ${request.url}`);\n}\n\nfunction isSubmissionNavigation(\n  opts: BaseNavigateOrFetchOptions\n): opts is SubmissionNavigateOptions {\n  return (\n    opts != null &&\n    ((\"formData\" in opts && opts.formData != null) ||\n      (\"body\" in opts && opts.body !== undefined))\n  );\n}\n\nfunction normalizeTo(\n  location: Path,\n  matches: AgnosticDataRouteMatch[],\n  basename: string,\n  prependBasename: boolean,\n  to: To | null,\n  v7_relativeSplatPath: boolean,\n  fromRouteId?: string,\n  relative?: RelativeRoutingType\n) {\n  let contextualMatches: AgnosticDataRouteMatch[];\n  let activeRouteMatch: AgnosticDataRouteMatch | undefined;\n  if (fromRouteId) {\n    // Grab matches up to the calling route so our route-relative logic is\n    // relative to the correct source route\n    contextualMatches = [];\n    for (let match of matches) {\n      contextualMatches.push(match);\n      if (match.route.id === fromRouteId) {\n        activeRouteMatch = match;\n        break;\n      }\n    }\n  } else {\n    contextualMatches = matches;\n    activeRouteMatch = matches[matches.length - 1];\n  }\n\n  // Resolve the relative path\n  let path = resolveTo(\n    to ? to : \".\",\n    getResolveToMatches(contextualMatches, v7_relativeSplatPath),\n    stripBasename(location.pathname, basename) || location.pathname,\n    relative === \"path\"\n  );\n\n  // When `to` is not specified we inherit search/hash from the current\n  // location, unlike when to=\".\" and we just inherit the path.\n  // See https://github.com/remix-run/remix/issues/927\n  if (to == null) {\n    path.search = location.search;\n    path.hash = location.hash;\n  }\n\n  // Account for `?index` params when routing to the current location\n  if ((to == null || to === \"\" || to === \".\") && activeRouteMatch) {\n    let nakedIndex = hasNakedIndexQuery(path.search);\n    if (activeRouteMatch.route.index && !nakedIndex) {\n      // Add one when we're targeting an index route\n      path.search = path.search\n        ? path.search.replace(/^\\?/, \"?index&\")\n        : \"?index\";\n    } else if (!activeRouteMatch.route.index && nakedIndex) {\n      // Remove existing ones when we're not\n      let params = new URLSearchParams(path.search);\n      let indexValues = params.getAll(\"index\");\n      params.delete(\"index\");\n      indexValues.filter((v) => v).forEach((v) => params.append(\"index\", v));\n      let qs = params.toString();\n      path.search = qs ? `?${qs}` : \"\";\n    }\n  }\n\n  // If we're operating within a basename, prepend it to the pathname.  If\n  // this is a root navigation, then just use the raw basename which allows\n  // the basename to have full control over the presence of a trailing slash\n  // on root actions\n  if (prependBasename && basename !== \"/\") {\n    path.pathname =\n      path.pathname === \"/\" ? basename : joinPaths([basename, path.pathname]);\n  }\n\n  return createPath(path);\n}\n\n// Normalize navigation options by converting formMethod=GET formData objects to\n// URLSearchParams so they behave identically to links with query params\nfunction normalizeNavigateOptions(\n  normalizeFormMethod: boolean,\n  isFetcher: boolean,\n  path: string,\n  opts?: BaseNavigateOrFetchOptions\n): {\n  path: string;\n  submission?: Submission;\n  error?: ErrorResponseImpl;\n} {\n  // Return location verbatim on non-submission navigations\n  if (!opts || !isSubmissionNavigation(opts)) {\n    return { path };\n  }\n\n  if (opts.formMethod && !isValidMethod(opts.formMethod)) {\n    return {\n      path,\n      error: getInternalRouterError(405, { method: opts.formMethod }),\n    };\n  }\n\n  let getInvalidBodyError = () => ({\n    path,\n    error: getInternalRouterError(400, { type: \"invalid-body\" }),\n  });\n\n  // Create a Submission on non-GET navigations\n  let rawFormMethod = opts.formMethod || \"get\";\n  let formMethod = normalizeFormMethod\n    ? (rawFormMethod.toUpperCase() as V7_FormMethod)\n    : (rawFormMethod.toLowerCase() as FormMethod);\n  let formAction = stripHashFromPath(path);\n\n  if (opts.body !== undefined) {\n    if (opts.formEncType === \"text/plain\") {\n      // text only support POST/PUT/PATCH/DELETE submissions\n      if (!isMutationMethod(formMethod)) {\n        return getInvalidBodyError();\n      }\n\n      let text =\n        typeof opts.body === \"string\"\n          ? opts.body\n          : opts.body instanceof FormData ||\n            opts.body instanceof URLSearchParams\n          ? // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#plain-text-form-data\n            Array.from(opts.body.entries()).reduce(\n              (acc, [name, value]) => `${acc}${name}=${value}\\n`,\n              \"\"\n            )\n          : String(opts.body);\n\n      return {\n        path,\n        submission: {\n          formMethod,\n          formAction,\n          formEncType: opts.formEncType,\n          formData: undefined,\n          json: undefined,\n          text,\n        },\n      };\n    } else if (opts.formEncType === \"application/json\") {\n      // json only supports POST/PUT/PATCH/DELETE submissions\n      if (!isMutationMethod(formMethod)) {\n        return getInvalidBodyError();\n      }\n\n      try {\n        let json =\n          typeof opts.body === \"string\" ? JSON.parse(opts.body) : opts.body;\n\n        return {\n          path,\n          submission: {\n            formMethod,\n            formAction,\n            formEncType: opts.formEncType,\n            formData: undefined,\n            json,\n            text: undefined,\n          },\n        };\n      } catch (e) {\n        return getInvalidBodyError();\n      }\n    }\n  }\n\n  invariant(\n    typeof FormData === \"function\",\n    \"FormData is not available in this environment\"\n  );\n\n  let searchParams: URLSearchParams;\n  let formData: FormData;\n\n  if (opts.formData) {\n    searchParams = convertFormDataToSearchParams(opts.formData);\n    formData = opts.formData;\n  } else if (opts.body instanceof FormData) {\n    searchParams = convertFormDataToSearchParams(opts.body);\n    formData = opts.body;\n  } else if (opts.body instanceof URLSearchParams) {\n    searchParams = opts.body;\n    formData = convertSearchParamsToFormData(searchParams);\n  } else if (opts.body == null) {\n    searchParams = new URLSearchParams();\n    formData = new FormData();\n  } else {\n    try {\n      searchParams = new URLSearchParams(opts.body);\n      formData = convertSearchParamsToFormData(searchParams);\n    } catch (e) {\n      return getInvalidBodyError();\n    }\n  }\n\n  let submission: Submission = {\n    formMethod,\n    formAction,\n    formEncType:\n      (opts && opts.formEncType) || \"application/x-www-form-urlencoded\",\n    formData,\n    json: undefined,\n    text: undefined,\n  };\n\n  if (isMutationMethod(submission.formMethod)) {\n    return { path, submission };\n  }\n\n  // Flatten submission onto URLSearchParams for GET submissions\n  let parsedPath = parsePath(path);\n  // On GET navigation submissions we can drop the ?index param from the\n  // resulting location since all loaders will run.  But fetcher GET submissions\n  // only run a single loader so we need to preserve any incoming ?index params\n  if (isFetcher && parsedPath.search && hasNakedIndexQuery(parsedPath.search)) {\n    searchParams.append(\"index\", \"\");\n  }\n  parsedPath.search = `?${searchParams}`;\n\n  return { path: createPath(parsedPath), submission };\n}\n\n// Filter out all routes at/below any caught error as they aren't going to\n// render so we don't need to load them\nfunction getLoaderMatchesUntilBoundary(\n  matches: AgnosticDataRouteMatch[],\n  boundaryId: string,\n  includeBoundary = false\n) {\n  let index = matches.findIndex((m) => m.route.id === boundaryId);\n  if (index >= 0) {\n    return matches.slice(0, includeBoundary ? index + 1 : index);\n  }\n  return matches;\n}\n\nfunction getMatchesToLoad(\n  history: History,\n  state: RouterState,\n  matches: AgnosticDataRouteMatch[],\n  submission: Submission | undefined,\n  location: Location,\n  initialHydration: boolean,\n  skipActionErrorRevalidation: boolean,\n  isRevalidationRequired: boolean,\n  cancelledDeferredRoutes: string[],\n  cancelledFetcherLoads: Set<string>,\n  deletedFetchers: Set<string>,\n  fetchLoadMatches: Map<string, FetchLoadMatch>,\n  fetchRedirectIds: Set<string>,\n  routesToUse: AgnosticDataRouteObject[],\n  basename: string | undefined,\n  pendingActionResult?: PendingActionResult\n): [AgnosticDataRouteMatch[], RevalidatingFetcher[]] {\n  let actionResult = pendingActionResult\n    ? isErrorResult(pendingActionResult[1])\n      ? pendingActionResult[1].error\n      : pendingActionResult[1].data\n    : undefined;\n  let currentUrl = history.createURL(state.location);\n  let nextUrl = history.createURL(location);\n\n  // Pick navigation matches that are net-new or qualify for revalidation\n  let boundaryMatches = matches;\n  if (initialHydration && state.errors) {\n    // On initial hydration, only consider matches up to _and including_ the boundary.\n    // This is inclusive to handle cases where a server loader ran successfully,\n    // a child server loader bubbled up to this route, but this route has\n    // `clientLoader.hydrate` so we want to still run the `clientLoader` so that\n    // we have a complete version of `loaderData`\n    boundaryMatches = getLoaderMatchesUntilBoundary(\n      matches,\n      Object.keys(state.errors)[0],\n      true\n    );\n  } else if (pendingActionResult && isErrorResult(pendingActionResult[1])) {\n    // If an action threw an error, we call loaders up to, but not including the\n    // boundary\n    boundaryMatches = getLoaderMatchesUntilBoundary(\n      matches,\n      pendingActionResult[0]\n    );\n  }\n\n  // Don't revalidate loaders by default after action 4xx/5xx responses\n  // when the flag is enabled.  They can still opt-into revalidation via\n  // `shouldRevalidate` via `actionResult`\n  let actionStatus = pendingActionResult\n    ? pendingActionResult[1].statusCode\n    : undefined;\n  let shouldSkipRevalidation =\n    skipActionErrorRevalidation && actionStatus && actionStatus >= 400;\n\n  let navigationMatches = boundaryMatches.filter((match, index) => {\n    let { route } = match;\n    if (route.lazy) {\n      // We haven't loaded this route yet so we don't know if it's got a loader!\n      return true;\n    }\n\n    if (route.loader == null) {\n      return false;\n    }\n\n    if (initialHydration) {\n      return shouldLoadRouteOnHydration(route, state.loaderData, state.errors);\n    }\n\n    // Always call the loader on new route instances and pending defer cancellations\n    if (\n      isNewLoader(state.loaderData, state.matches[index], match) ||\n      cancelledDeferredRoutes.some((id) => id === match.route.id)\n    ) {\n      return true;\n    }\n\n    // This is the default implementation for when we revalidate.  If the route\n    // provides it's own implementation, then we give them full control but\n    // provide this value so they can leverage it if needed after they check\n    // their own specific use cases\n    let currentRouteMatch = state.matches[index];\n    let nextRouteMatch = match;\n\n    return shouldRevalidateLoader(match, {\n      currentUrl,\n      currentParams: currentRouteMatch.params,\n      nextUrl,\n      nextParams: nextRouteMatch.params,\n      ...submission,\n      actionResult,\n      actionStatus,\n      defaultShouldRevalidate: shouldSkipRevalidation\n        ? false\n        : // Forced revalidation due to submission, useRevalidator, or X-Remix-Revalidate\n          isRevalidationRequired ||\n          currentUrl.pathname + currentUrl.search ===\n            nextUrl.pathname + nextUrl.search ||\n          // Search params affect all loaders\n          currentUrl.search !== nextUrl.search ||\n          isNewRouteInstance(currentRouteMatch, nextRouteMatch),\n    });\n  });\n\n  // Pick fetcher.loads that need to be revalidated\n  let revalidatingFetchers: RevalidatingFetcher[] = [];\n  fetchLoadMatches.forEach((f, key) => {\n    // Don't revalidate:\n    //  - on initial hydration (shouldn't be any fetchers then anyway)\n    //  - if fetcher won't be present in the subsequent render\n    //    - no longer matches the URL (v7_fetcherPersist=false)\n    //    - was unmounted but persisted due to v7_fetcherPersist=true\n    if (\n      initialHydration ||\n      !matches.some((m) => m.route.id === f.routeId) ||\n      deletedFetchers.has(key)\n    ) {\n      return;\n    }\n\n    let fetcherMatches = matchRoutes(routesToUse, f.path, basename);\n\n    // If the fetcher path no longer matches, push it in with null matches so\n    // we can trigger a 404 in callLoadersAndMaybeResolveData.  Note this is\n    // currently only a use-case for Remix HMR where the route tree can change\n    // at runtime and remove a route previously loaded via a fetcher\n    if (!fetcherMatches) {\n      revalidatingFetchers.push({\n        key,\n        routeId: f.routeId,\n        path: f.path,\n        matches: null,\n        match: null,\n        controller: null,\n      });\n      return;\n    }\n\n    // Revalidating fetchers are decoupled from the route matches since they\n    // load from a static href.  They revalidate based on explicit revalidation\n    // (submission, useRevalidator, or X-Remix-Revalidate)\n    let fetcher = state.fetchers.get(key);\n    let fetcherMatch = getTargetMatch(fetcherMatches, f.path);\n\n    let shouldRevalidate = false;\n    if (fetchRedirectIds.has(key)) {\n      // Never trigger a revalidation of an actively redirecting fetcher\n      shouldRevalidate = false;\n    } else if (cancelledFetcherLoads.has(key)) {\n      // Always mark for revalidation if the fetcher was cancelled\n      cancelledFetcherLoads.delete(key);\n      shouldRevalidate = true;\n    } else if (\n      fetcher &&\n      fetcher.state !== \"idle\" &&\n      fetcher.data === undefined\n    ) {\n      // If the fetcher hasn't ever completed loading yet, then this isn't a\n      // revalidation, it would just be a brand new load if an explicit\n      // revalidation is required\n      shouldRevalidate = isRevalidationRequired;\n    } else {\n      // Otherwise fall back on any user-defined shouldRevalidate, defaulting\n      // to explicit revalidations only\n      shouldRevalidate = shouldRevalidateLoader(fetcherMatch, {\n        currentUrl,\n        currentParams: state.matches[state.matches.length - 1].params,\n        nextUrl,\n        nextParams: matches[matches.length - 1].params,\n        ...submission,\n        actionResult,\n        actionStatus,\n        defaultShouldRevalidate: shouldSkipRevalidation\n          ? false\n          : isRevalidationRequired,\n      });\n    }\n\n    if (shouldRevalidate) {\n      revalidatingFetchers.push({\n        key,\n        routeId: f.routeId,\n        path: f.path,\n        matches: fetcherMatches,\n        match: fetcherMatch,\n        controller: new AbortController(),\n      });\n    }\n  });\n\n  return [navigationMatches, revalidatingFetchers];\n}\n\nfunction shouldLoadRouteOnHydration(\n  route: AgnosticDataRouteObject,\n  loaderData: RouteData | null | undefined,\n  errors: RouteData | null | undefined\n) {\n  // We dunno if we have a loader - gotta find out!\n  if (route.lazy) {\n    return true;\n  }\n\n  // No loader, nothing to initialize\n  if (!route.loader) {\n    return false;\n  }\n\n  let hasData = loaderData != null && loaderData[route.id] !== undefined;\n  let hasError = errors != null && errors[route.id] !== undefined;\n\n  // Don't run if we error'd during SSR\n  if (!hasData && hasError) {\n    return false;\n  }\n\n  // Explicitly opting-in to running on hydration\n  if (typeof route.loader === \"function\" && route.loader.hydrate === true) {\n    return true;\n  }\n\n  // Otherwise, run if we're not yet initialized with anything\n  return !hasData && !hasError;\n}\n\nfunction isNewLoader(\n  currentLoaderData: RouteData,\n  currentMatch: AgnosticDataRouteMatch,\n  match: AgnosticDataRouteMatch\n) {\n  let isNew =\n    // [a] -> [a, b]\n    !currentMatch ||\n    // [a, b] -> [a, c]\n    match.route.id !== currentMatch.route.id;\n\n  // Handle the case that we don't have data for a re-used route, potentially\n  // from a prior error or from a cancelled pending deferred\n  let isMissingData = currentLoaderData[match.route.id] === undefined;\n\n  // Always load if this is a net-new route or we don't yet have data\n  return isNew || isMissingData;\n}\n\nfunction isNewRouteInstance(\n  currentMatch: AgnosticDataRouteMatch,\n  match: AgnosticDataRouteMatch\n) {\n  let currentPath = currentMatch.route.path;\n  return (\n    // param change for this match, /users/123 -> /users/456\n    currentMatch.pathname !== match.pathname ||\n    // splat param changed, which is not present in match.path\n    // e.g. /files/images/avatar.jpg -> files/finances.xls\n    (currentPath != null &&\n      currentPath.endsWith(\"*\") &&\n      currentMatch.params[\"*\"] !== match.params[\"*\"])\n  );\n}\n\nfunction shouldRevalidateLoader(\n  loaderMatch: AgnosticDataRouteMatch,\n  arg: ShouldRevalidateFunctionArgs\n) {\n  if (loaderMatch.route.shouldRevalidate) {\n    let routeChoice = loaderMatch.route.shouldRevalidate(arg);\n    if (typeof routeChoice === \"boolean\") {\n      return routeChoice;\n    }\n  }\n\n  return arg.defaultShouldRevalidate;\n}\n\nfunction patchRoutesImpl(\n  routeId: string | null,\n  children: AgnosticRouteObject[],\n  routesToUse: AgnosticDataRouteObject[],\n  manifest: RouteManifest,\n  mapRouteProperties: MapRoutePropertiesFunction\n) {\n  let childrenToPatch: AgnosticDataRouteObject[];\n  if (routeId) {\n    let route = manifest[routeId];\n    invariant(\n      route,\n      `No route found to patch children into: routeId = ${routeId}`\n    );\n    if (!route.children) {\n      route.children = [];\n    }\n    childrenToPatch = route.children;\n  } else {\n    childrenToPatch = routesToUse;\n  }\n\n  // Don't patch in routes we already know about so that `patch` is idempotent\n  // to simplify user-land code. This is useful because we re-call the\n  // `patchRoutesOnNavigation` function for matched routes with params.\n  let uniqueChildren = children.filter(\n    (newRoute) =>\n      !childrenToPatch.some((existingRoute) =>\n        isSameRoute(newRoute, existingRoute)\n      )\n  );\n\n  let newRoutes = convertRoutesToDataRoutes(\n    uniqueChildren,\n    mapRouteProperties,\n    [routeId || \"_\", \"patch\", String(childrenToPatch?.length || \"0\")],\n    manifest\n  );\n\n  childrenToPatch.push(...newRoutes);\n}\n\nfunction isSameRoute(\n  newRoute: AgnosticRouteObject,\n  existingRoute: AgnosticRouteObject\n): boolean {\n  // Most optimal check is by id\n  if (\n    \"id\" in newRoute &&\n    \"id\" in existingRoute &&\n    newRoute.id === existingRoute.id\n  ) {\n    return true;\n  }\n\n  // Second is by pathing differences\n  if (\n    !(\n      newRoute.index === existingRoute.index &&\n      newRoute.path === existingRoute.path &&\n      newRoute.caseSensitive === existingRoute.caseSensitive\n    )\n  ) {\n    return false;\n  }\n\n  // Pathless layout routes are trickier since we need to check children.\n  // If they have no children then they're the same as far as we can tell\n  if (\n    (!newRoute.children || newRoute.children.length === 0) &&\n    (!existingRoute.children || existingRoute.children.length === 0)\n  ) {\n    return true;\n  }\n\n  // Otherwise, we look to see if every child in the new route is already\n  // represented in the existing route's children\n  return newRoute.children!.every((aChild, i) =>\n    existingRoute.children?.some((bChild) => isSameRoute(aChild, bChild))\n  );\n}\n\n/**\n * Execute route.lazy() methods to lazily load route modules (loader, action,\n * shouldRevalidate) and update the routeManifest in place which shares objects\n * with dataRoutes so those get updated as well.\n */\nasync function loadLazyRouteModule(\n  route: AgnosticDataRouteObject,\n  mapRouteProperties: MapRoutePropertiesFunction,\n  manifest: RouteManifest\n) {\n  if (!route.lazy) {\n    return;\n  }\n\n  let lazyRoute = await route.lazy();\n\n  // If the lazy route function was executed and removed by another parallel\n  // call then we can return - first lazy() to finish wins because the return\n  // value of lazy is expected to be static\n  if (!route.lazy) {\n    return;\n  }\n\n  let routeToUpdate = manifest[route.id];\n  invariant(routeToUpdate, \"No route found in manifest\");\n\n  // Update the route in place.  This should be safe because there's no way\n  // we could yet be sitting on this route as we can't get there without\n  // resolving lazy() first.\n  //\n  // This is different than the HMR \"update\" use-case where we may actively be\n  // on the route being updated.  The main concern boils down to \"does this\n  // mutation affect any ongoing navigations or any current state.matches\n  // values?\".  If not, it should be safe to update in place.\n  let routeUpdates: Record<string, any> = {};\n  for (let lazyRouteProperty in lazyRoute) {\n    let staticRouteValue =\n      routeToUpdate[lazyRouteProperty as keyof typeof routeToUpdate];\n\n    let isPropertyStaticallyDefined =\n      staticRouteValue !== undefined &&\n      // This property isn't static since it should always be updated based\n      // on the route updates\n      lazyRouteProperty !== \"hasErrorBoundary\";\n\n    warning(\n      !isPropertyStaticallyDefined,\n      `Route \"${routeToUpdate.id}\" has a static property \"${lazyRouteProperty}\" ` +\n        `defined but its lazy function is also returning a value for this property. ` +\n        `The lazy route property \"${lazyRouteProperty}\" will be ignored.`\n    );\n\n    if (\n      !isPropertyStaticallyDefined &&\n      !immutableRouteKeys.has(lazyRouteProperty as ImmutableRouteKey)\n    ) {\n      routeUpdates[lazyRouteProperty] =\n        lazyRoute[lazyRouteProperty as keyof typeof lazyRoute];\n    }\n  }\n\n  // Mutate the route with the provided updates.  Do this first so we pass\n  // the updated version to mapRouteProperties\n  Object.assign(routeToUpdate, routeUpdates);\n\n  // Mutate the `hasErrorBoundary` property on the route based on the route\n  // updates and remove the `lazy` function so we don't resolve the lazy\n  // route again.\n  Object.assign(routeToUpdate, {\n    // To keep things framework agnostic, we use the provided\n    // `mapRouteProperties` (or wrapped `detectErrorBoundary`) function to\n    // set the framework-aware properties (`element`/`hasErrorBoundary`) since\n    // the logic will differ between frameworks.\n    ...mapRouteProperties(routeToUpdate),\n    lazy: undefined,\n  });\n}\n\n// Default implementation of `dataStrategy` which fetches all loaders in parallel\nasync function defaultDataStrategy({\n  matches,\n}: DataStrategyFunctionArgs): ReturnType<DataStrategyFunction> {\n  let matchesToLoad = matches.filter((m) => m.shouldLoad);\n  let results = await Promise.all(matchesToLoad.map((m) => m.resolve()));\n  return results.reduce(\n    (acc, result, i) =>\n      Object.assign(acc, { [matchesToLoad[i].route.id]: result }),\n    {}\n  );\n}\n\nasync function callDataStrategyImpl(\n  dataStrategyImpl: DataStrategyFunction,\n  type: \"loader\" | \"action\",\n  state: RouterState | null,\n  request: Request,\n  matchesToLoad: AgnosticDataRouteMatch[],\n  matches: AgnosticDataRouteMatch[],\n  fetcherKey: string | null,\n  manifest: RouteManifest,\n  mapRouteProperties: MapRoutePropertiesFunction,\n  requestContext?: unknown\n): Promise<Record<string, DataStrategyResult>> {\n  let loadRouteDefinitionsPromises = matches.map((m) =>\n    m.route.lazy\n      ? loadLazyRouteModule(m.route, mapRouteProperties, manifest)\n      : undefined\n  );\n\n  let dsMatches = matches.map((match, i) => {\n    let loadRoutePromise = loadRouteDefinitionsPromises[i];\n    let shouldLoad = matchesToLoad.some((m) => m.route.id === match.route.id);\n    // `resolve` encapsulates route.lazy(), executing the loader/action,\n    // and mapping return values/thrown errors to a `DataStrategyResult`.  Users\n    // can pass a callback to take fine-grained control over the execution\n    // of the loader/action\n    let resolve: DataStrategyMatch[\"resolve\"] = async (handlerOverride) => {\n      if (\n        handlerOverride &&\n        request.method === \"GET\" &&\n        (match.route.lazy || match.route.loader)\n      ) {\n        shouldLoad = true;\n      }\n      return shouldLoad\n        ? callLoaderOrAction(\n            type,\n            request,\n            match,\n            loadRoutePromise,\n            handlerOverride,\n            requestContext\n          )\n        : Promise.resolve({ type: ResultType.data, result: undefined });\n    };\n\n    return {\n      ...match,\n      shouldLoad,\n      resolve,\n    };\n  });\n\n  // Send all matches here to allow for a middleware-type implementation.\n  // handler will be a no-op for unneeded routes and we filter those results\n  // back out below.\n  let results = await dataStrategyImpl({\n    matches: dsMatches,\n    request,\n    params: matches[0].params,\n    fetcherKey,\n    context: requestContext,\n  });\n\n  // Wait for all routes to load here but 'swallow the error since we want\n  // it to bubble up from the `await loadRoutePromise` in `callLoaderOrAction` -\n  // called from `match.resolve()`\n  try {\n    await Promise.all(loadRouteDefinitionsPromises);\n  } catch (e) {\n    // No-op\n  }\n\n  return results;\n}\n\n// Default logic for calling a loader/action is the user has no specified a dataStrategy\nasync function callLoaderOrAction(\n  type: \"loader\" | \"action\",\n  request: Request,\n  match: AgnosticDataRouteMatch,\n  loadRoutePromise: Promise<void> | undefined,\n  handlerOverride: Parameters<DataStrategyMatch[\"resolve\"]>[0],\n  staticContext?: unknown\n): Promise<DataStrategyResult> {\n  let result: DataStrategyResult;\n  let onReject: (() => void) | undefined;\n\n  let runHandler = (\n    handler: AgnosticRouteObject[\"loader\"] | AgnosticRouteObject[\"action\"]\n  ): Promise<DataStrategyResult> => {\n    // Setup a promise we can race against so that abort signals short circuit\n    let reject: () => void;\n    // This will never resolve so safe to type it as Promise<DataStrategyResult> to\n    // satisfy the function return value\n    let abortPromise = new Promise<DataStrategyResult>((_, r) => (reject = r));\n    onReject = () => reject();\n    request.signal.addEventListener(\"abort\", onReject);\n\n    let actualHandler = (ctx?: unknown) => {\n      if (typeof handler !== \"function\") {\n        return Promise.reject(\n          new Error(\n            `You cannot call the handler for a route which defines a boolean ` +\n              `\"${type}\" [routeId: ${match.route.id}]`\n          )\n        );\n      }\n      return handler(\n        {\n          request,\n          params: match.params,\n          context: staticContext,\n        },\n        ...(ctx !== undefined ? [ctx] : [])\n      );\n    };\n\n    let handlerPromise: Promise<DataStrategyResult> = (async () => {\n      try {\n        let val = await (handlerOverride\n          ? handlerOverride((ctx: unknown) => actualHandler(ctx))\n          : actualHandler());\n        return { type: \"data\", result: val };\n      } catch (e) {\n        return { type: \"error\", result: e };\n      }\n    })();\n\n    return Promise.race([handlerPromise, abortPromise]);\n  };\n\n  try {\n    let handler = match.route[type];\n\n    // If we have a route.lazy promise, await that first\n    if (loadRoutePromise) {\n      if (handler) {\n        // Run statically defined handler in parallel with lazy()\n        let handlerError;\n        let [value] = await Promise.all([\n          // If the handler throws, don't let it immediately bubble out,\n          // since we need to let the lazy() execution finish so we know if this\n          // route has a boundary that can handle the error\n          runHandler(handler).catch((e) => {\n            handlerError = e;\n          }),\n          loadRoutePromise,\n        ]);\n        if (handlerError !== undefined) {\n          throw handlerError;\n        }\n        result = value!;\n      } else {\n        // Load lazy route module, then run any returned handler\n        await loadRoutePromise;\n\n        handler = match.route[type];\n        if (handler) {\n          // Handler still runs even if we got interrupted to maintain consistency\n          // with un-abortable behavior of handler execution on non-lazy or\n          // previously-lazy-loaded routes\n          result = await runHandler(handler);\n        } else if (type === \"action\") {\n          let url = new URL(request.url);\n          let pathname = url.pathname + url.search;\n          throw getInternalRouterError(405, {\n            method: request.method,\n            pathname,\n            routeId: match.route.id,\n          });\n        } else {\n          // lazy() route has no loader to run.  Short circuit here so we don't\n          // hit the invariant below that errors on returning undefined.\n          return { type: ResultType.data, result: undefined };\n        }\n      }\n    } else if (!handler) {\n      let url = new URL(request.url);\n      let pathname = url.pathname + url.search;\n      throw getInternalRouterError(404, {\n        pathname,\n      });\n    } else {\n      result = await runHandler(handler);\n    }\n\n    invariant(\n      result.result !== undefined,\n      `You defined ${type === \"action\" ? \"an action\" : \"a loader\"} for route ` +\n        `\"${match.route.id}\" but didn't return anything from your \\`${type}\\` ` +\n        `function. Please return a value or \\`null\\`.`\n    );\n  } catch (e) {\n    // We should already be catching and converting normal handler executions to\n    // DataStrategyResults and returning them, so anything that throws here is an\n    // unexpected error we still need to wrap\n    return { type: ResultType.error, result: e };\n  } finally {\n    if (onReject) {\n      request.signal.removeEventListener(\"abort\", onReject);\n    }\n  }\n\n  return result;\n}\n\nasync function convertDataStrategyResultToDataResult(\n  dataStrategyResult: DataStrategyResult\n): Promise<DataResult> {\n  let { result, type } = dataStrategyResult;\n\n  if (isResponse(result)) {\n    let data: any;\n\n    try {\n      let contentType = result.headers.get(\"Content-Type\");\n      // Check between word boundaries instead of startsWith() due to the last\n      // paragraph of https://httpwg.org/specs/rfc9110.html#field.content-type\n      if (contentType && /\\bapplication\\/json\\b/.test(contentType)) {\n        if (result.body == null) {\n          data = null;\n        } else {\n          data = await result.json();\n        }\n      } else {\n        data = await result.text();\n      }\n    } catch (e) {\n      return { type: ResultType.error, error: e };\n    }\n\n    if (type === ResultType.error) {\n      return {\n        type: ResultType.error,\n        error: new ErrorResponseImpl(result.status, result.statusText, data),\n        statusCode: result.status,\n        headers: result.headers,\n      };\n    }\n\n    return {\n      type: ResultType.data,\n      data,\n      statusCode: result.status,\n      headers: result.headers,\n    };\n  }\n\n  if (type === ResultType.error) {\n    if (isDataWithResponseInit(result)) {\n      if (result.data instanceof Error) {\n        return {\n          type: ResultType.error,\n          error: result.data,\n          statusCode: result.init?.status,\n          headers: result.init?.headers\n            ? new Headers(result.init.headers)\n            : undefined,\n        };\n      }\n\n      // Convert thrown data() to ErrorResponse instances\n      return {\n        type: ResultType.error,\n        error: new ErrorResponseImpl(\n          result.init?.status || 500,\n          undefined,\n          result.data\n        ),\n        statusCode: isRouteErrorResponse(result) ? result.status : undefined,\n        headers: result.init?.headers\n          ? new Headers(result.init.headers)\n          : undefined,\n      };\n    }\n    return {\n      type: ResultType.error,\n      error: result,\n      statusCode: isRouteErrorResponse(result) ? result.status : undefined,\n    };\n  }\n\n  if (isDeferredData(result)) {\n    return {\n      type: ResultType.deferred,\n      deferredData: result,\n      statusCode: result.init?.status,\n      headers: result.init?.headers && new Headers(result.init.headers),\n    };\n  }\n\n  if (isDataWithResponseInit(result)) {\n    return {\n      type: ResultType.data,\n      data: result.data,\n      statusCode: result.init?.status,\n      headers: result.init?.headers\n        ? new Headers(result.init.headers)\n        : undefined,\n    };\n  }\n\n  return { type: ResultType.data, data: result };\n}\n\n// Support relative routing in internal redirects\nfunction normalizeRelativeRoutingRedirectResponse(\n  response: Response,\n  request: Request,\n  routeId: string,\n  matches: AgnosticDataRouteMatch[],\n  basename: string,\n  v7_relativeSplatPath: boolean\n) {\n  let location = response.headers.get(\"Location\");\n  invariant(\n    location,\n    \"Redirects returned/thrown from loaders/actions must have a Location header\"\n  );\n\n  if (!ABSOLUTE_URL_REGEX.test(location)) {\n    let trimmedMatches = matches.slice(\n      0,\n      matches.findIndex((m) => m.route.id === routeId) + 1\n    );\n    location = normalizeTo(\n      new URL(request.url),\n      trimmedMatches,\n      basename,\n      true,\n      location,\n      v7_relativeSplatPath\n    );\n    response.headers.set(\"Location\", location);\n  }\n\n  return response;\n}\n\nfunction normalizeRedirectLocation(\n  location: string,\n  currentUrl: URL,\n  basename: string,\n  historyInstance: History,\n): string {\n  // Match Chrome's behavior:\n  // https://github.com/chromium/chromium/blob/216dbeb61db0c667e62082e5f5400a32d6983df3/content/public/common/url_utils.cc#L82\n  let invalidProtocols = [\n    \"about:\",\n    \"blob:\",\n    \"chrome:\",\n    \"chrome-untrusted:\",\n    \"content:\",\n    \"data:\",\n    \"devtools:\",\n    \"file:\",\n    \"filesystem:\",\n    // eslint-disable-next-line no-script-url\n    \"javascript:\",\n  ];\n\n  if (ABSOLUTE_URL_REGEX.test(location)) {\n    // Strip off the protocol+origin for same-origin + same-basename absolute redirects\n    let normalizedLocation = location;\n    let url = normalizedLocation.startsWith(\"//\")\n      ? new URL(currentUrl.protocol + normalizedLocation)\n      : new URL(normalizedLocation);\n    if (invalidProtocols.includes(url.protocol)) {\n      throw new Error(\"Invalid redirect location\");\n    }\n    let isSameBasename = stripBasename(url.pathname, basename) != null;\n    if (url.origin === currentUrl.origin && isSameBasename) {\n      return url.pathname + url.search + url.hash;\n    }\n  }\n\n  try {\n    let url = historyInstance.createURL(location);\n    if (invalidProtocols.includes(url.protocol)) {\n      throw new Error(\"Invalid redirect location\");\n    }\n  } catch (e) {}\n\n  return location;\n}\n\n// Utility method for creating the Request instances for loaders/actions during\n// client-side navigations and fetches.  During SSR we will always have a\n// Request instance from the static handler (query/queryRoute)\nfunction createClientSideRequest(\n  history: History,\n  location: string | Location,\n  signal: AbortSignal,\n  submission?: Submission\n): Request {\n  let url = history.createURL(stripHashFromPath(location)).toString();\n  let init: RequestInit = { signal };\n\n  if (submission && isMutationMethod(submission.formMethod)) {\n    let { formMethod, formEncType } = submission;\n    // Didn't think we needed this but it turns out unlike other methods, patch\n    // won't be properly normalized to uppercase and results in a 405 error.\n    // See: https://fetch.spec.whatwg.org/#concept-method\n    init.method = formMethod.toUpperCase();\n\n    if (formEncType === \"application/json\") {\n      init.headers = new Headers({ \"Content-Type\": formEncType });\n      init.body = JSON.stringify(submission.json);\n    } else if (formEncType === \"text/plain\") {\n      // Content-Type is inferred (https://fetch.spec.whatwg.org/#dom-request)\n      init.body = submission.text;\n    } else if (\n      formEncType === \"application/x-www-form-urlencoded\" &&\n      submission.formData\n    ) {\n      // Content-Type is inferred (https://fetch.spec.whatwg.org/#dom-request)\n      init.body = convertFormDataToSearchParams(submission.formData);\n    } else {\n      // Content-Type is inferred (https://fetch.spec.whatwg.org/#dom-request)\n      init.body = submission.formData;\n    }\n  }\n\n  return new Request(url, init);\n}\n\nfunction convertFormDataToSearchParams(formData: FormData): URLSearchParams {\n  let searchParams = new URLSearchParams();\n\n  for (let [key, value] of formData.entries()) {\n    // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#converting-an-entry-list-to-a-list-of-name-value-pairs\n    searchParams.append(key, typeof value === \"string\" ? value : value.name);\n  }\n\n  return searchParams;\n}\n\nfunction convertSearchParamsToFormData(\n  searchParams: URLSearchParams\n): FormData {\n  let formData = new FormData();\n  for (let [key, value] of searchParams.entries()) {\n    formData.append(key, value);\n  }\n  return formData;\n}\n\nfunction processRouteLoaderData(\n  matches: AgnosticDataRouteMatch[],\n  results: Record<string, DataResult>,\n  pendingActionResult: PendingActionResult | undefined,\n  activeDeferreds: Map<string, DeferredData>,\n  skipLoaderErrorBubbling: boolean\n): {\n  loaderData: RouterState[\"loaderData\"];\n  errors: RouterState[\"errors\"] | null;\n  statusCode: number;\n  loaderHeaders: Record<string, Headers>;\n} {\n  // Fill in loaderData/errors from our loaders\n  let loaderData: RouterState[\"loaderData\"] = {};\n  let errors: RouterState[\"errors\"] | null = null;\n  let statusCode: number | undefined;\n  let foundError = false;\n  let loaderHeaders: Record<string, Headers> = {};\n  let pendingError =\n    pendingActionResult && isErrorResult(pendingActionResult[1])\n      ? pendingActionResult[1].error\n      : undefined;\n\n  // Process loader results into state.loaderData/state.errors\n  matches.forEach((match) => {\n    if (!(match.route.id in results)) {\n      return;\n    }\n    let id = match.route.id;\n    let result = results[id];\n    invariant(\n      !isRedirectResult(result),\n      \"Cannot handle redirect results in processLoaderData\"\n    );\n    if (isErrorResult(result)) {\n      let error = result.error;\n      // If we have a pending action error, we report it at the highest-route\n      // that throws a loader error, and then clear it out to indicate that\n      // it was consumed\n      if (pendingError !== undefined) {\n        error = pendingError;\n        pendingError = undefined;\n      }\n\n      errors = errors || {};\n\n      if (skipLoaderErrorBubbling) {\n        errors[id] = error;\n      } else {\n        // Look upwards from the matched route for the closest ancestor error\n        // boundary, defaulting to the root match.  Prefer higher error values\n        // if lower errors bubble to the same boundary\n        let boundaryMatch = findNearestBoundary(matches, id);\n        if (errors[boundaryMatch.route.id] == null) {\n          errors[boundaryMatch.route.id] = error;\n        }\n      }\n\n      // Clear our any prior loaderData for the throwing route\n      loaderData[id] = undefined;\n\n      // Once we find our first (highest) error, we set the status code and\n      // prevent deeper status codes from overriding\n      if (!foundError) {\n        foundError = true;\n        statusCode = isRouteErrorResponse(result.error)\n          ? result.error.status\n          : 500;\n      }\n      if (result.headers) {\n        loaderHeaders[id] = result.headers;\n      }\n    } else {\n      if (isDeferredResult(result)) {\n        activeDeferreds.set(id, result.deferredData);\n        loaderData[id] = result.deferredData.data;\n        // Error status codes always override success status codes, but if all\n        // loaders are successful we take the deepest status code.\n        if (\n          result.statusCode != null &&\n          result.statusCode !== 200 &&\n          !foundError\n        ) {\n          statusCode = result.statusCode;\n        }\n        if (result.headers) {\n          loaderHeaders[id] = result.headers;\n        }\n      } else {\n        loaderData[id] = result.data;\n        // Error status codes always override success status codes, but if all\n        // loaders are successful we take the deepest status code.\n        if (result.statusCode && result.statusCode !== 200 && !foundError) {\n          statusCode = result.statusCode;\n        }\n        if (result.headers) {\n          loaderHeaders[id] = result.headers;\n        }\n      }\n    }\n  });\n\n  // If we didn't consume the pending action error (i.e., all loaders\n  // resolved), then consume it here.  Also clear out any loaderData for the\n  // throwing route\n  if (pendingError !== undefined && pendingActionResult) {\n    errors = { [pendingActionResult[0]]: pendingError };\n    loaderData[pendingActionResult[0]] = undefined;\n  }\n\n  return {\n    loaderData,\n    errors,\n    statusCode: statusCode || 200,\n    loaderHeaders,\n  };\n}\n\nfunction processLoaderData(\n  state: RouterState,\n  matches: AgnosticDataRouteMatch[],\n  results: Record<string, DataResult>,\n  pendingActionResult: PendingActionResult | undefined,\n  revalidatingFetchers: RevalidatingFetcher[],\n  fetcherResults: Record<string, DataResult>,\n  activeDeferreds: Map<string, DeferredData>\n): {\n  loaderData: RouterState[\"loaderData\"];\n  errors?: RouterState[\"errors\"];\n} {\n  let { loaderData, errors } = processRouteLoaderData(\n    matches,\n    results,\n    pendingActionResult,\n    activeDeferreds,\n    false // This method is only called client side so we always want to bubble\n  );\n\n  // Process results from our revalidating fetchers\n  revalidatingFetchers.forEach((rf) => {\n    let { key, match, controller } = rf;\n    let result = fetcherResults[key];\n    invariant(result, \"Did not find corresponding fetcher result\");\n\n    // Process fetcher non-redirect errors\n    if (controller && controller.signal.aborted) {\n      // Nothing to do for aborted fetchers\n      return;\n    } else if (isErrorResult(result)) {\n      let boundaryMatch = findNearestBoundary(state.matches, match?.route.id);\n      if (!(errors && errors[boundaryMatch.route.id])) {\n        errors = {\n          ...errors,\n          [boundaryMatch.route.id]: result.error,\n        };\n      }\n      state.fetchers.delete(key);\n    } else if (isRedirectResult(result)) {\n      // Should never get here, redirects should get processed above, but we\n      // keep this to type narrow to a success result in the else\n      invariant(false, \"Unhandled fetcher revalidation redirect\");\n    } else if (isDeferredResult(result)) {\n      // Should never get here, deferred data should be awaited for fetchers\n      // in resolveDeferredResults\n      invariant(false, \"Unhandled fetcher deferred data\");\n    } else {\n      let doneFetcher = getDoneFetcher(result.data);\n      state.fetchers.set(key, doneFetcher);\n    }\n  });\n\n  return { loaderData, errors };\n}\n\nfunction mergeLoaderData(\n  loaderData: RouteData,\n  newLoaderData: RouteData,\n  matches: AgnosticDataRouteMatch[],\n  errors: RouteData | null | undefined\n): RouteData {\n  let mergedLoaderData = { ...newLoaderData };\n  for (let match of matches) {\n    let id = match.route.id;\n    if (newLoaderData.hasOwnProperty(id)) {\n      if (newLoaderData[id] !== undefined) {\n        mergedLoaderData[id] = newLoaderData[id];\n      } else {\n        // No-op - this is so we ignore existing data if we have a key in the\n        // incoming object with an undefined value, which is how we unset a prior\n        // loaderData if we encounter a loader error\n      }\n    } else if (loaderData[id] !== undefined && match.route.loader) {\n      // Preserve existing keys not included in newLoaderData and where a loader\n      // wasn't removed by HMR\n      mergedLoaderData[id] = loaderData[id];\n    }\n\n    if (errors && errors.hasOwnProperty(id)) {\n      // Don't keep any loader data below the boundary\n      break;\n    }\n  }\n  return mergedLoaderData;\n}\n\nfunction getActionDataForCommit(\n  pendingActionResult: PendingActionResult | undefined\n) {\n  if (!pendingActionResult) {\n    return {};\n  }\n  return isErrorResult(pendingActionResult[1])\n    ? {\n        // Clear out prior actionData on errors\n        actionData: {},\n      }\n    : {\n        actionData: {\n          [pendingActionResult[0]]: pendingActionResult[1].data,\n        },\n      };\n}\n\n// Find the nearest error boundary, looking upwards from the leaf route (or the\n// route specified by routeId) for the closest ancestor error boundary,\n// defaulting to the root match\nfunction findNearestBoundary(\n  matches: AgnosticDataRouteMatch[],\n  routeId?: string\n): AgnosticDataRouteMatch {\n  let eligibleMatches = routeId\n    ? matches.slice(0, matches.findIndex((m) => m.route.id === routeId) + 1)\n    : [...matches];\n  return (\n    eligibleMatches.reverse().find((m) => m.route.hasErrorBoundary === true) ||\n    matches[0]\n  );\n}\n\nfunction getShortCircuitMatches(routes: AgnosticDataRouteObject[]): {\n  matches: AgnosticDataRouteMatch[];\n  route: AgnosticDataRouteObject;\n} {\n  // Prefer a root layout route if present, otherwise shim in a route object\n  let route =\n    routes.length === 1\n      ? routes[0]\n      : routes.find((r) => r.index || !r.path || r.path === \"/\") || {\n          id: `__shim-error-route__`,\n        };\n\n  return {\n    matches: [\n      {\n        params: {},\n        pathname: \"\",\n        pathnameBase: \"\",\n        route,\n      },\n    ],\n    route,\n  };\n}\n\nfunction getInternalRouterError(\n  status: number,\n  {\n    pathname,\n    routeId,\n    method,\n    type,\n    message,\n  }: {\n    pathname?: string;\n    routeId?: string;\n    method?: string;\n    type?: \"defer-action\" | \"invalid-body\";\n    message?: string;\n  } = {}\n) {\n  let statusText = \"Unknown Server Error\";\n  let errorMessage = \"Unknown @remix-run/router error\";\n\n  if (status === 400) {\n    statusText = \"Bad Request\";\n    if (method && pathname && routeId) {\n      errorMessage =\n        `You made a ${method} request to \"${pathname}\" but ` +\n        `did not provide a \\`loader\\` for route \"${routeId}\", ` +\n        `so there is no way to handle the request.`;\n    } else if (type === \"defer-action\") {\n      errorMessage = \"defer() is not supported in actions\";\n    } else if (type === \"invalid-body\") {\n      errorMessage = \"Unable to encode submission body\";\n    }\n  } else if (status === 403) {\n    statusText = \"Forbidden\";\n    errorMessage = `Route \"${routeId}\" does not match URL \"${pathname}\"`;\n  } else if (status === 404) {\n    statusText = \"Not Found\";\n    errorMessage = `No route matches URL \"${pathname}\"`;\n  } else if (status === 405) {\n    statusText = \"Method Not Allowed\";\n    if (method && pathname && routeId) {\n      errorMessage =\n        `You made a ${method.toUpperCase()} request to \"${pathname}\" but ` +\n        `did not provide an \\`action\\` for route \"${routeId}\", ` +\n        `so there is no way to handle the request.`;\n    } else if (method) {\n      errorMessage = `Invalid request method \"${method.toUpperCase()}\"`;\n    }\n  }\n\n  return new ErrorResponseImpl(\n    status || 500,\n    statusText,\n    new Error(errorMessage),\n    true\n  );\n}\n\n// Find any returned redirect errors, starting from the lowest match\nfunction findRedirect(\n  results: Record<string, DataResult>\n): { key: string; result: RedirectResult } | undefined {\n  let entries = Object.entries(results);\n  for (let i = entries.length - 1; i >= 0; i--) {\n    let [key, result] = entries[i];\n    if (isRedirectResult(result)) {\n      return { key, result };\n    }\n  }\n}\n\nfunction stripHashFromPath(path: To) {\n  let parsedPath = typeof path === \"string\" ? parsePath(path) : path;\n  return createPath({ ...parsedPath, hash: \"\" });\n}\n\nfunction isHashChangeOnly(a: Location, b: Location): boolean {\n  if (a.pathname !== b.pathname || a.search !== b.search) {\n    return false;\n  }\n\n  if (a.hash === \"\") {\n    // /page -> /page#hash\n    return b.hash !== \"\";\n  } else if (a.hash === b.hash) {\n    // /page#hash -> /page#hash\n    return true;\n  } else if (b.hash !== \"\") {\n    // /page#hash -> /page#other\n    return true;\n  }\n\n  // If the hash is removed the browser will re-perform a request to the server\n  // /page#hash -> /page\n  return false;\n}\n\nfunction isPromise<T = unknown>(val: unknown): val is Promise<T> {\n  return typeof val === \"object\" && val != null && \"then\" in val;\n}\n\nfunction isDataStrategyResult(result: unknown): result is DataStrategyResult {\n  return (\n    result != null &&\n    typeof result === \"object\" &&\n    \"type\" in result &&\n    \"result\" in result &&\n    (result.type === ResultType.data || result.type === ResultType.error)\n  );\n}\n\nfunction isRedirectDataStrategyResultResult(result: DataStrategyResult) {\n  return (\n    isResponse(result.result) && redirectStatusCodes.has(result.result.status)\n  );\n}\n\nfunction isDeferredResult(result: DataResult): result is DeferredResult {\n  return result.type === ResultType.deferred;\n}\n\nfunction isErrorResult(result: DataResult): result is ErrorResult {\n  return result.type === ResultType.error;\n}\n\nfunction isRedirectResult(result?: DataResult): result is RedirectResult {\n  return (result && result.type) === ResultType.redirect;\n}\n\nexport function isDataWithResponseInit(\n  value: any\n): value is DataWithResponseInit<unknown> {\n  return (\n    typeof value === \"object\" &&\n    value != null &&\n    \"type\" in value &&\n    \"data\" in value &&\n    \"init\" in value &&\n    value.type === \"DataWithResponseInit\"\n  );\n}\n\nexport function isDeferredData(value: any): value is DeferredData {\n  let deferred: DeferredData = value;\n  return (\n    deferred &&\n    typeof deferred === \"object\" &&\n    typeof deferred.data === \"object\" &&\n    typeof deferred.subscribe === \"function\" &&\n    typeof deferred.cancel === \"function\" &&\n    typeof deferred.resolveData === \"function\"\n  );\n}\n\nfunction isResponse(value: any): value is Response {\n  return (\n    value != null &&\n    typeof value.status === \"number\" &&\n    typeof value.statusText === \"string\" &&\n    typeof value.headers === \"object\" &&\n    typeof value.body !== \"undefined\"\n  );\n}\n\nfunction isRedirectResponse(result: any): result is Response {\n  if (!isResponse(result)) {\n    return false;\n  }\n\n  let status = result.status;\n  let location = result.headers.get(\"Location\");\n  return status >= 300 && status <= 399 && location != null;\n}\n\nfunction isValidMethod(method: string): method is FormMethod | V7_FormMethod {\n  return validRequestMethods.has(method.toLowerCase() as FormMethod);\n}\n\nfunction isMutationMethod(\n  method: string\n): method is MutationFormMethod | V7_MutationFormMethod {\n  return validMutationMethods.has(method.toLowerCase() as MutationFormMethod);\n}\n\nasync function resolveNavigationDeferredResults(\n  matches: (AgnosticDataRouteMatch | null)[],\n  results: Record<string, DataResult>,\n  signal: AbortSignal,\n  currentMatches: AgnosticDataRouteMatch[],\n  currentLoaderData: RouteData\n) {\n  let entries = Object.entries(results);\n  for (let index = 0; index < entries.length; index++) {\n    let [routeId, result] = entries[index];\n    let match = matches.find((m) => m?.route.id === routeId);\n    // If we don't have a match, then we can have a deferred result to do\n    // anything with.  This is for revalidating fetchers where the route was\n    // removed during HMR\n    if (!match) {\n      continue;\n    }\n\n    let currentMatch = currentMatches.find(\n      (m) => m.route.id === match!.route.id\n    );\n    let isRevalidatingLoader =\n      currentMatch != null &&\n      !isNewRouteInstance(currentMatch, match) &&\n      (currentLoaderData && currentLoaderData[match.route.id]) !== undefined;\n\n    if (isDeferredResult(result) && isRevalidatingLoader) {\n      // Note: we do not have to touch activeDeferreds here since we race them\n      // against the signal in resolveDeferredData and they'll get aborted\n      // there if needed\n      await resolveDeferredData(result, signal, false).then((result) => {\n        if (result) {\n          results[routeId] = result;\n        }\n      });\n    }\n  }\n}\n\nasync function resolveFetcherDeferredResults(\n  matches: (AgnosticDataRouteMatch | null)[],\n  results: Record<string, DataResult>,\n  revalidatingFetchers: RevalidatingFetcher[]\n) {\n  for (let index = 0; index < revalidatingFetchers.length; index++) {\n    let { key, routeId, controller } = revalidatingFetchers[index];\n    let result = results[key];\n    let match = matches.find((m) => m?.route.id === routeId);\n    // If we don't have a match, then we can have a deferred result to do\n    // anything with.  This is for revalidating fetchers where the route was\n    // removed during HMR\n    if (!match) {\n      continue;\n    }\n\n    if (isDeferredResult(result)) {\n      // Note: we do not have to touch activeDeferreds here since we race them\n      // against the signal in resolveDeferredData and they'll get aborted\n      // there if needed\n      invariant(\n        controller,\n        \"Expected an AbortController for revalidating fetcher deferred result\"\n      );\n      await resolveDeferredData(result, controller.signal, true).then(\n        (result) => {\n          if (result) {\n            results[key] = result;\n          }\n        }\n      );\n    }\n  }\n}\n\nasync function resolveDeferredData(\n  result: DeferredResult,\n  signal: AbortSignal,\n  unwrap = false\n): Promise<SuccessResult | ErrorResult | undefined> {\n  let aborted = await result.deferredData.resolveData(signal);\n  if (aborted) {\n    return;\n  }\n\n  if (unwrap) {\n    try {\n      return {\n        type: ResultType.data,\n        data: result.deferredData.unwrappedData,\n      };\n    } catch (e) {\n      // Handle any TrackedPromise._error values encountered while unwrapping\n      return {\n        type: ResultType.error,\n        error: e,\n      };\n    }\n  }\n\n  return {\n    type: ResultType.data,\n    data: result.deferredData.data,\n  };\n}\n\nfunction hasNakedIndexQuery(search: string): boolean {\n  return new URLSearchParams(search).getAll(\"index\").some((v) => v === \"\");\n}\n\nfunction getTargetMatch(\n  matches: AgnosticDataRouteMatch[],\n  location: Location | string\n) {\n  let search =\n    typeof location === \"string\" ? parsePath(location).search : location.search;\n  if (\n    matches[matches.length - 1].route.index &&\n    hasNakedIndexQuery(search || \"\")\n  ) {\n    // Return the leaf index route when index is present\n    return matches[matches.length - 1];\n  }\n  // Otherwise grab the deepest \"path contributing\" match (ignoring index and\n  // pathless layout routes)\n  let pathMatches = getPathContributingMatches(matches);\n  return pathMatches[pathMatches.length - 1];\n}\n\nfunction getSubmissionFromNavigation(\n  navigation: Navigation\n): Submission | undefined {\n  let { formMethod, formAction, formEncType, text, formData, json } =\n    navigation;\n  if (!formMethod || !formAction || !formEncType) {\n    return;\n  }\n\n  if (text != null) {\n    return {\n      formMethod,\n      formAction,\n      formEncType,\n      formData: undefined,\n      json: undefined,\n      text,\n    };\n  } else if (formData != null) {\n    return {\n      formMethod,\n      formAction,\n      formEncType,\n      formData,\n      json: undefined,\n      text: undefined,\n    };\n  } else if (json !== undefined) {\n    return {\n      formMethod,\n      formAction,\n      formEncType,\n      formData: undefined,\n      json,\n      text: undefined,\n    };\n  }\n}\n\nfunction getLoadingNavigation(\n  location: Location,\n  submission?: Submission\n): NavigationStates[\"Loading\"] {\n  if (submission) {\n    let navigation: NavigationStates[\"Loading\"] = {\n      state: \"loading\",\n      location,\n      formMethod: submission.formMethod,\n      formAction: submission.formAction,\n      formEncType: submission.formEncType,\n      formData: submission.formData,\n      json: submission.json,\n      text: submission.text,\n    };\n    return navigation;\n  } else {\n    let navigation: NavigationStates[\"Loading\"] = {\n      state: \"loading\",\n      location,\n      formMethod: undefined,\n      formAction: undefined,\n      formEncType: undefined,\n      formData: undefined,\n      json: undefined,\n      text: undefined,\n    };\n    return navigation;\n  }\n}\n\nfunction getSubmittingNavigation(\n  location: Location,\n  submission: Submission\n): NavigationStates[\"Submitting\"] {\n  let navigation: NavigationStates[\"Submitting\"] = {\n    state: \"submitting\",\n    location,\n    formMethod: submission.formMethod,\n    formAction: submission.formAction,\n    formEncType: submission.formEncType,\n    formData: submission.formData,\n    json: submission.json,\n    text: submission.text,\n  };\n  return navigation;\n}\n\nfunction getLoadingFetcher(\n  submission?: Submission,\n  data?: Fetcher[\"data\"]\n): FetcherStates[\"Loading\"] {\n  if (submission) {\n    let fetcher: FetcherStates[\"Loading\"] = {\n      state: \"loading\",\n      formMethod: submission.formMethod,\n      formAction: submission.formAction,\n      formEncType: submission.formEncType,\n      formData: submission.formData,\n      json: submission.json,\n      text: submission.text,\n      data,\n    };\n    return fetcher;\n  } else {\n    let fetcher: FetcherStates[\"Loading\"] = {\n      state: \"loading\",\n      formMethod: undefined,\n      formAction: undefined,\n      formEncType: undefined,\n      formData: undefined,\n      json: undefined,\n      text: undefined,\n      data,\n    };\n    return fetcher;\n  }\n}\n\nfunction getSubmittingFetcher(\n  submission: Submission,\n  existingFetcher?: Fetcher\n): FetcherStates[\"Submitting\"] {\n  let fetcher: FetcherStates[\"Submitting\"] = {\n    state: \"submitting\",\n    formMethod: submission.formMethod,\n    formAction: submission.formAction,\n    formEncType: submission.formEncType,\n    formData: submission.formData,\n    json: submission.json,\n    text: submission.text,\n    data: existingFetcher ? existingFetcher.data : undefined,\n  };\n  return fetcher;\n}\n\nfunction getDoneFetcher(data: Fetcher[\"data\"]): FetcherStates[\"Idle\"] {\n  let fetcher: FetcherStates[\"Idle\"] = {\n    state: \"idle\",\n    formMethod: undefined,\n    formAction: undefined,\n    formEncType: undefined,\n    formData: undefined,\n    json: undefined,\n    text: undefined,\n    data,\n  };\n  return fetcher;\n}\n\nfunction restoreAppliedTransitions(\n  _window: Window,\n  transitions: Map<string, Set<string>>\n) {\n  try {\n    let sessionPositions = _window.sessionStorage.getItem(\n      TRANSITIONS_STORAGE_KEY\n    );\n    if (sessionPositions) {\n      let json = JSON.parse(sessionPositions);\n      for (let [k, v] of Object.entries(json || {})) {\n        if (v && Array.isArray(v)) {\n          transitions.set(k, new Set(v || []));\n        }\n      }\n    }\n  } catch (e) {\n    // no-op, use default empty object\n  }\n}\n\nfunction persistAppliedTransitions(\n  _window: Window,\n  transitions: Map<string, Set<string>>\n) {\n  if (transitions.size > 0) {\n    let json: Record<string, string[]> = {};\n    for (let [k, v] of transitions) {\n      json[k] = [...v];\n    }\n    try {\n      _window.sessionStorage.setItem(\n        TRANSITIONS_STORAGE_KEY,\n        JSON.stringify(json)\n      );\n    } catch (error) {\n      warning(\n        false,\n        `Failed to save applied view transitions in sessionStorage (${error}).`\n      );\n    }\n  }\n}\n//#endregion\n"],"names":["Action","PopStateEventType","invariant","value","message","Error","warning","cond","console","warn","e","getHistoryState","location","index","usr","state","key","idx","createLocation","current","to","_extends","pathname","search","hash","parsePath","Math","random","toString","substr","createPath","_ref","charAt","path","parsedPath","hashIndex","indexOf","searchIndex","getUrlBasedHistory","getLocation","createHref","validateLocation","options","window","document","defaultView","v5Compat","globalHistory","history","action","Pop","listener","getIndex","handlePop","nextIndex","delta","createURL","base","origin","href","replace","URL","replaceState","listen","fn","addEventListener","removeEventListener","encodeLocation","url","push","Push","historyState","pushState","error","DOMException","name","assign","Replace","go","n","ResultType","immutableRouteKeys","Set","convertRoutesToDataRoutes","routes","mapRouteProperties","parentPath","manifest","map","route","treePath","String","id","join","children","isIndexRoute","indexRoute","pathOrLayoutRoute","undefined","matchRoutes","locationArg","basename","matchRoutesImpl","allowPartial","stripBasename","branches","flattenRoutes","sort","a","b","score","length","slice","every","i","compareIndexes","routesMeta","meta","childrenIndex","rankRouteBranches","matches","decoded","decodePath","matchRouteBranch","convertRouteMatchToUiMatch","match","loaderData","params","data","handle","parentsMeta","flattenRoute","relativePath","caseSensitive","startsWith","joinPaths","concat","computeScore","forEach","_route$path","includes","exploded","explodeOptionalSegments","segments","split","first","rest","isOptional","endsWith","required","restExploded","result","subpath","paramRe","isSplat","s","initialScore","some","filter","reduce","segment","test","branch","matchedParams","matchedPathname","end","remainingPathname","matchPath","Object","pathnameBase","normalizePathname","pattern","matcher","compiledParams","regexpSource","_","paramName","RegExp","compilePath","captureGroups","memo","splatValue","v","decodeURIComponent","toLowerCase","startIndex","nextChar","ABSOLUTE_URL_REGEX","resolvePath","fromPathname","toPathname","oldPathname","resolvePathname","substring","normalizeSearch","normalizeHash","pop","getInvalidPathError","char","field","dest","JSON","stringify","getPathContributingMatches","getResolveToMatches","v7_relativeSplatPath","pathMatches","resolveTo","toArg","routePathnames","locationPathname","isPathRelative","from","isEmptyPath","routePathnameIndex","toSegments","shift","hasExplicitTrailingSlash","hasCurrentTrailingSlash","paths","DataWithResponseInit","constructor","init","this","type","AbortedDeferredError","DeferredData","responseInit","reject","pendingKeysSet","subscribers","deferredKeys","Array","isArray","abortPromise","Promise","r","controller","AbortController","onAbort","unlistenAbortSignal","signal","entries","acc","_ref2","trackPromise","done","add","promise","race","then","onSettle","catch","defineProperty","get","aborted","delete","undefinedError","emit","settledKey","subscriber","subscribe","cancel","abort","k","async","resolve","size","unwrappedData","_ref3","unwrapTrackedPromise","pendingKeys","_tracked","isTrackedPromise","_error","_data","defer","redirect","status","headers","Headers","set","Response","ErrorResponseImpl","statusText","internal","isRouteErrorResponse","validMutationMethodsArr","validMutationMethods","validRequestMethodsArr","validRequestMethods","redirectStatusCodes","redirectPreserveMethodStatusCodes","IDLE_NAVIGATION","formMethod","formAction","formEncType","formData","json","text","IDLE_FETCHER","IDLE_BLOCKER","proceed","reset","defaultMapRouteProperties","hasErrorBoundary","Boolean","TRANSITIONS_STORAGE_KEY","UNSAFE_DEFERRED_SYMBOL","Symbol","throwStaticHandlerAbortedError","request","isRouteRequest","future","v7_throwAbortReason","reason","method","normalizeTo","prependBasename","fromRouteId","relative","contextualMatches","activeRouteMatch","nakedIndex","hasNakedIndexQuery","URLSearchParams","indexValues","getAll","append","qs","normalizeNavigateOptions","normalizeFormMethod","isFetcher","opts","body","isSubmissionNavigation","isValidMethod","getInternalRouterError","searchParams","getInvalidBodyError","rawFormMethod","toUpperCase","stripHashFromPath","isMutationMethod","FormData","submission","parse","convertFormDataToSearchParams","convertSearchParamsToFormData","getLoaderMatchesUntilBoundary","boundaryId","includeBoundary","findIndex","m","getMatchesToLoad","initialHydration","skipActionErrorRevalidation","isRevalidationRequired","cancelledDeferredRoutes","cancelledFetcherLoads","deletedFetchers","fetchLoadMatches","fetchRedirectIds","routesToUse","pendingActionResult","actionResult","isErrorResult","currentUrl","nextUrl","boundaryMatches","errors","keys","actionStatus","statusCode","shouldSkipRevalidation","navigationMatches","lazy","loader","shouldLoadRouteOnHydration","currentLoaderData","currentMatch","isNew","isMissingData","isNewLoader","currentRouteMatch","nextRouteMatch","shouldRevalidateLoader","currentParams","nextParams","defaultShouldRevalidate","isNewRouteInstance","revalidatingFetchers","f","routeId","has","fetcherMatches","fetcher","fetchers","fetcherMatch","getTargetMatch","shouldRevalidate","hasData","hasError","hydrate","currentPath","loaderMatch","arg","routeChoice","patchRoutesImpl","_childrenToPatch","childrenToPatch","newRoutes","newRoute","existingRoute","isSameRoute","aChild","_existingRoute$childr","bChild","defaultDataStrategy","_ref4","matchesToLoad","shouldLoad","all","callDataStrategyImpl","dataStrategyImpl","fetcherKey","requestContext","loadRouteDefinitionsPromises","lazyRoute","routeToUpdate","routeUpdates","lazyRouteProperty","isPropertyStaticallyDefined","loadLazyRouteModule","dsMatches","loadRoutePromise","handlerOverride","staticContext","onReject","runHandler","handler","actualHandler","ctx","context","handlerPromise","handlerError","callLoaderOrAction","results","convertDataStrategyResultToDataResult","dataStrategyResult","isResponse","contentType","_result$init3","_result$init4","_result$init","_result$init2","_result$init5","_result$init6","_result$init7","_result$init8","isDataWithResponseInit","isDeferredData","deferred","deferredData","normalizeRelativeRoutingRedirectResponse","response","trimmedMatches","normalizeRedirectLocation","historyInstance","invalidProtocols","normalizedLocation","protocol","isSameBasename","createClientSideRequest","Request","processRouteLoaderData","activeDeferreds","skipLoaderErrorBubbling","foundError","loaderHeaders","pendingError","isRedirectResult","boundaryMatch","findNearestBoundary","isDeferredResult","processLoaderData","fetcherResults","rf","doneFetcher","getDoneFetcher","mergeLoaderData","newLoaderData","mergedLoaderData","hasOwnProperty","getActionDataForCommit","actionData","reverse","find","getShortCircuitMatches","_temp5","errorMessage","findRedirect","isRedirectDataStrategyResultResult","resolveData","resolveNavigationDeferredResults","currentMatches","isRevalidatingLoader","resolveDeferredData","resolveFetcherDeferredResults","unwrap","getSubmissionFromNavigation","navigation","getLoadingNavigation","getSubmittingNavigation","getLoadingFetcher","querySelector","getAttribute","initialEntries","initialIndex","entry","createMemoryLocation","clampIndex","min","max","getCurrentLocation","nextLocation","splice","routerWindow","isBrowser","createElement","isServer","detectErrorBoundary","inFlightDataRoutes","initialized","router","dataRoutes","dataStrategy","patchRoutesOnNavigationImpl","patchRoutesOnNavigation","v7_fetcherPersist","v7_normalizeFormMethod","v7_partialHydration","v7_prependBasename","v7_skipActionErrorRevalidation","unlistenHistory","savedScrollPositions","getScrollRestorationKey","getScrollPosition","initialScrollRestored","hydrationData","initialMatches","initialMatchesIsFOW","initialErrors","checkFogOfWar","active","fogOfWar","pendingNavigationController","unblockBlockerHistoryUpdate","historyAction","restoreScrollPosition","preventScrollReset","revalidation","Map","blockers","pendingAction","HistoryAction","pendingPreventScrollReset","pendingViewTransitionEnabled","appliedViewTransitions","removePageHideEventListener","isUninterruptedRevalidation","fetchControllers","incrementingLoadId","pendingNavigationLoadId","fetchReloadIds","activeFetchers","blockerFunctions","updateState","newState","completedFetchers","deletedFetchersKeys","viewTransitionOpts","flushSync","deleteFetcher","completeNavigation","_temp","_location$state","_location$state2","isActionReload","_isRedirect","priorPaths","currentLocation","toPaths","getSavedScrollPosition","startNavigation","startUninterruptedRevalidation","getScrollKey","saveScrollPosition","enableViewTransition","loadingNavigation","overrideNavigation","isHashChangeOnly","notFoundMatches","handleNavigational404","isFogOfWar","interruptActiveLoads","discoverResult","discoverRoutes","shortCircuited","partialMatches","actionMatch","callDataStrategy","startRedirectNavigation","handleAction","updatedMatches","fetcherSubmission","activeSubmission","shouldUpdateNavigationState","getUpdatedActionData","cancelActiveDeferreds","updatedFetchers","markFetchRedirectsDone","updates","revalidatingFetcher","getUpdatedRevalidatingFetchers","abortFetcher","abortPendingFetchRevalidations","loaderResults","callLoadersAndMaybeResolveData","didAbortFetchLoads","abortStaleFetchLoads","shouldUpdateFetchers","handleLoaders","isNavigation","_temp2","redirectLocation","isDocumentReload","redirectHistoryAction","dataResults","fetchersToLoad","loaderResultsPromise","fetcherResultsPromise","updateFetcherState","setFetcherError","getFetcher","markFetchersDone","doneKeys","landedId","yeetedKeys","deleteBlocker","updateBlocker","newBlocker","blocker","shouldBlockNavigation","blockerKey","blockerFunction","predicate","cancelledRouteIds","dfd","y","isNonHMR","localManifest","patch","newMatches","newPartialMatches","initialize","nextHistoryUpdatePromise","_window","transitions","sessionPositions","sessionStorage","getItem","restoreAppliedTransitions","_saveAppliedTransitions","setItem","persistAppliedTransitions","enableScrollRestoration","positions","getPosition","getKey","navigate","normalizedPath","userReplace","viewTransition","fetch","requestMatches","detectAndHandle405Error","existingFetcher","getSubmittingFetcher","abortController","fetchRequest","originatingLoadId","revalidationRequest","loadId","loadFetcher","staleKey","handleFetcherAction","handleFetcherLoader","revalidate","count","dispose","clear","getBlocker","patchRoutes","_internalFetchControllers","_internalActiveDeferreds","_internalSetRoutes","queryImpl","routeMatch","Location","actionHeaders","loaderRequest","loadRouteData","submit","isDataStrategyResult","isRedirectResponse","executedLoaders","fromEntries","query","_temp3","methodNotAllowedMatches","queryRoute","_temp4","values","_result$activeDeferre","originalPath","prefix","p","array","keyMatch","optional","param","_deepestRenderedBoundaryId","redirectDocument"],"mappings":"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"}
Index: frontend/node_modules/@remix-run/router/dist/utils.d.ts
===================================================================
--- frontend/node_modules/@remix-run/router/dist/utils.d.ts	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/@remix-run/router/dist/utils.d.ts	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,556 @@
+import type { Location, Path, To } from "./history";
+/**
+ * Map of routeId -> data returned from a loader/action/error
+ */
+export interface RouteData {
+    [routeId: string]: any;
+}
+export declare enum ResultType {
+    data = "data",
+    deferred = "deferred",
+    redirect = "redirect",
+    error = "error"
+}
+/**
+ * Successful result from a loader or action
+ */
+export interface SuccessResult {
+    type: ResultType.data;
+    data: unknown;
+    statusCode?: number;
+    headers?: Headers;
+}
+/**
+ * Successful defer() result from a loader or action
+ */
+export interface DeferredResult {
+    type: ResultType.deferred;
+    deferredData: DeferredData;
+    statusCode?: number;
+    headers?: Headers;
+}
+/**
+ * Redirect result from a loader or action
+ */
+export interface RedirectResult {
+    type: ResultType.redirect;
+    response: Response;
+}
+/**
+ * Unsuccessful result from a loader or action
+ */
+export interface ErrorResult {
+    type: ResultType.error;
+    error: unknown;
+    statusCode?: number;
+    headers?: Headers;
+}
+/**
+ * Result from a loader or action - potentially successful or unsuccessful
+ */
+export type DataResult = SuccessResult | DeferredResult | RedirectResult | ErrorResult;
+type LowerCaseFormMethod = "get" | "post" | "put" | "patch" | "delete";
+type UpperCaseFormMethod = Uppercase<LowerCaseFormMethod>;
+/**
+ * Users can specify either lowercase or uppercase form methods on `<Form>`,
+ * useSubmit(), `<fetcher.Form>`, etc.
+ */
+export type HTMLFormMethod = LowerCaseFormMethod | UpperCaseFormMethod;
+/**
+ * Active navigation/fetcher form methods are exposed in lowercase on the
+ * RouterState
+ */
+export type FormMethod = LowerCaseFormMethod;
+export type MutationFormMethod = Exclude<FormMethod, "get">;
+/**
+ * In v7, active navigation/fetcher form methods are exposed in uppercase on the
+ * RouterState.  This is to align with the normalization done via fetch().
+ */
+export type V7_FormMethod = UpperCaseFormMethod;
+export type V7_MutationFormMethod = Exclude<V7_FormMethod, "GET">;
+export type FormEncType = "application/x-www-form-urlencoded" | "multipart/form-data" | "application/json" | "text/plain";
+type JsonObject = {
+    [Key in string]: JsonValue;
+} & {
+    [Key in string]?: JsonValue | undefined;
+};
+type JsonArray = JsonValue[] | readonly JsonValue[];
+type JsonPrimitive = string | number | boolean | null;
+type JsonValue = JsonPrimitive | JsonObject | JsonArray;
+/**
+ * @private
+ * Internal interface to pass around for action submissions, not intended for
+ * external consumption
+ */
+export type Submission = {
+    formMethod: FormMethod | V7_FormMethod;
+    formAction: string;
+    formEncType: FormEncType;
+    formData: FormData;
+    json: undefined;
+    text: undefined;
+} | {
+    formMethod: FormMethod | V7_FormMethod;
+    formAction: string;
+    formEncType: FormEncType;
+    formData: undefined;
+    json: JsonValue;
+    text: undefined;
+} | {
+    formMethod: FormMethod | V7_FormMethod;
+    formAction: string;
+    formEncType: FormEncType;
+    formData: undefined;
+    json: undefined;
+    text: string;
+};
+/**
+ * @private
+ * Arguments passed to route loader/action functions.  Same for now but we keep
+ * this as a private implementation detail in case they diverge in the future.
+ */
+interface DataFunctionArgs<Context> {
+    request: Request;
+    params: Params;
+    context?: Context;
+}
+/**
+ * Arguments passed to loader functions
+ */
+export interface LoaderFunctionArgs<Context = any> extends DataFunctionArgs<Context> {
+}
+/**
+ * Arguments passed to action functions
+ */
+export interface ActionFunctionArgs<Context = any> extends DataFunctionArgs<Context> {
+}
+/**
+ * Loaders and actions can return anything except `undefined` (`null` is a
+ * valid return value if there is no data to return).  Responses are preferred
+ * and will ease any future migration to Remix
+ */
+type DataFunctionValue = Response | NonNullable<unknown> | null;
+type DataFunctionReturnValue = Promise<DataFunctionValue> | DataFunctionValue;
+/**
+ * Route loader function signature
+ */
+export type LoaderFunction<Context = any> = {
+    (args: LoaderFunctionArgs<Context>, handlerCtx?: unknown): DataFunctionReturnValue;
+} & {
+    hydrate?: boolean;
+};
+/**
+ * Route action function signature
+ */
+export interface ActionFunction<Context = any> {
+    (args: ActionFunctionArgs<Context>, handlerCtx?: unknown): DataFunctionReturnValue;
+}
+/**
+ * Arguments passed to shouldRevalidate function
+ */
+export interface ShouldRevalidateFunctionArgs {
+    currentUrl: URL;
+    currentParams: AgnosticDataRouteMatch["params"];
+    nextUrl: URL;
+    nextParams: AgnosticDataRouteMatch["params"];
+    formMethod?: Submission["formMethod"];
+    formAction?: Submission["formAction"];
+    formEncType?: Submission["formEncType"];
+    text?: Submission["text"];
+    formData?: Submission["formData"];
+    json?: Submission["json"];
+    actionStatus?: number;
+    actionResult?: any;
+    defaultShouldRevalidate: boolean;
+}
+/**
+ * Route shouldRevalidate function signature.  This runs after any submission
+ * (navigation or fetcher), so we flatten the navigation/fetcher submission
+ * onto the arguments.  It shouldn't matter whether it came from a navigation
+ * or a fetcher, what really matters is the URLs and the formData since loaders
+ * have to re-run based on the data models that were potentially mutated.
+ */
+export interface ShouldRevalidateFunction {
+    (args: ShouldRevalidateFunctionArgs): boolean;
+}
+/**
+ * Function provided by the framework-aware layers to set `hasErrorBoundary`
+ * from the framework-aware `errorElement` prop
+ *
+ * @deprecated Use `mapRouteProperties` instead
+ */
+export interface DetectErrorBoundaryFunction {
+    (route: AgnosticRouteObject): boolean;
+}
+export interface DataStrategyMatch extends AgnosticRouteMatch<string, AgnosticDataRouteObject> {
+    shouldLoad: boolean;
+    resolve: (handlerOverride?: (handler: (ctx?: unknown) => DataFunctionReturnValue) => DataFunctionReturnValue) => Promise<DataStrategyResult>;
+}
+export interface DataStrategyFunctionArgs<Context = any> extends DataFunctionArgs<Context> {
+    matches: DataStrategyMatch[];
+    fetcherKey: string | null;
+}
+/**
+ * Result from a loader or action called via dataStrategy
+ */
+export interface DataStrategyResult {
+    type: "data" | "error";
+    result: unknown;
+}
+export interface DataStrategyFunction {
+    (args: DataStrategyFunctionArgs): Promise<Record<string, DataStrategyResult>>;
+}
+export type AgnosticPatchRoutesOnNavigationFunctionArgs<O extends AgnosticRouteObject = AgnosticRouteObject, M extends AgnosticRouteMatch = AgnosticRouteMatch> = {
+    signal: AbortSignal;
+    path: string;
+    matches: M[];
+    fetcherKey: string | undefined;
+    patch: (routeId: string | null, children: O[]) => void;
+};
+export type AgnosticPatchRoutesOnNavigationFunction<O extends AgnosticRouteObject = AgnosticRouteObject, M extends AgnosticRouteMatch = AgnosticRouteMatch> = (opts: AgnosticPatchRoutesOnNavigationFunctionArgs<O, M>) => void | Promise<void>;
+/**
+ * Function provided by the framework-aware layers to set any framework-specific
+ * properties from framework-agnostic properties
+ */
+export interface MapRoutePropertiesFunction {
+    (route: AgnosticRouteObject): {
+        hasErrorBoundary: boolean;
+    } & Record<string, any>;
+}
+/**
+ * Keys we cannot change from within a lazy() function. We spread all other keys
+ * onto the route. Either they're meaningful to the router, or they'll get
+ * ignored.
+ */
+export type ImmutableRouteKey = "lazy" | "caseSensitive" | "path" | "id" | "index" | "children";
+export declare const immutableRouteKeys: Set<ImmutableRouteKey>;
+type RequireOne<T, Key = keyof T> = Exclude<{
+    [K in keyof T]: K extends Key ? Omit<T, K> & Required<Pick<T, K>> : never;
+}[keyof T], undefined>;
+/**
+ * lazy() function to load a route definition, which can add non-matching
+ * related properties to a route
+ */
+export interface LazyRouteFunction<R extends AgnosticRouteObject> {
+    (): Promise<RequireOne<Omit<R, ImmutableRouteKey>>>;
+}
+/**
+ * Base RouteObject with common props shared by all types of routes
+ */
+type AgnosticBaseRouteObject = {
+    caseSensitive?: boolean;
+    path?: string;
+    id?: string;
+    loader?: LoaderFunction | boolean;
+    action?: ActionFunction | boolean;
+    hasErrorBoundary?: boolean;
+    shouldRevalidate?: ShouldRevalidateFunction;
+    handle?: any;
+    lazy?: LazyRouteFunction<AgnosticBaseRouteObject>;
+};
+/**
+ * Index routes must not have children
+ */
+export type AgnosticIndexRouteObject = AgnosticBaseRouteObject & {
+    children?: undefined;
+    index: true;
+};
+/**
+ * Non-index routes may have children, but cannot have index
+ */
+export type AgnosticNonIndexRouteObject = AgnosticBaseRouteObject & {
+    children?: AgnosticRouteObject[];
+    index?: false;
+};
+/**
+ * A route object represents a logical route, with (optionally) its child
+ * routes organized in a tree-like structure.
+ */
+export type AgnosticRouteObject = AgnosticIndexRouteObject | AgnosticNonIndexRouteObject;
+export type AgnosticDataIndexRouteObject = AgnosticIndexRouteObject & {
+    id: string;
+};
+export type AgnosticDataNonIndexRouteObject = AgnosticNonIndexRouteObject & {
+    children?: AgnosticDataRouteObject[];
+    id: string;
+};
+/**
+ * A data route object, which is just a RouteObject with a required unique ID
+ */
+export type AgnosticDataRouteObject = AgnosticDataIndexRouteObject | AgnosticDataNonIndexRouteObject;
+export type RouteManifest = Record<string, AgnosticDataRouteObject | undefined>;
+type _PathParam<Path extends string> = Path extends `${infer L}/${infer R}` ? _PathParam<L> | _PathParam<R> : Path extends `:${infer Param}` ? Param extends `${infer Optional}?` ? Optional : Param : never;
+/**
+ * Examples:
+ * "/a/b/*" -> "*"
+ * ":a" -> "a"
+ * "/a/:b" -> "b"
+ * "/a/blahblahblah:b" -> "b"
+ * "/:a/:b" -> "a" | "b"
+ * "/:a/b/:c/*" -> "a" | "c" | "*"
+ */
+export type PathParam<Path extends string> = Path extends "*" | "/*" ? "*" : Path extends `${infer Rest}/*` ? "*" | _PathParam<Rest> : _PathParam<Path>;
+export type ParamParseKey<Segment extends string> = [
+    PathParam<Segment>
+] extends [never] ? string : PathParam<Segment>;
+/**
+ * The parameters that were parsed from the URL path.
+ */
+export type Params<Key extends string = string> = {
+    readonly [key in Key]: string | undefined;
+};
+/**
+ * A RouteMatch contains info about how a route matched a URL.
+ */
+export interface AgnosticRouteMatch<ParamKey extends string = string, RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject> {
+    /**
+     * The names and values of dynamic parameters in the URL.
+     */
+    params: Params<ParamKey>;
+    /**
+     * The portion of the URL pathname that was matched.
+     */
+    pathname: string;
+    /**
+     * The portion of the URL pathname that was matched before child routes.
+     */
+    pathnameBase: string;
+    /**
+     * The route object that was used to match.
+     */
+    route: RouteObjectType;
+}
+export interface AgnosticDataRouteMatch extends AgnosticRouteMatch<string, AgnosticDataRouteObject> {
+}
+export declare function convertRoutesToDataRoutes(routes: AgnosticRouteObject[], mapRouteProperties: MapRoutePropertiesFunction, parentPath?: string[], manifest?: RouteManifest): AgnosticDataRouteObject[];
+/**
+ * Matches the given routes to a location and returns the match data.
+ *
+ * @see https://reactrouter.com/v6/utils/match-routes
+ */
+export declare function matchRoutes<RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject>(routes: RouteObjectType[], locationArg: Partial<Location> | string, basename?: string): AgnosticRouteMatch<string, RouteObjectType>[] | null;
+export declare function matchRoutesImpl<RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject>(routes: RouteObjectType[], locationArg: Partial<Location> | string, basename: string, allowPartial: boolean): AgnosticRouteMatch<string, RouteObjectType>[] | null;
+export interface UIMatch<Data = unknown, Handle = unknown> {
+    id: string;
+    pathname: string;
+    params: AgnosticRouteMatch["params"];
+    data: Data;
+    handle: Handle;
+}
+export declare function convertRouteMatchToUiMatch(match: AgnosticDataRouteMatch, loaderData: RouteData): UIMatch;
+/**
+ * Returns a path with params interpolated.
+ *
+ * @see https://reactrouter.com/v6/utils/generate-path
+ */
+export declare function generatePath<Path extends string>(originalPath: Path, params?: {
+    [key in PathParam<Path>]: string | null;
+}): string;
+/**
+ * A PathPattern is used to match on some portion of a URL pathname.
+ */
+export interface PathPattern<Path extends string = string> {
+    /**
+     * A string to match against a URL pathname. May contain `:id`-style segments
+     * to indicate placeholders for dynamic parameters. May also end with `/*` to
+     * indicate matching the rest of the URL pathname.
+     */
+    path: Path;
+    /**
+     * Should be `true` if the static portions of the `path` should be matched in
+     * the same case.
+     */
+    caseSensitive?: boolean;
+    /**
+     * Should be `true` if this pattern should match the entire URL pathname.
+     */
+    end?: boolean;
+}
+/**
+ * A PathMatch contains info about how a PathPattern matched on a URL pathname.
+ */
+export interface PathMatch<ParamKey extends string = string> {
+    /**
+     * The names and values of dynamic parameters in the URL.
+     */
+    params: Params<ParamKey>;
+    /**
+     * The portion of the URL pathname that was matched.
+     */
+    pathname: string;
+    /**
+     * The portion of the URL pathname that was matched before child routes.
+     */
+    pathnameBase: string;
+    /**
+     * The pattern that was used to match.
+     */
+    pattern: PathPattern;
+}
+/**
+ * Performs pattern matching on a URL pathname and returns information about
+ * the match.
+ *
+ * @see https://reactrouter.com/v6/utils/match-path
+ */
+export declare function matchPath<ParamKey extends ParamParseKey<Path>, Path extends string>(pattern: PathPattern<Path> | Path, pathname: string): PathMatch<ParamKey> | null;
+export declare function decodePath(value: string): string;
+/**
+ * @private
+ */
+export declare function stripBasename(pathname: string, basename: string): string | null;
+export declare const isAbsoluteUrl: (url: string) => boolean;
+/**
+ * Returns a resolved path object relative to the given pathname.
+ *
+ * @see https://reactrouter.com/v6/utils/resolve-path
+ */
+export declare function resolvePath(to: To, fromPathname?: string): Path;
+/**
+ * @private
+ *
+ * When processing relative navigation we want to ignore ancestor routes that
+ * do not contribute to the path, such that index/pathless layout routes don't
+ * interfere.
+ *
+ * For example, when moving a route element into an index route and/or a
+ * pathless layout route, relative link behavior contained within should stay
+ * the same.  Both of the following examples should link back to the root:
+ *
+ *   <Route path="/">
+ *     <Route path="accounts" element={<Link to=".."}>
+ *   </Route>
+ *
+ *   <Route path="/">
+ *     <Route path="accounts">
+ *       <Route element={<AccountsLayout />}>       // <-- Does not contribute
+ *         <Route index element={<Link to=".."} />  // <-- Does not contribute
+ *       </Route
+ *     </Route>
+ *   </Route>
+ */
+export declare function getPathContributingMatches<T extends AgnosticRouteMatch = AgnosticRouteMatch>(matches: T[]): T[];
+export declare function getResolveToMatches<T extends AgnosticRouteMatch = AgnosticRouteMatch>(matches: T[], v7_relativeSplatPath: boolean): string[];
+/**
+ * @private
+ */
+export declare function resolveTo(toArg: To, routePathnames: string[], locationPathname: string, isPathRelative?: boolean): Path;
+/**
+ * @private
+ */
+export declare function getToPathname(to: To): string | undefined;
+/**
+ * @private
+ */
+export declare const joinPaths: (paths: string[]) => string;
+/**
+ * @private
+ */
+export declare const normalizePathname: (pathname: string) => string;
+/**
+ * @private
+ */
+export declare const normalizeSearch: (search: string) => string;
+/**
+ * @private
+ */
+export declare const normalizeHash: (hash: string) => string;
+export type JsonFunction = <Data>(data: Data, init?: number | ResponseInit) => Response;
+/**
+ * This is a shortcut for creating `application/json` responses. Converts `data`
+ * to JSON and sets the `Content-Type` header.
+ *
+ * @deprecated The `json` method is deprecated in favor of returning raw objects.
+ * This method will be removed in v7.
+ */
+export declare const json: JsonFunction;
+export declare class DataWithResponseInit<D> {
+    type: string;
+    data: D;
+    init: ResponseInit | null;
+    constructor(data: D, init?: ResponseInit);
+}
+/**
+ * Create "responses" that contain `status`/`headers` without forcing
+ * serialization into an actual `Response` - used by Remix single fetch
+ */
+export declare function data<D>(data: D, init?: number | ResponseInit): DataWithResponseInit<D>;
+export interface TrackedPromise extends Promise<any> {
+    _tracked?: boolean;
+    _data?: any;
+    _error?: any;
+}
+export declare class AbortedDeferredError extends Error {
+}
+export declare class DeferredData {
+    private pendingKeysSet;
+    private controller;
+    private abortPromise;
+    private unlistenAbortSignal;
+    private subscribers;
+    data: Record<string, unknown>;
+    init?: ResponseInit;
+    deferredKeys: string[];
+    constructor(data: Record<string, unknown>, responseInit?: ResponseInit);
+    private trackPromise;
+    private onSettle;
+    private emit;
+    subscribe(fn: (aborted: boolean, settledKey?: string) => void): () => boolean;
+    cancel(): void;
+    resolveData(signal: AbortSignal): Promise<boolean>;
+    get done(): boolean;
+    get unwrappedData(): {};
+    get pendingKeys(): string[];
+}
+export type DeferFunction = (data: Record<string, unknown>, init?: number | ResponseInit) => DeferredData;
+/**
+ * @deprecated The `defer` method is deprecated in favor of returning raw
+ * objects. This method will be removed in v7.
+ */
+export declare const defer: DeferFunction;
+export type RedirectFunction = (url: string, init?: number | ResponseInit) => Response;
+/**
+ * A redirect response. Sets the status code and the `Location` header.
+ * Defaults to "302 Found".
+ */
+export declare const redirect: RedirectFunction;
+/**
+ * A redirect response that will force a document reload to the new location.
+ * Sets the status code and the `Location` header.
+ * Defaults to "302 Found".
+ */
+export declare const redirectDocument: RedirectFunction;
+/**
+ * A redirect response that will perform a `history.replaceState` instead of a
+ * `history.pushState` for client-side navigation redirects.
+ * Sets the status code and the `Location` header.
+ * Defaults to "302 Found".
+ */
+export declare const replace: RedirectFunction;
+export type ErrorResponse = {
+    status: number;
+    statusText: string;
+    data: any;
+};
+/**
+ * @private
+ * Utility class we use to hold auto-unwrapped 4xx/5xx Response bodies
+ *
+ * We don't export the class for public use since it's an implementation
+ * detail, but we export the interface above so folks can build their own
+ * abstractions around instances via isRouteErrorResponse()
+ */
+export declare class ErrorResponseImpl implements ErrorResponse {
+    status: number;
+    statusText: string;
+    data: any;
+    private error?;
+    private internal;
+    constructor(status: number, statusText: string | undefined, data: any, internal?: boolean);
+}
+/**
+ * Check if the given error is an ErrorResponse generated from a 4xx/5xx
+ * Response thrown from an action/loader
+ */
+export declare function isRouteErrorResponse(error: any): error is ErrorResponse;
+export {};
Index: frontend/node_modules/@remix-run/router/history.ts
===================================================================
--- frontend/node_modules/@remix-run/router/history.ts	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/@remix-run/router/history.ts	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,746 @@
+////////////////////////////////////////////////////////////////////////////////
+//#region Types and Constants
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Actions represent the type of change to a location value.
+ */
+export enum Action {
+  /**
+   * A POP indicates a change to an arbitrary index in the history stack, such
+   * as a back or forward navigation. It does not describe the direction of the
+   * navigation, only that the current index changed.
+   *
+   * Note: This is the default action for newly created history objects.
+   */
+  Pop = "POP",
+
+  /**
+   * A PUSH indicates a new entry being added to the history stack, such as when
+   * a link is clicked and a new page loads. When this happens, all subsequent
+   * entries in the stack are lost.
+   */
+  Push = "PUSH",
+
+  /**
+   * A REPLACE indicates the entry at the current index in the history stack
+   * being replaced by a new one.
+   */
+  Replace = "REPLACE",
+}
+
+/**
+ * The pathname, search, and hash values of a URL.
+ */
+export interface Path {
+  /**
+   * A URL pathname, beginning with a /.
+   */
+  pathname: string;
+
+  /**
+   * A URL search string, beginning with a ?.
+   */
+  search: string;
+
+  /**
+   * A URL fragment identifier, beginning with a #.
+   */
+  hash: string;
+}
+
+// TODO: (v7) Change the Location generic default from `any` to `unknown` and
+// remove Remix `useLocation` wrapper.
+
+/**
+ * An entry in a history stack. A location contains information about the
+ * URL path, as well as possibly some arbitrary state and a key.
+ */
+export interface Location<State = any> extends Path {
+  /**
+   * A value of arbitrary data associated with this location.
+   */
+  state: State;
+
+  /**
+   * A unique string associated with this location. May be used to safely store
+   * and retrieve data in some other storage API, like `localStorage`.
+   *
+   * Note: This value is always "default" on the initial location.
+   */
+  key: string;
+}
+
+/**
+ * A change to the current location.
+ */
+export interface Update {
+  /**
+   * The action that triggered the change.
+   */
+  action: Action;
+
+  /**
+   * The new location.
+   */
+  location: Location;
+
+  /**
+   * The delta between this location and the former location in the history stack
+   */
+  delta: number | null;
+}
+
+/**
+ * A function that receives notifications about location changes.
+ */
+export interface Listener {
+  (update: Update): void;
+}
+
+/**
+ * Describes a location that is the destination of some navigation, either via
+ * `history.push` or `history.replace`. This may be either a URL or the pieces
+ * of a URL path.
+ */
+export type To = string | Partial<Path>;
+
+/**
+ * A history is an interface to the navigation stack. The history serves as the
+ * source of truth for the current location, as well as provides a set of
+ * methods that may be used to change it.
+ *
+ * It is similar to the DOM's `window.history` object, but with a smaller, more
+ * focused API.
+ */
+export interface History {
+  /**
+   * The last action that modified the current location. This will always be
+   * Action.Pop when a history instance is first created. This value is mutable.
+   */
+  readonly action: Action;
+
+  /**
+   * The current location. This value is mutable.
+   */
+  readonly location: Location;
+
+  /**
+   * Returns a valid href for the given `to` value that may be used as
+   * the value of an <a href> attribute.
+   *
+   * @param to - The destination URL
+   */
+  createHref(to: To): string;
+
+  /**
+   * Returns a URL for the given `to` value
+   *
+   * @param to - The destination URL
+   */
+  createURL(to: To): URL;
+
+  /**
+   * Encode a location the same way window.history would do (no-op for memory
+   * history) so we ensure our PUSH/REPLACE navigations for data routers
+   * behave the same as POP
+   *
+   * @param to Unencoded path
+   */
+  encodeLocation(to: To): Path;
+
+  /**
+   * Pushes a new location onto the history stack, increasing its length by one.
+   * If there were any entries in the stack after the current one, they are
+   * lost.
+   *
+   * @param to - The new URL
+   * @param state - Data to associate with the new location
+   */
+  push(to: To, state?: any): void;
+
+  /**
+   * Replaces the current location in the history stack with a new one.  The
+   * location that was replaced will no longer be available.
+   *
+   * @param to - The new URL
+   * @param state - Data to associate with the new location
+   */
+  replace(to: To, state?: any): void;
+
+  /**
+   * Navigates `n` entries backward/forward in the history stack relative to the
+   * current index. For example, a "back" navigation would use go(-1).
+   *
+   * @param delta - The delta in the stack index
+   */
+  go(delta: number): void;
+
+  /**
+   * Sets up a listener that will be called whenever the current location
+   * changes.
+   *
+   * @param listener - A function that will be called when the location changes
+   * @returns unlisten - A function that may be used to stop listening
+   */
+  listen(listener: Listener): () => void;
+}
+
+type HistoryState = {
+  usr: any;
+  key?: string;
+  idx: number;
+};
+
+const PopStateEventType = "popstate";
+//#endregion
+
+////////////////////////////////////////////////////////////////////////////////
+//#region Memory History
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * A user-supplied object that describes a location. Used when providing
+ * entries to `createMemoryHistory` via its `initialEntries` option.
+ */
+export type InitialEntry = string | Partial<Location>;
+
+export type MemoryHistoryOptions = {
+  initialEntries?: InitialEntry[];
+  initialIndex?: number;
+  v5Compat?: boolean;
+};
+
+/**
+ * A memory history stores locations in memory. This is useful in stateful
+ * environments where there is no web browser, such as node tests or React
+ * Native.
+ */
+export interface MemoryHistory extends History {
+  /**
+   * The current index in the history stack.
+   */
+  readonly index: number;
+}
+
+/**
+ * Memory history stores the current location in memory. It is designed for use
+ * in stateful non-browser environments like tests and React Native.
+ */
+export function createMemoryHistory(
+  options: MemoryHistoryOptions = {}
+): MemoryHistory {
+  let { initialEntries = ["/"], initialIndex, v5Compat = false } = options;
+  let entries: Location[]; // Declare so we can access from createMemoryLocation
+  entries = initialEntries.map((entry, index) =>
+    createMemoryLocation(
+      entry,
+      typeof entry === "string" ? null : entry.state,
+      index === 0 ? "default" : undefined
+    )
+  );
+  let index = clampIndex(
+    initialIndex == null ? entries.length - 1 : initialIndex
+  );
+  let action = Action.Pop;
+  let listener: Listener | null = null;
+
+  function clampIndex(n: number): number {
+    return Math.min(Math.max(n, 0), entries.length - 1);
+  }
+  function getCurrentLocation(): Location {
+    return entries[index];
+  }
+  function createMemoryLocation(
+    to: To,
+    state: any = null,
+    key?: string
+  ): Location {
+    let location = createLocation(
+      entries ? getCurrentLocation().pathname : "/",
+      to,
+      state,
+      key
+    );
+    warning(
+      location.pathname.charAt(0) === "/",
+      `relative pathnames are not supported in memory history: ${JSON.stringify(
+        to
+      )}`
+    );
+    return location;
+  }
+
+  function createHref(to: To) {
+    return typeof to === "string" ? to : createPath(to);
+  }
+
+  let history: MemoryHistory = {
+    get index() {
+      return index;
+    },
+    get action() {
+      return action;
+    },
+    get location() {
+      return getCurrentLocation();
+    },
+    createHref,
+    createURL(to) {
+      return new URL(createHref(to), "http://localhost");
+    },
+    encodeLocation(to: To) {
+      let path = typeof to === "string" ? parsePath(to) : to;
+      return {
+        pathname: path.pathname || "",
+        search: path.search || "",
+        hash: path.hash || "",
+      };
+    },
+    push(to, state) {
+      action = Action.Push;
+      let nextLocation = createMemoryLocation(to, state);
+      index += 1;
+      entries.splice(index, entries.length, nextLocation);
+      if (v5Compat && listener) {
+        listener({ action, location: nextLocation, delta: 1 });
+      }
+    },
+    replace(to, state) {
+      action = Action.Replace;
+      let nextLocation = createMemoryLocation(to, state);
+      entries[index] = nextLocation;
+      if (v5Compat && listener) {
+        listener({ action, location: nextLocation, delta: 0 });
+      }
+    },
+    go(delta) {
+      action = Action.Pop;
+      let nextIndex = clampIndex(index + delta);
+      let nextLocation = entries[nextIndex];
+      index = nextIndex;
+      if (listener) {
+        listener({ action, location: nextLocation, delta });
+      }
+    },
+    listen(fn: Listener) {
+      listener = fn;
+      return () => {
+        listener = null;
+      };
+    },
+  };
+
+  return history;
+}
+//#endregion
+
+////////////////////////////////////////////////////////////////////////////////
+//#region Browser History
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * A browser history stores the current location in regular URLs in a web
+ * browser environment. This is the standard for most web apps and provides the
+ * cleanest URLs the browser's address bar.
+ *
+ * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#browserhistory
+ */
+export interface BrowserHistory extends UrlHistory {}
+
+export type BrowserHistoryOptions = UrlHistoryOptions;
+
+/**
+ * Browser history stores the location in regular URLs. This is the standard for
+ * most web apps, but it requires some configuration on the server to ensure you
+ * serve the same app at multiple URLs.
+ *
+ * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createbrowserhistory
+ */
+export function createBrowserHistory(
+  options: BrowserHistoryOptions = {}
+): BrowserHistory {
+  function createBrowserLocation(
+    window: Window,
+    globalHistory: Window["history"]
+  ) {
+    let { pathname, search, hash } = window.location;
+    return createLocation(
+      "",
+      { pathname, search, hash },
+      // state defaults to `null` because `window.history.state` does
+      (globalHistory.state && globalHistory.state.usr) || null,
+      (globalHistory.state && globalHistory.state.key) || "default"
+    );
+  }
+
+  function createBrowserHref(window: Window, to: To) {
+    return typeof to === "string" ? to : createPath(to);
+  }
+
+  return getUrlBasedHistory(
+    createBrowserLocation,
+    createBrowserHref,
+    null,
+    options
+  );
+}
+//#endregion
+
+////////////////////////////////////////////////////////////////////////////////
+//#region Hash History
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * A hash history stores the current location in the fragment identifier portion
+ * of the URL in a web browser environment.
+ *
+ * This is ideal for apps that do not control the server for some reason
+ * (because the fragment identifier is never sent to the server), including some
+ * shared hosting environments that do not provide fine-grained controls over
+ * which pages are served at which URLs.
+ *
+ * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#hashhistory
+ */
+export interface HashHistory extends UrlHistory {}
+
+export type HashHistoryOptions = UrlHistoryOptions;
+
+/**
+ * Hash history stores the location in window.location.hash. This makes it ideal
+ * for situations where you don't want to send the location to the server for
+ * some reason, either because you do cannot configure it or the URL space is
+ * reserved for something else.
+ *
+ * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createhashhistory
+ */
+export function createHashHistory(
+  options: HashHistoryOptions = {}
+): HashHistory {
+  function createHashLocation(
+    window: Window,
+    globalHistory: Window["history"]
+  ) {
+    let {
+      pathname = "/",
+      search = "",
+      hash = "",
+    } = parsePath(window.location.hash.substr(1));
+
+    // Hash URL should always have a leading / just like window.location.pathname
+    // does, so if an app ends up at a route like /#something then we add a
+    // leading slash so all of our path-matching behaves the same as if it would
+    // in a browser router.  This is particularly important when there exists a
+    // root splat route (<Route path="*">) since that matches internally against
+    // "/*" and we'd expect /#something to 404 in a hash router app.
+    if (!pathname.startsWith("/") && !pathname.startsWith(".")) {
+      pathname = "/" + pathname;
+    }
+
+    return createLocation(
+      "",
+      { pathname, search, hash },
+      // state defaults to `null` because `window.history.state` does
+      (globalHistory.state && globalHistory.state.usr) || null,
+      (globalHistory.state && globalHistory.state.key) || "default"
+    );
+  }
+
+  function createHashHref(window: Window, to: To) {
+    let base = window.document.querySelector("base");
+    let href = "";
+
+    if (base && base.getAttribute("href")) {
+      let url = window.location.href;
+      let hashIndex = url.indexOf("#");
+      href = hashIndex === -1 ? url : url.slice(0, hashIndex);
+    }
+
+    return href + "#" + (typeof to === "string" ? to : createPath(to));
+  }
+
+  function validateHashLocation(location: Location, to: To) {
+    warning(
+      location.pathname.charAt(0) === "/",
+      `relative pathnames are not supported in hash history.push(${JSON.stringify(
+        to
+      )})`
+    );
+  }
+
+  return getUrlBasedHistory(
+    createHashLocation,
+    createHashHref,
+    validateHashLocation,
+    options
+  );
+}
+//#endregion
+
+////////////////////////////////////////////////////////////////////////////////
+//#region UTILS
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * @private
+ */
+export function invariant(value: boolean, message?: string): asserts value;
+export function invariant<T>(
+  value: T | null | undefined,
+  message?: string
+): asserts value is T;
+export function invariant(value: any, message?: string) {
+  if (value === false || value === null || typeof value === "undefined") {
+    throw new Error(message);
+  }
+}
+
+export function warning(cond: any, message: string) {
+  if (!cond) {
+    // eslint-disable-next-line no-console
+    if (typeof console !== "undefined") console.warn(message);
+
+    try {
+      // Welcome to debugging history!
+      //
+      // This error is thrown as a convenience, so you can more easily
+      // find the source for a warning that appears in the console by
+      // enabling "pause on exceptions" in your JavaScript debugger.
+      throw new Error(message);
+      // eslint-disable-next-line no-empty
+    } catch (e) {}
+  }
+}
+
+function createKey() {
+  return Math.random().toString(36).substr(2, 8);
+}
+
+/**
+ * For browser-based histories, we combine the state and key into an object
+ */
+function getHistoryState(location: Location, index: number): HistoryState {
+  return {
+    usr: location.state,
+    key: location.key,
+    idx: index,
+  };
+}
+
+/**
+ * Creates a Location object with a unique key from the given Path
+ */
+export function createLocation(
+  current: string | Location,
+  to: To,
+  state: any = null,
+  key?: string
+): Readonly<Location> {
+  let location: Readonly<Location> = {
+    pathname: typeof current === "string" ? current : current.pathname,
+    search: "",
+    hash: "",
+    ...(typeof to === "string" ? parsePath(to) : to),
+    state,
+    // TODO: This could be cleaned up.  push/replace should probably just take
+    // full Locations now and avoid the need to run through this flow at all
+    // But that's a pretty big refactor to the current test suite so going to
+    // keep as is for the time being and just let any incoming keys take precedence
+    key: (to && (to as Location).key) || key || createKey(),
+  };
+  return location;
+}
+
+/**
+ * Creates a string URL path from the given pathname, search, and hash components.
+ */
+export function createPath({
+  pathname = "/",
+  search = "",
+  hash = "",
+}: Partial<Path>) {
+  if (search && search !== "?")
+    pathname += search.charAt(0) === "?" ? search : "?" + search;
+  if (hash && hash !== "#")
+    pathname += hash.charAt(0) === "#" ? hash : "#" + hash;
+  return pathname;
+}
+
+/**
+ * Parses a string URL path into its separate pathname, search, and hash components.
+ */
+export function parsePath(path: string): Partial<Path> {
+  let parsedPath: Partial<Path> = {};
+
+  if (path) {
+    let hashIndex = path.indexOf("#");
+    if (hashIndex >= 0) {
+      parsedPath.hash = path.substr(hashIndex);
+      path = path.substr(0, hashIndex);
+    }
+
+    let searchIndex = path.indexOf("?");
+    if (searchIndex >= 0) {
+      parsedPath.search = path.substr(searchIndex);
+      path = path.substr(0, searchIndex);
+    }
+
+    if (path) {
+      parsedPath.pathname = path;
+    }
+  }
+
+  return parsedPath;
+}
+
+export interface UrlHistory extends History {}
+
+export type UrlHistoryOptions = {
+  window?: Window;
+  v5Compat?: boolean;
+};
+
+function getUrlBasedHistory(
+  getLocation: (window: Window, globalHistory: Window["history"]) => Location,
+  createHref: (window: Window, to: To) => string,
+  validateLocation: ((location: Location, to: To) => void) | null,
+  options: UrlHistoryOptions = {}
+): UrlHistory {
+  let { window = document.defaultView!, v5Compat = false } = options;
+  let globalHistory = window.history;
+  let action = Action.Pop;
+  let listener: Listener | null = null;
+
+  let index = getIndex()!;
+  // Index should only be null when we initialize. If not, it's because the
+  // user called history.pushState or history.replaceState directly, in which
+  // case we should log a warning as it will result in bugs.
+  if (index == null) {
+    index = 0;
+    globalHistory.replaceState({ ...globalHistory.state, idx: index }, "");
+  }
+
+  function getIndex(): number {
+    let state = globalHistory.state || { idx: null };
+    return state.idx;
+  }
+
+  function handlePop() {
+    action = Action.Pop;
+    let nextIndex = getIndex();
+    let delta = nextIndex == null ? null : nextIndex - index;
+    index = nextIndex;
+    if (listener) {
+      listener({ action, location: history.location, delta });
+    }
+  }
+
+  function push(to: To, state?: any) {
+    action = Action.Push;
+    let location = createLocation(history.location, to, state);
+    if (validateLocation) validateLocation(location, to);
+
+    index = getIndex() + 1;
+    let historyState = getHistoryState(location, index);
+    let url = history.createHref(location);
+
+    // try...catch because iOS limits us to 100 pushState calls :/
+    try {
+      globalHistory.pushState(historyState, "", url);
+    } catch (error) {
+      // If the exception is because `state` can't be serialized, let that throw
+      // outwards just like a replace call would so the dev knows the cause
+      // https://html.spec.whatwg.org/multipage/nav-history-apis.html#shared-history-push/replace-state-steps
+      // https://html.spec.whatwg.org/multipage/structured-data.html#structuredserializeinternal
+      if (error instanceof DOMException && error.name === "DataCloneError") {
+        throw error;
+      }
+      // They are going to lose state here, but there is no real
+      // way to warn them about it since the page will refresh...
+      window.location.assign(url);
+    }
+
+    if (v5Compat && listener) {
+      listener({ action, location: history.location, delta: 1 });
+    }
+  }
+
+  function replace(to: To, state?: any) {
+    action = Action.Replace;
+    let location = createLocation(history.location, to, state);
+    if (validateLocation) validateLocation(location, to);
+
+    index = getIndex();
+    let historyState = getHistoryState(location, index);
+    let url = history.createHref(location);
+    globalHistory.replaceState(historyState, "", url);
+
+    if (v5Compat && listener) {
+      listener({ action, location: history.location, delta: 0 });
+    }
+  }
+
+  function createURL(to: To): URL {
+    // window.location.origin is "null" (the literal string value) in Firefox
+    // under certain conditions, notably when serving from a local HTML file
+    // See https://bugzilla.mozilla.org/show_bug.cgi?id=878297
+    let base =
+      window.location.origin !== "null"
+        ? window.location.origin
+        : window.location.href;
+
+    let href = typeof to === "string" ? to : createPath(to);
+    // Treating this as a full URL will strip any trailing spaces so we need to
+    // pre-encode them since they might be part of a matching splat param from
+    // an ancestor route
+    href = href.replace(/ $/, "%20");
+    invariant(
+      base,
+      `No window.location.(origin|href) available to create URL for href: ${href}`
+    );
+    return new URL(href, base);
+  }
+
+  let history: History = {
+    get action() {
+      return action;
+    },
+    get location() {
+      return getLocation(window, globalHistory);
+    },
+    listen(fn: Listener) {
+      if (listener) {
+        throw new Error("A history only accepts one active listener");
+      }
+      window.addEventListener(PopStateEventType, handlePop);
+      listener = fn;
+
+      return () => {
+        window.removeEventListener(PopStateEventType, handlePop);
+        listener = null;
+      };
+    },
+    createHref(to) {
+      return createHref(window, to);
+    },
+    createURL,
+    encodeLocation(to) {
+      // Encode a Location the same way window.location would
+      let url = createURL(to);
+      return {
+        pathname: url.pathname,
+        search: url.search,
+        hash: url.hash,
+      };
+    },
+    push,
+    replace,
+    go(n) {
+      return globalHistory.go(n);
+    },
+  };
+
+  return history;
+}
+
+//#endregion
Index: frontend/node_modules/@remix-run/router/index.ts
===================================================================
--- frontend/node_modules/@remix-run/router/index.ts	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/@remix-run/router/index.ts	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,106 @@
+export type {
+  ActionFunction,
+  ActionFunctionArgs,
+  AgnosticDataIndexRouteObject,
+  AgnosticDataNonIndexRouteObject,
+  AgnosticDataRouteMatch,
+  AgnosticDataRouteObject,
+  AgnosticIndexRouteObject,
+  AgnosticNonIndexRouteObject,
+  AgnosticPatchRoutesOnNavigationFunction,
+  AgnosticPatchRoutesOnNavigationFunctionArgs,
+  AgnosticRouteMatch,
+  AgnosticRouteObject,
+  DataStrategyFunction,
+  DataStrategyFunctionArgs,
+  DataStrategyMatch,
+  DataStrategyResult,
+  ErrorResponse,
+  FormEncType,
+  FormMethod,
+  HTMLFormMethod,
+  JsonFunction,
+  LazyRouteFunction,
+  LoaderFunction,
+  LoaderFunctionArgs,
+  ParamParseKey,
+  Params,
+  PathMatch,
+  PathParam,
+  PathPattern,
+  RedirectFunction,
+  ShouldRevalidateFunction,
+  ShouldRevalidateFunctionArgs,
+  TrackedPromise,
+  UIMatch,
+  V7_FormMethod,
+  DataWithResponseInit as UNSAFE_DataWithResponseInit,
+} from "./utils";
+
+export {
+  AbortedDeferredError,
+  data,
+  defer,
+  generatePath,
+  getToPathname,
+  isRouteErrorResponse,
+  joinPaths,
+  json,
+  matchPath,
+  matchRoutes,
+  normalizePathname,
+  redirect,
+  redirectDocument,
+  replace,
+  resolvePath,
+  resolveTo,
+  stripBasename,
+} from "./utils";
+
+export type {
+  BrowserHistory,
+  BrowserHistoryOptions,
+  HashHistory,
+  HashHistoryOptions,
+  History,
+  InitialEntry,
+  Location,
+  MemoryHistory,
+  MemoryHistoryOptions,
+  Path,
+  To,
+} from "./history";
+
+export {
+  Action,
+  createBrowserHistory,
+  createHashHistory,
+  createMemoryHistory,
+  createPath,
+  parsePath,
+} from "./history";
+
+export * from "./router";
+
+///////////////////////////////////////////////////////////////////////////////
+// DANGER! PLEASE READ ME!
+// We consider these exports an implementation detail and do not guarantee
+// against any breaking changes, regardless of the semver release. Use with
+// extreme caution and only if you understand the consequences. Godspeed.
+///////////////////////////////////////////////////////////////////////////////
+
+/** @internal */
+export type { RouteManifest as UNSAFE_RouteManifest } from "./utils";
+export {
+  DeferredData as UNSAFE_DeferredData,
+  ErrorResponseImpl as UNSAFE_ErrorResponseImpl,
+  convertRoutesToDataRoutes as UNSAFE_convertRoutesToDataRoutes,
+  convertRouteMatchToUiMatch as UNSAFE_convertRouteMatchToUiMatch,
+  decodePath as UNSAFE_decodePath,
+  getResolveToMatches as UNSAFE_getResolveToMatches,
+} from "./utils";
+
+export {
+  invariant as UNSAFE_invariant,
+  warning as UNSAFE_warning,
+} from "./history";
Index: frontend/node_modules/@remix-run/router/package.json
===================================================================
--- frontend/node_modules/@remix-run/router/package.json	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/@remix-run/router/package.json	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,33 @@
+{
+  "name": "@remix-run/router",
+  "version": "1.23.2",
+  "description": "Nested/Data-driven/Framework-agnostic Routing",
+  "keywords": [
+    "remix",
+    "router",
+    "location"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/remix-run/react-router",
+    "directory": "packages/router"
+  },
+  "license": "MIT",
+  "author": "Remix Software <hello@remix.run>",
+  "sideEffects": false,
+  "main": "./dist/router.cjs.js",
+  "unpkg": "./dist/router.umd.min.js",
+  "module": "./dist/router.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist/",
+    "*.ts",
+    "CHANGELOG.md"
+  ],
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}
Index: frontend/node_modules/@remix-run/router/router.ts
===================================================================
--- frontend/node_modules/@remix-run/router/router.ts	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/@remix-run/router/router.ts	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,6031 @@
+import type { History, Location, Path, To } from "./history";
+import {
+  Action as HistoryAction,
+  createLocation,
+  createPath,
+  invariant,
+  parsePath,
+  warning,
+} from "./history";
+import type {
+  AgnosticDataRouteMatch,
+  AgnosticDataRouteObject,
+  DataStrategyMatch,
+  AgnosticRouteObject,
+  DataResult,
+  DataStrategyFunction,
+  DataStrategyFunctionArgs,
+  DeferredData,
+  DeferredResult,
+  DetectErrorBoundaryFunction,
+  ErrorResult,
+  FormEncType,
+  FormMethod,
+  HTMLFormMethod,
+  DataStrategyResult,
+  ImmutableRouteKey,
+  MapRoutePropertiesFunction,
+  MutationFormMethod,
+  RedirectResult,
+  RouteData,
+  RouteManifest,
+  ShouldRevalidateFunctionArgs,
+  Submission,
+  SuccessResult,
+  UIMatch,
+  V7_FormMethod,
+  V7_MutationFormMethod,
+  AgnosticPatchRoutesOnNavigationFunction,
+  DataWithResponseInit,
+} from "./utils";
+import {
+  ErrorResponseImpl,
+  ResultType,
+  convertRouteMatchToUiMatch,
+  convertRoutesToDataRoutes,
+  getPathContributingMatches,
+  getResolveToMatches,
+  immutableRouteKeys,
+  isRouteErrorResponse,
+  joinPaths,
+  matchRoutes,
+  matchRoutesImpl,
+  resolveTo,
+  stripBasename,
+} from "./utils";
+
+////////////////////////////////////////////////////////////////////////////////
+//#region Types and Constants
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * A Router instance manages all navigation and data loading/mutations
+ */
+export interface Router {
+  /**
+   * @internal
+   * PRIVATE - DO NOT USE
+   *
+   * Return the basename for the router
+   */
+  get basename(): RouterInit["basename"];
+
+  /**
+   * @internal
+   * PRIVATE - DO NOT USE
+   *
+   * Return the future config for the router
+   */
+  get future(): FutureConfig;
+
+  /**
+   * @internal
+   * PRIVATE - DO NOT USE
+   *
+   * Return the current state of the router
+   */
+  get state(): RouterState;
+
+  /**
+   * @internal
+   * PRIVATE - DO NOT USE
+   *
+   * Return the routes for this router instance
+   */
+  get routes(): AgnosticDataRouteObject[];
+
+  /**
+   * @internal
+   * PRIVATE - DO NOT USE
+   *
+   * Return the window associated with the router
+   */
+  get window(): RouterInit["window"];
+
+  /**
+   * @internal
+   * PRIVATE - DO NOT USE
+   *
+   * Initialize the router, including adding history listeners and kicking off
+   * initial data fetches.  Returns a function to cleanup listeners and abort
+   * any in-progress loads
+   */
+  initialize(): Router;
+
+  /**
+   * @internal
+   * PRIVATE - DO NOT USE
+   *
+   * Subscribe to router.state updates
+   *
+   * @param fn function to call with the new state
+   */
+  subscribe(fn: RouterSubscriber): () => void;
+
+  /**
+   * @internal
+   * PRIVATE - DO NOT USE
+   *
+   * Enable scroll restoration behavior in the router
+   *
+   * @param savedScrollPositions Object that will manage positions, in case
+   *                             it's being restored from sessionStorage
+   * @param getScrollPosition    Function to get the active Y scroll position
+   * @param getKey               Function to get the key to use for restoration
+   */
+  enableScrollRestoration(
+    savedScrollPositions: Record<string, number>,
+    getScrollPosition: GetScrollPositionFunction,
+    getKey?: GetScrollRestorationKeyFunction
+  ): () => void;
+
+  /**
+   * @internal
+   * PRIVATE - DO NOT USE
+   *
+   * Navigate forward/backward in the history stack
+   * @param to Delta to move in the history stack
+   */
+  navigate(to: number): Promise<void>;
+
+  /**
+   * Navigate to the given path
+   * @param to Path to navigate to
+   * @param opts Navigation options (method, submission, etc.)
+   */
+  navigate(to: To | null, opts?: RouterNavigateOptions): Promise<void>;
+
+  /**
+   * @internal
+   * PRIVATE - DO NOT USE
+   *
+   * Trigger a fetcher load/submission
+   *
+   * @param key     Fetcher key
+   * @param routeId Route that owns the fetcher
+   * @param href    href to fetch
+   * @param opts    Fetcher options, (method, submission, etc.)
+   */
+  fetch(
+    key: string,
+    routeId: string,
+    href: string | null,
+    opts?: RouterFetchOptions
+  ): void;
+
+  /**
+   * @internal
+   * PRIVATE - DO NOT USE
+   *
+   * Trigger a revalidation of all current route loaders and fetcher loads
+   */
+  revalidate(): void;
+
+  /**
+   * @internal
+   * PRIVATE - DO NOT USE
+   *
+   * Utility function to create an href for the given location
+   * @param location
+   */
+  createHref(location: Location | URL): string;
+
+  /**
+   * @internal
+   * PRIVATE - DO NOT USE
+   *
+   * Utility function to URL encode a destination path according to the internal
+   * history implementation
+   * @param to
+   */
+  encodeLocation(to: To): Path;
+
+  /**
+   * @internal
+   * PRIVATE - DO NOT USE
+   *
+   * Get/create a fetcher for the given key
+   * @param key
+   */
+  getFetcher<TData = any>(key: string): Fetcher<TData>;
+
+  /**
+   * @internal
+   * PRIVATE - DO NOT USE
+   *
+   * Delete the fetcher for a given key
+   * @param key
+   */
+  deleteFetcher(key: string): void;
+
+  /**
+   * @internal
+   * PRIVATE - DO NOT USE
+   *
+   * Cleanup listeners and abort any in-progress loads
+   */
+  dispose(): void;
+
+  /**
+   * @internal
+   * PRIVATE - DO NOT USE
+   *
+   * Get a navigation blocker
+   * @param key The identifier for the blocker
+   * @param fn The blocker function implementation
+   */
+  getBlocker(key: string, fn: BlockerFunction): Blocker;
+
+  /**
+   * @internal
+   * PRIVATE - DO NOT USE
+   *
+   * Delete a navigation blocker
+   * @param key The identifier for the blocker
+   */
+  deleteBlocker(key: string): void;
+
+  /**
+   * @internal
+   * PRIVATE DO NOT USE
+   *
+   * Patch additional children routes into an existing parent route
+   * @param routeId The parent route id or a callback function accepting `patch`
+   *                to perform batch patching
+   * @param children The additional children routes
+   */
+  patchRoutes(routeId: string | null, children: AgnosticRouteObject[]): void;
+
+  /**
+   * @internal
+   * PRIVATE - DO NOT USE
+   *
+   * HMR needs to pass in-flight route updates to React Router
+   * TODO: Replace this with granular route update APIs (addRoute, updateRoute, deleteRoute)
+   */
+  _internalSetRoutes(routes: AgnosticRouteObject[]): void;
+
+  /**
+   * @internal
+   * PRIVATE - DO NOT USE
+   *
+   * Internal fetch AbortControllers accessed by unit tests
+   */
+  _internalFetchControllers: Map<string, AbortController>;
+
+  /**
+   * @internal
+   * PRIVATE - DO NOT USE
+   *
+   * Internal pending DeferredData instances accessed by unit tests
+   */
+  _internalActiveDeferreds: Map<string, DeferredData>;
+}
+
+/**
+ * State maintained internally by the router.  During a navigation, all states
+ * reflect the the "old" location unless otherwise noted.
+ */
+export interface RouterState {
+  /**
+   * The action of the most recent navigation
+   */
+  historyAction: HistoryAction;
+
+  /**
+   * The current location reflected by the router
+   */
+  location: Location;
+
+  /**
+   * The current set of route matches
+   */
+  matches: AgnosticDataRouteMatch[];
+
+  /**
+   * Tracks whether we've completed our initial data load
+   */
+  initialized: boolean;
+
+  /**
+   * Current scroll position we should start at for a new view
+   *  - number -> scroll position to restore to
+   *  - false -> do not restore scroll at all (used during submissions)
+   *  - null -> don't have a saved position, scroll to hash or top of page
+   */
+  restoreScrollPosition: number | false | null;
+
+  /**
+   * Indicate whether this navigation should skip resetting the scroll position
+   * if we are unable to restore the scroll position
+   */
+  preventScrollReset: boolean;
+
+  /**
+   * Tracks the state of the current navigation
+   */
+  navigation: Navigation;
+
+  /**
+   * Tracks any in-progress revalidations
+   */
+  revalidation: RevalidationState;
+
+  /**
+   * Data from the loaders for the current matches
+   */
+  loaderData: RouteData;
+
+  /**
+   * Data from the action for the current matches
+   */
+  actionData: RouteData | null;
+
+  /**
+   * Errors caught from loaders for the current matches
+   */
+  errors: RouteData | null;
+
+  /**
+   * Map of current fetchers
+   */
+  fetchers: Map<string, Fetcher>;
+
+  /**
+   * Map of current blockers
+   */
+  blockers: Map<string, Blocker>;
+}
+
+/**
+ * Data that can be passed into hydrate a Router from SSR
+ */
+export type HydrationState = Partial<
+  Pick<RouterState, "loaderData" | "actionData" | "errors">
+>;
+
+/**
+ * Future flags to toggle new feature behavior
+ */
+export interface FutureConfig {
+  v7_fetcherPersist: boolean;
+  v7_normalizeFormMethod: boolean;
+  v7_partialHydration: boolean;
+  v7_prependBasename: boolean;
+  v7_relativeSplatPath: boolean;
+  v7_skipActionErrorRevalidation: boolean;
+}
+
+/**
+ * Initialization options for createRouter
+ */
+export interface RouterInit {
+  routes: AgnosticRouteObject[];
+  history: History;
+  basename?: string;
+  /**
+   * @deprecated Use `mapRouteProperties` instead
+   */
+  detectErrorBoundary?: DetectErrorBoundaryFunction;
+  mapRouteProperties?: MapRoutePropertiesFunction;
+  future?: Partial<FutureConfig>;
+  hydrationData?: HydrationState;
+  window?: Window;
+  dataStrategy?: DataStrategyFunction;
+  patchRoutesOnNavigation?: AgnosticPatchRoutesOnNavigationFunction;
+}
+
+/**
+ * State returned from a server-side query() call
+ */
+export interface StaticHandlerContext {
+  basename: Router["basename"];
+  location: RouterState["location"];
+  matches: RouterState["matches"];
+  loaderData: RouterState["loaderData"];
+  actionData: RouterState["actionData"];
+  errors: RouterState["errors"];
+  statusCode: number;
+  loaderHeaders: Record<string, Headers>;
+  actionHeaders: Record<string, Headers>;
+  activeDeferreds: Record<string, DeferredData> | null;
+  _deepestRenderedBoundaryId?: string | null;
+}
+
+/**
+ * A StaticHandler instance manages a singular SSR navigation/fetch event
+ */
+export interface StaticHandler {
+  dataRoutes: AgnosticDataRouteObject[];
+  query(
+    request: Request,
+    opts?: {
+      requestContext?: unknown;
+      skipLoaderErrorBubbling?: boolean;
+      dataStrategy?: DataStrategyFunction;
+    }
+  ): Promise<StaticHandlerContext | Response>;
+  queryRoute(
+    request: Request,
+    opts?: {
+      routeId?: string;
+      requestContext?: unknown;
+      dataStrategy?: DataStrategyFunction;
+    }
+  ): Promise<any>;
+}
+
+type ViewTransitionOpts = {
+  currentLocation: Location;
+  nextLocation: Location;
+};
+
+/**
+ * Subscriber function signature for changes to router state
+ */
+export interface RouterSubscriber {
+  (
+    state: RouterState,
+    opts: {
+      deletedFetchers: string[];
+      viewTransitionOpts?: ViewTransitionOpts;
+      flushSync: boolean;
+    }
+  ): void;
+}
+
+/**
+ * Function signature for determining the key to be used in scroll restoration
+ * for a given location
+ */
+export interface GetScrollRestorationKeyFunction {
+  (location: Location, matches: UIMatch[]): string | null;
+}
+
+/**
+ * Function signature for determining the current scroll position
+ */
+export interface GetScrollPositionFunction {
+  (): number;
+}
+
+export type RelativeRoutingType = "route" | "path";
+
+// Allowed for any navigation or fetch
+type BaseNavigateOrFetchOptions = {
+  preventScrollReset?: boolean;
+  relative?: RelativeRoutingType;
+  flushSync?: boolean;
+};
+
+// Only allowed for navigations
+type BaseNavigateOptions = BaseNavigateOrFetchOptions & {
+  replace?: boolean;
+  state?: any;
+  fromRouteId?: string;
+  viewTransition?: boolean;
+};
+
+// Only allowed for submission navigations
+type BaseSubmissionOptions = {
+  formMethod?: HTMLFormMethod;
+  formEncType?: FormEncType;
+} & (
+  | { formData: FormData; body?: undefined }
+  | { formData?: undefined; body: any }
+);
+
+/**
+ * Options for a navigate() call for a normal (non-submission) navigation
+ */
+type LinkNavigateOptions = BaseNavigateOptions;
+
+/**
+ * Options for a navigate() call for a submission navigation
+ */
+type SubmissionNavigateOptions = BaseNavigateOptions & BaseSubmissionOptions;
+
+/**
+ * Options to pass to navigate() for a navigation
+ */
+export type RouterNavigateOptions =
+  | LinkNavigateOptions
+  | SubmissionNavigateOptions;
+
+/**
+ * Options for a fetch() load
+ */
+type LoadFetchOptions = BaseNavigateOrFetchOptions;
+
+/**
+ * Options for a fetch() submission
+ */
+type SubmitFetchOptions = BaseNavigateOrFetchOptions & BaseSubmissionOptions;
+
+/**
+ * Options to pass to fetch()
+ */
+export type RouterFetchOptions = LoadFetchOptions | SubmitFetchOptions;
+
+/**
+ * Potential states for state.navigation
+ */
+export type NavigationStates = {
+  Idle: {
+    state: "idle";
+    location: undefined;
+    formMethod: undefined;
+    formAction: undefined;
+    formEncType: undefined;
+    formData: undefined;
+    json: undefined;
+    text: undefined;
+  };
+  Loading: {
+    state: "loading";
+    location: Location;
+    formMethod: Submission["formMethod"] | undefined;
+    formAction: Submission["formAction"] | undefined;
+    formEncType: Submission["formEncType"] | undefined;
+    formData: Submission["formData"] | undefined;
+    json: Submission["json"] | undefined;
+    text: Submission["text"] | undefined;
+  };
+  Submitting: {
+    state: "submitting";
+    location: Location;
+    formMethod: Submission["formMethod"];
+    formAction: Submission["formAction"];
+    formEncType: Submission["formEncType"];
+    formData: Submission["formData"];
+    json: Submission["json"];
+    text: Submission["text"];
+  };
+};
+
+export type Navigation = NavigationStates[keyof NavigationStates];
+
+export type RevalidationState = "idle" | "loading";
+
+/**
+ * Potential states for fetchers
+ */
+type FetcherStates<TData = any> = {
+  Idle: {
+    state: "idle";
+    formMethod: undefined;
+    formAction: undefined;
+    formEncType: undefined;
+    text: undefined;
+    formData: undefined;
+    json: undefined;
+    data: TData | undefined;
+  };
+  Loading: {
+    state: "loading";
+    formMethod: Submission["formMethod"] | undefined;
+    formAction: Submission["formAction"] | undefined;
+    formEncType: Submission["formEncType"] | undefined;
+    text: Submission["text"] | undefined;
+    formData: Submission["formData"] | undefined;
+    json: Submission["json"] | undefined;
+    data: TData | undefined;
+  };
+  Submitting: {
+    state: "submitting";
+    formMethod: Submission["formMethod"];
+    formAction: Submission["formAction"];
+    formEncType: Submission["formEncType"];
+    text: Submission["text"];
+    formData: Submission["formData"];
+    json: Submission["json"];
+    data: TData | undefined;
+  };
+};
+
+export type Fetcher<TData = any> =
+  FetcherStates<TData>[keyof FetcherStates<TData>];
+
+interface BlockerBlocked {
+  state: "blocked";
+  reset(): void;
+  proceed(): void;
+  location: Location;
+}
+
+interface BlockerUnblocked {
+  state: "unblocked";
+  reset: undefined;
+  proceed: undefined;
+  location: undefined;
+}
+
+interface BlockerProceeding {
+  state: "proceeding";
+  reset: undefined;
+  proceed: undefined;
+  location: Location;
+}
+
+export type Blocker = BlockerUnblocked | BlockerBlocked | BlockerProceeding;
+
+export type BlockerFunction = (args: {
+  currentLocation: Location;
+  nextLocation: Location;
+  historyAction: HistoryAction;
+}) => boolean;
+
+interface ShortCircuitable {
+  /**
+   * startNavigation does not need to complete the navigation because we
+   * redirected or got interrupted
+   */
+  shortCircuited?: boolean;
+}
+
+type PendingActionResult = [string, SuccessResult | ErrorResult];
+
+interface HandleActionResult extends ShortCircuitable {
+  /**
+   * Route matches which may have been updated from fog of war discovery
+   */
+  matches?: RouterState["matches"];
+  /**
+   * Tuple for the returned or thrown value from the current action.  The routeId
+   * is the action route for success and the bubbled boundary route for errors.
+   */
+  pendingActionResult?: PendingActionResult;
+}
+
+interface HandleLoadersResult extends ShortCircuitable {
+  /**
+   * Route matches which may have been updated from fog of war discovery
+   */
+  matches?: RouterState["matches"];
+  /**
+   * loaderData returned from the current set of loaders
+   */
+  loaderData?: RouterState["loaderData"];
+  /**
+   * errors thrown from the current set of loaders
+   */
+  errors?: RouterState["errors"];
+}
+
+/**
+ * Cached info for active fetcher.load() instances so they can participate
+ * in revalidation
+ */
+interface FetchLoadMatch {
+  routeId: string;
+  path: string;
+}
+
+/**
+ * Identified fetcher.load() calls that need to be revalidated
+ */
+interface RevalidatingFetcher extends FetchLoadMatch {
+  key: string;
+  match: AgnosticDataRouteMatch | null;
+  matches: AgnosticDataRouteMatch[] | null;
+  controller: AbortController | null;
+}
+
+const validMutationMethodsArr: MutationFormMethod[] = [
+  "post",
+  "put",
+  "patch",
+  "delete",
+];
+const validMutationMethods = new Set<MutationFormMethod>(
+  validMutationMethodsArr
+);
+
+const validRequestMethodsArr: FormMethod[] = [
+  "get",
+  ...validMutationMethodsArr,
+];
+const validRequestMethods = new Set<FormMethod>(validRequestMethodsArr);
+
+const redirectStatusCodes = new Set([301, 302, 303, 307, 308]);
+const redirectPreserveMethodStatusCodes = new Set([307, 308]);
+
+export const IDLE_NAVIGATION: NavigationStates["Idle"] = {
+  state: "idle",
+  location: undefined,
+  formMethod: undefined,
+  formAction: undefined,
+  formEncType: undefined,
+  formData: undefined,
+  json: undefined,
+  text: undefined,
+};
+
+export const IDLE_FETCHER: FetcherStates["Idle"] = {
+  state: "idle",
+  data: undefined,
+  formMethod: undefined,
+  formAction: undefined,
+  formEncType: undefined,
+  formData: undefined,
+  json: undefined,
+  text: undefined,
+};
+
+export const IDLE_BLOCKER: BlockerUnblocked = {
+  state: "unblocked",
+  proceed: undefined,
+  reset: undefined,
+  location: undefined,
+};
+
+const ABSOLUTE_URL_REGEX = /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i;
+
+const defaultMapRouteProperties: MapRoutePropertiesFunction = (route) => ({
+  hasErrorBoundary: Boolean(route.hasErrorBoundary),
+});
+
+const TRANSITIONS_STORAGE_KEY = "remix-router-transitions";
+
+//#endregion
+
+////////////////////////////////////////////////////////////////////////////////
+//#region createRouter
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Create a router and listen to history POP navigations
+ */
+export function createRouter(init: RouterInit): Router {
+  const routerWindow = init.window
+    ? init.window
+    : typeof window !== "undefined"
+    ? window
+    : undefined;
+  const isBrowser =
+    typeof routerWindow !== "undefined" &&
+    typeof routerWindow.document !== "undefined" &&
+    typeof routerWindow.document.createElement !== "undefined";
+  const isServer = !isBrowser;
+
+  invariant(
+    init.routes.length > 0,
+    "You must provide a non-empty routes array to createRouter"
+  );
+
+  let mapRouteProperties: MapRoutePropertiesFunction;
+  if (init.mapRouteProperties) {
+    mapRouteProperties = init.mapRouteProperties;
+  } else if (init.detectErrorBoundary) {
+    // If they are still using the deprecated version, wrap it with the new API
+    let detectErrorBoundary = init.detectErrorBoundary;
+    mapRouteProperties = (route) => ({
+      hasErrorBoundary: detectErrorBoundary(route),
+    });
+  } else {
+    mapRouteProperties = defaultMapRouteProperties;
+  }
+
+  // Routes keyed by ID
+  let manifest: RouteManifest = {};
+  // Routes in tree format for matching
+  let dataRoutes = convertRoutesToDataRoutes(
+    init.routes,
+    mapRouteProperties,
+    undefined,
+    manifest
+  );
+  let inFlightDataRoutes: AgnosticDataRouteObject[] | undefined;
+  let basename = init.basename || "/";
+  let dataStrategyImpl = init.dataStrategy || defaultDataStrategy;
+  let patchRoutesOnNavigationImpl = init.patchRoutesOnNavigation;
+
+  // Config driven behavior flags
+  let future: FutureConfig = {
+    v7_fetcherPersist: false,
+    v7_normalizeFormMethod: false,
+    v7_partialHydration: false,
+    v7_prependBasename: false,
+    v7_relativeSplatPath: false,
+    v7_skipActionErrorRevalidation: false,
+    ...init.future,
+  };
+  // Cleanup function for history
+  let unlistenHistory: (() => void) | null = null;
+  // Externally-provided functions to call on all state changes
+  let subscribers = new Set<RouterSubscriber>();
+  // Externally-provided object to hold scroll restoration locations during routing
+  let savedScrollPositions: Record<string, number> | null = null;
+  // Externally-provided function to get scroll restoration keys
+  let getScrollRestorationKey: GetScrollRestorationKeyFunction | null = null;
+  // Externally-provided function to get current scroll position
+  let getScrollPosition: GetScrollPositionFunction | null = null;
+  // One-time flag to control the initial hydration scroll restoration.  Because
+  // we don't get the saved positions from <ScrollRestoration /> until _after_
+  // the initial render, we need to manually trigger a separate updateState to
+  // send along the restoreScrollPosition
+  // Set to true if we have `hydrationData` since we assume we were SSR'd and that
+  // SSR did the initial scroll restoration.
+  let initialScrollRestored = init.hydrationData != null;
+
+  let initialMatches = matchRoutes(dataRoutes, init.history.location, basename);
+  let initialMatchesIsFOW = false;
+  let initialErrors: RouteData | null = null;
+
+  if (initialMatches == null && !patchRoutesOnNavigationImpl) {
+    // If we do not match a user-provided-route, fall back to the root
+    // to allow the error boundary to take over
+    let error = getInternalRouterError(404, {
+      pathname: init.history.location.pathname,
+    });
+    let { matches, route } = getShortCircuitMatches(dataRoutes);
+    initialMatches = matches;
+    initialErrors = { [route.id]: error };
+  }
+
+  // In SPA apps, if the user provided a patchRoutesOnNavigation implementation and
+  // our initial match is a splat route, clear them out so we run through lazy
+  // discovery on hydration in case there's a more accurate lazy route match.
+  // In SSR apps (with `hydrationData`), we expect that the server will send
+  // up the proper matched routes so we don't want to run lazy discovery on
+  // initial hydration and want to hydrate into the splat route.
+  if (initialMatches && !init.hydrationData) {
+    let fogOfWar = checkFogOfWar(
+      initialMatches,
+      dataRoutes,
+      init.history.location.pathname
+    );
+    if (fogOfWar.active) {
+      initialMatches = null;
+    }
+  }
+
+  let initialized: boolean;
+  if (!initialMatches) {
+    initialized = false;
+    initialMatches = [];
+
+    // If partial hydration and fog of war is enabled, we will be running
+    // `patchRoutesOnNavigation` during hydration so include any partial matches as
+    // the initial matches so we can properly render `HydrateFallback`'s
+    if (future.v7_partialHydration) {
+      let fogOfWar = checkFogOfWar(
+        null,
+        dataRoutes,
+        init.history.location.pathname
+      );
+      if (fogOfWar.active && fogOfWar.matches) {
+        initialMatchesIsFOW = true;
+        initialMatches = fogOfWar.matches;
+      }
+    }
+  } else if (initialMatches.some((m) => m.route.lazy)) {
+    // All initialMatches need to be loaded before we're ready.  If we have lazy
+    // functions around still then we'll need to run them in initialize()
+    initialized = false;
+  } else if (!initialMatches.some((m) => m.route.loader)) {
+    // If we've got no loaders to run, then we're good to go
+    initialized = true;
+  } else if (future.v7_partialHydration) {
+    // If partial hydration is enabled, we're initialized so long as we were
+    // provided with hydrationData for every route with a loader, and no loaders
+    // were marked for explicit hydration
+    let loaderData = init.hydrationData ? init.hydrationData.loaderData : null;
+    let errors = init.hydrationData ? init.hydrationData.errors : null;
+    // If errors exist, don't consider routes below the boundary
+    if (errors) {
+      let idx = initialMatches.findIndex(
+        (m) => errors![m.route.id] !== undefined
+      );
+      initialized = initialMatches
+        .slice(0, idx + 1)
+        .every((m) => !shouldLoadRouteOnHydration(m.route, loaderData, errors));
+    } else {
+      initialized = initialMatches.every(
+        (m) => !shouldLoadRouteOnHydration(m.route, loaderData, errors)
+      );
+    }
+  } else {
+    // Without partial hydration - we're initialized if we were provided any
+    // hydrationData - which is expected to be complete
+    initialized = init.hydrationData != null;
+  }
+
+  let router: Router;
+  let state: RouterState = {
+    historyAction: init.history.action,
+    location: init.history.location,
+    matches: initialMatches,
+    initialized,
+    navigation: IDLE_NAVIGATION,
+    // Don't restore on initial updateState() if we were SSR'd
+    restoreScrollPosition: init.hydrationData != null ? false : null,
+    preventScrollReset: false,
+    revalidation: "idle",
+    loaderData: (init.hydrationData && init.hydrationData.loaderData) || {},
+    actionData: (init.hydrationData && init.hydrationData.actionData) || null,
+    errors: (init.hydrationData && init.hydrationData.errors) || initialErrors,
+    fetchers: new Map(),
+    blockers: new Map(),
+  };
+
+  // -- Stateful internal variables to manage navigations --
+  // Current navigation in progress (to be committed in completeNavigation)
+  let pendingAction: HistoryAction = HistoryAction.Pop;
+
+  // Should the current navigation prevent the scroll reset if scroll cannot
+  // be restored?
+  let pendingPreventScrollReset = false;
+
+  // AbortController for the active navigation
+  let pendingNavigationController: AbortController | null;
+
+  // Should the current navigation enable document.startViewTransition?
+  let pendingViewTransitionEnabled = false;
+
+  // Store applied view transitions so we can apply them on POP
+  let appliedViewTransitions: Map<string, Set<string>> = new Map<
+    string,
+    Set<string>
+  >();
+
+  // Cleanup function for persisting applied transitions to sessionStorage
+  let removePageHideEventListener: (() => void) | null = null;
+
+  // We use this to avoid touching history in completeNavigation if a
+  // revalidation is entirely uninterrupted
+  let isUninterruptedRevalidation = false;
+
+  // Use this internal flag to force revalidation of all loaders:
+  //  - submissions (completed or interrupted)
+  //  - useRevalidator()
+  //  - X-Remix-Revalidate (from redirect)
+  let isRevalidationRequired = false;
+
+  // Use this internal array to capture routes that require revalidation due
+  // to a cancelled deferred on action submission
+  let cancelledDeferredRoutes: string[] = [];
+
+  // Use this internal array to capture fetcher loads that were cancelled by an
+  // action navigation and require revalidation
+  let cancelledFetcherLoads: Set<string> = new Set();
+
+  // AbortControllers for any in-flight fetchers
+  let fetchControllers = new Map<string, AbortController>();
+
+  // Track loads based on the order in which they started
+  let incrementingLoadId = 0;
+
+  // Track the outstanding pending navigation data load to be compared against
+  // the globally incrementing load when a fetcher load lands after a completed
+  // navigation
+  let pendingNavigationLoadId = -1;
+
+  // Fetchers that triggered data reloads as a result of their actions
+  let fetchReloadIds = new Map<string, number>();
+
+  // Fetchers that triggered redirect navigations
+  let fetchRedirectIds = new Set<string>();
+
+  // Most recent href/match for fetcher.load calls for fetchers
+  let fetchLoadMatches = new Map<string, FetchLoadMatch>();
+
+  // Ref-count mounted fetchers so we know when it's ok to clean them up
+  let activeFetchers = new Map<string, number>();
+
+  // Fetchers that have requested a delete when using v7_fetcherPersist,
+  // they'll be officially removed after they return to idle
+  let deletedFetchers = new Set<string>();
+
+  // Store DeferredData instances for active route matches.  When a
+  // route loader returns defer() we stick one in here.  Then, when a nested
+  // promise resolves we update loaderData.  If a new navigation starts we
+  // cancel active deferreds for eliminated routes.
+  let activeDeferreds = new Map<string, DeferredData>();
+
+  // Store blocker functions in a separate Map outside of router state since
+  // we don't need to update UI state if they change
+  let blockerFunctions = new Map<string, BlockerFunction>();
+
+  // Map of pending patchRoutesOnNavigation() promises (keyed by path/matches) so
+  // that we only kick them off once for a given combo
+  let pendingPatchRoutes = new Map<
+    string,
+    ReturnType<AgnosticPatchRoutesOnNavigationFunction>
+  >();
+
+  // Flag to ignore the next history update, so we can revert the URL change on
+  // a POP navigation that was blocked by the user without touching router state
+  let unblockBlockerHistoryUpdate: (() => void) | undefined = undefined;
+
+  // Initialize the router, all side effects should be kicked off from here.
+  // Implemented as a Fluent API for ease of:
+  //   let router = createRouter(init).initialize();
+  function initialize() {
+    // If history informs us of a POP navigation, start the navigation but do not update
+    // state.  We'll update our own state once the navigation completes
+    unlistenHistory = init.history.listen(
+      ({ action: historyAction, location, delta }) => {
+        // Ignore this event if it was just us resetting the URL from a
+        // blocked POP navigation
+        if (unblockBlockerHistoryUpdate) {
+          unblockBlockerHistoryUpdate();
+          unblockBlockerHistoryUpdate = undefined;
+          return;
+        }
+
+        warning(
+          blockerFunctions.size === 0 || delta != null,
+          "You are trying to use a blocker on a POP navigation to a location " +
+            "that was not created by @remix-run/router. This will fail silently in " +
+            "production. This can happen if you are navigating outside the router " +
+            "via `window.history.pushState`/`window.location.hash` instead of using " +
+            "router navigation APIs.  This can also happen if you are using " +
+            "createHashRouter and the user manually changes the URL."
+        );
+
+        let blockerKey = shouldBlockNavigation({
+          currentLocation: state.location,
+          nextLocation: location,
+          historyAction,
+        });
+
+        if (blockerKey && delta != null) {
+          // Restore the URL to match the current UI, but don't update router state
+          let nextHistoryUpdatePromise = new Promise<void>((resolve) => {
+            unblockBlockerHistoryUpdate = resolve;
+          });
+          init.history.go(delta * -1);
+
+          // Put the blocker into a blocked state
+          updateBlocker(blockerKey, {
+            state: "blocked",
+            location,
+            proceed() {
+              updateBlocker(blockerKey!, {
+                state: "proceeding",
+                proceed: undefined,
+                reset: undefined,
+                location,
+              });
+              // Re-do the same POP navigation we just blocked, after the url
+              // restoration is also complete.  See:
+              // https://github.com/remix-run/react-router/issues/11613
+              nextHistoryUpdatePromise.then(() => init.history.go(delta));
+            },
+            reset() {
+              let blockers = new Map(state.blockers);
+              blockers.set(blockerKey!, IDLE_BLOCKER);
+              updateState({ blockers });
+            },
+          });
+          return;
+        }
+
+        return startNavigation(historyAction, location);
+      }
+    );
+
+    if (isBrowser) {
+      // FIXME: This feels gross.  How can we cleanup the lines between
+      // scrollRestoration/appliedTransitions persistance?
+      restoreAppliedTransitions(routerWindow, appliedViewTransitions);
+      let _saveAppliedTransitions = () =>
+        persistAppliedTransitions(routerWindow, appliedViewTransitions);
+      routerWindow.addEventListener("pagehide", _saveAppliedTransitions);
+      removePageHideEventListener = () =>
+        routerWindow.removeEventListener("pagehide", _saveAppliedTransitions);
+    }
+
+    // Kick off initial data load if needed.  Use Pop to avoid modifying history
+    // Note we don't do any handling of lazy here.  For SPA's it'll get handled
+    // in the normal navigation flow.  For SSR it's expected that lazy modules are
+    // resolved prior to router creation since we can't go into a fallbackElement
+    // UI for SSR'd apps
+    if (!state.initialized) {
+      startNavigation(HistoryAction.Pop, state.location, {
+        initialHydration: true,
+      });
+    }
+
+    return router;
+  }
+
+  // Clean up a router and it's side effects
+  function dispose() {
+    if (unlistenHistory) {
+      unlistenHistory();
+    }
+    if (removePageHideEventListener) {
+      removePageHideEventListener();
+    }
+    subscribers.clear();
+    pendingNavigationController && pendingNavigationController.abort();
+    state.fetchers.forEach((_, key) => deleteFetcher(key));
+    state.blockers.forEach((_, key) => deleteBlocker(key));
+  }
+
+  // Subscribe to state updates for the router
+  function subscribe(fn: RouterSubscriber) {
+    subscribers.add(fn);
+    return () => subscribers.delete(fn);
+  }
+
+  // Update our state and notify the calling context of the change
+  function updateState(
+    newState: Partial<RouterState>,
+    opts: {
+      flushSync?: boolean;
+      viewTransitionOpts?: ViewTransitionOpts;
+    } = {}
+  ): void {
+    state = {
+      ...state,
+      ...newState,
+    };
+
+    // Prep fetcher cleanup so we can tell the UI which fetcher data entries
+    // can be removed
+    let completedFetchers: string[] = [];
+    let deletedFetchersKeys: string[] = [];
+
+    if (future.v7_fetcherPersist) {
+      state.fetchers.forEach((fetcher, key) => {
+        if (fetcher.state === "idle") {
+          if (deletedFetchers.has(key)) {
+            // Unmounted from the UI and can be totally removed
+            deletedFetchersKeys.push(key);
+          } else {
+            // Returned to idle but still mounted in the UI, so semi-remains for
+            // revalidations and such
+            completedFetchers.push(key);
+          }
+        }
+      });
+    }
+
+    // Remove any lingering deleted fetchers that have already been removed
+    // from state.fetchers
+    deletedFetchers.forEach((key) => {
+      if (!state.fetchers.has(key) && !fetchControllers.has(key)) {
+        deletedFetchersKeys.push(key);
+      }
+    });
+
+    // Iterate over a local copy so that if flushSync is used and we end up
+    // removing and adding a new subscriber due to the useCallback dependencies,
+    // we don't get ourselves into a loop calling the new subscriber immediately
+    [...subscribers].forEach((subscriber) =>
+      subscriber(state, {
+        deletedFetchers: deletedFetchersKeys,
+        viewTransitionOpts: opts.viewTransitionOpts,
+        flushSync: opts.flushSync === true,
+      })
+    );
+
+    // Remove idle fetchers from state since we only care about in-flight fetchers.
+    if (future.v7_fetcherPersist) {
+      completedFetchers.forEach((key) => state.fetchers.delete(key));
+      deletedFetchersKeys.forEach((key) => deleteFetcher(key));
+    } else {
+      // We already called deleteFetcher() on these, can remove them from this
+      // Set now that we've handed the keys off to the data layer
+      deletedFetchersKeys.forEach((key) => deletedFetchers.delete(key));
+    }
+  }
+
+  // Complete a navigation returning the state.navigation back to the IDLE_NAVIGATION
+  // and setting state.[historyAction/location/matches] to the new route.
+  // - Location is a required param
+  // - Navigation will always be set to IDLE_NAVIGATION
+  // - Can pass any other state in newState
+  function completeNavigation(
+    location: Location,
+    newState: Partial<Omit<RouterState, "action" | "location" | "navigation">>,
+    { flushSync }: { flushSync?: boolean } = {}
+  ): void {
+    // Deduce if we're in a loading/actionReload state:
+    // - We have committed actionData in the store
+    // - The current navigation was a mutation submission
+    // - We're past the submitting state and into the loading state
+    // - The location being loaded is not the result of a redirect
+    let isActionReload =
+      state.actionData != null &&
+      state.navigation.formMethod != null &&
+      isMutationMethod(state.navigation.formMethod) &&
+      state.navigation.state === "loading" &&
+      location.state?._isRedirect !== true;
+
+    let actionData: RouteData | null;
+    if (newState.actionData) {
+      if (Object.keys(newState.actionData).length > 0) {
+        actionData = newState.actionData;
+      } else {
+        // Empty actionData -> clear prior actionData due to an action error
+        actionData = null;
+      }
+    } else if (isActionReload) {
+      // Keep the current data if we're wrapping up the action reload
+      actionData = state.actionData;
+    } else {
+      // Clear actionData on any other completed navigations
+      actionData = null;
+    }
+
+    // Always preserve any existing loaderData from re-used routes
+    let loaderData = newState.loaderData
+      ? mergeLoaderData(
+          state.loaderData,
+          newState.loaderData,
+          newState.matches || [],
+          newState.errors
+        )
+      : state.loaderData;
+
+    // On a successful navigation we can assume we got through all blockers
+    // so we can start fresh
+    let blockers = state.blockers;
+    if (blockers.size > 0) {
+      blockers = new Map(blockers);
+      blockers.forEach((_, k) => blockers.set(k, IDLE_BLOCKER));
+    }
+
+    // Always respect the user flag.  Otherwise don't reset on mutation
+    // submission navigations unless they redirect
+    let preventScrollReset =
+      pendingPreventScrollReset === true ||
+      (state.navigation.formMethod != null &&
+        isMutationMethod(state.navigation.formMethod) &&
+        location.state?._isRedirect !== true);
+
+    // Commit any in-flight routes at the end of the HMR revalidation "navigation"
+    if (inFlightDataRoutes) {
+      dataRoutes = inFlightDataRoutes;
+      inFlightDataRoutes = undefined;
+    }
+
+    if (isUninterruptedRevalidation) {
+      // If this was an uninterrupted revalidation then do not touch history
+    } else if (pendingAction === HistoryAction.Pop) {
+      // Do nothing for POP - URL has already been updated
+    } else if (pendingAction === HistoryAction.Push) {
+      init.history.push(location, location.state);
+    } else if (pendingAction === HistoryAction.Replace) {
+      init.history.replace(location, location.state);
+    }
+
+    let viewTransitionOpts: ViewTransitionOpts | undefined;
+
+    // On POP, enable transitions if they were enabled on the original navigation
+    if (pendingAction === HistoryAction.Pop) {
+      // Forward takes precedence so they behave like the original navigation
+      let priorPaths = appliedViewTransitions.get(state.location.pathname);
+      if (priorPaths && priorPaths.has(location.pathname)) {
+        viewTransitionOpts = {
+          currentLocation: state.location,
+          nextLocation: location,
+        };
+      } else if (appliedViewTransitions.has(location.pathname)) {
+        // If we don't have a previous forward nav, assume we're popping back to
+        // the new location and enable if that location previously enabled
+        viewTransitionOpts = {
+          currentLocation: location,
+          nextLocation: state.location,
+        };
+      }
+    } else if (pendingViewTransitionEnabled) {
+      // Store the applied transition on PUSH/REPLACE
+      let toPaths = appliedViewTransitions.get(state.location.pathname);
+      if (toPaths) {
+        toPaths.add(location.pathname);
+      } else {
+        toPaths = new Set<string>([location.pathname]);
+        appliedViewTransitions.set(state.location.pathname, toPaths);
+      }
+      viewTransitionOpts = {
+        currentLocation: state.location,
+        nextLocation: location,
+      };
+    }
+
+    updateState(
+      {
+        ...newState, // matches, errors, fetchers go through as-is
+        actionData,
+        loaderData,
+        historyAction: pendingAction,
+        location,
+        initialized: true,
+        navigation: IDLE_NAVIGATION,
+        revalidation: "idle",
+        restoreScrollPosition: getSavedScrollPosition(
+          location,
+          newState.matches || state.matches
+        ),
+        preventScrollReset,
+        blockers,
+      },
+      {
+        viewTransitionOpts,
+        flushSync: flushSync === true,
+      }
+    );
+
+    // Reset stateful navigation vars
+    pendingAction = HistoryAction.Pop;
+    pendingPreventScrollReset = false;
+    pendingViewTransitionEnabled = false;
+    isUninterruptedRevalidation = false;
+    isRevalidationRequired = false;
+    cancelledDeferredRoutes = [];
+  }
+
+  // Trigger a navigation event, which can either be a numerical POP or a PUSH
+  // replace with an optional submission
+  async function navigate(
+    to: number | To | null,
+    opts?: RouterNavigateOptions
+  ): Promise<void> {
+    if (typeof to === "number") {
+      init.history.go(to);
+      return;
+    }
+
+    let normalizedPath = normalizeTo(
+      state.location,
+      state.matches,
+      basename,
+      future.v7_prependBasename,
+      to,
+      future.v7_relativeSplatPath,
+      opts?.fromRouteId,
+      opts?.relative
+    );
+    let { path, submission, error } = normalizeNavigateOptions(
+      future.v7_normalizeFormMethod,
+      false,
+      normalizedPath,
+      opts
+    );
+
+    let currentLocation = state.location;
+    let nextLocation = createLocation(state.location, path, opts && opts.state);
+
+    // When using navigate as a PUSH/REPLACE we aren't reading an already-encoded
+    // URL from window.location, so we need to encode it here so the behavior
+    // remains the same as POP and non-data-router usages.  new URL() does all
+    // the same encoding we'd get from a history.pushState/window.location read
+    // without having to touch history
+    nextLocation = {
+      ...nextLocation,
+      ...init.history.encodeLocation(nextLocation),
+    };
+
+    let userReplace = opts && opts.replace != null ? opts.replace : undefined;
+
+    let historyAction = HistoryAction.Push;
+
+    if (userReplace === true) {
+      historyAction = HistoryAction.Replace;
+    } else if (userReplace === false) {
+      // no-op
+    } else if (
+      submission != null &&
+      isMutationMethod(submission.formMethod) &&
+      submission.formAction === state.location.pathname + state.location.search
+    ) {
+      // By default on submissions to the current location we REPLACE so that
+      // users don't have to double-click the back button to get to the prior
+      // location.  If the user redirects to a different location from the
+      // action/loader this will be ignored and the redirect will be a PUSH
+      historyAction = HistoryAction.Replace;
+    }
+
+    let preventScrollReset =
+      opts && "preventScrollReset" in opts
+        ? opts.preventScrollReset === true
+        : undefined;
+
+    let flushSync = (opts && opts.flushSync) === true;
+
+    let blockerKey = shouldBlockNavigation({
+      currentLocation,
+      nextLocation,
+      historyAction,
+    });
+
+    if (blockerKey) {
+      // Put the blocker into a blocked state
+      updateBlocker(blockerKey, {
+        state: "blocked",
+        location: nextLocation,
+        proceed() {
+          updateBlocker(blockerKey!, {
+            state: "proceeding",
+            proceed: undefined,
+            reset: undefined,
+            location: nextLocation,
+          });
+          // Send the same navigation through
+          navigate(to, opts);
+        },
+        reset() {
+          let blockers = new Map(state.blockers);
+          blockers.set(blockerKey!, IDLE_BLOCKER);
+          updateState({ blockers });
+        },
+      });
+      return;
+    }
+
+    return await startNavigation(historyAction, nextLocation, {
+      submission,
+      // Send through the formData serialization error if we have one so we can
+      // render at the right error boundary after we match routes
+      pendingError: error,
+      preventScrollReset,
+      replace: opts && opts.replace,
+      enableViewTransition: opts && opts.viewTransition,
+      flushSync,
+    });
+  }
+
+  // Revalidate all current loaders.  If a navigation is in progress or if this
+  // is interrupted by a navigation, allow this to "succeed" by calling all
+  // loaders during the next loader round
+  function revalidate() {
+    interruptActiveLoads();
+    updateState({ revalidation: "loading" });
+
+    // If we're currently submitting an action, we don't need to start a new
+    // navigation, we'll just let the follow up loader execution call all loaders
+    if (state.navigation.state === "submitting") {
+      return;
+    }
+
+    // If we're currently in an idle state, start a new navigation for the current
+    // action/location and mark it as uninterrupted, which will skip the history
+    // update in completeNavigation
+    if (state.navigation.state === "idle") {
+      startNavigation(state.historyAction, state.location, {
+        startUninterruptedRevalidation: true,
+      });
+      return;
+    }
+
+    // Otherwise, if we're currently in a loading state, just start a new
+    // navigation to the navigation.location but do not trigger an uninterrupted
+    // revalidation so that history correctly updates once the navigation completes
+    startNavigation(
+      pendingAction || state.historyAction,
+      state.navigation.location,
+      {
+        overrideNavigation: state.navigation,
+        // Proxy through any rending view transition
+        enableViewTransition: pendingViewTransitionEnabled === true,
+      }
+    );
+  }
+
+  // Start a navigation to the given action/location.  Can optionally provide a
+  // overrideNavigation which will override the normalLoad in the case of a redirect
+  // navigation
+  async function startNavigation(
+    historyAction: HistoryAction,
+    location: Location,
+    opts?: {
+      initialHydration?: boolean;
+      submission?: Submission;
+      fetcherSubmission?: Submission;
+      overrideNavigation?: Navigation;
+      pendingError?: ErrorResponseImpl;
+      startUninterruptedRevalidation?: boolean;
+      preventScrollReset?: boolean;
+      replace?: boolean;
+      enableViewTransition?: boolean;
+      flushSync?: boolean;
+    }
+  ): Promise<void> {
+    // Abort any in-progress navigations and start a new one. Unset any ongoing
+    // uninterrupted revalidations unless told otherwise, since we want this
+    // new navigation to update history normally
+    pendingNavigationController && pendingNavigationController.abort();
+    pendingNavigationController = null;
+    pendingAction = historyAction;
+    isUninterruptedRevalidation =
+      (opts && opts.startUninterruptedRevalidation) === true;
+
+    // Save the current scroll position every time we start a new navigation,
+    // and track whether we should reset scroll on completion
+    saveScrollPosition(state.location, state.matches);
+    pendingPreventScrollReset = (opts && opts.preventScrollReset) === true;
+
+    pendingViewTransitionEnabled = (opts && opts.enableViewTransition) === true;
+
+    let routesToUse = inFlightDataRoutes || dataRoutes;
+    let loadingNavigation = opts && opts.overrideNavigation;
+    let matches =
+      opts?.initialHydration &&
+      state.matches &&
+      state.matches.length > 0 &&
+      !initialMatchesIsFOW
+        ? // `matchRoutes()` has already been called if we're in here via `router.initialize()`
+          state.matches
+        : matchRoutes(routesToUse, location, basename);
+    let flushSync = (opts && opts.flushSync) === true;
+
+    // Short circuit if it's only a hash change and not a revalidation or
+    // mutation submission.
+    //
+    // Ignore on initial page loads because since the initial hydration will always
+    // be "same hash".  For example, on /page#hash and submit a <Form method="post">
+    // which will default to a navigation to /page
+    if (
+      matches &&
+      state.initialized &&
+      !isRevalidationRequired &&
+      isHashChangeOnly(state.location, location) &&
+      !(opts && opts.submission && isMutationMethod(opts.submission.formMethod))
+    ) {
+      completeNavigation(location, { matches }, { flushSync });
+      return;
+    }
+
+    let fogOfWar = checkFogOfWar(matches, routesToUse, location.pathname);
+    if (fogOfWar.active && fogOfWar.matches) {
+      matches = fogOfWar.matches;
+    }
+
+    // Short circuit with a 404 on the root error boundary if we match nothing
+    if (!matches) {
+      let { error, notFoundMatches, route } = handleNavigational404(
+        location.pathname
+      );
+      completeNavigation(
+        location,
+        {
+          matches: notFoundMatches,
+          loaderData: {},
+          errors: {
+            [route.id]: error,
+          },
+        },
+        { flushSync }
+      );
+      return;
+    }
+
+    // Create a controller/Request for this navigation
+    pendingNavigationController = new AbortController();
+    let request = createClientSideRequest(
+      init.history,
+      location,
+      pendingNavigationController.signal,
+      opts && opts.submission
+    );
+    let pendingActionResult: PendingActionResult | undefined;
+
+    if (opts && opts.pendingError) {
+      // If we have a pendingError, it means the user attempted a GET submission
+      // with binary FormData so assign here and skip to handleLoaders.  That
+      // way we handle calling loaders above the boundary etc.  It's not really
+      // different from an actionError in that sense.
+      pendingActionResult = [
+        findNearestBoundary(matches).route.id,
+        { type: ResultType.error, error: opts.pendingError },
+      ];
+    } else if (
+      opts &&
+      opts.submission &&
+      isMutationMethod(opts.submission.formMethod)
+    ) {
+      // Call action if we received an action submission
+      let actionResult = await handleAction(
+        request,
+        location,
+        opts.submission,
+        matches,
+        fogOfWar.active,
+        { replace: opts.replace, flushSync }
+      );
+
+      if (actionResult.shortCircuited) {
+        return;
+      }
+
+      // If we received a 404 from handleAction, it's because we couldn't lazily
+      // discover the destination route so we don't want to call loaders
+      if (actionResult.pendingActionResult) {
+        let [routeId, result] = actionResult.pendingActionResult;
+        if (
+          isErrorResult(result) &&
+          isRouteErrorResponse(result.error) &&
+          result.error.status === 404
+        ) {
+          pendingNavigationController = null;
+
+          completeNavigation(location, {
+            matches: actionResult.matches,
+            loaderData: {},
+            errors: {
+              [routeId]: result.error,
+            },
+          });
+          return;
+        }
+      }
+
+      matches = actionResult.matches || matches;
+      pendingActionResult = actionResult.pendingActionResult;
+      loadingNavigation = getLoadingNavigation(location, opts.submission);
+      flushSync = false;
+      // No need to do fog of war matching again on loader execution
+      fogOfWar.active = false;
+
+      // Create a GET request for the loaders
+      request = createClientSideRequest(
+        init.history,
+        request.url,
+        request.signal
+      );
+    }
+
+    // Call loaders
+    let {
+      shortCircuited,
+      matches: updatedMatches,
+      loaderData,
+      errors,
+    } = await handleLoaders(
+      request,
+      location,
+      matches,
+      fogOfWar.active,
+      loadingNavigation,
+      opts && opts.submission,
+      opts && opts.fetcherSubmission,
+      opts && opts.replace,
+      opts && opts.initialHydration === true,
+      flushSync,
+      pendingActionResult
+    );
+
+    if (shortCircuited) {
+      return;
+    }
+
+    // Clean up now that the action/loaders have completed.  Don't clean up if
+    // we short circuited because pendingNavigationController will have already
+    // been assigned to a new controller for the next navigation
+    pendingNavigationController = null;
+
+    completeNavigation(location, {
+      matches: updatedMatches || matches,
+      ...getActionDataForCommit(pendingActionResult),
+      loaderData,
+      errors,
+    });
+  }
+
+  // Call the action matched by the leaf route for this navigation and handle
+  // redirects/errors
+  async function handleAction(
+    request: Request,
+    location: Location,
+    submission: Submission,
+    matches: AgnosticDataRouteMatch[],
+    isFogOfWar: boolean,
+    opts: { replace?: boolean; flushSync?: boolean } = {}
+  ): Promise<HandleActionResult> {
+    interruptActiveLoads();
+
+    // Put us in a submitting state
+    let navigation = getSubmittingNavigation(location, submission);
+    updateState({ navigation }, { flushSync: opts.flushSync === true });
+
+    if (isFogOfWar) {
+      let discoverResult = await discoverRoutes(
+        matches,
+        location.pathname,
+        request.signal
+      );
+      if (discoverResult.type === "aborted") {
+        return { shortCircuited: true };
+      } else if (discoverResult.type === "error") {
+        let boundaryId = findNearestBoundary(discoverResult.partialMatches)
+          .route.id;
+        return {
+          matches: discoverResult.partialMatches,
+          pendingActionResult: [
+            boundaryId,
+            {
+              type: ResultType.error,
+              error: discoverResult.error,
+            },
+          ],
+        };
+      } else if (!discoverResult.matches) {
+        let { notFoundMatches, error, route } = handleNavigational404(
+          location.pathname
+        );
+        return {
+          matches: notFoundMatches,
+          pendingActionResult: [
+            route.id,
+            {
+              type: ResultType.error,
+              error,
+            },
+          ],
+        };
+      } else {
+        matches = discoverResult.matches;
+      }
+    }
+
+    // Call our action and get the result
+    let result: DataResult;
+    let actionMatch = getTargetMatch(matches, location);
+
+    if (!actionMatch.route.action && !actionMatch.route.lazy) {
+      result = {
+        type: ResultType.error,
+        error: getInternalRouterError(405, {
+          method: request.method,
+          pathname: location.pathname,
+          routeId: actionMatch.route.id,
+        }),
+      };
+    } else {
+      let results = await callDataStrategy(
+        "action",
+        state,
+        request,
+        [actionMatch],
+        matches,
+        null
+      );
+      result = results[actionMatch.route.id];
+
+      if (request.signal.aborted) {
+        return { shortCircuited: true };
+      }
+    }
+
+    if (isRedirectResult(result)) {
+      let replace: boolean;
+      if (opts && opts.replace != null) {
+        replace = opts.replace;
+      } else {
+        // If the user didn't explicity indicate replace behavior, replace if
+        // we redirected to the exact same location we're currently at to avoid
+        // double back-buttons
+        let location = normalizeRedirectLocation(
+          result.response.headers.get("Location")!,
+          new URL(request.url),
+          basename,
+          init.history,
+        );
+        replace = location === state.location.pathname + state.location.search;
+      }
+      await startRedirectNavigation(request, result, true, {
+        submission,
+        replace,
+      });
+      return { shortCircuited: true };
+    }
+
+    if (isDeferredResult(result)) {
+      throw getInternalRouterError(400, { type: "defer-action" });
+    }
+
+    if (isErrorResult(result)) {
+      // Store off the pending error - we use it to determine which loaders
+      // to call and will commit it when we complete the navigation
+      let boundaryMatch = findNearestBoundary(matches, actionMatch.route.id);
+
+      // By default, all submissions to the current location are REPLACE
+      // navigations, but if the action threw an error that'll be rendered in
+      // an errorElement, we fall back to PUSH so that the user can use the
+      // back button to get back to the pre-submission form location to try
+      // again
+      if ((opts && opts.replace) !== true) {
+        pendingAction = HistoryAction.Push;
+      }
+
+      return {
+        matches,
+        pendingActionResult: [boundaryMatch.route.id, result],
+      };
+    }
+
+    return {
+      matches,
+      pendingActionResult: [actionMatch.route.id, result],
+    };
+  }
+
+  // Call all applicable loaders for the given matches, handling redirects,
+  // errors, etc.
+  async function handleLoaders(
+    request: Request,
+    location: Location,
+    matches: AgnosticDataRouteMatch[],
+    isFogOfWar: boolean,
+    overrideNavigation?: Navigation,
+    submission?: Submission,
+    fetcherSubmission?: Submission,
+    replace?: boolean,
+    initialHydration?: boolean,
+    flushSync?: boolean,
+    pendingActionResult?: PendingActionResult
+  ): Promise<HandleLoadersResult> {
+    // Figure out the right navigation we want to use for data loading
+    let loadingNavigation =
+      overrideNavigation || getLoadingNavigation(location, submission);
+
+    // If this was a redirect from an action we don't have a "submission" but
+    // we have it on the loading navigation so use that if available
+    let activeSubmission =
+      submission ||
+      fetcherSubmission ||
+      getSubmissionFromNavigation(loadingNavigation);
+
+    // If this is an uninterrupted revalidation, we remain in our current idle
+    // state.  If not, we need to switch to our loading state and load data,
+    // preserving any new action data or existing action data (in the case of
+    // a revalidation interrupting an actionReload)
+    // If we have partialHydration enabled, then don't update the state for the
+    // initial data load since it's not a "navigation"
+    let shouldUpdateNavigationState =
+      !isUninterruptedRevalidation &&
+      (!future.v7_partialHydration || !initialHydration);
+
+    // When fog of war is enabled, we enter our `loading` state earlier so we
+    // can discover new routes during the `loading` state.  We skip this if
+    // we've already run actions since we would have done our matching already.
+    // If the children() function threw then, we want to proceed with the
+    // partial matches it discovered.
+    if (isFogOfWar) {
+      if (shouldUpdateNavigationState) {
+        let actionData = getUpdatedActionData(pendingActionResult);
+        updateState(
+          {
+            navigation: loadingNavigation,
+            ...(actionData !== undefined ? { actionData } : {}),
+          },
+          {
+            flushSync,
+          }
+        );
+      }
+
+      let discoverResult = await discoverRoutes(
+        matches,
+        location.pathname,
+        request.signal
+      );
+
+      if (discoverResult.type === "aborted") {
+        return { shortCircuited: true };
+      } else if (discoverResult.type === "error") {
+        let boundaryId = findNearestBoundary(discoverResult.partialMatches)
+          .route.id;
+        return {
+          matches: discoverResult.partialMatches,
+          loaderData: {},
+          errors: {
+            [boundaryId]: discoverResult.error,
+          },
+        };
+      } else if (!discoverResult.matches) {
+        let { error, notFoundMatches, route } = handleNavigational404(
+          location.pathname
+        );
+        return {
+          matches: notFoundMatches,
+          loaderData: {},
+          errors: {
+            [route.id]: error,
+          },
+        };
+      } else {
+        matches = discoverResult.matches;
+      }
+    }
+
+    let routesToUse = inFlightDataRoutes || dataRoutes;
+    let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(
+      init.history,
+      state,
+      matches,
+      activeSubmission,
+      location,
+      future.v7_partialHydration && initialHydration === true,
+      future.v7_skipActionErrorRevalidation,
+      isRevalidationRequired,
+      cancelledDeferredRoutes,
+      cancelledFetcherLoads,
+      deletedFetchers,
+      fetchLoadMatches,
+      fetchRedirectIds,
+      routesToUse,
+      basename,
+      pendingActionResult
+    );
+
+    // Cancel pending deferreds for no-longer-matched routes or routes we're
+    // about to reload.  Note that if this is an action reload we would have
+    // already cancelled all pending deferreds so this would be a no-op
+    cancelActiveDeferreds(
+      (routeId) =>
+        !(matches && matches.some((m) => m.route.id === routeId)) ||
+        (matchesToLoad && matchesToLoad.some((m) => m.route.id === routeId))
+    );
+
+    pendingNavigationLoadId = ++incrementingLoadId;
+
+    // Short circuit if we have no loaders to run
+    if (matchesToLoad.length === 0 && revalidatingFetchers.length === 0) {
+      let updatedFetchers = markFetchRedirectsDone();
+      completeNavigation(
+        location,
+        {
+          matches,
+          loaderData: {},
+          // Commit pending error if we're short circuiting
+          errors:
+            pendingActionResult && isErrorResult(pendingActionResult[1])
+              ? { [pendingActionResult[0]]: pendingActionResult[1].error }
+              : null,
+          ...getActionDataForCommit(pendingActionResult),
+          ...(updatedFetchers ? { fetchers: new Map(state.fetchers) } : {}),
+        },
+        { flushSync }
+      );
+      return { shortCircuited: true };
+    }
+
+    if (shouldUpdateNavigationState) {
+      let updates: Partial<RouterState> = {};
+      if (!isFogOfWar) {
+        // Only update navigation/actionNData if we didn't already do it above
+        updates.navigation = loadingNavigation;
+        let actionData = getUpdatedActionData(pendingActionResult);
+        if (actionData !== undefined) {
+          updates.actionData = actionData;
+        }
+      }
+      if (revalidatingFetchers.length > 0) {
+        updates.fetchers = getUpdatedRevalidatingFetchers(revalidatingFetchers);
+      }
+      updateState(updates, { flushSync });
+    }
+
+    revalidatingFetchers.forEach((rf) => {
+      abortFetcher(rf.key);
+      if (rf.controller) {
+        // Fetchers use an independent AbortController so that aborting a fetcher
+        // (via deleteFetcher) does not abort the triggering navigation that
+        // triggered the revalidation
+        fetchControllers.set(rf.key, rf.controller);
+      }
+    });
+
+    // Proxy navigation abort through to revalidation fetchers
+    let abortPendingFetchRevalidations = () =>
+      revalidatingFetchers.forEach((f) => abortFetcher(f.key));
+    if (pendingNavigationController) {
+      pendingNavigationController.signal.addEventListener(
+        "abort",
+        abortPendingFetchRevalidations
+      );
+    }
+
+    let { loaderResults, fetcherResults } =
+      await callLoadersAndMaybeResolveData(
+        state,
+        matches,
+        matchesToLoad,
+        revalidatingFetchers,
+        request
+      );
+
+    if (request.signal.aborted) {
+      return { shortCircuited: true };
+    }
+
+    // Clean up _after_ loaders have completed.  Don't clean up if we short
+    // circuited because fetchControllers would have been aborted and
+    // reassigned to new controllers for the next navigation
+    if (pendingNavigationController) {
+      pendingNavigationController.signal.removeEventListener(
+        "abort",
+        abortPendingFetchRevalidations
+      );
+    }
+
+    revalidatingFetchers.forEach((rf) => fetchControllers.delete(rf.key));
+
+    // If any loaders returned a redirect Response, start a new REPLACE navigation
+    let redirect = findRedirect(loaderResults);
+    if (redirect) {
+      await startRedirectNavigation(request, redirect.result, true, {
+        replace,
+      });
+      return { shortCircuited: true };
+    }
+
+    redirect = findRedirect(fetcherResults);
+    if (redirect) {
+      // If this redirect came from a fetcher make sure we mark it in
+      // fetchRedirectIds so it doesn't get revalidated on the next set of
+      // loader executions
+      fetchRedirectIds.add(redirect.key);
+      await startRedirectNavigation(request, redirect.result, true, {
+        replace,
+      });
+      return { shortCircuited: true };
+    }
+
+    // Process and commit output from loaders
+    let { loaderData, errors } = processLoaderData(
+      state,
+      matches,
+      loaderResults,
+      pendingActionResult,
+      revalidatingFetchers,
+      fetcherResults,
+      activeDeferreds
+    );
+
+    // Wire up subscribers to update loaderData as promises settle
+    activeDeferreds.forEach((deferredData, routeId) => {
+      deferredData.subscribe((aborted) => {
+        // Note: No need to updateState here since the TrackedPromise on
+        // loaderData is stable across resolve/reject
+        // Remove this instance if we were aborted or if promises have settled
+        if (aborted || deferredData.done) {
+          activeDeferreds.delete(routeId);
+        }
+      });
+    });
+
+    // Preserve SSR errors during partial hydration
+    if (future.v7_partialHydration && initialHydration && state.errors) {
+      errors = { ...state.errors, ...errors };
+    }
+
+    let updatedFetchers = markFetchRedirectsDone();
+    let didAbortFetchLoads = abortStaleFetchLoads(pendingNavigationLoadId);
+    let shouldUpdateFetchers =
+      updatedFetchers || didAbortFetchLoads || revalidatingFetchers.length > 0;
+
+    return {
+      matches,
+      loaderData,
+      errors,
+      ...(shouldUpdateFetchers ? { fetchers: new Map(state.fetchers) } : {}),
+    };
+  }
+
+  function getUpdatedActionData(
+    pendingActionResult: PendingActionResult | undefined
+  ): Record<string, RouteData> | null | undefined {
+    if (pendingActionResult && !isErrorResult(pendingActionResult[1])) {
+      // This is cast to `any` currently because `RouteData`uses any and it
+      // would be a breaking change to use any.
+      // TODO: v7 - change `RouteData` to use `unknown` instead of `any`
+      return {
+        [pendingActionResult[0]]: pendingActionResult[1].data as any,
+      };
+    } else if (state.actionData) {
+      if (Object.keys(state.actionData).length === 0) {
+        return null;
+      } else {
+        return state.actionData;
+      }
+    }
+  }
+
+  function getUpdatedRevalidatingFetchers(
+    revalidatingFetchers: RevalidatingFetcher[]
+  ) {
+    revalidatingFetchers.forEach((rf) => {
+      let fetcher = state.fetchers.get(rf.key);
+      let revalidatingFetcher = getLoadingFetcher(
+        undefined,
+        fetcher ? fetcher.data : undefined
+      );
+      state.fetchers.set(rf.key, revalidatingFetcher);
+    });
+    return new Map(state.fetchers);
+  }
+
+  // Trigger a fetcher load/submit for the given fetcher key
+  function fetch(
+    key: string,
+    routeId: string,
+    href: string | null,
+    opts?: RouterFetchOptions
+  ) {
+    if (isServer) {
+      throw new Error(
+        "router.fetch() was called during the server render, but it shouldn't be. " +
+          "You are likely calling a useFetcher() method in the body of your component. " +
+          "Try moving it to a useEffect or a callback."
+      );
+    }
+
+    abortFetcher(key);
+
+    let flushSync = (opts && opts.flushSync) === true;
+
+    let routesToUse = inFlightDataRoutes || dataRoutes;
+    let normalizedPath = normalizeTo(
+      state.location,
+      state.matches,
+      basename,
+      future.v7_prependBasename,
+      href,
+      future.v7_relativeSplatPath,
+      routeId,
+      opts?.relative
+    );
+    let matches = matchRoutes(routesToUse, normalizedPath, basename);
+
+    let fogOfWar = checkFogOfWar(matches, routesToUse, normalizedPath);
+    if (fogOfWar.active && fogOfWar.matches) {
+      matches = fogOfWar.matches;
+    }
+
+    if (!matches) {
+      setFetcherError(
+        key,
+        routeId,
+        getInternalRouterError(404, { pathname: normalizedPath }),
+        { flushSync }
+      );
+      return;
+    }
+
+    let { path, submission, error } = normalizeNavigateOptions(
+      future.v7_normalizeFormMethod,
+      true,
+      normalizedPath,
+      opts
+    );
+
+    if (error) {
+      setFetcherError(key, routeId, error, { flushSync });
+      return;
+    }
+
+    let match = getTargetMatch(matches, path);
+
+    let preventScrollReset = (opts && opts.preventScrollReset) === true;
+
+    if (submission && isMutationMethod(submission.formMethod)) {
+      handleFetcherAction(
+        key,
+        routeId,
+        path,
+        match,
+        matches,
+        fogOfWar.active,
+        flushSync,
+        preventScrollReset,
+        submission
+      );
+      return;
+    }
+
+    // Store off the match so we can call it's shouldRevalidate on subsequent
+    // revalidations
+    fetchLoadMatches.set(key, { routeId, path });
+    handleFetcherLoader(
+      key,
+      routeId,
+      path,
+      match,
+      matches,
+      fogOfWar.active,
+      flushSync,
+      preventScrollReset,
+      submission
+    );
+  }
+
+  // Call the action for the matched fetcher.submit(), and then handle redirects,
+  // errors, and revalidation
+  async function handleFetcherAction(
+    key: string,
+    routeId: string,
+    path: string,
+    match: AgnosticDataRouteMatch,
+    requestMatches: AgnosticDataRouteMatch[],
+    isFogOfWar: boolean,
+    flushSync: boolean,
+    preventScrollReset: boolean,
+    submission: Submission
+  ) {
+    interruptActiveLoads();
+    fetchLoadMatches.delete(key);
+
+    function detectAndHandle405Error(m: AgnosticDataRouteMatch) {
+      if (!m.route.action && !m.route.lazy) {
+        let error = getInternalRouterError(405, {
+          method: submission.formMethod,
+          pathname: path,
+          routeId: routeId,
+        });
+        setFetcherError(key, routeId, error, { flushSync });
+        return true;
+      }
+      return false;
+    }
+
+    if (!isFogOfWar && detectAndHandle405Error(match)) {
+      return;
+    }
+
+    // Put this fetcher into it's submitting state
+    let existingFetcher = state.fetchers.get(key);
+    updateFetcherState(key, getSubmittingFetcher(submission, existingFetcher), {
+      flushSync,
+    });
+
+    let abortController = new AbortController();
+    let fetchRequest = createClientSideRequest(
+      init.history,
+      path,
+      abortController.signal,
+      submission
+    );
+
+    if (isFogOfWar) {
+      let discoverResult = await discoverRoutes(
+        requestMatches,
+        new URL(fetchRequest.url).pathname,
+        fetchRequest.signal,
+        key
+      );
+
+      if (discoverResult.type === "aborted") {
+        return;
+      } else if (discoverResult.type === "error") {
+        setFetcherError(key, routeId, discoverResult.error, { flushSync });
+        return;
+      } else if (!discoverResult.matches) {
+        setFetcherError(
+          key,
+          routeId,
+          getInternalRouterError(404, { pathname: path }),
+          { flushSync }
+        );
+        return;
+      } else {
+        requestMatches = discoverResult.matches;
+        match = getTargetMatch(requestMatches, path);
+
+        if (detectAndHandle405Error(match)) {
+          return;
+        }
+      }
+    }
+
+    // Call the action for the fetcher
+    fetchControllers.set(key, abortController);
+
+    let originatingLoadId = incrementingLoadId;
+    let actionResults = await callDataStrategy(
+      "action",
+      state,
+      fetchRequest,
+      [match],
+      requestMatches,
+      key
+    );
+    let actionResult = actionResults[match.route.id];
+
+    if (fetchRequest.signal.aborted) {
+      // We can delete this so long as we weren't aborted by our own fetcher
+      // re-submit which would have put _new_ controller is in fetchControllers
+      if (fetchControllers.get(key) === abortController) {
+        fetchControllers.delete(key);
+      }
+      return;
+    }
+
+    // When using v7_fetcherPersist, we don't want errors bubbling up to the UI
+    // or redirects processed for unmounted fetchers so we just revert them to
+    // idle
+    if (future.v7_fetcherPersist && deletedFetchers.has(key)) {
+      if (isRedirectResult(actionResult) || isErrorResult(actionResult)) {
+        updateFetcherState(key, getDoneFetcher(undefined));
+        return;
+      }
+      // Let SuccessResult's fall through for revalidation
+    } else {
+      if (isRedirectResult(actionResult)) {
+        fetchControllers.delete(key);
+        if (pendingNavigationLoadId > originatingLoadId) {
+          // A new navigation was kicked off after our action started, so that
+          // should take precedence over this redirect navigation.  We already
+          // set isRevalidationRequired so all loaders for the new route should
+          // fire unless opted out via shouldRevalidate
+          updateFetcherState(key, getDoneFetcher(undefined));
+          return;
+        } else {
+          fetchRedirectIds.add(key);
+          updateFetcherState(key, getLoadingFetcher(submission));
+          return startRedirectNavigation(fetchRequest, actionResult, false, {
+            fetcherSubmission: submission,
+            preventScrollReset,
+          });
+        }
+      }
+
+      // Process any non-redirect errors thrown
+      if (isErrorResult(actionResult)) {
+        setFetcherError(key, routeId, actionResult.error);
+        return;
+      }
+    }
+
+    if (isDeferredResult(actionResult)) {
+      throw getInternalRouterError(400, { type: "defer-action" });
+    }
+
+    // Start the data load for current matches, or the next location if we're
+    // in the middle of a navigation
+    let nextLocation = state.navigation.location || state.location;
+    let revalidationRequest = createClientSideRequest(
+      init.history,
+      nextLocation,
+      abortController.signal
+    );
+    let routesToUse = inFlightDataRoutes || dataRoutes;
+    let matches =
+      state.navigation.state !== "idle"
+        ? matchRoutes(routesToUse, state.navigation.location, basename)
+        : state.matches;
+
+    invariant(matches, "Didn't find any matches after fetcher action");
+
+    let loadId = ++incrementingLoadId;
+    fetchReloadIds.set(key, loadId);
+
+    let loadFetcher = getLoadingFetcher(submission, actionResult.data);
+    state.fetchers.set(key, loadFetcher);
+
+    let [matchesToLoad, revalidatingFetchers] = getMatchesToLoad(
+      init.history,
+      state,
+      matches,
+      submission,
+      nextLocation,
+      false,
+      future.v7_skipActionErrorRevalidation,
+      isRevalidationRequired,
+      cancelledDeferredRoutes,
+      cancelledFetcherLoads,
+      deletedFetchers,
+      fetchLoadMatches,
+      fetchRedirectIds,
+      routesToUse,
+      basename,
+      [match.route.id, actionResult]
+    );
+
+    // Put all revalidating fetchers into the loading state, except for the
+    // current fetcher which we want to keep in it's current loading state which
+    // contains it's action submission info + action data
+    revalidatingFetchers
+      .filter((rf) => rf.key !== key)
+      .forEach((rf) => {
+        let staleKey = rf.key;
+        let existingFetcher = state.fetchers.get(staleKey);
+        let revalidatingFetcher = getLoadingFetcher(
+          undefined,
+          existingFetcher ? existingFetcher.data : undefined
+        );
+        state.fetchers.set(staleKey, revalidatingFetcher);
+        abortFetcher(staleKey);
+        if (rf.controller) {
+          fetchControllers.set(staleKey, rf.controller);
+        }
+      });
+
+    updateState({ fetchers: new Map(state.fetchers) });
+
+    let abortPendingFetchRevalidations = () =>
+      revalidatingFetchers.forEach((rf) => abortFetcher(rf.key));
+
+    abortController.signal.addEventListener(
+      "abort",
+      abortPendingFetchRevalidations
+    );
+
+    let { loaderResults, fetcherResults } =
+      await callLoadersAndMaybeResolveData(
+        state,
+        matches,
+        matchesToLoad,
+        revalidatingFetchers,
+        revalidationRequest
+      );
+
+    if (abortController.signal.aborted) {
+      return;
+    }
+
+    abortController.signal.removeEventListener(
+      "abort",
+      abortPendingFetchRevalidations
+    );
+
+    fetchReloadIds.delete(key);
+    fetchControllers.delete(key);
+    revalidatingFetchers.forEach((r) => fetchControllers.delete(r.key));
+
+    let redirect = findRedirect(loaderResults);
+    if (redirect) {
+      return startRedirectNavigation(
+        revalidationRequest,
+        redirect.result,
+        false,
+        { preventScrollReset }
+      );
+    }
+
+    redirect = findRedirect(fetcherResults);
+    if (redirect) {
+      // If this redirect came from a fetcher make sure we mark it in
+      // fetchRedirectIds so it doesn't get revalidated on the next set of
+      // loader executions
+      fetchRedirectIds.add(redirect.key);
+      return startRedirectNavigation(
+        revalidationRequest,
+        redirect.result,
+        false,
+        { preventScrollReset }
+      );
+    }
+
+    // Process and commit output from loaders
+    let { loaderData, errors } = processLoaderData(
+      state,
+      matches,
+      loaderResults,
+      undefined,
+      revalidatingFetchers,
+      fetcherResults,
+      activeDeferreds
+    );
+
+    // Since we let revalidations complete even if the submitting fetcher was
+    // deleted, only put it back to idle if it hasn't been deleted
+    if (state.fetchers.has(key)) {
+      let doneFetcher = getDoneFetcher(actionResult.data);
+      state.fetchers.set(key, doneFetcher);
+    }
+
+    abortStaleFetchLoads(loadId);
+
+    // If we are currently in a navigation loading state and this fetcher is
+    // more recent than the navigation, we want the newer data so abort the
+    // navigation and complete it with the fetcher data
+    if (
+      state.navigation.state === "loading" &&
+      loadId > pendingNavigationLoadId
+    ) {
+      invariant(pendingAction, "Expected pending action");
+      pendingNavigationController && pendingNavigationController.abort();
+
+      completeNavigation(state.navigation.location, {
+        matches,
+        loaderData,
+        errors,
+        fetchers: new Map(state.fetchers),
+      });
+    } else {
+      // otherwise just update with the fetcher data, preserving any existing
+      // loaderData for loaders that did not need to reload.  We have to
+      // manually merge here since we aren't going through completeNavigation
+      updateState({
+        errors,
+        loaderData: mergeLoaderData(
+          state.loaderData,
+          loaderData,
+          matches,
+          errors
+        ),
+        fetchers: new Map(state.fetchers),
+      });
+      isRevalidationRequired = false;
+    }
+  }
+
+  // Call the matched loader for fetcher.load(), handling redirects, errors, etc.
+  async function handleFetcherLoader(
+    key: string,
+    routeId: string,
+    path: string,
+    match: AgnosticDataRouteMatch,
+    matches: AgnosticDataRouteMatch[],
+    isFogOfWar: boolean,
+    flushSync: boolean,
+    preventScrollReset: boolean,
+    submission?: Submission
+  ) {
+    let existingFetcher = state.fetchers.get(key);
+    updateFetcherState(
+      key,
+      getLoadingFetcher(
+        submission,
+        existingFetcher ? existingFetcher.data : undefined
+      ),
+      { flushSync }
+    );
+
+    let abortController = new AbortController();
+    let fetchRequest = createClientSideRequest(
+      init.history,
+      path,
+      abortController.signal
+    );
+
+    if (isFogOfWar) {
+      let discoverResult = await discoverRoutes(
+        matches,
+        new URL(fetchRequest.url).pathname,
+        fetchRequest.signal,
+        key
+      );
+
+      if (discoverResult.type === "aborted") {
+        return;
+      } else if (discoverResult.type === "error") {
+        setFetcherError(key, routeId, discoverResult.error, { flushSync });
+        return;
+      } else if (!discoverResult.matches) {
+        setFetcherError(
+          key,
+          routeId,
+          getInternalRouterError(404, { pathname: path }),
+          { flushSync }
+        );
+        return;
+      } else {
+        matches = discoverResult.matches;
+        match = getTargetMatch(matches, path);
+      }
+    }
+
+    // Call the loader for this fetcher route match
+    fetchControllers.set(key, abortController);
+
+    let originatingLoadId = incrementingLoadId;
+    let results = await callDataStrategy(
+      "loader",
+      state,
+      fetchRequest,
+      [match],
+      matches,
+      key
+    );
+    let result = results[match.route.id];
+
+    // Deferred isn't supported for fetcher loads, await everything and treat it
+    // as a normal load.  resolveDeferredData will return undefined if this
+    // fetcher gets aborted, so we just leave result untouched and short circuit
+    // below if that happens
+    if (isDeferredResult(result)) {
+      result =
+        (await resolveDeferredData(result, fetchRequest.signal, true)) ||
+        result;
+    }
+
+    // We can delete this so long as we weren't aborted by our our own fetcher
+    // re-load which would have put _new_ controller is in fetchControllers
+    if (fetchControllers.get(key) === abortController) {
+      fetchControllers.delete(key);
+    }
+
+    if (fetchRequest.signal.aborted) {
+      return;
+    }
+
+    // We don't want errors bubbling up or redirects followed for unmounted
+    // fetchers, so short circuit here if it was removed from the UI
+    if (deletedFetchers.has(key)) {
+      updateFetcherState(key, getDoneFetcher(undefined));
+      return;
+    }
+
+    // If the loader threw a redirect Response, start a new REPLACE navigation
+    if (isRedirectResult(result)) {
+      if (pendingNavigationLoadId > originatingLoadId) {
+        // A new navigation was kicked off after our loader started, so that
+        // should take precedence over this redirect navigation
+        updateFetcherState(key, getDoneFetcher(undefined));
+        return;
+      } else {
+        fetchRedirectIds.add(key);
+        await startRedirectNavigation(fetchRequest, result, false, {
+          preventScrollReset,
+        });
+        return;
+      }
+    }
+
+    // Process any non-redirect errors thrown
+    if (isErrorResult(result)) {
+      setFetcherError(key, routeId, result.error);
+      return;
+    }
+
+    invariant(!isDeferredResult(result), "Unhandled fetcher deferred data");
+
+    // Put the fetcher back into an idle state
+    updateFetcherState(key, getDoneFetcher(result.data));
+  }
+
+  /**
+   * Utility function to handle redirects returned from an action or loader.
+   * Normally, a redirect "replaces" the navigation that triggered it.  So, for
+   * example:
+   *
+   *  - user is on /a
+   *  - user clicks a link to /b
+   *  - loader for /b redirects to /c
+   *
+   * In a non-JS app the browser would track the in-flight navigation to /b and
+   * then replace it with /c when it encountered the redirect response.  In
+   * the end it would only ever update the URL bar with /c.
+   *
+   * In client-side routing using pushState/replaceState, we aim to emulate
+   * this behavior and we also do not update history until the end of the
+   * navigation (including processed redirects).  This means that we never
+   * actually touch history until we've processed redirects, so we just use
+   * the history action from the original navigation (PUSH or REPLACE).
+   */
+  async function startRedirectNavigation(
+    request: Request,
+    redirect: RedirectResult,
+    isNavigation: boolean,
+    {
+      submission,
+      fetcherSubmission,
+      preventScrollReset,
+      replace,
+    }: {
+      submission?: Submission;
+      fetcherSubmission?: Submission;
+      preventScrollReset?: boolean;
+      replace?: boolean;
+    } = {}
+  ) {
+    if (redirect.response.headers.has("X-Remix-Revalidate")) {
+      isRevalidationRequired = true;
+    }
+
+    let location = redirect.response.headers.get("Location");
+    invariant(location, "Expected a Location header on the redirect Response");
+    location = normalizeRedirectLocation(
+      location,
+      new URL(request.url),
+      basename,
+      init.history,
+    );
+    let redirectLocation = createLocation(state.location, location, {
+      _isRedirect: true,
+    });
+
+    if (isBrowser) {
+      let isDocumentReload = false;
+
+      if (redirect.response.headers.has("X-Remix-Reload-Document")) {
+        // Hard reload if the response contained X-Remix-Reload-Document
+        isDocumentReload = true;
+      } else if (ABSOLUTE_URL_REGEX.test(location)) {
+        const url = init.history.createURL(location);
+        isDocumentReload =
+          // Hard reload if it's an absolute URL to a new origin
+          url.origin !== routerWindow.location.origin ||
+          // Hard reload if it's an absolute URL that does not match our basename
+          stripBasename(url.pathname, basename) == null;
+      }
+
+      if (isDocumentReload) {
+        if (replace) {
+          routerWindow.location.replace(location);
+        } else {
+          routerWindow.location.assign(location);
+        }
+        return;
+      }
+    }
+
+    // There's no need to abort on redirects, since we don't detect the
+    // redirect until the action/loaders have settled
+    pendingNavigationController = null;
+
+    let redirectHistoryAction =
+      replace === true || redirect.response.headers.has("X-Remix-Replace")
+        ? HistoryAction.Replace
+        : HistoryAction.Push;
+
+    // Use the incoming submission if provided, fallback on the active one in
+    // state.navigation
+    let { formMethod, formAction, formEncType } = state.navigation;
+    if (
+      !submission &&
+      !fetcherSubmission &&
+      formMethod &&
+      formAction &&
+      formEncType
+    ) {
+      submission = getSubmissionFromNavigation(state.navigation);
+    }
+
+    // If this was a 307/308 submission we want to preserve the HTTP method and
+    // re-submit the GET/POST/PUT/PATCH/DELETE as a submission navigation to the
+    // redirected location
+    let activeSubmission = submission || fetcherSubmission;
+    if (
+      redirectPreserveMethodStatusCodes.has(redirect.response.status) &&
+      activeSubmission &&
+      isMutationMethod(activeSubmission.formMethod)
+    ) {
+      await startNavigation(redirectHistoryAction, redirectLocation, {
+        submission: {
+          ...activeSubmission,
+          formAction: location,
+        },
+        // Preserve these flags across redirects
+        preventScrollReset: preventScrollReset || pendingPreventScrollReset,
+        enableViewTransition: isNavigation
+          ? pendingViewTransitionEnabled
+          : undefined,
+      });
+    } else {
+      // If we have a navigation submission, we will preserve it through the
+      // redirect navigation
+      let overrideNavigation = getLoadingNavigation(
+        redirectLocation,
+        submission
+      );
+      await startNavigation(redirectHistoryAction, redirectLocation, {
+        overrideNavigation,
+        // Send fetcher submissions through for shouldRevalidate
+        fetcherSubmission,
+        // Preserve these flags across redirects
+        preventScrollReset: preventScrollReset || pendingPreventScrollReset,
+        enableViewTransition: isNavigation
+          ? pendingViewTransitionEnabled
+          : undefined,
+      });
+    }
+  }
+
+  // Utility wrapper for calling dataStrategy client-side without having to
+  // pass around the manifest, mapRouteProperties, etc.
+  async function callDataStrategy(
+    type: "loader" | "action",
+    state: RouterState,
+    request: Request,
+    matchesToLoad: AgnosticDataRouteMatch[],
+    matches: AgnosticDataRouteMatch[],
+    fetcherKey: string | null
+  ): Promise<Record<string, DataResult>> {
+    let results: Record<string, DataStrategyResult>;
+    let dataResults: Record<string, DataResult> = {};
+    try {
+      results = await callDataStrategyImpl(
+        dataStrategyImpl,
+        type,
+        state,
+        request,
+        matchesToLoad,
+        matches,
+        fetcherKey,
+        manifest,
+        mapRouteProperties
+      );
+    } catch (e) {
+      // If the outer dataStrategy method throws, just return the error for all
+      // matches - and it'll naturally bubble to the root
+      matchesToLoad.forEach((m) => {
+        dataResults[m.route.id] = {
+          type: ResultType.error,
+          error: e,
+        };
+      });
+      return dataResults;
+    }
+
+    for (let [routeId, result] of Object.entries(results)) {
+      if (isRedirectDataStrategyResultResult(result)) {
+        let response = result.result as Response;
+        dataResults[routeId] = {
+          type: ResultType.redirect,
+          response: normalizeRelativeRoutingRedirectResponse(
+            response,
+            request,
+            routeId,
+            matches,
+            basename,
+            future.v7_relativeSplatPath
+          ),
+        };
+      } else {
+        dataResults[routeId] = await convertDataStrategyResultToDataResult(
+          result
+        );
+      }
+    }
+
+    return dataResults;
+  }
+
+  async function callLoadersAndMaybeResolveData(
+    state: RouterState,
+    matches: AgnosticDataRouteMatch[],
+    matchesToLoad: AgnosticDataRouteMatch[],
+    fetchersToLoad: RevalidatingFetcher[],
+    request: Request
+  ) {
+    let currentMatches = state.matches;
+
+    // Kick off loaders and fetchers in parallel
+    let loaderResultsPromise = callDataStrategy(
+      "loader",
+      state,
+      request,
+      matchesToLoad,
+      matches,
+      null
+    );
+
+    let fetcherResultsPromise = Promise.all(
+      fetchersToLoad.map(async (f) => {
+        if (f.matches && f.match && f.controller) {
+          let results = await callDataStrategy(
+            "loader",
+            state,
+            createClientSideRequest(init.history, f.path, f.controller.signal),
+            [f.match],
+            f.matches,
+            f.key
+          );
+          let result = results[f.match.route.id];
+          // Fetcher results are keyed by fetcher key from here on out, not routeId
+          return { [f.key]: result };
+        } else {
+          return Promise.resolve({
+            [f.key]: {
+              type: ResultType.error,
+              error: getInternalRouterError(404, {
+                pathname: f.path,
+              }),
+            } as ErrorResult,
+          });
+        }
+      })
+    );
+
+    let loaderResults = await loaderResultsPromise;
+    let fetcherResults = (await fetcherResultsPromise).reduce(
+      (acc, r) => Object.assign(acc, r),
+      {}
+    );
+
+    await Promise.all([
+      resolveNavigationDeferredResults(
+        matches,
+        loaderResults,
+        request.signal,
+        currentMatches,
+        state.loaderData
+      ),
+      resolveFetcherDeferredResults(matches, fetcherResults, fetchersToLoad),
+    ]);
+
+    return {
+      loaderResults,
+      fetcherResults,
+    };
+  }
+
+  function interruptActiveLoads() {
+    // Every interruption triggers a revalidation
+    isRevalidationRequired = true;
+
+    // Cancel pending route-level deferreds and mark cancelled routes for
+    // revalidation
+    cancelledDeferredRoutes.push(...cancelActiveDeferreds());
+
+    // Abort in-flight fetcher loads
+    fetchLoadMatches.forEach((_, key) => {
+      if (fetchControllers.has(key)) {
+        cancelledFetcherLoads.add(key);
+      }
+      abortFetcher(key);
+    });
+  }
+
+  function updateFetcherState(
+    key: string,
+    fetcher: Fetcher,
+    opts: { flushSync?: boolean } = {}
+  ) {
+    state.fetchers.set(key, fetcher);
+    updateState(
+      { fetchers: new Map(state.fetchers) },
+      { flushSync: (opts && opts.flushSync) === true }
+    );
+  }
+
+  function setFetcherError(
+    key: string,
+    routeId: string,
+    error: any,
+    opts: { flushSync?: boolean } = {}
+  ) {
+    let boundaryMatch = findNearestBoundary(state.matches, routeId);
+    deleteFetcher(key);
+    updateState(
+      {
+        errors: {
+          [boundaryMatch.route.id]: error,
+        },
+        fetchers: new Map(state.fetchers),
+      },
+      { flushSync: (opts && opts.flushSync) === true }
+    );
+  }
+
+  function getFetcher<TData = any>(key: string): Fetcher<TData> {
+    activeFetchers.set(key, (activeFetchers.get(key) || 0) + 1);
+    // If this fetcher was previously marked for deletion, unmark it since we
+    // have a new instance
+    if (deletedFetchers.has(key)) {
+      deletedFetchers.delete(key);
+    }
+    return state.fetchers.get(key) || IDLE_FETCHER;
+  }
+
+  function deleteFetcher(key: string): void {
+    let fetcher = state.fetchers.get(key);
+    // Don't abort the controller if this is a deletion of a fetcher.submit()
+    // in it's loading phase since - we don't want to abort the corresponding
+    // revalidation and want them to complete and land
+    if (
+      fetchControllers.has(key) &&
+      !(fetcher && fetcher.state === "loading" && fetchReloadIds.has(key))
+    ) {
+      abortFetcher(key);
+    }
+    fetchLoadMatches.delete(key);
+    fetchReloadIds.delete(key);
+    fetchRedirectIds.delete(key);
+
+    // If we opted into the flag we can clear this now since we're calling
+    // deleteFetcher() at the end of updateState() and we've already handed the
+    // deleted fetcher keys off to the data layer.
+    // If not, we're eagerly calling deleteFetcher() and we need to keep this
+    // Set populated until the next updateState call, and we'll clear
+    // `deletedFetchers` then
+    if (future.v7_fetcherPersist) {
+      deletedFetchers.delete(key);
+    }
+
+    cancelledFetcherLoads.delete(key);
+    state.fetchers.delete(key);
+  }
+
+  function deleteFetcherAndUpdateState(key: string): void {
+    let count = (activeFetchers.get(key) || 0) - 1;
+    if (count <= 0) {
+      activeFetchers.delete(key);
+      deletedFetchers.add(key);
+      if (!future.v7_fetcherPersist) {
+        deleteFetcher(key);
+      }
+    } else {
+      activeFetchers.set(key, count);
+    }
+
+    updateState({ fetchers: new Map(state.fetchers) });
+  }
+
+  function abortFetcher(key: string) {
+    let controller = fetchControllers.get(key);
+    if (controller) {
+      controller.abort();
+      fetchControllers.delete(key);
+    }
+  }
+
+  function markFetchersDone(keys: string[]) {
+    for (let key of keys) {
+      let fetcher = getFetcher(key);
+      let doneFetcher = getDoneFetcher(fetcher.data);
+      state.fetchers.set(key, doneFetcher);
+    }
+  }
+
+  function markFetchRedirectsDone(): boolean {
+    let doneKeys = [];
+    let updatedFetchers = false;
+    for (let key of fetchRedirectIds) {
+      let fetcher = state.fetchers.get(key);
+      invariant(fetcher, `Expected fetcher: ${key}`);
+      if (fetcher.state === "loading") {
+        fetchRedirectIds.delete(key);
+        doneKeys.push(key);
+        updatedFetchers = true;
+      }
+    }
+    markFetchersDone(doneKeys);
+    return updatedFetchers;
+  }
+
+  function abortStaleFetchLoads(landedId: number): boolean {
+    let yeetedKeys = [];
+    for (let [key, id] of fetchReloadIds) {
+      if (id < landedId) {
+        let fetcher = state.fetchers.get(key);
+        invariant(fetcher, `Expected fetcher: ${key}`);
+        if (fetcher.state === "loading") {
+          abortFetcher(key);
+          fetchReloadIds.delete(key);
+          yeetedKeys.push(key);
+        }
+      }
+    }
+    markFetchersDone(yeetedKeys);
+    return yeetedKeys.length > 0;
+  }
+
+  function getBlocker(key: string, fn: BlockerFunction) {
+    let blocker: Blocker = state.blockers.get(key) || IDLE_BLOCKER;
+
+    if (blockerFunctions.get(key) !== fn) {
+      blockerFunctions.set(key, fn);
+    }
+
+    return blocker;
+  }
+
+  function deleteBlocker(key: string) {
+    state.blockers.delete(key);
+    blockerFunctions.delete(key);
+  }
+
+  // Utility function to update blockers, ensuring valid state transitions
+  function updateBlocker(key: string, newBlocker: Blocker) {
+    let blocker = state.blockers.get(key) || IDLE_BLOCKER;
+
+    // Poor mans state machine :)
+    // https://mermaid.live/edit#pako:eNqVkc9OwzAMxl8l8nnjAYrEtDIOHEBIgwvKJTReGy3_lDpIqO27k6awMG0XcrLlnz87nwdonESogKXXBuE79rq75XZO3-yHds0RJVuv70YrPlUrCEe2HfrORS3rubqZfuhtpg5C9wk5tZ4VKcRUq88q9Z8RS0-48cE1iHJkL0ugbHuFLus9L6spZy8nX9MP2CNdomVaposqu3fGayT8T8-jJQwhepo_UtpgBQaDEUom04dZhAN1aJBDlUKJBxE1ceB2Smj0Mln-IBW5AFU2dwUiktt_2Qaq2dBfaKdEup85UV7Yd-dKjlnkabl2Pvr0DTkTreM
+    invariant(
+      (blocker.state === "unblocked" && newBlocker.state === "blocked") ||
+        (blocker.state === "blocked" && newBlocker.state === "blocked") ||
+        (blocker.state === "blocked" && newBlocker.state === "proceeding") ||
+        (blocker.state === "blocked" && newBlocker.state === "unblocked") ||
+        (blocker.state === "proceeding" && newBlocker.state === "unblocked"),
+      `Invalid blocker state transition: ${blocker.state} -> ${newBlocker.state}`
+    );
+
+    let blockers = new Map(state.blockers);
+    blockers.set(key, newBlocker);
+    updateState({ blockers });
+  }
+
+  function shouldBlockNavigation({
+    currentLocation,
+    nextLocation,
+    historyAction,
+  }: {
+    currentLocation: Location;
+    nextLocation: Location;
+    historyAction: HistoryAction;
+  }): string | undefined {
+    if (blockerFunctions.size === 0) {
+      return;
+    }
+
+    // We ony support a single active blocker at the moment since we don't have
+    // any compelling use cases for multi-blocker yet
+    if (blockerFunctions.size > 1) {
+      warning(false, "A router only supports one blocker at a time");
+    }
+
+    let entries = Array.from(blockerFunctions.entries());
+    let [blockerKey, blockerFunction] = entries[entries.length - 1];
+    let blocker = state.blockers.get(blockerKey);
+
+    if (blocker && blocker.state === "proceeding") {
+      // If the blocker is currently proceeding, we don't need to re-check
+      // it and can let this navigation continue
+      return;
+    }
+
+    // At this point, we know we're unblocked/blocked so we need to check the
+    // user-provided blocker function
+    if (blockerFunction({ currentLocation, nextLocation, historyAction })) {
+      return blockerKey;
+    }
+  }
+
+  function handleNavigational404(pathname: string) {
+    let error = getInternalRouterError(404, { pathname });
+    let routesToUse = inFlightDataRoutes || dataRoutes;
+    let { matches, route } = getShortCircuitMatches(routesToUse);
+
+    // Cancel all pending deferred on 404s since we don't keep any routes
+    cancelActiveDeferreds();
+
+    return { notFoundMatches: matches, route, error };
+  }
+
+  function cancelActiveDeferreds(
+    predicate?: (routeId: string) => boolean
+  ): string[] {
+    let cancelledRouteIds: string[] = [];
+    activeDeferreds.forEach((dfd, routeId) => {
+      if (!predicate || predicate(routeId)) {
+        // Cancel the deferred - but do not remove from activeDeferreds here -
+        // we rely on the subscribers to do that so our tests can assert proper
+        // cleanup via _internalActiveDeferreds
+        dfd.cancel();
+        cancelledRouteIds.push(routeId);
+        activeDeferreds.delete(routeId);
+      }
+    });
+    return cancelledRouteIds;
+  }
+
+  // Opt in to capturing and reporting scroll positions during navigations,
+  // used by the <ScrollRestoration> component
+  function enableScrollRestoration(
+    positions: Record<string, number>,
+    getPosition: GetScrollPositionFunction,
+    getKey?: GetScrollRestorationKeyFunction
+  ) {
+    savedScrollPositions = positions;
+    getScrollPosition = getPosition;
+    getScrollRestorationKey = getKey || null;
+
+    // Perform initial hydration scroll restoration, since we miss the boat on
+    // the initial updateState() because we've not yet rendered <ScrollRestoration/>
+    // and therefore have no savedScrollPositions available
+    if (!initialScrollRestored && state.navigation === IDLE_NAVIGATION) {
+      initialScrollRestored = true;
+      let y = getSavedScrollPosition(state.location, state.matches);
+      if (y != null) {
+        updateState({ restoreScrollPosition: y });
+      }
+    }
+
+    return () => {
+      savedScrollPositions = null;
+      getScrollPosition = null;
+      getScrollRestorationKey = null;
+    };
+  }
+
+  function getScrollKey(location: Location, matches: AgnosticDataRouteMatch[]) {
+    if (getScrollRestorationKey) {
+      let key = getScrollRestorationKey(
+        location,
+        matches.map((m) => convertRouteMatchToUiMatch(m, state.loaderData))
+      );
+      return key || location.key;
+    }
+    return location.key;
+  }
+
+  function saveScrollPosition(
+    location: Location,
+    matches: AgnosticDataRouteMatch[]
+  ): void {
+    if (savedScrollPositions && getScrollPosition) {
+      let key = getScrollKey(location, matches);
+      savedScrollPositions[key] = getScrollPosition();
+    }
+  }
+
+  function getSavedScrollPosition(
+    location: Location,
+    matches: AgnosticDataRouteMatch[]
+  ): number | null {
+    if (savedScrollPositions) {
+      let key = getScrollKey(location, matches);
+      let y = savedScrollPositions[key];
+      if (typeof y === "number") {
+        return y;
+      }
+    }
+    return null;
+  }
+
+  function checkFogOfWar(
+    matches: AgnosticDataRouteMatch[] | null,
+    routesToUse: AgnosticDataRouteObject[],
+    pathname: string
+  ): { active: boolean; matches: AgnosticDataRouteMatch[] | null } {
+    if (patchRoutesOnNavigationImpl) {
+      if (!matches) {
+        let fogMatches = matchRoutesImpl<AgnosticDataRouteObject>(
+          routesToUse,
+          pathname,
+          basename,
+          true
+        );
+
+        return { active: true, matches: fogMatches || [] };
+      } else {
+        if (Object.keys(matches[0].params).length > 0) {
+          // If we matched a dynamic param or a splat, it might only be because
+          // we haven't yet discovered other routes that would match with a
+          // higher score.  Call patchRoutesOnNavigation just to be sure
+          let partialMatches = matchRoutesImpl<AgnosticDataRouteObject>(
+            routesToUse,
+            pathname,
+            basename,
+            true
+          );
+          return { active: true, matches: partialMatches };
+        }
+      }
+    }
+
+    return { active: false, matches: null };
+  }
+
+  type DiscoverRoutesSuccessResult = {
+    type: "success";
+    matches: AgnosticDataRouteMatch[] | null;
+  };
+  type DiscoverRoutesErrorResult = {
+    type: "error";
+    error: any;
+    partialMatches: AgnosticDataRouteMatch[];
+  };
+  type DiscoverRoutesAbortedResult = { type: "aborted" };
+  type DiscoverRoutesResult =
+    | DiscoverRoutesSuccessResult
+    | DiscoverRoutesErrorResult
+    | DiscoverRoutesAbortedResult;
+
+  async function discoverRoutes(
+    matches: AgnosticDataRouteMatch[],
+    pathname: string,
+    signal: AbortSignal,
+    fetcherKey?: string
+  ): Promise<DiscoverRoutesResult> {
+    if (!patchRoutesOnNavigationImpl) {
+      return { type: "success", matches };
+    }
+
+    let partialMatches: AgnosticDataRouteMatch[] | null = matches;
+    while (true) {
+      let isNonHMR = inFlightDataRoutes == null;
+      let routesToUse = inFlightDataRoutes || dataRoutes;
+      let localManifest = manifest;
+      try {
+        await patchRoutesOnNavigationImpl({
+          signal,
+          path: pathname,
+          matches: partialMatches,
+          fetcherKey,
+          patch: (routeId, children) => {
+            if (signal.aborted) return;
+            patchRoutesImpl(
+              routeId,
+              children,
+              routesToUse,
+              localManifest,
+              mapRouteProperties
+            );
+          },
+        });
+      } catch (e) {
+        return { type: "error", error: e, partialMatches };
+      } finally {
+        // If we are not in the middle of an HMR revalidation and we changed the
+        // routes, provide a new identity so when we `updateState` at the end of
+        // this navigation/fetch `router.routes` will be a new identity and
+        // trigger a re-run of memoized `router.routes` dependencies.
+        // HMR will already update the identity and reflow when it lands
+        // `inFlightDataRoutes` in `completeNavigation`
+        if (isNonHMR && !signal.aborted) {
+          dataRoutes = [...dataRoutes];
+        }
+      }
+
+      if (signal.aborted) {
+        return { type: "aborted" };
+      }
+
+      let newMatches = matchRoutes(routesToUse, pathname, basename);
+      if (newMatches) {
+        return { type: "success", matches: newMatches };
+      }
+
+      let newPartialMatches = matchRoutesImpl<AgnosticDataRouteObject>(
+        routesToUse,
+        pathname,
+        basename,
+        true
+      );
+
+      // Avoid loops if the second pass results in the same partial matches
+      if (
+        !newPartialMatches ||
+        (partialMatches.length === newPartialMatches.length &&
+          partialMatches.every(
+            (m, i) => m.route.id === newPartialMatches![i].route.id
+          ))
+      ) {
+        return { type: "success", matches: null };
+      }
+
+      partialMatches = newPartialMatches;
+    }
+  }
+
+  function _internalSetRoutes(newRoutes: AgnosticDataRouteObject[]) {
+    manifest = {};
+    inFlightDataRoutes = convertRoutesToDataRoutes(
+      newRoutes,
+      mapRouteProperties,
+      undefined,
+      manifest
+    );
+  }
+
+  function patchRoutes(
+    routeId: string | null,
+    children: AgnosticRouteObject[]
+  ): void {
+    let isNonHMR = inFlightDataRoutes == null;
+    let routesToUse = inFlightDataRoutes || dataRoutes;
+    patchRoutesImpl(
+      routeId,
+      children,
+      routesToUse,
+      manifest,
+      mapRouteProperties
+    );
+
+    // If we are not in the middle of an HMR revalidation and we changed the
+    // routes, provide a new identity and trigger a reflow via `updateState`
+    // to re-run memoized `router.routes` dependencies.
+    // HMR will already update the identity and reflow when it lands
+    // `inFlightDataRoutes` in `completeNavigation`
+    if (isNonHMR) {
+      dataRoutes = [...dataRoutes];
+      updateState({});
+    }
+  }
+
+  router = {
+    get basename() {
+      return basename;
+    },
+    get future() {
+      return future;
+    },
+    get state() {
+      return state;
+    },
+    get routes() {
+      return dataRoutes;
+    },
+    get window() {
+      return routerWindow;
+    },
+    initialize,
+    subscribe,
+    enableScrollRestoration,
+    navigate,
+    fetch,
+    revalidate,
+    // Passthrough to history-aware createHref used by useHref so we get proper
+    // hash-aware URLs in DOM paths
+    createHref: (to: To) => init.history.createHref(to),
+    encodeLocation: (to: To) => init.history.encodeLocation(to),
+    getFetcher,
+    deleteFetcher: deleteFetcherAndUpdateState,
+    dispose,
+    getBlocker,
+    deleteBlocker,
+    patchRoutes,
+    _internalFetchControllers: fetchControllers,
+    _internalActiveDeferreds: activeDeferreds,
+    // TODO: Remove setRoutes, it's temporary to avoid dealing with
+    // updating the tree while validating the update algorithm.
+    _internalSetRoutes,
+  };
+
+  return router;
+}
+//#endregion
+
+////////////////////////////////////////////////////////////////////////////////
+//#region createStaticHandler
+////////////////////////////////////////////////////////////////////////////////
+
+export const UNSAFE_DEFERRED_SYMBOL = Symbol("deferred");
+
+/**
+ * Future flags to toggle new feature behavior
+ */
+export interface StaticHandlerFutureConfig {
+  v7_relativeSplatPath: boolean;
+  v7_throwAbortReason: boolean;
+}
+
+export interface CreateStaticHandlerOptions {
+  basename?: string;
+  /**
+   * @deprecated Use `mapRouteProperties` instead
+   */
+  detectErrorBoundary?: DetectErrorBoundaryFunction;
+  mapRouteProperties?: MapRoutePropertiesFunction;
+  future?: Partial<StaticHandlerFutureConfig>;
+}
+
+export function createStaticHandler(
+  routes: AgnosticRouteObject[],
+  opts?: CreateStaticHandlerOptions
+): StaticHandler {
+  invariant(
+    routes.length > 0,
+    "You must provide a non-empty routes array to createStaticHandler"
+  );
+
+  let manifest: RouteManifest = {};
+  let basename = (opts ? opts.basename : null) || "/";
+  let mapRouteProperties: MapRoutePropertiesFunction;
+  if (opts?.mapRouteProperties) {
+    mapRouteProperties = opts.mapRouteProperties;
+  } else if (opts?.detectErrorBoundary) {
+    // If they are still using the deprecated version, wrap it with the new API
+    let detectErrorBoundary = opts.detectErrorBoundary;
+    mapRouteProperties = (route) => ({
+      hasErrorBoundary: detectErrorBoundary(route),
+    });
+  } else {
+    mapRouteProperties = defaultMapRouteProperties;
+  }
+  // Config driven behavior flags
+  let future: StaticHandlerFutureConfig = {
+    v7_relativeSplatPath: false,
+    v7_throwAbortReason: false,
+    ...(opts ? opts.future : null),
+  };
+
+  let dataRoutes = convertRoutesToDataRoutes(
+    routes,
+    mapRouteProperties,
+    undefined,
+    manifest
+  );
+
+  /**
+   * The query() method is intended for document requests, in which we want to
+   * call an optional action and potentially multiple loaders for all nested
+   * routes.  It returns a StaticHandlerContext object, which is very similar
+   * to the router state (location, loaderData, actionData, errors, etc.) and
+   * also adds SSR-specific information such as the statusCode and headers
+   * from action/loaders Responses.
+   *
+   * It _should_ never throw and should report all errors through the
+   * returned context.errors object, properly associating errors to their error
+   * boundary.  Additionally, it tracks _deepestRenderedBoundaryId which can be
+   * used to emulate React error boundaries during SSr by performing a second
+   * pass only down to the boundaryId.
+   *
+   * The one exception where we do not return a StaticHandlerContext is when a
+   * redirect response is returned or thrown from any action/loader.  We
+   * propagate that out and return the raw Response so the HTTP server can
+   * return it directly.
+   *
+   * - `opts.requestContext` is an optional server context that will be passed
+   *   to actions/loaders in the `context` parameter
+   * - `opts.skipLoaderErrorBubbling` is an optional parameter that will prevent
+   *   the bubbling of errors which allows single-fetch-type implementations
+   *   where the client will handle the bubbling and we may need to return data
+   *   for the handling route
+   */
+  async function query(
+    request: Request,
+    {
+      requestContext,
+      skipLoaderErrorBubbling,
+      dataStrategy,
+    }: {
+      requestContext?: unknown;
+      skipLoaderErrorBubbling?: boolean;
+      dataStrategy?: DataStrategyFunction;
+    } = {}
+  ): Promise<StaticHandlerContext | Response> {
+    let url = new URL(request.url);
+    let method = request.method;
+    let location = createLocation("", createPath(url), null, "default");
+    let matches = matchRoutes(dataRoutes, location, basename);
+
+    // SSR supports HEAD requests while SPA doesn't
+    if (!isValidMethod(method) && method !== "HEAD") {
+      let error = getInternalRouterError(405, { method });
+      let { matches: methodNotAllowedMatches, route } =
+        getShortCircuitMatches(dataRoutes);
+      return {
+        basename,
+        location,
+        matches: methodNotAllowedMatches,
+        loaderData: {},
+        actionData: null,
+        errors: {
+          [route.id]: error,
+        },
+        statusCode: error.status,
+        loaderHeaders: {},
+        actionHeaders: {},
+        activeDeferreds: null,
+      };
+    } else if (!matches) {
+      let error = getInternalRouterError(404, { pathname: location.pathname });
+      let { matches: notFoundMatches, route } =
+        getShortCircuitMatches(dataRoutes);
+      return {
+        basename,
+        location,
+        matches: notFoundMatches,
+        loaderData: {},
+        actionData: null,
+        errors: {
+          [route.id]: error,
+        },
+        statusCode: error.status,
+        loaderHeaders: {},
+        actionHeaders: {},
+        activeDeferreds: null,
+      };
+    }
+
+    let result = await queryImpl(
+      request,
+      location,
+      matches,
+      requestContext,
+      dataStrategy || null,
+      skipLoaderErrorBubbling === true,
+      null
+    );
+    if (isResponse(result)) {
+      return result;
+    }
+
+    // When returning StaticHandlerContext, we patch back in the location here
+    // since we need it for React Context.  But this helps keep our submit and
+    // loadRouteData operating on a Request instead of a Location
+    return { location, basename, ...result };
+  }
+
+  /**
+   * The queryRoute() method is intended for targeted route requests, either
+   * for fetch ?_data requests or resource route requests.  In this case, we
+   * are only ever calling a single action or loader, and we are returning the
+   * returned value directly.  In most cases, this will be a Response returned
+   * from the action/loader, but it may be a primitive or other value as well -
+   * and in such cases the calling context should handle that accordingly.
+   *
+   * We do respect the throw/return differentiation, so if an action/loader
+   * throws, then this method will throw the value.  This is important so we
+   * can do proper boundary identification in Remix where a thrown Response
+   * must go to the Catch Boundary but a returned Response is happy-path.
+   *
+   * One thing to note is that any Router-initiated Errors that make sense
+   * to associate with a status code will be thrown as an ErrorResponse
+   * instance which include the raw Error, such that the calling context can
+   * serialize the error as they see fit while including the proper response
+   * code.  Examples here are 404 and 405 errors that occur prior to reaching
+   * any user-defined loaders.
+   *
+   * - `opts.routeId` allows you to specify the specific route handler to call.
+   *   If not provided the handler will determine the proper route by matching
+   *   against `request.url`
+   * - `opts.requestContext` is an optional server context that will be passed
+   *    to actions/loaders in the `context` parameter
+   */
+  async function queryRoute(
+    request: Request,
+    {
+      routeId,
+      requestContext,
+      dataStrategy,
+    }: {
+      requestContext?: unknown;
+      routeId?: string;
+      dataStrategy?: DataStrategyFunction;
+    } = {}
+  ): Promise<any> {
+    let url = new URL(request.url);
+    let method = request.method;
+    let location = createLocation("", createPath(url), null, "default");
+    let matches = matchRoutes(dataRoutes, location, basename);
+
+    // SSR supports HEAD requests while SPA doesn't
+    if (!isValidMethod(method) && method !== "HEAD" && method !== "OPTIONS") {
+      throw getInternalRouterError(405, { method });
+    } else if (!matches) {
+      throw getInternalRouterError(404, { pathname: location.pathname });
+    }
+
+    let match = routeId
+      ? matches.find((m) => m.route.id === routeId)
+      : getTargetMatch(matches, location);
+
+    if (routeId && !match) {
+      throw getInternalRouterError(403, {
+        pathname: location.pathname,
+        routeId,
+      });
+    } else if (!match) {
+      // This should never hit I don't think?
+      throw getInternalRouterError(404, { pathname: location.pathname });
+    }
+
+    let result = await queryImpl(
+      request,
+      location,
+      matches,
+      requestContext,
+      dataStrategy || null,
+      false,
+      match
+    );
+
+    if (isResponse(result)) {
+      return result;
+    }
+
+    let error = result.errors ? Object.values(result.errors)[0] : undefined;
+    if (error !== undefined) {
+      // If we got back result.errors, that means the loader/action threw
+      // _something_ that wasn't a Response, but it's not guaranteed/required
+      // to be an `instanceof Error` either, so we have to use throw here to
+      // preserve the "error" state outside of queryImpl.
+      throw error;
+    }
+
+    // Pick off the right state value to return
+    if (result.actionData) {
+      return Object.values(result.actionData)[0];
+    }
+
+    if (result.loaderData) {
+      let data = Object.values(result.loaderData)[0];
+      if (result.activeDeferreds?.[match.route.id]) {
+        data[UNSAFE_DEFERRED_SYMBOL] = result.activeDeferreds[match.route.id];
+      }
+      return data;
+    }
+
+    return undefined;
+  }
+
+  async function queryImpl(
+    request: Request,
+    location: Location,
+    matches: AgnosticDataRouteMatch[],
+    requestContext: unknown,
+    dataStrategy: DataStrategyFunction | null,
+    skipLoaderErrorBubbling: boolean,
+    routeMatch: AgnosticDataRouteMatch | null
+  ): Promise<Omit<StaticHandlerContext, "location" | "basename"> | Response> {
+    invariant(
+      request.signal,
+      "query()/queryRoute() requests must contain an AbortController signal"
+    );
+
+    try {
+      if (isMutationMethod(request.method.toLowerCase())) {
+        let result = await submit(
+          request,
+          matches,
+          routeMatch || getTargetMatch(matches, location),
+          requestContext,
+          dataStrategy,
+          skipLoaderErrorBubbling,
+          routeMatch != null
+        );
+        return result;
+      }
+
+      let result = await loadRouteData(
+        request,
+        matches,
+        requestContext,
+        dataStrategy,
+        skipLoaderErrorBubbling,
+        routeMatch
+      );
+      return isResponse(result)
+        ? result
+        : {
+            ...result,
+            actionData: null,
+            actionHeaders: {},
+          };
+    } catch (e) {
+      // If the user threw/returned a Response in callLoaderOrAction for a
+      // `queryRoute` call, we throw the `DataStrategyResult` to bail out early
+      // and then return or throw the raw Response here accordingly
+      if (isDataStrategyResult(e) && isResponse(e.result)) {
+        if (e.type === ResultType.error) {
+          throw e.result;
+        }
+        return e.result;
+      }
+      // Redirects are always returned since they don't propagate to catch
+      // boundaries
+      if (isRedirectResponse(e)) {
+        return e;
+      }
+      throw e;
+    }
+  }
+
+  async function submit(
+    request: Request,
+    matches: AgnosticDataRouteMatch[],
+    actionMatch: AgnosticDataRouteMatch,
+    requestContext: unknown,
+    dataStrategy: DataStrategyFunction | null,
+    skipLoaderErrorBubbling: boolean,
+    isRouteRequest: boolean
+  ): Promise<Omit<StaticHandlerContext, "location" | "basename"> | Response> {
+    let result: DataResult;
+
+    if (!actionMatch.route.action && !actionMatch.route.lazy) {
+      let error = getInternalRouterError(405, {
+        method: request.method,
+        pathname: new URL(request.url).pathname,
+        routeId: actionMatch.route.id,
+      });
+      if (isRouteRequest) {
+        throw error;
+      }
+      result = {
+        type: ResultType.error,
+        error,
+      };
+    } else {
+      let results = await callDataStrategy(
+        "action",
+        request,
+        [actionMatch],
+        matches,
+        isRouteRequest,
+        requestContext,
+        dataStrategy
+      );
+      result = results[actionMatch.route.id];
+
+      if (request.signal.aborted) {
+        throwStaticHandlerAbortedError(request, isRouteRequest, future);
+      }
+    }
+
+    if (isRedirectResult(result)) {
+      // Uhhhh - this should never happen, we should always throw these from
+      // callLoaderOrAction, but the type narrowing here keeps TS happy and we
+      // can get back on the "throw all redirect responses" train here should
+      // this ever happen :/
+      throw new Response(null, {
+        status: result.response.status,
+        headers: {
+          Location: result.response.headers.get("Location")!,
+        },
+      });
+    }
+
+    if (isDeferredResult(result)) {
+      let error = getInternalRouterError(400, { type: "defer-action" });
+      if (isRouteRequest) {
+        throw error;
+      }
+      result = {
+        type: ResultType.error,
+        error,
+      };
+    }
+
+    if (isRouteRequest) {
+      // Note: This should only be non-Response values if we get here, since
+      // isRouteRequest should throw any Response received in callLoaderOrAction
+      if (isErrorResult(result)) {
+        throw result.error;
+      }
+
+      return {
+        matches: [actionMatch],
+        loaderData: {},
+        actionData: { [actionMatch.route.id]: result.data },
+        errors: null,
+        // Note: statusCode + headers are unused here since queryRoute will
+        // return the raw Response or value
+        statusCode: 200,
+        loaderHeaders: {},
+        actionHeaders: {},
+        activeDeferreds: null,
+      };
+    }
+
+    // Create a GET request for the loaders
+    let loaderRequest = new Request(request.url, {
+      headers: request.headers,
+      redirect: request.redirect,
+      signal: request.signal,
+    });
+
+    if (isErrorResult(result)) {
+      // Store off the pending error - we use it to determine which loaders
+      // to call and will commit it when we complete the navigation
+      let boundaryMatch = skipLoaderErrorBubbling
+        ? actionMatch
+        : findNearestBoundary(matches, actionMatch.route.id);
+
+      let context = await loadRouteData(
+        loaderRequest,
+        matches,
+        requestContext,
+        dataStrategy,
+        skipLoaderErrorBubbling,
+        null,
+        [boundaryMatch.route.id, result]
+      );
+
+      // action status codes take precedence over loader status codes
+      return {
+        ...context,
+        statusCode: isRouteErrorResponse(result.error)
+          ? result.error.status
+          : result.statusCode != null
+          ? result.statusCode
+          : 500,
+        actionData: null,
+        actionHeaders: {
+          ...(result.headers ? { [actionMatch.route.id]: result.headers } : {}),
+        },
+      };
+    }
+
+    let context = await loadRouteData(
+      loaderRequest,
+      matches,
+      requestContext,
+      dataStrategy,
+      skipLoaderErrorBubbling,
+      null
+    );
+
+    return {
+      ...context,
+      actionData: {
+        [actionMatch.route.id]: result.data,
+      },
+      // action status codes take precedence over loader status codes
+      ...(result.statusCode ? { statusCode: result.statusCode } : {}),
+      actionHeaders: result.headers
+        ? { [actionMatch.route.id]: result.headers }
+        : {},
+    };
+  }
+
+  async function loadRouteData(
+    request: Request,
+    matches: AgnosticDataRouteMatch[],
+    requestContext: unknown,
+    dataStrategy: DataStrategyFunction | null,
+    skipLoaderErrorBubbling: boolean,
+    routeMatch: AgnosticDataRouteMatch | null,
+    pendingActionResult?: PendingActionResult
+  ): Promise<
+    | Omit<
+        StaticHandlerContext,
+        "location" | "basename" | "actionData" | "actionHeaders"
+      >
+    | Response
+  > {
+    let isRouteRequest = routeMatch != null;
+
+    // Short circuit if we have no loaders to run (queryRoute())
+    if (
+      isRouteRequest &&
+      !routeMatch?.route.loader &&
+      !routeMatch?.route.lazy
+    ) {
+      throw getInternalRouterError(400, {
+        method: request.method,
+        pathname: new URL(request.url).pathname,
+        routeId: routeMatch?.route.id,
+      });
+    }
+
+    let requestMatches = routeMatch
+      ? [routeMatch]
+      : pendingActionResult && isErrorResult(pendingActionResult[1])
+      ? getLoaderMatchesUntilBoundary(matches, pendingActionResult[0])
+      : matches;
+    let matchesToLoad = requestMatches.filter(
+      (m) => m.route.loader || m.route.lazy
+    );
+
+    // Short circuit if we have no loaders to run (query())
+    if (matchesToLoad.length === 0) {
+      return {
+        matches,
+        // Add a null for all matched routes for proper revalidation on the client
+        loaderData: matches.reduce(
+          (acc, m) => Object.assign(acc, { [m.route.id]: null }),
+          {}
+        ),
+        errors:
+          pendingActionResult && isErrorResult(pendingActionResult[1])
+            ? {
+                [pendingActionResult[0]]: pendingActionResult[1].error,
+              }
+            : null,
+        statusCode: 200,
+        loaderHeaders: {},
+        activeDeferreds: null,
+      };
+    }
+
+    let results = await callDataStrategy(
+      "loader",
+      request,
+      matchesToLoad,
+      matches,
+      isRouteRequest,
+      requestContext,
+      dataStrategy
+    );
+
+    if (request.signal.aborted) {
+      throwStaticHandlerAbortedError(request, isRouteRequest, future);
+    }
+
+    // Process and commit output from loaders
+    let activeDeferreds = new Map<string, DeferredData>();
+    let context = processRouteLoaderData(
+      matches,
+      results,
+      pendingActionResult,
+      activeDeferreds,
+      skipLoaderErrorBubbling
+    );
+
+    // Add a null for any non-loader matches for proper revalidation on the client
+    let executedLoaders = new Set<string>(
+      matchesToLoad.map((match) => match.route.id)
+    );
+    matches.forEach((match) => {
+      if (!executedLoaders.has(match.route.id)) {
+        context.loaderData[match.route.id] = null;
+      }
+    });
+
+    return {
+      ...context,
+      matches,
+      activeDeferreds:
+        activeDeferreds.size > 0
+          ? Object.fromEntries(activeDeferreds.entries())
+          : null,
+    };
+  }
+
+  // Utility wrapper for calling dataStrategy server-side without having to
+  // pass around the manifest, mapRouteProperties, etc.
+  async function callDataStrategy(
+    type: "loader" | "action",
+    request: Request,
+    matchesToLoad: AgnosticDataRouteMatch[],
+    matches: AgnosticDataRouteMatch[],
+    isRouteRequest: boolean,
+    requestContext: unknown,
+    dataStrategy: DataStrategyFunction | null
+  ): Promise<Record<string, DataResult>> {
+    let results = await callDataStrategyImpl(
+      dataStrategy || defaultDataStrategy,
+      type,
+      null,
+      request,
+      matchesToLoad,
+      matches,
+      null,
+      manifest,
+      mapRouteProperties,
+      requestContext
+    );
+
+    let dataResults: Record<string, DataResult> = {};
+    await Promise.all(
+      matches.map(async (match) => {
+        if (!(match.route.id in results)) {
+          return;
+        }
+        let result = results[match.route.id];
+        if (isRedirectDataStrategyResultResult(result)) {
+          let response = result.result as Response;
+          // Throw redirects and let the server handle them with an HTTP redirect
+          throw normalizeRelativeRoutingRedirectResponse(
+            response,
+            request,
+            match.route.id,
+            matches,
+            basename,
+            future.v7_relativeSplatPath
+          );
+        }
+        if (isResponse(result.result) && isRouteRequest) {
+          // For SSR single-route requests, we want to hand Responses back
+          // directly without unwrapping
+          throw result;
+        }
+
+        dataResults[match.route.id] =
+          await convertDataStrategyResultToDataResult(result);
+      })
+    );
+    return dataResults;
+  }
+
+  return {
+    dataRoutes,
+    query,
+    queryRoute,
+  };
+}
+
+//#endregion
+
+////////////////////////////////////////////////////////////////////////////////
+//#region Helpers
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Given an existing StaticHandlerContext and an error thrown at render time,
+ * provide an updated StaticHandlerContext suitable for a second SSR render
+ */
+export function getStaticContextFromError(
+  routes: AgnosticDataRouteObject[],
+  context: StaticHandlerContext,
+  error: any
+) {
+  let newContext: StaticHandlerContext = {
+    ...context,
+    statusCode: isRouteErrorResponse(error) ? error.status : 500,
+    errors: {
+      [context._deepestRenderedBoundaryId || routes[0].id]: error,
+    },
+  };
+  return newContext;
+}
+
+function throwStaticHandlerAbortedError(
+  request: Request,
+  isRouteRequest: boolean,
+  future: StaticHandlerFutureConfig
+) {
+  if (future.v7_throwAbortReason && request.signal.reason !== undefined) {
+    throw request.signal.reason;
+  }
+
+  let method = isRouteRequest ? "queryRoute" : "query";
+  throw new Error(`${method}() call aborted: ${request.method} ${request.url}`);
+}
+
+function isSubmissionNavigation(
+  opts: BaseNavigateOrFetchOptions
+): opts is SubmissionNavigateOptions {
+  return (
+    opts != null &&
+    (("formData" in opts && opts.formData != null) ||
+      ("body" in opts && opts.body !== undefined))
+  );
+}
+
+function normalizeTo(
+  location: Path,
+  matches: AgnosticDataRouteMatch[],
+  basename: string,
+  prependBasename: boolean,
+  to: To | null,
+  v7_relativeSplatPath: boolean,
+  fromRouteId?: string,
+  relative?: RelativeRoutingType
+) {
+  let contextualMatches: AgnosticDataRouteMatch[];
+  let activeRouteMatch: AgnosticDataRouteMatch | undefined;
+  if (fromRouteId) {
+    // Grab matches up to the calling route so our route-relative logic is
+    // relative to the correct source route
+    contextualMatches = [];
+    for (let match of matches) {
+      contextualMatches.push(match);
+      if (match.route.id === fromRouteId) {
+        activeRouteMatch = match;
+        break;
+      }
+    }
+  } else {
+    contextualMatches = matches;
+    activeRouteMatch = matches[matches.length - 1];
+  }
+
+  // Resolve the relative path
+  let path = resolveTo(
+    to ? to : ".",
+    getResolveToMatches(contextualMatches, v7_relativeSplatPath),
+    stripBasename(location.pathname, basename) || location.pathname,
+    relative === "path"
+  );
+
+  // When `to` is not specified we inherit search/hash from the current
+  // location, unlike when to="." and we just inherit the path.
+  // See https://github.com/remix-run/remix/issues/927
+  if (to == null) {
+    path.search = location.search;
+    path.hash = location.hash;
+  }
+
+  // Account for `?index` params when routing to the current location
+  if ((to == null || to === "" || to === ".") && activeRouteMatch) {
+    let nakedIndex = hasNakedIndexQuery(path.search);
+    if (activeRouteMatch.route.index && !nakedIndex) {
+      // Add one when we're targeting an index route
+      path.search = path.search
+        ? path.search.replace(/^\?/, "?index&")
+        : "?index";
+    } else if (!activeRouteMatch.route.index && nakedIndex) {
+      // Remove existing ones when we're not
+      let params = new URLSearchParams(path.search);
+      let indexValues = params.getAll("index");
+      params.delete("index");
+      indexValues.filter((v) => v).forEach((v) => params.append("index", v));
+      let qs = params.toString();
+      path.search = qs ? `?${qs}` : "";
+    }
+  }
+
+  // If we're operating within a basename, prepend it to the pathname.  If
+  // this is a root navigation, then just use the raw basename which allows
+  // the basename to have full control over the presence of a trailing slash
+  // on root actions
+  if (prependBasename && basename !== "/") {
+    path.pathname =
+      path.pathname === "/" ? basename : joinPaths([basename, path.pathname]);
+  }
+
+  return createPath(path);
+}
+
+// Normalize navigation options by converting formMethod=GET formData objects to
+// URLSearchParams so they behave identically to links with query params
+function normalizeNavigateOptions(
+  normalizeFormMethod: boolean,
+  isFetcher: boolean,
+  path: string,
+  opts?: BaseNavigateOrFetchOptions
+): {
+  path: string;
+  submission?: Submission;
+  error?: ErrorResponseImpl;
+} {
+  // Return location verbatim on non-submission navigations
+  if (!opts || !isSubmissionNavigation(opts)) {
+    return { path };
+  }
+
+  if (opts.formMethod && !isValidMethod(opts.formMethod)) {
+    return {
+      path,
+      error: getInternalRouterError(405, { method: opts.formMethod }),
+    };
+  }
+
+  let getInvalidBodyError = () => ({
+    path,
+    error: getInternalRouterError(400, { type: "invalid-body" }),
+  });
+
+  // Create a Submission on non-GET navigations
+  let rawFormMethod = opts.formMethod || "get";
+  let formMethod = normalizeFormMethod
+    ? (rawFormMethod.toUpperCase() as V7_FormMethod)
+    : (rawFormMethod.toLowerCase() as FormMethod);
+  let formAction = stripHashFromPath(path);
+
+  if (opts.body !== undefined) {
+    if (opts.formEncType === "text/plain") {
+      // text only support POST/PUT/PATCH/DELETE submissions
+      if (!isMutationMethod(formMethod)) {
+        return getInvalidBodyError();
+      }
+
+      let text =
+        typeof opts.body === "string"
+          ? opts.body
+          : opts.body instanceof FormData ||
+            opts.body instanceof URLSearchParams
+          ? // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#plain-text-form-data
+            Array.from(opts.body.entries()).reduce(
+              (acc, [name, value]) => `${acc}${name}=${value}\n`,
+              ""
+            )
+          : String(opts.body);
+
+      return {
+        path,
+        submission: {
+          formMethod,
+          formAction,
+          formEncType: opts.formEncType,
+          formData: undefined,
+          json: undefined,
+          text,
+        },
+      };
+    } else if (opts.formEncType === "application/json") {
+      // json only supports POST/PUT/PATCH/DELETE submissions
+      if (!isMutationMethod(formMethod)) {
+        return getInvalidBodyError();
+      }
+
+      try {
+        let json =
+          typeof opts.body === "string" ? JSON.parse(opts.body) : opts.body;
+
+        return {
+          path,
+          submission: {
+            formMethod,
+            formAction,
+            formEncType: opts.formEncType,
+            formData: undefined,
+            json,
+            text: undefined,
+          },
+        };
+      } catch (e) {
+        return getInvalidBodyError();
+      }
+    }
+  }
+
+  invariant(
+    typeof FormData === "function",
+    "FormData is not available in this environment"
+  );
+
+  let searchParams: URLSearchParams;
+  let formData: FormData;
+
+  if (opts.formData) {
+    searchParams = convertFormDataToSearchParams(opts.formData);
+    formData = opts.formData;
+  } else if (opts.body instanceof FormData) {
+    searchParams = convertFormDataToSearchParams(opts.body);
+    formData = opts.body;
+  } else if (opts.body instanceof URLSearchParams) {
+    searchParams = opts.body;
+    formData = convertSearchParamsToFormData(searchParams);
+  } else if (opts.body == null) {
+    searchParams = new URLSearchParams();
+    formData = new FormData();
+  } else {
+    try {
+      searchParams = new URLSearchParams(opts.body);
+      formData = convertSearchParamsToFormData(searchParams);
+    } catch (e) {
+      return getInvalidBodyError();
+    }
+  }
+
+  let submission: Submission = {
+    formMethod,
+    formAction,
+    formEncType:
+      (opts && opts.formEncType) || "application/x-www-form-urlencoded",
+    formData,
+    json: undefined,
+    text: undefined,
+  };
+
+  if (isMutationMethod(submission.formMethod)) {
+    return { path, submission };
+  }
+
+  // Flatten submission onto URLSearchParams for GET submissions
+  let parsedPath = parsePath(path);
+  // On GET navigation submissions we can drop the ?index param from the
+  // resulting location since all loaders will run.  But fetcher GET submissions
+  // only run a single loader so we need to preserve any incoming ?index params
+  if (isFetcher && parsedPath.search && hasNakedIndexQuery(parsedPath.search)) {
+    searchParams.append("index", "");
+  }
+  parsedPath.search = `?${searchParams}`;
+
+  return { path: createPath(parsedPath), submission };
+}
+
+// Filter out all routes at/below any caught error as they aren't going to
+// render so we don't need to load them
+function getLoaderMatchesUntilBoundary(
+  matches: AgnosticDataRouteMatch[],
+  boundaryId: string,
+  includeBoundary = false
+) {
+  let index = matches.findIndex((m) => m.route.id === boundaryId);
+  if (index >= 0) {
+    return matches.slice(0, includeBoundary ? index + 1 : index);
+  }
+  return matches;
+}
+
+function getMatchesToLoad(
+  history: History,
+  state: RouterState,
+  matches: AgnosticDataRouteMatch[],
+  submission: Submission | undefined,
+  location: Location,
+  initialHydration: boolean,
+  skipActionErrorRevalidation: boolean,
+  isRevalidationRequired: boolean,
+  cancelledDeferredRoutes: string[],
+  cancelledFetcherLoads: Set<string>,
+  deletedFetchers: Set<string>,
+  fetchLoadMatches: Map<string, FetchLoadMatch>,
+  fetchRedirectIds: Set<string>,
+  routesToUse: AgnosticDataRouteObject[],
+  basename: string | undefined,
+  pendingActionResult?: PendingActionResult
+): [AgnosticDataRouteMatch[], RevalidatingFetcher[]] {
+  let actionResult = pendingActionResult
+    ? isErrorResult(pendingActionResult[1])
+      ? pendingActionResult[1].error
+      : pendingActionResult[1].data
+    : undefined;
+  let currentUrl = history.createURL(state.location);
+  let nextUrl = history.createURL(location);
+
+  // Pick navigation matches that are net-new or qualify for revalidation
+  let boundaryMatches = matches;
+  if (initialHydration && state.errors) {
+    // On initial hydration, only consider matches up to _and including_ the boundary.
+    // This is inclusive to handle cases where a server loader ran successfully,
+    // a child server loader bubbled up to this route, but this route has
+    // `clientLoader.hydrate` so we want to still run the `clientLoader` so that
+    // we have a complete version of `loaderData`
+    boundaryMatches = getLoaderMatchesUntilBoundary(
+      matches,
+      Object.keys(state.errors)[0],
+      true
+    );
+  } else if (pendingActionResult && isErrorResult(pendingActionResult[1])) {
+    // If an action threw an error, we call loaders up to, but not including the
+    // boundary
+    boundaryMatches = getLoaderMatchesUntilBoundary(
+      matches,
+      pendingActionResult[0]
+    );
+  }
+
+  // Don't revalidate loaders by default after action 4xx/5xx responses
+  // when the flag is enabled.  They can still opt-into revalidation via
+  // `shouldRevalidate` via `actionResult`
+  let actionStatus = pendingActionResult
+    ? pendingActionResult[1].statusCode
+    : undefined;
+  let shouldSkipRevalidation =
+    skipActionErrorRevalidation && actionStatus && actionStatus >= 400;
+
+  let navigationMatches = boundaryMatches.filter((match, index) => {
+    let { route } = match;
+    if (route.lazy) {
+      // We haven't loaded this route yet so we don't know if it's got a loader!
+      return true;
+    }
+
+    if (route.loader == null) {
+      return false;
+    }
+
+    if (initialHydration) {
+      return shouldLoadRouteOnHydration(route, state.loaderData, state.errors);
+    }
+
+    // Always call the loader on new route instances and pending defer cancellations
+    if (
+      isNewLoader(state.loaderData, state.matches[index], match) ||
+      cancelledDeferredRoutes.some((id) => id === match.route.id)
+    ) {
+      return true;
+    }
+
+    // This is the default implementation for when we revalidate.  If the route
+    // provides it's own implementation, then we give them full control but
+    // provide this value so they can leverage it if needed after they check
+    // their own specific use cases
+    let currentRouteMatch = state.matches[index];
+    let nextRouteMatch = match;
+
+    return shouldRevalidateLoader(match, {
+      currentUrl,
+      currentParams: currentRouteMatch.params,
+      nextUrl,
+      nextParams: nextRouteMatch.params,
+      ...submission,
+      actionResult,
+      actionStatus,
+      defaultShouldRevalidate: shouldSkipRevalidation
+        ? false
+        : // Forced revalidation due to submission, useRevalidator, or X-Remix-Revalidate
+          isRevalidationRequired ||
+          currentUrl.pathname + currentUrl.search ===
+            nextUrl.pathname + nextUrl.search ||
+          // Search params affect all loaders
+          currentUrl.search !== nextUrl.search ||
+          isNewRouteInstance(currentRouteMatch, nextRouteMatch),
+    });
+  });
+
+  // Pick fetcher.loads that need to be revalidated
+  let revalidatingFetchers: RevalidatingFetcher[] = [];
+  fetchLoadMatches.forEach((f, key) => {
+    // Don't revalidate:
+    //  - on initial hydration (shouldn't be any fetchers then anyway)
+    //  - if fetcher won't be present in the subsequent render
+    //    - no longer matches the URL (v7_fetcherPersist=false)
+    //    - was unmounted but persisted due to v7_fetcherPersist=true
+    if (
+      initialHydration ||
+      !matches.some((m) => m.route.id === f.routeId) ||
+      deletedFetchers.has(key)
+    ) {
+      return;
+    }
+
+    let fetcherMatches = matchRoutes(routesToUse, f.path, basename);
+
+    // If the fetcher path no longer matches, push it in with null matches so
+    // we can trigger a 404 in callLoadersAndMaybeResolveData.  Note this is
+    // currently only a use-case for Remix HMR where the route tree can change
+    // at runtime and remove a route previously loaded via a fetcher
+    if (!fetcherMatches) {
+      revalidatingFetchers.push({
+        key,
+        routeId: f.routeId,
+        path: f.path,
+        matches: null,
+        match: null,
+        controller: null,
+      });
+      return;
+    }
+
+    // Revalidating fetchers are decoupled from the route matches since they
+    // load from a static href.  They revalidate based on explicit revalidation
+    // (submission, useRevalidator, or X-Remix-Revalidate)
+    let fetcher = state.fetchers.get(key);
+    let fetcherMatch = getTargetMatch(fetcherMatches, f.path);
+
+    let shouldRevalidate = false;
+    if (fetchRedirectIds.has(key)) {
+      // Never trigger a revalidation of an actively redirecting fetcher
+      shouldRevalidate = false;
+    } else if (cancelledFetcherLoads.has(key)) {
+      // Always mark for revalidation if the fetcher was cancelled
+      cancelledFetcherLoads.delete(key);
+      shouldRevalidate = true;
+    } else if (
+      fetcher &&
+      fetcher.state !== "idle" &&
+      fetcher.data === undefined
+    ) {
+      // If the fetcher hasn't ever completed loading yet, then this isn't a
+      // revalidation, it would just be a brand new load if an explicit
+      // revalidation is required
+      shouldRevalidate = isRevalidationRequired;
+    } else {
+      // Otherwise fall back on any user-defined shouldRevalidate, defaulting
+      // to explicit revalidations only
+      shouldRevalidate = shouldRevalidateLoader(fetcherMatch, {
+        currentUrl,
+        currentParams: state.matches[state.matches.length - 1].params,
+        nextUrl,
+        nextParams: matches[matches.length - 1].params,
+        ...submission,
+        actionResult,
+        actionStatus,
+        defaultShouldRevalidate: shouldSkipRevalidation
+          ? false
+          : isRevalidationRequired,
+      });
+    }
+
+    if (shouldRevalidate) {
+      revalidatingFetchers.push({
+        key,
+        routeId: f.routeId,
+        path: f.path,
+        matches: fetcherMatches,
+        match: fetcherMatch,
+        controller: new AbortController(),
+      });
+    }
+  });
+
+  return [navigationMatches, revalidatingFetchers];
+}
+
+function shouldLoadRouteOnHydration(
+  route: AgnosticDataRouteObject,
+  loaderData: RouteData | null | undefined,
+  errors: RouteData | null | undefined
+) {
+  // We dunno if we have a loader - gotta find out!
+  if (route.lazy) {
+    return true;
+  }
+
+  // No loader, nothing to initialize
+  if (!route.loader) {
+    return false;
+  }
+
+  let hasData = loaderData != null && loaderData[route.id] !== undefined;
+  let hasError = errors != null && errors[route.id] !== undefined;
+
+  // Don't run if we error'd during SSR
+  if (!hasData && hasError) {
+    return false;
+  }
+
+  // Explicitly opting-in to running on hydration
+  if (typeof route.loader === "function" && route.loader.hydrate === true) {
+    return true;
+  }
+
+  // Otherwise, run if we're not yet initialized with anything
+  return !hasData && !hasError;
+}
+
+function isNewLoader(
+  currentLoaderData: RouteData,
+  currentMatch: AgnosticDataRouteMatch,
+  match: AgnosticDataRouteMatch
+) {
+  let isNew =
+    // [a] -> [a, b]
+    !currentMatch ||
+    // [a, b] -> [a, c]
+    match.route.id !== currentMatch.route.id;
+
+  // Handle the case that we don't have data for a re-used route, potentially
+  // from a prior error or from a cancelled pending deferred
+  let isMissingData = currentLoaderData[match.route.id] === undefined;
+
+  // Always load if this is a net-new route or we don't yet have data
+  return isNew || isMissingData;
+}
+
+function isNewRouteInstance(
+  currentMatch: AgnosticDataRouteMatch,
+  match: AgnosticDataRouteMatch
+) {
+  let currentPath = currentMatch.route.path;
+  return (
+    // param change for this match, /users/123 -> /users/456
+    currentMatch.pathname !== match.pathname ||
+    // splat param changed, which is not present in match.path
+    // e.g. /files/images/avatar.jpg -> files/finances.xls
+    (currentPath != null &&
+      currentPath.endsWith("*") &&
+      currentMatch.params["*"] !== match.params["*"])
+  );
+}
+
+function shouldRevalidateLoader(
+  loaderMatch: AgnosticDataRouteMatch,
+  arg: ShouldRevalidateFunctionArgs
+) {
+  if (loaderMatch.route.shouldRevalidate) {
+    let routeChoice = loaderMatch.route.shouldRevalidate(arg);
+    if (typeof routeChoice === "boolean") {
+      return routeChoice;
+    }
+  }
+
+  return arg.defaultShouldRevalidate;
+}
+
+function patchRoutesImpl(
+  routeId: string | null,
+  children: AgnosticRouteObject[],
+  routesToUse: AgnosticDataRouteObject[],
+  manifest: RouteManifest,
+  mapRouteProperties: MapRoutePropertiesFunction
+) {
+  let childrenToPatch: AgnosticDataRouteObject[];
+  if (routeId) {
+    let route = manifest[routeId];
+    invariant(
+      route,
+      `No route found to patch children into: routeId = ${routeId}`
+    );
+    if (!route.children) {
+      route.children = [];
+    }
+    childrenToPatch = route.children;
+  } else {
+    childrenToPatch = routesToUse;
+  }
+
+  // Don't patch in routes we already know about so that `patch` is idempotent
+  // to simplify user-land code. This is useful because we re-call the
+  // `patchRoutesOnNavigation` function for matched routes with params.
+  let uniqueChildren = children.filter(
+    (newRoute) =>
+      !childrenToPatch.some((existingRoute) =>
+        isSameRoute(newRoute, existingRoute)
+      )
+  );
+
+  let newRoutes = convertRoutesToDataRoutes(
+    uniqueChildren,
+    mapRouteProperties,
+    [routeId || "_", "patch", String(childrenToPatch?.length || "0")],
+    manifest
+  );
+
+  childrenToPatch.push(...newRoutes);
+}
+
+function isSameRoute(
+  newRoute: AgnosticRouteObject,
+  existingRoute: AgnosticRouteObject
+): boolean {
+  // Most optimal check is by id
+  if (
+    "id" in newRoute &&
+    "id" in existingRoute &&
+    newRoute.id === existingRoute.id
+  ) {
+    return true;
+  }
+
+  // Second is by pathing differences
+  if (
+    !(
+      newRoute.index === existingRoute.index &&
+      newRoute.path === existingRoute.path &&
+      newRoute.caseSensitive === existingRoute.caseSensitive
+    )
+  ) {
+    return false;
+  }
+
+  // Pathless layout routes are trickier since we need to check children.
+  // If they have no children then they're the same as far as we can tell
+  if (
+    (!newRoute.children || newRoute.children.length === 0) &&
+    (!existingRoute.children || existingRoute.children.length === 0)
+  ) {
+    return true;
+  }
+
+  // Otherwise, we look to see if every child in the new route is already
+  // represented in the existing route's children
+  return newRoute.children!.every((aChild, i) =>
+    existingRoute.children?.some((bChild) => isSameRoute(aChild, bChild))
+  );
+}
+
+/**
+ * Execute route.lazy() methods to lazily load route modules (loader, action,
+ * shouldRevalidate) and update the routeManifest in place which shares objects
+ * with dataRoutes so those get updated as well.
+ */
+async function loadLazyRouteModule(
+  route: AgnosticDataRouteObject,
+  mapRouteProperties: MapRoutePropertiesFunction,
+  manifest: RouteManifest
+) {
+  if (!route.lazy) {
+    return;
+  }
+
+  let lazyRoute = await route.lazy();
+
+  // If the lazy route function was executed and removed by another parallel
+  // call then we can return - first lazy() to finish wins because the return
+  // value of lazy is expected to be static
+  if (!route.lazy) {
+    return;
+  }
+
+  let routeToUpdate = manifest[route.id];
+  invariant(routeToUpdate, "No route found in manifest");
+
+  // Update the route in place.  This should be safe because there's no way
+  // we could yet be sitting on this route as we can't get there without
+  // resolving lazy() first.
+  //
+  // This is different than the HMR "update" use-case where we may actively be
+  // on the route being updated.  The main concern boils down to "does this
+  // mutation affect any ongoing navigations or any current state.matches
+  // values?".  If not, it should be safe to update in place.
+  let routeUpdates: Record<string, any> = {};
+  for (let lazyRouteProperty in lazyRoute) {
+    let staticRouteValue =
+      routeToUpdate[lazyRouteProperty as keyof typeof routeToUpdate];
+
+    let isPropertyStaticallyDefined =
+      staticRouteValue !== undefined &&
+      // This property isn't static since it should always be updated based
+      // on the route updates
+      lazyRouteProperty !== "hasErrorBoundary";
+
+    warning(
+      !isPropertyStaticallyDefined,
+      `Route "${routeToUpdate.id}" has a static property "${lazyRouteProperty}" ` +
+        `defined but its lazy function is also returning a value for this property. ` +
+        `The lazy route property "${lazyRouteProperty}" will be ignored.`
+    );
+
+    if (
+      !isPropertyStaticallyDefined &&
+      !immutableRouteKeys.has(lazyRouteProperty as ImmutableRouteKey)
+    ) {
+      routeUpdates[lazyRouteProperty] =
+        lazyRoute[lazyRouteProperty as keyof typeof lazyRoute];
+    }
+  }
+
+  // Mutate the route with the provided updates.  Do this first so we pass
+  // the updated version to mapRouteProperties
+  Object.assign(routeToUpdate, routeUpdates);
+
+  // Mutate the `hasErrorBoundary` property on the route based on the route
+  // updates and remove the `lazy` function so we don't resolve the lazy
+  // route again.
+  Object.assign(routeToUpdate, {
+    // To keep things framework agnostic, we use the provided
+    // `mapRouteProperties` (or wrapped `detectErrorBoundary`) function to
+    // set the framework-aware properties (`element`/`hasErrorBoundary`) since
+    // the logic will differ between frameworks.
+    ...mapRouteProperties(routeToUpdate),
+    lazy: undefined,
+  });
+}
+
+// Default implementation of `dataStrategy` which fetches all loaders in parallel
+async function defaultDataStrategy({
+  matches,
+}: DataStrategyFunctionArgs): ReturnType<DataStrategyFunction> {
+  let matchesToLoad = matches.filter((m) => m.shouldLoad);
+  let results = await Promise.all(matchesToLoad.map((m) => m.resolve()));
+  return results.reduce(
+    (acc, result, i) =>
+      Object.assign(acc, { [matchesToLoad[i].route.id]: result }),
+    {}
+  );
+}
+
+async function callDataStrategyImpl(
+  dataStrategyImpl: DataStrategyFunction,
+  type: "loader" | "action",
+  state: RouterState | null,
+  request: Request,
+  matchesToLoad: AgnosticDataRouteMatch[],
+  matches: AgnosticDataRouteMatch[],
+  fetcherKey: string | null,
+  manifest: RouteManifest,
+  mapRouteProperties: MapRoutePropertiesFunction,
+  requestContext?: unknown
+): Promise<Record<string, DataStrategyResult>> {
+  let loadRouteDefinitionsPromises = matches.map((m) =>
+    m.route.lazy
+      ? loadLazyRouteModule(m.route, mapRouteProperties, manifest)
+      : undefined
+  );
+
+  let dsMatches = matches.map((match, i) => {
+    let loadRoutePromise = loadRouteDefinitionsPromises[i];
+    let shouldLoad = matchesToLoad.some((m) => m.route.id === match.route.id);
+    // `resolve` encapsulates route.lazy(), executing the loader/action,
+    // and mapping return values/thrown errors to a `DataStrategyResult`.  Users
+    // can pass a callback to take fine-grained control over the execution
+    // of the loader/action
+    let resolve: DataStrategyMatch["resolve"] = async (handlerOverride) => {
+      if (
+        handlerOverride &&
+        request.method === "GET" &&
+        (match.route.lazy || match.route.loader)
+      ) {
+        shouldLoad = true;
+      }
+      return shouldLoad
+        ? callLoaderOrAction(
+            type,
+            request,
+            match,
+            loadRoutePromise,
+            handlerOverride,
+            requestContext
+          )
+        : Promise.resolve({ type: ResultType.data, result: undefined });
+    };
+
+    return {
+      ...match,
+      shouldLoad,
+      resolve,
+    };
+  });
+
+  // Send all matches here to allow for a middleware-type implementation.
+  // handler will be a no-op for unneeded routes and we filter those results
+  // back out below.
+  let results = await dataStrategyImpl({
+    matches: dsMatches,
+    request,
+    params: matches[0].params,
+    fetcherKey,
+    context: requestContext,
+  });
+
+  // Wait for all routes to load here but 'swallow the error since we want
+  // it to bubble up from the `await loadRoutePromise` in `callLoaderOrAction` -
+  // called from `match.resolve()`
+  try {
+    await Promise.all(loadRouteDefinitionsPromises);
+  } catch (e) {
+    // No-op
+  }
+
+  return results;
+}
+
+// Default logic for calling a loader/action is the user has no specified a dataStrategy
+async function callLoaderOrAction(
+  type: "loader" | "action",
+  request: Request,
+  match: AgnosticDataRouteMatch,
+  loadRoutePromise: Promise<void> | undefined,
+  handlerOverride: Parameters<DataStrategyMatch["resolve"]>[0],
+  staticContext?: unknown
+): Promise<DataStrategyResult> {
+  let result: DataStrategyResult;
+  let onReject: (() => void) | undefined;
+
+  let runHandler = (
+    handler: AgnosticRouteObject["loader"] | AgnosticRouteObject["action"]
+  ): Promise<DataStrategyResult> => {
+    // Setup a promise we can race against so that abort signals short circuit
+    let reject: () => void;
+    // This will never resolve so safe to type it as Promise<DataStrategyResult> to
+    // satisfy the function return value
+    let abortPromise = new Promise<DataStrategyResult>((_, r) => (reject = r));
+    onReject = () => reject();
+    request.signal.addEventListener("abort", onReject);
+
+    let actualHandler = (ctx?: unknown) => {
+      if (typeof handler !== "function") {
+        return Promise.reject(
+          new Error(
+            `You cannot call the handler for a route which defines a boolean ` +
+              `"${type}" [routeId: ${match.route.id}]`
+          )
+        );
+      }
+      return handler(
+        {
+          request,
+          params: match.params,
+          context: staticContext,
+        },
+        ...(ctx !== undefined ? [ctx] : [])
+      );
+    };
+
+    let handlerPromise: Promise<DataStrategyResult> = (async () => {
+      try {
+        let val = await (handlerOverride
+          ? handlerOverride((ctx: unknown) => actualHandler(ctx))
+          : actualHandler());
+        return { type: "data", result: val };
+      } catch (e) {
+        return { type: "error", result: e };
+      }
+    })();
+
+    return Promise.race([handlerPromise, abortPromise]);
+  };
+
+  try {
+    let handler = match.route[type];
+
+    // If we have a route.lazy promise, await that first
+    if (loadRoutePromise) {
+      if (handler) {
+        // Run statically defined handler in parallel with lazy()
+        let handlerError;
+        let [value] = await Promise.all([
+          // If the handler throws, don't let it immediately bubble out,
+          // since we need to let the lazy() execution finish so we know if this
+          // route has a boundary that can handle the error
+          runHandler(handler).catch((e) => {
+            handlerError = e;
+          }),
+          loadRoutePromise,
+        ]);
+        if (handlerError !== undefined) {
+          throw handlerError;
+        }
+        result = value!;
+      } else {
+        // Load lazy route module, then run any returned handler
+        await loadRoutePromise;
+
+        handler = match.route[type];
+        if (handler) {
+          // Handler still runs even if we got interrupted to maintain consistency
+          // with un-abortable behavior of handler execution on non-lazy or
+          // previously-lazy-loaded routes
+          result = await runHandler(handler);
+        } else if (type === "action") {
+          let url = new URL(request.url);
+          let pathname = url.pathname + url.search;
+          throw getInternalRouterError(405, {
+            method: request.method,
+            pathname,
+            routeId: match.route.id,
+          });
+        } else {
+          // lazy() route has no loader to run.  Short circuit here so we don't
+          // hit the invariant below that errors on returning undefined.
+          return { type: ResultType.data, result: undefined };
+        }
+      }
+    } else if (!handler) {
+      let url = new URL(request.url);
+      let pathname = url.pathname + url.search;
+      throw getInternalRouterError(404, {
+        pathname,
+      });
+    } else {
+      result = await runHandler(handler);
+    }
+
+    invariant(
+      result.result !== undefined,
+      `You defined ${type === "action" ? "an action" : "a loader"} for route ` +
+        `"${match.route.id}" but didn't return anything from your \`${type}\` ` +
+        `function. Please return a value or \`null\`.`
+    );
+  } catch (e) {
+    // We should already be catching and converting normal handler executions to
+    // DataStrategyResults and returning them, so anything that throws here is an
+    // unexpected error we still need to wrap
+    return { type: ResultType.error, result: e };
+  } finally {
+    if (onReject) {
+      request.signal.removeEventListener("abort", onReject);
+    }
+  }
+
+  return result;
+}
+
+async function convertDataStrategyResultToDataResult(
+  dataStrategyResult: DataStrategyResult
+): Promise<DataResult> {
+  let { result, type } = dataStrategyResult;
+
+  if (isResponse(result)) {
+    let data: any;
+
+    try {
+      let contentType = result.headers.get("Content-Type");
+      // Check between word boundaries instead of startsWith() due to the last
+      // paragraph of https://httpwg.org/specs/rfc9110.html#field.content-type
+      if (contentType && /\bapplication\/json\b/.test(contentType)) {
+        if (result.body == null) {
+          data = null;
+        } else {
+          data = await result.json();
+        }
+      } else {
+        data = await result.text();
+      }
+    } catch (e) {
+      return { type: ResultType.error, error: e };
+    }
+
+    if (type === ResultType.error) {
+      return {
+        type: ResultType.error,
+        error: new ErrorResponseImpl(result.status, result.statusText, data),
+        statusCode: result.status,
+        headers: result.headers,
+      };
+    }
+
+    return {
+      type: ResultType.data,
+      data,
+      statusCode: result.status,
+      headers: result.headers,
+    };
+  }
+
+  if (type === ResultType.error) {
+    if (isDataWithResponseInit(result)) {
+      if (result.data instanceof Error) {
+        return {
+          type: ResultType.error,
+          error: result.data,
+          statusCode: result.init?.status,
+          headers: result.init?.headers
+            ? new Headers(result.init.headers)
+            : undefined,
+        };
+      }
+
+      // Convert thrown data() to ErrorResponse instances
+      return {
+        type: ResultType.error,
+        error: new ErrorResponseImpl(
+          result.init?.status || 500,
+          undefined,
+          result.data
+        ),
+        statusCode: isRouteErrorResponse(result) ? result.status : undefined,
+        headers: result.init?.headers
+          ? new Headers(result.init.headers)
+          : undefined,
+      };
+    }
+    return {
+      type: ResultType.error,
+      error: result,
+      statusCode: isRouteErrorResponse(result) ? result.status : undefined,
+    };
+  }
+
+  if (isDeferredData(result)) {
+    return {
+      type: ResultType.deferred,
+      deferredData: result,
+      statusCode: result.init?.status,
+      headers: result.init?.headers && new Headers(result.init.headers),
+    };
+  }
+
+  if (isDataWithResponseInit(result)) {
+    return {
+      type: ResultType.data,
+      data: result.data,
+      statusCode: result.init?.status,
+      headers: result.init?.headers
+        ? new Headers(result.init.headers)
+        : undefined,
+    };
+  }
+
+  return { type: ResultType.data, data: result };
+}
+
+// Support relative routing in internal redirects
+function normalizeRelativeRoutingRedirectResponse(
+  response: Response,
+  request: Request,
+  routeId: string,
+  matches: AgnosticDataRouteMatch[],
+  basename: string,
+  v7_relativeSplatPath: boolean
+) {
+  let location = response.headers.get("Location");
+  invariant(
+    location,
+    "Redirects returned/thrown from loaders/actions must have a Location header"
+  );
+
+  if (!ABSOLUTE_URL_REGEX.test(location)) {
+    let trimmedMatches = matches.slice(
+      0,
+      matches.findIndex((m) => m.route.id === routeId) + 1
+    );
+    location = normalizeTo(
+      new URL(request.url),
+      trimmedMatches,
+      basename,
+      true,
+      location,
+      v7_relativeSplatPath
+    );
+    response.headers.set("Location", location);
+  }
+
+  return response;
+}
+
+function normalizeRedirectLocation(
+  location: string,
+  currentUrl: URL,
+  basename: string,
+  historyInstance: History,
+): string {
+  // Match Chrome's behavior:
+  // https://github.com/chromium/chromium/blob/216dbeb61db0c667e62082e5f5400a32d6983df3/content/public/common/url_utils.cc#L82
+  let invalidProtocols = [
+    "about:",
+    "blob:",
+    "chrome:",
+    "chrome-untrusted:",
+    "content:",
+    "data:",
+    "devtools:",
+    "file:",
+    "filesystem:",
+    // eslint-disable-next-line no-script-url
+    "javascript:",
+  ];
+
+  if (ABSOLUTE_URL_REGEX.test(location)) {
+    // Strip off the protocol+origin for same-origin + same-basename absolute redirects
+    let normalizedLocation = location;
+    let url = normalizedLocation.startsWith("//")
+      ? new URL(currentUrl.protocol + normalizedLocation)
+      : new URL(normalizedLocation);
+    if (invalidProtocols.includes(url.protocol)) {
+      throw new Error("Invalid redirect location");
+    }
+    let isSameBasename = stripBasename(url.pathname, basename) != null;
+    if (url.origin === currentUrl.origin && isSameBasename) {
+      return url.pathname + url.search + url.hash;
+    }
+  }
+
+  try {
+    let url = historyInstance.createURL(location);
+    if (invalidProtocols.includes(url.protocol)) {
+      throw new Error("Invalid redirect location");
+    }
+  } catch (e) {}
+
+  return location;
+}
+
+// Utility method for creating the Request instances for loaders/actions during
+// client-side navigations and fetches.  During SSR we will always have a
+// Request instance from the static handler (query/queryRoute)
+function createClientSideRequest(
+  history: History,
+  location: string | Location,
+  signal: AbortSignal,
+  submission?: Submission
+): Request {
+  let url = history.createURL(stripHashFromPath(location)).toString();
+  let init: RequestInit = { signal };
+
+  if (submission && isMutationMethod(submission.formMethod)) {
+    let { formMethod, formEncType } = submission;
+    // Didn't think we needed this but it turns out unlike other methods, patch
+    // won't be properly normalized to uppercase and results in a 405 error.
+    // See: https://fetch.spec.whatwg.org/#concept-method
+    init.method = formMethod.toUpperCase();
+
+    if (formEncType === "application/json") {
+      init.headers = new Headers({ "Content-Type": formEncType });
+      init.body = JSON.stringify(submission.json);
+    } else if (formEncType === "text/plain") {
+      // Content-Type is inferred (https://fetch.spec.whatwg.org/#dom-request)
+      init.body = submission.text;
+    } else if (
+      formEncType === "application/x-www-form-urlencoded" &&
+      submission.formData
+    ) {
+      // Content-Type is inferred (https://fetch.spec.whatwg.org/#dom-request)
+      init.body = convertFormDataToSearchParams(submission.formData);
+    } else {
+      // Content-Type is inferred (https://fetch.spec.whatwg.org/#dom-request)
+      init.body = submission.formData;
+    }
+  }
+
+  return new Request(url, init);
+}
+
+function convertFormDataToSearchParams(formData: FormData): URLSearchParams {
+  let searchParams = new URLSearchParams();
+
+  for (let [key, value] of formData.entries()) {
+    // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#converting-an-entry-list-to-a-list-of-name-value-pairs
+    searchParams.append(key, typeof value === "string" ? value : value.name);
+  }
+
+  return searchParams;
+}
+
+function convertSearchParamsToFormData(
+  searchParams: URLSearchParams
+): FormData {
+  let formData = new FormData();
+  for (let [key, value] of searchParams.entries()) {
+    formData.append(key, value);
+  }
+  return formData;
+}
+
+function processRouteLoaderData(
+  matches: AgnosticDataRouteMatch[],
+  results: Record<string, DataResult>,
+  pendingActionResult: PendingActionResult | undefined,
+  activeDeferreds: Map<string, DeferredData>,
+  skipLoaderErrorBubbling: boolean
+): {
+  loaderData: RouterState["loaderData"];
+  errors: RouterState["errors"] | null;
+  statusCode: number;
+  loaderHeaders: Record<string, Headers>;
+} {
+  // Fill in loaderData/errors from our loaders
+  let loaderData: RouterState["loaderData"] = {};
+  let errors: RouterState["errors"] | null = null;
+  let statusCode: number | undefined;
+  let foundError = false;
+  let loaderHeaders: Record<string, Headers> = {};
+  let pendingError =
+    pendingActionResult && isErrorResult(pendingActionResult[1])
+      ? pendingActionResult[1].error
+      : undefined;
+
+  // Process loader results into state.loaderData/state.errors
+  matches.forEach((match) => {
+    if (!(match.route.id in results)) {
+      return;
+    }
+    let id = match.route.id;
+    let result = results[id];
+    invariant(
+      !isRedirectResult(result),
+      "Cannot handle redirect results in processLoaderData"
+    );
+    if (isErrorResult(result)) {
+      let error = result.error;
+      // If we have a pending action error, we report it at the highest-route
+      // that throws a loader error, and then clear it out to indicate that
+      // it was consumed
+      if (pendingError !== undefined) {
+        error = pendingError;
+        pendingError = undefined;
+      }
+
+      errors = errors || {};
+
+      if (skipLoaderErrorBubbling) {
+        errors[id] = error;
+      } else {
+        // Look upwards from the matched route for the closest ancestor error
+        // boundary, defaulting to the root match.  Prefer higher error values
+        // if lower errors bubble to the same boundary
+        let boundaryMatch = findNearestBoundary(matches, id);
+        if (errors[boundaryMatch.route.id] == null) {
+          errors[boundaryMatch.route.id] = error;
+        }
+      }
+
+      // Clear our any prior loaderData for the throwing route
+      loaderData[id] = undefined;
+
+      // Once we find our first (highest) error, we set the status code and
+      // prevent deeper status codes from overriding
+      if (!foundError) {
+        foundError = true;
+        statusCode = isRouteErrorResponse(result.error)
+          ? result.error.status
+          : 500;
+      }
+      if (result.headers) {
+        loaderHeaders[id] = result.headers;
+      }
+    } else {
+      if (isDeferredResult(result)) {
+        activeDeferreds.set(id, result.deferredData);
+        loaderData[id] = result.deferredData.data;
+        // Error status codes always override success status codes, but if all
+        // loaders are successful we take the deepest status code.
+        if (
+          result.statusCode != null &&
+          result.statusCode !== 200 &&
+          !foundError
+        ) {
+          statusCode = result.statusCode;
+        }
+        if (result.headers) {
+          loaderHeaders[id] = result.headers;
+        }
+      } else {
+        loaderData[id] = result.data;
+        // Error status codes always override success status codes, but if all
+        // loaders are successful we take the deepest status code.
+        if (result.statusCode && result.statusCode !== 200 && !foundError) {
+          statusCode = result.statusCode;
+        }
+        if (result.headers) {
+          loaderHeaders[id] = result.headers;
+        }
+      }
+    }
+  });
+
+  // If we didn't consume the pending action error (i.e., all loaders
+  // resolved), then consume it here.  Also clear out any loaderData for the
+  // throwing route
+  if (pendingError !== undefined && pendingActionResult) {
+    errors = { [pendingActionResult[0]]: pendingError };
+    loaderData[pendingActionResult[0]] = undefined;
+  }
+
+  return {
+    loaderData,
+    errors,
+    statusCode: statusCode || 200,
+    loaderHeaders,
+  };
+}
+
+function processLoaderData(
+  state: RouterState,
+  matches: AgnosticDataRouteMatch[],
+  results: Record<string, DataResult>,
+  pendingActionResult: PendingActionResult | undefined,
+  revalidatingFetchers: RevalidatingFetcher[],
+  fetcherResults: Record<string, DataResult>,
+  activeDeferreds: Map<string, DeferredData>
+): {
+  loaderData: RouterState["loaderData"];
+  errors?: RouterState["errors"];
+} {
+  let { loaderData, errors } = processRouteLoaderData(
+    matches,
+    results,
+    pendingActionResult,
+    activeDeferreds,
+    false // This method is only called client side so we always want to bubble
+  );
+
+  // Process results from our revalidating fetchers
+  revalidatingFetchers.forEach((rf) => {
+    let { key, match, controller } = rf;
+    let result = fetcherResults[key];
+    invariant(result, "Did not find corresponding fetcher result");
+
+    // Process fetcher non-redirect errors
+    if (controller && controller.signal.aborted) {
+      // Nothing to do for aborted fetchers
+      return;
+    } else if (isErrorResult(result)) {
+      let boundaryMatch = findNearestBoundary(state.matches, match?.route.id);
+      if (!(errors && errors[boundaryMatch.route.id])) {
+        errors = {
+          ...errors,
+          [boundaryMatch.route.id]: result.error,
+        };
+      }
+      state.fetchers.delete(key);
+    } else if (isRedirectResult(result)) {
+      // Should never get here, redirects should get processed above, but we
+      // keep this to type narrow to a success result in the else
+      invariant(false, "Unhandled fetcher revalidation redirect");
+    } else if (isDeferredResult(result)) {
+      // Should never get here, deferred data should be awaited for fetchers
+      // in resolveDeferredResults
+      invariant(false, "Unhandled fetcher deferred data");
+    } else {
+      let doneFetcher = getDoneFetcher(result.data);
+      state.fetchers.set(key, doneFetcher);
+    }
+  });
+
+  return { loaderData, errors };
+}
+
+function mergeLoaderData(
+  loaderData: RouteData,
+  newLoaderData: RouteData,
+  matches: AgnosticDataRouteMatch[],
+  errors: RouteData | null | undefined
+): RouteData {
+  let mergedLoaderData = { ...newLoaderData };
+  for (let match of matches) {
+    let id = match.route.id;
+    if (newLoaderData.hasOwnProperty(id)) {
+      if (newLoaderData[id] !== undefined) {
+        mergedLoaderData[id] = newLoaderData[id];
+      } else {
+        // No-op - this is so we ignore existing data if we have a key in the
+        // incoming object with an undefined value, which is how we unset a prior
+        // loaderData if we encounter a loader error
+      }
+    } else if (loaderData[id] !== undefined && match.route.loader) {
+      // Preserve existing keys not included in newLoaderData and where a loader
+      // wasn't removed by HMR
+      mergedLoaderData[id] = loaderData[id];
+    }
+
+    if (errors && errors.hasOwnProperty(id)) {
+      // Don't keep any loader data below the boundary
+      break;
+    }
+  }
+  return mergedLoaderData;
+}
+
+function getActionDataForCommit(
+  pendingActionResult: PendingActionResult | undefined
+) {
+  if (!pendingActionResult) {
+    return {};
+  }
+  return isErrorResult(pendingActionResult[1])
+    ? {
+        // Clear out prior actionData on errors
+        actionData: {},
+      }
+    : {
+        actionData: {
+          [pendingActionResult[0]]: pendingActionResult[1].data,
+        },
+      };
+}
+
+// Find the nearest error boundary, looking upwards from the leaf route (or the
+// route specified by routeId) for the closest ancestor error boundary,
+// defaulting to the root match
+function findNearestBoundary(
+  matches: AgnosticDataRouteMatch[],
+  routeId?: string
+): AgnosticDataRouteMatch {
+  let eligibleMatches = routeId
+    ? matches.slice(0, matches.findIndex((m) => m.route.id === routeId) + 1)
+    : [...matches];
+  return (
+    eligibleMatches.reverse().find((m) => m.route.hasErrorBoundary === true) ||
+    matches[0]
+  );
+}
+
+function getShortCircuitMatches(routes: AgnosticDataRouteObject[]): {
+  matches: AgnosticDataRouteMatch[];
+  route: AgnosticDataRouteObject;
+} {
+  // Prefer a root layout route if present, otherwise shim in a route object
+  let route =
+    routes.length === 1
+      ? routes[0]
+      : routes.find((r) => r.index || !r.path || r.path === "/") || {
+          id: `__shim-error-route__`,
+        };
+
+  return {
+    matches: [
+      {
+        params: {},
+        pathname: "",
+        pathnameBase: "",
+        route,
+      },
+    ],
+    route,
+  };
+}
+
+function getInternalRouterError(
+  status: number,
+  {
+    pathname,
+    routeId,
+    method,
+    type,
+    message,
+  }: {
+    pathname?: string;
+    routeId?: string;
+    method?: string;
+    type?: "defer-action" | "invalid-body";
+    message?: string;
+  } = {}
+) {
+  let statusText = "Unknown Server Error";
+  let errorMessage = "Unknown @remix-run/router error";
+
+  if (status === 400) {
+    statusText = "Bad Request";
+    if (method && pathname && routeId) {
+      errorMessage =
+        `You made a ${method} request to "${pathname}" but ` +
+        `did not provide a \`loader\` for route "${routeId}", ` +
+        `so there is no way to handle the request.`;
+    } else if (type === "defer-action") {
+      errorMessage = "defer() is not supported in actions";
+    } else if (type === "invalid-body") {
+      errorMessage = "Unable to encode submission body";
+    }
+  } else if (status === 403) {
+    statusText = "Forbidden";
+    errorMessage = `Route "${routeId}" does not match URL "${pathname}"`;
+  } else if (status === 404) {
+    statusText = "Not Found";
+    errorMessage = `No route matches URL "${pathname}"`;
+  } else if (status === 405) {
+    statusText = "Method Not Allowed";
+    if (method && pathname && routeId) {
+      errorMessage =
+        `You made a ${method.toUpperCase()} request to "${pathname}" but ` +
+        `did not provide an \`action\` for route "${routeId}", ` +
+        `so there is no way to handle the request.`;
+    } else if (method) {
+      errorMessage = `Invalid request method "${method.toUpperCase()}"`;
+    }
+  }
+
+  return new ErrorResponseImpl(
+    status || 500,
+    statusText,
+    new Error(errorMessage),
+    true
+  );
+}
+
+// Find any returned redirect errors, starting from the lowest match
+function findRedirect(
+  results: Record<string, DataResult>
+): { key: string; result: RedirectResult } | undefined {
+  let entries = Object.entries(results);
+  for (let i = entries.length - 1; i >= 0; i--) {
+    let [key, result] = entries[i];
+    if (isRedirectResult(result)) {
+      return { key, result };
+    }
+  }
+}
+
+function stripHashFromPath(path: To) {
+  let parsedPath = typeof path === "string" ? parsePath(path) : path;
+  return createPath({ ...parsedPath, hash: "" });
+}
+
+function isHashChangeOnly(a: Location, b: Location): boolean {
+  if (a.pathname !== b.pathname || a.search !== b.search) {
+    return false;
+  }
+
+  if (a.hash === "") {
+    // /page -> /page#hash
+    return b.hash !== "";
+  } else if (a.hash === b.hash) {
+    // /page#hash -> /page#hash
+    return true;
+  } else if (b.hash !== "") {
+    // /page#hash -> /page#other
+    return true;
+  }
+
+  // If the hash is removed the browser will re-perform a request to the server
+  // /page#hash -> /page
+  return false;
+}
+
+function isPromise<T = unknown>(val: unknown): val is Promise<T> {
+  return typeof val === "object" && val != null && "then" in val;
+}
+
+function isDataStrategyResult(result: unknown): result is DataStrategyResult {
+  return (
+    result != null &&
+    typeof result === "object" &&
+    "type" in result &&
+    "result" in result &&
+    (result.type === ResultType.data || result.type === ResultType.error)
+  );
+}
+
+function isRedirectDataStrategyResultResult(result: DataStrategyResult) {
+  return (
+    isResponse(result.result) && redirectStatusCodes.has(result.result.status)
+  );
+}
+
+function isDeferredResult(result: DataResult): result is DeferredResult {
+  return result.type === ResultType.deferred;
+}
+
+function isErrorResult(result: DataResult): result is ErrorResult {
+  return result.type === ResultType.error;
+}
+
+function isRedirectResult(result?: DataResult): result is RedirectResult {
+  return (result && result.type) === ResultType.redirect;
+}
+
+export function isDataWithResponseInit(
+  value: any
+): value is DataWithResponseInit<unknown> {
+  return (
+    typeof value === "object" &&
+    value != null &&
+    "type" in value &&
+    "data" in value &&
+    "init" in value &&
+    value.type === "DataWithResponseInit"
+  );
+}
+
+export function isDeferredData(value: any): value is DeferredData {
+  let deferred: DeferredData = value;
+  return (
+    deferred &&
+    typeof deferred === "object" &&
+    typeof deferred.data === "object" &&
+    typeof deferred.subscribe === "function" &&
+    typeof deferred.cancel === "function" &&
+    typeof deferred.resolveData === "function"
+  );
+}
+
+function isResponse(value: any): value is Response {
+  return (
+    value != null &&
+    typeof value.status === "number" &&
+    typeof value.statusText === "string" &&
+    typeof value.headers === "object" &&
+    typeof value.body !== "undefined"
+  );
+}
+
+function isRedirectResponse(result: any): result is Response {
+  if (!isResponse(result)) {
+    return false;
+  }
+
+  let status = result.status;
+  let location = result.headers.get("Location");
+  return status >= 300 && status <= 399 && location != null;
+}
+
+function isValidMethod(method: string): method is FormMethod | V7_FormMethod {
+  return validRequestMethods.has(method.toLowerCase() as FormMethod);
+}
+
+function isMutationMethod(
+  method: string
+): method is MutationFormMethod | V7_MutationFormMethod {
+  return validMutationMethods.has(method.toLowerCase() as MutationFormMethod);
+}
+
+async function resolveNavigationDeferredResults(
+  matches: (AgnosticDataRouteMatch | null)[],
+  results: Record<string, DataResult>,
+  signal: AbortSignal,
+  currentMatches: AgnosticDataRouteMatch[],
+  currentLoaderData: RouteData
+) {
+  let entries = Object.entries(results);
+  for (let index = 0; index < entries.length; index++) {
+    let [routeId, result] = entries[index];
+    let match = matches.find((m) => m?.route.id === routeId);
+    // If we don't have a match, then we can have a deferred result to do
+    // anything with.  This is for revalidating fetchers where the route was
+    // removed during HMR
+    if (!match) {
+      continue;
+    }
+
+    let currentMatch = currentMatches.find(
+      (m) => m.route.id === match!.route.id
+    );
+    let isRevalidatingLoader =
+      currentMatch != null &&
+      !isNewRouteInstance(currentMatch, match) &&
+      (currentLoaderData && currentLoaderData[match.route.id]) !== undefined;
+
+    if (isDeferredResult(result) && isRevalidatingLoader) {
+      // Note: we do not have to touch activeDeferreds here since we race them
+      // against the signal in resolveDeferredData and they'll get aborted
+      // there if needed
+      await resolveDeferredData(result, signal, false).then((result) => {
+        if (result) {
+          results[routeId] = result;
+        }
+      });
+    }
+  }
+}
+
+async function resolveFetcherDeferredResults(
+  matches: (AgnosticDataRouteMatch | null)[],
+  results: Record<string, DataResult>,
+  revalidatingFetchers: RevalidatingFetcher[]
+) {
+  for (let index = 0; index < revalidatingFetchers.length; index++) {
+    let { key, routeId, controller } = revalidatingFetchers[index];
+    let result = results[key];
+    let match = matches.find((m) => m?.route.id === routeId);
+    // If we don't have a match, then we can have a deferred result to do
+    // anything with.  This is for revalidating fetchers where the route was
+    // removed during HMR
+    if (!match) {
+      continue;
+    }
+
+    if (isDeferredResult(result)) {
+      // Note: we do not have to touch activeDeferreds here since we race them
+      // against the signal in resolveDeferredData and they'll get aborted
+      // there if needed
+      invariant(
+        controller,
+        "Expected an AbortController for revalidating fetcher deferred result"
+      );
+      await resolveDeferredData(result, controller.signal, true).then(
+        (result) => {
+          if (result) {
+            results[key] = result;
+          }
+        }
+      );
+    }
+  }
+}
+
+async function resolveDeferredData(
+  result: DeferredResult,
+  signal: AbortSignal,
+  unwrap = false
+): Promise<SuccessResult | ErrorResult | undefined> {
+  let aborted = await result.deferredData.resolveData(signal);
+  if (aborted) {
+    return;
+  }
+
+  if (unwrap) {
+    try {
+      return {
+        type: ResultType.data,
+        data: result.deferredData.unwrappedData,
+      };
+    } catch (e) {
+      // Handle any TrackedPromise._error values encountered while unwrapping
+      return {
+        type: ResultType.error,
+        error: e,
+      };
+    }
+  }
+
+  return {
+    type: ResultType.data,
+    data: result.deferredData.data,
+  };
+}
+
+function hasNakedIndexQuery(search: string): boolean {
+  return new URLSearchParams(search).getAll("index").some((v) => v === "");
+}
+
+function getTargetMatch(
+  matches: AgnosticDataRouteMatch[],
+  location: Location | string
+) {
+  let search =
+    typeof location === "string" ? parsePath(location).search : location.search;
+  if (
+    matches[matches.length - 1].route.index &&
+    hasNakedIndexQuery(search || "")
+  ) {
+    // Return the leaf index route when index is present
+    return matches[matches.length - 1];
+  }
+  // Otherwise grab the deepest "path contributing" match (ignoring index and
+  // pathless layout routes)
+  let pathMatches = getPathContributingMatches(matches);
+  return pathMatches[pathMatches.length - 1];
+}
+
+function getSubmissionFromNavigation(
+  navigation: Navigation
+): Submission | undefined {
+  let { formMethod, formAction, formEncType, text, formData, json } =
+    navigation;
+  if (!formMethod || !formAction || !formEncType) {
+    return;
+  }
+
+  if (text != null) {
+    return {
+      formMethod,
+      formAction,
+      formEncType,
+      formData: undefined,
+      json: undefined,
+      text,
+    };
+  } else if (formData != null) {
+    return {
+      formMethod,
+      formAction,
+      formEncType,
+      formData,
+      json: undefined,
+      text: undefined,
+    };
+  } else if (json !== undefined) {
+    return {
+      formMethod,
+      formAction,
+      formEncType,
+      formData: undefined,
+      json,
+      text: undefined,
+    };
+  }
+}
+
+function getLoadingNavigation(
+  location: Location,
+  submission?: Submission
+): NavigationStates["Loading"] {
+  if (submission) {
+    let navigation: NavigationStates["Loading"] = {
+      state: "loading",
+      location,
+      formMethod: submission.formMethod,
+      formAction: submission.formAction,
+      formEncType: submission.formEncType,
+      formData: submission.formData,
+      json: submission.json,
+      text: submission.text,
+    };
+    return navigation;
+  } else {
+    let navigation: NavigationStates["Loading"] = {
+      state: "loading",
+      location,
+      formMethod: undefined,
+      formAction: undefined,
+      formEncType: undefined,
+      formData: undefined,
+      json: undefined,
+      text: undefined,
+    };
+    return navigation;
+  }
+}
+
+function getSubmittingNavigation(
+  location: Location,
+  submission: Submission
+): NavigationStates["Submitting"] {
+  let navigation: NavigationStates["Submitting"] = {
+    state: "submitting",
+    location,
+    formMethod: submission.formMethod,
+    formAction: submission.formAction,
+    formEncType: submission.formEncType,
+    formData: submission.formData,
+    json: submission.json,
+    text: submission.text,
+  };
+  return navigation;
+}
+
+function getLoadingFetcher(
+  submission?: Submission,
+  data?: Fetcher["data"]
+): FetcherStates["Loading"] {
+  if (submission) {
+    let fetcher: FetcherStates["Loading"] = {
+      state: "loading",
+      formMethod: submission.formMethod,
+      formAction: submission.formAction,
+      formEncType: submission.formEncType,
+      formData: submission.formData,
+      json: submission.json,
+      text: submission.text,
+      data,
+    };
+    return fetcher;
+  } else {
+    let fetcher: FetcherStates["Loading"] = {
+      state: "loading",
+      formMethod: undefined,
+      formAction: undefined,
+      formEncType: undefined,
+      formData: undefined,
+      json: undefined,
+      text: undefined,
+      data,
+    };
+    return fetcher;
+  }
+}
+
+function getSubmittingFetcher(
+  submission: Submission,
+  existingFetcher?: Fetcher
+): FetcherStates["Submitting"] {
+  let fetcher: FetcherStates["Submitting"] = {
+    state: "submitting",
+    formMethod: submission.formMethod,
+    formAction: submission.formAction,
+    formEncType: submission.formEncType,
+    formData: submission.formData,
+    json: submission.json,
+    text: submission.text,
+    data: existingFetcher ? existingFetcher.data : undefined,
+  };
+  return fetcher;
+}
+
+function getDoneFetcher(data: Fetcher["data"]): FetcherStates["Idle"] {
+  let fetcher: FetcherStates["Idle"] = {
+    state: "idle",
+    formMethod: undefined,
+    formAction: undefined,
+    formEncType: undefined,
+    formData: undefined,
+    json: undefined,
+    text: undefined,
+    data,
+  };
+  return fetcher;
+}
+
+function restoreAppliedTransitions(
+  _window: Window,
+  transitions: Map<string, Set<string>>
+) {
+  try {
+    let sessionPositions = _window.sessionStorage.getItem(
+      TRANSITIONS_STORAGE_KEY
+    );
+    if (sessionPositions) {
+      let json = JSON.parse(sessionPositions);
+      for (let [k, v] of Object.entries(json || {})) {
+        if (v && Array.isArray(v)) {
+          transitions.set(k, new Set(v || []));
+        }
+      }
+    }
+  } catch (e) {
+    // no-op, use default empty object
+  }
+}
+
+function persistAppliedTransitions(
+  _window: Window,
+  transitions: Map<string, Set<string>>
+) {
+  if (transitions.size > 0) {
+    let json: Record<string, string[]> = {};
+    for (let [k, v] of transitions) {
+      json[k] = [...v];
+    }
+    try {
+      _window.sessionStorage.setItem(
+        TRANSITIONS_STORAGE_KEY,
+        JSON.stringify(json)
+      );
+    } catch (error) {
+      warning(
+        false,
+        `Failed to save applied view transitions in sessionStorage (${error}).`
+      );
+    }
+  }
+}
+//#endregion
Index: frontend/node_modules/@remix-run/router/utils.ts
===================================================================
--- frontend/node_modules/@remix-run/router/utils.ts	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/@remix-run/router/utils.ts	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,1743 @@
+import type { Location, Path, To } from "./history";
+import { invariant, parsePath, warning } from "./history";
+
+/**
+ * Map of routeId -> data returned from a loader/action/error
+ */
+export interface RouteData {
+  [routeId: string]: any;
+}
+
+export enum ResultType {
+  data = "data",
+  deferred = "deferred",
+  redirect = "redirect",
+  error = "error",
+}
+
+/**
+ * Successful result from a loader or action
+ */
+export interface SuccessResult {
+  type: ResultType.data;
+  data: unknown;
+  statusCode?: number;
+  headers?: Headers;
+}
+
+/**
+ * Successful defer() result from a loader or action
+ */
+export interface DeferredResult {
+  type: ResultType.deferred;
+  deferredData: DeferredData;
+  statusCode?: number;
+  headers?: Headers;
+}
+
+/**
+ * Redirect result from a loader or action
+ */
+export interface RedirectResult {
+  type: ResultType.redirect;
+  // We keep the raw Response for redirects so we can return it verbatim
+  response: Response;
+}
+
+/**
+ * Unsuccessful result from a loader or action
+ */
+export interface ErrorResult {
+  type: ResultType.error;
+  error: unknown;
+  statusCode?: number;
+  headers?: Headers;
+}
+
+/**
+ * Result from a loader or action - potentially successful or unsuccessful
+ */
+export type DataResult =
+  | SuccessResult
+  | DeferredResult
+  | RedirectResult
+  | ErrorResult;
+
+type LowerCaseFormMethod = "get" | "post" | "put" | "patch" | "delete";
+type UpperCaseFormMethod = Uppercase<LowerCaseFormMethod>;
+
+/**
+ * Users can specify either lowercase or uppercase form methods on `<Form>`,
+ * useSubmit(), `<fetcher.Form>`, etc.
+ */
+export type HTMLFormMethod = LowerCaseFormMethod | UpperCaseFormMethod;
+
+/**
+ * Active navigation/fetcher form methods are exposed in lowercase on the
+ * RouterState
+ */
+export type FormMethod = LowerCaseFormMethod;
+export type MutationFormMethod = Exclude<FormMethod, "get">;
+
+/**
+ * In v7, active navigation/fetcher form methods are exposed in uppercase on the
+ * RouterState.  This is to align with the normalization done via fetch().
+ */
+export type V7_FormMethod = UpperCaseFormMethod;
+export type V7_MutationFormMethod = Exclude<V7_FormMethod, "GET">;
+
+export type FormEncType =
+  | "application/x-www-form-urlencoded"
+  | "multipart/form-data"
+  | "application/json"
+  | "text/plain";
+
+// Thanks https://github.com/sindresorhus/type-fest!
+type JsonObject = { [Key in string]: JsonValue } & {
+  [Key in string]?: JsonValue | undefined;
+};
+type JsonArray = JsonValue[] | readonly JsonValue[];
+type JsonPrimitive = string | number | boolean | null;
+type JsonValue = JsonPrimitive | JsonObject | JsonArray;
+
+/**
+ * @private
+ * Internal interface to pass around for action submissions, not intended for
+ * external consumption
+ */
+export type Submission =
+  | {
+      formMethod: FormMethod | V7_FormMethod;
+      formAction: string;
+      formEncType: FormEncType;
+      formData: FormData;
+      json: undefined;
+      text: undefined;
+    }
+  | {
+      formMethod: FormMethod | V7_FormMethod;
+      formAction: string;
+      formEncType: FormEncType;
+      formData: undefined;
+      json: JsonValue;
+      text: undefined;
+    }
+  | {
+      formMethod: FormMethod | V7_FormMethod;
+      formAction: string;
+      formEncType: FormEncType;
+      formData: undefined;
+      json: undefined;
+      text: string;
+    };
+
+/**
+ * @private
+ * Arguments passed to route loader/action functions.  Same for now but we keep
+ * this as a private implementation detail in case they diverge in the future.
+ */
+interface DataFunctionArgs<Context> {
+  request: Request;
+  params: Params;
+  context?: Context;
+}
+
+// TODO: (v7) Change the defaults from any to unknown in and remove Remix wrappers:
+//   ActionFunction, ActionFunctionArgs, LoaderFunction, LoaderFunctionArgs
+//   Also, make them a type alias instead of an interface
+
+/**
+ * Arguments passed to loader functions
+ */
+export interface LoaderFunctionArgs<Context = any>
+  extends DataFunctionArgs<Context> {}
+
+/**
+ * Arguments passed to action functions
+ */
+export interface ActionFunctionArgs<Context = any>
+  extends DataFunctionArgs<Context> {}
+
+/**
+ * Loaders and actions can return anything except `undefined` (`null` is a
+ * valid return value if there is no data to return).  Responses are preferred
+ * and will ease any future migration to Remix
+ */
+type DataFunctionValue = Response | NonNullable<unknown> | null;
+
+type DataFunctionReturnValue = Promise<DataFunctionValue> | DataFunctionValue;
+
+/**
+ * Route loader function signature
+ */
+export type LoaderFunction<Context = any> = {
+  (
+    args: LoaderFunctionArgs<Context>,
+    handlerCtx?: unknown
+  ): DataFunctionReturnValue;
+} & { hydrate?: boolean };
+
+/**
+ * Route action function signature
+ */
+export interface ActionFunction<Context = any> {
+  (
+    args: ActionFunctionArgs<Context>,
+    handlerCtx?: unknown
+  ): DataFunctionReturnValue;
+}
+
+/**
+ * Arguments passed to shouldRevalidate function
+ */
+export interface ShouldRevalidateFunctionArgs {
+  currentUrl: URL;
+  currentParams: AgnosticDataRouteMatch["params"];
+  nextUrl: URL;
+  nextParams: AgnosticDataRouteMatch["params"];
+  formMethod?: Submission["formMethod"];
+  formAction?: Submission["formAction"];
+  formEncType?: Submission["formEncType"];
+  text?: Submission["text"];
+  formData?: Submission["formData"];
+  json?: Submission["json"];
+  actionStatus?: number;
+  actionResult?: any;
+  defaultShouldRevalidate: boolean;
+}
+
+/**
+ * Route shouldRevalidate function signature.  This runs after any submission
+ * (navigation or fetcher), so we flatten the navigation/fetcher submission
+ * onto the arguments.  It shouldn't matter whether it came from a navigation
+ * or a fetcher, what really matters is the URLs and the formData since loaders
+ * have to re-run based on the data models that were potentially mutated.
+ */
+export interface ShouldRevalidateFunction {
+  (args: ShouldRevalidateFunctionArgs): boolean;
+}
+
+/**
+ * Function provided by the framework-aware layers to set `hasErrorBoundary`
+ * from the framework-aware `errorElement` prop
+ *
+ * @deprecated Use `mapRouteProperties` instead
+ */
+export interface DetectErrorBoundaryFunction {
+  (route: AgnosticRouteObject): boolean;
+}
+
+export interface DataStrategyMatch
+  extends AgnosticRouteMatch<string, AgnosticDataRouteObject> {
+  shouldLoad: boolean;
+  resolve: (
+    handlerOverride?: (
+      handler: (ctx?: unknown) => DataFunctionReturnValue
+    ) => DataFunctionReturnValue
+  ) => Promise<DataStrategyResult>;
+}
+
+export interface DataStrategyFunctionArgs<Context = any>
+  extends DataFunctionArgs<Context> {
+  matches: DataStrategyMatch[];
+  fetcherKey: string | null;
+}
+
+/**
+ * Result from a loader or action called via dataStrategy
+ */
+export interface DataStrategyResult {
+  type: "data" | "error";
+  result: unknown; // data, Error, Response, DeferredData, DataWithResponseInit
+}
+
+export interface DataStrategyFunction {
+  (args: DataStrategyFunctionArgs): Promise<Record<string, DataStrategyResult>>;
+}
+
+export type AgnosticPatchRoutesOnNavigationFunctionArgs<
+  O extends AgnosticRouteObject = AgnosticRouteObject,
+  M extends AgnosticRouteMatch = AgnosticRouteMatch
+> = {
+  signal: AbortSignal;
+  path: string;
+  matches: M[];
+  fetcherKey: string | undefined;
+  patch: (routeId: string | null, children: O[]) => void;
+};
+
+export type AgnosticPatchRoutesOnNavigationFunction<
+  O extends AgnosticRouteObject = AgnosticRouteObject,
+  M extends AgnosticRouteMatch = AgnosticRouteMatch
+> = (
+  opts: AgnosticPatchRoutesOnNavigationFunctionArgs<O, M>
+) => void | Promise<void>;
+
+/**
+ * Function provided by the framework-aware layers to set any framework-specific
+ * properties from framework-agnostic properties
+ */
+export interface MapRoutePropertiesFunction {
+  (route: AgnosticRouteObject): {
+    hasErrorBoundary: boolean;
+  } & Record<string, any>;
+}
+
+/**
+ * Keys we cannot change from within a lazy() function. We spread all other keys
+ * onto the route. Either they're meaningful to the router, or they'll get
+ * ignored.
+ */
+export type ImmutableRouteKey =
+  | "lazy"
+  | "caseSensitive"
+  | "path"
+  | "id"
+  | "index"
+  | "children";
+
+export const immutableRouteKeys = new Set<ImmutableRouteKey>([
+  "lazy",
+  "caseSensitive",
+  "path",
+  "id",
+  "index",
+  "children",
+]);
+
+type RequireOne<T, Key = keyof T> = Exclude<
+  {
+    [K in keyof T]: K extends Key ? Omit<T, K> & Required<Pick<T, K>> : never;
+  }[keyof T],
+  undefined
+>;
+
+/**
+ * lazy() function to load a route definition, which can add non-matching
+ * related properties to a route
+ */
+export interface LazyRouteFunction<R extends AgnosticRouteObject> {
+  (): Promise<RequireOne<Omit<R, ImmutableRouteKey>>>;
+}
+
+/**
+ * Base RouteObject with common props shared by all types of routes
+ */
+type AgnosticBaseRouteObject = {
+  caseSensitive?: boolean;
+  path?: string;
+  id?: string;
+  loader?: LoaderFunction | boolean;
+  action?: ActionFunction | boolean;
+  hasErrorBoundary?: boolean;
+  shouldRevalidate?: ShouldRevalidateFunction;
+  handle?: any;
+  lazy?: LazyRouteFunction<AgnosticBaseRouteObject>;
+};
+
+/**
+ * Index routes must not have children
+ */
+export type AgnosticIndexRouteObject = AgnosticBaseRouteObject & {
+  children?: undefined;
+  index: true;
+};
+
+/**
+ * Non-index routes may have children, but cannot have index
+ */
+export type AgnosticNonIndexRouteObject = AgnosticBaseRouteObject & {
+  children?: AgnosticRouteObject[];
+  index?: false;
+};
+
+/**
+ * A route object represents a logical route, with (optionally) its child
+ * routes organized in a tree-like structure.
+ */
+export type AgnosticRouteObject =
+  | AgnosticIndexRouteObject
+  | AgnosticNonIndexRouteObject;
+
+export type AgnosticDataIndexRouteObject = AgnosticIndexRouteObject & {
+  id: string;
+};
+
+export type AgnosticDataNonIndexRouteObject = AgnosticNonIndexRouteObject & {
+  children?: AgnosticDataRouteObject[];
+  id: string;
+};
+
+/**
+ * A data route object, which is just a RouteObject with a required unique ID
+ */
+export type AgnosticDataRouteObject =
+  | AgnosticDataIndexRouteObject
+  | AgnosticDataNonIndexRouteObject;
+
+export type RouteManifest = Record<string, AgnosticDataRouteObject | undefined>;
+
+// Recursive helper for finding path parameters in the absence of wildcards
+type _PathParam<Path extends string> =
+  // split path into individual path segments
+  Path extends `${infer L}/${infer R}`
+    ? _PathParam<L> | _PathParam<R>
+    : // find params after `:`
+    Path extends `:${infer Param}`
+    ? Param extends `${infer Optional}?`
+      ? Optional
+      : Param
+    : // otherwise, there aren't any params present
+      never;
+
+/**
+ * Examples:
+ * "/a/b/*" -> "*"
+ * ":a" -> "a"
+ * "/a/:b" -> "b"
+ * "/a/blahblahblah:b" -> "b"
+ * "/:a/:b" -> "a" | "b"
+ * "/:a/b/:c/*" -> "a" | "c" | "*"
+ */
+export type PathParam<Path extends string> =
+  // check if path is just a wildcard
+  Path extends "*" | "/*"
+    ? "*"
+    : // look for wildcard at the end of the path
+    Path extends `${infer Rest}/*`
+    ? "*" | _PathParam<Rest>
+    : // look for params in the absence of wildcards
+      _PathParam<Path>;
+
+// Attempt to parse the given string segment. If it fails, then just return the
+// plain string type as a default fallback. Otherwise, return the union of the
+// parsed string literals that were referenced as dynamic segments in the route.
+export type ParamParseKey<Segment extends string> =
+  // if you could not find path params, fallback to `string`
+  [PathParam<Segment>] extends [never] ? string : PathParam<Segment>;
+
+/**
+ * The parameters that were parsed from the URL path.
+ */
+export type Params<Key extends string = string> = {
+  readonly [key in Key]: string | undefined;
+};
+
+/**
+ * A RouteMatch contains info about how a route matched a URL.
+ */
+export interface AgnosticRouteMatch<
+  ParamKey extends string = string,
+  RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject
+> {
+  /**
+   * The names and values of dynamic parameters in the URL.
+   */
+  params: Params<ParamKey>;
+  /**
+   * The portion of the URL pathname that was matched.
+   */
+  pathname: string;
+  /**
+   * The portion of the URL pathname that was matched before child routes.
+   */
+  pathnameBase: string;
+  /**
+   * The route object that was used to match.
+   */
+  route: RouteObjectType;
+}
+
+export interface AgnosticDataRouteMatch
+  extends AgnosticRouteMatch<string, AgnosticDataRouteObject> {}
+
+function isIndexRoute(
+  route: AgnosticRouteObject
+): route is AgnosticIndexRouteObject {
+  return route.index === true;
+}
+
+// Walk the route tree generating unique IDs where necessary, so we are working
+// solely with AgnosticDataRouteObject's within the Router
+export function convertRoutesToDataRoutes(
+  routes: AgnosticRouteObject[],
+  mapRouteProperties: MapRoutePropertiesFunction,
+  parentPath: string[] = [],
+  manifest: RouteManifest = {}
+): AgnosticDataRouteObject[] {
+  return routes.map((route, index) => {
+    let treePath = [...parentPath, String(index)];
+    let id = typeof route.id === "string" ? route.id : treePath.join("-");
+    invariant(
+      route.index !== true || !route.children,
+      `Cannot specify children on an index route`
+    );
+    invariant(
+      !manifest[id],
+      `Found a route id collision on id "${id}".  Route ` +
+        "id's must be globally unique within Data Router usages"
+    );
+
+    if (isIndexRoute(route)) {
+      let indexRoute: AgnosticDataIndexRouteObject = {
+        ...route,
+        ...mapRouteProperties(route),
+        id,
+      };
+      manifest[id] = indexRoute;
+      return indexRoute;
+    } else {
+      let pathOrLayoutRoute: AgnosticDataNonIndexRouteObject = {
+        ...route,
+        ...mapRouteProperties(route),
+        id,
+        children: undefined,
+      };
+      manifest[id] = pathOrLayoutRoute;
+
+      if (route.children) {
+        pathOrLayoutRoute.children = convertRoutesToDataRoutes(
+          route.children,
+          mapRouteProperties,
+          treePath,
+          manifest
+        );
+      }
+
+      return pathOrLayoutRoute;
+    }
+  });
+}
+
+/**
+ * Matches the given routes to a location and returns the match data.
+ *
+ * @see https://reactrouter.com/v6/utils/match-routes
+ */
+export function matchRoutes<
+  RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject
+>(
+  routes: RouteObjectType[],
+  locationArg: Partial<Location> | string,
+  basename = "/"
+): AgnosticRouteMatch<string, RouteObjectType>[] | null {
+  return matchRoutesImpl(routes, locationArg, basename, false);
+}
+
+export function matchRoutesImpl<
+  RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject
+>(
+  routes: RouteObjectType[],
+  locationArg: Partial<Location> | string,
+  basename: string,
+  allowPartial: boolean
+): AgnosticRouteMatch<string, RouteObjectType>[] | null {
+  let location =
+    typeof locationArg === "string" ? parsePath(locationArg) : locationArg;
+
+  let pathname = stripBasename(location.pathname || "/", basename);
+
+  if (pathname == null) {
+    return null;
+  }
+
+  let branches = flattenRoutes(routes);
+  rankRouteBranches(branches);
+
+  let matches = null;
+  for (let i = 0; matches == null && i < branches.length; ++i) {
+    // Incoming pathnames are generally encoded from either window.location
+    // or from router.navigate, but we want to match against the unencoded
+    // paths in the route definitions.  Memory router locations won't be
+    // encoded here but there also shouldn't be anything to decode so this
+    // should be a safe operation.  This avoids needing matchRoutes to be
+    // history-aware.
+    let decoded = decodePath(pathname);
+    matches = matchRouteBranch<string, RouteObjectType>(
+      branches[i],
+      decoded,
+      allowPartial
+    );
+  }
+
+  return matches;
+}
+
+export interface UIMatch<Data = unknown, Handle = unknown> {
+  id: string;
+  pathname: string;
+  params: AgnosticRouteMatch["params"];
+  data: Data;
+  handle: Handle;
+}
+
+export function convertRouteMatchToUiMatch(
+  match: AgnosticDataRouteMatch,
+  loaderData: RouteData
+): UIMatch {
+  let { route, pathname, params } = match;
+  return {
+    id: route.id,
+    pathname,
+    params,
+    data: loaderData[route.id],
+    handle: route.handle,
+  };
+}
+
+interface RouteMeta<
+  RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject
+> {
+  relativePath: string;
+  caseSensitive: boolean;
+  childrenIndex: number;
+  route: RouteObjectType;
+}
+
+interface RouteBranch<
+  RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject
+> {
+  path: string;
+  score: number;
+  routesMeta: RouteMeta<RouteObjectType>[];
+}
+
+function flattenRoutes<
+  RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject
+>(
+  routes: RouteObjectType[],
+  branches: RouteBranch<RouteObjectType>[] = [],
+  parentsMeta: RouteMeta<RouteObjectType>[] = [],
+  parentPath = ""
+): RouteBranch<RouteObjectType>[] {
+  let flattenRoute = (
+    route: RouteObjectType,
+    index: number,
+    relativePath?: string
+  ) => {
+    let meta: RouteMeta<RouteObjectType> = {
+      relativePath:
+        relativePath === undefined ? route.path || "" : relativePath,
+      caseSensitive: route.caseSensitive === true,
+      childrenIndex: index,
+      route,
+    };
+
+    if (meta.relativePath.startsWith("/")) {
+      invariant(
+        meta.relativePath.startsWith(parentPath),
+        `Absolute route path "${meta.relativePath}" nested under path ` +
+          `"${parentPath}" is not valid. An absolute child route path ` +
+          `must start with the combined path of all its parent routes.`
+      );
+
+      meta.relativePath = meta.relativePath.slice(parentPath.length);
+    }
+
+    let path = joinPaths([parentPath, meta.relativePath]);
+    let routesMeta = parentsMeta.concat(meta);
+
+    // Add the children before adding this route to the array, so we traverse the
+    // route tree depth-first and child routes appear before their parents in
+    // the "flattened" version.
+    if (route.children && route.children.length > 0) {
+      invariant(
+        // Our types know better, but runtime JS may not!
+        // @ts-expect-error
+        route.index !== true,
+        `Index routes must not have child routes. Please remove ` +
+          `all child routes from route path "${path}".`
+      );
+      flattenRoutes(route.children, branches, routesMeta, path);
+    }
+
+    // Routes without a path shouldn't ever match by themselves unless they are
+    // index routes, so don't add them to the list of possible branches.
+    if (route.path == null && !route.index) {
+      return;
+    }
+
+    branches.push({
+      path,
+      score: computeScore(path, route.index),
+      routesMeta,
+    });
+  };
+  routes.forEach((route, index) => {
+    // coarse-grain check for optional params
+    if (route.path === "" || !route.path?.includes("?")) {
+      flattenRoute(route, index);
+    } else {
+      for (let exploded of explodeOptionalSegments(route.path)) {
+        flattenRoute(route, index, exploded);
+      }
+    }
+  });
+
+  return branches;
+}
+
+/**
+ * Computes all combinations of optional path segments for a given path,
+ * excluding combinations that are ambiguous and of lower priority.
+ *
+ * For example, `/one/:two?/three/:four?/:five?` explodes to:
+ * - `/one/three`
+ * - `/one/:two/three`
+ * - `/one/three/:four`
+ * - `/one/three/:five`
+ * - `/one/:two/three/:four`
+ * - `/one/:two/three/:five`
+ * - `/one/three/:four/:five`
+ * - `/one/:two/three/:four/:five`
+ */
+function explodeOptionalSegments(path: string): string[] {
+  let segments = path.split("/");
+  if (segments.length === 0) return [];
+
+  let [first, ...rest] = segments;
+
+  // Optional path segments are denoted by a trailing `?`
+  let isOptional = first.endsWith("?");
+  // Compute the corresponding required segment: `foo?` -> `foo`
+  let required = first.replace(/\?$/, "");
+
+  if (rest.length === 0) {
+    // Intepret empty string as omitting an optional segment
+    // `["one", "", "three"]` corresponds to omitting `:two` from `/one/:two?/three` -> `/one/three`
+    return isOptional ? [required, ""] : [required];
+  }
+
+  let restExploded = explodeOptionalSegments(rest.join("/"));
+
+  let result: string[] = [];
+
+  // All child paths with the prefix.  Do this for all children before the
+  // optional version for all children, so we get consistent ordering where the
+  // parent optional aspect is preferred as required.  Otherwise, we can get
+  // child sections interspersed where deeper optional segments are higher than
+  // parent optional segments, where for example, /:two would explode _earlier_
+  // then /:one.  By always including the parent as required _for all children_
+  // first, we avoid this issue
+  result.push(
+    ...restExploded.map((subpath) =>
+      subpath === "" ? required : [required, subpath].join("/")
+    )
+  );
+
+  // Then, if this is an optional value, add all child versions without
+  if (isOptional) {
+    result.push(...restExploded);
+  }
+
+  // for absolute paths, ensure `/` instead of empty segment
+  return result.map((exploded) =>
+    path.startsWith("/") && exploded === "" ? "/" : exploded
+  );
+}
+
+function rankRouteBranches(branches: RouteBranch[]): void {
+  branches.sort((a, b) =>
+    a.score !== b.score
+      ? b.score - a.score // Higher score first
+      : compareIndexes(
+          a.routesMeta.map((meta) => meta.childrenIndex),
+          b.routesMeta.map((meta) => meta.childrenIndex)
+        )
+  );
+}
+
+const paramRe = /^:[\w-]+$/;
+const dynamicSegmentValue = 3;
+const indexRouteValue = 2;
+const emptySegmentValue = 1;
+const staticSegmentValue = 10;
+const splatPenalty = -2;
+const isSplat = (s: string) => s === "*";
+
+function computeScore(path: string, index: boolean | undefined): number {
+  let segments = path.split("/");
+  let initialScore = segments.length;
+  if (segments.some(isSplat)) {
+    initialScore += splatPenalty;
+  }
+
+  if (index) {
+    initialScore += indexRouteValue;
+  }
+
+  return segments
+    .filter((s) => !isSplat(s))
+    .reduce(
+      (score, segment) =>
+        score +
+        (paramRe.test(segment)
+          ? dynamicSegmentValue
+          : segment === ""
+          ? emptySegmentValue
+          : staticSegmentValue),
+      initialScore
+    );
+}
+
+function compareIndexes(a: number[], b: number[]): number {
+  let siblings =
+    a.length === b.length && a.slice(0, -1).every((n, i) => n === b[i]);
+
+  return siblings
+    ? // If two routes are siblings, we should try to match the earlier sibling
+      // first. This allows people to have fine-grained control over the matching
+      // behavior by simply putting routes with identical paths in the order they
+      // want them tried.
+      a[a.length - 1] - b[b.length - 1]
+    : // Otherwise, it doesn't really make sense to rank non-siblings by index,
+      // so they sort equally.
+      0;
+}
+
+function matchRouteBranch<
+  ParamKey extends string = string,
+  RouteObjectType extends AgnosticRouteObject = AgnosticRouteObject
+>(
+  branch: RouteBranch<RouteObjectType>,
+  pathname: string,
+  allowPartial = false
+): AgnosticRouteMatch<ParamKey, RouteObjectType>[] | null {
+  let { routesMeta } = branch;
+
+  let matchedParams = {};
+  let matchedPathname = "/";
+  let matches: AgnosticRouteMatch<ParamKey, RouteObjectType>[] = [];
+  for (let i = 0; i < routesMeta.length; ++i) {
+    let meta = routesMeta[i];
+    let end = i === routesMeta.length - 1;
+    let remainingPathname =
+      matchedPathname === "/"
+        ? pathname
+        : pathname.slice(matchedPathname.length) || "/";
+    let match = matchPath(
+      { path: meta.relativePath, caseSensitive: meta.caseSensitive, end },
+      remainingPathname
+    );
+
+    let route = meta.route;
+
+    if (
+      !match &&
+      end &&
+      allowPartial &&
+      !routesMeta[routesMeta.length - 1].route.index
+    ) {
+      match = matchPath(
+        {
+          path: meta.relativePath,
+          caseSensitive: meta.caseSensitive,
+          end: false,
+        },
+        remainingPathname
+      );
+    }
+
+    if (!match) {
+      return null;
+    }
+
+    Object.assign(matchedParams, match.params);
+
+    matches.push({
+      // TODO: Can this as be avoided?
+      params: matchedParams as Params<ParamKey>,
+      pathname: joinPaths([matchedPathname, match.pathname]),
+      pathnameBase: normalizePathname(
+        joinPaths([matchedPathname, match.pathnameBase])
+      ),
+      route,
+    });
+
+    if (match.pathnameBase !== "/") {
+      matchedPathname = joinPaths([matchedPathname, match.pathnameBase]);
+    }
+  }
+
+  return matches;
+}
+
+/**
+ * Returns a path with params interpolated.
+ *
+ * @see https://reactrouter.com/v6/utils/generate-path
+ */
+export function generatePath<Path extends string>(
+  originalPath: Path,
+  params: {
+    [key in PathParam<Path>]: string | null;
+  } = {} as any
+): string {
+  let path: string = originalPath;
+  if (path.endsWith("*") && path !== "*" && !path.endsWith("/*")) {
+    warning(
+      false,
+      `Route path "${path}" will be treated as if it were ` +
+        `"${path.replace(/\*$/, "/*")}" because the \`*\` character must ` +
+        `always follow a \`/\` in the pattern. To get rid of this warning, ` +
+        `please change the route path to "${path.replace(/\*$/, "/*")}".`
+    );
+    path = path.replace(/\*$/, "/*") as Path;
+  }
+
+  // ensure `/` is added at the beginning if the path is absolute
+  const prefix = path.startsWith("/") ? "/" : "";
+
+  const stringify = (p: any) =>
+    p == null ? "" : typeof p === "string" ? p : String(p);
+
+  const segments = path
+    .split(/\/+/)
+    .map((segment, index, array) => {
+      const isLastSegment = index === array.length - 1;
+
+      // only apply the splat if it's the last segment
+      if (isLastSegment && segment === "*") {
+        const star = "*" as PathParam<Path>;
+        // Apply the splat
+        return stringify(params[star]);
+      }
+
+      const keyMatch = segment.match(/^:([\w-]+)(\??)$/);
+      if (keyMatch) {
+        const [, key, optional] = keyMatch;
+        let param = params[key as PathParam<Path>];
+        invariant(optional === "?" || param != null, `Missing ":${key}" param`);
+        return stringify(param);
+      }
+
+      // Remove any optional markers from optional static segments
+      return segment.replace(/\?$/g, "");
+    })
+    // Remove empty segments
+    .filter((segment) => !!segment);
+
+  return prefix + segments.join("/");
+}
+
+/**
+ * A PathPattern is used to match on some portion of a URL pathname.
+ */
+export interface PathPattern<Path extends string = string> {
+  /**
+   * A string to match against a URL pathname. May contain `:id`-style segments
+   * to indicate placeholders for dynamic parameters. May also end with `/*` to
+   * indicate matching the rest of the URL pathname.
+   */
+  path: Path;
+  /**
+   * Should be `true` if the static portions of the `path` should be matched in
+   * the same case.
+   */
+  caseSensitive?: boolean;
+  /**
+   * Should be `true` if this pattern should match the entire URL pathname.
+   */
+  end?: boolean;
+}
+
+/**
+ * A PathMatch contains info about how a PathPattern matched on a URL pathname.
+ */
+export interface PathMatch<ParamKey extends string = string> {
+  /**
+   * The names and values of dynamic parameters in the URL.
+   */
+  params: Params<ParamKey>;
+  /**
+   * The portion of the URL pathname that was matched.
+   */
+  pathname: string;
+  /**
+   * The portion of the URL pathname that was matched before child routes.
+   */
+  pathnameBase: string;
+  /**
+   * The pattern that was used to match.
+   */
+  pattern: PathPattern;
+}
+
+type Mutable<T> = {
+  -readonly [P in keyof T]: T[P];
+};
+
+/**
+ * Performs pattern matching on a URL pathname and returns information about
+ * the match.
+ *
+ * @see https://reactrouter.com/v6/utils/match-path
+ */
+export function matchPath<
+  ParamKey extends ParamParseKey<Path>,
+  Path extends string
+>(
+  pattern: PathPattern<Path> | Path,
+  pathname: string
+): PathMatch<ParamKey> | null {
+  if (typeof pattern === "string") {
+    pattern = { path: pattern, caseSensitive: false, end: true };
+  }
+
+  let [matcher, compiledParams] = compilePath(
+    pattern.path,
+    pattern.caseSensitive,
+    pattern.end
+  );
+
+  let match = pathname.match(matcher);
+  if (!match) return null;
+
+  let matchedPathname = match[0];
+  let pathnameBase = matchedPathname.replace(/(.)\/+$/, "$1");
+  let captureGroups = match.slice(1);
+  let params: Params = compiledParams.reduce<Mutable<Params>>(
+    (memo, { paramName, isOptional }, index) => {
+      // We need to compute the pathnameBase here using the raw splat value
+      // instead of using params["*"] later because it will be decoded then
+      if (paramName === "*") {
+        let splatValue = captureGroups[index] || "";
+        pathnameBase = matchedPathname
+          .slice(0, matchedPathname.length - splatValue.length)
+          .replace(/(.)\/+$/, "$1");
+      }
+
+      const value = captureGroups[index];
+      if (isOptional && !value) {
+        memo[paramName] = undefined;
+      } else {
+        memo[paramName] = (value || "").replace(/%2F/g, "/");
+      }
+      return memo;
+    },
+    {}
+  );
+
+  return {
+    params,
+    pathname: matchedPathname,
+    pathnameBase,
+    pattern,
+  };
+}
+
+type CompiledPathParam = { paramName: string; isOptional?: boolean };
+
+function compilePath(
+  path: string,
+  caseSensitive = false,
+  end = true
+): [RegExp, CompiledPathParam[]] {
+  warning(
+    path === "*" || !path.endsWith("*") || path.endsWith("/*"),
+    `Route path "${path}" will be treated as if it were ` +
+      `"${path.replace(/\*$/, "/*")}" because the \`*\` character must ` +
+      `always follow a \`/\` in the pattern. To get rid of this warning, ` +
+      `please change the route path to "${path.replace(/\*$/, "/*")}".`
+  );
+
+  let params: CompiledPathParam[] = [];
+  let regexpSource =
+    "^" +
+    path
+      .replace(/\/*\*?$/, "") // Ignore trailing / and /*, we'll handle it below
+      .replace(/^\/*/, "/") // Make sure it has a leading /
+      .replace(/[\\.*+^${}|()[\]]/g, "\\$&") // Escape special regex chars
+      .replace(
+        /\/:([\w-]+)(\?)?/g,
+        (_: string, paramName: string, isOptional) => {
+          params.push({ paramName, isOptional: isOptional != null });
+          return isOptional ? "/?([^\\/]+)?" : "/([^\\/]+)";
+        }
+      );
+
+  if (path.endsWith("*")) {
+    params.push({ paramName: "*" });
+    regexpSource +=
+      path === "*" || path === "/*"
+        ? "(.*)$" // Already matched the initial /, just match the rest
+        : "(?:\\/(.+)|\\/*)$"; // Don't include the / in params["*"]
+  } else if (end) {
+    // When matching to the end, ignore trailing slashes
+    regexpSource += "\\/*$";
+  } else if (path !== "" && path !== "/") {
+    // If our path is non-empty and contains anything beyond an initial slash,
+    // then we have _some_ form of path in our regex, so we should expect to
+    // match only if we find the end of this path segment.  Look for an optional
+    // non-captured trailing slash (to match a portion of the URL) or the end
+    // of the path (if we've matched to the end).  We used to do this with a
+    // word boundary but that gives false positives on routes like
+    // /user-preferences since `-` counts as a word boundary.
+    regexpSource += "(?:(?=\\/|$))";
+  } else {
+    // Nothing to match for "" or "/"
+  }
+
+  let matcher = new RegExp(regexpSource, caseSensitive ? undefined : "i");
+
+  return [matcher, params];
+}
+
+export function decodePath(value: string) {
+  try {
+    return value
+      .split("/")
+      .map((v) => decodeURIComponent(v).replace(/\//g, "%2F"))
+      .join("/");
+  } catch (error) {
+    warning(
+      false,
+      `The URL path "${value}" could not be decoded because it is is a ` +
+        `malformed URL segment. This is probably due to a bad percent ` +
+        `encoding (${error}).`
+    );
+
+    return value;
+  }
+}
+
+/**
+ * @private
+ */
+export function stripBasename(
+  pathname: string,
+  basename: string
+): string | null {
+  if (basename === "/") return pathname;
+
+  if (!pathname.toLowerCase().startsWith(basename.toLowerCase())) {
+    return null;
+  }
+
+  // We want to leave trailing slash behavior in the user's control, so if they
+  // specify a basename with a trailing slash, we should support it
+  let startIndex = basename.endsWith("/")
+    ? basename.length - 1
+    : basename.length;
+  let nextChar = pathname.charAt(startIndex);
+  if (nextChar && nextChar !== "/") {
+    // pathname does not start with basename/
+    return null;
+  }
+
+  return pathname.slice(startIndex) || "/";
+}
+
+const ABSOLUTE_URL_REGEX = /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i;
+export const isAbsoluteUrl = (url: string) => ABSOLUTE_URL_REGEX.test(url);
+
+/**
+ * Returns a resolved path object relative to the given pathname.
+ *
+ * @see https://reactrouter.com/v6/utils/resolve-path
+ */
+export function resolvePath(to: To, fromPathname = "/"): Path {
+  let {
+    pathname: toPathname,
+    search = "",
+    hash = "",
+  } = typeof to === "string" ? parsePath(to) : to;
+
+  let pathname: string;
+  if (toPathname) {
+    if (isAbsoluteUrl(toPathname)) {
+      pathname = toPathname;
+    } else {
+      if (toPathname.includes("//")) {
+        let oldPathname = toPathname;
+        toPathname = toPathname.replace(/\/\/+/g, "/");
+        warning(
+          false,
+          `Pathnames cannot have embedded double slashes - normalizing ` +
+            `${oldPathname} -> ${toPathname}`
+        );
+      }
+      if (toPathname.startsWith("/")) {
+        pathname = resolvePathname(toPathname.substring(1), "/");
+      } else {
+        pathname = resolvePathname(toPathname, fromPathname);
+      }
+    }
+  } else {
+    pathname = fromPathname;
+  }
+
+  return {
+    pathname,
+    search: normalizeSearch(search),
+    hash: normalizeHash(hash),
+  };
+}
+
+function resolvePathname(relativePath: string, fromPathname: string): string {
+  let segments = fromPathname.replace(/\/+$/, "").split("/");
+  let relativeSegments = relativePath.split("/");
+
+  relativeSegments.forEach((segment) => {
+    if (segment === "..") {
+      // Keep the root "" segment so the pathname starts at /
+      if (segments.length > 1) segments.pop();
+    } else if (segment !== ".") {
+      segments.push(segment);
+    }
+  });
+
+  return segments.length > 1 ? segments.join("/") : "/";
+}
+
+function getInvalidPathError(
+  char: string,
+  field: string,
+  dest: string,
+  path: Partial<Path>
+) {
+  return (
+    `Cannot include a '${char}' character in a manually specified ` +
+    `\`to.${field}\` field [${JSON.stringify(
+      path
+    )}].  Please separate it out to the ` +
+    `\`to.${dest}\` field. Alternatively you may provide the full path as ` +
+    `a string in <Link to="..."> and the router will parse it for you.`
+  );
+}
+
+/**
+ * @private
+ *
+ * When processing relative navigation we want to ignore ancestor routes that
+ * do not contribute to the path, such that index/pathless layout routes don't
+ * interfere.
+ *
+ * For example, when moving a route element into an index route and/or a
+ * pathless layout route, relative link behavior contained within should stay
+ * the same.  Both of the following examples should link back to the root:
+ *
+ *   <Route path="/">
+ *     <Route path="accounts" element={<Link to=".."}>
+ *   </Route>
+ *
+ *   <Route path="/">
+ *     <Route path="accounts">
+ *       <Route element={<AccountsLayout />}>       // <-- Does not contribute
+ *         <Route index element={<Link to=".."} />  // <-- Does not contribute
+ *       </Route
+ *     </Route>
+ *   </Route>
+ */
+export function getPathContributingMatches<
+  T extends AgnosticRouteMatch = AgnosticRouteMatch
+>(matches: T[]) {
+  return matches.filter(
+    (match, index) =>
+      index === 0 || (match.route.path && match.route.path.length > 0)
+  );
+}
+
+// Return the array of pathnames for the current route matches - used to
+// generate the routePathnames input for resolveTo()
+export function getResolveToMatches<
+  T extends AgnosticRouteMatch = AgnosticRouteMatch
+>(matches: T[], v7_relativeSplatPath: boolean) {
+  let pathMatches = getPathContributingMatches(matches);
+
+  // When v7_relativeSplatPath is enabled, use the full pathname for the leaf
+  // match so we include splat values for "." links.  See:
+  // https://github.com/remix-run/react-router/issues/11052#issuecomment-1836589329
+  if (v7_relativeSplatPath) {
+    return pathMatches.map((match, idx) =>
+      idx === pathMatches.length - 1 ? match.pathname : match.pathnameBase
+    );
+  }
+
+  return pathMatches.map((match) => match.pathnameBase);
+}
+
+/**
+ * @private
+ */
+export function resolveTo(
+  toArg: To,
+  routePathnames: string[],
+  locationPathname: string,
+  isPathRelative = false
+): Path {
+  let to: Partial<Path>;
+  if (typeof toArg === "string") {
+    to = parsePath(toArg);
+  } else {
+    to = { ...toArg };
+
+    invariant(
+      !to.pathname || !to.pathname.includes("?"),
+      getInvalidPathError("?", "pathname", "search", to)
+    );
+    invariant(
+      !to.pathname || !to.pathname.includes("#"),
+      getInvalidPathError("#", "pathname", "hash", to)
+    );
+    invariant(
+      !to.search || !to.search.includes("#"),
+      getInvalidPathError("#", "search", "hash", to)
+    );
+  }
+
+  let isEmptyPath = toArg === "" || to.pathname === "";
+  let toPathname = isEmptyPath ? "/" : to.pathname;
+
+  let from: string;
+
+  // Routing is relative to the current pathname if explicitly requested.
+  //
+  // If a pathname is explicitly provided in `to`, it should be relative to the
+  // route context. This is explained in `Note on `<Link to>` values` in our
+  // migration guide from v5 as a means of disambiguation between `to` values
+  // that begin with `/` and those that do not. However, this is problematic for
+  // `to` values that do not provide a pathname. `to` can simply be a search or
+  // hash string, in which case we should assume that the navigation is relative
+  // to the current location's pathname and *not* the route pathname.
+  if (toPathname == null) {
+    from = locationPathname;
+  } else {
+    let routePathnameIndex = routePathnames.length - 1;
+
+    // With relative="route" (the default), each leading .. segment means
+    // "go up one route" instead of "go up one URL segment".  This is a key
+    // difference from how <a href> works and a major reason we call this a
+    // "to" value instead of a "href".
+    if (!isPathRelative && toPathname.startsWith("..")) {
+      let toSegments = toPathname.split("/");
+
+      while (toSegments[0] === "..") {
+        toSegments.shift();
+        routePathnameIndex -= 1;
+      }
+
+      to.pathname = toSegments.join("/");
+    }
+
+    from = routePathnameIndex >= 0 ? routePathnames[routePathnameIndex] : "/";
+  }
+
+  let path = resolvePath(to, from);
+
+  // Ensure the pathname has a trailing slash if the original "to" had one
+  let hasExplicitTrailingSlash =
+    toPathname && toPathname !== "/" && toPathname.endsWith("/");
+  // Or if this was a link to the current path which has a trailing slash
+  let hasCurrentTrailingSlash =
+    (isEmptyPath || toPathname === ".") && locationPathname.endsWith("/");
+  if (
+    !path.pathname.endsWith("/") &&
+    (hasExplicitTrailingSlash || hasCurrentTrailingSlash)
+  ) {
+    path.pathname += "/";
+  }
+
+  return path;
+}
+
+/**
+ * @private
+ */
+export function getToPathname(to: To): string | undefined {
+  // Empty strings should be treated the same as / paths
+  return to === "" || (to as Path).pathname === ""
+    ? "/"
+    : typeof to === "string"
+    ? parsePath(to).pathname
+    : to.pathname;
+}
+
+/**
+ * @private
+ */
+export const joinPaths = (paths: string[]): string =>
+  paths.join("/").replace(/\/\/+/g, "/");
+
+/**
+ * @private
+ */
+export const normalizePathname = (pathname: string): string =>
+  pathname.replace(/\/+$/, "").replace(/^\/*/, "/");
+
+/**
+ * @private
+ */
+export const normalizeSearch = (search: string): string =>
+  !search || search === "?"
+    ? ""
+    : search.startsWith("?")
+    ? search
+    : "?" + search;
+
+/**
+ * @private
+ */
+export const normalizeHash = (hash: string): string =>
+  !hash || hash === "#" ? "" : hash.startsWith("#") ? hash : "#" + hash;
+
+export type JsonFunction = <Data>(
+  data: Data,
+  init?: number | ResponseInit
+) => Response;
+
+/**
+ * This is a shortcut for creating `application/json` responses. Converts `data`
+ * to JSON and sets the `Content-Type` header.
+ *
+ * @deprecated The `json` method is deprecated in favor of returning raw objects.
+ * This method will be removed in v7.
+ */
+export const json: JsonFunction = (data, init = {}) => {
+  let responseInit = typeof init === "number" ? { status: init } : init;
+
+  let headers = new Headers(responseInit.headers);
+  if (!headers.has("Content-Type")) {
+    headers.set("Content-Type", "application/json; charset=utf-8");
+  }
+
+  return new Response(JSON.stringify(data), {
+    ...responseInit,
+    headers,
+  });
+};
+
+export class DataWithResponseInit<D> {
+  type: string = "DataWithResponseInit";
+  data: D;
+  init: ResponseInit | null;
+
+  constructor(data: D, init?: ResponseInit) {
+    this.data = data;
+    this.init = init || null;
+  }
+}
+
+/**
+ * Create "responses" that contain `status`/`headers` without forcing
+ * serialization into an actual `Response` - used by Remix single fetch
+ */
+export function data<D>(data: D, init?: number | ResponseInit) {
+  return new DataWithResponseInit(
+    data,
+    typeof init === "number" ? { status: init } : init
+  );
+}
+
+export interface TrackedPromise extends Promise<any> {
+  _tracked?: boolean;
+  _data?: any;
+  _error?: any;
+}
+
+export class AbortedDeferredError extends Error {}
+
+export class DeferredData {
+  private pendingKeysSet: Set<string> = new Set<string>();
+  private controller: AbortController;
+  private abortPromise: Promise<void>;
+  private unlistenAbortSignal: () => void;
+  private subscribers: Set<(aborted: boolean, settledKey?: string) => void> =
+    new Set();
+  data: Record<string, unknown>;
+  init?: ResponseInit;
+  deferredKeys: string[] = [];
+
+  constructor(data: Record<string, unknown>, responseInit?: ResponseInit) {
+    invariant(
+      data && typeof data === "object" && !Array.isArray(data),
+      "defer() only accepts plain objects"
+    );
+
+    // Set up an AbortController + Promise we can race against to exit early
+    // cancellation
+    let reject: (e: AbortedDeferredError) => void;
+    this.abortPromise = new Promise((_, r) => (reject = r));
+    this.controller = new AbortController();
+    let onAbort = () =>
+      reject(new AbortedDeferredError("Deferred data aborted"));
+    this.unlistenAbortSignal = () =>
+      this.controller.signal.removeEventListener("abort", onAbort);
+    this.controller.signal.addEventListener("abort", onAbort);
+
+    this.data = Object.entries(data).reduce(
+      (acc, [key, value]) =>
+        Object.assign(acc, {
+          [key]: this.trackPromise(key, value),
+        }),
+      {}
+    );
+
+    if (this.done) {
+      // All incoming values were resolved
+      this.unlistenAbortSignal();
+    }
+
+    this.init = responseInit;
+  }
+
+  private trackPromise(
+    key: string,
+    value: Promise<unknown> | unknown
+  ): TrackedPromise | unknown {
+    if (!(value instanceof Promise)) {
+      return value;
+    }
+
+    this.deferredKeys.push(key);
+    this.pendingKeysSet.add(key);
+
+    // We store a little wrapper promise that will be extended with
+    // _data/_error props upon resolve/reject
+    let promise: TrackedPromise = Promise.race([value, this.abortPromise]).then(
+      (data) => this.onSettle(promise, key, undefined, data as unknown),
+      (error) => this.onSettle(promise, key, error as unknown)
+    );
+
+    // Register rejection listeners to avoid uncaught promise rejections on
+    // errors or aborted deferred values
+    promise.catch(() => {});
+
+    Object.defineProperty(promise, "_tracked", { get: () => true });
+    return promise;
+  }
+
+  private onSettle(
+    promise: TrackedPromise,
+    key: string,
+    error: unknown,
+    data?: unknown
+  ): unknown {
+    if (
+      this.controller.signal.aborted &&
+      error instanceof AbortedDeferredError
+    ) {
+      this.unlistenAbortSignal();
+      Object.defineProperty(promise, "_error", { get: () => error });
+      return Promise.reject(error);
+    }
+
+    this.pendingKeysSet.delete(key);
+
+    if (this.done) {
+      // Nothing left to abort!
+      this.unlistenAbortSignal();
+    }
+
+    // If the promise was resolved/rejected with undefined, we'll throw an error as you
+    // should always resolve with a value or null
+    if (error === undefined && data === undefined) {
+      let undefinedError = new Error(
+        `Deferred data for key "${key}" resolved/rejected with \`undefined\`, ` +
+          `you must resolve/reject with a value or \`null\`.`
+      );
+      Object.defineProperty(promise, "_error", { get: () => undefinedError });
+      this.emit(false, key);
+      return Promise.reject(undefinedError);
+    }
+
+    if (data === undefined) {
+      Object.defineProperty(promise, "_error", { get: () => error });
+      this.emit(false, key);
+      return Promise.reject(error);
+    }
+
+    Object.defineProperty(promise, "_data", { get: () => data });
+    this.emit(false, key);
+    return data;
+  }
+
+  private emit(aborted: boolean, settledKey?: string) {
+    this.subscribers.forEach((subscriber) => subscriber(aborted, settledKey));
+  }
+
+  subscribe(fn: (aborted: boolean, settledKey?: string) => void) {
+    this.subscribers.add(fn);
+    return () => this.subscribers.delete(fn);
+  }
+
+  cancel() {
+    this.controller.abort();
+    this.pendingKeysSet.forEach((v, k) => this.pendingKeysSet.delete(k));
+    this.emit(true);
+  }
+
+  async resolveData(signal: AbortSignal) {
+    let aborted = false;
+    if (!this.done) {
+      let onAbort = () => this.cancel();
+      signal.addEventListener("abort", onAbort);
+      aborted = await new Promise((resolve) => {
+        this.subscribe((aborted) => {
+          signal.removeEventListener("abort", onAbort);
+          if (aborted || this.done) {
+            resolve(aborted);
+          }
+        });
+      });
+    }
+    return aborted;
+  }
+
+  get done() {
+    return this.pendingKeysSet.size === 0;
+  }
+
+  get unwrappedData() {
+    invariant(
+      this.data !== null && this.done,
+      "Can only unwrap data on initialized and settled deferreds"
+    );
+
+    return Object.entries(this.data).reduce(
+      (acc, [key, value]) =>
+        Object.assign(acc, {
+          [key]: unwrapTrackedPromise(value),
+        }),
+      {}
+    );
+  }
+
+  get pendingKeys() {
+    return Array.from(this.pendingKeysSet);
+  }
+}
+
+function isTrackedPromise(value: any): value is TrackedPromise {
+  return (
+    value instanceof Promise && (value as TrackedPromise)._tracked === true
+  );
+}
+
+function unwrapTrackedPromise(value: any) {
+  if (!isTrackedPromise(value)) {
+    return value;
+  }
+
+  if (value._error) {
+    throw value._error;
+  }
+  return value._data;
+}
+
+export type DeferFunction = (
+  data: Record<string, unknown>,
+  init?: number | ResponseInit
+) => DeferredData;
+
+/**
+ * @deprecated The `defer` method is deprecated in favor of returning raw
+ * objects. This method will be removed in v7.
+ */
+export const defer: DeferFunction = (data, init = {}) => {
+  let responseInit = typeof init === "number" ? { status: init } : init;
+
+  return new DeferredData(data, responseInit);
+};
+
+export type RedirectFunction = (
+  url: string,
+  init?: number | ResponseInit
+) => Response;
+
+/**
+ * A redirect response. Sets the status code and the `Location` header.
+ * Defaults to "302 Found".
+ */
+export const redirect: RedirectFunction = (url, init = 302) => {
+  let responseInit = init;
+  if (typeof responseInit === "number") {
+    responseInit = { status: responseInit };
+  } else if (typeof responseInit.status === "undefined") {
+    responseInit.status = 302;
+  }
+
+  let headers = new Headers(responseInit.headers);
+  headers.set("Location", url);
+
+  return new Response(null, {
+    ...responseInit,
+    headers,
+  });
+};
+
+/**
+ * A redirect response that will force a document reload to the new location.
+ * Sets the status code and the `Location` header.
+ * Defaults to "302 Found".
+ */
+export const redirectDocument: RedirectFunction = (url, init) => {
+  let response = redirect(url, init);
+  response.headers.set("X-Remix-Reload-Document", "true");
+  return response;
+};
+
+/**
+ * A redirect response that will perform a `history.replaceState` instead of a
+ * `history.pushState` for client-side navigation redirects.
+ * Sets the status code and the `Location` header.
+ * Defaults to "302 Found".
+ */
+export const replace: RedirectFunction = (url, init) => {
+  let response = redirect(url, init);
+  response.headers.set("X-Remix-Replace", "true");
+  return response;
+};
+
+export type ErrorResponse = {
+  status: number;
+  statusText: string;
+  data: any;
+};
+
+/**
+ * @private
+ * Utility class we use to hold auto-unwrapped 4xx/5xx Response bodies
+ *
+ * We don't export the class for public use since it's an implementation
+ * detail, but we export the interface above so folks can build their own
+ * abstractions around instances via isRouteErrorResponse()
+ */
+export class ErrorResponseImpl implements ErrorResponse {
+  status: number;
+  statusText: string;
+  data: any;
+  private error?: Error;
+  private internal: boolean;
+
+  constructor(
+    status: number,
+    statusText: string | undefined,
+    data: any,
+    internal = false
+  ) {
+    this.status = status;
+    this.statusText = statusText || "";
+    this.internal = internal;
+    if (data instanceof Error) {
+      this.data = data.toString();
+      this.error = data;
+    } else {
+      this.data = data;
+    }
+  }
+}
+
+/**
+ * Check if the given error is an ErrorResponse generated from a 4xx/5xx
+ * Response thrown from an action/loader
+ */
+export function isRouteErrorResponse(error: any): error is ErrorResponse {
+  return (
+    error != null &&
+    typeof error.status === "number" &&
+    typeof error.statusText === "string" &&
+    typeof error.internal === "boolean" &&
+    "data" in error
+  );
+}