@funstack/router 0.0.7 → 0.0.9

package/dist/docs/LearnSsrWithLoadersPage.tsx

@@ -0,0 +1,141 @@
+import { CodeBlock } from "../components/CodeBlock.js";
+
+export function LearnSsrWithLoadersPage() {
+  return (
+    <div className="learn-content">
+      <h2>SSR with Loaders</h2>
+
+      <p className="page-intro">
+        When you have a server runtime that can execute loaders at request time,
+        set <code>runLoaders: true</code> in the <code>ssr</code> config to
+        produce fully rendered HTML &mdash; including loader data &mdash; on the
+        server.
+      </p>
+
+      <section>
+        <h3>
+          How <code>runLoaders</code> Works
+        </h3>
+        <p>
+          As described in the{" "}
+          <a href="/learn/ssr/static-site-generation">Static Site Generation</a>{" "}
+          guide, the <code>ssr</code> prop enables path-based route matching
+          during SSR. By default, routes with loaders are skipped. Setting{" "}
+          <code>runLoaders: true</code> changes this: those routes are matched
+          and their loaders execute during SSR.
+        </p>
+        <CodeBlock language="tsx">{`// Without runLoaders (default): loaders are skipped
+<Router routes={routes} ssr={{ path: "/dashboard" }} />
+
+// With runLoaders: loaders execute during SSR
+<Router routes={routes} ssr={{ path: "/dashboard", runLoaders: true }} />`}</CodeBlock>
+        <p>
+          When loaders run during SSR, their results are passed to components as
+          the <code>data</code> prop. The server-rendered HTML includes the
+          loader content, so users see the full page immediately.
+        </p>
+      </section>
+
+      <section>
+        <h3>Example</h3>
+        <p>Consider a dashboard route with a loader that fetches user data:</p>
+        <CodeBlock language="tsx">{`const routes = [
+  route({
+    component: AppShell,
+    children: [
+      route({ path: "/", component: HomePage }),
+      route({
+        path: "/dashboard",
+        component: DashboardPage,
+        loader: dashboardLoader,
+      }),
+    ],
+  }),
+];
+
+// Without runLoaders: DashboardPage is skipped during SSR.
+// Users see only the app shell; dashboard content fills in after hydration.
+<Router routes={routes} ssr={{ path: "/dashboard" }} />
+
+// With runLoaders: dashboardLoader executes during SSR.
+// DashboardPage renders with data — users see the full page immediately.
+<Router routes={routes} ssr={{ path: "/dashboard", runLoaders: true }} />`}</CodeBlock>
+      </section>
+
+      <section>
+        <h3>Server Setup</h3>
+        <p>
+          Unlike{" "}
+          <a href="/learn/ssr/static-site-generation">static site generation</a>
+          , SSR with loaders requires a server runtime that can handle requests
+          and render pages dynamically. Your server needs to know the requested
+          pathname and pass it to the router:
+        </p>
+        <CodeBlock language="tsx">{`// App.tsx — receives the pathname from the server
+export default function App({ pathname }: { pathname: string }) {
+  return (
+    <Router
+      routes={routes}
+      ssr={{ path: pathname, runLoaders: true }}
+    />
+  );
+}`}</CodeBlock>
+        <p>
+          Because loaders run during SSR, they must be able to execute in the
+          server environment. If your loaders call browser-only APIs, you may
+          need to adjust them or use environment checks.
+        </p>
+      </section>
+
+      <section>
+        <h3>
+          Comparison with <code>ssr</code> (No Loaders)
+        </h3>
+        <p>
+          The choice between <code>ssr</code> alone and{" "}
+          <code>ssr + runLoaders</code> depends on your deployment model:
+        </p>
+        <ul>
+          <li>
+            <strong>
+              <code>{"ssr={{ path }}"}</code>
+            </strong>{" "}
+            &mdash; Ideal for static site generation. Pages without loaders are
+            fully pre-rendered. Pages with loaders show the app shell during SSR
+            and fill in data after hydration. No server runtime needed.
+          </li>
+          <li>
+            <strong>
+              <code>{"ssr={{ path, runLoaders: true }}"}</code>
+            </strong>{" "}
+            &mdash; Ideal for dynamic SSR with a server runtime. All matched
+            routes render during SSR, including those with loaders. Users see
+            the complete page immediately.
+          </li>
+        </ul>
+      </section>
+
+      <section>
+        <h3>Key Takeaways</h3>
+        <ul>
+          <li>
+            Set <code>runLoaders: true</code> to execute loaders during SSR for
+            fully rendered server output
+          </li>
+          <li>
+            Loader results are passed to components as the <code>data</code>{" "}
+            prop during SSR, just as they are on the client
+          </li>
+          <li>
+            This mode requires a server runtime that handles requests
+            dynamically
+          </li>
+          <li>
+            After hydration, the real URL from the Navigation API takes over and{" "}
+            <code>ssr</code> is ignored
+          </li>
+        </ul>
+      </section>
+    </div>
+  );
+}

package/dist/docs/LearnTransitionsPage.tsx

@@ -6,7 +6,7 @@ export function LearnTransitionsPage() {
       <h2>Controlling Transitions</h2>
 
       <p className="page-intro">
-        FUNSTACK Router wraps every navigation in React's{" "}
+        FUNSTACK Router wraps navigations in React's{" "}
         <code>startTransition</code>, which means the old UI may stay visible
         while the new route loads. This page explains how this works and how to
         control it.
@@ -16,11 +16,11 @@ export function LearnTransitionsPage() {
         <h3>Navigations as Transitions</h3>
         <p>
           When the user navigates, the Router updates its location state inside{" "}
-          <code>startTransition()</code>. This means React treats every
-          navigation as a transition: if an existing Suspense boundary suspends
-          (e.g., a component loading data with <code>use()</code>), React keeps
-          the old UI visible instead of immediately showing the fallback. This
-          behavior is{" "}
+          <code>startTransition()</code>. This means React treats navigations as
+          transitions: if an existing Suspense boundary suspends (e.g., a
+          component loading data with <code>use()</code>), React keeps the old
+          UI visible instead of immediately showing the fallback. This behavior
+          is{" "}
           <a href="https://react.dev/reference/react/useTransition#building-a-suspense-enabled-router">
             what React recommends for Suspense-enabled routers
           </a>
@@ -141,6 +141,80 @@ function UserDetailPage({
           transition behavior is usually the better experience.
         </p>
       </section>
+
+      <section>
+        <h3>Sync State Updates Bypass Transitions</h3>
+        <p>
+          FUNSTACK Router allows you to save state in a navigation entry, which
+          is useful for form state or other UI state that should persist when
+          the user navigates back and forth. You can update this state using the{" "}
+          <code>setState</code> and <code>resetState</code> functions passed to
+          route components. These functions use a replace navigation internally,
+          so they trigger a transition.
+        </p>
+        <p>
+          In rare cases, you may want to update navigation state without
+          triggering a transition. <code>setStateSync</code> and{" "}
+          <code>resetStateSync</code> are designed for this purpose. When you
+          call them, the Router updates the current history entry using the
+          Navigation API's <code>updateCurrentEntry()</code> method, which does
+          not trigger a navigation. The Router detects this and applies the
+          update synchronously, outside of <code>startTransition</code>. As a
+          result:
+        </p>
+        <ul>
+          <li>
+            The update is reflected in the UI immediately &mdash; there is no
+            pending phase.
+          </li>
+          <li>
+            <code>useIsPending()</code> (and the <code>isPending</code> prop)
+            will <strong>not</strong> become <code>true</code>.
+          </li>
+          <li>
+            If the update causes a component to suspend, React will show the
+            fallback immediately instead of waiting for the transition to end.
+          </li>
+        </ul>
+        <h4>When to Use Sync State Updates</h4>
+        <p>
+          When it comes to `setState` vs `setStateSync`, you can think in the
+          same way as you would with wrapping state updates in `startTransition`
+          or not. A general guideline is to{" "}
+          <strong>
+            just use <code>setState</code> (with transition)
+          </strong>{" "}
+          when you don't have a specific reason to avoid it. The exception is
+          when the state change <em>already happened</em> on the screen and you
+          just want to reflect it in the navigation entry state.
+        </p>
+        <p>
+          A typical example of this is a form where you want to save the current
+          input value in the navigation state, so that if the user navigates
+          away and then back, their input is preserved. In this case, you would
+          call <code>setStateSync</code> in the input's <code>onChange</code>{" "}
+          handler, because the state update is already reflected in the input's
+          value and you don't want to trigger a transition for this:
+        </p>
+        <CodeBlock language="tsx">{`function MyForm({ state, setStateSync }: { state: State; setStateSync: (state: State) => void }) {
+  const [inputValue, setInputValue] = useState(state.inputValue ?? "");
+
+  const handleChange = (e: React.ChangeEvent<HTMLInputElement>) => {
+    const newValue = e.target.value;
+    setInputValue(newValue);
+    setStateSync({ inputValue: newValue }); // Save to navigation state without transition
+  };
+
+  return <input value={inputValue} onChange={handleChange} />;
+}`}</CodeBlock>
+        <p>
+          In this example, using <code>setState</code> (with transition) would
+          cause the UI to enter a pending state on every keystroke, which would
+          be a poor user experience. By using <code>setStateSync</code>, the
+          navigation state updates seamlessly without triggering transitions or
+          pending states.
+        </p>
+      </section>
     </div>
   );
 }

package/dist/docs/LearnTypeSafetyPage.tsx

@@ -67,7 +67,7 @@ function UserPage({ params }: { params: { userId: string } }) {
           For explicit type annotations, use the{" "}
           <code>RouteComponentProps</code> type helper with your params type:
         </p>
-        <CodeBlock language="tsx">{`import { route, RouteComponentProps } from "@funstack/router";
+        <CodeBlock language="tsx">{`import { route, type RouteComponentProps } from "@funstack/router";
 
 // Define component with explicit props type
 function UserPage({ params }: RouteComponentProps<{ userId: string }>) {
@@ -97,7 +97,7 @@ const userRoute = route({
           for routes with loaders.
         </p>
         <CodeBlock language="tsx">{`import { use, Suspense } from "react";
-import { route, RouteComponentPropsWithData } from "@funstack/router";
+import { route, type RouteComponentPropsWithData } from "@funstack/router";
 
 interface User {
   id: string;
@@ -155,7 +155,7 @@ const userRoute = route({
           the current page). Use the <code>routeState</code> helper to define
           typed state for your routes.
         </p>
-        <CodeBlock language="tsx">{`import { route, routeState, RouteComponentProps } from "@funstack/router";
+        <CodeBlock language="tsx">{`import { routeState, RouteComponentProps } from "@funstack/router";
 
 // Define the state shape
 interface ProductListState {
@@ -209,12 +209,10 @@ function ProductListPage({
 }
 
 // Use routeState to create a typed route
-const productListRoute = routeState<ProductListState>()(
-  route({
-    path: "/products",
-    component: ProductListPage,
-  })
-);`}</CodeBlock>
+const productListRoute = routeState<ProductListState>()({
+  path: "/products",
+  component: ProductListPage,
+});`}</CodeBlock>
         <p>
           The <code>routeState</code> helper adds four props to your component:
         </p>
@@ -225,14 +223,24 @@ const productListRoute = routeState<ProductListState>()(
           </li>
           <li>
             <code>setState</code> &mdash; Navigate to the same URL with new
-            state (creates a new history entry)
+            state (creates a new history entry). Goes through a React
+            transition, so it may set <code>isPending</code> to{" "}
+            <code>true</code>.
           </li>
           <li>
             <code>setStateSync</code> &mdash; Update state synchronously without
-            creating a new history entry
+            creating a new history entry. Bypasses React transitions, so{" "}
+            <code>isPending</code> stays <code>false</code>.
           </li>
           <li>
             <code>resetState</code> &mdash; Clear the navigation state
+            asynchronously via replace navigation. Like <code>setState</code>,
+            goes through React transitions.
+          </li>
+          <li>
+            <code>resetStateSync</code> &mdash; Clear the navigation state
+            synchronously. Like <code>setStateSync</code>, bypasses React
+            transitions.
           </li>
         </ul>
 
@@ -302,20 +310,18 @@ function ProductListPage(props: Props) {
 }
 
 // Route definition with both loader and state
-const productListRoute = routeState<ProductListState>()(
-  route({
-    path: "/products",
-    component: ProductListPage,
-    loader: async (): Promise<Product[]> => {
-      const response = await fetch("/api/products");
-      return response.json();
-    },
-  })
-);`}</CodeBlock>
+const productListRoute = routeState<ProductListState>()({
+  path: "/products",
+  component: ProductListPage,
+  loader: async (): Promise<Product[]> => {
+    const response = await fetch("/api/products");
+    return response.json();
+  },
+});`}</CodeBlock>
       </section>
 
       <section>
-        <h3>Approach 2: Hooks</h3>
+        <h3 id="hooks">Approach 2: Hooks</h3>
 
         <h4>When to Use Hooks</h4>
         <p>

package/dist/docs/index.md

@@ -2,6 +2,7 @@
 
 ## Available Documentation
 
+- [Examples](./ExamplesPage.tsx)
 - [Getting Started](./GettingStartedPage.tsx)
 
 ### API Reference
@@ -16,6 +17,8 @@
 - [Navigation API](./LearnNavigationApiPage.tsx) - FUNSTACK Router is built on the Navigation API , a modern browser API that provides a unified way to handle navigation. This guide explains the key differences from the older History API and the benefits this brings to your application.
 - [Nested Routes](./LearnNestedRoutesPage.tsx) - Nested routes let you build complex page layouts where parts of the UI persist across navigation while other parts change. Think of a dashboard with a sidebar that stays in place while the main content area updates—that's nested routing in action.
 - [React Server Components](./LearnRscPage.tsx) - FUNSTACK Router is designed to work with React Server Components (RSC). The package provides a dedicated server entry point so that route definitions can live in server modules, keeping client bundle sizes small.
-- [Server-Side Rendering](./LearnSsrPage.tsx) - FUNSTACK Router supports server-side rendering with a two-stage model. During SSR, pathless (layout) routes without loaders render to produce an app shell, while path-based routes and loaders activate only after client hydration.
-- [Controlling Transitions](./LearnTransitionsPage.tsx) - FUNSTACK Router wraps every navigation in React's startTransition, which means the old UI may stay visible while the new route loads. This page explains how this works and how to control it.
+- [Static Site Generation](./LearnSsgPage.tsx) - When your server or static site generator knows the URL being rendered, you can use the ssr prop to match path-based routes during SSR. This produces richer server-rendered HTML — users see page content immediately instead of just the app shell.
+- [How SSR Works](./LearnSsrBasicPage.tsx) - FUNSTACK Router supports server-side rendering with a two-stage model. During SSR, pathless (layout) routes without loaders render to produce an app shell, while path-based routes and loaders activate only after client hydration.
+- [SSR with Loaders](./LearnSsrWithLoadersPage.tsx) - When you have a server runtime that can execute loaders at request time, set runLoaders: true in the ssr config to produce fully rendered HTML — including loader data — on the server.
+- [Controlling Transitions](./LearnTransitionsPage.tsx) - FUNSTACK Router wraps navigations in React's startTransition, which means the old UI may stay visible while the new route loads. This page explains how this works and how to control it.
 - [Type Safety](./LearnTypeSafetyPage.tsx) - FUNSTACK Router provides first-class TypeScript support, allowing you to access route params, navigation state, and loader data with full type safety. This guide covers two approaches: receiving typed data through component props (recommended) and accessing it through hooks.

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { a as LoaderArgs, c as RouteComponentProps, d as RouteDefinition, f as TypefulOpaqueRouteDefinition, i as ExtractRouteState, l as RouteComponentPropsOf, m as routeState, n as ExtractRouteId, o as OpaqueRouteDefinition, p as route, r as ExtractRouteParams, s as PathParams, t as ExtractRouteData, u as RouteComponentPropsWithData } from "./route-ClVnhrQD.mjs";
+import { a as ExtractRouteState, c as PathParams, d as RouteComponentPropsWithData, f as RouteDefinition, h as routeState, i as ExtractRouteParams, l as RouteComponentProps, m as route, n as ExtractRouteData, o as LoaderArgs, p as TypefulOpaqueRouteDefinition, r as ExtractRouteId, s as OpaqueRouteDefinition, t as ActionArgs, u as RouteComponentPropsOf } from "./route-DRcgs0Pt.mjs";
 import { ComponentType, ReactNode } from "react";
 
 //#region src/types.d.ts
@@ -27,15 +27,17 @@ type InternalRouteDefinition = {
    * - true (default): Parent does not match if no child matches
    * - false: Parent can match alone if it has a component, outlet will be null
    */
-  requireChildren?: boolean; /** Data loader function for this route */
-  loader?: (args: LoaderArgs<Record<string, string>>) => unknown; /** Component to render when this route matches */
+  requireChildren?: boolean; /** Action function for handling form submissions (POST navigations) */
+  action?: (args: ActionArgs<Record<string, string>>) => unknown; /** Data loader function for this route */
+  loader?: (args: LoaderArgs<Record<string, string>, unknown>) => unknown; /** Component to render when this route matches */
   component?: ComponentType<{
     data?: unknown;
     params?: Record<string, string>;
     state?: unknown;
     setState?: (state: unknown | ((prev: unknown) => unknown)) => Promise<void>;
     setStateSync?: (state: unknown | ((prev: unknown) => unknown)) => void;
-    resetState?: () => void;
+    resetState?: () => Promise<void>;
+    resetStateSync?: () => void;
     info?: unknown;
   }> | ReactNode;
 };
@@ -47,18 +49,13 @@ type MatchedRoute = {
   params: Record<string, string>; /** The matched pathname segment */
   pathname: string;
 };
-/**
- * A matched route with loader data.
- */
-type MatchedRouteWithData = MatchedRoute & {
-  /** Data returned from the loader (undefined if no loader) */data: unknown | undefined;
-};
 /**
  * Information passed to onNavigate callback.
  */
 type OnNavigateInfo = {
   /** Array of matched routes, or null if no routes matched */matches: readonly MatchedRoute[] | null; /** Whether the router will intercept this navigation (before user's preventDefault() call) */
-  intercepting: boolean;
+  intercepting: boolean; /** FormData from the NavigateEvent, or null for non-POST navigations */
+  formData: FormData | null;
 };
 /**
  * Options for navigation.
@@ -93,6 +90,30 @@ type OnNavigateCallback = (event: NavigateEvent, info: OnNavigateInfo) => void;
 type FallbackMode = "none" | "static";
 //#endregion
 //#region src/Router.d.ts
+/**
+ * SSR configuration for the router.
+ */
+type SSRConfig = {
+  /**
+   * Pathname to use for route matching during SSR.
+   *
+   * The router uses this pathname to match path-based routes during SSR.
+   * Route params are extracted normally.
+   */
+  path: string;
+  /**
+   * Whether to run loaders during SSR.
+   *
+   * - When `false` or omitted, routes with loaders are skipped during SSR
+   *   and the parent route renders as a shell.
+   * - When `true`, routes with loaders are matched and their loaders are
+   *   executed during SSR. The loader results are passed to components as
+   *   the `data` prop, so server-rendered HTML includes loader content.
+   *
+   * @default false
+   */
+  runLoaders?: boolean;
+};
 type RouterProps = {
   routes: RouteDefinition[];
   /**
@@ -110,11 +131,33 @@ type RouterProps = {
    * - `"static"`: Render matched routes without navigation capabilities (MPA behavior)
    */
   fallback?: FallbackMode;
+  /**
+   * SSR configuration for the router.
+   *
+   * By default (no `ssr` prop), during SSR only pathless routes match.
+   * When provided, the router uses the given pathname to match path-based
+   * routes during SSR as well.
+   *
+   * This prop is only used when the location entry is not available (during SSR
+   * or hydration). Once the client hydrates, the real URL from the Navigation API
+   * takes over.
+   *
+   * @example
+   * ```tsx
+   * // SSG: match path-based routes, skip loaders
+   * <Router routes={routes} ssr={{ path: "/about" }} />
+   *
+   * // SSR with loaders: match path-based routes including those with loaders
+   * <Router routes={routes} ssr={{ path: "/about", runLoaders: true }} />
+   * ```
+   */
+  ssr?: SSRConfig;
 };
 declare function Router({
   routes: inputRoutes,
   onNavigate,
-  fallback
+  fallback,
+  ssr
 }: RouterProps): ReactNode;
 //#endregion
 //#region src/Outlet.d.ts
@@ -260,17 +303,5 @@ declare function useRouteData<T extends TypefulOpaqueRouteDefinition<string, Rec
  */
 declare function useIsPending(): boolean;
 //#endregion
-//#region src/core/RouterAdapter.d.ts
-/**
- * Represents the current location state.
- * Abstracts NavigationHistoryEntry for static mode compatibility.
- */
-type LocationEntry = {
-  /** The current URL */url: URL; /** Unique key for this entry (used for loader caching) */
-  key: string; /** State associated with this entry */
-  state: unknown; /** Ephemeral info from current navigation (undefined if not from navigation event) */
-  info: unknown;
-};
-//#endregion
-export { type ExtractRouteData, type ExtractRouteId, type ExtractRouteParams, type ExtractRouteState, type FallbackMode, type LoaderArgs, type Location, type LocationEntry, type MatchedRoute, type MatchedRouteWithData, type NavigateOptions, type OnNavigateCallback, type OnNavigateInfo, type OpaqueRouteDefinition, Outlet, type PathParams, type RouteComponentProps, type RouteComponentPropsOf, type RouteComponentPropsWithData, type RouteDefinition, Router, type RouterProps, type TypefulOpaqueRouteDefinition, type UseBlockerOptions, route, routeState, useBlocker, useIsPending, useLocation, useNavigate, useRouteData, useRouteParams, useRouteState, useSearchParams };
+export { type ActionArgs, type ExtractRouteData, type ExtractRouteId, type ExtractRouteParams, type ExtractRouteState, type FallbackMode, type LoaderArgs, type Location, type MatchedRoute, type NavigateOptions, type OnNavigateCallback, type OnNavigateInfo, type OpaqueRouteDefinition, Outlet, type PathParams, type RouteComponentProps, type RouteComponentPropsOf, type RouteComponentPropsWithData, type RouteDefinition, Router, type RouterProps, type SSRConfig, type TypefulOpaqueRouteDefinition, type UseBlockerOptions, route, routeState, useBlocker, useIsPending, useLocation, useNavigate, useRouteData, useRouteParams, useRouteState, useSearchParams };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/types.ts","../src/Router.tsx","../src/Outlet.tsx","../src/hooks/useNavigate.ts","../src/hooks/useLocation.ts","../src/hooks/useSearchParams.ts","../src/hooks/useBlocker.ts","../src/hooks/useRouteParams.ts","../src/hooks/useRouteState.ts","../src/hooks/useRouteData.ts","../src/hooks/useIsPending.ts","../src/core/RouterAdapter.ts"],"mappings":";;;;cAGM,6BAAA;;AAFwD;;;;;;;KAgBlD,uBAAA;EAAA,CACT,6BAAA,UA4Bc;EA1Bf,IAAA,WAwBI;EAtBJ,QAAA,GAAW,uBAAA;EAiCE;;;;;;EA1Bb,KAAA;EAMA;;;;;EAAA,eAAA,YASI;EAHJ,MAAA,IAAU,IAAA,EAAM,UAAA,CAAW,MAAA,+BAKrB;EAHN,SAAA,GACI,aAAA;IACE,IAAA;IACA,MAAA,GAAS,MAAA;IACT,KAAA;IACA,QAAA,IACE,KAAA,cAAmB,IAAA,2BAChB,OAAA;IACL,YAAA,IAAgB,KAAA,cAAmB,IAAA;IACnC,UAAA;IACA,IAAA;EAAA,KAEF,SAAA;AAAA;;;;KAmBM,YAAA;EAMV,oCAJA,KAAA,EAAO,uBAAA,EAIC;EAFR,MAAA,EAAQ,MAAA,kBAQsB;EAN9B,QAAA;AAAA;;AAcF;;KARY,oBAAA,GAAuB,YAAA;EAUH,6DAR9B,IAAA;AAAA;;;;KAMU,cAAA;EAUe,4DARzB,OAAA,WAAkB,YAAA,WAQO;EANzB,YAAA;AAAA;;;;KAMU,eAAA;EAYQ,uDAVlB,OAAA,YAUkB;EARlB,KAAA,YAUA;EARA,IAAA;AAAA;;AAmBF;;KAbY,QAAA;EACV,QAAA;EACA,MAAA;EACA,IAAA;AAAA;;;;AAqBF;;;;KAXY,kBAAA,IACV,KAAA,EAAO,aAAA,EACP,IAAA,EAAM,cAAA;;;;ACrGR;;;KD8GY,YAAA;;;KC9GA,WAAA;EACV,MAAA,EAAQ,eAAA;ED5BoC;;;;AAc9C;;;ECsBE,UAAA,GAAa,kBAAA;EDjBF;;;;;;ECwBX,QAAA,GAAW,YAAA;AAAA;AAAA,iBAYG,MAAA,CAAA;EACd,MAAA,EAAQ,WAAA;EACR,UAAA;EACA;AAAA,GACC,WAAA,GAAc,SAAA;;;;;;AD7D6C;iBEM9C,MAAA,CAAA,GAAU,SAAA;;;;;;iBCAV,WAAA,CAAA,IAAgB,EAAA,UAAY,OAAA,GAAU,eAAA;;;;;;iBCAtC,WAAA,CAAA,GAAe,QAAA;;;KCJ1B,eAAA,IACH,MAAA,EACI,eAAA,GACA,MAAA,qBACE,IAAA,EAAM,eAAA,KAAoB,eAAA,GAAkB,MAAA;;;;iBAMpC,eAAA,CAAA,IAAoB,eAAA,EAAiB,eAAA;;;KCVzC,iBAAA;;;;ANFkD;EMO5D,WAAA;AAAA;;;ANSF;;;;;;;;;;;;;;;;;;;;;;;;;iBMqBgB,UAAA,CAAW,OAAA,EAAS,iBAAA;;;;;;ANrC0B;;;;;AAgB9D;;;;;;;;;;;;iBOSgB,cAAA,WACJ,4BAAA,SAER,MAAA,oCAAA,CAIF,KAAA,EAAO,CAAA,GAAI,kBAAA,CAAmB,CAAA;;;;;;APhC8B;;;;;AAgB9D;;;;;;;;;;;;;iBQUgB,aAAA,WACJ,4BAAA,SAER,MAAA,oCAAA,CAIF,KAAA,EAAO,CAAA,GAAI,iBAAA,CAAkB,CAAA;;;;;;ARjC+B;;;;;AAgB9D;;;;;;;;;;;;;;;;iBSagB,YAAA,WACJ,4BAAA,SAER,MAAA,oCAAA,CAIF,KAAA,EAAO,CAAA,GAAI,gBAAA,CAAiB,CAAA;;;;;;iBC/Bd,YAAA,CAAA;;;;;;AVL8C;KWSlD,aAAA;wBAEV,GAAA,EAAK,GAAA,EXTuC;EWW5C,GAAA,UXGiC;EWDjC,KAAA,WXEC;EWAD,IAAA;AAAA"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/types.ts","../src/Router.tsx","../src/Outlet.tsx","../src/hooks/useNavigate.ts","../src/hooks/useLocation.ts","../src/hooks/useSearchParams.ts","../src/hooks/useBlocker.ts","../src/hooks/useRouteParams.ts","../src/hooks/useRouteState.ts","../src/hooks/useRouteData.ts","../src/hooks/useIsPending.ts"],"mappings":";;;;cAGM,6BAAA;;AAFoE;;;;;;;KAgB9D,uBAAA;EAAA,CACT,6BAAA,UAyB0B;EAvB3B,IAAA,WA4Be;EA1Bf,QAAA,GAAW,uBAAA;EAgCc;;;;;;EAzBzB,KAAA;EAPA;;;;;EAaA,eAAA,YAM2B;EAA3B,MAAA,IAAU,IAAA,EAAM,UAAA,CAAW,MAAA,+BAE3B;EAAA,MAAA,IAAU,IAAA,EAAM,UAAA,CAAW,MAAA,wCAAA;EAE3B,SAAA,GACI,aAAA;IACE,IAAA;IACA,MAAA,GAAS,MAAA;IACT,KAAA;IACA,QAAA,IACE,KAAA,cAAmB,IAAA,2BAChB,OAAA;IACL,YAAA,IAAgB,KAAA,cAAmB,IAAA;IACnC,UAAA,SAAmB,OAAA;IACnB,cAAA;IACA,IAAA;EAAA,KAEF,SAAA;AAAA;;;AAmBN;KAAY,YAAA;sCAEV,KAAA,EAAO,uBAAA,EAAP;EAEA,MAAA,EAAQ,MAAA,kBAAR;EAEA,QAAA;AAAA;;;;KAcU,cAAA;EAMQ,4DAJlB,OAAA,WAAkB,YAAA,WAUR;EARV,YAAA;EAEA,QAAA,EAAU,QAAA;AAAA;;;;KAMA,eAAA;EAYA,uDAVV,OAAA;EAEA,KAAA,YASA;EAPA,IAAA;AAAA;;;AAmBF;KAbY,QAAA;EACV,QAAA;EACA,MAAA;EACA,IAAA;AAAA;;;;;AAqBF;;;KAXY,kBAAA,IACV,KAAA,EAAO,aAAA,EACP,IAAA,EAAM,cAAA;;;;;ACvGR;;KDgHY,YAAA;;;;AAhJ8D;;KCgC9D,SAAA;ED9BkC;;AAc9C;;;;ECuBE,IAAA;EDC2B;;;;;;;;;;;ECW3B,UAAA;AAAA;AAAA,KAGU,WAAA;EACV,MAAA,EAAQ,eAAA;ED3BR;;;;;;;ECmCA,UAAA,GAAa,kBAAA;EDrBc;;;;;;EC4B3B,QAAA,GAAW,YAAA;EDtBL;;;;;;;;;;;;;;;AA4BR;;;;;ECeE,GAAA,GAAM,SAAA;AAAA;AAAA,iBAYQ,MAAA,CAAA;EACd,MAAA,EAAQ,WAAA;EACR,UAAA;EACA,QAAA;EACA;AAAA,GACC,WAAA,GAAc,SAAA;;;;;;AD5GyD;iBEM1D,MAAA,CAAA,GAAU,SAAA;;;;;;iBCAV,WAAA,CAAA,IAAgB,EAAA,UAAY,OAAA,GAAU,eAAA;;;;;;iBCAtC,WAAA,CAAA,GAAe,QAAA;;;KCJ1B,eAAA,IACH,MAAA,EACI,eAAA,GACA,MAAA,qBACE,IAAA,EAAM,eAAA,KAAoB,eAAA,GAAkB,MAAA;;;;iBAMpC,eAAA,CAAA,IAAoB,eAAA,EAAiB,eAAA;;;KCVzC,iBAAA;;;;ANF8D;EMOxE,WAAA;AAAA;;;ANSF;;;;;;;;;;;;;;;;;;;;;;;;;iBMqBgB,UAAA,CAAW,OAAA,EAAS,iBAAA;;;;;;ANrCsC;;;;;AAgB1E;;;;;;;;;;;;iBOSgB,cAAA,WACJ,4BAAA,SAER,MAAA,oCAAA,CAIF,KAAA,EAAO,CAAA,GAAI,kBAAA,CAAmB,CAAA;;;;;;APhC0C;;;;;AAgB1E;;;;;;;;;;;;;iBQUgB,aAAA,WACJ,4BAAA,SAER,MAAA,oCAAA,CAIF,KAAA,EAAO,CAAA,GAAI,iBAAA,CAAkB,CAAA;;;;;;ARjC2C;;;;;AAgB1E;;;;;;;;;;;;;;;;iBSagB,YAAA,WACJ,4BAAA,SAER,MAAA,oCAAA,CAIF,KAAA,EAAO,CAAA,GAAI,gBAAA,CAAiB,CAAA;;;;;;iBC/Bd,YAAA,CAAA"}