@esportsplus/routing 0.0.47 → 0.0.49

package/build/browser.d.ts

@@ -8,7 +8,7 @@ declare const _default: <T>(instance?: Router<T>) => {
     middleware: {
         (...middleware: Middleware<T>[]): () => T;
         dispatch(request: Request<T>): T;
-        match(fallback: Route<T>, scheduler: Scheduler, subdomain?: string | undefined): (request: Request<T>, next: Next<T>) => import("@esportsplus/template").Renderable;
+        match(fallback: Route<T>, scheduler: Scheduler, subdomain?: string | undefined): (request: Request<T>, next: Next<T>) => T;
     };
     redirect: (path: string, values?: unknown[]) => void;
     router: Router<T>;

package/build/browser.js

@@ -1,5 +1,4 @@
 import { effect, reactive, root } from '@esportsplus/reactivity';
-import { html } from '@esportsplus/template';
 import pipeline from '@esportsplus/pipeline';
 import factory from './router';
 let cache = [];
@@ -67,22 +66,20 @@ function middleware(request, router) {
             state.route = route || fallback;
         });
         return (request, next) => {
-            return html `${() => {
-                if (state.route === undefined) {
-                    throw new Error('Routing: route is undefined');
-                }
-                if (state.root !== undefined) {
-                    state.root.dispose();
-                }
-                return root((root) => {
-                    request.data = {
-                        parameters: state.parameters,
-                        route: state.route
-                    };
-                    state.root = root;
-                    return next(request);
-                }, scheduler);
-            }}`;
+            if (state.route === undefined) {
+                throw new Error('Routing: route is undefined');
+            }
+            if (state.root !== undefined) {
+                state.root.dispose();
+            }
+            return root((root) => {
+                request.data = {
+                    parameters: state.parameters,
+                    route: state.route
+                };
+                state.root = root;
+                return next(request);
+            }, scheduler);
         };
     };
     return host;

package/build/index.d.ts

@@ -1,5 +1,6 @@
 import browser from './browser';
 import router from './router';
+import { Router as R2 } from './router2';
 import slugify from './slugify';
-export { browser, router, slugify };
+export { browser, router, slugify, R2 };
 export * from './types';

package/build/index.js

@@ -1,5 +1,6 @@
 import browser from './browser';
 import router from './router';
+import { Router as R2 } from './router2';
 import slugify from './slugify';
-export { browser, router, slugify };
+export { browser, router, slugify, R2 };
 export * from './types';

package/build/router2/constants.d.ts

@@ -0,0 +1,3 @@
+declare const METHOD_NAME_ALL = "ALL";
+declare const PATH_ERROR: unique symbol;
+export { METHOD_NAME_ALL, PATH_ERROR };

package/build/router2/constants.js

@@ -0,0 +1,3 @@
+const METHOD_NAME_ALL = 'ALL';
+const PATH_ERROR = Symbol();
+export { METHOD_NAME_ALL, PATH_ERROR };

package/build/router2/index.d.ts

@@ -0,0 +1,11 @@
+import { HandlerMap, Method, Path, Result } from './types';
+declare class Router<T> {
+    middleware?: Record<Method, Record<Path, HandlerMap<T>[]>>;
+    routes?: Record<Method, Record<Path, HandlerMap<T>[]>>;
+    constructor();
+    private buildAllMatchers;
+    private buildMatcher;
+    add(method: Method, path: Path, handler: T): void;
+    match(method: Method, path: Path): Result<T>;
+}
+export { Router };

package/build/router2/index.js

@@ -0,0 +1,226 @@
+import { METHOD_NAME_ALL, PATH_ERROR } from './constants';
+import { Trie } from './trie';
+const NULL_MATCHER = [/^$/, [], Object.create(null)];
+let empty = [], wildcardCache = Object.create(null);
+function buildMatcherFromPreprocessedRoutes(routes) {
+    if (routes.length === 0) {
+        return NULL_MATCHER;
+    }
+    let handlerMetadata = [], routesWithStaticPathFlag = routes
+        .map((route) => [!/\*|\/:/.test(route[0]), ...route])
+        .sort(([isStaticA, pathA], [isStaticB, pathB]) => isStaticA ? 1 : isStaticB ? -1 : pathA.length - pathB.length), staticMap = Object.create(null), trie = new Trie();
+    for (let i = 0, j = -1, n = routesWithStaticPathFlag.length; i < n; i++) {
+        let [validatePathOnly, path, handlers] = routesWithStaticPathFlag[i];
+        if (validatePathOnly) {
+            staticMap[path] = [handlers.map(([h]) => [h, Object.create(null)]), empty];
+        }
+        else {
+            j++;
+        }
+        let parameterMetadata;
+        try {
+            parameterMetadata = trie.insert(path, j, validatePathOnly);
+        }
+        catch (e) {
+            throw e === PATH_ERROR ? new Error(`Routing: '${path}' is not supported`) : e;
+        }
+        if (validatePathOnly) {
+            continue;
+        }
+        handlerMetadata[j] = handlers.map(([h, i]) => {
+            let paramIndexMap = Object.create(null);
+            i -= 1;
+            for (; i >= 0; i--) {
+                let [key, value] = parameterMetadata[i];
+                paramIndexMap[key] = value;
+            }
+            return [h, paramIndexMap];
+        });
+    }
+    let [regexp, handlerReplacementMap, parameterReplacementMap] = trie.build();
+    for (let i = 0, n = handlerMetadata.length; i < n; i++) {
+        let metadata = handlerMetadata[i];
+        for (let j = 0, n = metadata.length; j < n; j++) {
+            let map = metadata[j]?.[1];
+            if (!map) {
+                continue;
+            }
+            for (let key in map) {
+                map[key] = parameterReplacementMap[map[key]];
+            }
+        }
+    }
+    let handlerMap = [];
+    for (let i = 0, n = handlerReplacementMap.length; i < n; i++) {
+        handlerMap[i] = handlerMetadata[handlerReplacementMap[i]];
+    }
+    return [regexp, handlerMap, staticMap];
+}
+function buildWildcardRegExp(path) {
+    return (wildcardCache[path] ??= new RegExp(path === '*'
+        ? ''
+        : `^${path.replace(/\/\*$|([.\\+*[^\]$()])/g, (_, char) => char ? `\\${char}` : '(?:|/.*)')}$`));
+}
+function clearWildcardCache() {
+    wildcardCache = Object.create(null);
+}
+function findMiddleware(middleware, path) {
+    if (!middleware) {
+        return undefined;
+    }
+    let keys = Object.keys(middleware).sort((a, b) => b.length - a.length);
+    for (let i = 0, n = keys.length; i < n; i++) {
+        if (buildWildcardRegExp(keys[i]).test(path)) {
+            return [...middleware[keys[i]]];
+        }
+    }
+    return undefined;
+}
+function findOptionalParameters(path) {
+    if (!path.match(/\:.+\?$/)) {
+        return null;
+    }
+    let base = '', results = [], segments = path.split('/');
+    for (let i = 0, n = segments.length; i < n; i++) {
+        let segment = segments[i];
+        if (segment !== '' && !/\:/.test(segment)) {
+            base += '/' + segment;
+        }
+        else if (/\:/.test(segment)) {
+            if (/\?/.test(segment)) {
+                if (results.length === 0 && base === '') {
+                    results.push('/');
+                }
+                else {
+                    results.push(base);
+                }
+                base += '/' + segment.replace('?', '');
+                results.push(base);
+            }
+            else {
+                base += '/' + segment;
+            }
+        }
+    }
+    return results.filter((v, i, a) => a.indexOf(v) === i);
+}
+class Router {
+    middleware;
+    routes;
+    constructor() {
+        this.middleware = {
+            [METHOD_NAME_ALL]: Object.create(null)
+        };
+        this.routes = {
+            [METHOD_NAME_ALL]: Object.create(null)
+        };
+    }
+    buildAllMatchers() {
+        let matchers = Object.create(null);
+        for (let method in this.middleware) {
+            matchers[method] ||= this.buildMatcher(method);
+        }
+        for (let method in this.routes) {
+            matchers[method] ||= this.buildMatcher(method);
+        }
+        this.middleware = this.routes = undefined;
+        return matchers;
+    }
+    buildMatcher(method) {
+        let isAll = method === METHOD_NAME_ALL, properties = [this.middleware, this.routes], property, routes = [];
+        while (property = properties.pop()) {
+            let values = property[method]
+                ? Object.keys(property[method]).map((path) => [path, property[method][path]])
+                : [];
+            if (values.length !== 0) {
+                isAll ||= true;
+                routes.push(...values);
+            }
+            else if (method !== METHOD_NAME_ALL) {
+                routes.push(...Object.keys(property[METHOD_NAME_ALL]).map((path) => [path, property[METHOD_NAME_ALL][path]]));
+            }
+        }
+        return isAll === true ? buildMatcherFromPreprocessedRoutes(routes) : null;
+    }
+    add(method, path, handler) {
+        let { middleware, routes } = this;
+        if (!middleware || !routes) {
+            throw new Error('Routing: Cannot add route after matcher has been built.');
+        }
+        if (!middleware[method]) {
+            let properties = [middleware, routes], property;
+            while (property = properties.pop()) {
+                let copy = property[METHOD_NAME_ALL], into = property[method];
+                property[method] = Object.create(null);
+                for (let path in copy) {
+                    into[path] = [...copy[path]];
+                }
+            }
+        }
+        if (path === '/*') {
+            path = '*';
+        }
+        let parameters = (path.match(/\/:/g) || []).length;
+        if (/\*$/.test(path)) {
+            let regex = buildWildcardRegExp(path);
+            if (method === METHOD_NAME_ALL) {
+                for (let m in middleware) {
+                    middleware[m][path] ||=
+                        findMiddleware(middleware[m], path) ||
+                            findMiddleware(middleware[METHOD_NAME_ALL], path) ||
+                            [];
+                }
+            }
+            else {
+                middleware[method][path] ||=
+                    findMiddleware(middleware[method], path) ||
+                        findMiddleware(middleware[METHOD_NAME_ALL], path) ||
+                        [];
+            }
+            let properties = [middleware, routes], property;
+            while (property = properties.pop()) {
+                for (let m in property) {
+                    if (method === METHOD_NAME_ALL || method === m) {
+                        let routes = property[m];
+                        for (let path in routes) {
+                            regex.test(path) && routes[path].push([handler, parameters]);
+                        }
+                    }
+                }
+            }
+            return;
+        }
+        let paths = findOptionalParameters(path) || [path];
+        for (let i = 0, n = paths.length; i < n; i++) {
+            let path = paths[i];
+            for (let m in routes) {
+                if (method === METHOD_NAME_ALL || method === m) {
+                    let r = routes[m];
+                    r[path] ||= [
+                        ...(findMiddleware(middleware[m], path) ||
+                            findMiddleware(middleware[METHOD_NAME_ALL], path) ||
+                            []),
+                    ];
+                    r[path].push([handler, parameters - n + i + 1]);
+                }
+            }
+        }
+    }
+    match(method, path) {
+        clearWildcardCache();
+        let matchers = this.buildAllMatchers();
+        this.match = (method, path) => {
+            let matcher = (matchers[method] || matchers[METHOD_NAME_ALL]), staticMatch = matcher[2][path];
+            if (staticMatch) {
+                return staticMatch;
+            }
+            let match = path.match(matcher[0]);
+            if (!match) {
+                return [[], empty];
+            }
+            return [matcher[1][match.indexOf('', 1)], match];
+        };
+        return this.match(method, path);
+    }
+}
+export { Router };

package/build/router2/node.d.ts

@@ -0,0 +1,10 @@
+import type { Trie } from './trie';
+import { ParameterMetadata, Path } from './types';
+declare class Node {
+    children: Record<Path, Node>;
+    index?: number;
+    slot?: number;
+    buildRegexString(): Path;
+    insert(tokens: readonly Path[], index: number, parameters: ParameterMetadata, context: Trie['context'], validatePathOnly: boolean): void;
+}
+export { Node };

package/build/router2/node.js

@@ -0,0 +1,117 @@
+import { PATH_ERROR } from './constants';
+const LABEL_REGEXP = '[^/]+';
+const REGEXP_CHARACTERS = new Set('.\\+*[^]$()');
+const WILDCARD_ONLY_REGEXP = '.*';
+const WILDCARD_TAIL_REGEXP = '(?:|/.*)';
+const MATCH_WILDCARD_ONLY = ['', '', WILDCARD_ONLY_REGEXP];
+const MATCH_LABEL = ['', '', LABEL_REGEXP];
+const MATCH_WILDCARD_TAIL = ['', '', WILDCARD_TAIL_REGEXP];
+function sort(a, b) {
+    if (a.length === 1) {
+        return b.length === 1 ? (a < b ? -1 : 1) : -1;
+    }
+    else if (b.length === 1) {
+        return 1;
+    }
+    if (a === WILDCARD_ONLY_REGEXP || a === WILDCARD_TAIL_REGEXP) {
+        return 1;
+    }
+    else if (b === WILDCARD_ONLY_REGEXP || b === WILDCARD_TAIL_REGEXP) {
+        return -1;
+    }
+    if (a === LABEL_REGEXP) {
+        return 1;
+    }
+    else if (b === LABEL_REGEXP) {
+        return -1;
+    }
+    return a.length === b.length ? (a < b ? -1 : 1) : b.length - a.length;
+}
+class Node {
+    children = Object.create(null);
+    index;
+    slot;
+    buildRegexString() {
+        let children = this.children, path, paths = Object.keys(children).sort(sort);
+        for (let i = 0, n = paths.length; i < n; i++) {
+            let child = children[path = paths[i]];
+            paths[i] = (typeof child.slot === 'number'
+                ? `(${path})@${child.slot}`
+                : REGEXP_CHARACTERS.has(path)
+                    ? `\\${path}`
+                    : path) + child.buildRegexString();
+        }
+        if (typeof this.index === 'number') {
+            paths.unshift(`#${this.index}`);
+        }
+        if (paths.length === 0) {
+            return '';
+        }
+        else if (paths.length === 1) {
+            return paths[0];
+        }
+        return '(?:' + paths.join('|') + ')';
+    }
+    insert(tokens, index, parameters, context, validatePathOnly) {
+        if (tokens.length === 0) {
+            if (this.index !== undefined) {
+                throw PATH_ERROR;
+            }
+            else if (validatePathOnly) {
+                return;
+            }
+            this.index = index;
+            return;
+        }
+        let [token, ...remainingTokens] = tokens, node, pattern = token === '*'
+            ? remainingTokens.length === 0
+                ? MATCH_WILDCARD_ONLY
+                : MATCH_LABEL
+            : token === '/*'
+                ? MATCH_WILDCARD_TAIL
+                : token.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
+        if (pattern) {
+            let name = pattern[1], path = pattern[2] || LABEL_REGEXP;
+            if (name && pattern[2]) {
+                path = path.replace(/^\((?!\?:)(?=[^)]+\)$)/, '(?:');
+                if (/\((?!\?:)/.test(path)) {
+                    throw PATH_ERROR;
+                }
+            }
+            node = this.children[path];
+            if (!node) {
+                for (let key in this.children) {
+                    if (key !== WILDCARD_ONLY_REGEXP && key !== WILDCARD_TAIL_REGEXP) {
+                        throw PATH_ERROR;
+                    }
+                }
+                if (validatePathOnly) {
+                    return;
+                }
+                node = this.children[path] = new Node();
+                if (name !== '') {
+                    node.slot = context.slot++;
+                }
+            }
+            if (name !== '' && validatePathOnly === false) {
+                parameters.push([name, node.slot]);
+            }
+        }
+        else {
+            node = this.children[token];
+            if (!node) {
+                for (let key in this.children) {
+                    if (key.length > 1 && key !== WILDCARD_ONLY_REGEXP && key !== WILDCARD_TAIL_REGEXP) {
+                        throw PATH_ERROR;
+                    }
+                }
+                if (validatePathOnly) {
+                    return;
+                }
+                node = this.children[token] = new Node();
+            }
+        }
+        node.insert(remainingTokens, index, parameters, context, validatePathOnly);
+    }
+}
+export { Node };

package/build/router2/trie.d.ts

@@ -0,0 +1,11 @@
+import { Node } from './node';
+import { Indexes, ParameterMetadata, Path } from './types';
+declare class Trie {
+    context: {
+        slot: number;
+    };
+    root: Node;
+    build(): [RegExp, Indexes, Indexes];
+    insert(path: Path, index: number, pathErrorCheckOnly: boolean): ParameterMetadata;
+}
+export { Trie };

package/build/router2/trie.js

@@ -0,0 +1,53 @@
+import { Node } from './node';
+const NEVER_MATCH = [/^$/, [], []];
+class Trie {
+    context = { slot: 0 };
+    root = new Node();
+    build() {
+        let regex = this.root.buildRegexString();
+        if (regex === '') {
+            return NEVER_MATCH;
+        }
+        let handlers = [], i = 0, parameters = [];
+        regex = regex.replace(/#(\d+)|@(\d+)|\.\*\$/g, (_, handler, parameter) => {
+            if (typeof handler !== 'undefined') {
+                handlers[++i] = Number(handler);
+                return '$()';
+            }
+            else if (typeof parameter !== 'undefined') {
+                parameters[Number(parameter)] = ++i;
+            }
+            return '';
+        });
+        return [new RegExp(`^${regex}`), handlers, parameters];
+    }
+    insert(path, index, pathErrorCheckOnly) {
+        let groups = [], parameters = [];
+        for (let i = 0;;) {
+            let replaced = false;
+            path = path.replace(/\{[^}]+\}/g, (m) => {
+                let mark = `@\\${i}`;
+                groups[i++] = [mark, m];
+                replaced = true;
+                return mark;
+            });
+            if (!replaced) {
+                break;
+            }
+        }
+        let tokens = path.match(/(?::[^\/]+)|(?:\/\*$)|./g) || [];
+        for (let i = groups.length - 1; i >= 0; i--) {
+            let [mark, replacement] = groups[i], token;
+            for (let j = tokens.length - 1; j >= 0; j--) {
+                token = tokens[j];
+                if (token.indexOf(mark) !== -1) {
+                    token = token.replace(mark, replacement);
+                    break;
+                }
+            }
+        }
+        this.root.insert(tokens, index, parameters, this.context, pathErrorCheckOnly);
+        return parameters;
+    }
+}
+export { Trie };

package/build/router2/types.d.ts

@@ -0,0 +1,11 @@
+type HandlerMap<T> = [T, number];
+type HandlerMetadata<T> = [T, ParameterMap][];
+type Indexes = number[];
+type Matcher<T> = [RegExp, HandlerMetadata<T>[], StaticMap<T>];
+type Method = string;
+type ParameterMap = Record<string, number>;
+type ParameterMetadata = [string, number][];
+type Path = string;
+type Result<T> = [[T, ParameterMap][], string[]] | [[T, Record<string, string>][]];
+type StaticMap<T> = Record<Path, Result<T>>;
+export { HandlerMap, HandlerMetadata, Indexes, Matcher, Method, ParameterMap, ParameterMetadata, Path, Result, StaticMap };

package/build/router2/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -2,8 +2,7 @@
     "author": "ICJR",
     "dependencies": {
         "@esportsplus/pipeline": "^0.0.6",
-        "@esportsplus/reactivity": "^0.1.21",
-        "@esportsplus/template": "^0.2.4"
+        "@esportsplus/reactivity": "^0.1.21"
     },
     "devDependencies": {
         "@esportsplus/typescript": "^0.1.2"
@@ -18,5 +17,5 @@
         "prepublishOnly": "npm run build"
     },
     "types": "./build/index.d.ts",
-    "version": "0.0.47"
+    "version": "0.0.49"
 }

package/src/browser.ts

@@ -1,5 +1,4 @@
 import { effect, reactive, root, Root, Scheduler } from '@esportsplus/reactivity';
-import { html } from '@esportsplus/template';
 import { Middleware, Next, Request, Route, Router } from './types';
 import pipeline from '@esportsplus/pipeline';
 import factory from './router';
@@ -90,25 +89,23 @@ function middleware<T>(request: Request<T>, router: Router<T>) {
         });
 
         return (request: Request<T>, next: Next<T>) => {
-            return html`${() => {
-                if (state.route === undefined) {
-                    throw new Error('Routing: route is undefined');
-                }
-
-                if (state.root !== undefined) {
-                    state.root.dispose();
-                }
-
-                return root((root) => {
-                    request.data = {
-                        parameters: state.parameters,
-                        route: state.route
-                    };
-                    state.root = root;
-
-                    return next(request);
-                }, scheduler);
-            }}`;
+            if (state.route === undefined) {
+                throw new Error('Routing: route is undefined');
+            }
+
+            if (state.root !== undefined) {
+                state.root.dispose();
+            }
+
+            return root((root) => {
+                request.data = {
+                    parameters: state.parameters,
+                    route: state.route
+                };
+                state.root = root;
+
+                return next(request);
+            }, scheduler);
         };
     };
 

package/src/index.ts

@@ -1,7 +1,8 @@
 import browser from './browser';
 import router from './router';
+import { Router as R2 } from './router2';
 import slugify from './slugify';
 
 
-export { browser, router, slugify };
+export { browser, router, slugify, R2 };
 export * from './types';

package/src/router2/constants.ts

@@ -0,0 +1,6 @@
+const METHOD_NAME_ALL = 'ALL';
+
+const PATH_ERROR = Symbol();
+
+
+export { METHOD_NAME_ALL, PATH_ERROR };

package/src/router2/index.ts

@@ -0,0 +1,330 @@
+import { METHOD_NAME_ALL, PATH_ERROR } from './constants';
+import { Trie } from './trie';
+import { HandlerMap, HandlerMetadata, Matcher, Method, ParameterMap, ParameterMetadata, Path, Result, StaticMap } from './types';
+
+
+const NULL_MATCHER = [/^$/, [], Object.create(null)] as Matcher<any>;
+
+
+let empty: any[] = [],
+    wildcardCache: Record<Path, RegExp> = Object.create(null);
+
+
+function buildMatcherFromPreprocessedRoutes<T>(routes: [Path, HandlerMap<T>[]][]): Matcher<T> {
+    if (routes.length === 0) {
+        return NULL_MATCHER;
+    }
+
+    let handlerMetadata: HandlerMetadata<T>[] = [],
+        routesWithStaticPathFlag = routes
+            .map(
+                (route) => [!/\*|\/:/.test(route[0]), ...route] as [boolean, Path, HandlerMap<T>[]]
+            )
+            .sort(([isStaticA, pathA], [isStaticB, pathB]) =>
+                isStaticA ? 1 : isStaticB ? -1 : pathA.length - pathB.length
+            ),
+        staticMap: StaticMap<T> = Object.create(null),
+        trie = new Trie();
+
+    for (let i = 0, j = -1, n = routesWithStaticPathFlag.length; i < n; i++) {
+        let [ validatePathOnly, path, handlers ] = routesWithStaticPathFlag[i];
+
+        if (validatePathOnly) {
+            staticMap[path] = [ handlers.map(([h]) => [h, Object.create(null)]), empty ]
+        }
+        else {
+            j++
+        }
+
+        let parameterMetadata: ParameterMetadata;
+
+        try {
+            parameterMetadata = trie.insert(path, j, validatePathOnly)
+        }
+        catch (e) {
+            throw e === PATH_ERROR ? new Error(`Routing: '${path}' is not supported`) : e
+        }
+
+        if (validatePathOnly) {
+            continue
+        }
+
+        handlerMetadata[j] = handlers.map(([h, i]) => {
+            let paramIndexMap: ParameterMap = Object.create(null);
+
+            i -= 1;
+
+            for (; i >= 0; i--) {
+                let [key, value] = parameterMetadata[i];
+
+                paramIndexMap[key] = value;
+            }
+
+            return [h, paramIndexMap];
+        })
+    }
+
+    let [regexp, handlerReplacementMap, parameterReplacementMap] = trie.build();
+
+    for (let i = 0, n = handlerMetadata.length; i < n; i++) {
+        let metadata = handlerMetadata[i];
+
+        for (let j = 0, n = metadata.length; j < n; j++) {
+            let map = metadata[j]?.[1];
+
+            if (!map) {
+                continue;
+            }
+
+            for (let key in map) {
+                map[key] = parameterReplacementMap[ map[key] ];
+            }
+        }
+    }
+
+    let handlerMap: HandlerMetadata<T>[] = [];
+
+    for (let i = 0, n = handlerReplacementMap.length; i < n; i++) {
+        handlerMap[i] = handlerMetadata[handlerReplacementMap[i]];
+    }
+
+    return [regexp, handlerMap, staticMap] as Matcher<T>;
+}
+
+function buildWildcardRegExp(path: Path): RegExp {
+    return (wildcardCache[path] ??= new RegExp(
+        path === '*'
+            ? ''
+            : `^${path.replace(/\/\*$|([.\\+*[^\]$()])/g, (_, char) =>
+                char ? `\\${char}` : '(?:|/.*)'
+            )}$`
+    ))
+}
+
+function clearWildcardCache() {
+    wildcardCache = Object.create(null);
+}
+
+function findMiddleware<T>(middleware: Record<string, T[]> | undefined, path: Path): T[] | undefined {
+    if (!middleware) {
+        return undefined;
+    }
+
+    let keys = Object.keys(middleware).sort((a, b) => b.length - a.length);
+
+    for (let i = 0, n = keys.length; i < n; i++) {
+        if (buildWildcardRegExp(keys[i]).test(path)) {
+            return [...middleware[keys[i]]];
+        }
+    }
+
+    return undefined;
+}
+
+// If path is `/api/animals/:type?` [`/api/animals`, `/api/animals/:type`] else null
+function findOptionalParameters(path: Path): string[] | null {
+    if (!path.match(/\:.+\?$/)) {
+        return null
+    }
+
+    let base = '',
+        results: string[] = [],
+        segments = path.split('/');
+
+    for (let i = 0, n = segments.length; i < n; i++) {
+        let segment = segments[i];
+
+        if (segment !== '' && !/\:/.test(segment)) {
+            base += '/' + segment;
+        }
+        else if (/\:/.test(segment)) {
+            if (/\?/.test(segment)) {
+                if (results.length === 0 && base === '') {
+                    results.push('/');
+                }
+                else {
+                    results.push(base);
+                }
+
+                base += '/' + segment.replace('?', '');
+                results.push(base);
+            }
+            else {
+                base += '/' + segment;
+            }
+        }
+    }
+
+    return results.filter((v, i, a) => a.indexOf(v) === i);
+}
+
+
+class Router<T> {
+    middleware?: Record<Method, Record<Path, HandlerMap<T>[]>>
+    routes?: Record<Method, Record<Path, HandlerMap<T>[]>>
+
+
+    constructor() {
+        this.middleware = {
+            [METHOD_NAME_ALL]: Object.create(null)
+        };
+        this.routes = {
+            [METHOD_NAME_ALL]: Object.create(null)
+        };
+    }
+
+
+    private buildAllMatchers(): Record<Method, Matcher<T> | null> {
+        let matchers: Record<Method, Matcher<T> | null> = Object.create(null);
+
+        for (let method in this.middleware) {
+            matchers[method] ||= this.buildMatcher(method);
+        }
+
+        for (let method in this.routes) {
+            matchers[method] ||= this.buildMatcher(method);
+        }
+
+        this.middleware = this.routes = undefined;
+
+        return matchers;
+    }
+
+    private buildMatcher(method: Method): Matcher<T> | null {
+        let isAll = method === METHOD_NAME_ALL,
+            properties = [this.middleware, this.routes],
+            property,
+            routes: [Path, HandlerMap<T>[]][] = [];
+
+        while (property = properties.pop()) {
+            let values = property[method]
+                    ? Object.keys(property[method]).map((path) => [path, property![method][path]])
+                    : [];
+
+            if (values.length !== 0) {
+                isAll ||= true;
+                routes.push(...(values as typeof routes));
+            }
+            else if (method !== METHOD_NAME_ALL) {
+                routes.push(
+                    ...(Object.keys(property[METHOD_NAME_ALL]).map((path) => [path, property![METHOD_NAME_ALL][path]]) as typeof routes)
+                );
+            }
+        }
+
+        return isAll === true ? buildMatcherFromPreprocessedRoutes(routes) : null;
+    }
+
+    add(method: Method, path: Path, handler: T) {
+        let { middleware, routes } = this;
+
+        if (!middleware || !routes) {
+            throw new Error('Routing: Cannot add route after matcher has been built.');
+        }
+
+        if (!middleware[method]) {
+            let properties = [middleware, routes],
+                property;
+
+            while (property = properties.pop()) {
+                let copy = property[METHOD_NAME_ALL],
+                    into = property[method];
+
+                property[method] = Object.create(null);
+
+                for (let path in copy) {
+                    into[path] = [ ...copy[path] ];
+                }
+            }
+        }
+
+        if (path === '/*') {
+            path = '*';
+        }
+
+        let parameters = (path.match(/\/:/g) || []).length;
+
+        if (/\*$/.test(path)) {
+            let regex = buildWildcardRegExp(path);
+
+            if (method === METHOD_NAME_ALL) {
+                for (let m in middleware) {
+                    middleware[m][path] ||=
+                        findMiddleware(middleware[m], path) ||
+                        findMiddleware(middleware[METHOD_NAME_ALL], path) ||
+                        [];
+                }
+            }
+            else {
+                middleware[method][path] ||=
+                    findMiddleware(middleware[method], path) ||
+                    findMiddleware(middleware[METHOD_NAME_ALL], path) ||
+                    [];
+            }
+
+            let properties = [middleware, routes],
+                property;
+
+            while (property = properties.pop()) {
+                for (let m in property) {
+                    if (method === METHOD_NAME_ALL || method === m) {
+                        let routes = property[m];
+
+                        for (let path in routes) {
+                            regex.test(path) && routes[path].push([handler, parameters]);
+                        }
+                    }
+                }
+            }
+
+            return;
+        }
+
+        let paths = findOptionalParameters(path) || [path];
+
+        for (let i = 0, n = paths.length; i < n; i++) {
+            let path = paths[i];
+
+            for (let m in routes) {
+                if (method === METHOD_NAME_ALL || method === m) {
+                    let r = routes[m];
+
+                    r[path] ||= [
+                        ...(findMiddleware(middleware[m], path) ||
+                            findMiddleware(middleware[METHOD_NAME_ALL], path) ||
+                            []),
+                    ];
+                    r[path].push([handler, parameters - n + i + 1]);
+                }
+            }
+        }
+    }
+
+    match(method: Method, path: Path): Result<T> {
+        clearWildcardCache();
+
+        let matchers = this.buildAllMatchers();
+
+        this.match = (method, path) => {
+            let matcher = (matchers[method] || matchers[METHOD_NAME_ALL]) as Matcher<T>,
+                staticMatch = matcher[2][path];
+
+            if (staticMatch) {
+                return staticMatch;
+            }
+
+            let match = path.match(matcher[0]);
+
+            if (!match) {
+                return [[], empty];
+            }
+
+            return [matcher[1][match.indexOf('', 1)], match];
+        }
+
+        return this.match(method, path);
+    }
+}
+
+
+export { Router };

package/src/router2/node.ts

@@ -0,0 +1,184 @@
+import { PATH_ERROR } from './constants';
+import type { Trie } from './trie';
+import { ParameterMetadata, Path } from './types';
+
+
+const LABEL_REGEXP = '[^/]+';
+
+const REGEXP_CHARACTERS = new Set('.\\+*[^]$()');
+
+const WILDCARD_ONLY_REGEXP = '.*';
+
+const WILDCARD_TAIL_REGEXP = '(?:|/.*)';
+
+
+// '*' matches to all the trailing paths
+const MATCH_WILDCARD_ONLY = ['', '', WILDCARD_ONLY_REGEXP];
+
+const MATCH_LABEL = ['', '', LABEL_REGEXP];
+
+// '/path/to/*' is /\/path\/to(?:|/.*)$
+const MATCH_WILDCARD_TAIL = ['', '', WILDCARD_TAIL_REGEXP];
+
+
+/**
+ * Sort order:
+ * 1. literal
+ * 2. special pattern (e.g. :label{[0-9]+})
+ * 3. common label pattern (e.g. :label)
+ * 4. wildcard
+ */
+function sort(a: Path, b: Path): number {
+    if (a.length === 1) {
+        return b.length === 1 ? (a < b ? -1 : 1) : -1;
+    }
+    else if (b.length === 1) {
+        return 1;
+    }
+
+    if (a === WILDCARD_ONLY_REGEXP || a === WILDCARD_TAIL_REGEXP) {
+        return 1;
+    }
+    else if (b === WILDCARD_ONLY_REGEXP || b === WILDCARD_TAIL_REGEXP) {
+        return -1;
+    }
+
+    if (a === LABEL_REGEXP) {
+        return 1;
+    }
+    else if (b === LABEL_REGEXP) {
+        return -1;
+    }
+
+    return a.length === b.length ? (a < b ? -1 : 1) : b.length - a.length;
+}
+
+
+class Node {
+    children: Record<Path, Node> = Object.create(null);
+    index?: number;
+    slot?: number;
+
+
+    buildRegexString(): Path {
+        let children = this.children,
+            path,
+            paths: Path[] = Object.keys(children).sort(sort);
+
+        for (let i = 0, n = paths.length; i < n; i++) {
+            let child = children[ path = paths[i] ];
+
+            paths[i] = (
+                typeof child.slot === 'number'
+                    ? `(${path})@${child.slot}`
+                    : REGEXP_CHARACTERS.has(path)
+                        ? `\\${path}`
+                        : path
+            ) + child.buildRegexString();
+        }
+
+        if (typeof this.index === 'number') {
+            paths.unshift(`#${this.index}`);
+        }
+
+        if (paths.length === 0) {
+            return '';
+        }
+        else if (paths.length === 1) {
+            return paths[0];
+        }
+
+        return '(?:' + paths.join('|') + ')';
+    }
+
+    insert(
+        tokens: readonly Path[],
+        index: number,
+        parameters: ParameterMetadata,
+        context: Trie['context'],
+        validatePathOnly: boolean
+    ): void {
+        if (tokens.length === 0) {
+            if (this.index !== undefined) {
+                throw PATH_ERROR;
+            }
+            else if (validatePathOnly) {
+                return;
+            }
+
+            this.index = index;
+            return;
+        }
+
+        let [token, ...remainingTokens] = tokens,
+            node,
+            pattern = token === '*'
+                ? remainingTokens.length === 0
+                    ? MATCH_WILDCARD_ONLY
+                    : MATCH_LABEL
+                : token === '/*'
+                    ? MATCH_WILDCARD_TAIL
+                    : token.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
+
+        if (pattern) {
+            let name = pattern[1],
+                path = pattern[2] || LABEL_REGEXP;
+
+            if (name && pattern[2]) {
+                // (a|b) => (?:a|b)
+                path = path.replace(/^\((?!\?:)(?=[^)]+\)$)/, '(?:');
+
+                // prefix(?:a|b) is allowed, but prefix(a|b) is not
+                if (/\((?!\?:)/.test(path)) {
+                    throw PATH_ERROR;
+                }
+            }
+
+            node = this.children[path];
+
+            if (!node) {
+                for (let key in this.children) {
+                    if (key !== WILDCARD_ONLY_REGEXP && key !== WILDCARD_TAIL_REGEXP) {
+                        throw PATH_ERROR;
+                    }
+                }
+
+                if (validatePathOnly) {
+                    return;
+                }
+
+                node = this.children[path] = new Node();
+
+                if (name !== '') {
+                    node.slot = context.slot++;
+                }
+            }
+
+            if (name !== '' && validatePathOnly === false) {
+                parameters.push([name, node.slot as number]);
+            }
+        }
+        else {
+            node = this.children[token];
+
+            if (!node) {
+                for (let key in this.children) {
+                    if (key.length > 1 && key !== WILDCARD_ONLY_REGEXP && key !== WILDCARD_TAIL_REGEXP) {
+                        throw PATH_ERROR;
+                    }
+                }
+
+                if (validatePathOnly) {
+                    return;
+                }
+
+                node = this.children[token] = new Node();
+            }
+        }
+
+        node.insert(remainingTokens, index, parameters, context, validatePathOnly);
+    }
+}
+
+
+export { Node };

package/src/router2/trie.ts

@@ -0,0 +1,88 @@
+import { Node } from './node'
+import { Indexes, ParameterMetadata, Path } from './types';
+
+
+const NEVER_MATCH = [/^$/, [], []] as [RegExp, Indexes, Indexes];
+
+
+class Trie {
+    context = { slot: 0 };
+    root = new Node();
+
+
+    build(): [RegExp, Indexes, Indexes] {
+        let regex = this.root.buildRegexString();
+
+        if (regex === '') {
+            return NEVER_MATCH;
+        }
+
+        let handlers: Indexes = [],
+            i = 0,
+            parameters: Indexes = [];
+
+        regex = regex.replace(/#(\d+)|@(\d+)|\.\*\$/g, (_, handler, parameter) => {
+            if (typeof handler !== 'undefined') {
+                handlers[++i] = Number(handler);
+                return '$()';
+            }
+            else if (typeof parameter !== 'undefined') {
+                parameters[Number(parameter)] = ++i;
+            }
+
+            return '';
+        })
+
+        return [new RegExp(`^${regex}`), handlers, parameters];
+    }
+
+    insert(path: Path, index: number, pathErrorCheckOnly: boolean): ParameterMetadata {
+        let groups: [string, string][] = [],
+            parameters: ParameterMetadata = [];
+
+        for (let i = 0; ;) {
+            let replaced = false;
+
+            path = path.replace(/\{[^}]+\}/g, (m) => {
+                let mark = `@\\${i}`;
+
+                groups[i++] = [mark, m];
+                replaced = true;
+
+                return mark;
+            });
+
+            if (!replaced) {
+                break;
+            }
+        }
+
+        /**
+         *  - pattern (:label, :label{0-9]+}, ...)
+         *  - /* wildcard
+         *  - character
+         */
+        let tokens = path.match(/(?::[^\/]+)|(?:\/\*$)|./g) || [];
+
+        for (let i = groups.length - 1; i >= 0; i--) {
+            let [ mark, replacement ] = groups[i],
+                token;
+
+            for (let j = tokens.length - 1; j >= 0; j--) {
+                token = tokens[j];
+
+                if (token.indexOf(mark) !== -1) {
+                    token = token.replace(mark, replacement);
+                    break
+                }
+            }
+        }
+
+        this.root.insert(tokens, index, parameters, this.context, pathErrorCheckOnly);
+
+        return parameters;
+    }
+}
+
+
+export { Trie };

package/src/router2/types.ts

@@ -0,0 +1,59 @@
+type HandlerMap<T> = [T, number];
+
+type HandlerMetadata<T> = [T, ParameterMap][];
+
+type Indexes = number[];
+
+type Matcher<T> = [RegExp, HandlerMetadata<T>[], StaticMap<T>];
+
+type Method = string;
+
+type ParameterMap = Record<string, number>;
+
+type ParameterMetadata = [string, number][];
+
+type Path = string;
+
+/**
+ * The result can be in one of two formats:
+ * 1. An array of handlers with their corresponding parameter index maps, followed by a parameter stash.
+ * 2. An array of handlers with their corresponding parameter maps.
+ *
+ * Example:
+ *
+ * [[handler, paramIndexMap][], paramArray]
+ * ```typescript
+ * [
+ *   [
+ *     [middlewareA, {}],                     // '*'
+ *     [funcA,       {'id': 0}],              // '/user/:id/*'
+ *     [funcB,       {'id': 0, 'action': 1}], // '/user/:id/:action'
+ *   ],
+ *   ['123', 'abc']
+ * ]
+ * ```
+ *
+ * [[handler, params][]]
+ * ```typescript
+ * [
+ *   [
+ *     [middlewareA, {}],                             // '*'
+ *     [funcA,       {'id': '123'}],                  // '/user/:id/*'
+ *     [funcB,       {'id': '123', 'action': 'abc'}], // '/user/:id/:action'
+ *   ]
+ * ]
+ * ```
+ */
+type Result<T> = [ [T, ParameterMap][], string[] ] | [ [T, Record<string, string>][] ];
+
+type StaticMap<T> = Record<Path, Result<T>>;
+
+
+export {
+    HandlerMap, HandlerMetadata,
+    Indexes,
+    Matcher, Method,
+    ParameterMap, ParameterMetadata, Path,
+    Result,
+    StaticMap
+};