hono 1.4.2 → 1.4.5

package/README.md

@@ -38,13 +38,13 @@ app.fire()
 **Hono is fastest**, compared to other routers for Cloudflare Workers.
 
 ```plain
-hono - trie-router(default) x 724,143 ops/sec ±3.63% (80 runs sampled)
-hono - regexp-router x 1,236,810 ops/sec ±6.77% (72 runs sampled)
-itty-router x 161,786 ops/sec ±2.28% (97 runs sampled)
-sunder x 312,262 ops/sec ±2.59% (85 runs sampled)
-worktop x 224,979 ops/sec ±1.13% (96 runs sampled)
+hono - trie-router(default) x 389,510 ops/sec ±3.16% (85 runs sampled)
+hono - regexp-router x 452,290 ops/sec ±2.64% (84 runs sampled)
+itty-router x 206,013 ops/sec ±3.39% (90 runs sampled)
+sunder x 323,131 ops/sec ±0.75% (97 runs sampled)
+worktop x 191,218 ops/sec ±2.70% (91 runs sampled)
 Fastest is hono - regexp-router
-✨  Done in 95.05s.
+✨  Done in 43.56s.
 ```
 
 ## Why so fast?
@@ -98,7 +98,7 @@ import { basicAuth } from 'hono/basic-auth'
 
 const v1 = new Hono()
 v1.get('/posts', (c) => {
-  return c.text('list pots')
+  return c.text('list posts')
 })
   .post(basicAuth({ username, password }), (c) => {
     return c.text('created!', 201)
@@ -644,7 +644,7 @@ npx wrangler publish ./src/index.ts
 
 You can start making your Cloudflare Workers application with [the starter template](https://github.com/honojs/hono-minimal). It is really minimal using TypeScript, esbuild, Miniflare, and Jest.
 
-To generate a project skelton, run this command.
+To generate a project skeleton, run this command.
 
 ```
 npx create-cloudflare my-app https://github.com/honojs/hono-minimal

package/dist/compose.js

@@ -16,18 +16,16 @@ const compose = (middleware, onError, onNotFound) => {
             if (i === middleware.length && next)
                 handler = next;
             if (!handler) {
-                if (context instanceof context_1.Context && context.res._finalized === false && onNotFound) {
+                if (context instanceof context_1.Context && context.finalized === false && onNotFound) {
                     context.res = onNotFound(context);
-                    context.res._finalized = true;
                 }
                 return Promise.resolve(context);
             }
-            return Promise.resolve(handler(context, dispatch.bind(null, i + 1)))
+            return Promise.resolve(handler(context, () => dispatch(i + 1)))
                 .then(async (res) => {
                 // If handler return Response like `return c.text('foo')`
                 if (res && context instanceof context_1.Context) {
                     context.res = res;
-                    context.res._finalized = true;
                 }
                 return context;
             })
@@ -35,7 +33,6 @@ const compose = (middleware, onError, onNotFound) => {
                 if (context instanceof context_1.Context && onError) {
                     if (err instanceof Error) {
                         context.res = onError(err, context);
-                        context.res._finalized = true;
                     }
                     return context;
                 }

package/dist/context.d.ts

@@ -1,36 +1,35 @@
 /// <reference types="@cloudflare/workers-types" />
-import { HonoResponse } from './response';
 import type { StatusCode } from './utils/http-status';
 declare type Headers = Record<string, string>;
 export declare type Data = string | ArrayBuffer | ReadableStream;
 export declare type Env = Record<string, any>;
 export declare class Context<RequestParamKeyType extends string = string, E = Env> {
     req: Request<RequestParamKeyType>;
-    res: Response;
     env: E;
     event: FetchEvent | undefined;
+    finalized: boolean;
     private _status;
     private _pretty;
     private _prettySpace;
     private _map;
+    private _headers;
+    private _res;
+    private notFoundHandler;
     render: (template: string, params?: object, options?: object) => Promise<Response>;
-    notFound: () => Response | Promise<Response>;
-    constructor(req: Request<RequestParamKeyType>, opts?: {
-        env?: Env;
-        event?: FetchEvent;
-        res?: Response | HonoResponse;
-    });
-    private initRequest;
+    constructor(req: Request<RequestParamKeyType>, env?: E | undefined, event?: FetchEvent | undefined, notFoundHandler?: (c: Context<string, E>) => Response);
+    get res(): Response;
+    set res(_res: Response);
     header(name: string, value: string): void;
     status(status: StatusCode): void;
     set(key: string, value: any): void;
     get(key: string): any;
     pretty(prettyJSON: boolean, space?: number): void;
-    newResponse(data: Data | null, init?: ResponseInit): Response;
+    newResponse(data: Data | null, status: StatusCode, headers?: Headers): Response;
     body(data: Data | null, status?: StatusCode, headers?: Headers): Response;
     text(text: string, status?: StatusCode, headers?: Headers): Response;
     json(object: object, status?: StatusCode, headers?: Headers): Response;
     html(html: string, status?: StatusCode, headers?: Headers): Response;
     redirect(location: string, status?: StatusCode): Response;
+    notFound(): Response | Promise<Response>;
 }
 export {};

package/dist/context.js

@@ -1,109 +1,71 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Context = void 0;
-const response_1 = require("./response");
 const url_1 = require("./utils/url");
 class Context {
-    constructor(req, opts = {
-        env: {},
-        event: undefined,
-        res: undefined,
-    }) {
+    constructor(req, env = undefined, event = undefined, notFoundHandler = () => new Response()) {
         this._status = 200;
         this._pretty = false;
         this._prettySpace = 2;
-        this.req = this.initRequest(req);
-        this._map = {};
-        Object.assign(this, opts);
-        if (!this.res) {
-            const res = new response_1.HonoResponse(null, { status: 404 });
-            res._finalized = false;
-            this.res = res;
+        this.req = req;
+        if (env) {
+            this.env = env;
         }
+        this.event = event;
+        this.notFoundHandler = notFoundHandler;
+        this.finalized = false;
     }
-    initRequest(req) {
-        req.header = ((name) => {
-            if (name) {
-                return req.headers.get(name);
-            }
-            else {
-                const result = {};
-                for (const [key, value] of req.headers) {
-                    result[key] = value;
-                }
-                return result;
-            }
-        });
-        req.query = ((key) => {
-            const url = new URL(req.url);
-            if (key) {
-                return url.searchParams.get(key);
-            }
-            else {
-                const result = {};
-                for (const key of url.searchParams.keys()) {
-                    result[key] = url.searchParams.get(key) || '';
-                }
-                return result;
-            }
-        });
-        req.queries = ((key) => {
-            const url = new URL(req.url);
-            if (key) {
-                return url.searchParams.getAll(key);
-            }
-            else {
-                const result = {};
-                for (const key of url.searchParams.keys()) {
-                    result[key] = url.searchParams.getAll(key);
-                }
-                return result;
-            }
-        });
-        return req;
+    get res() {
+        return (this._res || (this._res = new Response()));
+    }
+    set res(_res) {
+        this._res = _res;
+        this.finalized = true;
     }
     header(name, value) {
-        this.res.headers.set(name, value);
+        this._headers || (this._headers = {});
+        this._headers[name] = value;
+        if (this.finalized) {
+            this.res.headers.set(name, value);
+        }
     }
     status(status) {
         this._status = status;
     }
     set(key, value) {
+        this._map || (this._map = {});
         this._map[key] = value;
     }
     get(key) {
+        if (!this._map) {
+            return undefined;
+        }
         return this._map[key];
     }
     pretty(prettyJSON, space = 2) {
         this._pretty = prettyJSON;
         this._prettySpace = space;
     }
-    newResponse(data, init = {}) {
-        init.status = init.status || this._status || 200;
-        const headers = {};
-        this.res.headers.forEach((v, k) => {
-            headers[k] = v;
+    newResponse(data, status, headers = {}) {
+        const _headers = { ...this._headers, ...headers };
+        if (this._res) {
+            this._res.headers.forEach((v, k) => {
+                _headers[k] = v;
+            });
+        }
+        return new Response(data, {
+            status: status || this._status || 200,
+            headers: _headers,
         });
-        init.headers = Object.assign(headers, init.headers);
-        return new Response(data, init);
     }
     body(data, status = this._status, headers = {}) {
-        return this.newResponse(data, {
-            status: status,
-            headers: headers,
-        });
+        return this.newResponse(data, status, headers);
     }
     text(text, status = this._status, headers = {}) {
-        if (typeof text !== 'string') {
-            throw new TypeError('text method arg must be a string!');
-        }
         headers['Content-Type'] || (headers['Content-Type'] = 'text/plain; charset=UTF-8');
         return this.body(text, status, headers);
     }
     json(object, status = this._status, headers = {}) {
-        if (typeof object !== 'object') {
-            throw new TypeError('json method arg must be an object!');
-        }
         const body = this._pretty
             ? JSON.stringify(object, null, this._prettySpace)
             : JSON.stringify(object);
@@ -111,27 +73,21 @@ class Context {
         return this.body(body, status, headers);
     }
     html(html, status = this._status, headers = {}) {
-        if (typeof html !== 'string') {
-            throw new TypeError('html method arg must be a string!');
-        }
         headers['Content-Type'] || (headers['Content-Type'] = 'text/html; charset=UTF-8');
         return this.body(html, status, headers);
     }
     redirect(location, status = 302) {
-        if (typeof location !== 'string') {
-            throw new TypeError('location must be a string!');
-        }
         if (!(0, url_1.isAbsoluteURL)(location)) {
             const url = new URL(this.req.url);
             url.pathname = location;
             location = url.toString();
         }
-        return this.newResponse(null, {
-            status: status,
-            headers: {
-                Location: location,
-            },
+        return this.newResponse(null, status, {
+            Location: location,
         });
     }
+    notFound() {
+        return this.notFoundHandler(this);
+    }
 }
 exports.Context = Context;

package/dist/hono.d.ts

@@ -2,29 +2,6 @@
 import { Context } from './context';
 import type { Env } from './context';
 import type { Router } from './router';
-declare global {
-    interface Request<ParamKeyType extends string = string> {
-        param: {
-            (key: ParamKeyType): string;
-            (): Record<ParamKeyType, string>;
-        };
-        query: {
-            (key: string): string;
-            (): Record<string, string>;
-        };
-        queries: {
-            (key: string): string[];
-            (): Record<string, string[]>;
-        };
-        header: {
-            (name: string): string;
-            (): Record<string, string>;
-        };
-    }
-    interface Response {
-        _finalized: boolean;
-    }
-}
 export declare type Handler<RequestParamKeyType extends string = string, E = Env> = (c: Context<RequestParamKeyType, E>, next: Next) => Response | Promise<Response> | Promise<void> | Promise<Response | undefined>;
 export declare type NotFoundHandler<E = Env> = (c: Context<string, E>) => Response;
 export declare type ErrorHandler<E = Env> = (err: Error, c: Context<string, E>) => Response;
@@ -32,7 +9,7 @@ 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>;
-interface HandlerInterface<T extends string, E = Env, U = Hono<E, T>> {
+interface HandlerInterface<T extends string, E extends Env = 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;
@@ -53,7 +30,7 @@ declare const Hono_base: new <E_1 extends Env, T extends string, U>() => {
     options: HandlerInterface<T, E_1, U>;
     patch: HandlerInterface<T, E_1, U>;
 };
-export declare class Hono<E = Env, P extends string = '/'> extends Hono_base<E, P, Hono<E, P>> {
+export declare class Hono<E extends Env = Env, P extends string = '/'> extends Hono_base<E, P, Hono<E, P>> {
     readonly router: Router<Handler<string, E>>;
     readonly strict: boolean;
     private _tempPath;

package/dist/hono.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Hono = void 0;
 const compose_1 = require("./compose");
 const context_1 = require("./context");
+const request_1 = require("./request");
 const router_1 = require("./router");
 const trie_router_1 = require("./router/trie-router"); // Default Router
 const url_1 = require("./utils/url");
@@ -28,6 +29,7 @@ class Hono extends defineDynamicClass() {
             const message = 'Internal Server Error';
             return c.text(message, 500);
         };
+        (0, request_1.extendRequestPrototype)(); // FIXME: should be executed at a better timing
         const allMethods = [...methods, router_1.METHOD_NAME_ALL_LOWERCASE];
         allMethods.map((method) => {
             this[method] = (args1, ...args) => {
@@ -86,34 +88,23 @@ class Hono extends defineDynamicClass() {
         const r = { path: path, method: method, handler: handler };
         this.routes.push(r);
     }
-    async matchRoute(method, path) {
+    matchRoute(method, path) {
         return this.router.match(method, path);
     }
     async dispatch(request, event, env) {
-        const path = (0, url_1.getPathFromURL)(request.url, { strict: this.strict });
+        const path = (0, url_1.getPathFromURL)(request.url, this.strict);
         const method = request.method;
-        const result = await this.matchRoute(method, path);
-        request.param = ((key) => {
-            if (result) {
-                if (key) {
-                    return result.params[key];
-                }
-                else {
-                    return result.params;
-                }
-            }
-            return null;
-        });
+        const result = this.matchRoute(method, path);
+        request.paramData = result?.params;
         const handlers = result ? result.handlers : [this.notFoundHandler];
-        const c = new context_1.Context(request, {
-            env: env,
-            event: event,
-        });
-        c.notFound = () => this.notFoundHandler(c);
+        const c = new context_1.Context(request, env, event, this.notFoundHandler);
         const composed = (0, compose_1.compose)(handlers, this.errorHandler, this.notFoundHandler);
         let context;
         try {
             context = await composed(c);
+            if (!context.finalized) {
+                throw new Error('Context is not finalized. You may forget returning Response object or `await next()`');
+            }
         }
         catch (err) {
             if (err instanceof Error) {
@@ -121,8 +112,6 @@ class Hono extends defineDynamicClass() {
             }
             throw err;
         }
-        if (!context.res)
-            return context.notFound();
         return context.res;
     }
     async handleEvent(event) {

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+/// <reference path="request.d.ts" />
 export { Hono } from './hono';
 export type { Handler, Next } from './hono';
 export { Context } from './context';

package/dist/index.js

@@ -1,4 +1,6 @@
 "use strict";
+// eslint-disable-next-line @typescript-eslint/triple-slash-reference
+/// <reference path="./request.ts" /> Import "declare global" for the Request interface.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Context = exports.Hono = void 0;
 var hono_1 = require("./hono");

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

@@ -34,7 +34,6 @@ const basicAuth = (options, ...users) => {
     }
     users.unshift({ username: options.username, password: options.password });
     return async (ctx, next) => {
-        var _a;
         const requestUser = auth(ctx.req);
         if (requestUser) {
             for (const user of users) {
@@ -50,7 +49,7 @@ const basicAuth = (options, ...users) => {
         ctx.res = new Response('Unauthorized', {
             status: 401,
             headers: {
-                'WWW-Authenticate': 'Basic realm="' + ((_a = options.realm) === null || _a === void 0 ? void 0 : _a.replace(/"/g, '\\"')) + '"',
+                'WWW-Authenticate': 'Basic realm="' + options.realm?.replace(/"/g, '\\"') + '"',
             },
         });
     };

package/dist/middleware/bearer-auth/index.d.ts

@@ -0,0 +1,8 @@
+import type { Context } from '../../context';
+import type { Next } from '../../hono';
+export declare const bearerAuth: (options: {
+    token: string;
+    realm?: string;
+    prefix?: string;
+    hashFunction?: Function;
+}) => (c: Context, next: Next) => Promise<void>;

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

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bearerAuth = void 0;
+const buffer_1 = require("../../utils/buffer");
+const TOKEN_STRINGS = '[A-Za-z0-9._~+/-]+=*';
+const PREFIX = 'Bearer';
+const bearerAuth = (options) => {
+    if (!options.token) {
+        throw new Error('bearer auth middleware requires options for "token"');
+    }
+    if (!options.realm) {
+        options.realm = '';
+    }
+    if (!options.prefix) {
+        options.prefix = PREFIX;
+    }
+    const realm = options.realm?.replace(/"/g, '\\"');
+    return async (c, next) => {
+        const headerToken = c.req.headers.get('Authorization');
+        if (!headerToken) {
+            // No Authorization header
+            c.res = new Response('Unauthorized', {
+                status: 401,
+                headers: {
+                    'WWW-Authenticate': `${options.prefix} realm="` + realm + '"',
+                },
+            });
+        }
+        else {
+            const regexp = new RegExp('^' + options.prefix + ' +(' + TOKEN_STRINGS + ') *$');
+            const match = regexp.exec(headerToken);
+            if (!match) {
+                // Invalid Request
+                c.res = new Response('Bad Request', {
+                    status: 400,
+                    headers: {
+                        'WWW-Authenticate': `${options.prefix} error="invalid_request"`,
+                    },
+                });
+            }
+            else {
+                const equal = await (0, buffer_1.timingSafeEqual)(options.token, match[1], options.hashFunction);
+                if (!equal) {
+                    // Invalid Token
+                    c.res = new Response('Unauthorized', {
+                        status: 401,
+                        headers: {
+                            'WWW-Authenticate': `${options.prefix} error="invalid_token"`,
+                        },
+                    });
+                }
+                else {
+                    // Authorize OK
+                    await next();
+                    return;
+                }
+            }
+        }
+    };
+};
+exports.bearerAuth = bearerAuth;

package/dist/middleware/cors/index.js

@@ -8,9 +8,11 @@ const cors = (options) => {
         allowHeaders: [],
         exposeHeaders: [],
     };
-    const opts = Object.assign(Object.assign({}, defaults), options);
+    const opts = {
+        ...defaults,
+        ...options,
+    };
     return async (c, next) => {
-        var _a, _b;
         await next();
         function set(key, value) {
             c.res.headers.append(key, value);
@@ -24,7 +26,7 @@ const cors = (options) => {
         if (opts.credentials) {
             set('Access-Control-Allow-Credentials', 'true');
         }
-        if ((_a = opts.exposeHeaders) === null || _a === void 0 ? void 0 : _a.length) {
+        if (opts.exposeHeaders?.length) {
             set('Access-Control-Expose-Headers', opts.exposeHeaders.join(','));
         }
         if (c.req.method === 'OPTIONS') {
@@ -32,17 +34,17 @@ const cors = (options) => {
             if (opts.maxAge != null) {
                 set('Access-Control-Max-Age', opts.maxAge.toString());
             }
-            if ((_b = opts.allowMethods) === null || _b === void 0 ? void 0 : _b.length) {
+            if (opts.allowMethods?.length) {
                 set('Access-Control-Allow-Methods', opts.allowMethods.join(','));
             }
             let headers = opts.allowHeaders;
-            if (!(headers === null || headers === void 0 ? void 0 : headers.length)) {
+            if (!headers?.length) {
                 const requestHeaders = c.req.headers.get('Access-Control-Request-Headers');
                 if (requestHeaders) {
                     headers = requestHeaders.split(/\s*,\s*/);
                 }
             }
-            if (headers === null || headers === void 0 ? void 0 : headers.length) {
+            if (headers?.length) {
                 set('Access-Control-Allow-Headers', headers.join(','));
                 set('Vary', 'Access-Control-Request-Headers');
             }

package/dist/middleware/graphql-server/index.js

@@ -6,11 +6,10 @@ exports.errorMessages = exports.getGraphQLParams = exports.graphqlServer = void
 const graphql_1 = require("graphql");
 const parse_body_1 = require("./parse-body");
 const graphqlServer = (options) => {
-    var _a, _b;
     const schema = options.schema;
     const rootValue = options.rootValue;
-    const pretty = (_a = options.pretty) !== null && _a !== void 0 ? _a : false;
-    const validationRules = (_b = options.validationRules) !== null && _b !== void 0 ? _b : [];
+    const pretty = options.pretty ?? false;
+    const validationRules = options.validationRules ?? [];
     // const showGraphiQL = options.graphiql ?? false
     return async (c, next) => {
         // GraphQL HTTP only supports GET and POST methods.
@@ -122,21 +121,20 @@ const graphqlServer = (options) => {
 };
 exports.graphqlServer = graphqlServer;
 const getGraphQLParams = async (request) => {
-    var _a, _b, _c;
     const urlData = new URLSearchParams(request.url.split('?')[1]);
     const bodyData = await (0, parse_body_1.parseBody)(request);
     // GraphQL Query string.
-    let query = (_a = urlData.get('query')) !== null && _a !== void 0 ? _a : bodyData.query;
+    let query = urlData.get('query') ?? bodyData.query;
     if (typeof query !== 'string') {
         query = null;
     }
     // Parse the variables if needed.
-    let variables = ((_b = urlData.get('variables')) !== null && _b !== void 0 ? _b : bodyData.variables);
+    let variables = (urlData.get('variables') ?? bodyData.variables);
     if (typeof variables === 'string') {
         try {
             variables = JSON.parse(variables);
         }
-        catch (_d) {
+        catch {
             throw Error('Variables are invalid JSON.');
         }
     }
@@ -144,7 +142,7 @@ const getGraphQLParams = async (request) => {
         variables = null;
     }
     // Name of GraphQL operation to execute.
-    let operationName = (_c = urlData.get('operationName')) !== null && _c !== void 0 ? _c : bodyData.operationName;
+    let operationName = urlData.get('operationName') ?? bodyData.operationName;
     if (typeof operationName !== 'string') {
         operationName = null;
     }

package/dist/middleware/jwt/index.js

@@ -12,7 +12,7 @@ const jwt = (options) => {
             ctx.res = new Response('Unauthorized', {
                 status: 401,
                 headers: {
-                    'WWW-Authenticate': 'Basic ${options.secret}',
+                    'WWW-Authenticate': `Bearer realm="${ctx.req.url}",error="invalid_request",error_description="no authorization included in request"`,
                 },
             });
             return;
@@ -22,7 +22,7 @@ const jwt = (options) => {
             ctx.res = new Response('Unauthorized', {
                 status: 401,
                 headers: {
-                    'WWW-Authenticate': 'Basic ${options.secret}',
+                    'WWW-Authenticate': `Bearer realm="${ctx.req.url}",error="invalid_request",error_description="no authorization included in request"`,
                 },
             });
             return;
@@ -40,7 +40,7 @@ const jwt = (options) => {
                 status: 401,
                 statusText: msg,
                 headers: {
-                    'WWW-Authenticate': 'Bearer ${options.secret}',
+                    'WWW-Authenticate': `Bearer realm="${ctx.req.url}",error="invalid_token",error_description="token verification failure"`,
                 },
             });
             return;

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

@@ -8,7 +8,7 @@ const DEFAULT_DOCUMENT = 'index.html';
 const serveStatic = (options = { root: '' }) => {
     return async (c, next) => {
         // Do nothing if Response is already set
-        if (c.res && c.res._finalized) {
+        if (c.res && c.finalized) {
             await next();
         }
         const url = new URL(c.req.url);

package/dist/request.d.ts

@@ -0,0 +1,22 @@
+declare global {
+    interface Request<ParamKeyType extends string = string> {
+        param: {
+            (key: ParamKeyType): string;
+            (): Record<ParamKeyType, string>;
+        };
+        paramData?: Record<ParamKeyType, string>;
+        query: {
+            (key: string): string;
+            (): Record<string, string>;
+        };
+        queries: {
+            (key: string): string[];
+            (): Record<string, string[]>;
+        };
+        header: {
+            (name: string): string;
+            (): Record<string, string>;
+        };
+    }
+}
+export declare function extendRequestPrototype(): void;

package/dist/request.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extendRequestPrototype = void 0;
+function extendRequestPrototype() {
+    if (!!Request.prototype.param) {
+        // already extended
+        return;
+    }
+    Request.prototype.param = function (key) {
+        if (this.paramData) {
+            if (key) {
+                return this.paramData[key];
+            }
+            else {
+                return this.paramData;
+            }
+        }
+        return null;
+    };
+    Request.prototype.header = function (name) {
+        if (name) {
+            return this.headers.get(name);
+        }
+        else {
+            const result = {};
+            for (const [key, value] of this.headers) {
+                result[key] = value;
+            }
+            return result;
+        }
+    };
+    Request.prototype.query = function (key) {
+        const url = new URL(this.url);
+        if (key) {
+            return url.searchParams.get(key);
+        }
+        else {
+            const result = {};
+            for (const key of url.searchParams.keys()) {
+                result[key] = url.searchParams.get(key) || '';
+            }
+            return result;
+        }
+    };
+    Request.prototype.queries = function (key) {
+        const url = new URL(this.url);
+        if (key) {
+            return url.searchParams.getAll(key);
+        }
+        else {
+            const result = {};
+            for (const key of url.searchParams.keys()) {
+                result[key] = url.searchParams.getAll(key);
+            }
+            return result;
+        }
+    };
+}
+exports.extendRequestPrototype = extendRequestPrototype;

package/dist/router/trie-router/node.d.ts

@@ -11,10 +11,10 @@ export declare class Node<T> {
     patterns: Pattern[];
     order: number;
     name: string;
+    handlerSetCache: Record<string, HandlerSet<T>[]>;
     constructor(method?: string, handler?: T, children?: Record<string, Node<T>>);
     insert(method: string, path: string, handler: T): Node<T>;
     private getHandlerSets;
-    private next;
     search(method: string, path: string): Result<T> | null;
 }
 export {};

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

@@ -28,6 +28,7 @@ class Node {
             this.methods = [m];
         }
         this.patterns = [];
+        this.handlerSetCache = {};
     }
     insert(method, path, handler) {
         this.name = `${method} ${path}`;
@@ -82,89 +83,76 @@ class Node {
         return curNode;
     }
     getHandlerSets(node, method, wildcard) {
-        const handlerSets = [];
-        node.methods.map((m) => {
-            const handlerSet = m[method] || m[router_1.METHOD_NAME_ALL];
-            if (handlerSet !== undefined) {
-                const hs = Object.assign({}, handlerSet);
-                if (wildcard) {
-                    hs.score = handlerSet.score - 1;
-                }
-                handlerSets.push(hs);
-                return;
-            }
-        });
-        return handlerSets;
-    }
-    next(node, part, method, isLast) {
-        const handlerSets = [];
-        const nextNodes = [];
-        const params = {};
-        for (let j = 0, len = node.patterns.length; j < len; j++) {
-            const pattern = node.patterns[j];
-            // Wildcard
-            // '/hello/*/foo' => match /hello/bar/foo
-            if (pattern === '*') {
-                const astNode = node.children['*'];
-                if (astNode) {
-                    handlerSets.push(...this.getHandlerSets(astNode, method));
-                    nextNodes.push(astNode);
-                }
-            }
-            if (part === '')
-                continue;
-            // Named match
-            // `/posts/:id` => match /posts/123
-            const [key, name, matcher] = pattern;
-            if (matcher === true || (matcher instanceof RegExp && matcher.test(part))) {
-                if (typeof key === 'string') {
-                    if (isLast === true) {
-                        handlerSets.push(...this.getHandlerSets(node.children[key], method));
+        var _a, _b;
+        return ((_a = node.handlerSetCache)[_b = `${method}:${wildcard ? '1' : '0'}`] || (_a[_b] = (() => {
+            const handlerSets = [];
+            node.methods.map((m) => {
+                const handlerSet = m[method] || m[router_1.METHOD_NAME_ALL];
+                if (handlerSet !== undefined) {
+                    const hs = { ...handlerSet };
+                    if (wildcard) {
+                        hs.score = handlerSet.score - 1;
                     }
-                    nextNodes.push(node.children[key]);
-                }
-                if (typeof name === 'string') {
-                    params[name] = part;
-                }
-            }
-        }
-        const nextNode = node.children[part];
-        if (nextNode) {
-            if (isLast === true) {
-                // '/hello/*' => match '/hello'
-                if (nextNode.children['*']) {
-                    handlerSets.push(...this.getHandlerSets(nextNode.children['*'], method, true));
+                    handlerSets.push(hs);
+                    return;
                 }
-                handlerSets.push(...this.getHandlerSets(nextNode, method));
-            }
-            nextNodes.push(nextNode);
-        }
-        const next = {
-            nodes: nextNodes,
-            handlerSets: handlerSets,
-            params: params,
-        };
-        return next;
+            });
+            return handlerSets;
+        })()));
     }
     search(method, path) {
         const handlerSets = [];
-        let params = {};
+        const params = {};
         // eslint-disable-next-line @typescript-eslint/no-this-alias
         const curNode = this;
         let curNodes = [curNode];
         const parts = (0, url_1.splitPath)(path);
         for (let i = 0, len = parts.length; i < len; i++) {
-            const p = parts[i];
+            const part = parts[i];
             const isLast = i === len - 1;
             const tempNodes = [];
             for (let j = 0, len2 = curNodes.length; j < len2; j++) {
-                const res = this.next(curNodes[j], p, method, isLast);
-                if (res.nodes.length === 0) {
-                    continue;
+                const node = curNodes[j];
+                for (let k = 0, len3 = node.patterns.length; k < len3; k++) {
+                    const pattern = node.patterns[k];
+                    // Wildcard
+                    // '/hello/*/foo' => match /hello/bar/foo
+                    if (pattern === '*') {
+                        const astNode = node.children['*'];
+                        if (astNode) {
+                            handlerSets.push(...this.getHandlerSets(astNode, method));
+                            tempNodes.push(astNode);
+                        }
+                        continue;
+                    }
+                    if (part === '')
+                        continue;
+                    // Named match
+                    // `/posts/:id` => match /posts/123
+                    const [key, name, matcher] = pattern;
+                    if (matcher === true || (matcher instanceof RegExp && matcher.test(part))) {
+                        if (typeof key === 'string') {
+                            if (isLast === true) {
+                                handlerSets.push(...this.getHandlerSets(node.children[key], method));
+                            }
+                            tempNodes.push(node.children[key]);
+                        }
+                        if (typeof name === 'string') {
+                            params[name] = part;
+                        }
+                    }
+                }
+                const nextNode = node.children[part];
+                if (nextNode) {
+                    if (isLast === true) {
+                        // '/hello/*' => match '/hello'
+                        if (nextNode.children['*']) {
+                            handlerSets.push(...this.getHandlerSets(nextNode.children['*'], method, true));
+                        }
+                        handlerSets.push(...this.getHandlerSets(nextNode, method));
+                    }
+                    tempNodes.push(nextNode);
                 }
-                handlerSets.push(...res.handlerSets);
-                params = Object.assign(params, res.params);
-                tempNodes.push(...res.nodes);
             }
             curNodes = tempNodes;
         }

package/dist/utils/encode.js

@@ -10,7 +10,7 @@ const encodeBase64 = (str) => {
         const bytes = encoder.encode(str);
         return btoa(String.fromCharCode(...bytes));
     }
-    catch (_a) { }
+    catch { }
     try {
         return Buffer.from(str).toString('base64');
     }
@@ -30,7 +30,7 @@ const decodeBase64 = (str) => {
         const decoder = new TextDecoder();
         return decoder.decode(bytes);
     }
-    catch (_a) { }
+    catch { }
     try {
         return Buffer.from(str, 'base64').toString();
     }

package/dist/utils/url.d.ts

@@ -1,10 +1,6 @@
 export declare type Pattern = readonly [string, string, RegExp | true] | '*';
 export declare const splitPath: (path: 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 getPathFromURL: (url: string, strict?: boolean) => string;
 export declare const isAbsoluteURL: (url: string) => boolean;
 export declare const mergePath: (...paths: string[]) => string;
-export {};

package/dist/utils/url.js

@@ -34,17 +34,15 @@ const getPattern = (label) => {
     return null;
 };
 exports.getPattern = getPattern;
-const getPathFromURL = (url, params = { strict: true }) => {
+const getPathFromURL = (url, strict = true) => {
+    const queryIndex = url.indexOf('?');
+    const result = url.substring(url.indexOf('/', 8), queryIndex === -1 ? url.length : queryIndex);
     // if strict routing is false => `/hello/hey/` and `/hello/hey` are treated the same
     // default is true
-    if (params.strict === false && url.endsWith('/')) {
-        url = url.slice(0, -1);
+    if (strict === false && result.endsWith('/')) {
+        return result.slice(0, -1);
     }
-    const match = url.match(URL_REGEXP);
-    if (match) {
-        return match[1];
-    }
-    return '';
+    return result;
 };
 exports.getPathFromURL = getPathFromURL;
 const isAbsoluteURL = (url) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hono",
-  "version": "1.4.2",
+  "version": "1.4.5",
   "description": "Ultrafast web framework for Cloudflare Workers.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -18,6 +18,7 @@
   "exports": {
     ".": "./dist/index.js",
     "./basic-auth": "./dist/middleware/basic-auth/index.js",
+    "./bearer-auth": "./dist/middleware/bearer-auth/index.js",
     "./body-parse": "./dist/middleware/body-parse/index.js",
     "./cookie": "./dist/middleware/cookie/index.js",
     "./cors": "./dist/middleware/cors/index.js",
@@ -41,6 +42,9 @@
       "basic-auth": [
         "./dist/middleware/basic-auth"
       ],
+      "bearer-auth": [
+        "./dist/middleware/bearer-auth"
+      ],
       "body-parse": [
         "./dist/middleware/body-parse"
       ],
@@ -133,7 +137,7 @@
     "form-data": "^4.0.0",
     "graphql": "^16.4.0",
     "jest": "27.5.1",
-    "jest-environment-miniflare": "^2.4.0",
+    "jest-environment-miniflare": "^2.5.0",
     "mustache": "^4.2.0",
     "prettier": "^2.6.2",
     "prettier-plugin-md-nocjsp": "^1.2.0",

package/dist/response.d.ts

@@ -1,25 +0,0 @@
-import type { Data } from './context';
-export declare class HonoResponse implements Response {
-    headers: Headers;
-    ok: boolean;
-    redirected: boolean;
-    status: number;
-    statusText: string;
-    type: ResponseType;
-    url: string;
-    _finalized: boolean;
-    constructor(_data: Data | null, init: ResponseInit);
-    clone(): Response;
-    body: ReadableStream<Uint8Array> | null;
-    bodyUsed: boolean;
-    arrayBuffer(): Promise<ArrayBuffer>;
-    arrayBuffer(): Promise<ArrayBuffer>;
-    blob(): Promise<Blob>;
-    blob(): Promise<Blob>;
-    formData(): Promise<FormData>;
-    formData(): Promise<FormData>;
-    json(): Promise<any>;
-    json<T>(): Promise<T>;
-    text(): Promise<string>;
-    text(): Promise<string>;
-}

package/dist/response.js

@@ -1,35 +0,0 @@
-"use strict";
-/*
-  This Response object is for better performance.
-  This object is used in a Context before the Handler dispatches.
-*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HonoResponse = void 0;
-const errorMessage = 'Response is not finalized';
-class HonoResponse {
-    constructor(_data, init) {
-        var _a;
-        this.headers = new Headers(init.headers);
-        this.status = (_a = init.status) !== null && _a !== void 0 ? _a : 404;
-        this._finalized = false;
-    }
-    clone() {
-        throw new Error(errorMessage);
-    }
-    arrayBuffer() {
-        throw new Error(errorMessage);
-    }
-    blob() {
-        throw new Error(errorMessage);
-    }
-    formData() {
-        throw new Error(errorMessage);
-    }
-    json() {
-        throw new Error(errorMessage);
-    }
-    text() {
-        throw new Error(errorMessage);
-    }
-}
-exports.HonoResponse = HonoResponse;