hono 0.3.6 → 0.4.1

package/README.md

@@ -1,6 +1,6 @@
 # Hono
 
-Hono[炎] - _**means flame🔥 in Japanese**_ - is small, simple, and ultrafast web flamework for a Service Workers API based serverless such as Cloudflare Workers and Fastly Compute@Edge.
+Hono[炎] - _**means flame🔥 in Japanese**_ - is small, simple, and ultrafast web framework for a Service Workers API based serverless such as Cloudflare Workers and Fastly Compute@Edge.
 
 ```js
 import { Hono } from 'hono'
@@ -13,7 +13,7 @@ app.fire()
 
 ## Features
 
-- **Ultra fast** - the router is implemented with Trie-Tree structure.
+- **Ultra fast** - the router is implemented with Trie-Tree structure. Not use loops.
 - **Zero dependencies** - using only Web standard API.
 - **Middleware** - builtin middleware, and you can make your own middleware.
 - **Optimized** - for Cloudflare Workers.
@@ -23,12 +23,12 @@ app.fire()
 **Hono is fastest** compared to other routers for Cloudflare Workers.
 
 ```plain
-hono x 708,671 ops/sec ±2.58% (58 runs sampled)
-itty-router x 159,610 ops/sec ±2.86% (87 runs sampled)
-sunder x 322,846 ops/sec ±2.24% (86 runs sampled)
-worktop x 223,625 ops/sec ±2.01% (95 runs sampled)
+hono x 779,197 ops/sec ±6.55% (78 runs sampled)
+itty-router x 161,813 ops/sec ±3.87% (87 runs sampled)
+sunder x 334,096 ops/sec ±1.33% (93 runs sampled)
+worktop x 212,661 ops/sec ±4.40% (81 runs sampled)
 Fastest is hono
-✨  Done in 57.83s.
+✨  Done in 58.29s.
 ```
 
 ## Hono in 1 minute
@@ -37,9 +37,13 @@ Below is a demonstration to create an application of Cloudflare Workers with Hon
 
 ![Demo](https://user-images.githubusercontent.com/10682/151973526-342644f9-71c5-4fee-81f4-64a7558bb192.gif)
 
+Now, the named path parameter has types.
+
+![Demo](https://user-images.githubusercontent.com/10682/154179671-9e491597-6778-44ac-a8e6-4483d7ad5393.png)
+
 ## Install
 
-You can install from npm registry:
+You can install Hono from npm registry:
 
 ```sh
 yarn add hono
@@ -53,7 +57,7 @@ npm install hono
 
 ## Methods
 
-Instance of `Hono` has these methods:
+An instance of `Hono` has these methods:
 
 - app.**HTTP_METHOD**(path, handler)
 - app.**all**(path, handler)
@@ -104,27 +108,32 @@ app.get('/post/:date{[0-9]+}/:title{[a-z]+}', (c) => {
   ...
 ```
 
-### Chained Route
+### Nested route
 
 ```js
-app
-  .route('/api/book')
-    .get(() => {...})
-    .post(() => {...})
-    .put(() => {...})
+const book = app.route('/book')
+book.get('/', (c) => c.text('List Books')) // => GET /book
+book.get('/:id', (c) => {
+  // => GET /book/:id
+  const id = c.req.param('id')
+  return c.text('Get Book: ' + id)
+})
+book.post('/', (c) => c.text('Create Book')) // => POST /book
 ```
 
-### Custom 404 Response
+### no strict
 
-You can customize 404 Not Found response:
+If `strict` is set `false`, `/hello`and`/hello/` are treated the same:
 
 ```js
-app.get('*', (c) => {
-  return c.text('Custom 404 Error', 404)
-})
+const app = new Hono({ strict: false })
+
+app.get('/hello', (c) => c.text('/hello or /hello/'))
 ```
 
-## async/await
+Default is `true`.
+
+### async/await
 
 ```js
 app.get('/fetch-url', async (c) => {
@@ -147,15 +156,7 @@ const app = new Hono()
 
 app.use('*', poweredBy())
 app.use('*', logger())
-app.use(
-  '/auth/*',
-  basicAuth({
-    username: 'hono',
-    password: 'acoolproject',
-  })
-)
-
-...
+app.use('/auth/*', basicAuth({ username: 'hono', password: 'acoolproject' }))
 ```
 
 Available builtin middleware are listed on [src/middleware](https://github.com/yusukebe/hono/tree/master/src/middleware).
@@ -174,49 +175,15 @@ app.use('*', async (c, next) => {
 // Add a custom header
 app.use('/message/*', async (c, next) => {
   await next()
-  await c.res.headers.add('x-message', 'This is middleware!')
+  await c.header('x-message', 'This is middleware!')
 })
 
 app.get('/message/hello', (c) => c.text('Hello Middleware!'))
 ```
 
-### Handling Error
-
-```js
-app.use('*', async (c, next) => {
-  try {
-    await next()
-  } catch (err) {
-    console.error(`${err}`)
-    c.res = c.text('Custom Error Message', { status: 500 })
-  }
-})
-```
-
-### Complex Pattern
-
-You can also do this:
-
-```js
-// Output response time
-app.use('*', async (c, next) => {
-  await next()
-  const responseTime = await c.res.headers.get('X-Response-Time')
-  console.log(`X-Response-Time: ${responseTime}`)
-})
-
-// Add X-Response-Time header
-app.use('*', async (c, next) => {
-  const start = Date.now()
-  await next()
-  const ms = Date.now() - start
-  await c.res.headers.append('X-Response-Time', `${ms}ms`)
-})
-```
-
 ## Context
 
-To handle Request and Reponse easily, you can use Context object:
+To handle Request and Reponse, you can use Context object:
 
 ### c.req
 
@@ -301,6 +268,16 @@ app.get('/', (c) => {
 })
 ```
 
+### c.notFound()
+
+Return the default `404 Not Found` Response:
+
+```js
+app.get('/notfound', (c) => {
+  return c.notFound()
+})
+```
+
 ### c.redirect()
 
 Redirect, default status code is `302`:
@@ -342,6 +319,26 @@ app.get('*', async c => {
 })
 ```
 
+## Not Found
+
+If you want, you can set the default `404 Not Found` Response:
+
+```js
+app.notFound = (c) => {
+  return c.text('This is default 404 Not Found', 404)
+}
+```
+
+## Error handling
+
+You can handle errors in your way:
+
+```js
+app.onError = (err, c) => {
+  return c.text(`This is error message: ${err.mssage}`, 500)
+}
+```
+
 ## fire
 
 `app.fire()` do:
@@ -430,7 +427,7 @@ Run the development server locally. Then, access like `http://127.0.0.1:8787/` i
 wrangler dev
 ```
 
-### Publish
+### 7. Publish
 
 Deploy to Cloudflare. That's all!
 
@@ -461,6 +458,10 @@ Contributions Welcome! You can contribute by the following way:
 
 If you can, let's make Hono together!
 
+## Contributors
+
+Thanks to [all contributors](https://github.com/yusukebe/hono/graphs/contributors)!
+
 ## Author
 
 Yusuke Wada <https://github.com/yusukebe>

package/dist/compose.d.ts

@@ -1 +1 @@
-export declare const compose: <T>(middleware: Function[]) => (context: T, next?: Function) => Promise<void | object>;
+export declare const compose: <T>(middleware: Function[], onError?: Function) => (context: T, next?: Function) => Promise<void | object>;

package/dist/compose.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.compose = void 0;
+const context_1 = require("./context");
 // Based on the code in the MIT licensed `koa-compose` package.
-const compose = (middleware) => {
+const compose = (middleware, onError) => {
     const errors = [];
     return function (context, next) {
         let index = -1;
@@ -19,7 +20,12 @@ const compose = (middleware) => {
             try {
                 return Promise.resolve(fn(context, dispatch.bind(null, i + 1))).catch((e) => {
                     errors.push(e);
-                    throw errors[0]; // XXX
+                    if (onError && context instanceof context_1.Context) {
+                        context.res = onError(errors[0], context);
+                    }
+                    else {
+                        throw errors[0];
+                    }
                 });
             }
             catch (err) {

package/dist/context.d.ts

@@ -1,12 +1,10 @@
 /// <reference types="@cloudflare/workers-types" />
-declare type Headers = {
-    [key: string]: string;
-};
+declare type Headers = Record<string, string>;
 declare type Data = string | ArrayBuffer | ReadableStream;
 export interface Env {
 }
-export declare class Context {
-    req: Request;
+export declare class Context<RequestParamKeyType = string> {
+    req: Request<RequestParamKeyType>;
     res: Response;
     env: Env;
     event: FetchEvent;
@@ -14,7 +12,8 @@ export declare class Context {
     private _status;
     private _statusText;
     render: (template: string, params?: object, options?: object) => Promise<Response>;
-    constructor(req: Request, opts?: {
+    notFound: () => Response;
+    constructor(req: Request<RequestParamKeyType>, opts?: {
         res: Response;
         env: Env;
         event: FetchEvent;

package/dist/context.js

@@ -28,7 +28,7 @@ class Context {
     }
     status(number) {
         if (this.res) {
-            console.warn('c.res.status is already setted.');
+            console.warn('c.res.status is already set.');
             return;
         }
         this._status = number;

package/dist/hono.d.ts

@@ -1,45 +1,54 @@
 /// <reference types="@cloudflare/workers-types" />
-import type { Result } from './node';
 import { Node } from './node';
 import { Context } from './context';
 import type { Env } from './context';
+import type { Result } from './router';
+import { Router } from './router';
 declare global {
-    interface Request {
-        param: (key: string) => string;
+    interface Request<ParamKeyType = string> {
+        param: (key: ParamKeyType) => string;
         query: (key: string) => string;
         header: (name: string) => string;
         parsedBody: any;
     }
 }
-export declare type Handler = (c: Context, next?: Function) => Response | Promise<Response>;
+export declare type Handler<RequestParamKeyType = string> = (c: Context<RequestParamKeyType>, next?: Function) => Response | Promise<Response>;
 export declare type MiddlewareHandler = (c: Context, next: Function) => Promise<void>;
-export declare class Router<T> {
+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>;
+export declare class TrieRouter<T> extends Router<T> {
     node: Node<T>;
     constructor();
     add(method: string, path: string, handler: T): void;
     match(method: string, path: string): Result<T> | null;
 }
 export declare class Hono {
-    router: Router<Handler[]>;
+    routerClass: {
+        new (): Router<any>;
+    };
+    strict: boolean;
+    router: Router<Handler>;
     middlewareRouters: Router<MiddlewareHandler>[];
     tempPath: string;
-    constructor();
-    get(arg: string | Handler, ...args: Handler[]): Hono;
-    post(arg: string | Handler, ...args: Handler[]): Hono;
-    put(arg: string | Handler, ...args: Handler[]): Hono;
-    head(arg: string | Handler, ...args: Handler[]): Hono;
-    delete(arg: string | Handler, ...args: Handler[]): Hono;
-    options(arg: string | Handler, ...args: Handler[]): Hono;
-    patch(arg: string | Handler, ...args: Handler[]): Hono;
-    all(arg: string | Handler, ...args: Handler[]): Hono;
+    constructor(init?: Partial<Pick<Hono, 'routerClass' | 'strict'>>);
+    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;
+    delete<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;
     route(path: string): Hono;
     use(path: string, middleware: MiddlewareHandler): void;
-    addRoute(method: string, arg: string | Handler, ...args: Handler[]): Hono;
-    matchRoute(method: string, path: string): Promise<Result<Handler[]>>;
+    addRoute(method: string, path: string, handler: Handler): Hono;
+    matchRoute(method: string, path: string): Promise<Result<Handler>>;
     dispatch(request: Request, env?: Env, event?: FetchEvent): Promise<Response>;
     handleEvent(event: FetchEvent): Promise<Response>;
     fetch(request: Request, env?: Env, event?: FetchEvent): Promise<Response>;
     fire(): void;
-    onError(err: Error): Response;
-    notFound(): Response;
+    onError(err: Error, c: Context): Response;
+    notFound(c: Context): Response;
 }
+export {};

package/dist/hono.js

@@ -1,13 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Hono = exports.Router = void 0;
+exports.Hono = exports.TrieRouter = void 0;
 const node_1 = require("./node");
 const compose_1 = require("./compose");
 const url_1 = require("./utils/url");
 const context_1 = require("./context");
-const METHOD_NAME_OF_ALL = 'ALL';
-class Router {
+const router_1 = require("./router");
+class TrieRouter extends router_1.Router {
     constructor() {
+        super();
         this.node = new node_1.Node();
     }
     add(method, path, handler) {
@@ -17,84 +18,69 @@ class Router {
         return this.node.search(method, path);
     }
 }
-exports.Router = Router;
+exports.TrieRouter = TrieRouter;
 class Hono {
-    constructor() {
-        this.router = new Router();
+    constructor(init = {}) {
+        this.routerClass = TrieRouter;
+        this.strict = true; // strict routing - default is true
+        Object.assign(this, init);
+        this.router = new this.routerClass();
         this.middlewareRouters = [];
-        this.tempPath = '/';
-    }
-    /* HTTP METHODS */
-    get(arg, ...args) {
-        return this.addRoute('get', arg, ...args);
-    }
-    post(arg, ...args) {
-        return this.addRoute('post', arg, ...args);
-    }
-    put(arg, ...args) {
-        return this.addRoute('put', arg, ...args);
-    }
-    head(arg, ...args) {
-        return this.addRoute('head', arg, ...args);
-    }
-    delete(arg, ...args) {
-        return this.addRoute('delete', arg, ...args);
-    }
-    options(arg, ...args) {
-        return this.addRoute('options', arg, ...args);
-    }
-    patch(arg, ...args) {
-        return this.addRoute('patch', arg, ...args);
-    }
-    /*
-    We may implement these HTTP methods:
-    trace
-    copy
-    lock
-    purge
-    unlock
-    report
-    checkout
-    merge
-    notify
-    subscribe
-    unsubscribe
-    search
-    connect
-    */
-    all(arg, ...args) {
-        return this.addRoute('all', arg, ...args);
+        this.tempPath = null;
+    }
+    get(path, handler) {
+        return this.addRoute('get', path, handler);
+    }
+    post(path, handler) {
+        return this.addRoute('post', path, handler);
+    }
+    put(path, handler) {
+        return this.addRoute('put', path, handler);
+    }
+    head(path, handler) {
+        return this.addRoute('head', path, handler);
+    }
+    delete(path, handler) {
+        return this.addRoute('delete', path, handler);
+    }
+    options(path, handler) {
+        return this.addRoute('options', path, handler);
+    }
+    patch(path, handler) {
+        return this.addRoute('patch', path, handler);
+    }
+    all(path, handler) {
+        return this.addRoute('all', path, handler);
     }
     route(path) {
-        this.tempPath = path;
-        return this;
+        const newHono = new Hono();
+        newHono.tempPath = path;
+        newHono.router = this.router;
+        return newHono;
     }
     use(path, middleware) {
         if (middleware.constructor.name !== 'AsyncFunction') {
             throw new TypeError('middleware must be a async function!');
         }
-        const router = new Router();
-        router.add(METHOD_NAME_OF_ALL, path, middleware);
+        const router = new this.routerClass();
+        router.add(router_1.METHOD_NAME_OF_ALL, path, middleware);
         this.middlewareRouters.push(router);
     }
     // addRoute('get', '/', handler)
-    addRoute(method, arg, ...args) {
+    addRoute(method, path, handler) {
         method = method.toUpperCase();
-        if (typeof arg === 'string') {
-            this.tempPath = arg;
-            this.router.add(method, arg, args);
-        }
-        else {
-            args.unshift(arg);
-            this.router.add(method, this.tempPath, args);
+        if (this.tempPath) {
+            path = (0, url_1.mergePath)(this.tempPath, path);
         }
+        this.router.add(method, path, handler);
         return this;
     }
     async matchRoute(method, path) {
         return this.router.match(method, path);
     }
     async dispatch(request, env, event) {
-        const [method, path] = [request.method, (0, url_1.getPathFromURL)(request.url)];
+        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) => {
@@ -109,10 +95,10 @@ class Hono {
             const url = new URL(c.req.url);
             return url.searchParams.get(key);
         };
-        const handler = result ? result.handler[0] : this.notFound; // XXX
+        const handler = result ? result.handler : this.notFound;
         const middleware = [];
         for (const mr of this.middlewareRouters) {
-            const mwResult = mr.match(METHOD_NAME_OF_ALL, path);
+            const mwResult = mr.match(router_1.METHOD_NAME_OF_ALL, path);
             if (mwResult) {
                 middleware.push(mwResult.handler);
             }
@@ -126,44 +112,33 @@ class Hono {
             await next();
         };
         middleware.push(wrappedHandler);
-        const composed = (0, compose_1.compose)(middleware);
+        const composed = (0, compose_1.compose)(middleware, this.onError);
         const c = new context_1.Context(request, { env: env, event: event, res: null });
+        c.notFound = () => this.notFound(c);
         await composed(c);
         return c.res;
     }
     async handleEvent(event) {
-        return this.dispatch(event.request, {}, event).catch((err) => {
-            return this.onError(err);
-        });
+        return this.dispatch(event.request, {}, event);
     }
     async fetch(request, env, event) {
-        return this.dispatch(request, env, event).catch((err) => {
-            return this.onError(err);
-        });
+        return this.dispatch(request, env, event);
     }
     fire() {
         addEventListener('fetch', (event) => {
             event.respondWith(this.handleEvent(event));
         });
     }
-    onError(err) {
-        console.error(`${err}`);
+    // Default error Response
+    onError(err, c) {
+        console.error(`${err.message}`);
         const message = 'Internal Server Error';
-        return new Response(message, {
-            status: 500,
-            headers: {
-                'Content-Length': message.length.toString(),
-            },
-        });
+        return c.text(message, 500);
     }
-    notFound() {
+    // Default 404 not found Response
+    notFound(c) {
         const message = 'Not Found';
-        return new Response('Not Found', {
-            status: 404,
-            headers: {
-                'Content-Length': message.length.toString(),
-            },
-        });
+        return c.text(message, 404);
     }
 }
 exports.Hono = Hono;

package/dist/middleware/logger/logger.js

@@ -12,9 +12,7 @@ const humanize = (n, opts) => {
 };
 const time = (start) => {
     const delta = Date.now() - start;
-    return humanize([
-        delta < 10000 ? delta + 'ms' : Math.round(delta / 1000) + 's',
-    ]);
+    return humanize([delta < 10000 ? delta + 'ms' : Math.round(delta / 1000) + 's']);
 };
 const LogPrefix = {
     Outgoing: '-->',
@@ -45,19 +43,9 @@ const logger = (fn = console.log) => {
         const path = (0, url_1.getPathFromURL)(c.req.url);
         log(fn, LogPrefix.Incoming, method, path);
         const start = Date.now();
-        try {
-            await next();
-        }
-        catch (e) {
-            log(fn, LogPrefix.Error, method, path, c.res.status || 500, time(start));
-            throw e;
-        }
+        await next();
         const len = parseFloat(c.res.headers.get('Content-Length'));
-        const contentLength = isNaN(len)
-            ? '0'
-            : len < 1024
-                ? `${len}b`
-                : `${len / 1024}kB`;
+        const contentLength = isNaN(len) ? '0' : len < 1024 ? `${len}b` : `${len / 1024}kB`;
         log(fn, LogPrefix.Outgoing, method, path, c.res.status, time(start), contentLength);
     };
 };

package/dist/middleware/mustache/mustache.d.ts

@@ -1,6 +1,6 @@
 import type { Context } from '../../context';
-declare type Options = {
+declare type Init = {
     root: string;
 };
-export declare const mustache: (opt?: Options) => (c: Context, next: Function) => Promise<void>;
+export declare const mustache: (init?: Init) => (c: Context, next: Function) => Promise<void>;
 export {};

package/dist/middleware/mustache/mustache.js

@@ -4,8 +4,8 @@ exports.mustache = void 0;
 const cloudflare_1 = require("../../utils/cloudflare");
 const EXTENSION = '.mustache';
 const DEFAULT_DOCUMENT = 'index.mustache';
-const mustache = (opt = { root: '' }) => {
-    const { root } = opt;
+const mustache = (init = { root: '' }) => {
+    const { root } = init;
     return async (c, next) => {
         let Mustache;
         try {
@@ -15,7 +15,11 @@ const mustache = (opt = { root: '' }) => {
             throw new Error('If you want to use Mustache Middleware, install "mustache" package first.');
         }
         c.render = async (filename, params = {}, options) => {
-            const path = (0, cloudflare_1.getKVFilePath)({ filename: `${filename}${EXTENSION}`, root: root, defaultDocument: DEFAULT_DOCUMENT });
+            const path = (0, cloudflare_1.getKVFilePath)({
+                filename: `${filename}${EXTENSION}`,
+                root: root,
+                defaultDocument: DEFAULT_DOCUMENT,
+            });
             const buffer = await (0, cloudflare_1.getContentFromKVAsset)(path);
             if (!buffer) {
                 throw new Error(`Template "${path}" is not found or blank.`);

package/dist/middleware/serve-static/serve-static.js

@@ -9,7 +9,11 @@ const serveStatic = (opt = { root: '' }) => {
     return async (c, next) => {
         await next();
         const url = new URL(c.req.url);
-        const path = (0, cloudflare_1.getKVFilePath)({ filename: url.pathname, root: opt.root, defaultDocument: DEFAULT_DOCUMENT });
+        const path = (0, cloudflare_1.getKVFilePath)({
+            filename: url.pathname,
+            root: opt.root,
+            defaultDocument: DEFAULT_DOCUMENT,
+        });
         const content = await (0, cloudflare_1.getContentFromKVAsset)(path);
         if (content) {
             const mimeType = (0, mime_1.getMimeType)(path);

package/dist/node.d.ts

@@ -1,24 +1,12 @@
-export declare class Result<T> {
-    handler: T;
-    params: {
-        [key: string]: string;
-    };
-    constructor(handler: T, params: {
-        [key: string]: string;
-    });
-}
+import type { Pattern } from './utils/url';
+import { Result } from './router';
 export declare class Node<T> {
-    method: {
-        [key: string]: T;
-    };
+    method: Record<string, T>;
     handler: T;
-    children: {
-        [key: string]: Node<T>;
-    };
+    children: Record<string, Node<T>>;
     middlewares: [];
-    constructor(method?: string, handler?: T, children?: {
-        [key: string]: Node<T>;
-    });
+    patterns: Pattern[];
+    constructor(method?: string, handler?: T, children?: Record<string, Node<T>>);
     insert(method: string, path: string, handler: T): Node<T>;
     search(method: string, path: string): Result<T>;
 }

package/dist/node.js

@@ -1,15 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Node = exports.Result = void 0;
+exports.Node = void 0;
 const url_1 = require("./utils/url");
-const METHOD_NAME_OF_ALL = 'ALL';
-class Result {
-    constructor(handler, params) {
-        this.handler = handler;
-        this.params = params;
-    }
-}
-exports.Result = Result;
+const router_1 = require("./router");
 const noRoute = () => {
     return null;
 };
@@ -21,6 +14,7 @@ class Node {
             this.method[method] = handler;
         }
         this.middlewares = [];
+        this.patterns = [];
     }
     insert(method, path, handler) {
         // eslint-disable-next-line @typescript-eslint/no-this-alias
@@ -33,6 +27,10 @@ class Node {
                 continue;
             }
             curNode.children[p] = new Node();
+            const pattern = (0, url_1.getPattern)(p);
+            if (pattern) {
+                curNode.patterns.push(pattern);
+            }
             curNode = curNode.children[p];
         }
         curNode.method[method] = handler;
@@ -64,29 +62,24 @@ class Node {
             }
             let isWildcard = false;
             let isParamMatch = false;
-            const keys = Object.keys(curNode.children);
-            for (let j = 0, len = keys.length; j < len; j++) {
-                const key = keys[j];
+            for (let j = 0, len = curNode.patterns.length; j < len; j++) {
+                const pattern = curNode.patterns[j];
                 // Wildcard
                 // '/hello/*/foo' => match /hello/bar/foo
-                if (key === '*') {
+                if (pattern === '*') {
                     curNode = curNode.children['*'];
                     isWildcard = true;
                     break;
                 }
-                const pattern = (0, url_1.getPattern)(key);
                 // Named match
-                if (pattern) {
-                    const match = p.match(new RegExp(pattern[1]));
-                    if (match) {
-                        const k = pattern[0];
-                        params[k] = match[1];
-                        curNode = curNode.children[key];
-                        isParamMatch = true;
-                        break;
-                    }
-                    return noRoute();
+                const [key, name, matcher] = pattern;
+                if (p !== '' && (matcher === true || matcher.test(p))) {
+                    params[name] = p;
+                    curNode = curNode.children[key];
+                    isParamMatch = true;
+                    break;
                 }
+                return noRoute();
             }
             if (isWildcard && i === len - 1) {
                 break;
@@ -95,11 +88,11 @@ class Node {
                 return noRoute();
             }
         }
-        const handler = curNode.method[METHOD_NAME_OF_ALL] || curNode.method[method];
+        const handler = curNode.method[router_1.METHOD_NAME_OF_ALL] || curNode.method[method];
         if (!handler) {
             return noRoute();
         }
-        return new Result(handler, params);
+        return new router_1.Result(handler, params);
     }
 }
 exports.Node = Node;

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

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

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

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

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

@@ -0,0 +1,15 @@
+export interface ParamMap {
+    [key: string]: number;
+}
+export interface Context {
+    varIndex: number;
+}
+export declare class Node {
+    index?: number;
+    varIndex?: number;
+    children: {
+        [key: string]: Node;
+    };
+    insert(tokens: readonly string[], index: number, paramMap: ParamMap, context: Context): void;
+    buildRegExpStr(): string;
+}

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

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Node = void 0;
+const LABEL_REG_EXP_STR = '[^/]+';
+const ONLY_WILDCARD_REG_EXP_STR = '.*';
+const TAIL_WILDCARD_REG_EXP_STR = '(?:|/.*)';
+/**
+ * Sort order:
+ * 1. literal
+ * 2. special pattern (e.g. :label{[0-9]+})
+ * 3. common label pattern (e.g. :label)
+ * 4. wildcard
+ */
+function compareKey(a, b) {
+    if (a.length === 1) {
+        return b.length === 1 ? (a < b ? -1 : 1) : -1;
+    }
+    if (b.length === 1) {
+        return 1;
+    }
+    // wildcard
+    if (a === ONLY_WILDCARD_REG_EXP_STR || a === TAIL_WILDCARD_REG_EXP_STR) {
+        return 1;
+    }
+    else if (b === ONLY_WILDCARD_REG_EXP_STR || b === TAIL_WILDCARD_REG_EXP_STR) {
+        return -1;
+    }
+    // label
+    if (a === LABEL_REG_EXP_STR) {
+        return 1;
+    }
+    else if (b === LABEL_REG_EXP_STR) {
+        return -1;
+    }
+    return a.length === b.length ? (a < b ? -1 : 1) : b.length - a.length;
+}
+class Node {
+    constructor() {
+        this.children = {};
+    }
+    insert(tokens, index, paramMap, context) {
+        var _a;
+        if (tokens.length === 0) {
+            this.index = index;
+            return;
+        }
+        const [token, ...restTokens] = tokens;
+        const pattern = token === '*'
+            ? restTokens.length === 0
+                ? ['', '', ONLY_WILDCARD_REG_EXP_STR] // '*' matches to all the trailing paths
+                : ['', '', LABEL_REG_EXP_STR]
+            : token === '/*'
+                ? ['', '', TAIL_WILDCARD_REG_EXP_STR] // '/path/to/*' is /\/path\/to(?:|/.*)$
+                : token.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
+        let node;
+        if (pattern) {
+            const name = pattern[1];
+            const regexpStr = pattern[2] || LABEL_REG_EXP_STR;
+            node = this.children[regexpStr];
+            if (!node) {
+                node = this.children[regexpStr] = new Node();
+                if (name !== '') {
+                    node.varIndex = context.varIndex++;
+                }
+            }
+            if (name !== '') {
+                paramMap[name] = node.varIndex;
+            }
+        }
+        else {
+            node = (_a = this.children)[token] || (_a[token] = new Node());
+        }
+        node.insert(restTokens, index, paramMap, context);
+    }
+    buildRegExpStr() {
+        const strList = Object.keys(this.children)
+            .sort(compareKey)
+            .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}`);
+        }
+        if (strList.length === 0) {
+            return '';
+        }
+        if (strList.length === 1) {
+            return strList[0];
+        }
+        return '(?:' + strList.join('|') + ')';
+    }
+}
+exports.Node = Node;

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

@@ -0,0 +1,18 @@
+import { Router, Result } from '../../router';
+import type { ParamMap, ReplacementMap } from './trie';
+declare type Route<T> = [string, T];
+declare type HandlerData<T> = [T, ParamMap];
+declare type Matcher<T> = [RegExp | true, ReplacementMap, HandlerData<T>[]];
+export declare class RegExpRouter<T> extends Router<T> {
+    routes?: {
+        [method: string]: Route<T>[];
+    };
+    matchers?: {
+        [method: string]: Matcher<T> | null;
+    };
+    add(method: string, path: string, handler: T): void;
+    match(method: string, path: string): Result<T> | null;
+    private buildAllMatchers;
+    private buildMatcher;
+}
+export {};

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

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RegExpRouter = void 0;
+const router_1 = require("../../router");
+const trie_1 = require("./trie");
+class RegExpRouter extends router_1.Router {
+    constructor() {
+        super(...arguments);
+        this.routes = {};
+        this.matchers = null;
+    }
+    add(method, path, handler) {
+        var _a;
+        if (!this.routes) {
+            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]);
+    }
+    match(method, path) {
+        if (!this.matchers) {
+            this.buildAllMatchers();
+        }
+        const matcher = this.matchers[method] || this.matchers[router_1.METHOD_NAME_OF_ALL];
+        if (!matcher) {
+            return null;
+        }
+        const [regexp, replacementMap, handlers] = matcher;
+        if (regexp === true) {
+            // '*'
+            return new router_1.Result(handlers[0][0], {});
+        }
+        const match = path.match(regexp);
+        if (!match) {
+            return null;
+        }
+        if (!replacementMap) {
+            // there is only one route and no capture
+            return new router_1.Result(handlers[0][0], {});
+        }
+        const index = match.indexOf('', 1);
+        const [handler, paramMap] = handlers[replacementMap[index]];
+        const params = {};
+        const keys = Object.keys(paramMap);
+        for (let i = 0; i < keys.length; i++) {
+            params[keys[i]] = match[paramMap[keys[i]]];
+        }
+        return new router_1.Result(handler, params);
+    }
+    buildAllMatchers() {
+        this.matchers || (this.matchers = {});
+        Object.keys(this.routes).forEach((method) => {
+            this.buildMatcher(method);
+        });
+        delete this.routes; // to reduce memory usage
+    }
+    buildMatcher(method) {
+        this.matchers || (this.matchers = {});
+        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) {
+            this.matchers[method] = null;
+            return;
+        }
+        if (routes.length === 1 && routes[0][0] === '*') {
+            this.matchers[method] = [true, null, [[routes[0][1], {}]]];
+            return;
+        }
+        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
+            this.matchers[method] = [new RegExp(regExpStr), null, [[routes[0][1], {}]]];
+            return;
+        }
+        for (let i = 0; i < routes.length; i++) {
+            const paramMap = trie.insert(routes[i][0], i);
+            handlers[i] = [routes[i][1], paramMap];
+        }
+        const [regexp, indexReplacementMap, paramReplacementMap] = trie.buildRegExp();
+        for (let i = 0; i < handlers.length; i++) {
+            const paramMap = handlers[i][1];
+            Object.keys(paramMap).forEach((k) => {
+                paramMap[k] = paramReplacementMap[paramMap[k]];
+            });
+        }
+        this.matchers[method] = [new RegExp(regexp), indexReplacementMap, handlers];
+    }
+}
+exports.RegExpRouter = RegExpRouter;

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

@@ -0,0 +1,10 @@
+import type { ParamMap, Context } from './node';
+import { Node } from './node';
+export type { ParamMap } from './node';
+export declare type ReplacementMap = number[];
+export declare class Trie {
+    context: Context;
+    root: Node;
+    insert(path: string, index: number): ParamMap;
+    buildRegExp(): [RegExp, ReplacementMap, ReplacementMap];
+}

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

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Trie = void 0;
+const node_1 = require("./node");
+class Trie {
+    constructor() {
+        this.context = { varIndex: 0 };
+        this.root = new node_1.Node();
+    }
+    insert(path, index) {
+        const paramMap = {};
+        /**
+         *  - pattern (:label, :label{0-9]+}, ...)
+         *  - /* wildcard
+         *  - character
+         */
+        const tokens = path.match(/(?::[^\/]+)|(?:\/\*$)|./g);
+        this.root.insert(tokens, index, paramMap, this.context);
+        return paramMap;
+    }
+    buildRegExp() {
+        let regexp = this.root.buildRegExpStr();
+        let captureIndex = 0;
+        const indexReplacementMap = [];
+        const paramReplacementMap = [];
+        regexp = regexp.replace(/#(\d+)|@(\d+)|\.\*\$/g, (_, handlerIndex, paramIndex) => {
+            if (typeof handlerIndex !== 'undefined') {
+                indexReplacementMap[++captureIndex] = Number(handlerIndex);
+                return '$()';
+            }
+            if (typeof paramIndex !== 'undefined') {
+                paramReplacementMap[Number(paramIndex)] = ++captureIndex;
+                return '';
+            }
+            return '';
+        });
+        return [new RegExp(`^${regexp}`), indexReplacementMap, paramReplacementMap];
+    }
+}
+exports.Trie = Trie;

package/dist/router.d.ts

@@ -0,0 +1,10 @@
+export declare const METHOD_NAME_OF_ALL = "ALL";
+export declare abstract class Router<T> {
+    abstract add(method: string, path: string, handler: T): void;
+    abstract match(method: string, path: string): Result<T> | null;
+}
+export declare class Result<T> {
+    handler: T;
+    params: Record<string, string>;
+    constructor(handler: T, params: Record<string, string>);
+}

package/dist/router.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Result = exports.Router = exports.METHOD_NAME_OF_ALL = void 0;
+exports.METHOD_NAME_OF_ALL = 'ALL';
+class Router {
+}
+exports.Router = Router;
+class Result {
+    constructor(handler, params) {
+        this.handler = handler;
+        this.params = params;
+    }
+}
+exports.Result = Result;

package/dist/utils/buffer.js

@@ -46,7 +46,9 @@ const sha256 = async (a) => {
         const buffer = await crypto.subtle.digest({
             name: 'SHA-256',
         }, new TextEncoder().encode(String(a)));
-        const hash = Array.prototype.map.call(new Uint8Array(buffer), (x) => ('00' + x.toString(16)).slice(-2)).join('');
+        const hash = Array.prototype.map
+            .call(new Uint8Array(buffer), (x) => ('00' + x.toString(16)).slice(-2))
+            .join('');
         return hash;
     }
     try {

package/dist/utils/url.d.ts

@@ -1,4 +1,10 @@
+export declare type Pattern = readonly [string, string, RegExp | true] | '*';
 export declare const splitPath: (path: string) => string[];
-export declare const getPattern: (label: string) => string[] | null;
-export declare const getPathFromURL: (url: string) => string;
+export declare const getPattern: (label: string) => Pattern | null;
+declare type Params = {
+    strict: boolean;
+};
+export declare const getPathFromURL: (url: string, params?: Params) => string;
 export declare const isAbsoluteURL: (url: string) => boolean;
+export declare const mergePath: (...paths: string[]) => string;
+export {};

package/dist/utils/url.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isAbsoluteURL = exports.getPathFromURL = exports.getPattern = exports.splitPath = void 0;
+exports.mergePath = exports.isAbsoluteURL = exports.getPathFromURL = exports.getPattern = exports.splitPath = void 0;
 const URL_REGEXP = /^(([^:\/?#]+):)?(\/\/([^\/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?/;
 const splitPath = (path) => {
     const paths = path.split(/\//); // faster than path.split('/')
@@ -10,23 +10,36 @@ const splitPath = (path) => {
     return paths;
 };
 exports.splitPath = splitPath;
+const patternCache = {};
 const getPattern = (label) => {
+    // *            => wildcard
     // :id{[0-9]+}  => ([0-9]+)
     // :id          => (.+)
     //const name = ''
+    if (label === '*') {
+        return '*';
+    }
     const match = label.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
     if (match) {
-        if (match[2]) {
-            return [match[1], '(' + match[2] + ')'];
-        }
-        else {
-            return [match[1], '(.+)'];
+        if (!patternCache[label]) {
+            if (match[2]) {
+                patternCache[label] = [label, match[1], new RegExp('^' + match[2] + '$')];
+            }
+            else {
+                patternCache[label] = [label, match[1], true];
+            }
         }
+        return patternCache[label];
     }
     return null;
 };
 exports.getPattern = getPattern;
-const getPathFromURL = (url) => {
+const getPathFromURL = (url, params = { strict: true }) => {
+    // if strict routing is false => `/hello/hey/` and `/hello/hey` are treated the same
+    // default is true
+    if (!params.strict && url.endsWith('/')) {
+        url = url.slice(0, -1);
+    }
     const match = url.match(URL_REGEXP);
     if (match) {
         return match[5];
@@ -42,3 +55,27 @@ const isAbsoluteURL = (url) => {
     return false;
 };
 exports.isAbsoluteURL = isAbsoluteURL;
+const mergePath = (...paths) => {
+    let p = '';
+    let endsWithSlash = false;
+    for (let path of paths) {
+        /* ['/hey/','/say'] => ['/hey', '/say'] */
+        if (p.endsWith('/')) {
+            p = p.slice(0, -1);
+            endsWithSlash = true;
+        }
+        /* ['/hey','say'] => ['/hey', '/say'] */
+        if (!path.startsWith('/')) {
+            path = `/${path}`;
+        }
+        /* ['/hey/', '/'] => `/hey/` */
+        if (path === '/' && endsWithSlash) {
+            p = `${p}/`;
+        }
+        else if (path !== '/') {
+            p = `${p}${path}`;
+        }
+    }
+    return p;
+};
+exports.mergePath = mergePath;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hono",
-  "version": "0.3.6",
+  "version": "0.4.1",
   "description": "[炎] Ultrafast web framework for Cloudflare Workers.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -16,7 +16,9 @@
     "./logger": "./dist/middleware/logger/logger.js",
     "./mustache": "./dist/middleware/mustache/mustache.js",
     "./powered-by": "./dist/middleware/powered-by/powered-by.js",
-    "./serve-static": "./dist/middleware/serve-static/serve-static.js"
+    "./serve-static": "./dist/middleware/serve-static/serve-static.js",
+    "./utils/buffer": "./dist/utils/buffer.js",
+    "./package.json": "./package.json"
   },
   "typesVersions": {
     "*": {
@@ -48,7 +50,7 @@
   },
   "scripts": {
     "test": "jest",
-    "lint": "eslint --ext js,ts src .eslintrc.js test",
+    "lint": "eslint --ext js,ts src .eslintrc.js test && prettier --check src",
     "build": "rimraf dist && tsc",
     "watch": "tsc -w",
     "prepublishOnly": "yarn build"
@@ -80,18 +82,18 @@
     "@typescript-eslint/eslint-plugin": "^5.9.0",
     "@typescript-eslint/parser": "^5.9.0",
     "eslint": "^7.26.0",
-    "eslint-config-prettier": "^8.1.0",
+    "eslint-config-prettier": "^8.3.0",
     "eslint-define-config": "^1.2.1",
     "eslint-import-resolver-typescript": "^2.0.0",
     "eslint-plugin-eslint-comments": "^3.2.0",
     "eslint-plugin-flowtype": "^5.7.2",
     "eslint-plugin-import": "^2.20.2",
     "eslint-plugin-node": "^11.1.0",
-    "eslint-plugin-prettier": "^4.0.0",
     "form-data": "^4.0.0",
     "jest": "^27.4.5",
     "jest-environment-miniflare": "^2.0.0",
     "mustache": "^4.2.0",
+    "prettier": "^2.5.1",
     "rimraf": "^3.0.2",
     "ts-jest": "^27.1.2",
     "typescript": "^4.5.5"

package/dist/middleware.d.ts

@@ -1,2 +0,0 @@
-export declare class Middleware {
-}

package/dist/middleware.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Middleware = void 0;
-class Middleware {
-}
-exports.Middleware = Middleware;