@llui/router 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Franco Ponticelli
+
+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,13 @@
+# @llui/router
+
+Router for [LLui](https://github.com/fponticelli/llui).
+
+Structured path matching, history/hash mode, `routing.link()` helper, `routing.listener()` for popstate, and `createHandler()` for mergeHandlers integration.
+
+```bash
+pnpm add @llui/router
+```
+
+## License
+
+MIT

package/dist/connect.d.ts

@@ -0,0 +1,54 @@
+import type { Router } from './index';
+export interface RouterEffect {
+    type: '__router';
+    action: 'push' | 'replace' | 'back' | 'forward' | 'scroll';
+    path?: string;
+    x?: number;
+    y?: number;
+}
+export interface ConnectedRouter<R> {
+    /** Effect: push a new route onto history */
+    push(route: R): RouterEffect;
+    /** Effect: replace current history entry */
+    replace(route: R): RouterEffect;
+    /** Effect: go back */
+    back(): RouterEffect;
+    /** Effect: go forward */
+    forward(): RouterEffect;
+    /** Effect: scroll to position */
+    scroll(x: number, y: number): RouterEffect;
+    /** Plugin for handleEffects().use() — handles RouterEffect */
+    handleEffect: (ctx: {
+        effect: {
+            type: string;
+        };
+        send: unknown;
+        signal: AbortSignal;
+    }) => boolean;
+    /**
+     * View helper: attach URL change listener via onMount.
+     * Returns an empty comment node. Sends { type: 'navigate', route } on URL change.
+     */
+    listener<M>(send: (msg: M) => void, msgFactory?: (route: R) => M): Node[];
+    /**
+     * View helper: render a navigation link.
+     * Generates <a> with proper href and click handler that sends navigate message.
+     */
+    link<M>(send: (msg: M) => void, route: R, attrs: Record<string, unknown>, children: Node[], msgFactory?: (route: R) => M): HTMLElement;
+    /**
+     * Create an update handler for mergeHandlers.
+     * Returns [newState, Effect[]] for navigate messages, null for others.
+     */
+    createHandler<S, M, E>(config: {
+        /** Message type to handle (default: 'navigate') */
+        message?: string;
+        /** Extract route from message */
+        getRoute: (msg: M) => R;
+        /** Optional guard — can redirect */
+        guard?: (route: R, state: S) => R;
+        /** Build new state + effects for the route */
+        onNavigate: (state: S, route: R) => [S, E[]];
+    }): (state: S, msg: M) => [S, E[]] | null;
+}
+export declare function connectRouter<R>(router: Router<R>): ConnectedRouter<R>;
+//# sourceMappingURL=connect.d.ts.map

package/dist/connect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connect.d.ts","sourceRoot":"","sources":["../src/connect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAA;AAKrC,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,UAAU,CAAA;IAChB,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,GAAG,QAAQ,CAAA;IAC1D,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,CAAC,CAAC,EAAE,MAAM,CAAA;IACV,CAAC,CAAC,EAAE,MAAM,CAAA;CACX;AAED,MAAM,WAAW,eAAe,CAAC,CAAC;IAChC,4CAA4C;IAC5C,IAAI,CAAC,KAAK,EAAE,CAAC,GAAG,YAAY,CAAA;IAC5B,4CAA4C;IAC5C,OAAO,CAAC,KAAK,EAAE,CAAC,GAAG,YAAY,CAAA;IAC/B,sBAAsB;IACtB,IAAI,IAAI,YAAY,CAAA;IACpB,yBAAyB;IACzB,OAAO,IAAI,YAAY,CAAA;IACvB,iCAAiC;IACjC,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,YAAY,CAAA;IAE1C,8DAA8D;IAC9D,YAAY,EAAE,CAAC,GAAG,EAAE;QAAE,MAAM,EAAE;YAAE,IAAI,EAAE,MAAM,CAAA;SAAE,CAAC;QAAC,IAAI,EAAE,OAAO,CAAC;QAAC,MAAM,EAAE,WAAW,CAAA;KAAE,KAAK,OAAO,CAAA;IAEhG;;;OAGG;IACH,QAAQ,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,IAAI,EAAE,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,GAAG,IAAI,EAAE,CAAA;IAEzE;;;OAGG;IACH,IAAI,CAAC,CAAC,EACJ,IAAI,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,IAAI,EACtB,KAAK,EAAE,CAAC,EACR,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,QAAQ,EAAE,IAAI,EAAE,EAChB,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,GAC3B,WAAW,CAAA;IAEd;;;OAGG;IACH,aAAa,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE;QAC7B,mDAAmD;QACnD,OAAO,CAAC,EAAE,MAAM,CAAA;QAChB,iCAAiC;QACjC,QAAQ,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,CAAA;QACvB,oCAAoC;QACpC,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,CAAC,CAAA;QACjC,8CAA8C;QAC9C,UAAU,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAA;KAC7C,GAAG,CAAC,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,IAAI,CAAA;CAC1C;AAED,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,GAAG,eAAe,CAAC,CAAC,CAAC,CAgHtE"}

package/dist/connect.js

@@ -0,0 +1,101 @@
+import { a, onMount } from '@llui/dom';
+export function connectRouter(router) {
+    function applyEffect(effect) {
+        switch (effect.action) {
+            case 'push':
+                if (router.mode === 'hash') {
+                    location.hash = effect.path;
+                }
+                else {
+                    history.pushState(null, '', effect.path);
+                }
+                break;
+            case 'replace':
+                if (router.mode === 'hash') {
+                    location.replace(effect.path);
+                }
+                else {
+                    history.replaceState(null, '', effect.path);
+                }
+                break;
+            case 'back':
+                history.back();
+                break;
+            case 'forward':
+                history.forward();
+                break;
+            case 'scroll':
+                window.scrollTo(effect.x, effect.y);
+                break;
+        }
+    }
+    return {
+        push(route) {
+            return { type: '__router', action: 'push', path: router.href(route) };
+        },
+        replace(route) {
+            return { type: '__router', action: 'replace', path: router.href(route) };
+        },
+        back() {
+            return { type: '__router', action: 'back' };
+        },
+        forward() {
+            return { type: '__router', action: 'forward' };
+        },
+        scroll(x, y) {
+            return { type: '__router', action: 'scroll', x, y };
+        },
+        handleEffect({ effect }) {
+            if (effect.type !== '__router')
+                return false;
+            applyEffect(effect);
+            return true;
+        },
+        listener(send, msgFactory) {
+            const factory = msgFactory ?? ((r) => ({ type: 'navigate', route: r }));
+            onMount(() => {
+                const event = router.mode === 'hash' ? 'hashchange' : 'popstate';
+                const handler = () => {
+                    const input = router.mode === 'hash' ? location.hash : location.pathname + location.search;
+                    const route = router.match(input);
+                    send(factory(route));
+                };
+                window.addEventListener(event, handler);
+                return () => window.removeEventListener(event, handler);
+            });
+            return [document.createComment('router')];
+        },
+        link(send, route, attrs, children, msgFactory) {
+            const factory = msgFactory ?? ((r) => ({ type: 'navigate', route: r }));
+            return a({
+                ...attrs,
+                href: router.href(route),
+                onClick: (e) => {
+                    const me = e;
+                    if (me.ctrlKey || me.metaKey || me.shiftKey || me.altKey || me.button !== 0)
+                        return;
+                    e.preventDefault();
+                    // Push history — pushState doesn't fire popstate, so no double-nav
+                    if (router.mode === 'hash') {
+                        // hashchange will fire the listener, which sends the navigate message
+                        location.hash = router.href(route);
+                        return;
+                    }
+                    history.pushState(null, '', router.href(route));
+                    send(factory(route));
+                },
+            }, children);
+        },
+        createHandler(config) {
+            const msgType = config.message ?? 'navigate';
+            return (state, msg) => {
+                if (msg.type !== msgType)
+                    return null;
+                let route = config.getRoute(msg);
+                if (config.guard)
+                    route = config.guard(route, state);
+                return config.onNavigate(state, route);
+            };
+        },
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,54 @@
+interface ParamSegment {
+    __kind: 'param';
+    name: string;
+}
+interface RestSegment {
+    __kind: 'rest';
+    name: string;
+}
+export type Segment = string | ParamSegment | RestSegment;
+/** Named path parameter: matches one segment */
+export declare function param(name: string): ParamSegment;
+/** Rest parameter: matches remaining segments */
+export declare function rest(name: string): RestSegment;
+interface RouteDefOptions {
+    query?: string[];
+}
+export interface RouteDef<R> {
+    segments: Segment[];
+    build: (params: Record<string, string>) => R;
+    queryKeys: string[];
+    /** Optional manual toPath override */
+    toPath?: (route: R) => string;
+}
+/**
+ * Define a route with structured path segments.
+ *
+ * @example
+ * route(['article', param('slug')], ({ slug }) => ({ page: 'article', slug }))
+ * route(['search'], { query: ['q'] }, ({ q }) => ({ page: 'search', q: q ?? '' }))
+ */
+export declare function route<R = any>(segments: Segment[], buildOrOpts: ((params: Record<string, string>) => R) | RouteDefOptions, buildOrToPath?: ((params: Record<string, string>) => R) | {
+    toPath: (route: R) => string;
+}): RouteDef<R>;
+export interface RouterConfig<R> {
+    mode?: 'hash' | 'history';
+    fallback?: R;
+}
+export interface Router<R> {
+    /** Match a pathname to a Route. Returns fallback if no match. */
+    match(pathname: string): R;
+    /** Format a Route back to a pathname (without hash/history prefix). */
+    toPath(route: R): string;
+    /** Format a Route to a full href (with # prefix in hash mode). */
+    href(route: R): string;
+    /** The configured mode */
+    mode: 'hash' | 'history';
+    /** All route definitions (for iteration) */
+    routes: ReadonlyArray<RouteDef<R>>;
+    /** The fallback route */
+    fallback: R;
+}
+export declare function createRouter<R>(defs: RouteDef<any>[], config?: RouterConfig<R>): Router<R>;
+export {};
+//# 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":"AAEA,UAAU,YAAY;IACpB,MAAM,EAAE,OAAO,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;CACb;AAED,UAAU,WAAW;IACnB,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,MAAM,CAAA;CACb;AAED,MAAM,MAAM,OAAO,GAAG,MAAM,GAAG,YAAY,GAAG,WAAW,CAAA;AAEzD,gDAAgD;AAChD,wBAAgB,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,CAEhD;AAED,iDAAiD;AACjD,wBAAgB,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,CAE9C;AAID,UAAU,eAAe;IACvB,KAAK,CAAC,EAAE,MAAM,EAAE,CAAA;CACjB;AAED,MAAM,WAAW,QAAQ,CAAC,CAAC;IACzB,QAAQ,EAAE,OAAO,EAAE,CAAA;IACnB,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,CAAC,CAAA;IAC5C,SAAS,EAAE,MAAM,EAAE,CAAA;IACnB,sCAAsC;IACtC,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,MAAM,CAAA;CAC9B;AAED;;;;;;GAMG;AAEH,wBAAgB,KAAK,CAAC,CAAC,GAAG,GAAG,EAC3B,QAAQ,EAAE,OAAO,EAAE,EACnB,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,GAAG,eAAe,EACtE,aAAa,CAAC,EAAE,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,GAAG;IAAE,MAAM,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,MAAM,CAAA;CAAE,GACzF,QAAQ,CAAC,CAAC,CAAC,CAQb;AAID,MAAM,WAAW,YAAY,CAAC,CAAC;IAC7B,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IACzB,QAAQ,CAAC,EAAE,CAAC,CAAA;CACb;AAED,MAAM,WAAW,MAAM,CAAC,CAAC;IACvB,iEAAiE;IACjE,KAAK,CAAC,QAAQ,EAAE,MAAM,GAAG,CAAC,CAAA;IAC1B,uEAAuE;IACvE,MAAM,CAAC,KAAK,EAAE,CAAC,GAAG,MAAM,CAAA;IACxB,kEAAkE;IAClE,IAAI,CAAC,KAAK,EAAE,CAAC,GAAG,MAAM,CAAA;IACtB,0BAA0B;IAC1B,IAAI,EAAE,MAAM,GAAG,SAAS,CAAA;IACxB,4CAA4C;IAC5C,MAAM,EAAE,aAAa,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAA;IAClC,yBAAyB;IACzB,QAAQ,EAAE,CAAC,CAAA;CACZ;AAED,wBAAgB,YAAY,CAAC,CAAC,EAE5B,IAAI,EAAE,QAAQ,CAAC,GAAG,CAAC,EAAE,EACrB,MAAM,CAAC,EAAE,YAAY,CAAC,CAAC,CAAC,GACvB,MAAM,CAAC,CAAC,CAAC,CAgFX"}

package/dist/index.js

@@ -0,0 +1,220 @@
+// ── Path Segment Types ───────────────────────────────────────────
+/** Named path parameter: matches one segment */
+export function param(name) {
+    return { __kind: 'param', name };
+}
+/** Rest parameter: matches remaining segments */
+export function rest(name) {
+    return { __kind: 'rest', name };
+}
+/**
+ * Define a route with structured path segments.
+ *
+ * @example
+ * route(['article', param('slug')], ({ slug }) => ({ page: 'article', slug }))
+ * route(['search'], { query: ['q'] }, ({ q }) => ({ page: 'search', q: q ?? '' }))
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function route(segments, buildOrOpts, buildOrToPath) {
+    if (typeof buildOrOpts === 'function') {
+        const tp = buildOrToPath && typeof buildOrToPath === 'object' ? buildOrToPath.toPath : undefined;
+        return { segments, build: buildOrOpts, queryKeys: [], toPath: tp };
+    }
+    const opts = buildOrOpts;
+    const build = buildOrToPath;
+    return { segments, build, queryKeys: opts.query ?? [] };
+}
+export function createRouter(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+defs, config) {
+    const mode = config?.mode ?? 'hash';
+    const fallback = config?.fallback ?? defs[0].build({});
+    function matchPathname(pathname) {
+        // Separate path from query string
+        let queryParams = {};
+        const qIdx = pathname.indexOf('?');
+        const rawPath = qIdx !== -1 ? pathname.slice(0, qIdx) : pathname;
+        if (qIdx !== -1) {
+            queryParams = parseQuery(pathname.slice(qIdx + 1));
+        }
+        const path = rawPath.replace(/^\/+|\/+$/g, '');
+        const pathSegments = path === '' ? [] : path.split('/');
+        // Try each route definition
+        for (const def of defs) {
+            const params = matchDef(def, pathSegments);
+            if (params !== null) {
+                // Merge query params
+                for (const key of def.queryKeys) {
+                    if (queryParams[key] !== undefined)
+                        params[key] = queryParams[key];
+                }
+                return def.build(params);
+            }
+        }
+        return fallback;
+    }
+    function formatPath(r) {
+        // Try each route definition in reverse order (most specific first)
+        for (let i = defs.length - 1; i >= 0; i--) {
+            const def = defs[i];
+            // If route has a manual toPath, use it
+            if (def.toPath)
+                return def.toPath(r);
+            // Try to extract params from the Route and build the path
+            const path = tryFormat(def, r);
+            if (path !== null) {
+                // Round-trip check: parse the formatted path and verify URL-relevant
+                // fields match. Ignore extra fields (like runtime `data`) that aren't
+                // part of the URL — they would break the comparison since the route
+                // builder produces default values that differ from the actual state.
+                const roundTrip = matchPathname(path);
+                const urlKeys = getUrlKeys(def);
+                if (partialEqual(roundTrip, r, urlKeys))
+                    return path;
+            }
+        }
+        // Last resort: try forward order
+        for (const def of defs) {
+            if (def.toPath)
+                return def.toPath(r);
+            const path = tryFormat(def, r);
+            if (path !== null)
+                return path;
+        }
+        return '/';
+    }
+    return {
+        match(input) {
+            // Strip hash prefix, preserve query string
+            const pathname = mode === 'hash' ? input.replace(/^#\/?/, '/') : input;
+            return matchPathname(pathname);
+        },
+        toPath: formatPath,
+        href(r) {
+            const path = formatPath(r);
+            return mode === 'hash' ? `#${path}` : path;
+        },
+        mode,
+        routes: defs,
+        fallback,
+    };
+}
+// ── Matching ─────────────────────────────────────────────────────
+function matchDef(def, pathSegments) {
+    const params = {};
+    let si = 0;
+    for (let di = 0; di < def.segments.length; di++) {
+        const seg = def.segments[di];
+        if (typeof seg === 'string') {
+            if (si >= pathSegments.length || pathSegments[si] !== seg)
+                return null;
+            si++;
+        }
+        else if (seg.__kind === 'param') {
+            if (si >= pathSegments.length)
+                return null;
+            params[seg.name] = decodeURIComponent(pathSegments[si]);
+            si++;
+        }
+        else if (seg.__kind === 'rest') {
+            params[seg.name] = pathSegments.slice(si).map(decodeURIComponent).join('/');
+            si = pathSegments.length;
+        }
+    }
+    // All path segments must be consumed
+    if (si !== pathSegments.length)
+        return null;
+    return params;
+}
+function tryFormat(def, r) {
+    const routeObj = r;
+    const parts = [];
+    for (const seg of def.segments) {
+        if (typeof seg === 'string') {
+            parts.push(seg);
+        }
+        else if (seg.__kind === 'param') {
+            const value = routeObj[seg.name];
+            if (value === undefined || value === null)
+                return null;
+            parts.push(encodeURIComponent(String(value)));
+        }
+        else if (seg.__kind === 'rest') {
+            const value = routeObj[seg.name];
+            if (value === undefined || value === null)
+                return null;
+            parts.push(String(value));
+        }
+    }
+    let path = '/' + parts.join('/');
+    // Append query params if defined
+    if (def.queryKeys.length > 0) {
+        const qParts = [];
+        for (const key of def.queryKeys) {
+            const value = routeObj[key];
+            if (value !== undefined && value !== null && value !== '') {
+                qParts.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+            }
+        }
+        if (qParts.length > 0)
+            path += '?' + qParts.join('&');
+    }
+    return path;
+}
+// ── Utilities ────────────────────────────────────────────────────
+function parseQuery(qs) {
+    const params = {};
+    for (const pair of qs.split('&')) {
+        const [key, val] = pair.split('=');
+        if (key)
+            params[decodeURIComponent(key)] = decodeURIComponent(val ?? '');
+    }
+    return params;
+}
+/** Extract URL-relevant field names from a route definition */
+function getUrlKeys(def) {
+    const keys = new Set();
+    for (const seg of def.segments) {
+        if (typeof seg === 'string')
+            continue;
+        keys.add(seg.name);
+    }
+    for (const key of def.queryKeys) {
+        keys.add(key);
+    }
+    // Also include 'page' / 'tab' or any fixed field from the builder
+    // by running the builder with empty params and collecting its keys
+    const sample = def.build({});
+    for (const key of Object.keys(sample)) {
+        // Include all keys from the builder EXCEPT those with object/array values
+        // (which are likely runtime state like `data`)
+        const val = sample[key];
+        if (val === null || val === undefined || typeof val !== 'object') {
+            keys.add(key);
+        }
+    }
+    return keys;
+}
+/** Compare two objects only on the specified keys */
+function partialEqual(a, b, keys) {
+    for (const key of keys) {
+        if (!deepEqual(a[key], b[key]))
+            return false;
+    }
+    return true;
+}
+function deepEqual(a, b) {
+    if (Object.is(a, b))
+        return true;
+    if (typeof a !== 'object' || typeof b !== 'object' || a === null || b === null)
+        return false;
+    const ka = Object.keys(a);
+    const kb = Object.keys(b);
+    if (ka.length !== kb.length)
+        return false;
+    for (const key of ka) {
+        if (!deepEqual(a[key], b[key]))
+            return false;
+    }
+    return true;
+}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@llui/router",
+  "version": "0.0.1",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./connect": {
+      "import": "./dist/connect.js",
+      "types": "./dist/connect.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "check": "tsc --noEmit -p tsconfig.check.json",
+    "lint": "eslint src",
+    "test": "vitest run"
+  },
+  "peerDependencies": {
+    "@llui/dom": "^0.0.1"
+  },
+  "devDependencies": {
+    "@llui/dom": "workspace:*",
+    "typescript": "^6.0.0",
+    "vitest": "^4.1.2"
+  },
+  "sideEffects": false,
+  "description": "LLui router — structured path matching, history/hash mode, link helper",
+  "keywords": [
+    "llui",
+    "router",
+    "routing",
+    "history",
+    "navigation"
+  ],
+  "author": "Franco Ponticelli <franco.ponticelli@gmail.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fponticelli/llui.git",
+    "directory": "packages/router"
+  },
+  "bugs": {
+    "url": "https://github.com/fponticelli/llui/issues"
+  },
+  "homepage": "https://github.com/fponticelli/llui/tree/main/packages/router#readme",
+  "files": [
+    "dist"
+  ]
+}