hono 0.5.0 → 0.5.3

package/README.md

@@ -1,4 +1,10 @@
-# Hono
+# Hono\[炎\]
+
+<p>
+<a href="https://github.com/yusukebe/hono/blob/master/README.md">English</a>
+&#x000B7;
+<a href="https://github.com/yusukebe/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)
@@ -8,7 +14,7 @@
 [![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)
 
-Hono[炎] - _**means flame🔥 in Japanese**_ - is small, simple, and ultrafast web framework for Service Worker based serverless applications like Cloudflare Workers and Fastly Compute@Edge.
+Hono[炎] - _**means flame🔥 in Japanese**_ - is small, simple, and ultrafast web framework for Cloudflare Workers and Fastly Compute@Edge.
 
 ```js
 import { Hono } from 'hono'
@@ -22,26 +28,26 @@ app.fire()
 ## Features
 
 - **Ultrafast** - the router does not use linear loops.
-- **Zero-dependencies** - using only Web standard API.
-- **Middleware** - builtin middleware and your own middleware.
+- **Zero-dependencies** - using only Service Worker and Web standard API.
+- **Middleware** - built-in middleware and ability to extend with your own middleware.
 - **Optimized** - for Cloudflare Workers.
 
 ## Benchmark
 
-**Hono is fastest** compared to other routers for Cloudflare Workers.
+**Hono is fastest**, compared to other routers for Cloudflare Workers.
 
 ```plain
-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)
+hono x 809,503 ops/sec ±6.94% (73 runs sampled)
+itty-router x 157,310 ops/sec ±4.31% (87 runs sampled)
+sunder x 328,350 ops/sec ±2.30% (95 runs sampled)
+worktop x 209,758 ops/sec ±4.28% (83 runs sampled)
 Fastest is hono
-✨  Done in 58.29s.
+✨  Done in 60.66s.
 ```
 
 ## Hono in 1 minute
 
-A demonstration to create an application of Cloudflare Workers with Hono.
+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)
 
@@ -53,13 +59,13 @@ Now, the named path parameter has types.
 
 You can install Hono from the npm registry.
 
-```sh
+```
 $ yarn add hono
 ```
 
 or
 
-```sh
+```
 $ npm install hono
 ```
 
@@ -75,6 +81,7 @@ An instance of `Hono` has these methods.
 - app.**onError**(err, handler)
 - app.**fire**()
 - app.**fetch**(request, env, event)
+- app.**request**(path, option)
 
 ## Routing
 
@@ -147,7 +154,9 @@ app.get('/fetch-url', async (c) => {
 
 ## Middleware
 
-### Builtin Middleware
+### Built-in Middleware
+
+Hono has built-in middleware.
 
 ```js
 import { Hono } from 'hono'
@@ -168,7 +177,7 @@ app.use(
 )
 ```
 
-Available builtin middleware are 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/yusukebe/hono/tree/master/src/middleware).
 
 ### Custom Middleware
 
@@ -184,15 +193,13 @@ app.use('*', async (c, next) => {
 // Add a custom header
 app.use('/message/*', async (c, next) => {
   await next()
-  await c.header('x-message', 'This is middleware!')
+  c.header('x-message', 'This is middleware!')
 })
 
 app.get('/message/hello', (c) => c.text('Hello Middleware!'))
 ```
 
-## Error
-
-### Not Found
+## Not Found
 
 `app.notFound` for customizing Not Found Response.
 
@@ -202,7 +209,7 @@ app.notFound((c) => {
 })
 ```
 
-### Error Handling
+## Error Handling
 
 `app.onError` handle the error and return the customized Response.
 
@@ -215,7 +222,7 @@ app.onError((err, c) => {
 
 ## Context
 
-To handle Request and Reponse, you can use Context object.
+To handle Request and Reponse, you can use `Context` object.
 
 ### c.req
 
@@ -275,7 +282,7 @@ new Response('Thank you for comming', {
 
 ### c.text()
 
-Render texts as `Content-Type:text/plain`.
+Render text as `Content-Type:text/plain`.
 
 ```js
 app.get('/say', (c) => {
@@ -305,7 +312,7 @@ app.get('/', (c) => {
 
 ### c.notFound()
 
-Return the `404 Not Found` Response.
+Return the `Not Found` Response.
 
 ```js
 app.get('/notfound', (c) => {
@@ -381,51 +388,74 @@ export default app
 */
 ```
 
+## request
+
+`request` is a useful method for testing.
+
+```js
+test('GET /hello is ok', async () => {
+  const res = await app.request('http://localhost/hello')
+  expect(res.status).toBe(200)
+})
+```
+
 ## Cloudflare Workers with Hono
 
-Using `wrangler` or `miniflare`, you can develop the application locally and publish it with few commands.
+Using [Wrangler](https://developers.cloudflare.com/workers/cli-wrangler/) or [Miniflare](https://miniflare.dev), you can develop the application locally and publish it with few commands.
 
 Let's write your first code for Cloudflare Workers with Hono.
 
-### 1. Install Wrangler
+---
 
-Install Cloudflare Command Line "[Wrangler](https://github.com/cloudflare/wrangler)".
+### Caution
 
-```sh
-$ npm i @cloudflare/wrangler -g
-```
+**Wrangler 1.x** does not support importing middleware. We recommend two ways:
 
-### 2. `npm init`
+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).
+
+---
+
+### 1. `npm init`
 
 Make a npm skeleton directory.
 
-```sh
-mkdir hono-example
-cd hono-example
-npm init -y
+```
+$ mkdir hono-example
+$ cd hono-example
+$ npm init -y
 ```
 
-### 3. `wrangler init`
+### 2. `wrangler init`
 
-Init as a wrangler project.
+Initialize as a wrangler project.
 
-```sh
-$ wrangler init
+```
+$ npx wrangler@beta init
 ```
 
-### 4. `npm install hono`
+Answer the questions. If you want, you can answer `y`.
+
+```
+Would you like to install wrangler into your package.json? (y/n) <--- n
+Would you like to use TypeScript? (y/n) <--- n
+Would you like to create a Worker at src/index.js? (y/n) <--- n
+```
+
+### 3. `npm install hono`
 
 Install `hono` from the npm registry.
 
-```sh
+```
 $ npm i hono
 ```
 
-### 5. Write your app
+### 4. Write your app
 
 Only 4 lines!!
 
 ```js
+// index.js
 import { Hono } from 'hono'
 const app = new Hono()
 
@@ -434,25 +464,25 @@ app.get('/', (c) => c.text('Hello! Hono!'))
 app.fire()
 ```
 
-### 6. Run
+### 5. Run
 
 Run the development server locally. Then, access `http://127.0.0.1:8787/` in your Web browser.
 
-```sh
-$ wrangler dev
+```
+$ npx wrangler@beta dev index.js
 ```
 
-### 7. Publish
+### 6. Publish
 
 Deploy to Cloudflare. That's all!
 
-```sh
-$ wrangler publish
+```
+$ npx wrangler@beta publish index.js
 ```
 
 ## Starter template
 
-You can start making your application of Cloudflare Workers with [the starter template](https://github.com/yusukebe/hono-minimal). It is a realy minimal using TypeScript, esbuild, and Miniflare.
+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.
 
 To generate a project skelton, run this command.
 

package/dist/compose.d.ts

@@ -1,2 +1,2 @@
 import type { ErrorHandler } from './hono';
-export declare const compose: <T>(middleware: Function[], onError?: ErrorHandler) => (context: T, next?: Function) => Promise<T>;
+export declare const compose: <C>(middleware: Function[], onError?: ErrorHandler) => (context: C) => Promise<C>;

package/dist/compose.js

@@ -4,36 +4,31 @@ exports.compose = void 0;
 const context_1 = require("./context");
 // Based on the code in the MIT licensed `koa-compose` package.
 const compose = (middleware, onError) => {
-    return function (context, next) {
+    return function (context) {
         let index = -1;
         return dispatch(0);
         async function dispatch(i) {
-            if (i <= index)
+            if (i === middleware.length) {
+                return context;
+            }
+            if (i <= index) {
                 return Promise.reject(new Error('next() called multiple times'));
+            }
+            const handler = middleware[i];
             index = i;
-            let fn = middleware[i];
-            if (i === middleware.length)
-                fn = next;
-            if (!fn)
+            return Promise.resolve(handler(context, dispatch.bind(null, i + 1)))
+                .then(() => {
                 return context;
-            try {
-                return Promise.resolve(fn(context, dispatch.bind(null, i + 1)))
-                    .then(() => {
+            })
+                .catch((err) => {
+                if (onError && context instanceof context_1.Context) {
+                    context.res = onError(err, context);
                     return context;
-                })
-                    .catch((err) => {
-                    if (onError && context instanceof context_1.Context) {
-                        context.res = onError(err, context);
-                        return context;
-                    }
-                    else {
-                        throw err;
-                    }
-                });
-            }
-            catch (err) {
-                return Promise.reject(err);
-            }
+                }
+                else {
+                    throw err;
+                }
+            });
         }
     };
 };

package/dist/context.js

@@ -35,8 +35,8 @@ class Context {
         this._statusText = (0, http_status_1.getStatusText)(number);
     }
     newResponse(data, init = {}) {
-        init.status = init.status || this._status;
-        init.statusText = init.statusText || this._statusText;
+        init.status = init.status || this._status || 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;

package/dist/hono.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="@cloudflare/workers-types" />
 import { Context } from './context';
 import type { Env } from './context';
-import type { Result, Router } from './router';
+import type { Router } from './router';
 declare global {
     interface Request<ParamKeyType = string> {
         param: (key: ParamKeyType) => string;
@@ -26,8 +26,8 @@ export declare class Hono {
     middlewareRouters: Router<MiddlewareHandler>[];
     tempPath: string;
     constructor(init?: Partial<Pick<Hono, 'routerClass' | 'strict'>>);
-    notFoundHandler: NotFoundHandler;
-    errorHandler: ErrorHandler;
+    private notFoundHandler;
+    private errorHandler;
     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;
@@ -40,11 +40,12 @@ export declare class Hono {
     use(path: string, middleware: MiddlewareHandler): void;
     onError(handler: ErrorHandler): Hono;
     notFound(handler: NotFoundHandler): Hono;
-    addRoute(method: string, path: string, handler: Handler): Hono;
-    matchRoute(method: string, path: string): Promise<Result<Handler>>;
+    private addRoute;
+    private matchRoute;
     dispatch(request: Request, env?: Env, event?: FetchEvent): Promise<Response>;
     handleEvent(event: FetchEvent): Promise<Response>;
     fetch(request: Request, env?: Env, event?: FetchEvent): Promise<Response>;
+    request(input: RequestInfo, requestInit?: RequestInit): Promise<Response>;
     fire(): void;
 }
 export {};

package/dist/hono.js

@@ -128,6 +128,10 @@ class Hono {
     async fetch(request, env, event) {
         return this.dispatch(request, env, event);
     }
+    request(input, requestInit) {
+        const req = new Request(input, requestInit);
+        return this.dispatch(req);
+    }
     fire() {
         addEventListener('fetch', (event) => {
             event.respondWith(this.handleEvent(event));

package/dist/middleware/basic-auth/basic-auth.d.ts

@@ -3,6 +3,7 @@ export declare const basicAuth: (options: {
     username: string;
     password: string;
     realm?: string;
+    hashFunction?: Function;
 }, ...users: {
     username: string;
     password: string;

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

@@ -2,6 +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 CREDENTIALS_REGEXP = /^ *(?:[Bb][Aa][Ss][Ii][Cc]) +([A-Za-z0-9._~+/-]+=*) *$/;
 const USER_PASS_REGEXP = /^([^:]*):(.*)$/;
 const auth = (req) => {
@@ -18,7 +19,7 @@ const auth = (req) => {
     if (!match) {
         return undefined;
     }
-    const userPass = USER_PASS_REGEXP.exec((0, buffer_1.decodeBase64)(match[1]));
+    const userPass = USER_PASS_REGEXP.exec((0, crypto_1.decodeBase64)(match[1]));
     if (!userPass) {
         return undefined;
     }
@@ -36,8 +37,8 @@ const basicAuth = (options, ...users) => {
         const requestUser = auth(ctx.req);
         if (requestUser) {
             for (const user of users) {
-                const usernameEqual = await (0, buffer_1.timingSafeEqual)(user.username, requestUser.username);
-                const passwordEqual = await (0, buffer_1.timingSafeEqual)(user.password, requestUser.password);
+                const usernameEqual = await (0, buffer_1.timingSafeEqual)(user.username, requestUser.username, options.hashFunction);
+                const passwordEqual = await (0, buffer_1.timingSafeEqual)(user.password, requestUser.password, options.hashFunction);
                 if (usernameEqual && passwordEqual) {
                     // Authorized OK
                     return next();

package/dist/middleware/body-parse/body-parse.js

@@ -1,26 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.bodyParse = void 0;
+const body_1 = require("../../utils/body");
 const bodyParse = () => {
     return async (ctx, next) => {
-        const contentType = ctx.req.headers.get('Content-Type') || '';
-        if (contentType.includes('application/json')) {
-            ctx.req.parsedBody = await ctx.req.json();
-        }
-        else if (contentType.includes('application/text')) {
-            ctx.req.parsedBody = await ctx.req.text();
-        }
-        else if (contentType.includes('text/html')) {
-            ctx.req.parsedBody = await ctx.req.text();
-        }
-        else if (contentType.includes('form')) {
-            const form = {};
-            const data = [...(await ctx.req.formData())].reduce((acc, cur) => {
-                acc[cur[0]] = cur[1];
-                return acc;
-            }, form);
-            ctx.req.parsedBody = data;
-        }
+        ctx.req.parsedBody = await (0, body_1.parseBody)(ctx.req);
         await next();
     };
 };

package/dist/middleware/etag/etag.d.ts

@@ -0,0 +1,6 @@
+import type { Context } from '../../context';
+declare type ETagOptions = {
+    weak: boolean;
+};
+export declare const etag: (options?: ETagOptions) => (c: Context, next: Function) => Promise<void>;
+export {};

package/dist/middleware/etag/etag.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.etag = void 0;
+const crypto_1 = require("../../utils/crypto");
+const body_1 = require("../../utils/body");
+const etag = (options = { weak: false }) => {
+    return async (c, next) => {
+        const ifNoneMatch = c.req.header('If-None-Match') || c.req.header('if-none-match');
+        await next();
+        const clone = c.res.clone();
+        const body = await (0, body_1.parseBody)(c.res);
+        const hash = await (0, crypto_1.sha1)(body);
+        const etag = options.weak ? `W/"${hash}"` : `"${hash}"`;
+        if (ifNoneMatch && ifNoneMatch === etag) {
+            await clone.blob(); // Force using body
+            c.res = new Response(null, {
+                status: 304,
+                statusText: 'Not Modified',
+            });
+            c.res.headers.delete('Content-Length');
+        }
+        else {
+            c.res = new Response(clone.body, clone);
+            c.res.headers.append('ETag', etag);
+        }
+    };
+};
+exports.etag = etag;

package/dist/utils/body.d.ts

@@ -0,0 +1 @@
+export declare const parseBody: (r: Request | Response) => Promise<string | object | Record<string, string | File>>;

package/dist/utils/body.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseBody = void 0;
+const parseBody = async (r) => {
+    const contentType = r.headers.get('Content-Type') || '';
+    if (contentType.includes('application/json')) {
+        return await r.json();
+    }
+    else if (contentType.includes('application/text')) {
+        return r.text();
+    }
+    else if (contentType.startsWith('text')) {
+        return r.text();
+    }
+    else if (contentType.includes('form')) {
+        const form = {};
+        const data = [...(await r.formData())].reduce((acc, cur) => {
+            acc[cur[0]] = cur[1];
+            return acc;
+        }, form);
+        return data;
+    }
+};
+exports.parseBody = parseBody;

package/dist/utils/buffer.d.ts

@@ -1,4 +1,2 @@
 export declare const equal: (a: ArrayBuffer, b: ArrayBuffer) => boolean;
-export declare const decodeBase64: (str: string) => any;
-export declare const sha256: (a: string | object | boolean) => Promise<string>;
-export declare const timingSafeEqual: (a: string | object | boolean, b: string | object | boolean) => Promise<boolean>;
+export declare const timingSafeEqual: (a: string | object | boolean, b: string | object | boolean, hashFunction?: Function) => Promise<boolean>;

package/dist/utils/buffer.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.timingSafeEqual = exports.sha256 = exports.decodeBase64 = exports.equal = void 0;
+exports.timingSafeEqual = exports.equal = void 0;
+const crypto_1 = require("./crypto");
 const equal = (a, b) => {
     if (a === b) {
         return true;
@@ -19,52 +20,12 @@ const equal = (a, b) => {
     return true;
 };
 exports.equal = equal;
-const decodeBase64 = (str) => {
-    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;
-const sha256 = async (a) => {
-    if (crypto && crypto.subtle) {
-        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('');
-        return hash;
-    }
-    try {
-        const crypto = require('crypto');
-        const hash = crypto.createHash('sha256').update(a).digest('hex');
-        return hash;
+const timingSafeEqual = async (a, b, hashFunction) => {
+    if (!hashFunction) {
+        hashFunction = crypto_1.sha256;
     }
-    catch (e) {
-        console.error('If you want to do "sha256", polyfill "crypto" module.');
-        throw e;
-    }
-};
-exports.sha256 = sha256;
-const timingSafeEqual = async (a, b) => {
-    const sa = await (0, exports.sha256)(a);
-    const sb = await (0, exports.sha256)(b);
+    const sa = await hashFunction(a);
+    const sb = await hashFunction(b);
     return sa === sb && a === b;
 };
 exports.timingSafeEqual = timingSafeEqual;

package/dist/utils/crypto.d.ts

@@ -0,0 +1,10 @@
+declare type Algorithm = {
+    name: string;
+    alias: string;
+};
+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 decodeBase64: (str: string) => any;
+export {};

package/dist/utils/crypto.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeBase64 = 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);
+    return hash;
+};
+exports.sha256 = sha256;
+const sha1 = async (data) => {
+    const algorithm = { name: 'SHA-1', alias: 'sha1' };
+    const hash = await (0, exports.createHash)(data, algorithm);
+    return hash;
+};
+exports.sha1 = sha1;
+const createHash = async (data, algorithm) => {
+    if (crypto && crypto.subtle) {
+        const buffer = await crypto.subtle.digest({
+            name: algorithm.name,
+        }, new TextEncoder().encode(String(data)));
+        const hash = Array.prototype.map
+            .call(new Uint8Array(buffer), (x) => ('00' + x.toString(16)).slice(-2))
+            .join('');
+        return hash;
+    }
+    try {
+        const crypto = require('crypto');
+        const hash = crypto.createHash(algorithm.alias).update(data).digest('hex');
+        return hash;
+    }
+    catch (e) {
+        console.error(`If you want to create hash ${algorithm.name}, polyfill "crypto" module.`);
+        throw e;
+    }
+};
+exports.createHash = createHash;
+const decodeBase64 = (str) => {
+    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/mime.js

@@ -4,11 +4,10 @@ exports.getMimeType = void 0;
 const getMimeType = (filename) => {
     const regexp = /\.([a-zA-Z0-9]+?)$/;
     const match = filename.match(regexp);
-    if (!match) {
+    if (!match)
         return;
-    }
     let mimeType = mimes[match[1]];
-    if (mimeType.startsWith('text') || mimeType === 'application/json') {
+    if ((mimeType && mimeType.startsWith('text')) || mimeType === 'application/json') {
         mimeType += '; charset=utf-8';
     }
     return mimeType;
@@ -43,6 +42,7 @@ const mimes = {
     js: 'text/javascript',
     json: 'application/json',
     jsonld: 'application/ld+json',
+    map: 'application/json',
     mid: 'audio/x-midi',
     midi: 'audio/x-midi',
     mjs: 'text/javascript',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hono",
-  "version": "0.5.0",
+  "version": "0.5.3",
   "description": "[炎] Ultrafast web framework for Cloudflare Workers.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -78,11 +78,13 @@
   ],
   "devDependencies": {
     "@cloudflare/workers-types": "^3.3.0",
+    "@types/crypto-js": "^4.1.1",
     "@types/jest": "^27.4.0",
     "@types/mustache": "^4.1.2",
     "@types/node": "^17.0.8",
     "@typescript-eslint/eslint-plugin": "^5.9.0",
     "@typescript-eslint/parser": "^5.9.0",
+    "crypto-js": "^4.1.1",
     "eslint": "^7.26.0",
     "eslint-config-prettier": "^8.3.0",
     "eslint-define-config": "^1.2.1",
@@ -96,6 +98,7 @@
     "jest-environment-miniflare": "^2.0.0",
     "mustache": "^4.2.0",
     "prettier": "^2.5.1",
+    "prettier-plugin-md-nocjsp": "^1.2.0",
     "rimraf": "^3.0.2",
     "ts-jest": "^27.1.2",
     "typescript": "^4.5.5"