@esportsplus/routing 0.0.22 → 0.0.24

package/build/browser.d.ts

@@ -1,15 +1,15 @@
 import { Middleware, Response, Router } from './types';
 declare function back(): void;
 declare function forward(): void;
-declare const _default: <R>(instance?: Router<R> | undefined) => {
+declare const _default: <T>(instance?: Router<T> | undefined) => {
     back: typeof back;
     forward: typeof forward;
-    middleware: (...middleware: Middleware<R>[]) => () => Response<R>;
+    middleware: (...middleware: Middleware<T>[]) => () => Response<T>;
     redirect: (path: string, { state, values }: {
         state?: Record<PropertyKey, unknown> | undefined;
         values?: unknown[] | undefined;
     }) => void;
-    router: Router<R>;
+    router: Router<T>;
     uri: (path: string, values?: unknown[]) => string;
 };
 export default _default;

package/build/router/index.d.ts

@@ -1,26 +1,26 @@
 import { Options } from '../types';
 import { Node } from './node';
 import { Route } from './route';
-declare class Router<R> {
-    groups: Omit<Options<R>, 'responder'>[];
-    root: Node<R>;
-    routes: Record<string, Route<R>>;
-    static: Record<string, Route<R>>;
+declare class Router<T> {
+    groups: Omit<Options<T>, 'responder'>[];
+    root: Node<T>;
+    routes: Record<string, Route<T>>;
+    static: Record<string, Route<T>>;
     subdomains: string[] | null;
     constructor();
     private add;
     private route;
-    delete(options: Options<R>): this;
-    get(options: Options<R>): this;
-    group(options: Router<R>['groups'][0]): {
-        routes: (fn: (router: Router<R>) => void) => void;
+    delete(options: Options<T>): this;
+    get(options: Options<T>): this;
+    group(options: Router<T>['groups'][0]): {
+        routes: (fn: (router: Router<T>) => void) => void;
     };
-    match(method: string, path: string, subdomain?: string | null): ReturnType<Node<R>['find']>;
-    on(methods: string[], options: Options<R>): this;
-    post(options: Options<R>): this;
-    put(options: Options<R>): this;
+    match(method: string, path: string, subdomain?: string | null): ReturnType<Node<T>['find']>;
+    on(methods: string[], options: Options<T>): this;
+    post(options: Options<T>): this;
+    put(options: Options<T>): this;
     uri(name: string, values?: unknown[]): string;
 }
-declare const _default: <R>() => Router<R>;
+declare const _default: <T>() => Router<T>;
 export default _default;
 export { Router, Route };

package/build/router/node.d.ts

@@ -1,16 +1,16 @@
 import { Route } from './index';
-declare class Node<R> {
-    children: Map<string | number, Node<R>> | null;
-    parent: Node<R> | null;
+declare class Node<T> {
+    children: Map<string | number, Node<T>> | null;
+    parent: Node<T> | null;
     path: string | null;
     property: string | null;
-    route: Route<R> | null;
+    route: Route<T> | null;
     type: number | null;
-    constructor(parent?: Node<R>['parent']);
-    add(path: string, route: Route<R>): Node<R>;
+    constructor(parent?: Node<T>['parent']);
+    add(path: string, route: Route<T>): Node<T>;
     find(path: string): {
         parameters?: Record<PropertyKey, unknown>;
-        route?: Route<R>;
+        route?: Route<T>;
     };
     remove(path: string): void;
 }

package/build/router/route.d.ts

@@ -1,12 +1,12 @@
 import { Middleware, Next, Responder } from '../types';
-declare class Route<R> {
-    dispatch: Next<R> | null;
+declare class Route<T> {
+    dispatch: Next<T> | null;
     name: string | null;
     path: string | null;
-    responder: Responder<R>;
-    stack: Middleware<R>[] | null;
+    responder: Responder<T>;
+    stack: Middleware<T>[] | null;
     subdomain: string | null;
-    constructor(responder: Responder<R>);
-    get dispatcher(): Next<R>;
+    constructor(responder: Responder<T>);
+    get dispatcher(): Next<T>;
 }
 export { Route };

package/build/types.d.ts

@@ -1,16 +1,16 @@
 import { Next as N, Stage } from '@esportsplus/pipeline';
 import { Route, Router } from './router';
-type Middleware<R> = Stage<Request, Response<R>>;
-type Next<R> = N<Request, Response<R>>;
-type Options<R> = {
-    middleware?: Middleware<R>[];
+type Middleware<T> = Stage<Request<T>, Response<T>>;
+type Next<T> = N<Request<T>, Response<T>>;
+type Options<T> = {
+    middleware?: Middleware<T>[];
     name?: string;
     path?: string;
-    responder: Responder<R>;
+    responder: Responder<T>;
     subdomain?: string;
 };
-type Request = {
-    data: Record<PropertyKey, unknown>;
+type Request<T> = {
+    data: Record<PropertyKey, unknown> & ReturnType<Router<T>['match']>;
     href: string;
     hostname: string;
     method: string;
@@ -21,6 +21,6 @@ type Request = {
     query: Record<string, unknown>;
     subdomain?: string;
 };
-type Responder<R> = (request: Request) => Response<R>;
-type Response<R> = Promise<R> | R;
+type Responder<T> = (request: Request<T>) => Response<T>;
+type Response<T> = Promise<T> | T;
 export { Middleware, Next, Options, Request, Responder, Response, Route, Router };

package/package.json

@@ -2,10 +2,10 @@
     "author": "ICJR",
     "dependencies": {
         "@esportsplus/pipeline": "^0.0.1",
-        "@esportsplus/reactivity": "^0.0.30"
+        "@esportsplus/reactivity": "^0.1.2"
     },
     "devDependencies": {
-        "@esportsplus/typescript": "^0.0.1"
+        "@esportsplus/typescript": "^0.0.3"
     },
     "main": "./build/index.js",
     "name": "@esportsplus/routing",
@@ -17,5 +17,5 @@
         "prepublishOnly": "npm run build"
     },
     "types": "./build/index.d.ts",
-    "version": "0.0.22"
+    "version": "0.0.24"
 }

package/src/browser.ts

@@ -4,7 +4,7 @@ import pipeline from '@esportsplus/pipeline';
 import factory from './router';
 
 
-let cache: Request[] = [],
+let cache: Request<any>[] = [],
     registered = false;
 
 
@@ -37,7 +37,7 @@ function onpopstate() {
     }
 }
 
-function request(): Request {
+function request<T>(): Request<T> {
     let { hash, hostname, href, origin, port, protocol } = new URL( window.location?.href || '' ),
         path = hash ? hash.slice(1).split('?') : ['/', ''];
 
@@ -55,9 +55,9 @@ function request(): Request {
 }
 
 
-export default <R>(instance?: Router<R>) => {
-    let router = instance || factory<R>(),
-        state = reactive( request() );
+export default <T>(instance?: Router<T>) => {
+    let router = instance || factory<T>(),
+        state = reactive( request<T>() );
 
     cache.push(state);
 
@@ -69,8 +69,8 @@ export default <R>(instance?: Router<R>) => {
     return {
         back,
         forward,
-        middleware: (...middleware: Middleware<R>[]) => {
-            let instance = pipeline<Request, Response<R>>(...middleware);
+        middleware: (...middleware: Middleware<T>[]) => {
+            let instance = pipeline<Request<T>, Response<T>>(...middleware);
 
             return () => instance(state);
         },

package/src/router/index.ts

@@ -23,7 +23,7 @@ function radixkey(method: string, path: string, subdomain?: string | null) {
     return ((subdomain ? subdomain + ' ' : '') + method).toUpperCase() + ' ' + normalize(path);
 }
 
-function set<R>(route: Route<R>, key: keyof Route<R>, value?: unknown) {
+function set<T>(route: Route<T>, key: keyof Route<T>, value?: unknown) {
     if (!value) {
         return;
     }
@@ -44,11 +44,11 @@ function set<R>(route: Route<R>, key: keyof Route<R>, value?: unknown) {
 }
 
 
-class Router<R> {
-    groups: Omit<Options<R>, 'responder'>[] = [];
-    root: Node<R>;
-    routes: Record<string, Route<R>> = {};
-    static: Record<string, Route<R>> = {};
+class Router<T> {
+    groups: Omit<Options<T>, 'responder'>[] = [];
+    root: Node<T>;
+    routes: Record<string, Route<T>> = {};
+    static: Record<string, Route<T>> = {};
     subdomains: string[] | null = null;
 
 
@@ -57,7 +57,7 @@ class Router<R> {
     }
 
 
-    private add(radixkey: string, route: Route<R>) {
+    private add(radixkey: string, route: Route<T>) {
         if (radixkey.indexOf(':') === -1 || this.root.add(radixkey, route).type === STATIC) {
             if (this.static[radixkey]) {
                 throw new Error(`Routing: static path '${radixkey}' is already in use`);
@@ -69,7 +69,7 @@ class Router<R> {
         return this;
     }
 
-    private route({ middleware, name, path, responder, subdomain }: Options<R>) {
+    private route({ middleware, name, path, responder, subdomain }: Options<T>) {
         let route = new Route(responder);
 
         for (let i = 0, n = this.groups.length; i < n; i++) {
@@ -98,19 +98,19 @@ class Router<R> {
     }
 
 
-    delete(options: Options<R>) {
+    delete(options: Options<T>) {
         this.on(['DELETE'], options);
         return this;
     }
 
-    get(options: Options<R>) {
+    get(options: Options<T>) {
         this.on(['GET'], options);
         return this;
     }
 
-    group(options: Router<R>['groups'][0]) {
+    group(options: Router<T>['groups'][0]) {
         return {
-            routes: (fn: (router: Router<R>) => void) => {
+            routes: (fn: (router: Router<T>) => void) => {
                 this.groups.push(options);
                 fn(this);
                 this.groups.pop();
@@ -118,7 +118,7 @@ class Router<R> {
         }
     }
 
-    match(method: string, path: string, subdomain?: string | null): ReturnType<Node<R>['find']> {
+    match(method: string, path: string, subdomain?: string | null): ReturnType<Node<T>['find']> {
         let key = radixkey(method, path, subdomain);
 
         if (key in this.static) {
@@ -130,7 +130,7 @@ class Router<R> {
         return this.root.find(key);
     }
 
-    on(methods: string[], options: Options<R>) {
+    on(methods: string[], options: Options<T>) {
         let route = this.route(options);
 
         if (route.name) {
@@ -171,12 +171,12 @@ class Router<R> {
         return this;
     }
 
-    post(options: Options<R>) {
+    post(options: Options<T>) {
         this.on(['POST'], options);
         return this;
     }
 
-    put(options: Options<R>) {
+    put(options: Options<T>) {
         this.on(['PUT'], options);
         return this;
     }
@@ -219,5 +219,5 @@ class Router<R> {
 }
 
 
-export default <R>() => new Router<R>();
+export default <T>() => new Router<T>();
 export { Router, Route };

package/src/router/node.ts

@@ -2,28 +2,28 @@ import { PLACEHOLDER, STATIC, WILDCARD } from '~/constants';
 import { Route } from './index';
 
 
-class Node<R> {
-    children: Map<string | number, Node<R>> | null = null;
-    parent: Node<R> | null = null;
+class Node<T> {
+    children: Map<string | number, Node<T>> | null = null;
+    parent: Node<T> | null = null;
     path: string | null = null;
     property: string | null = null;
-    route: Route<R> | null = null;
+    route: Route<T> | null = null;
     type: number | null = null;
 
 
-    constructor(parent: Node<R>['parent'] = null) {
+    constructor(parent: Node<T>['parent'] = null) {
         this.parent = parent;
     }
 
 
-    add(path: string, route: Route<R>) {
-        let node: Node<R> | undefined = this,
+    add(path: string, route: Route<T>) {
+        let node: Node<T> | undefined = this,
             segments = path.split('/'),
-            type: Node<R>['type'] = STATIC,
+            type: Node<T>['type'] = STATIC,
             unnamed = 0;
 
         for (let i = 0, n = segments.length; i < n; i++) {
-            let child: Node<R> | undefined = node.children?.get(segments[i]);
+            let child: Node<T> | undefined = node.children?.get(segments[i]);
 
             if (!child) {
                 let segment = segments[i],
@@ -33,7 +33,7 @@ class Node<R> {
                     node.children = new Map();
                 }
 
-                node.children.set(segment, (child = new Node<R>(node)));
+                node.children.set(segment, (child = new Node<T>(node)));
 
                 // Named property
                 if (symbol === ':') {
@@ -61,12 +61,12 @@ class Node<R> {
 
     find(path: string): {
         parameters?: Record<PropertyKey, unknown>;
-        route?: Route<R>;
+        route?: Route<T>;
     } {
-        let node: Node<R> | undefined = this,
+        let node: Node<T> | undefined = this,
             parameters: Record<PropertyKey, unknown> = {},
             segments = path.split('/'),
-            wildcard: { node: Node<R>, value: string } | null = null;
+            wildcard: { node: Node<T>, value: string } | null = null;
 
         for (let i = 0, n = segments.length; i < n; i++) {
             let segment = segments[i],
@@ -80,7 +80,7 @@ class Node<R> {
             }
 
             // Exact matches take precedence over placeholders
-            let next: Node<R> | undefined = node.children?.get(segment);
+            let next: Node<T> | undefined = node.children?.get(segment);
 
             if (next) {
                 node = next;
@@ -112,7 +112,7 @@ class Node<R> {
     }
 
     remove(path: string) {
-        let node: Node<R> | undefined = this,
+        let node: Node<T> | undefined = this,
             segments = path.split('/');
 
         for (let i = 0, n = segments.length; i < n; i++) {

package/src/router/route.ts

@@ -2,16 +2,16 @@ import { Middleware, Next, Responder } from '~/types';
 import pipeline from '@esportsplus/pipeline';
 
 
-class Route<R> {
-    dispatch: Next<R> | null = null;
+class Route<T> {
+    dispatch: Next<T> | null = null;
     name: string | null = null;
     path: string | null = null;
-    responder: Responder<R>;
-    stack: Middleware<R>[] | null = null;
+    responder: Responder<T>;
+    stack: Middleware<T>[] | null = null;
     subdomain: string | null = null;
 
 
-    constructor(responder: Responder<R>) {
+    constructor(responder: Responder<T>) {
         this.responder = responder;
     }
 

package/src/types.ts

@@ -2,20 +2,20 @@ import { Next as N, Stage } from '@esportsplus/pipeline';
 import { Route, Router } from './router';
 
 
-type Middleware<R> = Stage<Request, Response<R>>;
+type Middleware<T> = Stage<Request<T>, Response<T>>;
 
-type Next<R> = N<Request, Response<R>>;
+type Next<T> = N<Request<T>, Response<T>>;
 
-type Options<R> = {
-    middleware?: Middleware<R>[];
+type Options<T> = {
+    middleware?: Middleware<T>[];
     name?: string;
     path?: string;
-    responder: Responder<R>;
+    responder: Responder<T>;
     subdomain?: string;
 };
 
-type Request = {
-    data: Record<PropertyKey, unknown>;
+type Request<T> = {
+    data: Record<PropertyKey, unknown> & ReturnType<Router<T>['match']>;
     href: string;
     hostname: string;
     method: string;
@@ -27,9 +27,9 @@ type Request = {
     subdomain?: string;
 };
 
-type Responder<R> = (request: Request) => Response<R>;
+type Responder<T> = (request: Request<T>) => Response<T>;
 
-type Response<R> = Promise<R> | R;
+type Response<T> = Promise<T> | T;
 
 
 export { Middleware, Next, Options, Request, Responder, Response, Route, Router };

package/build/hash.d.ts

@@ -1,70 +0,0 @@
-import { Router } from './types';
-declare let cache: {
-    factory: typeof request;
-    state: Record<PropertyKey, unknown>;
-}[];
-declare const back: () => void;
-declare const forward: () => void;
-declare const listener: {
-    register: (factory: (typeof cache)[0]['factory'], state: (typeof cache)[0]['state']) => () => void;
-    remove: (state: (typeof cache)[0]['state']) => void;
-};
-declare const factory: {
-    redirect: (router: Router) => (path: string, { state, values }: {
-        state?: Record<PropertyKey, unknown> | undefined;
-        values?: unknown[] | undefined;
-    }) => void;
-    uri: (router: Router) => (path: string, values?: unknown[]) => string;
-};
-declare const request: (url?: string) => {
-    href: string;
-    hostname: string;
-    method: string;
-    origin: string;
-    path: string;
-    port: string;
-    protocol: string;
-    query: {
-        [k: string]: string;
-    };
-};
-declare const _default: {
-    back: () => void;
-    factory: {
-        redirect: (router: Router) => (path: string, { state, values }: {
-            state?: Record<PropertyKey, unknown> | undefined;
-            values?: unknown[] | undefined;
-        }) => void;
-        uri: (router: Router) => (path: string, values?: unknown[]) => string;
-    };
-    forward: () => void;
-    listener: {
-        register: (factory: (url?: string) => {
-            href: string;
-            hostname: string;
-            method: string;
-            origin: string;
-            path: string;
-            port: string;
-            protocol: string;
-            query: {
-                [k: string]: string;
-            };
-        }, state: Record<PropertyKey, unknown>) => () => void;
-        remove: (state: Record<PropertyKey, unknown>) => void;
-    };
-    request: (url?: string) => {
-        href: string;
-        hostname: string;
-        method: string;
-        origin: string;
-        path: string;
-        port: string;
-        protocol: string;
-        query: {
-            [k: string]: string;
-        };
-    };
-};
-export default _default;
-export { back, factory, forward, listener, request };

package/build/hash.js

@@ -1,75 +0,0 @@
-let cache = [], registered = false;
-function update() {
-    for (let i = 0, n = cache.length; i < n; i++) {
-        let { factory, state } = cache[i], values = factory();
-        for (let key in values) {
-            state[key] = values[key];
-        }
-    }
-}
-const back = () => window.history.back();
-const forward = () => window.history.forward();
-const listener = {
-    register: (factory, state) => {
-        cache.push({ factory, state });
-        if (!registered) {
-            registered = true;
-            update();
-            window.addEventListener('popstate', update);
-        }
-        return () => {
-            listener.remove(state);
-        };
-    },
-    remove: (state) => {
-        for (let i = 0, n = cache.length; i < n; i++) {
-            if (cache[i].state !== state) {
-                continue;
-            }
-            cache[i] = cache[n - 1];
-            cache.pop();
-            if (cache.length === 0) {
-                window.removeEventListener('popstate', update);
-            }
-            return;
-        }
-    }
-};
-const factory = {
-    redirect: (router) => {
-        return (path, { state, values }) => {
-            if (path.startsWith('http://') || path.startsWith('https://')) {
-                return window.location.replace(path);
-            }
-            let uri = router.uri(path, values || []);
-            if (uri[0] === '/') {
-                uri = '#' + uri;
-            }
-            window.history.pushState(state || {}, '', uri);
-        };
-    },
-    uri: (router) => {
-        return (path, values = []) => {
-            let uri = router.uri(path, values || []);
-            if (uri[0] === '/') {
-                uri = '#' + uri;
-            }
-            return uri;
-        };
-    }
-};
-const request = (url = window?.location?.href || '') => {
-    let { hash, hostname, href, origin, port, protocol } = new URL(url), path = hash?.replace('#/', '/')?.split('?') || ['/', ''];
-    return {
-        href,
-        hostname,
-        method: 'GET',
-        origin,
-        path: path[0],
-        port,
-        protocol,
-        query: Object.fromEntries((new URLSearchParams(path[1])).entries())
-    };
-};
-export default { back, factory, forward, listener, request };
-export { back, factory, forward, listener, request };

package/build/middleware/dispatch.d.ts

@@ -1,9 +0,0 @@
-import { Request } from '../types';
-import { Router } from '../router';
-declare const _default: <R>(request: Request & {
-    data: {
-        parameters?: Record<PropertyKey, unknown> | undefined;
-        route?: import("../router/route").Route<R> | undefined;
-    };
-}) => import("../types").Response<R>;
-export default _default;

package/build/middleware/dispatch.js

@@ -1,7 +0,0 @@
-export default (request) => {
-    let { route } = request.data;
-    if (route === undefined) {
-        throw new Error(`Routing: route dispatching failed, route is undefined!`);
-    }
-    return route.dispatcher(request);
-};

package/build/middleware/factory.d.ts

@@ -1,3 +0,0 @@
-import { Middleware } from '../types';
-declare const _default: (...middleware: Middleware[]) => <T>(request: T) => unknown;
-export default _default;

package/build/middleware/factory.js

@@ -1,13 +0,0 @@
-function error() {
-    throw new Error('Routing: request middleware did not return a responder');
-}
-export default (...middleware) => {
-    let stack = [];
-    for (let i = 0, n = middleware.length; i < n; i++) {
-        stack[i] = (request) => middleware[i](request, stack[i + 1] || error);
-    }
-    if (!stack.length) {
-        throw new Error('Routing: request middleware has not been defined');
-    }
-    return (request) => stack[0](request);
-};

package/build/middleware/index.d.ts

@@ -1,13 +0,0 @@
-import dispatch from './dispatch';
-import match from './match';
-declare const _default: {
-    dispatch: <R>(request: import("../types").Request & {
-        data: {
-            parameters?: Record<PropertyKey, unknown> | undefined;
-            route?: import("../router/route").Route<R> | undefined;
-        };
-    }) => import("../types").Response<R>;
-    match: <R_1>(router: import("../router").Router<R_1>, subdomain?: string | undefined) => import("../types").Middleware<R_1>;
-};
-export default _default;
-export { dispatch, match };

package/build/middleware/index.js

@@ -1,4 +0,0 @@
-import dispatch from './dispatch';
-import match from './match';
-export default { dispatch, match };
-export { dispatch, match };

package/build/middleware/match.d.ts

@@ -1,3 +0,0 @@
-import { Middleware, Router } from '../types';
-declare const _default: <R>(router: Router<R>, subdomain?: string) => Middleware<R>;
-export default _default;

package/build/middleware/match.js

@@ -1,23 +0,0 @@
-export default (router, subdomain) => {
-    return (request, next) => {
-        let match = subdomain || request.subdomain;
-        if (match === undefined) {
-            if (router.subdomains) {
-                for (let i = 0, n = router.subdomains.length; i < n; i++) {
-                    if (!request.hostname.startsWith(router.subdomains[i])) {
-                        continue;
-                    }
-                    match = router.subdomains[i];
-                    break;
-                }
-            }
-            if (match === undefined) {
-                match = '';
-            }
-        }
-        let { parameters, route } = router.match(request.method, request.path, match);
-        request.data.parameters = parameters;
-        request.data.route = route;
-        return next(request);
-    };
-};

package/build/router/path.d.ts

@@ -1,6 +0,0 @@
-declare const normalize: (path: string) => string;
-declare const radixkey: (path: string, { method, subdomain }?: {
-    method?: string | null | undefined;
-    subdomain?: string | null | undefined;
-}) => string;
-export { normalize, radixkey };

package/build/router/path.js

@@ -1,20 +0,0 @@
-const normalize = (path) => {
-    if (path[0] !== '/') {
-        path = '/' + path;
-    }
-    if (path.endsWith('/')) {
-        path = path.slice(0, -1);
-    }
-    return path || '/';
-};
-const radixkey = (path, { method, subdomain } = {}) => {
-    let prefix = '';
-    if (subdomain) {
-        prefix = subdomain + ' ';
-    }
-    if (method) {
-        prefix += method + ' ';
-    }
-    return prefix.toUpperCase() + normalize(path);
-};
-export { normalize, radixkey };

package/build/spa.d.ts

@@ -1,14 +0,0 @@
-import { Middleware, Response, Router } from './types';
-declare function back(): void;
-declare function forward(): void;
-declare const _default: <R>(router: Router<R>) => {
-    back: typeof back;
-    forward: typeof forward;
-    middleware: (...fns: Middleware<R>[]) => () => Response<R>;
-    redirect: (path: string, { state, values }: {
-        state?: Record<PropertyKey, unknown> | undefined;
-        values?: unknown[] | undefined;
-    }) => void;
-    uri: (path: string, values?: unknown[]) => string;
-};
-export default _default;

package/build/spa.js

@@ -1,63 +0,0 @@
-import { reactive } from '@esportsplus/reactivity';
-import pipeline from '@esportsplus/pipeline';
-let cache = [], registered = false;
-function back() {
-    window.history.back();
-}
-function forward() {
-    window.history.forward();
-}
-function normalize(uri) {
-    if (uri[0] === '/') {
-        return '#' + uri;
-    }
-    return uri;
-}
-function request() {
-    let { hash, hostname, href, origin, port, protocol } = new URL(window.location?.href || ''), path = hash ? hash.slice(1).split('?') : ['/', ''];
-    return {
-        data: {},
-        href,
-        hostname,
-        method: 'GET',
-        origin,
-        path: path[0],
-        port,
-        protocol,
-        query: path[1] ? Object.fromEntries((new URLSearchParams(path[1])).entries()) : {}
-    };
-}
-function event() {
-    let values = request();
-    for (let i = 0, n = cache.length; i < n; i++) {
-        let state = cache[i];
-        for (let key in values) {
-            state[key] = values[key];
-        }
-    }
-}
-export default (router) => {
-    let state = reactive(request());
-    cache.push(state);
-    if (!registered) {
-        registered = true;
-        window.addEventListener('popstate', event);
-    }
-    return {
-        back,
-        forward,
-        middleware: (...fns) => {
-            let instance = pipeline(...fns);
-            return () => instance(state);
-        },
-        redirect: (path, { state, values }) => {
-            if (path.startsWith('https://') || path.startsWith('http://')) {
-                return window.location.replace(path);
-            }
-            window.history.pushState((state || {}), '', normalize(router.uri(path, values || [])));
-        },
-        uri: (path, values = []) => {
-            return normalize(router.uri(path, values || []));
-        }
-    };
-};

package/build/symbols.d.ts

@@ -1,4 +0,0 @@
-declare const PLACEHOLDER = 0;
-declare const STATIC = 1;
-declare const WILDCARD = 2;
-export { PLACEHOLDER, STATIC, WILDCARD };

package/build/symbols.js

@@ -1,4 +0,0 @@
-const PLACEHOLDER = 0;
-const STATIC = 1;
-const WILDCARD = 2;
-export { PLACEHOLDER, STATIC, WILDCARD };