@pithyjs/router 0.1.0-beta.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 PithyJS
+
+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.

package/README.md

@@ -0,0 +1,621 @@
+# @pithyjs/router
+
+File-based client-side router for PithyJS with guards, loaders, view transitions, and fine-grained reactivity.
+
+## Features
+
+- **File-Based Routing** - Automatic route generation from file structure
+- **Zero-Flash Navigation** - Guards execute before DOM/history mutations
+- **Data Loading** - Loaders with SWR caching and loading states
+- **Two-Phase Mounting** - Atomic DOM updates with diff-based rendering
+- **Error Boundaries** - Parent chain resolution for error components
+- **Intelligent Prefetching** - Hover, visible, and intent-based strategies
+- **View Transitions** - Smooth animations with View Transitions API
+- **Accessibility First** - Focus management, scroll restoration, screen reader announcements
+- **HMR Support** - Hot module replacement for development
+- **TypeScript** - Full type safety with strict mode
+
+## Installation
+
+<!-- @codex:auto install="@pithyjs/router" -->
+```bash
+npm install @pithyjs/router
+```
+
+```bash
+pnpm add @pithyjs/router
+```
+
+```bash
+yarn add @pithyjs/router
+```
+<!-- @codex:end -->
+
+## Quick Start
+
+### 1. Define Routes
+
+Create route files in your `src/routes/` directory:
+
+```
+src/routes/
+├── +page.ts               # /
+├── +layout.ts             # Root layout
+├── about/
+│   └── +page.ts           # /about
+└── products/
+    ├── +layout.ts         # Products layout
+    ├── +page.ts           # /products
+    ├── +loader.ts         # Products data loader
+    ├── [id]/
+    │   ├── +page.ts       # /products/:id
+    │   ├── +loader.ts     # Product details loader
+    │   └── +error.ts      # Product error boundary
+    └── +config.ts         # Products route config
+```
+
+### 2. Create Router
+
+```typescript
+// src/main.ts
+import { createRouter } from '@pithyjs/router';
+import { setupLinkInterceptor } from '@pithyjs/router/integration';
+import routes from './routes'; // Generated by Vite plugin
+
+const router = createRouter(routes, {
+  basePath: '/',
+  loadingPolicy: 'replace'
+});
+
+// Enable client-side navigation for all links
+setupLinkInterceptor(router);
+
+// Mount root outlet
+const app = document.getElementById('app');
+if (app) {
+  router.mount(app);
+}
+
+// Expose router for dev tools
+if (import.meta.env.DEV) {
+  (globalThis as any).router = router;
+}
+```
+
+### 3. Configure Vite Plugin
+
+```typescript
+// vite.config.ts
+import { defineConfig } from 'vite';
+import { pithyRouter } from '@pithyjs/vite-plugin-router';
+
+export default defineConfig({
+  plugins: [
+    pithyRouter({
+      routesDir: 'src/routes',
+      outputFile: 'src/routes.ts'
+    })
+  ]
+});
+```
+
+## Route File Conventions
+
+| File | Purpose |
+|------|---------|
+| `+page.ts` | Page component |
+| `+layout.ts` | Layout wrapper with `<div @routerOutlet>` |
+| `+loader.ts` | Data loader (runs before page render) |
+| `+error.ts` | Error boundary component |
+| `+config.ts` | Route configuration (guards, cache options) |
+| `[param]/` | Dynamic route segment |
+| `(group)/` | Route group (doesn't affect URL) |
+
+## Core Concepts
+
+### Guards (Authorization)
+
+Guards execute **before** navigation to protect routes:
+
+```typescript
+// guards/auth.ts
+import type { GuardFunction } from '@pithyjs/router';
+
+export const authGuard: GuardFunction = async ({ to, signal }) => {
+  const isAuthenticated = await checkAuth(signal);
+
+  if (!isAuthenticated) {
+    return `/login?returnUrl=${encodeURIComponent(to.path)}`;
+  }
+
+  return true; // Allow navigation
+};
+```
+
+```typescript
+// products/+config.ts
+import { authGuard } from '../guards/auth';
+
+export const guards = [authGuard];
+```
+
+### Loaders (Data Fetching)
+
+Loaders fetch data before rendering:
+
+```typescript
+// products/[id]/+loader.ts
+import type { LoaderFunction } from '@pithyjs/router';
+
+export const loader: LoaderFunction = async ({ params, signal }) => {
+  const response = await fetch(`/api/products/${params.id}`, { signal });
+
+  if (!response.ok) {
+    throw new Error(`HTTP ${response.status}`);
+  }
+
+  return response.json();
+};
+```
+
+```typescript
+// products/[id]/+page.ts
+import { html } from '@pithyjs/core';
+
+export default function ProductPage({ id, loaderData }) {
+  const product = loaderData;
+
+  return html`
+    <div>
+      <h1>{{ product.name }}</h1>
+      <p>{{ product.description }}</p>
+      <p>Price: {{ product.price }}</p>
+    </div>
+  `;
+}
+```
+
+### Layouts
+
+Layouts wrap child pages:
+
+```typescript
+// products/+layout.ts
+import { html } from '@pithyjs/core';
+
+export default function ProductsLayout() {
+  return html`
+    <div class="products-layout">
+      <aside>
+        <nav>
+          <a href="/products" @routerLink>All Products</a>
+          <a href="/products/featured" @routerLink>Featured</a>
+        </nav>
+      </aside>
+
+      <main>
+        <!-- Child pages render here -->
+        <div @routerOutlet></div>
+      </main>
+    </div>
+  `;
+}
+```
+
+### Error Boundaries
+
+Error components handle errors in child routes:
+
+```typescript
+// products/+error.ts
+import { html } from '@pithyjs/core';
+
+export default function ProductError({ error, retry }: { error: Error; retry: () => void }) {
+  return html`<div class="error"><h1>{{ error.message }}</h1><button @click="retry()">Retry</button></div>`;
+}
+```
+
+## Navigation
+
+### Declarative Navigation
+
+```html
+<!-- Basic link -->
+<a href="/products" @routerLink>Products</a>
+
+<!-- With active state -->
+<a href="/products" routerActive="active" @routerLink>Products</a>
+
+<!-- With prefetch -->
+<a href="/products" data-prefetch="hover" @routerLink>Products</a>
+
+<!-- Button navigation -->
+<button href="/dashboard" @routerLink>Go to Dashboard</button>
+```
+
+### Programmatic Navigation
+
+```typescript
+import { createRouter } from '@pithyjs/router';
+
+const router = createRouter(routes);
+
+// Basic navigation
+router.navigate('/products');
+
+// With options
+router.navigate('/products/123', {
+  replace: true,      // Replace history entry
+  skipScroll: true,   // Don't scroll to top
+  state: { from: 'search' }
+});
+
+// History navigation
+router.back();
+router.forward();
+```
+
+## Configuration
+
+### Router Options
+
+```typescript
+const router = createRouter(routes, {
+  // Core options
+  basePath: '/',                   // Base path for all routes
+  loadingPolicy: 'replace',        // 'replace' | 'overlay' | 'progress-only'
+  popstateLoading: 'none',         // Silent loaders for back/forward
+
+  // Cache options (default for all routes)
+  cache: {
+    strategy: 'swr',               // 'swr' | 'cache-first' | 'no-store'
+    ttl: 300000                    // 5 minutes
+  },
+
+  // UX options
+  scroll: {
+    enableAutoScroll: true,
+    scrollBehavior: 'smooth',
+    anchorScrollDelay: 100
+  },
+  focus: {
+    enableAutoFocus: true,
+    focusTarget: '[data-focus-target]'
+  },
+  transitions: {
+    enabled: true,
+    defaultTransition: 'fade',
+    duration: 400
+  },
+
+  // Prefetch options
+  prefetch: {
+    hoverDelay: 200,
+    visibleMargin: '200px'
+  }
+});
+```
+
+### Route-Level Configuration
+
+```typescript
+// +config.ts
+import { authGuard, adminGuard } from '../guards';
+import { lazy } from '@pithyjs/core';
+
+export const guards = [authGuard, adminGuard];
+
+export const cache = {
+  strategy: 'swr' as const,
+  ttl: 60000 // 1 minute
+};
+
+// Lazy components used in this route
+const Chart = lazy(() => import('./Chart.pithy'), { key: 'lazy-chart' });
+const Table = lazy(() => import('./Table.pithy'), { key: 'lazy-table' });
+
+// Prefetch these chunks when route is prefetched
+export const prefetchChunks = [
+  () => Chart.load(),
+  () => Table.load()
+];
+```
+
+## Advanced Features
+
+### Prefetching
+
+```typescript
+// Manual prefetch (also prefetches lazy chunks defined in +config.ts)
+await router.prefetchRoute('/products');
+```
+
+Directive-based (automatic):
+
+```html
+<a href="/products" @routerLink data-prefetch="hover">Products</a>
+<a href="/about" @routerLink data-prefetch="visible">About</a>
+<a href="/dashboard" @routerLink data-prefetch="intent">Dashboard</a>
+```
+
+When prefetching a route, the router also executes any `prefetchChunks` defined in the route's `+config.ts`. This enables prefetching lazy-loaded components along with route data.
+
+### View Transitions
+
+```typescript
+// Enable globally
+const router = createRouter(routes, {
+  transitions: {
+    enabled: true,
+    defaultTransition: 'fade',
+    duration: 300
+  }
+});
+```
+
+```html
+<!-- Custom transition name -->
+<div data-transition-name="hero">
+  <img src="/hero.jpg" alt="Hero">
+</div>
+```
+
+### Scroll Restoration
+
+```typescript
+// Automatic scroll restoration for back/forward
+router.navigate('/products'); // Scrolls to top
+
+// Manual control
+router.navigate('/products#section-2'); // Scrolls to anchor
+
+router.navigate('/products', {
+  skipScroll: true // Don't auto-scroll
+});
+```
+
+## API Reference
+
+| API | Signature | Stability | Description |
+| --- | --- | --- | --- |
+| Router | `class Router` | stable | Core router class with navigation transaction state machine |
+| state | `() => Signal<RouterState>` | stable | Get current router state as a reactive signal |
+| path | `() => () => string` | stable | Get current path as a computed reactive signal |
+| params | `() => () => RouteParams` | stable | Get current route params as a computed reactive signal |
+| query | `() => () => QueryParams` | stable | Get current query params as a computed reactive signal |
+| loaderData | `() => () => ResourceState \| null` | stable | Get current loader data as a computed reactive signal |
+| navigate | `(path: string, options?: NavigationOptions) => Promise<boolean>` | stable | Navigate to a path with two-phase commit via the pipeline |
+| back | `() => void` | stable | Go back one entry in browser history |
+| forward | `() => void` | stable | Go forward one entry in browser history |
+| mount | `(rootElement: HTMLElement) => void` | stable | Mount router to a DOM element and activate outlet routing |
+| getActiveNavId | `() => NavigationId` | experimental | Get the active navigation ID for outlet manager integration |
+| isNavActive | `(navId: NavigationId) => boolean` | experimental | Check if a navigation ID is still active |
+| prefetchRoute | `(href: string, signal: AbortSignal) => Promise<void>` | experimental | Prefetch route components using shared module cache |
+| updateRoutes | `(newRoutes: RouteNode[], options?: { source?: string }) => Promise<void>` | stable | Hot-update routes for HMR, preserving router state |
+| prefetchLoader | `(href: string, signal: AbortSignal) => Promise<void>` | experimental | Prefetch route loader data with guard checks |
+| getRouteCacheTTL | `(href: string) => Promise<number \| undefined>` | experimental | Get the configured cache TTL for a specific route |
+| dispose | `() => void` | stable | Dispose router and clean up all listeners, outlets, and navigations |
+| createRouter | `(routes: RouteNode[], config?: RouterConfig) => Router` | stable | Create a router instance with HMR hot-singleton reuse |
+
+### Matcher
+
+| API | Signature | Stability | Description |
+| --- | --- | --- | --- |
+| parseRoutePattern | `(pattern: string) => RouteSegment[]` | stable | Parse a route pattern into typed segments (static, dynamic, catch-all, group) |
+| calculateRouteScore | `(segments: RouteSegment[]) => number` | stable | Calculate route precedence score for conflict resolution |
+| normalizePath | `(path: string, policy?: TrailingSlashPolicy) => string` | stable | Normalize path according to trailing slash policy |
+| extractParams | `(pathSegments: string[], routeSegments: RouteSegment[], decodeParams?: boolean) => RouteParams` | stable | Extract parameters from a matched path using route segments |
+| matchRoute | `(path: string, pattern: string, config?: RouterConfig) => RouteMatch \| null` | stable | Check if a path matches a route pattern and return match details |
+| findBestMatch | `(path: string, patterns: string[], config?: RouterConfig) => RouteMatch \| null` | stable | Find the best matching route by highest precedence score |
+
+### Route Tree
+
+| API | Signature | Stability | Description |
+| --- | --- | --- | --- |
+| flattenRouteTree | `(routes: RouteNode[], parent?: RouteNode, ancestors?: RouteNode[]) => FlatRouteEntry[]` | experimental | Flatten hierarchical route tree into flat list with parent references |
+| buildRouteMap | `(flatRoutes: FlatRouteEntry[]) => Map<string, FlatRouteEntry>` | experimental | Build route map from flattened routes for quick lookup by ID |
+| getAncestorChain | `(routeId: string, routeMap: Map<string, FlatRouteEntry>) => RouteNode[]` | experimental | Get full ancestor chain for a route, ordered root to leaf |
+| findMatchingEntry | `(path: string, flatRoutes: FlatRouteEntry[]) => FlatRouteEntry \| null` | experimental | Find matching route entry from flattened routes for a given path |
+| extractAncestorParams | `(path: string, ancestors: RouteNode[]) => RouteParams[]` | experimental | Extract parameters for each ancestor by matching path progressively |
+| findRouteByPattern | `(routes: RouteNode[], pattern: string) => RouteNode \| null` | stable | Find a route node by exact pattern match, searching recursively |
+| collectPatterns | `(routes: RouteNode[]) => string[]` | stable | Collect all route patterns from a nested tree into a flat array |
+| mergeAncestorParams | `(paramsByLevel: RouteParams[]) => RouteParams[]` | experimental | Merge ancestor params cumulatively; child params override parent |
+
+### Guards
+
+| API | Signature | Stability | Description |
+| --- | --- | --- | --- |
+| RedirectConfig | `interface RedirectConfig` | stable | Redirect configuration for guard results with optional history replacement |
+| GuardManager | `class GuardManager` | stable | Manages route guards with zero-flash navigation and cancellation |
+| executeGuards | `(guards: GuardFunction[], context: GuardContext) => Promise<GuardExecutionResult>` | stable | Execute guards in parallel with proper cancellation support |
+| cancelGuards | `(navId: NavigationId) => void` | stable | Cancel all active guards for a navigation |
+| AuthProvider | `interface AuthProvider` | stable | Authentication provider interface for user state and permissions |
+
+### Loaders
+
+| API | Signature | Stability | Description |
+| --- | --- | --- | --- |
+| CacheOptions | `interface CacheOptions` | stable | Cache configuration with TTL and strategy for route loaders |
+| LoaderManager | `class LoaderManager` | stable | Manages route loaders with caching and cancellation support |
+| executeLoader | `<T>(routeId: string, loader: LoaderFunction<T>, context: LoaderContext, options?: CacheOptions) => Promise<T>` | stable | Execute a loader with caching and cancellation support |
+| executeRouteLoader | `<T>(routeId: string, loader: LoaderFunction<T>, context: LoaderContext, options?: CacheOptions) => Promise<T>` | stable | Execute a route loader with caching and cancellation via global manager |
+| getResourceCache | `() => ResourceCache` | stable | Get the global resource cache instance |
+
+### Prefetching
+
+| API | Signature | Stability | Description |
+| --- | --- | --- | --- |
+| PrefetchStrategy | `type PrefetchStrategy` | stable | Strategy options controlling when routes are prefetched |
+| PrefetchConfig | `interface PrefetchConfig` | stable | Fine-tune prefetch behavior with delays, thresholds, and caching |
+| PrefetchManager | `class PrefetchManager` | stable | Intelligent resource prefetching with enhanced heuristics |
+| registerLink | `(element: HTMLElement, strategy: PrefetchStrategy) => void` | stable | Register a link element for prefetching with a given strategy |
+| unregisterLink | `(element: HTMLElement) => void` | stable | Unregister a link and clean up its prefetch listeners |
+| prefetchRoute | `(href: string, strategy: PrefetchStrategy) => Promise<void>` | stable | Prefetch a route with priority handling and deduplication |
+| cancelPrefetch | `(href: string) => void` | stable | Cancel an in-flight prefetch for a specific route |
+| dispose | `() => void` | stable | Clean up all prefetch resources, requests, and timers |
+| getPrefetchManager | `() => PrefetchManager` | stable | Get the lazy-initialized global prefetch manager |
+
+### Error Handling
+
+| API | Signature | Stability | Description |
+| --- | --- | --- | --- |
+| ErrorComponentProps | `interface ErrorComponentProps` | stable | Props passed to error boundary components |
+| GlobalErrorFallback | `(props: ErrorComponentProps) => Component` | stable | Default error UI when no route-specific error.ts exists |
+| setRouteError | `(routeId: string, err: RouterError) => void` | stable | Set an error for a route, triggering reactive outlet update |
+| clearRouteError | `(routeId: string) => void` | stable | Clear error for a specific route on retry or navigation |
+| clearAllRouteErrors | `() => void` | stable | Clear all route errors on successful navigation |
+| resolveErrorImport | `(node: RouteNode, getParent: ...) => (() => Promise<unknown>) \| null` | internal | Resolve error component by walking parent chain |
+| hasErrorComponent | `(node: RouteNode) => boolean` | internal | Check if a route node has an error component |
+
+### Router Class
+
+```typescript
+class Router {
+  state(): Signal<RouterState>
+  path(): () => string
+  params(): () => RouteParams
+  query(): () => QueryParams
+  loaderData(): () => ResourceState | null
+  navigate(path: string, options?: NavigationOptions): Promise<boolean>
+  back(): void
+  forward(): void
+  mount(rootElement: HTMLElement): void
+  prefetchRoute(href: string, signal: AbortSignal): Promise<void>
+  prefetchLoader(href: string, signal: AbortSignal): Promise<void>
+  updateRoutes(newRoutes: RouteNode[], options?: { source?: string }): Promise<void>
+  dispose(): void
+}
+```
+
+### Types
+
+```typescript
+interface RouterConfig {
+  basePath?: string;
+  loadingPolicy?: 'replace' | 'overlay' | 'progress-only';
+  cache?: CacheOptions;
+  scroll?: ScrollConfig;
+  focus?: FocusConfig;
+  transitions?: ViewTransitionConfig;
+  // ... more options
+}
+
+interface NavigationOptions {
+  replace?: boolean;
+  skipScroll?: boolean;
+  state?: any;
+}
+
+type GuardFunction = (context: GuardContext) =>
+  | boolean
+  | string
+  | RedirectConfig
+  | Promise<boolean | string | RedirectConfig>;
+
+type LoaderFunction<T = any> = (context: LoaderContext) =>
+  | T
+  | Promise<T>;
+```
+
+## Documentation
+
+- **[Implementation Overview](src/router/README.md)** - Architecture and navigation flow
+- **[Core Engine](src/router/core/README.md)** - Router engine and pipeline
+- **[Features](src/router/features/README.md)** - Feature modules overview
+  - [Error Handling](src/router/features/errors/README.md)
+  - [Route Guards](src/router/features/guards/README.md)
+  - [Data Loaders](src/router/features/loaders/README.md)
+  - [Outlet System](src/router/features/outlet/README.md)
+  - [Prefetch System](src/router/features/prefetch/README.md)
+  - [UX Features](src/router/features/ux/README.md)
+- **[Integration Layer](src/router/integration/README.md)** - Directives, HMR, link interception
+- **[Error Handling Guide](ERROR_HANDLING.md)** - Complete error handling documentation
+
+## Examples
+
+### Basic Navigation
+
+```typescript
+import { createRouter } from '@pithyjs/router';
+import { effect } from '@pithyjs/signals';
+
+const router = createRouter(routes);
+
+// Navigate and check result
+const success = await router.navigate('/about');
+console.log(success); // true
+
+// Reactive state — updates automatically on navigation
+const state = router.state();
+effect(() => {
+  console.log('Current path:', state().path);
+  console.log('Params:', state().params);
+  console.log('Query:', state().query);
+});
+```
+
+### Dynamic Route Parameters
+
+```typescript
+// Given route pattern: /products/:id
+await router.navigate('/products/laptop-123');
+
+const state = router.state();
+console.log(state().params); // { id: 'laptop-123' }
+```
+
+### Guarded Navigation
+
+```typescript
+// Guard blocks unauthorized access and redirects
+import type { GuardFunction } from '@pithyjs/router';
+
+const authGuard: GuardFunction = async ({ to }) => {
+  const user = await getUser();
+  if (!user) return `/login?returnUrl=${to.path}`;
+  return true;
+};
+```
+
+See the [tests/demo-app/](tests/demo-app/) for a complete example application demonstrating:
+
+- File-based routing
+- Guards and loaders
+- Error boundaries
+- Nested layouts
+- View transitions
+- Prefetching
+
+## Testing
+
+The router package has 18 test files with 281+ passing tests. The table below highlights the 15 files that include `@codex:example` markers:
+
+| Module | Test File | Markers |
+| --- | --- | --- |
+| Navigation & state | `navigation.test.ts` | 5 |
+| Guards | `guards.test.ts` | 3 |
+| Loaders & caching | `loader.test.ts` | 2 |
+| Route tree | `route-tree.test.ts` | 3 |
+| Outlet mounting | `outlet.test.ts` | 2 |
+| Error resolution | `error-resolution.test.ts` | 2 |
+| Error types | `router-error.test.ts` | 1 |
+| Configuration | `config.test.ts` | 2 |
+| Prefetching | `prefetch.test.ts` | 1 |
+| Scroll & focus | `ux.test.ts` | 2 |
+| Live region a11y | `live-region.test.ts` | 1 |
+| HMR state preservation | `hmr.test.ts` | 1 |
+| Integration flow | `integration.test.ts` | 1 |
+| Directive binding | `directive-binder.test.ts` | 1 |
+| Router dispose | `router-dispose.test.ts` | 1 |
+
+```bash
+cd packages/router && pnpm test
+```
+
+## License
+
+MIT
+
+## Contributing
+
+See the main [DEVELOPMENT.md](../../docs/DEVELOPMENT.md) for development guidelines.

package/dist/index.d.ts

@@ -0,0 +1,29 @@
+/** @codex
+{
+  "id": "pithy.router",
+  "title": "PithyJS Router Core",
+  "category": "feature"
+}
+*/
+export * from './router/core/types';
+export * from './router/core/matcher';
+export * from './router/core/route-tree';
+export * from './router/core/params';
+export * from './router/core/utils';
+export * from './router/core/router';
+export * from './router/core/config';
+export * from './router/core/history';
+export * from './router/integration/directives';
+export { setGlobalRouter, getGlobalRouter, } from './router/integration/directive-binder';
+export * from './router/features/loaders';
+export * from './router/features/guards';
+export * from './router/features/prefetch';
+export * from './router/integration/hmr';
+export * from './router/integration/link-interceptor';
+export * from './router/features/ux/scroll-focus';
+export * from './router/features/ux/transitions';
+export * from './router/features/errors';
+export { OutletManager, type RouterInstance } from './router/features/outlet';
+export { buildSegmentChain } from './router/features/outlet/segment-chain';
+export { BrowserHistoryAdapter, MemoryHistoryAdapter, } from './router/integration/history-adapter';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;EAME;AAGF,cAAc,qBAAqB,CAAC;AAGpC,cAAc,uBAAuB,CAAC;AAGtC,cAAc,0BAA0B,CAAC;AAGzC,cAAc,sBAAsB,CAAC;AAGrC,cAAc,qBAAqB,CAAC;AAGpC,cAAc,sBAAsB,CAAC;AAGrC,cAAc,sBAAsB,CAAC;AAGrC,cAAc,uBAAuB,CAAC;AAGtC,cAAc,iCAAiC,CAAC;AAGhD,OAAO,EACL,eAAe,EACf,eAAe,GAChB,MAAM,uCAAuC,CAAC;AAG/C,cAAc,2BAA2B,CAAC;AAG1C,cAAc,0BAA0B,CAAC;AAGzC,cAAc,4BAA4B,CAAC;AAG3C,cAAc,0BAA0B,CAAC;AAGzC,cAAc,uCAAuC,CAAC;AAGtD,cAAc,mCAAmC,CAAC;AAGlD,cAAc,kCAAkC,CAAC;AAGjD,cAAc,0BAA0B,CAAC;AAGzC,OAAO,EAAE,aAAa,EAAE,KAAK,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC9E,OAAO,EAAE,iBAAiB,EAAE,MAAM,wCAAwC,CAAC;AAG3E,OAAO,EACL,qBAAqB,EACrB,oBAAoB,GACrB,MAAM,sCAAsC,CAAC"}