@plumile/router 0.1.19 → 0.1.20

package/README.md

@@ -228,175 +228,104 @@ Prepares route data and components for rendering.
 
 Type helper for strongly-typed route definitions.
 
-## Advanced Usage
+## Unified Query & Filter Model
 
-### Per-Route Prepared Data & Typed Navigate
+The router now unifies page-like query parameters and structured filters under a single model powered by `@plumile/filter-query`.
 
-Each route created with `r({...})` now preserves:
+Key points:
 
-- Prepared data type (return of `prepare`)
-- URL parameter type
-- Inferred typed query shape from its `query` schema
+- A route can declare a `querySchema` (filter schema) on its deepest branch.
+- All URL parameters (simple key=value and filter operators like `price.gt=10`) are parsed into a single `filters` object.
+- Equality is implicit: `field=value` maps to internal operator `eq`.
+- The current active schema is exposed as `entry.activeQuerySchema` for tooling.
+- Serialization is centralized via `buildCombinedSearch` (used by both `navigate` and `Link`).
 
-This enables discriminated narrowing using `entry.route?.path` and compile-time validation of `navigate` query objects.
+### Defining a Schema
 
 ```ts
-import { r, q, createRouter } from '@plumile/router';
+import { r } from '@plumile/router';
+import { defineSchema, numberField, stringField } from '@plumile/filter-query';
 
-const plans = r({
-  path: '/plans',
-  query: { page: q.number() } as const,
-  prepare: ({ query }) => ({ page: query.page }),
-});
-const user = r<{ userId: string }, { id: string }>({
-  path: '/users/:id',
-  prepare: ({ variables }) => ({ userId: variables.id }),
+const productFilters = defineSchema({
+  page: numberField(),
+  price: numberField(),
+  title: stringField(),
 });
-const { context } = createRouter([plans, user] as const);
-
-const entry = context.get();
-if (entry.route?.path === '/plans') {
-  const prepared = context.getPrepared('/plans');
-  // prepared?.page inferred as number | undefined
-  const typed = context.getTypedQuery('/plans');
-  // typed?.page inferred
-}
-
-// Typed navigate – query validated against the route schema
-context.navigate({ pathname: '/plans', query: { page: 2 } });
-```
-
-APIs:
-
-- `context.getPrepared(path)` → prepared object for that matched path (if present).
-- `context.getTypedQuery(path)` → typed query for path.
-- `context.navigate({...})` → enforces schema shape when `pathname` matches a known literal path.
-
-If a path is dynamic or no schema exists, the untyped fallback remains available.
-
-### Typed Query Parameters (DSL)
-
-The router provides a lightweight schema DSL for parsing, typing, normalizing and serializing query strings.
-
-#### 1. Define a schema on the deepest route
-
-```ts
-import { q, r } from '@plumile/router';
 
 const routes = [
   r({
-    path: '/items',
-    // Schema: page = number (default 1), tag(s) = array of strings, flag = optional boolean
-    query: {
-      page: q.default(q.number(), 1),
-      tags: q.array(q.string()),
-      flag: q.optional(q.boolean()),
-    },
-    prepare: ({ query }) => {
-      // query is typed: { page: number; tags: string[]; flag?: boolean }
-      return { page: query.page };
-    },
+    path: '/products',
+    querySchema: productFilters,
+    prepare: ({ filters }) => ({ page: filters.page?.eq ?? 1 }),
     render: () => null,
   }),
 ];
 ```
 
-#### 2. Access parsed & typed queries
+### Accessing Filters
 
 ```tsx
-import { useQuery, useTypedQuery } from '@plumile/router';
+import { useFilters } from '@plumile/router';
 
 function List() {
-  const raw = useQuery(); // Record<string, string | string[]>
-  const typed = useTypedQuery(); // Auto‑inferred from deepest route schema (no generic needed)
-  const [page, setPage] = useQueryState<number>('page'); // Bidirectional state ↔ URL for one param
-  return <pre>{JSON.stringify({ raw, typed }, null, 2)}</pre>;
+  const [filters, actions] = useFilters();
+  // filters.price?.gt, filters.title?.contains, filters.page?.eq
+  actions.set('price', 'gt', 10);
+  actions.set('page', 'eq', 2); // becomes page=2 in URL
+  return null;
 }
 ```
 
-Referential stability: both `raw` (from `useQuery()`) and `typed` (from `useTypedQuery()`) are memoized per canonical search string. If the URL search part doesn't change semantically (including key order canonicalization), the hook returns the exact same object reference. You can safely list either in React dependency arrays without extra `useMemo` or a hypothetical `useStableQuery` helper (not needed).
-
-Type inference:
-
-- If the matched deepest route has a `query` schema, `useTypedQuery()` returns the inferred `InferQuery<typeof schema>` shape automatically.
-- If no schema exists, it returns the raw parsed object (record of string | string[]) so you can still read values safely.
-- You can still supply a generic manually (`useTypedQuery<MyShape>()`) in edge cases (e.g. incremental migration) but it is usually unnecessary now.
-
-#### 3. Programmatic navigation with typed query
-
-```tsx
-import { useNavigate } from '@plumile/router';
+### Programmatic Navigation
 
-function Pager({ page }: { page: number }) {
-  const navigate = useNavigate();
-  return (
-    <button
-      onClick={() => {
-        navigate({ query: { page: page + 1 } });
-      }}
-    >
-      Next page
-    </button>
-  );
-}
+```ts
+context.navigate({ pathname: '/products', filters: { page: { eq: 3 } } });
 ```
 
-#### 4. Link component with query
+### Page Normalization
 
-```tsx
-import { Link } from '@plumile/router';
-
-<Link to="/items" query={{ page: 2, tags: ['a', 'b'], flag: true }}>
-  Filter
-</Link>;
-```
+The router clamps `page.eq < 1` to `1` synchronously and performs a history replace so the back stack is not polluted.
 
-`Link` & `navigate` automatically serialize using the route schema, applying:
+### Serialization Rules
 
-- Schema key order
-- Array repetition (`?tags=a&tags=b`)
-- Omission of default values when `omitDefaults` optimization applies internally
+`buildCombinedSearch` produces a leading `?` (or empty string) by:
 
-#### 5. Normalization
+1. Ordering simple query params (from schema order).
+2. Appending filter operator segments (`field.operator=value`).
+3. Using implicit equality (`field=value`).
+4. Maintaining reference stability (no unnecessary object churn).
 
-Built‑in simple normalization currently clamps `page < 1` to `1` and issues a `replaceState` to avoid polluting history.
+### Migration Note
 
-#### 6. Serialization utility
+The legacy query DSL (`q.*`, `parseTypedQuery`, `buildSearch`) has been removed. Replace any usage with a filter schema (`defineSchema`) and rely on `useFilters`, `navigate({ filters })`, and/or `buildCombinedSearch`.
 
-```ts
-import { buildSearch, q } from '@plumile/router';
-
-const schema = {
-  page: q.default(q.number(), 1),
-  tag: q.array(q.string()),
-} as const;
-const search = buildSearch({ page: 1, tag: ['x', 'y'] }, schema, {
-  omitDefaults: true,
-});
-// => '?tag=x&tag=y'
-```
+### Performance & Stability
 
-#### 7. Parsing utility / alias
+Filters cache: repeated navigations with semantically identical search strings reuse the same filter object reference, enabling cheap React renders.
 
-```ts
-import { parseSearch, q } from '@plumile/router';
+### Example Link
 
-const schema = { flag: q.boolean() } as const;
-const typed = parseSearch(schema, '?flag=1'); // { flag: true }
+```tsx
+<Link to="/products" filters={{ page: { eq: 1 }, price: { gt: 10 } }}>
+  Deals
+</Link>
 ```
 
-#### 8. Performance and stability
+Renders `href="/products?page=1&price.gt=10"`.
 
-There are two coordinated caching layers:
+### Manual Serialization Example
 
-1. Raw query cache: A process-wide Map keyed by a canonicalized search string (sorted keys, ordered value emission). Produces a frozen empty object for the empty search and reuses prior parsed objects, yielding stable references for unchanged search state.
-2. Typed query cache: A WeakMap keyed by (schema reference → canonical search signature) that parses once and reuses the typed value. Structural deep-equality canonicalization means semantically equivalent searches (e.g. reordered keys) reuse object identity.
+If you need to build a URL outside of navigation (e.g. constructing a sitemap entry):
 
-Effects:
+```ts
+import buildCombinedSearch from '@plumile/router/lib/esm/routing/tools/buildCombinedSearch.js'; // or routed re-export
 
-- Stable object identity for both raw and typed queries eliminates needless renders and removes the need for an extra `useStableQuery` hook.
-- Safe to put `useQuery()` / `useTypedQuery()` results directly in dependency arrays (`useEffect`, `useMemo`, selectors, etc.).
-- Empty query allocations are avoided (shared frozen object).
+const search = buildCombinedSearch({
+  filters: { page: { eq: 1 }, price: { gt: 10 } },
+  schema: productFilters,
+});
+// search === '?page=1&price.gt=10'
+```
 
 Guideline: If you need to derive lightweight projections (e.g. `const { page } = typed`), you can still destructure; but avoid spreading into a new object if you rely on reference equality downstream.
 
@@ -420,13 +349,13 @@ Devtools option forms:
   - `panel` (default: false) mounts an overlay; closed with the close button or page reload.
   - `shortcut` (default: `Alt+Shift+R`) toggles panel visibility.
 
-The panel displays current path+search, variables, raw query and typed query. It is intentionally framework‑agnostic (no React runtime cost) and uses a shadow root to minimize style collisions.
+The panel displays current path+search, variables, raw query aggregation, active schema, and parsed filters. It is intentionally framework‑agnostic (no React runtime cost) and uses a shadow root to minimize style collisions.
 
 ```js
 window.__PLUMILE_ROUTER__.get(); // current RouteEntry
-const unsub = window.__PLUMILE_ROUTER__.subscribe((entry) =>
-  console.log(entry.typedQuery),
-);
+const unsub = window.__PLUMILE_ROUTER__.subscribe((entry) => {
+  console.log('filters', entry.filters);
+});
 ```
 
 This lets you introspect parsed queries & variables without adding debug code. Neither global nor panel is present in production unless explicitly forced with `devtools: { global: true, panel: true }` (discouraged).
@@ -455,15 +384,16 @@ type RouteEntry = {
   route: { match; params; path } | null; // current matched route (or null)
   preparedMatch: { routes: { prepared; render?; resourcePage? }[]; match }; // internal prepared tree
   forceRerender: boolean; // indicates forced re-render situations
-  rawSearch: string; // '?page=2&tag=a'
-  query: Record<string, string | string[]>; // raw aggregated query params
-  typedQuery: any; // typed query if schema present
+  rawSearch: string; // '?page=2&price.gt=10'
+  query: Record<string, string | string[]>; // raw aggregated query params (for legacy/simple access)
+  filters: Record<string, any>; // unified parsed filters (implicit eq)
+  activeQuerySchema?: any; // active deepest schema (when present)
 };
 ```
 
 Common console patterns:
 
-1. Log every navigation with typed query & params:
+1. Log every navigation with filters & params:
 
 ```js
 const dev = window.__PLUMILE_ROUTER__;
@@ -471,7 +401,7 @@ if (dev) {
   const off = dev.subscribe((e) => {
     console.log('[router]', e.location.pathname + e.location.search, {
       vars: e.route?.params,
-      typed: e.typedQuery,
+      filters: e.filters,
     });
   });
   // later: off();
@@ -492,7 +422,7 @@ deepest?.prepared; // Prepared data returned by deepest prepare()
 let last = window.__PLUMILE_ROUTER__?.get().rawSearch;
 const off = window.__PLUMILE_ROUTER__?.subscribe((e) => {
   if (e.rawSearch !== last) {
-    console.log('query changed', last, '=>', e.rawSearch, e.typedQuery);
+    console.log('query changed', last, '=>', e.rawSearch, e.filters);
     last = e.rawSearch;
   }
 });
@@ -503,7 +433,7 @@ const off = window.__PLUMILE_ROUTER__?.subscribe((e) => {
 ```js
 const { get } = window.__PLUMILE_ROUTER__;
 const before = performance.now();
-for (let i = 0; i < 200; i++) get().typedQuery; // use cache; ensures no GC
+for (let i = 0; i < 200; i++) get().filters; // use cache; ensures no GC
 console.log('elapsed ms', performance.now() - before);
 ```
 
@@ -511,7 +441,7 @@ console.log('elapsed ms', performance.now() - before);
 
 ```js
 const R = window.__PLUMILE_ROUTER__;
-R && R.subscribe((e) => console.debug('[typedQuery]', e.typedQuery));
+R && R.subscribe((e) => console.debug('[filters]', e.filters));
 ```
 
 Unsubscribing: every `subscribe` returns a disposer function. Always call it if you set up long‑lived listeners in a debugging session to avoid memory leaks during hot reloads.
@@ -520,39 +450,42 @@ Extending: if you need more (e.g. trigger navigations) you can wrap `createRoute
 
 Production: the symbol is not defined; accessing it will yield `undefined`. Never ship logic depending on it; keep usage inside `if (process.env.NODE_ENV !== 'production')` blocks or guarded optional checks.
 
-### Filter Schema & useFilters (Integration with @plumile/filter-query)
+### Unified Query Schema & useFilters (Integration with @plumile/filter-query)
 
-The router can parse and serialize structured filter expressions using the `@plumile/filter-query` package. Define a `filterSchema` on the deepest route (same precedence rule as `query`). Each filter key is encoded as `field.operator=value`.
+The router uses a single unified schema (`querySchema`) defined with `@plumile/filter-query` to describe allowed key/operator pairs. Plain `field=value` maps to the implicit equality operator (`eq`). Each filter segment is encoded as `field.operator=value` (with `eq` omitted).
 
 ```ts
-import { r, q, useFilters } from '@plumile/router';
+import { r, useFilters } from '@plumile/router';
 import { defineSchema, numberField, stringField } from '@plumile/filter-query';
 
-const filterSchema = defineSchema({
-  price: numberField(), // operators: gt,gte,lt,lte,eq,neq,between,in,nin
-  name: stringField(), // operators: contains,sw,ew,eq,neq,in,nin
+const querySchema = defineSchema({
+  page: numberField(),      // page.eq=2 => ?page=2 (page normalization clamps <1 to 1)
+  price: numberField(),     // price.gt=10 => ?price.gt=10
+  name: stringField(),      // name.contains=ultra => ?name.contains=ultra
 });
 
-const routes = [
+export const routes = [
   r({
     path: '/items',
-    query: { page: q.default(q.number(), 1) },
-    filterSchema,
-    render: () => null,
+    querySchema,
+    render: () => <Items />,
   }),
 ];
 
-// Inside a component rendered under /items
-const [filters, actions] = useFilters();
-actions.set('price', 'gt', 10); // ?page=1&price.gt=10
-actions.set('price', 'eq', 15); // ?page=1&price.gt=10&price.eq=15
-actions.remove('price', 'gt'); // remove only that operator
-actions.clear(); // remove all filter segments
+function Items() {
+  const [filters, { set, remove, clear, merge }] = useFilters();
+  set('price', 'gt', 10); // => ?price.gt=10
+  set('page', 'eq', 2);   // => ?page=2
+  remove('price', 'gt');
+  merge([{ field: 'price', op: 'between', value: [10, 20] }]);
+  clear();
+  return null;
+}
 ```
 
-`navigate({ filters })` is also available for programmatic changes alongside query updates. Serialization keeps query parameters first, then filter segments, both deterministically ordered.
+`navigate({ filters })` is available for programmatic updates. Serialization order: schema field keys first, then any extra non‑schema keys (if present). Operators follow deterministic ordering from `@plumile/filter-query`.
 
-Diagnostics (unknown field/operator, invalid values, etc.) are accessible via `useFilterDiagnostics()` for debugging tooling or UI feedback.
+Diagnostics (unknown field/operator, invalid values, etc.) are accessible via `useFilterDiagnostics()`.
 
 ### ESLint Rule: no-direct-window-location-search
 
@@ -600,32 +533,29 @@ const qs = window.location.search;
 with:
 
 ```ts
-const query = useQuery(); // or useTypedQuery()
+const query = useQuery(); // raw key=value aggregation (simple); prefer useFilters() for structured access.
 ```
 
-### Migration Guide (Phases 1 → 5)
+### Migration Guide (Legacy DSL → Unified Filters)
+
+1. Remove legacy imports of `q`, `parseTypedQuery`, `buildSearch`.
+2. Define a schema with `defineSchema` from `@plumile/filter-query` and attach as `querySchema`.
+3. Replace (removed) `useTypedQuery()` usages with `useFilters()`.
+4. Update navigation: `navigate({ filters: { page: { eq: 2 } } })`.
+5. Update links: `<Link to="/x" filters={{ page: { eq: 2 } }} />`.
+6. Page defaults / normalization: rely on built-in clamp (`page < 1 -> 1`).
+7. Remove any type tests referencing the DSL; rely on schema inference.
 
-1. Phase 1/2: Upgrade — no schema needed. Use `useQuery()` for raw params.
-2. Phase 3: Add `query` schema to your deepest route; adopt `useTypedQuery()` where type safety is desirable.
-3. Phase 4: Replace manual URL building with `navigate({ query })` or `<Link query={...} />`. Remove ad‑hoc serialization logic.
-4. Phase 5: Move lightweight data loading logic that depends on query into `prepare({ query })` (now typed). Rely on built‑in normalization (e.g. page clamp) or add custom normalization inside `prepare` followed by a `navigate({ replace: true, query: normalized })` if needed.
-5. Optional: Use `buildSearch` / `parseSearch` for unit tests & utilities.
+### Removed APIs
 
-### Query Descriptor Reference
+The following legacy APIs were removed in favor of the unified filter model:
 
-| Descriptor                       | Description                                         | Serialize Example                    |
-| -------------------------------- | --------------------------------------------------- | ------------------------------------ |
-| `q.string()`                     | Last occurrence string                              | `{ q: 'x' } -> ?q=x`                 |
-| `q.number()`                     | Number (invalid => undefined)                       | `{ n: 2 } -> ?n=2`                   |
-| `q.boolean()`                    | Presence / true/false/1/0                           | `{ f: true } -> ?f=1`                |
-| `q.enum('a','b')`                | Restricted string                                   | `{ e: 'a' } -> ?e=a`                 |
-| `q.array(inner)`                 | Repeated key multi-values                           | `{ tag: ['x','y'] } -> ?tag=x&tag=y` |
-| `q.optional(d)`                  | Marks descriptor optional                           | omitted if undefined                 |
-| `q.default(d, v)`                | Supplies default + omit on serialize (omitDefaults) | default skipped                      |
-| `q.emptyAsUndefined(q.string())` | Maps empty string '' to undefined                   | omitted                              |
-| `q.custom({ parse, serialize })` | Custom parse/serialize logic                        | depends                              |
+- `q.*` descriptor DSL (replaced by `defineSchema` in `@plumile/filter-query`)
+- `parseTypedQuery`
+- `buildSearch` (use `buildCombinedSearch`)
+- `useTypedQuery`
 
-Custom: `q.custom({ parse(values), serialize(value) })` lets you wire bespoke formats. Ensure `serialize` outputs an array of raw string values. Use sparingly to keep schemas readable.
+Use `@plumile/filter-query` for schema definitions and `useFilters` / `buildCombinedSearch` for runtime access & serialization.
 
 ### useQueryState Hook
 
@@ -639,10 +569,10 @@ setPage(page! + 1, { replace: true });
 
 Behavior:
 
-- Reads from typedQuery if schema present, else raw query.
-- Respects schema defaults (and `defaultValue` override in options) and omits key when value equals default (with `omitIfDefault: true`).
+- Reads from filters (implicit equality) and falls back to raw query key when not covered by schema.
+- Allows `defaultValue` override in options and omits key when value equals default (with `omitIfDefault: true`).
 - Pass `{ raw: true }` to force raw (string) source for incremental migrations.
-- Uses existing navigation serialization (ordering, omit defaults, arrays).
+- Uses unified serialization ordering (schema keys then extras; operators deterministic).
 
 Options:
 `{ defaultValue?, omitIfDefault?: boolean = true, replace?: boolean, raw?: boolean }`

package/lib/esm/eslint-rules/no-direct-window-location-search.js

@@ -2,11 +2,11 @@ const rule = {
     meta: {
         type: 'suggestion',
         docs: {
-            description: 'Discourage direct window.location.search access; use useQuery()/useTypedQuery() instead',
+            description: 'Discourage direct window.location.search access; use useQuery()/useFilters() instead',
             recommended: false,
         },
         messages: {
-            avoid: 'Avoid direct access to window.location.search. Use useQuery() / useTypedQuery() from @plumile/router.',
+            avoid: 'Avoid direct access to window.location.search. Use useQuery() / useFilters() from @plumile/router.',
         },
         schema: [
             {
@@ -45,4 +45,4 @@ const rule = {
     },
 };
 export default rule;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/index.d.ts

@@ -4,6 +4,5 @@ export * from './routing/index.js';
 export * from './builder.js';
 export * from './ResourcePage.js';
 export * from './tools.js';
-export { q, parseTypedQuery } from './tools/query-dsl.js';
 export type * from './types.js';
 //# sourceMappingURL=index.d.ts.map

package/lib/esm/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AACA,cAAc,mBAAmB,CAAC;AAGlC,cAAc,oBAAoB,CAAC;AAGnC,cAAc,oBAAoB,CAAC;AAGnC,cAAc,cAAc,CAAC;AAG7B,cAAc,mBAAmB,CAAC;AAGlC,cAAc,YAAY,CAAC;AAC3B,OAAO,EAAE,CAAC,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAG1D,mBAAmB,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AACA,cAAc,mBAAmB,CAAC;AAGlC,cAAc,oBAAoB,CAAC;AAGnC,cAAc,oBAAoB,CAAC;AAGnC,cAAc,cAAc,CAAC;AAG7B,cAAc,mBAAmB,CAAC;AAGlC,cAAc,YAAY,CAAC;AAG3B,mBAAmB,YAAY,CAAC"}

package/lib/esm/index.js

@@ -4,5 +4,4 @@ export * from './routing/index.js';
 export * from './builder.js';
 export * from './ResourcePage.js';
 export * from './tools.js';
-export { q, parseTypedQuery } from './tools/query-dsl.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsY0FBYyxtQkFBbUIsQ0FBQztBQUdsQyxjQUFjLG9CQUFvQixDQUFDO0FBR25DLGNBQWMsb0JBQW9CLENBQUM7QUFHbkMsY0FBYyxjQUFjLENBQUM7QUFHN0IsY0FBYyxtQkFBbUIsQ0FBQztBQUdsQyxjQUFjLFlBQVksQ0FBQztBQUMzQixPQUFPLEVBQUUsQ0FBQyxFQUFFLGVBQWUsRUFBRSxNQUFNLHNCQUFzQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gRXhwb3J0IGVycm9yIGhhbmRsaW5nIHV0aWxpdGllc1xuZXhwb3J0ICogZnJvbSAnLi9lcnJvcnMvaW5kZXguanMnO1xuXG4vLyBFeHBvcnQgYnJvd3NlciBoaXN0b3J5IG1hbmFnZW1lbnRcbmV4cG9ydCAqIGZyb20gJy4vaGlzdG9yeS9pbmRleC5qcyc7XG5cbi8vIEV4cG9ydCByb3V0aW5nIGNvbXBvbmVudHMgYW5kIHV0aWxpdGllc1xuZXhwb3J0ICogZnJvbSAnLi9yb3V0aW5nL2luZGV4LmpzJztcblxuLy8gRXhwb3J0IHJvdXRlIGJ1aWxkaW5nIHV0aWxpdGllc1xuZXhwb3J0ICogZnJvbSAnLi9idWlsZGVyLmpzJztcblxuLy8gRXhwb3J0IHJlc291cmNlIHBhZ2UgbWFuYWdlbWVudCBmb3IgbGF6eSBsb2FkaW5nXG5leHBvcnQgKiBmcm9tICcuL1Jlc291cmNlUGFnZS5qcyc7XG5cbi8vIEV4cG9ydCB1dGlsaXR5IGZ1bmN0aW9uc1xuZXhwb3J0ICogZnJvbSAnLi90b29scy5qcyc7XG5leHBvcnQgeyBxLCBwYXJzZVR5cGVkUXVlcnkgfSBmcm9tICcuL3Rvb2xzL3F1ZXJ5LWRzbC5qcyc7XG5cbi8vIEV4cG9ydCBhbGwgVHlwZVNjcmlwdCB0eXBlc1xuZXhwb3J0IHR5cGUgKiBmcm9tICcuL3R5cGVzLmpzJztcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsY0FBYyxtQkFBbUIsQ0FBQztBQUdsQyxjQUFjLG9CQUFvQixDQUFDO0FBR25DLGNBQWMsb0JBQW9CLENBQUM7QUFHbkMsY0FBYyxjQUFjLENBQUM7QUFHN0IsY0FBYyxtQkFBbUIsQ0FBQztBQUdsQyxjQUFjLFlBQVksQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIEV4cG9ydCBlcnJvciBoYW5kbGluZyB1dGlsaXRpZXNcbmV4cG9ydCAqIGZyb20gJy4vZXJyb3JzL2luZGV4LmpzJztcblxuLy8gRXhwb3J0IGJyb3dzZXIgaGlzdG9yeSBtYW5hZ2VtZW50XG5leHBvcnQgKiBmcm9tICcuL2hpc3RvcnkvaW5kZXguanMnO1xuXG4vLyBFeHBvcnQgcm91dGluZyBjb21wb25lbnRzIGFuZCB1dGlsaXRpZXNcbmV4cG9ydCAqIGZyb20gJy4vcm91dGluZy9pbmRleC5qcyc7XG5cbi8vIEV4cG9ydCByb3V0ZSBidWlsZGluZyB1dGlsaXRpZXNcbmV4cG9ydCAqIGZyb20gJy4vYnVpbGRlci5qcyc7XG5cbi8vIEV4cG9ydCByZXNvdXJjZSBwYWdlIG1hbmFnZW1lbnQgZm9yIGxhenkgbG9hZGluZ1xuZXhwb3J0ICogZnJvbSAnLi9SZXNvdXJjZVBhZ2UuanMnO1xuXG4vLyBFeHBvcnQgdXRpbGl0eSBmdW5jdGlvbnNcbmV4cG9ydCAqIGZyb20gJy4vdG9vbHMuanMnO1xuXG4vLyBFeHBvcnQgYWxsIFR5cGVTY3JpcHQgdHlwZXNcbmV4cG9ydCB0eXBlICogZnJvbSAnLi90eXBlcy5qcyc7XG4iXX0=

package/lib/esm/routing/Link.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Link.d.ts","sourceRoot":"","sources":["../../../src/routing/Link.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EACZ,KAAK,yBAAyB,EAE9B,KAAK,SAAS,EAIf,MAAM,OAAO,CAAC;AAEf,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAa3E,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,OAAO,EACd,OAAO,EAAE,cAAc,GAAG,SAAS,EACnC,QAAQ,EAAE,MAAM,GACf,OAAO,CAmBT;AAKD,KAAK,KAAK,CAAC,MAAM,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI;IAE7E,eAAe,CAAC,EAAE,MAAM,CAAC;IAEzB,QAAQ,EAAE,SAAS,CAAC;IAEpB,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB,KAAK,CAAC,EAAE,OAAO,CAAC;IAEhB,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAE9B,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAE7B,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB,OAAO,CAAC,EAAE,KAAK,CAAC,iBAAiB,CAAC,iBAAiB,CAAC,CAAC;IAErD,OAAO,CAAC,EAAE,KAAK,CAAC,iBAAiB,CAAC,iBAAiB,CAAC,CAAC;IAErD,WAAW,CAAC,EAAE,KAAK,CAAC,iBAAiB,CAAC,iBAAiB,CAAC,CAAC;IAEzD,MAAM,CAAC,EAAE,yBAAyB,CAAC;IAEnC,EAAE,CAAC,EAAE,eAAe,GAAG,MAAM,CAAC;IAE9B,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAyBF,QAAA,MAAM,IAAI,0GAyKR,CAAC;AAEH,eAAe,IAAI,CAAC"}
+{"version":3,"file":"Link.d.ts","sourceRoot":"","sources":["../../../src/routing/Link.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EACZ,KAAK,yBAAyB,EAE9B,KAAK,SAAS,EAIf,MAAM,OAAO,CAAC;AAEf,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAa3E,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,OAAO,EACd,OAAO,EAAE,cAAc,GAAG,SAAS,EACnC,QAAQ,EAAE,MAAM,GACf,OAAO,CAmBT;AAKD,KAAK,KAAK,CAAC,MAAM,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI;IAE7E,eAAe,CAAC,EAAE,MAAM,CAAC;IAEzB,QAAQ,EAAE,SAAS,CAAC;IAEpB,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB,KAAK,CAAC,EAAE,OAAO,CAAC;IAEhB,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAE9B,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAE7B,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB,OAAO,CAAC,EAAE,KAAK,CAAC,iBAAiB,CAAC,iBAAiB,CAAC,CAAC;IAErD,OAAO,CAAC,EAAE,KAAK,CAAC,iBAAiB,CAAC,iBAAiB,CAAC,CAAC;IAErD,WAAW,CAAC,EAAE,KAAK,CAAC,iBAAiB,CAAC,iBAAiB,CAAC,CAAC;IAEzD,MAAM,CAAC,EAAE,yBAAyB,CAAC;IAEnC,EAAE,CAAC,EAAE,eAAe,GAAG,MAAM,CAAC;IAE9B,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAyBF,QAAA,MAAM,IAAI,0GAuJR,CAAC;AAEH,eAAe,IAAI,CAAC"}