hono 1.0.0 → 1.1.0

package/README.md

@@ -1,26 +1,26 @@
 <div align="center">
-  <a href="https://github.com/yusukebe/hono">
-    <img src="https://raw.githubusercontent.com/yusukebe/hono/master/docs/images/hono-title.png" width="500" height="auto" alt="Hono"/>
+  <a href="https://github.com/honojs/hono">
+    <img src="https://raw.githubusercontent.com/honojs/hono/master/docs/images/hono-title.png" width="500" height="auto" alt="Hono"/>
   </a>
 </div>
 
 <hr />
 
 <p>
-<a href="https://github.com/yusukebe/hono/blob/master/README.md">English</a>
+<a href="https://github.com/honojs/hono/blob/master/README.md">English</a>
 &#x000B7;
-<a href="https://github.com/yusukebe/hono/blob/master/docs/README.ja.md">日本語</a>
+<a href="https://github.com/honojs/hono/blob/master/docs/README.ja.md">日本語</a>
 </p>
 
-[![GitHub Workflow Status](https://img.shields.io/github/workflow/status/yusukebe/hono/ci)](https://github.com/yusukebe/hono/actions)
-[![GitHub](https://img.shields.io/github/license/yusukebe/hono)](https://github.com/yusukebe/hono/blob/master/LICENSE)
+[![GitHub Workflow Status](https://img.shields.io/github/workflow/status/honojs/hono/ci)](https://github.com/honojs/hono/actions)
+[![GitHub](https://img.shields.io/github/license/honojs/hono)](https://github.com/honojs/hono/blob/master/LICENSE)
 [![npm](https://img.shields.io/npm/v/hono)](https://www.npmjs.com/package/hono)
 [![npm](https://img.shields.io/npm/dm/hono)](https://www.npmjs.com/package/hono)
 [![npm type definitions](https://img.shields.io/npm/types/hono)](https://www.npmjs.com/package/hono)
-[![GitHub commit activity](https://img.shields.io/github/commit-activity/m/yusukebe/hono)](https://github.com/yusukebe/hono/pulse)
-[![GitHub last commit](https://img.shields.io/github/last-commit/yusukebe/hono)](https://github.com/yusukebe/hono/commits/master)
+[![GitHub commit activity](https://img.shields.io/github/commit-activity/m/honojs/hono)](https://github.com/honojs/hono/pulse)
+[![GitHub last commit](https://img.shields.io/github/last-commit/honojs/hono)](https://github.com/honojs/hono/commits/master)
 
-Hono - _**[炎] means flame🔥 in Japanese**_ - is small, simple, and ultrafast web framework for Cloudflare Workers and Fastly Compute@Edge.
+Hono - _**[炎] means flame🔥 in Japanese**_ - is a small, simple, and ultrafast web framework for Cloudflare Workers and Service Worker based serverless such as Fastly Compute@Edge.
 
 ```js
 import { Hono } from 'hono'
@@ -37,7 +37,7 @@ app.fire()
 - **Zero-dependencies** - using only Service Worker and Web standard API.
 - **Middleware** - built-in middleware and ability to extend with your own middleware.
 - **TypeScript** - first-class TypeScript support.
-- **Optimized** - for Cloudflare Workers.
+- **Optimized** - for Cloudflare Workers and Fastly Compute@Edge.
 
 ## Benchmark
 
@@ -58,7 +58,42 @@ A demonstration to create an application for Cloudflare Workers with Hono.
 
 ![Demo](https://user-images.githubusercontent.com/10682/151973526-342644f9-71c5-4fee-81f4-64a7558bb192.gif)
 
-Now, the named path parameter has types.
+## Not only fast
+
+Hono is fast. But not only fast.
+
+### Write Less, do more
+
+Built-in middleware make _"**Write Less, do more**"_ in reality. You can use a lot of middleware without writing code from scratch. Below are examples.
+
+- [Basic Authentication](https://github.com/honojs/hono/tree/master/src/middleware/basic-auth/)
+- [Cookie parsing / serializing](https://github.com/honojs/hono/tree/master/src/middleware/cookie/)
+- [CORS](https://github.com/honojs/hono/tree/master/src/middleware/cors/)
+- [ETag](https://github.com/honojs/hono/tree/master/src/middleware/etag/)
+- [GraphQL Server](https://github.com/honojs/hono/tree/master/src/middleware/graphql-server/)
+- [JWT Authentication](https://github.com/honojs/hono/tree/master/src/middleware/jwt/)
+- [Logger](https://github.com/honojs/hono/tree/master/src/middleware/logger/)
+- [Mustache template engine](https://github.com/honojs/hono/tree/master/src/middleware/mustache/) (Only for Cloudflare Workers)
+- [JSON pretty printing](https://github.com/honojs/hono/tree/master/src/middleware/pretty-json/)
+- [Serving static files](https://github.com/honojs/hono/tree/master/src/middleware/serve-static/) (Only for Cloudflare Workers)
+
+You can enable logger and CORS middleware with just this code.
+
+```js
+import { Hono } from 'hono'
+import { cors } from 'hono/cors'
+import { logger } from 'hono/logger'
+
+const app = new Hono()
+app.use('*', cors()).use(logger())
+```
+
+### Developer Experience
+
+And Hono provides fine _"**Developer Experience**"_. Easy access to Request/Response thanks to the `Context` object.
+Above all, Hono is written in TypeScript. So, Hono has _"**Types**"_!
+
+For example, the named path parameters will be literal types.
 
 ![Demo](https://user-images.githubusercontent.com/10682/154179671-9e491597-6778-44ac-a8e6-4483d7ad5393.png)
 
@@ -80,10 +115,10 @@ npm install hono
 
 An instance of `Hono` has these methods.
 
-- app.**HTTP_METHOD**(path, handler)
-- app.**all**(path, handler)
+- app.**HTTP_METHOD**(\[path,\] handler)
+- app.**all**(\[path,\] handler)
 - app.**route**(path)
-- app.**use**(path, middleware)
+- app.**use**(\[path,\] middleware)
 - app.**notFound**(handler)
 - app.**onError**(err, handler)
 - app.**fire**()
@@ -127,6 +162,21 @@ app.get('/post/:date{[0-9]+}/:title{[a-z]+}', (c) => {
 })
 ```
 
+### Chained route
+
+```js
+app
+  .get('/endpoint', (c) => {
+    return c.text('GET /endpoint')
+  })
+  .post((c) => {
+    return c.text('POST /endpoint')
+  })
+  .delete((c) => {
+    return c.text('DELETE /endpoint')
+  })
+```
+
 ### Nested route
 
 ```js
@@ -175,6 +225,9 @@ const app = new Hono()
 
 app.use('*', poweredBy())
 app.use('*', logger())
+// Or you can write:
+// app.use('*', poweredBy()).use(logger())
+
 app.use(
   '/auth/*',
   basicAuth({
@@ -184,7 +237,7 @@ app.use(
 )
 ```
 
-Available built-in middleware is listed on [src/middleware](https://github.com/yusukebe/hono/tree/master/src/middleware).
+Available built-in middleware is listed on [src/middleware](https://github.com/honojs/hono/tree/master/src/middleware).
 
 ### Custom Middleware
 
@@ -419,7 +472,7 @@ Let's write your first code for Cloudflare Workers with Hono.
 **Wrangler 1.x** does not support importing middleware. We recommend two ways:
 
 1. Use [Wragler 2.0 Beta](https://github.com/cloudflare/wrangler2).
-2. Build without webpack 4.x. For example, you can use esbuild. See [the starter template](https://github.com/yusukebe/hono-minimal).
+2. Build without webpack 4.x. For example, you can use esbuild. See [the starter template](https://github.com/honojs/hono-minimal).
 
 ---
 
@@ -489,29 +542,33 @@ npx wrangler@beta publish index.js
 
 ## Starter template
 
-You can start making your Cloudflare Workers application with [the starter template](https://github.com/yusukebe/hono-minimal). It is really minimal using TypeScript, esbuild, and Miniflare.
+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.
 
 ```sh
-wrangler generate my-app https://github.com/yusukebe/hono-minimal
+wrangler generate my-app https://github.com/honojs/hono-minimal
 ```
 
+## Examples
+
+- Hono Examples - <https://github.com/honojs/examples>
+
 ## Related projects
 
 Implementation of the original router `TrieRouter` is inspired by [goblin](https://github.com/bmf-san/goblin). `RegExpRouter` is inspired by [Router::Boom](https://github.com/tokuhirom/Router-Boom). API design is inspired by [express](https://github.com/expressjs/express) and [koa](https://github.com/koajs/koa). [itty-router](https://github.com/kwhitley/itty-router), [Sunder](https://github.com/SunderJS/sunder), and [worktop](https://github.com/lukeed/worktop) are the other routers or frameworks for Cloudflare Workers.
 
-- express <https://github.com/expressjs/express>
-- koa <https://github.com/koajs/koa>
-- itty-router <https://github.com/kwhitley/itty-router>
-- Sunder <https://github.com/SunderJS/sunder>
-- goblin <https://github.com/bmf-san/goblin>
-- worktop <https://github.com/lukeed/worktop>
-- Router::Boom <https://github.com/tokuhirom/Router-Boom>
+- express - <https://github.com/expressjs/express>
+- koa - <https://github.com/koajs/koa>
+- itty-router - <https://github.com/kwhitley/itty-router>
+- Sunder - <https://github.com/SunderJS/sunder>
+- goblin - <https://github.com/bmf-san/goblin>
+- worktop - <https://github.com/lukeed/worktop>
+- Router::Boom - <https://github.com/tokuhirom/Router-Boom>
 
 ## Contributing
 
-Contributions Welcome! You can contribute by the following way.
+Contributions Welcome! You can contribute in the following ways.
 
 - Write or fix documents
 - Write code of middleware
@@ -519,11 +576,9 @@ Contributions Welcome! You can contribute by the following way.
 - Refactor the code
 - etc.
 
-Let's make Hono together!
-
 ## Contributors
 
-Thanks to [all contributors](https://github.com/yusukebe/hono/graphs/contributors)!
+Thanks to [all contributors](https://github.com/honojs/hono/graphs/contributors)!
 
 ## Author
 

package/dist/context.d.ts

@@ -5,15 +5,11 @@ declare type Data = string | ArrayBuffer | ReadableStream;
 export interface Env {
 }
 export declare class Context<RequestParamKeyType = string> {
+    #private;
     req: Request<RequestParamKeyType>;
     res: Response;
     env: Env;
     event: FetchEvent;
-    private _headers;
-    private _status;
-    private _statusText;
-    private _pretty;
-    private _prettySpace;
     render: (template: string, params?: object, options?: object) => Promise<Response>;
     notFound: () => Response | Promise<Response>;
     constructor(req: Request<RequestParamKeyType>, opts?: {

package/dist/context.js

@@ -1,14 +1,30 @@
 "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 _Context_headers, _Context_status, _Context_statusText, _Context_pretty, _Context_prettySpace;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Context = void 0;
 const http_status_1 = require("./utils/http-status");
 const url_1 = require("./utils/url");
 class Context {
     constructor(req, opts) {
-        this._prettySpace = 2;
+        _Context_headers.set(this, void 0);
+        _Context_status.set(this, void 0);
+        _Context_statusText.set(this, void 0);
+        _Context_pretty.set(this, void 0);
+        _Context_prettySpace.set(this, 2);
         this.req = this.initRequest(req);
         Object.assign(this, opts);
-        this._headers = {};
+        __classPrivateFieldSet(this, _Context_headers, {}, "f");
     }
     initRequest(req) {
         req.header = (name) => {
@@ -24,63 +40,51 @@ class Context {
         if (this.res) {
             this.res.headers.set(name, value);
         }
-        this._headers[name] = value;
+        __classPrivateFieldGet(this, _Context_headers, "f")[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);
+        __classPrivateFieldSet(this, _Context_status, status, "f");
+        __classPrivateFieldSet(this, _Context_statusText, (0, http_status_1.getStatusText)(status), "f");
     }
     pretty(prettyJSON, space = 2) {
-        this._pretty = prettyJSON;
-        this._prettySpace = space;
+        __classPrivateFieldSet(this, _Context_pretty, prettyJSON, "f");
+        __classPrivateFieldSet(this, _Context_prettySpace, space, "f");
     }
     newResponse(data, init = {}) {
-        init.status = init.status || this._status || 200;
+        init.status = init.status || __classPrivateFieldGet(this, _Context_status, "f") || 200;
         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() });
+            init.statusText || __classPrivateFieldGet(this, _Context_statusText, "f") || (0, http_status_1.getStatusText)(init.status);
+        init.headers = Object.assign(Object.assign({}, __classPrivateFieldGet(this, _Context_headers, "f")), init.headers);
         return new Response(data, init);
     }
-    body(data, status = this._status, headers = this._headers) {
+    body(data, status = __classPrivateFieldGet(this, _Context_status, "f"), headers = __classPrivateFieldGet(this, _Context_headers, "f")) {
         return this.newResponse(data, {
             status: status,
             headers: headers,
         });
     }
-    text(text, status = this._status, headers = {}) {
+    text(text, status = __classPrivateFieldGet(this, _Context_status, "f"), 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 = {}) {
+    json(object, status = __classPrivateFieldGet(this, _Context_status, "f"), 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)
+        const body = __classPrivateFieldGet(this, _Context_pretty, "f")
+            ? JSON.stringify(object, null, __classPrivateFieldGet(this, _Context_prettySpace, "f"))
             : JSON.stringify(object);
         headers['Content-Type'] || (headers['Content-Type'] = 'application/json; charset=UTF-8');
         return this.body(body, status, headers);
     }
-    html(html, status = this._status, headers = {}) {
+    html(html, status = __classPrivateFieldGet(this, _Context_status, "f"), headers = {}) {
         if (typeof html !== 'string') {
             throw new TypeError('html method arg must be a string!');
         }
@@ -105,3 +109,4 @@ class Context {
     }
 }
 exports.Context = Context;
+_Context_headers = new WeakMap(), _Context_status = new WeakMap(), _Context_statusText = new WeakMap(), _Context_pretty = new WeakMap(), _Context_prettySpace = new WeakMap();

package/dist/hono.d.ts

@@ -7,10 +7,9 @@ declare global {
         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 Handler<RequestParamKeyType = string> = (c: Context<RequestParamKeyType>, 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;
@@ -18,33 +17,35 @@ 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> {
+    <Path extends string>(path: Path, handler: Handler<ParamKeys<Path>>): Hono<Path>;
+    <Path extends T>(handler: Handler<ParamKeys<T>>): Hono<Path>;
+}
+declare const Hono_base: new <T extends string>() => {
+    delete: HandlerInterface<T>;
+    get: HandlerInterface<T>;
+    post: HandlerInterface<T>;
+    put: HandlerInterface<T>;
+    head: HandlerInterface<T>;
+    options: HandlerInterface<T>;
+    patch: HandlerInterface<T>;
+    all: HandlerInterface<T>;
 };
-export declare class Hono extends Hono_base {
+export declare class Hono<P extends string> extends Hono_base<P> {
+    #private;
     readonly routerClass: {
         new (): Router<any>;
     };
     readonly strict: boolean;
-    private router;
-    private middlewareRouters;
-    private tempPath;
-    constructor(init?: Partial<Pick<Hono, 'routerClass' | 'strict'>>);
+    private path;
+    constructor(init?: Partial<Pick<Hono<P>, '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): Hono<P>;
+    use(path: string, middleware: MiddlewareHandler): Hono<P>;
+    use(middleware: MiddlewareHandler): Hono<P>;
+    onError(handler: ErrorHandler): Hono<P>;
+    notFound(handler: NotFoundHandler): Hono<P>;
     private addRoute;
     private matchRoute;
     private dispatch;

package/dist/hono.js

@@ -1,4 +1,16 @@
 "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 _Hono_router, _Hono_middlewareRouters, _Hono_tempPath;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Hono = void 0;
 const compose_1 = require("./compose");
@@ -6,18 +18,19 @@ const context_1 = require("./context");
 const router_1 = 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', 'all'];
+function defineDynamicClass() {
     return class {
-        get methods() {
-            return methods;
-        }
     };
 }
-class Hono extends defineDynamicClass('get', 'post', 'put', 'delete', 'head', 'options', 'patch', 'all') {
+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_middlewareRouters.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 +40,42 @@ 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);
+        methods.map((method) => {
+            this[method] = (arg1, arg2) => {
+                if (typeof arg1 === 'string') {
+                    this.path = arg1;
+                    return this.addRoute(method, this.path, arg2);
+                }
+                return this.addRoute(method, this.path, arg1);
             };
         });
         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_middlewareRouters, [], "f");
+        __classPrivateFieldSet(this, _Hono_tempPath, null, "f");
     }
     route(path) {
         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");
         return newHono;
     }
-    use(path, middleware) {
-        if (middleware.constructor.name !== 'AsyncFunction') {
+    use(arg1, arg2) {
+        let handler;
+        if (typeof arg1 === 'string') {
+            this.path = arg1;
+            handler = arg2;
+        }
+        else {
+            handler = arg1;
+        }
+        if (handler.constructor.name !== 'AsyncFunction') {
             throw new TypeError('middleware must be a async function!');
         }
         const router = new this.routerClass();
-        router.add(router_1.METHOD_NAME_OF_ALL, path, middleware);
-        this.middlewareRouters.push(router);
+        router.add(router_1.METHOD_NAME_OF_ALL, this.path, handler);
+        __classPrivateFieldGet(this, _Hono_middlewareRouters, "f").push(router);
+        return this;
     }
     onError(handler) {
         this.errorHandler = handler;
@@ -59,17 +85,16 @@ 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);
+        __classPrivateFieldGet(this, _Hono_router, "f").add(method, path, handler);
         return this;
     }
     async matchRoute(method, path) {
-        return this.router.match(method, path);
+        return __classPrivateFieldGet(this, _Hono_router, "f").match(method, path);
     }
     async dispatch(request, env, event) {
         const path = (0, url_1.getPathFromURL)(request.url, { strict: this.strict });
@@ -82,7 +107,7 @@ class Hono extends defineDynamicClass('get', 'post', 'put', 'delete', 'head', 'o
         };
         const handler = result ? result.handler : this.notFoundHandler;
         const middleware = [];
-        for (const mr of this.middlewareRouters) {
+        for (const mr of __classPrivateFieldGet(this, _Hono_middlewareRouters, "f")) {
             const mwResult = mr.match(router_1.METHOD_NAME_OF_ALL, path);
             if (mwResult)
                 middleware.push(mwResult.handler);
@@ -119,3 +144,4 @@ class Hono extends defineDynamicClass('get', 'post', 'put', 'delete', 'head', 'o
     }
 }
 exports.Hono = Hono;
+_Hono_router = new WeakMap(), _Hono_middlewareRouters = new WeakMap(), _Hono_tempPath = new WeakMap();

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;
     }

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,51 @@
+"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');
+        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}',
+                },
+            });
+            return;
+        }
+        let authorized = false;
+        let msg = '';
+        try {
+            authorized = await jwt_1.Jwt.verify(parts[1], options.secret, options.alg);
+        }
+        catch (e) {
+            msg = `${e}`;
+        }
+        if (authorized) {
+            return next();
+        }
+        ctx.res = new Response('Unauthorized', {
+            status: 401,
+            statusText: msg,
+            headers: {
+                'WWW-Authenticate': 'Bearer ${options.secret}',
+            },
+        });
+        return;
+    };
+};
+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/utils/buffer.d.ts

@@ -1,2 +1,3 @@
 export declare const equal: (a: ArrayBuffer, b: ArrayBuffer) => boolean;
 export declare const timingSafeEqual: (a: string | object | boolean, b: string | object | boolean, hashFunction?: Function) => Promise<boolean>;
+export declare const bufferToString: (buffer: ArrayBuffer) => string;

package/dist/utils/buffer.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.timingSafeEqual = exports.equal = void 0;
+exports.bufferToString = exports.timingSafeEqual = exports.equal = void 0;
 const crypto_1 = require("../utils/crypto");
 const equal = (a, b) => {
     if (a === b) {
@@ -29,3 +29,11 @@ const timingSafeEqual = async (a, b, hashFunction) => {
     return sa === sb && a === b;
 };
 exports.timingSafeEqual = timingSafeEqual;
+const bufferToString = (buffer) => {
+    if (buffer instanceof ArrayBuffer) {
+        const enc = new TextDecoder('utf-8');
+        return enc.decode(buffer);
+    }
+    return buffer;
+};
+exports.bufferToString = bufferToString;

package/dist/utils/crypto.d.ts

@@ -6,6 +6,4 @@ declare type Data = string | object | boolean;
 export declare const sha256: (data: Data) => Promise<string>;
 export declare const sha1: (data: Data) => Promise<string>;
 export declare const createHash: (data: Data, algorithm: Algorithm) => Promise<string>;
-export declare const encodeBase64: (str: string) => string;
-export declare const decodeBase64: (str: string) => string;
 export {};

package/dist/utils/crypto.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.decodeBase64 = exports.encodeBase64 = exports.createHash = exports.sha1 = exports.sha256 = void 0;
+exports.createHash = exports.sha1 = exports.sha256 = void 0;
 const sha256 = async (data) => {
     const algorithm = { name: 'SHA-256', alias: 'sha256' };
     const hash = await (0, exports.createHash)(data, algorithm);
@@ -34,53 +34,3 @@ const createHash = async (data, algorithm) => {
     }
 };
 exports.createHash = createHash;
-const encodeBase64 = (str) => {
-    if (str === null) {
-        throw new TypeError('1st argument of "encodeBase64" should not be null.');
-    }
-    try {
-        const encoder = new TextEncoder();
-        const bytes = encoder.encode(str);
-        const length = bytes.byteLength;
-        let binary = '';
-        for (let i = 0; i < length; i++) {
-            binary += String.fromCharCode(bytes[i]);
-        }
-        return btoa(binary);
-    }
-    catch (_a) { }
-    try {
-        const { Buffer } = require('buffer');
-        return Buffer.from(str).toString('base64');
-    }
-    catch (e) {
-        console.error('If you want to do "encodeBase64", polyfill "buffer" module.');
-        throw e;
-    }
-};
-exports.encodeBase64 = encodeBase64;
-const decodeBase64 = (str) => {
-    if (str === null) {
-        throw new TypeError('1st argument of "decodeBase64" should not be null.');
-    }
-    try {
-        const text = atob(str);
-        const length = text.length;
-        const bytes = new Uint8Array(length);
-        for (let i = 0; i < length; i++) {
-            bytes[i] = text.charCodeAt(i);
-        }
-        const decoder = new TextDecoder();
-        return decoder.decode(bytes);
-    }
-    catch (_a) { }
-    try {
-        const { Buffer } = require('buffer');
-        return Buffer.from(str, 'base64').toString();
-    }
-    catch (e) {
-        console.error('If you want to do "decodeBase64", polyfill "buffer" module.');
-        throw e;
-    }
-};
-exports.decodeBase64 = decodeBase64;

package/dist/utils/encode.d.ts

@@ -0,0 +1,7 @@
+export declare const encodeBase64: (str: string) => string;
+export declare const decodeBase64: (str: string) => string;
+export declare const encodeBase64URL: (str: string) => string;
+export declare const decodeBase64URL: (str: string) => string;
+export declare const utf8ToUint8Array: (str: string) => Uint8Array;
+export declare const arrayBufferToBase64: (buf: ArrayBuffer) => Promise<string>;
+export declare const arrayBufferToBase64URL: (buf: ArrayBuffer) => Promise<string>;

package/dist/utils/encode.js

@@ -0,0 +1,105 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arrayBufferToBase64URL = exports.arrayBufferToBase64 = exports.utf8ToUint8Array = exports.decodeBase64URL = exports.encodeBase64URL = exports.decodeBase64 = exports.encodeBase64 = void 0;
+const encodeBase64 = (str) => {
+    if (str === null) {
+        throw new TypeError('1st argument of "encodeBase64" should not be null.');
+    }
+    try {
+        const encoder = new TextEncoder();
+        const bytes = encoder.encode(str);
+        return btoa(String.fromCharCode(...bytes));
+    }
+    catch (_a) { }
+    try {
+        const { Buffer } = require('buffer');
+        return Buffer.from(str).toString('base64');
+    }
+    catch (e) {
+        console.error('If you want to do "encodeBase64", polyfill "buffer" module.');
+        throw e;
+    }
+};
+exports.encodeBase64 = encodeBase64;
+const decodeBase64 = (str) => {
+    if (str === null) {
+        throw new TypeError('1st argument of "decodeBase64" should not be null.');
+    }
+    try {
+        const text = atob(str);
+        const bytes = new Uint8Array(text.split('').map((c) => c.charCodeAt(0)));
+        const decoder = new TextDecoder();
+        return decoder.decode(bytes);
+    }
+    catch (_a) { }
+    try {
+        const { Buffer } = require('buffer');
+        return Buffer.from(str, 'base64').toString();
+    }
+    catch (e) {
+        console.error('If you want to do "decodeBase64", polyfill "buffer" module.');
+        throw e;
+    }
+};
+exports.decodeBase64 = decodeBase64;
+const encodeBase64URL = (str) => {
+    return (0, exports.encodeBase64)(str).replace(/=/g, '').replace(/\+/g, '-').replace(/\//g, '_');
+};
+exports.encodeBase64URL = encodeBase64URL;
+const decodeBase64URL = (str) => {
+    const pad = (s) => {
+        const diff = s.length % 4;
+        if (diff === 2) {
+            return `${s}==`;
+        }
+        if (diff === 3) {
+            return `${s}=`;
+        }
+        return s;
+    };
+    return (0, exports.decodeBase64)(pad(str).replace(/-/g, '+').replace('_', '/'));
+};
+exports.decodeBase64URL = decodeBase64URL;
+const utf8ToUint8Array = (str) => {
+    const encoder = new TextEncoder();
+    return encoder.encode(str);
+};
+exports.utf8ToUint8Array = utf8ToUint8Array;
+const arrayBufferToBase64 = async (buf) => {
+    if (typeof btoa === 'function') {
+        return btoa(String.fromCharCode(...new Uint8Array(buf)));
+    }
+    try {
+        const { Buffer } = await Promise.resolve().then(() => __importStar(require('buffer')));
+        return Buffer.from(String.fromCharCode(...new Uint8Array(buf))).toString('base64');
+    }
+    catch (e) { }
+};
+exports.arrayBufferToBase64 = arrayBufferToBase64;
+const arrayBufferToBase64URL = async (buf) => {
+    return (await (0, exports.arrayBufferToBase64)(buf)).replace(/=/g, '').replace(/\+/g, '-').replace(/\//g, '_');
+};
+exports.arrayBufferToBase64URL = arrayBufferToBase64URL;

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

@@ -0,0 +1 @@
+export * as Jwt from './jwt';

package/dist/utils/jwt/index.js

@@ -0,0 +1,27 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Jwt = void 0;
+exports.Jwt = __importStar(require("./jwt"));

package/dist/utils/jwt/jwt.d.ts

@@ -0,0 +1,7 @@
+import { AlgorithmTypes } from './types';
+export declare const sign: (payload: unknown, secret: string, alg?: AlgorithmTypes) => Promise<string>;
+export declare const verify: (token: string, secret: string, alg?: AlgorithmTypes) => Promise<boolean>;
+export declare const decode: (token: string) => {
+    header: any;
+    payload: any;
+};

package/dist/utils/jwt/jwt.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decode = exports.verify = exports.sign = void 0;
+const encode_1 = require("../../utils/encode");
+const types_1 = require("./types");
+const types_2 = require("./types");
+var CryptoKeyFormat;
+(function (CryptoKeyFormat) {
+    CryptoKeyFormat["RAW"] = "raw";
+    CryptoKeyFormat["PKCS8"] = "pkcs8";
+    CryptoKeyFormat["SPKI"] = "spki";
+    CryptoKeyFormat["JWK"] = "jwk";
+})(CryptoKeyFormat || (CryptoKeyFormat = {}));
+var CryptoKeyUsage;
+(function (CryptoKeyUsage) {
+    CryptoKeyUsage["Ecrypt"] = "encrypt";
+    CryptoKeyUsage["Decrypt"] = "decrypt";
+    CryptoKeyUsage["Sign"] = "sign";
+    CryptoKeyUsage["Verify"] = "verify";
+    CryptoKeyUsage["Deriverkey"] = "deriveKey";
+    CryptoKeyUsage["DeriveBits"] = "deriveBits";
+    CryptoKeyUsage["WrapKey"] = "wrapKey";
+    CryptoKeyUsage["UnwrapKey"] = "unwrapKey";
+})(CryptoKeyUsage || (CryptoKeyUsage = {}));
+const param = (name) => {
+    switch (name.toUpperCase()) {
+        case 'HS256':
+            return {
+                name: 'HMAC',
+                hash: {
+                    name: 'SHA-256',
+                },
+            };
+        case 'HS384':
+            return {
+                name: 'HMAC',
+                hash: {
+                    name: 'SHA-384',
+                },
+            };
+        case 'HS512':
+            return {
+                name: 'HMAC',
+                hash: {
+                    name: 'SHA-512',
+                },
+            };
+        default:
+            throw new types_2.JwtAlorithmNotImplemented(name);
+    }
+};
+const signing = async (data, secret, alg = types_1.AlgorithmTypes.HS256) => {
+    const cryptoKey = await crypto.subtle.importKey(CryptoKeyFormat.RAW, (0, encode_1.utf8ToUint8Array)(secret), param(alg), false, [CryptoKeyUsage.Sign]);
+    return await crypto.subtle.sign(param(alg), cryptoKey, (0, encode_1.utf8ToUint8Array)(data));
+};
+const sign = async (payload, secret, alg = types_1.AlgorithmTypes.HS256) => {
+    const encodedPayload = await (0, encode_1.encodeBase64URL)(JSON.stringify(payload));
+    const encodedHeader = await (0, encode_1.encodeBase64URL)(JSON.stringify({ alg, typ: 'JWT' }));
+    const partialToken = `${encodedHeader}.${encodedPayload}`;
+    const signature = await (0, encode_1.arrayBufferToBase64URL)(await signing(partialToken, secret, alg));
+    return `${partialToken}.${signature}`;
+};
+exports.sign = sign;
+const verify = async (token, secret, alg = types_1.AlgorithmTypes.HS256) => {
+    const tokenParts = token.split('.');
+    if (tokenParts.length !== 3) {
+        throw new types_2.JwtTokenInvalid(token);
+    }
+    const { payload } = (0, exports.decode)(token);
+    if (payload.nbf && payload.nbf > Math.floor(Date.now() / 1000)) {
+        throw new types_2.JwtTokenNotBefore(token);
+    }
+    if (payload.exp && payload.exp <= Math.floor(Date.now() / 1000)) {
+        throw new types_2.JwtTokenExpired(token);
+    }
+    const signature = await (0, encode_1.arrayBufferToBase64URL)(await signing(tokenParts.slice(0, 2).join('.'), secret, alg));
+    if (signature !== tokenParts[2]) {
+        throw new types_2.JwtTokenSignatureMismatched(token);
+    }
+    return true;
+};
+exports.verify = verify;
+// eslint-disable-next-line
+const decode = (token) => {
+    try {
+        const [h, p] = token.split('.');
+        const header = JSON.parse((0, encode_1.decodeBase64URL)(h));
+        const payload = JSON.parse((0, encode_1.decodeBase64URL)(p));
+        return {
+            header,
+            payload,
+        };
+    }
+    catch (e) {
+        throw new types_2.JwtTokenInvalid(token);
+    }
+};
+exports.decode = decode;

package/dist/utils/jwt/types.d.ts

@@ -0,0 +1,20 @@
+export declare class JwtAlorithmNotImplemented extends Error {
+    constructor(token: string);
+}
+export declare class JwtTokenInvalid extends Error {
+    constructor(token: string);
+}
+export declare class JwtTokenNotBefore extends Error {
+    constructor(token: string);
+}
+export declare class JwtTokenExpired extends Error {
+    constructor(token: string);
+}
+export declare class JwtTokenSignatureMismatched extends Error {
+    constructor(token: string);
+}
+export declare enum AlgorithmTypes {
+    HS256 = "HS256",
+    HS384 = "HS384",
+    HS512 = "HS512"
+}

package/dist/utils/jwt/types.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AlgorithmTypes = exports.JwtTokenSignatureMismatched = exports.JwtTokenExpired = exports.JwtTokenNotBefore = exports.JwtTokenInvalid = exports.JwtAlorithmNotImplemented = void 0;
+class JwtAlorithmNotImplemented extends Error {
+    constructor(token) {
+        super(`invalid JWT token: ${token}`);
+        this.name = 'JwtAlorithmNotImplemented';
+    }
+}
+exports.JwtAlorithmNotImplemented = JwtAlorithmNotImplemented;
+class JwtTokenInvalid extends Error {
+    constructor(token) {
+        super(`invalid JWT token: ${token}`);
+        this.name = 'JwtTokenInvalid';
+    }
+}
+exports.JwtTokenInvalid = JwtTokenInvalid;
+class JwtTokenNotBefore extends Error {
+    constructor(token) {
+        super(`token (${token}) is being used before it's valid`);
+        this.name = 'JwtTokenNotBefore';
+    }
+}
+exports.JwtTokenNotBefore = JwtTokenNotBefore;
+class JwtTokenExpired extends Error {
+    constructor(token) {
+        super(`token (${token}) expired`);
+        this.name = 'JwtTokenExpired';
+    }
+}
+exports.JwtTokenExpired = JwtTokenExpired;
+class JwtTokenSignatureMismatched extends Error {
+    constructor(token) {
+        super(`token(${token}) signature mismatched`);
+        this.name = 'JwtTokenSignatureMismatched';
+    }
+}
+exports.JwtTokenSignatureMismatched = JwtTokenSignatureMismatched;
+var AlgorithmTypes;
+(function (AlgorithmTypes) {
+    AlgorithmTypes["HS256"] = "HS256";
+    AlgorithmTypes["HS384"] = "HS384";
+    AlgorithmTypes["HS512"] = "HS512";
+})(AlgorithmTypes = exports.AlgorithmTypes || (exports.AlgorithmTypes = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hono",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Ultrafast web framework for Cloudflare Workers.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -23,6 +23,7 @@
     "./cors": "./dist/middleware/cors/index.js",
     "./etag": "./dist/middleware/etag/index.js",
     "./graphql-server": "./dist/middleware/graphql-server/index.js",
+    "./jwt": "./dist/middleware/jwt/index.js",
     "./logger": "./dist/middleware/logger/index.js",
     "./mustache": "./dist/middleware/mustache/index.js",
     "./powered-by": "./dist/middleware/powered-by/index.js",
@@ -52,6 +53,9 @@
       "graphql-server": [
         "./dist/middleware/graphql-server"
       ],
+      "jwt": [
+        "./dist/middleware/jwt"
+      ],
       "logger": [
         "./dist/middleware/logger"
       ],
@@ -82,9 +86,9 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/yusukebe/hono.git"
+    "url": "https://github.com/honojs/hono.git"
   },
-  "homepage": "https://github.com/yusukebe/hono",
+  "homepage": "https://github.com/honojs/hono",
   "keywords": [
     "web",
     "app",
@@ -98,33 +102,33 @@
     "compute@edge"
   ],
   "devDependencies": {
-    "@cloudflare/workers-types": "^3.3.0",
+    "@cloudflare/workers-types": "^3.7.1",
     "@types/crypto-js": "^4.1.1",
-    "@types/jest": "^27.4.0",
+    "@types/jest": "^27.4.1",
     "@types/mustache": "^4.1.2",
-    "@types/node": "^17.0.8",
-    "@typescript-eslint/eslint-plugin": "^5.9.0",
-    "@typescript-eslint/parser": "^5.9.0",
+    "@types/node": "^17.0.29",
+    "@typescript-eslint/eslint-plugin": "^5.21.0",
+    "@typescript-eslint/parser": "^5.21.0",
     "crypto-js": "^4.1.1",
-    "eslint": "^7.26.0",
-    "eslint-config-prettier": "^8.3.0",
-    "eslint-define-config": "^1.2.1",
-    "eslint-import-resolver-typescript": "^2.0.0",
+    "eslint": "^8.14.0",
+    "eslint-config-prettier": "^8.5.0",
+    "eslint-define-config": "^1.4.0",
+    "eslint-import-resolver-typescript": "^2.7.1",
     "eslint-plugin-eslint-comments": "^3.2.0",
-    "eslint-plugin-flowtype": "^5.7.2",
-    "eslint-plugin-import": "^2.20.2",
+    "eslint-plugin-flowtype": "^8.0.3",
+    "eslint-plugin-import": "^2.26.0",
     "eslint-plugin-node": "^11.1.0",
     "form-data": "^4.0.0",
-    "graphql": "^16.3.0",
-    "jest": "^27.4.5",
-    "jest-environment-miniflare": "^2.0.0",
+    "graphql": "^16.4.0",
+    "jest": "27.5.1",
+    "jest-environment-miniflare": "^2.4.0",
     "mustache": "^4.2.0",
-    "prettier": "^2.5.1",
+    "prettier": "^2.6.2",
     "prettier-plugin-md-nocjsp": "^1.2.0",
     "rimraf": "^3.0.2",
-    "ts-jest": "^27.1.2",
-    "tsc-alias": "^1.6.6",
-    "typescript": "^4.5.5"
+    "ts-jest": "^27.1.4",
+    "tsc-alias": "^1.6.7",
+    "typescript": "^4.6.3"
   },
   "engines": {
     "node": ">=11.0.0"