hono 2.1.4 → 2.2.1

package/dist/router/reg-exp-router/router.js

@@ -1,90 +1,28 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RegExpRouter = void 0;
-const router_1 = require("../../router");
-const trie_1 = require("./trie");
+import { METHOD_NAME_ALL, METHODS, UnsupportedPathError } from '../../router';
+import { checkOptionalParameter } from '../../utils/url';
+import { PATH_ERROR } from './node';
+import { Trie } from './trie';
+const METHOD_NAMES = [METHOD_NAME_ALL, ...METHODS].map((method) => method.toUpperCase());
 const emptyParam = {};
 const nullMatcher = [/^$/, []];
-function initHint(path) {
-    const components = path.match(/\/(?::\w+{[^}]+}|[^\/]*)/g) || [];
-    let componentsLength = components.length;
-    const paramIndexList = [];
-    const regExpComponents = [];
-    const namedParams = [];
-    for (let i = 0, len = components.length; i < len; i++) {
-        if (i === len - 1 && components[i] === '/*') {
-            componentsLength--;
-            break;
-        }
-        const m = components[i].match(/^\/:(\w+)({[^}]+})?/);
-        if (m) {
-            namedParams.push([i, m[1], m[2] || '[^/]+']);
-            regExpComponents[i] = m[2] || true;
-        }
-        else if (components[i] === '/*') {
-            regExpComponents[i] = true;
-        }
-        else {
-            regExpComponents[i] = components[i];
-        }
-        if (/\/(?::|\*)/.test(components[i])) {
-            paramIndexList.push(i);
-        }
-    }
-    return {
-        components,
-        regExpComponents,
-        componentsLength,
-        endWithWildcard: path.endsWith('*'),
-        paramIndexList,
-        namedParams,
-        maybeHandler: true,
-    };
-}
-function compareRoute(a, b) {
-    if (a.path === '*') {
-        return 1;
-    }
-    let i = 0;
-    const len = a.hint.regExpComponents.length;
-    for (; i < len; i++) {
-        if (a.hint.regExpComponents[i] !== b.hint.regExpComponents[i]) {
-            if (a.hint.regExpComponents[i] === true) {
-                break;
-            }
-            return 0;
-        }
-    }
-    // may be ambiguous
-    for (; i < len; i++) {
-        if (a.hint.regExpComponents[i] !== true &&
-            a.hint.regExpComponents[i] !== b.hint.regExpComponents[i]) {
-            return 2;
-        }
-    }
-    return i === b.hint.regExpComponents.length || a.hint.endWithWildcard ? 1 : 0;
-}
-function compareHandler(a, b) {
-    return a.index - b.index;
-}
-function getSortedHandlers(handlers) {
-    return [...handlers].sort(compareHandler).map((h) => h.handler);
+function buildWildcardRegExp(path) {
+    return new RegExp(path === '*' ? '' : `^${path.replace(/\/\*/, '(?:|/.*)')}$`);
 }
-function buildMatcherFromPreprocessedRoutes(routes, hasAmbiguous = false) {
-    const trie = new trie_1.Trie({ reverse: hasAmbiguous });
+function buildMatcherFromPreprocessedRoutes(routes) {
+    const trie = new Trie();
     const handlers = [];
     if (routes.length === 0) {
         return nullMatcher;
     }
     for (let i = 0, len = routes.length; i < len; i++) {
-        const paramMap = trie.insert(routes[i].path, i);
-        handlers[i] = [
-            [...routes[i].middleware, ...routes[i].handlers],
-            Object.keys(paramMap).length !== 0 ? paramMap : null,
-        ];
-        if (!hasAmbiguous) {
-            handlers[i][0] = getSortedHandlers(handlers[i][0]);
+        let paramMap;
+        try {
+            paramMap = trie.insert(routes[i][0], i);
         }
+        catch (e) {
+            throw e === PATH_ERROR ? new UnsupportedPathError(routes[i][0]) : e;
+        }
+        handlers[i] = [routes[i][1], paramMap.length !== 0 ? paramMap : null];
     }
     const [regexp, indexReplacementMap, paramReplacementMap] = trie.buildRegExp();
     for (let i = 0, len = handlers.length; i < len; i++) {
@@ -92,12 +30,6 @@ function buildMatcherFromPreprocessedRoutes(routes, hasAmbiguous = false) {
         if (paramMap) {
             for (let j = 0, len = paramMap.length; j < len; j++) {
                 paramMap[j][1] = paramReplacementMap[paramMap[j][1]];
-                const aliasTo = routes[i].paramAliasMap[paramMap[j][0]];
-                if (aliasTo) {
-                    for (let k = 0, len = aliasTo.length; k < len; k++) {
-                        paramMap.push([aliasTo[k], paramMap[j][1]]);
-                    }
-                }
             }
         }
     }
@@ -108,260 +40,118 @@ function buildMatcherFromPreprocessedRoutes(routes, hasAmbiguous = false) {
     }
     return [regexp, handlerMap];
 }
-function verifyDuplicateParam(routes) {
-    const nameMap = {};
-    for (let i = 0, len = routes.length; i < len; i++) {
-        const route = routes[i];
-        for (let k = 0, len = route.hint.namedParams.length; k < len; k++) {
-            const [index, name] = route.hint.namedParams[k];
-            if (name in nameMap && index !== nameMap[name]) {
-                return false;
-            }
-            else {
-                nameMap[name] = index;
-            }
-        }
-        const paramAliasMap = route.paramAliasMap;
-        const paramAliasMapKeys = Object.keys(paramAliasMap);
-        for (let k = 0, len = paramAliasMapKeys.length; k < len; k++) {
-            const aliasFrom = paramAliasMapKeys[k];
-            for (let l = 0, len = paramAliasMap[aliasFrom].length; l < len; l++) {
-                const aliasTo = paramAliasMap[aliasFrom][l];
-                const index = nameMap[aliasFrom];
-                if (aliasTo in nameMap && index !== nameMap[aliasTo]) {
-                    return false;
-                }
-                else {
-                    nameMap[aliasTo] = index;
-                }
-            }
+function findMiddleware(middleware, path) {
+    if (!middleware) {
+        return undefined;
+    }
+    for (const k of Object.keys(middleware).sort((a, b) => b.length - a.length)) {
+        if (buildWildcardRegExp(k).test(path)) {
+            return [...middleware[k]];
         }
     }
-    return true;
+    return undefined;
 }
-class RegExpRouter {
+export class RegExpRouter {
     constructor() {
-        this.routeData = { index: 0, routes: [], methods: new Set() };
+        this.middleware = { [METHOD_NAME_ALL]: {} };
+        this.routes = { [METHOD_NAME_ALL]: {} };
     }
     add(method, path, handler) {
-        if (!this.routeData) {
+        var _a, _b;
+        const { middleware, routes } = this;
+        if (!middleware || !routes) {
             throw new Error('Can not add a route since the matcher is already built.');
         }
-        this.routeData.index++;
-        const { index, routes, methods } = this.routeData;
         if (path === '/*') {
             path = '*';
         }
-        const hint = initHint(path);
-        const handlerWithSortIndex = {
-            index,
-            handler,
-        };
-        for (let i = 0, len = routes.length; i < len; i++) {
-            if (routes[i].method === method && routes[i].path === path) {
-                routes[i].handlers.push(handlerWithSortIndex);
-                return;
-            }
+        if (/\*$/.test(path)) {
+            middleware[method] || (middleware[method] = {});
+            const re = buildWildcardRegExp(path);
+            (_a = middleware[method])[path] || (_a[path] = findMiddleware(middleware[METHOD_NAME_ALL], path) || []);
+            Object.keys(middleware).forEach((m) => {
+                if (method === METHOD_NAME_ALL || method === m) {
+                    Object.keys(middleware[m]).forEach((p) => {
+                        ;
+                        (path === '*' || path === p) && middleware[m][p].push(handler);
+                    });
+                }
+            });
+            Object.keys(routes).forEach((m) => {
+                if (method === METHOD_NAME_ALL || method === m) {
+                    Object.keys(routes[m]).forEach((p) => (path === '*' || re.test(p)) && routes[m][p].push(handler));
+                }
+            });
+            return;
+        }
+        const paths = checkOptionalParameter(path) || [path];
+        for (let i = 0, len = paths.length; i < len; i++) {
+            const path = paths[i];
+            routes[method] || (routes[method] = {});
+            (_b = routes[method])[path] || (_b[path] = [
+                ...(routes[METHOD_NAME_ALL][path] ||
+                    findMiddleware(middleware[method], path) ||
+                    findMiddleware(middleware[METHOD_NAME_ALL], path) ||
+                    []),
+            ]);
+            Object.keys(routes).forEach((m) => {
+                ;
+                (method === METHOD_NAME_ALL || method === m) &&
+                    routes[m][path] &&
+                    routes[m][path].push(handler);
+            });
         }
-        methods.add(method);
-        routes.push({
-            method,
-            path,
-            hint,
-            handlers: [handlerWithSortIndex],
-            middleware: [],
-            paramAliasMap: {},
-        });
     }
     match(method, path) {
-        const [primaryMatchers, secondaryMatchers, hasAmbiguous] = this.buildAllMatchers();
-        this.match = hasAmbiguous
-            ? (method, path) => {
-                const matcher = (primaryMatchers[method] ||
-                    primaryMatchers[router_1.METHOD_NAME_ALL]);
-                let match = path.match(matcher[0]);
-                if (!match) {
-                    // do not support secondary matchers here.
-                    return null;
-                }
-                const params = {};
-                const handlers = new Set();
-                let regExpSrc = matcher[0].source;
-                while (match) {
-                    let index = match.indexOf('', 1);
-                    for (;;) {
-                        const [handler, paramMap] = matcher[1][index];
-                        if (paramMap) {
-                            for (let i = 0, len = paramMap.length; i < len; i++) {
-                                params[paramMap[i][0]] = match[paramMap[i][1]];
-                            }
-                        }
-                        for (let i = 0, len = handler.length; i < len; i++) {
-                            handlers.add(handler[i]);
-                        }
-                        const newIndex = match.indexOf('', index + 1);
-                        if (newIndex === -1) {
-                            break;
-                        }
-                        index = newIndex;
-                    }
-                    regExpSrc = regExpSrc.replace(new RegExp(`((?:(?:\\(\\?:|.)*?\\([^)]*\\)){${index - 1}}.*?)\\(\\)`), '$1(^)');
-                    match = path.match(new RegExp(regExpSrc));
-                }
-                return { handlers: getSortedHandlers(handlers.values()), params };
+        const matchers = this.buildAllMatchers();
+        this.match = (method, path) => {
+            const matcher = matchers[method];
+            const match = path.match(matcher[0]);
+            if (!match) {
+                return null;
             }
-            : (method, path) => {
-                let matcher = (primaryMatchers[method] || primaryMatchers[router_1.METHOD_NAME_ALL]);
-                let match = path.match(matcher[0]);
-                if (!match) {
-                    const matchers = secondaryMatchers[method] || secondaryMatchers[router_1.METHOD_NAME_ALL];
-                    for (let i = 0, len = matchers.length; i < len && !match; i++) {
-                        matcher = matchers[i];
-                        match = path.match(matcher[0]);
-                    }
-                    if (!match) {
-                        return null;
-                    }
-                }
-                const index = match.indexOf('', 1);
-                const [handlers, paramMap] = matcher[1][index];
-                if (!paramMap) {
-                    return { handlers, params: emptyParam };
-                }
-                const params = {};
-                for (let i = 0, len = paramMap.length; i < len; i++) {
-                    params[paramMap[i][0]] = match[paramMap[i][1]];
-                }
-                return { handlers, params };
-            };
+            const index = match.indexOf('', 1);
+            const [handlers, paramMap] = matcher[1][index];
+            if (!paramMap) {
+                return { handlers, params: emptyParam };
+            }
+            const params = {};
+            for (let i = 0, len = paramMap.length; i < len; i++) {
+                params[paramMap[i][0]] = match[paramMap[i][1]];
+            }
+            return { handlers, params };
+        };
         return this.match(method, path);
     }
     buildAllMatchers() {
-        if (!this.routeData) {
-            throw new Error('Can not call the buildAllMatchers since the matcher is already built.');
-        }
-        this.routeData.routes.sort(({ hint: a }, { hint: b }) => {
-            if (a.componentsLength !== b.componentsLength) {
-                return a.componentsLength - b.componentsLength;
-            }
-            for (let i = 0, len = Math.min(a.paramIndexList.length, b.paramIndexList.length) + 1; i < len; i++) {
-                if (a.paramIndexList[i] !== b.paramIndexList[i]) {
-                    if (a.paramIndexList[i] === undefined) {
-                        return -1;
-                    }
-                    else if (b.paramIndexList[i] === undefined) {
-                        return 1;
-                    }
-                    else {
-                        return a.paramIndexList[i] - b.paramIndexList[i];
-                    }
-                }
-            }
-            if (a.endWithWildcard !== b.endWithWildcard) {
-                return a.endWithWildcard ? -1 : 1;
-            }
-            return 0;
+        const matchers = {};
+        METHOD_NAMES.forEach((method) => {
+            matchers[method] = this.buildMatcher(method) || matchers[METHOD_NAME_ALL];
         });
-        const primaryMatchers = {};
-        const secondaryMatchers = {};
-        let hasAmbiguous = false;
-        this.routeData.methods.forEach((method) => {
-            let _hasAmbiguous;
-            [primaryMatchers[method], secondaryMatchers[method], _hasAmbiguous] =
-                this.buildMatcher(method);
-            hasAmbiguous = hasAmbiguous || _hasAmbiguous;
-        });
-        if (hasAmbiguous) {
-            // rebuild all matchers with ambiguous flag
-            this.routeData.methods.forEach((method) => {
-                ;
-                [primaryMatchers[method], secondaryMatchers[method]] = this.buildMatcher(method, hasAmbiguous);
-            });
-        }
-        primaryMatchers[router_1.METHOD_NAME_ALL] || (primaryMatchers[router_1.METHOD_NAME_ALL] = nullMatcher);
-        secondaryMatchers[router_1.METHOD_NAME_ALL] || (secondaryMatchers[router_1.METHOD_NAME_ALL] = []);
-        delete this.routeData; // to reduce memory usage
-        return [primaryMatchers, secondaryMatchers, hasAmbiguous];
+        // Release cache
+        this.middleware = this.routes = undefined;
+        return matchers;
     }
-    buildMatcher(method, hasAmbiguous = false) {
-        var _a, _b;
-        const targetMethods = new Set([method, router_1.METHOD_NAME_ALL]);
-        // @ts-ignore
-        const routes = this.routeData.routes.filter(({ method }) => targetMethods.has(method));
-        // Reset temporary data per method
-        for (let i = 0, len = routes.length; i < len; i++) {
-            routes[i].middleware = [];
-            routes[i].paramAliasMap = {};
-        }
-        // preprocess routes
-        for (let i = 0, len = routes.length; i < len; i++) {
-            for (let j = i + 1; j < len; j++) {
-                const compareResult = compareRoute(routes[i], routes[j]);
-                // i includes j
-                if (compareResult === 1) {
-                    const components = routes[j].hint.components;
-                    const namedParams = routes[i].hint.namedParams;
-                    for (let k = 0, len = namedParams.length; k < len; k++) {
-                        const c = components[namedParams[k][0]];
-                        const m = c.match(/^\/:(\w+)({[^}]+})?/);
-                        if (m && namedParams[k][1] === m[1]) {
-                            continue;
-                        }
-                        if (m) {
-                            (_a = routes[j].paramAliasMap)[_b = m[1]] || (_a[_b] = []);
-                            routes[j].paramAliasMap[m[1]].push(namedParams[k][1]);
-                        }
-                        else {
-                            components[namedParams[k][0]] = `/:${namedParams[k][1]}{${c.substring(1)}}`;
-                            routes[j].hint.namedParams.push([
-                                namedParams[k][0],
-                                namedParams[k][1],
-                                c.substring(1),
-                            ]);
-                            routes[j].path = components.join('');
-                        }
-                    }
-                    if (routes[j].hint.components.length < routes[i].hint.components.length) {
-                        routes[j].middleware.push(...routes[i].handlers.map((h) => ({
-                            index: h.index,
-                            handler: h.handler,
-                        })));
-                    }
-                    else {
-                        routes[j].middleware.push(...routes[i].handlers);
-                    }
-                    routes[i].hint.maybeHandler = false;
-                }
-                else if (compareResult === 2) {
-                    // ambiguous
-                    hasAmbiguous = true;
-                    if (!verifyDuplicateParam([routes[i], routes[j]])) {
-                        throw new Error('Duplicate param name');
-                    }
-                }
+    buildMatcher(method) {
+        const routes = [];
+        let hasOwnRoute = method === METHOD_NAME_ALL;
+        [this.middleware, this.routes].forEach((r) => {
+            const ownRoute = r[method]
+                ? Object.keys(r[method]).map((path) => [path, r[method][path]])
+                : [];
+            if (ownRoute.length !== 0) {
+                hasOwnRoute || (hasOwnRoute = true);
+                routes.push(...ownRoute);
             }
-            if (!verifyDuplicateParam([routes[i]])) {
-                throw new Error('Duplicate param name');
+            else if (method !== METHOD_NAME_ALL) {
+                routes.push(...Object.keys(r[METHOD_NAME_ALL]).map((path) => [path, r[METHOD_NAME_ALL][path]]));
             }
+        });
+        if (!hasOwnRoute) {
+            return null;
         }
-        if (hasAmbiguous) {
-            return [buildMatcherFromPreprocessedRoutes(routes, hasAmbiguous), [], hasAmbiguous];
-        }
-        const primaryRoutes = [];
-        const secondaryRoutes = [];
-        for (let i = 0, len = routes.length; i < len; i++) {
-            if (routes[i].hint.maybeHandler || !routes[i].hint.endWithWildcard) {
-                primaryRoutes.push(routes[i]);
-            }
-            else {
-                secondaryRoutes.push(routes[i]);
-            }
+        else {
+            return buildMatcherFromPreprocessedRoutes(routes);
         }
-        return [
-            buildMatcherFromPreprocessedRoutes(primaryRoutes, hasAmbiguous),
-            [buildMatcherFromPreprocessedRoutes(secondaryRoutes, hasAmbiguous)],
-            hasAmbiguous,
-        ];
     }
 }
-exports.RegExpRouter = RegExpRouter;

package/dist/router/reg-exp-router/trie.d.ts

@@ -2,13 +2,9 @@ import type { ParamMap, Context } from './node';
 import { Node } from './node';
 export type { ParamMap } from './node';
 export declare type ReplacementMap = number[];
-interface InitOptions {
-    reverse: boolean;
-}
 export declare class Trie {
     context: Context;
     root: Node;
-    constructor({ reverse }?: InitOptions);
     insert(path: string, index: number): ParamMap;
     buildRegExp(): [RegExp, ReplacementMap, ReplacementMap];
 }

package/dist/router/reg-exp-router/trie.js

@@ -1,11 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Trie = void 0;
-const node_1 = require("./node");
-class Trie {
-    constructor({ reverse } = { reverse: false }) {
+import { Node } from './node';
+export class Trie {
+    constructor() {
         this.context = { varIndex: 0 };
-        this.root = new node_1.Node({ reverse });
+        this.root = new Node();
     }
     insert(path, index) {
         const paramMap = [];
@@ -39,4 +36,3 @@ class Trie {
         return [new RegExp(`^${regexp}`), indexReplacementMap, paramReplacementMap];
     }
 }
-exports.Trie = Trie;

package/dist/router/smart-router/index.d.ts

@@ -0,0 +1 @@
+export { SmartRouter } from './router';

package/dist/router/smart-router/index.js

@@ -0,0 +1 @@
+export { SmartRouter } from './router';

package/dist/router/smart-router/router.d.ts

@@ -0,0 +1,9 @@
+import type { Router, Result } from '../../router';
+export declare class SmartRouter<T> implements Router<T> {
+    routers: Router<T>[];
+    routes?: [string, string, T][];
+    constructor(init: Pick<SmartRouter<T>, 'routers'>);
+    add(method: string, path: string, handler: T): void;
+    match(method: string, path: string): Result<T> | null;
+    get activeRouter(): Router<T>;
+}

package/dist/router/smart-router/router.js

@@ -0,0 +1,53 @@
+import { UnsupportedPathError } from '../../router';
+export class SmartRouter {
+    constructor(init) {
+        this.routers = [];
+        this.routes = [];
+        Object.assign(this, init);
+    }
+    add(method, path, handler) {
+        if (!this.routes) {
+            throw new Error('Can not add a route since the matcher is already built.');
+        }
+        this.routes.push([method, path, handler]);
+    }
+    match(method, path) {
+        if (!this.routes) {
+            throw new Error('Fatal error');
+        }
+        const { routers, routes } = this;
+        const len = routers.length;
+        let i = 0;
+        let res;
+        for (; i < len; i++) {
+            const router = routers[i];
+            try {
+                routes.forEach((args) => {
+                    router.add(...args);
+                });
+                res = router.match(method, path);
+            }
+            catch (e) {
+                if (e instanceof UnsupportedPathError) {
+                    continue;
+                }
+                throw e;
+            }
+            this.match = router.match.bind(router);
+            this.routers = [router];
+            this.routes = undefined;
+            break;
+        }
+        if (i === len) {
+            // not found
+            throw new Error('Fatal error');
+        }
+        return res || null;
+    }
+    get activeRouter() {
+        if (this.routes || this.routers.length !== 1) {
+            throw new Error('No active router has been determined yet.');
+        }
+        return this.routers[0];
+    }
+}

package/dist/router/static-router/index.d.ts

@@ -0,0 +1 @@
+export { StaticRouter } from './router';

package/dist/router/static-router/index.js

@@ -0,0 +1 @@
+export { StaticRouter } from './router';

package/dist/router/static-router/router.d.ts

@@ -0,0 +1,8 @@
+import type { Router, Result } from '../../router';
+export declare class StaticRouter<T> implements Router<T> {
+    middleware: Record<string, Result<T>>;
+    routes: Record<string, Record<string, Result<T>>>;
+    constructor();
+    add(method: string, path: string, handler: T): void;
+    match(method: string, path: string): Result<T> | null;
+}

package/dist/router/static-router/router.js

@@ -0,0 +1,68 @@
+import { METHOD_NAME_ALL, METHODS, UnsupportedPathError } from '../../router';
+export class StaticRouter {
+    constructor() {
+        this.middleware = {};
+        this.routes = {};
+        [METHOD_NAME_ALL, ...METHODS].forEach((method) => {
+            this.routes[method.toUpperCase()] = {};
+        });
+    }
+    add(method, path, handler) {
+        var _a;
+        const { middleware, routes } = this;
+        if (path === '/*') {
+            path = '*';
+        }
+        if (path === '*') {
+            if (method === METHOD_NAME_ALL) {
+                middleware[METHOD_NAME_ALL] || (middleware[METHOD_NAME_ALL] = { handlers: [], params: {} });
+                Object.keys(middleware).forEach((m) => {
+                    middleware[m].handlers.push(handler);
+                });
+                Object.keys(routes).forEach((m) => {
+                    Object.values(routes[m]).forEach((matchRes) => matchRes.handlers.push(handler));
+                });
+            }
+            else {
+                middleware[method] || (middleware[method] = {
+                    handlers: [...(middleware[METHOD_NAME_ALL]?.handlers || [])],
+                    params: {},
+                });
+                middleware[method].handlers.push(handler);
+                if (routes[method]) {
+                    Object.values(routes[method]).forEach((matchRes) => matchRes.handlers.push(handler));
+                }
+            }
+            return;
+        }
+        if (/\*|\/:/.test(path)) {
+            throw new UnsupportedPathError(path);
+        }
+        (_a = routes[method])[path] || (_a[path] = {
+            handlers: [
+                ...(routes[METHOD_NAME_ALL][path]?.handlers ||
+                    middleware[method]?.handlers ||
+                    middleware[METHOD_NAME_ALL]?.handlers ||
+                    []),
+            ],
+            params: {},
+        });
+        if (method === METHOD_NAME_ALL) {
+            Object.keys(routes).forEach((m) => {
+                routes[m][path]?.handlers?.push(handler);
+            });
+        }
+        else {
+            routes[method][path].handlers.push(handler);
+        }
+    }
+    match(method, path) {
+        const { routes, middleware } = this;
+        this.match = (method, path) => routes[method][path] ||
+            routes[METHOD_NAME_ALL][path] ||
+            middleware[method] ||
+            middleware[METHOD_NAME_ALL] ||
+            null;
+        return this.match(method, path);
+    }
+}

package/dist/router/trie-router/index.js

@@ -1,5 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TrieRouter = void 0;
-var router_1 = require("./router");
-Object.defineProperty(exports, "TrieRouter", { enumerable: true, get: function () { return router_1.TrieRouter; } });
+export { TrieRouter } from './router';