hono 1.0.0 → 1.2.0

package/dist/context.js

@@ -5,10 +5,14 @@ const http_status_1 = require("./utils/http-status");
 const url_1 = require("./utils/url");
 class Context {
     constructor(req, opts) {
+        this.res = undefined;
+        this._headers = {};
+        this._status = 200;
+        this._statusText = '';
+        this._pretty = false;
         this._prettySpace = 2;
         this.req = this.initRequest(req);
         Object.assign(this, opts);
-        this._headers = {};
     }
     initRequest(req) {
         req.header = (name) => {
@@ -27,10 +31,6 @@ class Context {
         this._headers[name] = value;
     }
     status(status) {
-        if (this.res) {
-            console.warn('c.res.status is already set.');
-            return;
-        }
         this._status = status;
         this._statusText = (0, http_status_1.getStatusText)(status);
     }
@@ -43,18 +43,6 @@ class Context {
         init.statusText =
             init.statusText || this._statusText || (0, http_status_1.getStatusText)(init.status);
         init.headers = Object.assign(Object.assign({}, this._headers), init.headers);
-        // Content-Length
-        let length = 0;
-        if (data) {
-            if (data instanceof ArrayBuffer) {
-                length = data.byteLength;
-            }
-            else if (typeof data == 'string') {
-                const Encoder = new TextEncoder();
-                length = Encoder.encode(data).byteLength || 0;
-            }
-        }
-        init.headers = Object.assign(Object.assign({}, init.headers), { 'Content-Length': length.toString() });
         return new Response(data, init);
     }
     body(data, status = this._status, headers = this._headers) {

package/dist/hono.d.ts

@@ -2,54 +2,80 @@
 import { Context } from './context';
 import type { Env } from './context';
 import type { Router } from './router';
+import { METHOD_NAME_ALL_LOWERCASE } from './router';
 declare global {
     interface Request<ParamKeyType = string> {
         param: (key: ParamKeyType) => string;
         query: (key: string) => string;
         header: (name: string) => string;
-        parsedBody: any;
     }
 }
-export declare type Handler<RequestParamKeyType = string> = (c: Context<RequestParamKeyType | string>, next?: Next) => Response | Promise<Response>;
-export declare type MiddlewareHandler = (c: Context, next: Next) => Promise<void>;
-export declare type NotFoundHandler = (c: Context) => Response | Promise<Response>;
-export declare type ErrorHandler = (err: Error, c: Context) => Response;
+export declare type Handler<RequestParamKeyType = string, E = Env> = (c: Context<RequestParamKeyType, E>, next?: Next) => Response | Promise<Response> | void | Promise<void>;
+export declare type NotFoundHandler<E = Env> = (c: Context<string, E>) => Response;
+export declare type ErrorHandler<E = Env> = (err: Error, c: Context<string, E>) => Response;
 export declare type Next = () => Promise<void>;
 declare type ParamKeyName<NameWithPattern> = NameWithPattern extends `${infer Name}{${infer _Pattern}` ? Name : NameWithPattern;
 declare type ParamKey<Component> = Component extends `:${infer NameWithPattern}` ? ParamKeyName<NameWithPattern> : never;
 declare type ParamKeys<Path> = Path extends `${infer Component}/${infer Rest}` ? ParamKey<Component> | ParamKeys<Rest> : ParamKey<Path>;
-declare const Hono_base: new () => {
-    delete: <Path extends string>(path: Path, handler: Handler<ParamKeys<Path>>) => Hono;
-    get: <Path extends string>(path: Path, handler: Handler<ParamKeys<Path>>) => Hono;
-    post: <Path extends string>(path: Path, handler: Handler<ParamKeys<Path>>) => Hono;
-    put: <Path extends string>(path: Path, handler: Handler<ParamKeys<Path>>) => Hono;
-    head: <Path extends string>(path: Path, handler: Handler<ParamKeys<Path>>) => Hono;
-    options: <Path extends string>(path: Path, handler: Handler<ParamKeys<Path>>) => Hono;
-    patch: <Path extends string>(path: Path, handler: Handler<ParamKeys<Path>>) => Hono;
-    all: <Path extends string>(path: Path, handler: Handler<ParamKeys<Path>>) => Hono;
-} & {
-    methods: ["get", "post", "put", "delete", "head", "options", "patch", "all"];
+interface HandlerInterface<T extends string, E = Env, U = Hono<E, T>> {
+    <Path extends string>(path: Path, ...handlers: Handler<ParamKeys<Path> extends never ? string : ParamKeys<Path>, E>[]): U;
+    (path: string, ...handlers: Handler<string, E>[]): U;
+    <Path extends string>(...handlers: Handler<ParamKeys<Path> extends never ? string : ParamKeys<Path>, E>[]): U;
+    (...handlers: Handler<string, E>[]): U;
+}
+declare const methods: readonly ["get", "post", "put", "delete", "head", "options", "patch"];
+declare type Methods = typeof methods[number] | typeof METHOD_NAME_ALL_LOWERCASE;
+interface Routing<E extends Env> {
+    path: string;
+    method: Methods;
+    handler: Handler<string, E>;
+}
+declare const Route_base: new <E_1 extends Env, T extends string, U>() => {
+    delete: HandlerInterface<T, E_1, U>;
+    get: HandlerInterface<T, E_1, U>;
+    all: HandlerInterface<T, E_1, U>;
+    post: HandlerInterface<T, E_1, U>;
+    put: HandlerInterface<T, E_1, U>;
+    head: HandlerInterface<T, E_1, U>;
+    options: HandlerInterface<T, E_1, U>;
+    patch: HandlerInterface<T, E_1, U>;
+};
+export declare class Route<E = Env, P extends string = ''> extends Route_base<E, P, Route<E, P>> {
+    #private;
+    routes: Routing<E>[];
+    constructor();
+    private add;
+}
+declare const Hono_base: new <E_1 extends Env, T extends string, U>() => {
+    delete: HandlerInterface<T, E_1, U>;
+    get: HandlerInterface<T, E_1, U>;
+    all: HandlerInterface<T, E_1, U>;
+    post: HandlerInterface<T, E_1, U>;
+    put: HandlerInterface<T, E_1, U>;
+    head: HandlerInterface<T, E_1, U>;
+    options: HandlerInterface<T, E_1, U>;
+    patch: HandlerInterface<T, E_1, U>;
 };
-export declare class Hono extends Hono_base {
+export declare class Hono<E = Env, P extends string = ''> extends Hono_base<E, P, Hono<E, P>> {
+    #private;
     readonly routerClass: {
         new (): Router<any>;
     };
     readonly strict: boolean;
-    private router;
-    private middlewareRouters;
-    private tempPath;
+    private path;
     constructor(init?: Partial<Pick<Hono, 'routerClass' | 'strict'>>);
     private notFoundHandler;
     private errorHandler;
-    route(path: string): Hono;
-    use(path: string, middleware: MiddlewareHandler): void;
-    onError(handler: ErrorHandler): Hono;
-    notFound(handler: NotFoundHandler): Hono;
+    route(path: string, route?: Route): Hono<E, P>;
+    use(path: string, ...middleware: Handler<string, E>[]): Hono<E, P>;
+    use(...middleware: Handler<string, E>[]): Hono<E, P>;
+    onError(handler: ErrorHandler<E>): Hono<E, P>;
+    notFound(handler: NotFoundHandler<E>): Hono<E, P>;
     private addRoute;
     private matchRoute;
     private dispatch;
     handleEvent(event: FetchEvent): Promise<Response>;
-    fetch(request: Request, env?: Env, event?: FetchEvent): Promise<Response>;
+    fetch(request: Request, env?: E, event?: FetchEvent): Promise<Response>;
     request(input: RequestInfo, requestInit?: RequestInit): Promise<Response>;
     fire(): void;
 }

package/dist/hono.js

@@ -1,23 +1,67 @@
 "use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Route_path, _Hono_router, _Hono_tempPath;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Hono = void 0;
+exports.Hono = exports.Route = void 0;
 const compose_1 = require("./compose");
 const context_1 = require("./context");
 const router_1 = require("./router");
+const router_2 = require("./router");
 const trie_router_1 = require("./router/trie-router"); // Default Router
 const url_1 = require("./utils/url");
-function defineDynamicClass(...methods) {
+const methods = ['get', 'post', 'put', 'delete', 'head', 'options', 'patch'];
+function defineDynamicClass() {
     return class {
-        get methods() {
-            return methods;
-        }
     };
 }
-class Hono extends defineDynamicClass('get', 'post', 'put', 'delete', 'head', 'options', 'patch', 'all') {
+class Route extends defineDynamicClass() {
+    constructor() {
+        super();
+        this.routes = [];
+        _Route_path.set(this, '');
+        const allMethods = [...methods, router_2.METHOD_NAME_ALL_LOWERCASE];
+        allMethods.map((method) => {
+            this[method] = (args1, ...args) => {
+                if (typeof args1 === 'string') {
+                    __classPrivateFieldSet(this, _Route_path, args1, "f");
+                }
+                else {
+                    this.add(method, __classPrivateFieldGet(this, _Route_path, "f"), args1);
+                }
+                args.map((handler) => {
+                    if (typeof handler !== 'string') {
+                        this.add(method, __classPrivateFieldGet(this, _Route_path, "f"), handler);
+                    }
+                });
+                return this;
+            };
+        });
+    }
+    add(method, path, handler) {
+        const r = { path: path, method: method, handler: handler };
+        this.routes.push(r);
+        return this;
+    }
+}
+exports.Route = Route;
+_Route_path = new WeakMap();
+class Hono extends defineDynamicClass() {
     constructor(init = {}) {
         super();
         this.routerClass = trie_router_1.TrieRouter;
         this.strict = true; // strict routing - default is true
+        _Hono_router.set(this, void 0);
+        _Hono_tempPath.set(this, void 0);
         this.notFoundHandler = (c) => {
             const message = '404 Not Found';
             return c.text(message, 404);
@@ -27,29 +71,49 @@ class Hono extends defineDynamicClass('get', 'post', 'put', 'delete', 'head', 'o
             const message = 'Internal Server Error';
             return c.text(message, 500);
         };
-        this.methods.map((method) => {
-            this[method] = (path, handler) => {
-                return this.addRoute(method, path, handler);
+        const allMethods = [...methods, router_2.METHOD_NAME_ALL_LOWERCASE];
+        allMethods.map((method) => {
+            this[method] = (args1, ...args) => {
+                if (typeof args1 === 'string') {
+                    this.path = args1;
+                }
+                else {
+                    this.addRoute(method, this.path, args1);
+                }
+                args.map((handler) => {
+                    if (typeof handler !== 'string') {
+                        this.addRoute(method, this.path, handler);
+                    }
+                });
+                return this;
             };
         });
         Object.assign(this, init);
-        this.router = new this.routerClass();
-        this.middlewareRouters = [];
-        this.tempPath = null;
+        __classPrivateFieldSet(this, _Hono_router, new this.routerClass(), "f");
+        __classPrivateFieldSet(this, _Hono_tempPath, null, "f");
     }
-    route(path) {
+    route(path, route) {
         const newHono = new Hono();
-        newHono.tempPath = path;
-        newHono.router = this.router;
+        __classPrivateFieldSet(newHono, _Hono_tempPath, path, "f");
+        __classPrivateFieldSet(newHono, _Hono_router, __classPrivateFieldGet(this, _Hono_router, "f"), "f");
+        if (route) {
+            route.routes.map((r) => {
+                newHono.addRoute(r.method, r.path, r.handler);
+            });
+        }
         return newHono;
     }
-    use(path, middleware) {
-        if (middleware.constructor.name !== 'AsyncFunction') {
-            throw new TypeError('middleware must be a async function!');
+    use(arg1, ...handlers) {
+        if (typeof arg1 === 'string') {
+            this.path = arg1;
         }
-        const router = new this.routerClass();
-        router.add(router_1.METHOD_NAME_OF_ALL, path, middleware);
-        this.middlewareRouters.push(router);
+        else {
+            handlers.unshift(arg1);
+        }
+        handlers.map((handler) => {
+            this.addRoute(router_1.METHOD_NAME_ALL, this.path, handler);
+        });
+        return this;
     }
     onError(handler) {
         this.errorHandler = handler;
@@ -59,54 +123,46 @@ class Hono extends defineDynamicClass('get', 'post', 'put', 'delete', 'head', 'o
         this.notFoundHandler = handler;
         return this;
     }
-    // addRoute('get', '/', handler)
     addRoute(method, path, handler) {
         method = method.toUpperCase();
-        if (this.tempPath) {
-            path = (0, url_1.mergePath)(this.tempPath, path);
+        if (__classPrivateFieldGet(this, _Hono_tempPath, "f")) {
+            path = (0, url_1.mergePath)(__classPrivateFieldGet(this, _Hono_tempPath, "f"), path);
         }
-        this.router.add(method, path, handler);
-        return this;
+        __classPrivateFieldGet(this, _Hono_router, "f").add(method, path, handler);
     }
     async matchRoute(method, path) {
-        return this.router.match(method, path);
+        return __classPrivateFieldGet(this, _Hono_router, "f").match(method, path);
     }
-    async dispatch(request, env, event) {
+    async dispatch(request, event, env) {
         const path = (0, url_1.getPathFromURL)(request.url, { strict: this.strict });
         const method = request.method;
         const result = await this.matchRoute(method, path);
-        // Methods for Request object
         request.param = (key) => {
             if (result)
                 return result.params[key];
         };
-        const handler = result ? result.handler : this.notFoundHandler;
-        const middleware = [];
-        for (const mr of this.middlewareRouters) {
-            const mwResult = mr.match(router_1.METHOD_NAME_OF_ALL, path);
-            if (mwResult)
-                middleware.push(mwResult.handler);
+        const handlers = result ? result.handlers : [this.notFoundHandler];
+        const c = new context_1.Context(request, { env: env, event: event, res: undefined });
+        c.notFound = () => this.notFoundHandler(c);
+        const composed = (0, compose_1.compose)(handlers, this.errorHandler, this.notFoundHandler);
+        let context;
+        try {
+            context = await composed(c);
         }
-        const wrappedHandler = async (context, next) => {
-            const res = await handler(context);
-            if (!(res instanceof Response)) {
-                throw new TypeError('response must be a instance of Response');
+        catch (err) {
+            if (err instanceof Error) {
+                return this.errorHandler(err, c);
             }
-            context.res = res;
-            await next();
-        };
-        middleware.push(wrappedHandler);
-        const composed = (0, compose_1.compose)(middleware, this.errorHandler);
-        const c = new context_1.Context(request, { env: env, event: event, res: null });
-        c.notFound = () => this.notFoundHandler(c);
-        const context = await composed(c);
+        }
+        if (!context.res)
+            return context.notFound();
         return context.res;
     }
     async handleEvent(event) {
-        return this.dispatch(event.request, {}, event);
+        return this.dispatch(event.request, event);
     }
     async fetch(request, env, event) {
-        return this.dispatch(request, env, event);
+        return this.dispatch(request, event, env);
     }
     request(input, requestInit) {
         const req = input instanceof Request ? input : new Request(input, requestInit);
@@ -119,3 +175,4 @@ class Hono extends defineDynamicClass('get', 'post', 'put', 'delete', 'head', 'o
     }
 }
 exports.Hono = Hono;
+_Hono_router = new WeakMap(), _Hono_tempPath = new WeakMap();

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { Hono } from './hono';
-export type { Handler, MiddlewareHandler, Next } from './hono';
+export { Hono, Route } from './hono';
+export type { Handler, Next } from './hono';
 export { Context } from './context';
 export type { Env } from './context';

package/dist/index.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Context = exports.Hono = void 0;
+exports.Context = exports.Route = exports.Hono = void 0;
 var hono_1 = require("./hono");
 Object.defineProperty(exports, "Hono", { enumerable: true, get: function () { return hono_1.Hono; } });
+Object.defineProperty(exports, "Route", { enumerable: true, get: function () { return hono_1.Route; } });
 var context_1 = require("./context");
 Object.defineProperty(exports, "Context", { enumerable: true, get: function () { return context_1.Context; } });

package/dist/middleware/basic-auth/index.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.basicAuth = void 0;
 const buffer_1 = require("../../utils/buffer");
-const crypto_1 = require("../../utils/crypto");
+const encode_1 = require("../../utils/encode");
 const CREDENTIALS_REGEXP = /^ *(?:[Bb][Aa][Ss][Ii][Cc]) +([A-Za-z0-9._~+/-]+=*) *$/;
 const USER_PASS_REGEXP = /^([^:]*):(.*)$/;
 const auth = (req) => {
@@ -19,7 +19,7 @@ const auth = (req) => {
     if (!match) {
         return undefined;
     }
-    const userPass = USER_PASS_REGEXP.exec((0, crypto_1.decodeBase64)(match[1]));
+    const userPass = USER_PASS_REGEXP.exec((0, encode_1.decodeBase64)(match[1]));
     if (!userPass) {
         return undefined;
     }
@@ -41,17 +41,18 @@ const basicAuth = (options, ...users) => {
                 const passwordEqual = await (0, buffer_1.timingSafeEqual)(user.password, requestUser.password, options.hashFunction);
                 if (usernameEqual && passwordEqual) {
                     // Authorized OK
-                    return next();
+                    await next();
                 }
             }
         }
-        ctx.res = new Response('Unauthorized', {
-            status: 401,
-            headers: {
-                'WWW-Authenticate': 'Basic realm="' + options.realm.replace(/"/g, '\\"') + '"',
-            },
-        });
-        return;
+        else {
+            ctx.res = new Response('Unauthorized', {
+                status: 401,
+                headers: {
+                    'WWW-Authenticate': 'Basic realm="' + options.realm.replace(/"/g, '\\"') + '"',
+                },
+            });
+        }
     };
 };
 exports.basicAuth = basicAuth;

package/dist/middleware/body-parse/index.d.ts

@@ -1,3 +1,8 @@
 import type { Context } from '../../context';
 import type { Next } from '../../hono';
+declare global {
+    interface Request {
+        parsedBody: any;
+    }
+}
 export declare const bodyParse: () => (ctx: Context, next: Next) => Promise<void>;

package/dist/middleware/cookie/index.d.ts

@@ -10,9 +10,7 @@ declare module '@/context' {
         cookie: (name: string, value: string, options?: CookieOptions) => void;
     }
 }
-export declare type Cookie = {
-    [key: string]: string;
-};
+export declare type Cookie = Record<string, string>;
 export declare type CookieOptions = {
     domain?: string;
     expires?: Date;

package/dist/middleware/graphql-server/parse-body.d.ts

@@ -1,3 +1 @@
-export declare function parseBody(req: Request): Promise<{
-    [param: string]: unknown;
-}>;
+export declare function parseBody(req: Request): Promise<Record<string, unknown>>;

package/dist/middleware/jwt/index.d.ts

@@ -0,0 +1,6 @@
+import type { Context } from '../../context';
+import type { Next } from '../../hono';
+export declare const jwt: (options: {
+    secret: string;
+    alg?: string;
+}) => (ctx: Context, next: Next) => Promise<void>;

package/dist/middleware/jwt/index.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jwt = void 0;
+const jwt_1 = require("../../utils/jwt");
+const jwt = (options) => {
+    if (!options) {
+        throw new Error('JWT auth middleware requires options for "secret');
+    }
+    return async (ctx, next) => {
+        const credentials = ctx.req.headers.get('Authorization');
+        await next();
+        if (!credentials) {
+            ctx.res = new Response('Unauthorized', {
+                status: 401,
+                headers: {
+                    'WWW-Authenticate': 'Basic ${options.secret}',
+                },
+            });
+            return;
+        }
+        const parts = credentials.split(/\s+/);
+        if (parts.length !== 2) {
+            ctx.res = new Response('Unauthorized', {
+                status: 401,
+                headers: {
+                    'WWW-Authenticate': 'Basic ${options.secret}',
+                },
+            });
+        }
+        let authorized = false;
+        let msg = '';
+        try {
+            authorized = await jwt_1.Jwt.verify(parts[1], options.secret, options.alg);
+        }
+        catch (e) {
+            msg = `${e}`;
+        }
+        if (!authorized) {
+            ctx.res = new Response('Unauthorized', {
+                status: 401,
+                statusText: msg,
+                headers: {
+                    'WWW-Authenticate': 'Bearer ${options.secret}',
+                },
+            });
+        }
+    };
+};
+exports.jwt = jwt;

package/dist/middleware/logger/index.js

@@ -31,10 +31,10 @@ const colorStatus = (status = 0) => {
     };
     return out[(status / 100) | 0];
 };
-function log(fn, prefix, method, path, status, elapsed, contentLength) {
+function log(fn, prefix, method, path, status, elapsed) {
     const out = prefix === LogPrefix.Incoming
         ? `  ${prefix} ${method} ${path}`
-        : `  ${prefix} ${method} ${path} ${colorStatus(status)} ${elapsed} ${contentLength}`;
+        : `  ${prefix} ${method} ${path} ${colorStatus(status)} ${elapsed}`;
     fn(out);
 }
 const logger = (fn = console.log) => {
@@ -44,9 +44,7 @@ const logger = (fn = console.log) => {
         log(fn, LogPrefix.Incoming, method, path);
         const start = Date.now();
         await next();
-        const len = parseFloat(c.res.headers.get('Content-Length'));
-        const contentLength = isNaN(len) ? '0' : len < 1024 ? `${len}b` : `${len / 1024}kB`;
-        log(fn, LogPrefix.Outgoing, method, path, c.res.status, time(start), contentLength);
+        log(fn, LogPrefix.Outgoing, method, path, c.res.status, time(start));
     };
 };
 exports.logger = logger;

package/dist/middleware/mustache/index.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mustache = void 0;
+const buffer_1 = require("../../utils/buffer");
 const cloudflare_1 = require("../../utils/cloudflare");
 const EXTENSION = '.mustache';
 const DEFAULT_DOCUMENT = 'index.mustache';
@@ -24,7 +25,7 @@ const mustache = (init = { root: '' }) => {
             if (!buffer) {
                 throw new Error(`Template "${path}" is not found or blank.`);
             }
-            const content = bufferToString(buffer);
+            const content = (0, buffer_1.bufferToString)(buffer);
             const partialArgs = {};
             if (options) {
                 const partials = options;
@@ -38,7 +39,7 @@ const mustache = (init = { root: '' }) => {
                     if (!partialBuffer) {
                         throw new Error(`Partial Template "${partialPath}" is not found or blank.`);
                     }
-                    partialArgs[key] = bufferToString(partialBuffer);
+                    partialArgs[key] = (0, buffer_1.bufferToString)(partialBuffer);
                 }
             }
             const output = Mustache.render(content, params, partialArgs);
@@ -48,10 +49,3 @@ const mustache = (init = { root: '' }) => {
     };
 };
 exports.mustache = mustache;
-const bufferToString = (buffer) => {
-    if (buffer instanceof ArrayBuffer) {
-        const enc = new TextDecoder('utf-8');
-        return enc.decode(buffer);
-    }
-    return buffer;
-};

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

@@ -6,6 +6,9 @@ export declare class Node {
     index?: number;
     varIndex?: number;
     children: Record<string, Node>;
+    reverse: boolean;
+    constructor({ reverse }?: Partial<Node>);
+    newChildNode(): Node;
     insert(tokens: readonly string[], index: number, paramMap: ParamMap, context: Context): void;
     buildRegExpStr(): string;
 }

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

@@ -35,8 +35,12 @@ function compareKey(a, b) {
     return a.length === b.length ? (a < b ? -1 : 1) : b.length - a.length;
 }
 class Node {
-    constructor() {
+    constructor({ reverse } = { reverse: false }) {
         this.children = {};
+        this.reverse = reverse;
+    }
+    newChildNode() {
+        return new Node({ reverse: this.reverse });
     }
     insert(tokens, index, paramMap, context) {
         var _a;
@@ -58,7 +62,7 @@ class Node {
             const regexpStr = pattern[2] || LABEL_REG_EXP_STR;
             node = this.children[regexpStr];
             if (!node) {
-                node = this.children[regexpStr] = new Node();
+                node = this.children[regexpStr] = this.newChildNode();
                 if (name !== '') {
                     node.varIndex = context.varIndex++;
                 }
@@ -68,19 +72,21 @@ class Node {
             }
         }
         else {
-            node = (_a = this.children)[token] || (_a[token] = new Node());
+            node = (_a = this.children)[token] || (_a[token] = this.newChildNode());
         }
         node.insert(restTokens, index, paramMap, context);
     }
     buildRegExpStr() {
-        const strList = Object.keys(this.children)
-            .sort(compareKey)
-            .map((k) => {
+        let childKeys = Object.keys(this.children).sort(compareKey);
+        if (this.reverse) {
+            childKeys = childKeys.reverse();
+        }
+        const strList = childKeys.map((k) => {
             const c = this.children[k];
             return (typeof c.varIndex === 'number' ? `(${k})@${c.varIndex}` : k) + c.buildRegExpStr();
         });
         if (typeof this.index === 'number') {
-            strList.push(`#${this.index}`);
+            strList.unshift(`#${this.index}`);
         }
         if (strList.length === 0) {
             return '';