hono 1.1.1 → 1.2.2

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

@@ -2,113 +2,333 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RegExpRouter = void 0;
 const router_1 = require("../../router");
-const trie_1 = require("../../router/reg-exp-router/trie");
-const regExpMatchAll = new RegExp('');
+const trie_1 = require("./trie");
 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 buildMatcherFromPreprocessedRoutes(routes, hasAmbiguous = false) {
+    const trie = new trie_1.Trie({ reverse: hasAmbiguous });
+    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,
+        ];
+    }
+    const [regexp, indexReplacementMap, paramReplacementMap] = trie.buildRegExp();
+    for (let i = 0, len = handlers.length; i < len; i++) {
+        const paramMap = handlers[i][1];
+        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]]);
+                    }
+                }
+            }
+        }
+    }
+    const handlerMap = [];
+    // using `in` because indexReplacementMap is a sparse array
+    for (const i in indexReplacementMap) {
+        handlerMap[i] = handlers[indexReplacementMap[i]];
+    }
+    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;
+                }
+            }
+        }
+    }
+    return true;
+}
 class RegExpRouter extends router_1.Router {
     constructor() {
         super(...arguments);
-        this.routes = {};
+        this.routeData = { routes: [], methods: new Set() };
     }
     add(method, path, handler) {
-        var _a;
-        if (!this.routes) {
+        if (!this.routeData) {
             throw new Error('Can not add a route since the matcher is already built.');
         }
-        (_a = this.routes)[method] || (_a[method] = []);
-        this.routes[method].push([path, handler]);
+        const { routes, methods } = this.routeData;
+        if (path === '/*') {
+            path = '*';
+        }
+        for (let i = 0, len = routes.length; i < len; i++) {
+            if (routes[i].method === method && routes[i].path === path) {
+                routes[i].handlers.push(handler);
+                return;
+            }
+        }
+        methods.add(method);
+        routes.push({
+            method,
+            path,
+            handlers: [handler],
+            hint: initHint(path),
+            middleware: [],
+            paramAliasMap: {},
+        });
     }
     match(method, path) {
-        const matchers = this.buildAllMatchers();
-        let match;
-        // Optimization for middleware
-        const methods = Object.keys(matchers);
-        if (methods.length === 1 && methods[0] === router_1.METHOD_NAME_OF_ALL) {
-            const [regexp, handlers] = matchers[router_1.METHOD_NAME_OF_ALL];
-            if (handlers.length === 1) {
-                const result = new router_1.Result(handlers[0][0], emptyParam);
-                if (regexp === regExpMatchAll) {
-                    match = () => result;
+        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;
                 }
-                else if (handlers.length === 1 && !handlers[0][1]) {
-                    match = (_, path) => (regexp.test(path) ? result : 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 new router_1.Result([...handlers.values()], params);
             }
-        }
-        match || (match = (method, path) => {
-            const matcher = matchers[method] || matchers[router_1.METHOD_NAME_OF_ALL];
-            if (!matcher) {
-                return null;
-            }
-            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 [handler, paramMap] = matcher[1][index];
+                if (!paramMap) {
+                    return new router_1.Result(handler, emptyParam);
+                }
+                const params = {};
+                for (let i = 0, len = paramMap.length; i < len; i++) {
+                    params[paramMap[i][0]] = match[paramMap[i][1]];
+                }
+                return new router_1.Result(handler, params);
+            };
+        return this.match(method, path);
+    }
+    buildAllMatchers() {
+        this.routeData.routes.sort(({ hint: a }, { hint: b }) => {
+            if (a.componentsLength !== b.componentsLength) {
+                return a.componentsLength - b.componentsLength;
             }
-            const index = match.indexOf('', 1);
-            const [handler, paramMap] = matcher[1][index];
-            if (!paramMap) {
-                return new router_1.Result(handler, emptyParam);
+            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];
+                    }
+                }
             }
-            const params = {};
-            for (let i = 0; i < paramMap.length; i++) {
-                params[paramMap[i][0]] = match[paramMap[i][1]];
+            if (a.endWithWildcard !== b.endWithWildcard) {
+                return a.endWithWildcard ? -1 : 1;
             }
-            return new router_1.Result(handler, params);
+            return 0;
         });
-        this.match = match;
-        return this.match(method, path);
-    }
-    buildAllMatchers() {
-        const matchers = {};
-        Object.keys(this.routes).forEach((method) => {
-            matchers[method] = this.buildMatcher(method);
+        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;
         });
-        delete this.routes; // to reduce memory usage
-        return matchers;
+        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];
     }
     buildMatcher(method) {
-        const trie = new trie_1.Trie();
-        const handlers = [];
-        const targetMethods = [method];
-        if (method !== router_1.METHOD_NAME_OF_ALL) {
-            targetMethods.unshift(router_1.METHOD_NAME_OF_ALL);
-        }
-        const routes = targetMethods.flatMap((method) => this.routes[method] || []);
-        if (routes.length === 0) {
-            return null;
-        }
-        if (method === router_1.METHOD_NAME_OF_ALL) {
-            if (routes.length === 1 && routes[0][0] === '*') {
-                return [regExpMatchAll, [[routes[0][1], null]]];
+        var _a, _b;
+        let hasAmbiguous = false;
+        const targetMethods = new Set([method, router_1.METHOD_NAME_ALL]);
+        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('');
+                        }
+                    }
+                    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');
+                    }
+                }
             }
-            if (routes.length === 1 && !routes[0][0].match(/:/)) {
-                // there is only one route and no capture
-                const tmp = routes[0][0].endsWith('*')
-                    ? routes[0][0].replace(/\/\*$/, '(?:$|/)') // /path/to/* => /path/to(?:$|/)
-                    : `${routes[0][0]}$`; // /path/to/action => /path/to/action$
-                const regExpStr = `^${tmp.replace(/\*/g, '[^/]+')}`; // /prefix/*/path/to => /prefix/[^/]+/path/to
-                return [new RegExp(regExpStr), [[routes[0][1], null]]];
+            if (!verifyDuplicateParam([routes[i]])) {
+                throw new Error('Duplicate param name');
             }
         }
-        for (let i = 0; i < routes.length; i++) {
-            const paramMap = trie.insert(routes[i][0], i);
-            handlers[i] = [routes[i][1], Object.keys(paramMap).length !== 0 ? paramMap : null];
+        if (hasAmbiguous) {
+            return [buildMatcherFromPreprocessedRoutes(routes, hasAmbiguous), [], hasAmbiguous];
         }
-        const [regexp, indexReplacementMap, paramReplacementMap] = trie.buildRegExp();
-        for (let i = 0; i < handlers.length; i++) {
-            const paramMap = handlers[i][1];
-            if (paramMap) {
-                for (let i = 0; i < paramMap.length; i++) {
-                    paramMap[i][1] = paramReplacementMap[paramMap[i][1]];
-                }
+        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]);
             }
         }
-        const handlerMap = [];
-        // using `in` because indexReplacementMap is a sparse array
-        for (const i in indexReplacementMap) {
-            handlerMap[i] = handlers[indexReplacementMap[i]];
-        }
-        return [regexp, handlerMap];
+        return [
+            buildMatcherFromPreprocessedRoutes(primaryRoutes, hasAmbiguous),
+            [buildMatcherFromPreprocessedRoutes(secondaryRoutes, hasAmbiguous)],
+            hasAmbiguous,
+        ];
     }
 }
 exports.RegExpRouter = RegExpRouter;

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

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

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

@@ -0,0 +1,212 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const router_1 = require("../../router");
+const router_2 = require("./router");
+describe('Basic Usage', () => {
+    const router = new router_2.RegExpRouter();
+    router.add('GET', '/hello', 'get hello');
+    router.add('POST', '/hello', 'post hello');
+    it('get, post hello', async () => {
+        let res = router.match('GET', '/hello');
+        expect(res).not.toBeNull();
+        expect(res.handlers).toEqual(['get hello']);
+        res = router.match('POST', '/hello');
+        expect(res).not.toBeNull();
+        expect(res.handlers).toEqual(['post hello']);
+        res = router.match('PUT', '/hello');
+        expect(res).toBeNull();
+        res = router.match('GET', '/');
+        expect(res).toBeNull();
+    });
+});
+describe('Complex', () => {
+    let router;
+    beforeEach(() => {
+        router = new router_2.RegExpRouter();
+    });
+    it('Named Param', async () => {
+        router.add('GET', '/entry/:id', 'get entry');
+        const res = router.match('GET', '/entry/123');
+        expect(res).not.toBeNull();
+        expect(res.handlers).toEqual(['get entry']);
+        expect(res.params['id']).toBe('123');
+    });
+    it('Wildcard', async () => {
+        router.add('GET', '/wild/*/card', 'get wildcard');
+        const res = router.match('GET', '/wild/xxx/card');
+        expect(res).not.toBeNull();
+        expect(res.handlers).toEqual(['get wildcard']);
+    });
+    it('Default', async () => {
+        router.add('GET', '/api/abc', 'get api');
+        router.add('GET', '/api/*', 'fallback');
+        let res = router.match('GET', '/api/abc');
+        expect(res).not.toBeNull();
+        expect(res.handlers).toEqual(['fallback', 'get api']);
+        res = router.match('GET', '/api/def');
+        expect(res).not.toBeNull();
+        expect(res.handlers).toEqual(['fallback']);
+    });
+    it('Regexp', async () => {
+        router.add('GET', '/post/:date{[0-9]+}/:title{[a-z]+}', 'get post');
+        let res = router.match('GET', '/post/20210101/hello');
+        expect(res).not.toBeNull();
+        expect(res.handlers).toEqual(['get post']);
+        expect(res.params['date']).toBe('20210101');
+        expect(res.params['title']).toBe('hello');
+        res = router.match('GET', '/post/onetwothree');
+        expect(res).toBeNull();
+        res = router.match('GET', '/post/123/123');
+        expect(res).toBeNull();
+    });
+});
+describe('Order independent', () => {
+    let router;
+    beforeEach(() => {
+        router = new router_2.RegExpRouter();
+    });
+    it('abstract -> concrete', async () => {
+        router.add('GET', '/:type/:action', 'foo');
+        router.add('GET', '/posts/:id', 'bar');
+        const res = router.match('GET', '/posts/123');
+        expect(res).not.toBeNull();
+        expect(res.handlers).toEqual(['foo', 'bar']);
+    });
+    it('concrete -> abstract', async () => {
+        router.add('GET', '/posts/:id', 'bar');
+        router.add('GET', '/:type/:action', 'foo');
+        const res = router.match('GET', '/posts/123');
+        expect(res).not.toBeNull();
+        expect(res.handlers).toEqual(['foo', 'bar']);
+    });
+});
+describe('Optimization for METHOD_NAME_OF_ALL', () => {
+    let router;
+    beforeEach(() => {
+        router = new router_2.RegExpRouter();
+    });
+    it('Apply to all requests', async () => {
+        router.add(router_1.METHOD_NAME_ALL, '*', 'OK');
+        const res = router.match('GET', '/entry/123');
+        expect(res).not.toBeNull();
+        expect(res.handlers).toEqual(['OK']);
+        expect(res.params).toMatchObject({});
+    });
+    it('Apply to all requests under a specific path', async () => {
+        router.add(router_1.METHOD_NAME_ALL, '/path/to/*', 'OK');
+        let res = router.match('GET', '/entry/123');
+        expect(res).toBeNull();
+        res = router.match('GET', '/path/to/entry/123');
+        expect(res).not.toBeNull();
+        expect(res.handlers).toEqual(['OK']);
+        expect(res.params).toMatchObject({});
+    });
+});
+describe('Multi match', () => {
+    describe('Blog', () => {
+        const router = new router_2.RegExpRouter();
+        router.add('ALL', '*', 'middleware a');
+        router.add('GET', '*', 'middleware b');
+        router.add('GET', '/entry', 'get entries');
+        router.add('POST', '/entry/*', 'middleware c');
+        router.add('POST', '/entry', 'post entry');
+        router.add('GET', '/entry/:id', 'get entry');
+        router.add('GET', '/entry/:id/comment/:comment_id', 'get comment');
+        it('GET /', async () => {
+            const res = router.match('GET', '/');
+            expect(res).not.toBeNull();
+            expect(res.handlers).toEqual(['middleware a', 'middleware b']);
+        });
+        it('GET /entry/123', async () => {
+            const res = router.match('GET', '/entry/123');
+            expect(res).not.toBeNull();
+            expect(res.handlers).toEqual(['middleware a', 'middleware b', 'get entry']);
+            expect(res.params['id']).toBe('123');
+        });
+        it('GET /entry/123/comment/456', async () => {
+            const res = router.match('GET', '/entry/123/comment/456');
+            expect(res).not.toBeNull();
+            expect(res.handlers).toEqual(['middleware a', 'middleware b', 'get comment']);
+            expect(res.params['id']).toBe('123');
+            expect(res.params['comment_id']).toBe('456');
+        });
+        it('POST /entry', async () => {
+            const res = router.match('POST', '/entry');
+            expect(res).not.toBeNull();
+            expect(res.handlers).toEqual(['middleware a', 'middleware c', 'post entry']);
+        });
+        it('DELETE /entry', async () => {
+            const res = router.match('DELETE', '/entry');
+            expect(res).not.toBeNull();
+            expect(res.handlers).toEqual(['middleware a']);
+        });
+    });
+    describe('Ambiguous', () => {
+        const router = new router_2.RegExpRouter();
+        router.add('GET', '/:user/entries', 'get user entries');
+        router.add('GET', '/entry/:name', 'get entry');
+        it('GET /entry/entry', async () => {
+            const res = router.match('GET', '/entry/entries');
+            expect(res).not.toBeNull();
+            expect(res.handlers).toEqual(['get user entries', 'get entry']);
+            expect(res.params['user']).toBe('entry');
+            expect(res.params['name']).toBe('entries');
+        });
+    });
+    describe('Multiple handlers', () => {
+        const router = new router_2.RegExpRouter();
+        router.add('GET', '/:type/:id', ':type');
+        router.add('GET', '/:class/:id', ':class');
+        router.add('GET', '/:model/:id', ':model');
+        router.add('GET', '/entry/:id', 'entry');
+        it('GET /entry/123', async () => {
+            const res = router.match('GET', '/entry/123');
+            expect(res).not.toBeNull();
+            expect(res.handlers).toEqual([':type', ':class', ':model', 'entry']);
+            expect(res.params['type']).toBe('entry');
+            expect(res.params['class']).toBe('entry');
+            expect(res.params['model']).toBe('entry');
+        });
+    });
+});
+describe('Check for duplicate parameter names', () => {
+    it('self', () => {
+        const router = new router_2.RegExpRouter();
+        router.add('GET', '/:id/:id', 'get');
+        expect(() => {
+            router.match('GET', '/'); // check parameter names on the first `match` call
+        }).toThrowError(/Duplicate param name/);
+    });
+    it('parent', () => {
+        const router = new router_2.RegExpRouter();
+        router.add('GET', '/:id/:action', 'foo');
+        router.add('GET', '/posts/:id', 'bar');
+        expect(() => {
+            router.match('GET', '/');
+        }).toThrowError(/Duplicate param name/);
+    });
+    it('child', () => {
+        const router = new router_2.RegExpRouter();
+        router.add('GET', '/posts/:id', 'foo');
+        router.add('GET', '/:id/:action', 'bar');
+        expect(() => {
+            router.match('GET', '/');
+        }).toThrowError(/Duplicate param name/);
+    });
+    it('hierarchy', () => {
+        const router = new router_2.RegExpRouter();
+        router.add('GET', '/posts/:id/comments/:comment_id', 'foo');
+        router.add('GET', '/posts/:id', 'bar');
+        expect(() => {
+            router.match('GET', '/');
+        }).not.toThrow();
+    });
+    it('different regular expression', () => {
+        const router = new router_2.RegExpRouter();
+        router.add('GET', '/:id/:action{create|update}', 'foo');
+        router.add('GET', '/:id/:action{delete}', 'bar');
+        expect(() => {
+            router.match('GET', '/');
+        }).not.toThrow();
+    });
+});

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

@@ -1,10 +1,14 @@
-import type { ParamMap, Context } from '../../router/reg-exp-router/node';
-import { Node } from '../../router/reg-exp-router/node';
-export type { ParamMap } from '../../router/reg-exp-router/node';
+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,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Trie = void 0;
-const node_1 = require("../../router/reg-exp-router/node");
+const node_1 = require("./node");
 class Trie {
-    constructor() {
+    constructor({ reverse } = { reverse: false }) {
         this.context = { varIndex: 0 };
-        this.root = new node_1.Node();
+        this.root = new node_1.Node({ reverse });
     }
     insert(path, index) {
         const paramMap = [];