hono 2.0.7 → 2.1.0

package/README.md

@@ -21,6 +21,7 @@
 [![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/main)
 [![Deno badge](https://img.shields.io/endpoint?url=https%3A%2F%2Fdeno-visualizer.danopia.net%2Fshields%2Flatest-version%2Fx%2Fhono%2Fmod.ts)](https://doc.deno.land/https/deno.land/x/hono/mod.ts)
+[![Discord badge](https://img.shields.io/discord/1011308539819597844?label=Discord&logo=Discord)](https://discord.gg/KVYKWmfD)
 
 Hono - _**[炎] means flame🔥 in Japanese**_ - is a small, simple, and ultrafast web framework for Cloudflare Workers, Deno, Bun, and others.
 
@@ -46,13 +47,13 @@ export default app
 **Hono is fastest**, compared to other routers for Cloudflare Workers.
 
 ```plain
-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)
+hono - trie-router(default) x 437,354 ops/sec ±4.58% (83 runs sampled)
+hono - regexp-router x 535,157 ops/sec ±3.46% (83 runs sampled)
+itty-router x 203,092 ops/sec ±3.64% (89 runs sampled)
+sunder x 308,252 ops/sec ±2.17% (91 runs sampled)
+worktop x 190,764 ops/sec ±3.11% (86 runs sampled)
 Fastest is hono - regexp-router
-✨  Done in 43.56s.
+✨  Done in 38.26s.
 ```
 
 ## Documentation
@@ -63,6 +64,10 @@ The documentation is available on [honojs.dev](https://honojs.dev).
 
 Migration guide is available on [docs/MIGRATION.md](docs/MIGRATION.md).
 
+## Communication
+
+[Twitter](https://twitter.com/honojs) and [Discord channel](https://discord.gg/KVYKWmfD) are available.
+
 ## Contributing
 
 Contributions Welcome! You can contribute in the following ways.

package/dist/compose.d.ts

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

package/dist/compose.js

@@ -4,42 +4,45 @@ exports.compose = void 0;
 const context_1 = require("./context");
 // Based on the code in the MIT licensed `koa-compose` package.
 const compose = (middleware, onError, onNotFound) => {
+    const middlewareLength = middleware.length;
     return (context, next) => {
         let index = -1;
         return dispatch(0);
         async function dispatch(i) {
             if (i <= index) {
-                return Promise.reject(new Error('next() called multiple times'));
+                throw new Error('next() called multiple times');
             }
             let handler = middleware[i];
             index = i;
-            if (i === middleware.length && next)
+            if (i === middlewareLength && next)
                 handler = next;
             if (!handler) {
                 if (context instanceof context_1.HonoContext && context.finalized === false && onNotFound) {
                     context.res = await onNotFound(context);
                 }
-                return Promise.resolve(context);
-            }
-            return Promise.resolve(handler(context, () => dispatch(i + 1)))
-                .then((res) => {
-                // If handler return Response like `return c.text('foo')`
-                if (res && context instanceof context_1.HonoContext) {
-                    context.res = res;
-                }
                 return context;
-            })
-                .catch((err) => {
+            }
+            let res;
+            let isError = false;
+            try {
+                const tmp = handler(context, () => dispatch(i + 1));
+                res = tmp instanceof Promise ? await tmp : tmp;
+            }
+            catch (err) {
                 if (context instanceof context_1.HonoContext && onError) {
                     if (err instanceof Error) {
-                        context.res = onError(err, context);
+                        isError = true;
+                        res = onError(err, context);
                     }
-                    return context;
                 }
-                else {
+                if (!res) {
                     throw err;
                 }
-            });
+            }
+            if (res && context instanceof context_1.HonoContext && (!context.finalized || isError)) {
+                context.res = res;
+            }
+            return context;
         }
     };
 };

package/dist/context.d.ts

@@ -1,13 +1,12 @@
 /// <reference types="@cloudflare/workers-types" />
-import type { ContextVariableMap, NotFoundHandler } from './hono';
+import type { Environment, NotFoundHandler, ContextVariableMap, Bindings } from './hono';
 import type { CookieOptions } from './utils/cookie';
 import type { StatusCode } from './utils/http-status';
 declare type Headers = Record<string, string>;
 export declare type Data = string | ArrayBuffer | ReadableStream;
-declare type Env = Record<string, any>;
-export interface Context<RequestParamKeyType extends string = string, E = Env> {
+export interface Context<RequestParamKeyType extends string = string, E extends Partial<Environment> = Environment> {
     req: Request<RequestParamKeyType>;
-    env: E;
+    env: E['Bindings'] | Bindings;
     event: FetchEvent;
     executionCtx: ExecutionContext;
     finalized: boolean;
@@ -17,10 +16,12 @@ export interface Context<RequestParamKeyType extends string = string, E = Env> {
     status: (status: StatusCode) => void;
     set: {
         <Key extends keyof ContextVariableMap>(key: Key, value: ContextVariableMap[Key]): void;
+        <Key extends keyof E['Variables']>(key: Key, value: E['Variables'][Key]): void;
         (key: string, value: any): void;
     };
     get: {
         <Key extends keyof ContextVariableMap>(key: Key): ContextVariableMap[Key];
+        <Key extends keyof E['Variables']>(key: Key): E['Variables'][Key];
         <T = any>(key: string): T;
     };
     pretty: (prettyJSON: boolean, space?: number) => void;
@@ -33,9 +34,9 @@ export interface Context<RequestParamKeyType extends string = string, E = Env> {
     cookie: (name: string, value: string, options?: CookieOptions) => void;
     notFound: () => Response | Promise<Response>;
 }
-export declare class HonoContext<RequestParamKeyType extends string = string, E = Env> implements Context<RequestParamKeyType, E> {
+export declare class HonoContext<RequestParamKeyType extends string = string, E extends Partial<Environment> = Environment> implements Context<RequestParamKeyType, E> {
     req: Request<RequestParamKeyType>;
-    env: E;
+    env: Environment['Bindings'];
     finalized: boolean;
     _status: StatusCode;
     private _executionCtx;
@@ -45,15 +46,19 @@ export declare class HonoContext<RequestParamKeyType extends string = string, E
     private _headers;
     private _res;
     private notFoundHandler;
-    constructor(req: Request, env?: E | undefined, executionCtx?: FetchEvent | ExecutionContext | undefined, notFoundHandler?: NotFoundHandler);
+    constructor(req: Request, env?: E['Bindings'] | undefined, executionCtx?: FetchEvent | ExecutionContext | undefined, notFoundHandler?: NotFoundHandler);
     get event(): FetchEvent;
     get executionCtx(): ExecutionContext;
     get res(): Response;
     set res(_res: Response);
     header(name: string, value: string): void;
     status(status: StatusCode): void;
+    set<Key extends keyof ContextVariableMap>(key: Key, value: ContextVariableMap[Key]): void;
+    set<Key extends keyof E['Variables']>(key: Key, value: E['Variables'][Key]): void;
     set(key: string, value: any): void;
-    get(key: string): any;
+    get<Key extends keyof ContextVariableMap>(key: Key): ContextVariableMap[Key];
+    get<Key extends keyof E['Variables']>(key: Key): E['Variables'][Key];
+    get<T = any>(key: string): T;
     pretty(prettyJSON: boolean, space?: number): void;
     newResponse(data: Data | null, status: StatusCode, headers?: Headers): Response;
     body(data: Data | null, status?: StatusCode, headers?: Headers): Response;

package/dist/context.js

@@ -39,7 +39,7 @@ class HonoContext {
     }
     header(name, value) {
         this._headers || (this._headers = {});
-        this._headers[name] = value;
+        this._headers[name.toLowerCase()] = value;
         if (this.finalized) {
             this.res.headers.set(name, value);
         }
@@ -62,7 +62,7 @@ class HonoContext {
         this._prettySpace = space;
     }
     newResponse(data, status, headers = {}) {
-        const _headers = { ...this._headers, ...headers };
+        const _headers = { ...this._headers };
         if (this._res) {
             this._res.headers.forEach((v, k) => {
                 _headers[k] = v;
@@ -70,25 +70,25 @@ class HonoContext {
         }
         return new Response(data, {
             status: status || this._status || 200,
-            headers: _headers,
+            headers: { ..._headers, ...headers },
         });
     }
     body(data, status = this._status, headers = {}) {
         return this.newResponse(data, status, headers);
     }
     text(text, status = this._status, headers = {}) {
-        headers['Content-Type'] || (headers['Content-Type'] = 'text/plain; charset=UTF-8');
+        headers['content-type'] = 'text/plain; charset=UTF-8';
         return this.body(text, status, headers);
     }
     json(object, status = this._status, headers = {}) {
         const body = this._pretty
             ? JSON.stringify(object, null, this._prettySpace)
             : JSON.stringify(object);
-        headers['Content-Type'] || (headers['Content-Type'] = 'application/json; charset=UTF-8');
+        headers['content-type'] = 'application/json; charset=UTF-8';
         return this.body(body, status, headers);
     }
     html(html, status = this._status, headers = {}) {
-        headers['Content-Type'] || (headers['Content-Type'] = 'text/html; charset=UTF-8');
+        headers['content-type'] = 'text/html; charset=UTF-8';
         return this.body(html, status, headers);
     }
     redirect(location, status = 302) {
@@ -103,7 +103,7 @@ class HonoContext {
     }
     cookie(name, value, opt) {
         const cookie = (0, cookie_1.serialize)(name, value, opt);
-        this.header('Set-Cookie', cookie);
+        this.header('set-cookie', cookie);
     }
     notFound() {
         return this.notFoundHandler(this);

package/dist/hono.d.ts

@@ -3,26 +3,31 @@ import type { Context } from './context';
 import type { Router } from './router';
 export interface ContextVariableMap {
 }
-declare type Env = Record<string, any>;
-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 | Promise<Response>;
-export declare type ErrorHandler<E = Env> = (err: Error, c: Context<string, E>) => Response;
+export declare type Bindings = Record<string, any>;
+export declare type Variables = Record<string, any>;
+export declare type Environment = {
+    Bindings: Bindings;
+    Variables: Variables;
+};
+export declare type Handler<RequestParamKeyType extends string = string, E extends Partial<Environment> = Environment> = (c: Context<RequestParamKeyType, E>, next: Next) => Response | Promise<Response> | Promise<void> | Promise<Response | undefined>;
+export declare type NotFoundHandler<E extends Partial<Environment> = Environment> = (c: Context<string, E>) => Response | Promise<Response>;
+export declare type ErrorHandler<E extends Partial<Environment> = Environment> = (err: Error, c: Context<string, E>) => Response;
 export declare type Next = () => Promise<void>;
 declare type ParamKeyName<NameWithPattern> = NameWithPattern extends `${infer Name}{${infer _Pattern}` ? Name : NameWithPattern;
 declare type ParamKey<Component> = Component extends `:${infer NameWithPattern}` ? ParamKeyName<NameWithPattern> : never;
 declare type ParamKeys<Path> = Path extends `${infer Component}/${infer Rest}` ? ParamKey<Component> | ParamKeys<Rest> : ParamKey<Path>;
-interface HandlerInterface<T extends string, E extends Env = Env, U = Hono<E, T>> {
+interface HandlerInterface<T extends string, E extends Partial<Environment> = Environment, U = Hono<E, T>> {
     <Path extends string>(path: Path, ...handlers: Handler<ParamKeys<Path> extends never ? string : ParamKeys<Path>, E>[]): U;
     (path: string, ...handlers: Handler<string, E>[]): U;
     <Path extends string>(...handlers: Handler<ParamKeys<Path> extends never ? string : ParamKeys<Path>, E>[]): U;
     (...handlers: Handler<string, E>[]): U;
 }
-interface Route<E extends Env> {
+interface Route<E extends Partial<Environment> = Environment> {
     path: string;
     method: string;
     handler: Handler<string, E>;
 }
-declare const Hono_base: new <E_1 extends Env, T extends string, U>() => {
+declare const Hono_base: new <E_1 extends Partial<Environment> = Environment, T extends string = string, U = Hono<Environment, "/">>() => {
     all: HandlerInterface<T, E_1, U>;
     get: HandlerInterface<T, E_1, U>;
     post: HandlerInterface<T, E_1, U>;
@@ -32,7 +37,10 @@ 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 extends Env = Env, P extends string = '/'> extends Hono_base<E, P, Hono<E, P>> {
+export declare class Hono<E extends {
+    Bindings?: Bindings;
+    Variables?: Variables;
+} = Environment, P extends string = '/'> extends Hono_base<E, P, Hono<E, P>> {
     readonly router: Router<Handler<string, E>>;
     readonly strict: boolean;
     private _tempPath;
@@ -44,13 +52,13 @@ export declare class Hono<E extends Env = Env, P extends string = '/'> extends H
     route(path: string, app?: Hono<any>): Hono<E, P>;
     use(path: string, ...middleware: Handler<string, E>[]): Hono<E, P>;
     use(...middleware: Handler<string, E>[]): Hono<E, P>;
-    onError(handler: ErrorHandler<E>): Hono<E, P>;
-    notFound(handler: NotFoundHandler<E>): Hono<E, P>;
+    onError(handler: ErrorHandler): Hono<E, P>;
+    notFound(handler: NotFoundHandler): Hono<E, P>;
     private addRoute;
     private matchRoute;
     private dispatch;
     handleEvent(event: FetchEvent): Promise<Response>;
-    fetch: (request: Request, env?: E, executionCtx?: ExecutionContext) => Promise<Response>;
+    fetch: (request: Request, Environment?: E["Bindings"] | undefined, executionCtx?: ExecutionContext | undefined) => Promise<Response>;
     request(input: RequestInfo, requestInit?: RequestInit): Promise<Response>;
 }
 export {};

package/dist/hono.js

@@ -29,8 +29,8 @@ class Hono extends defineDynamicClass() {
             const message = 'Internal Server Error';
             return c.text(message, 500);
         };
-        this.fetch = (request, env, executionCtx) => {
-            return this.dispatch(request, executionCtx, env);
+        this.fetch = (request, Environment, executionCtx) => {
+            return this.dispatch(request, executionCtx, Environment);
         };
         (0, request_1.extendRequestPrototype)();
         const allMethods = [...methods, router_1.METHOD_NAME_ALL_LOWERCASE];

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 /// <reference path="request.d.ts" />
 import { Hono } from './hono';
-export type { Handler, Next } from './hono';
+export type { Handler, Next, ContextVariableMap } from './hono';
 export type { Context } from './context';
 declare module './hono' {
     interface Hono {

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

@@ -4,5 +4,5 @@ declare type EncodingType = 'gzip' | 'deflate';
 interface CompressionOptions {
     encoding?: EncodingType;
 }
-export declare const compress: (options?: CompressionOptions) => (ctx: Context, next: Next) => Promise<void>;
+export declare const compress: (options?: CompressionOptions | undefined) => (ctx: Context, next: Next) => Promise<void>;
 export {};

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

@@ -8,5 +8,5 @@ declare type CORSOptions = {
     credentials?: boolean;
     exposeHeaders?: string[];
 };
-export declare const cors: (options?: CORSOptions) => (c: Context, next: Next) => Promise<void>;
+export declare const cors: (options?: CORSOptions | undefined) => (c: Context, next: Next) => Promise<void>;
 export {};

package/dist/middleware/etag/index.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.etag = void 0;
-const body_1 = require("../../utils/body");
 const crypto_1 = require("../../utils/crypto");
 const etag = (options = { weak: false }) => {
     return async (c, next) => {
@@ -9,8 +8,7 @@ const etag = (options = { weak: false }) => {
         await next();
         const res = c.res;
         const clone = res.clone();
-        const body = await (0, body_1.parseBody)(res);
-        const hash = await (0, crypto_1.sha1)(body);
+        const hash = await (0, crypto_1.sha1)(res.body || '');
         const etag = options.weak ? `W/"${hash}"` : `"${hash}"`;
         if (ifNoneMatch && ifNoneMatch === etag) {
             await clone.blob(); // Force using body

package/dist/middleware/serve-static/module.d.mts

@@ -1,5 +1,3 @@
 import type { ServeStaticOptions } from './serve-static';
-declare const module: (options?: ServeStaticOptions) => import("../../hono").Handler<string, {
-    [x: string]: any;
-}>;
+declare const module: (options?: ServeStaticOptions) => import("../../hono").Handler<string, import("../../hono").Environment>;
 export { module as serveStatic };

package/dist/request.d.ts

@@ -1,4 +1,3 @@
-import type { Body } from './utils/body';
 import type { Cookie } from './utils/cookie';
 declare global {
     interface Request<ParamKeyType extends string = string> {
@@ -23,9 +22,9 @@ declare global {
             (name: string): string;
             (): Cookie;
         };
-        parsedBody?: Promise<Body>;
+        parsedBody?: Promise<Record<string, string | File>>;
         parseBody: {
-            (): Promise<Body>;
+            (): Promise<Record<string, string | File>>;
         };
     }
 }

package/dist/request.js

@@ -69,10 +69,15 @@ function extendRequestPrototype() {
         }
     };
     Request.prototype.parseBody = function () {
+        let body;
         if (!this.parsedBody) {
-            this.parsedBody = (0, body_1.parseBody)(this);
+            body = (0, body_1.parseBody)(this);
+            this.parsedBody = body;
         }
-        return this.parsedBody;
+        else {
+            body = this.parsedBody;
+        }
+        return body;
     };
 }
 exports.extendRequestPrototype = extendRequestPrototype;

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

@@ -80,14 +80,13 @@ class Node {
         var _a, _b;
         return ((_a = node.handlerSetCache)[_b = `${method}:${wildcard ? '1' : '0'}`] || (_a[_b] = (() => {
             const handlerSets = [];
-            node.methods.map((m) => {
+            for (let i = 0, len = node.methods.length; i < len; i++) {
+                const m = node.methods[i];
                 const handlerSet = m[method] || m[router_1.METHOD_NAME_ALL];
                 if (handlerSet !== undefined) {
-                    const hs = { ...handlerSet };
-                    handlerSets.push(hs);
-                    return;
+                    handlerSets.push(handlerSet);
                 }
-            });
+            }
             return handlerSets;
         })()));
     }
@@ -115,7 +114,9 @@ class Node {
                         handlerSets.push(...this.getHandlerSets(nextNode, method));
                         matched = true;
                     }
-                    tempNodes.push(nextNode);
+                    else {
+                        tempNodes.push(nextNode);
+                    }
                 }
                 for (let k = 0, len3 = node.patterns.length; k < len3; k++) {
                     const pattern = node.patterns[k];
@@ -139,7 +140,9 @@ class Node {
                             if (isLast === true) {
                                 handlerSets.push(...this.getHandlerSets(node.children[key], method));
                             }
-                            tempNodes.push(node.children[key]);
+                            else {
+                                tempNodes.push(node.children[key]);
+                            }
                         }
                         // '/book/a'     => not-slug
                         // '/book/:slug' => slug
@@ -148,13 +151,17 @@ class Node {
                         if (typeof name === 'string' && !matched) {
                             params[name] = part;
                         }
+                        break;
                     }
                 }
             }
             curNodes = tempNodes;
         }
-        if (handlerSets.length <= 0)
+        const len = handlerSets.length;
+        if (len === 0)
             return null;
+        if (len === 1)
+            return { handlers: [handlerSets[0].handler], params };
         const handlers = handlerSets
             .sort((a, b) => {
             return a.score - b.score;

package/dist/utils/body.d.ts

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

package/dist/utils/body.js

@@ -1,31 +1,18 @@
 "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')) {
-        let body = {};
-        try {
-            body = await r.json();
-        }
-        catch { } // Do nothing
-        return body;
-    }
-    else if (contentType.includes('application/text')) {
-        return await r.text();
-    }
-    else if (contentType.startsWith('text')) {
-        return await r.text();
-    }
-    else if (contentType.includes('form')) {
+async function parseBody(r) {
+    let body = {};
+    const contentType = r.headers.get('Content-Type');
+    if (contentType &&
+        (contentType.startsWith('multipart/form-data') ||
+            contentType === 'application/x-www-form-urlencoded')) {
         const form = {};
-        const data = [...(await r.formData())].reduce((acc, cur) => {
+        body = [...(await r.formData())].reduce((acc, cur) => {
             acc[cur[0]] = cur[1];
             return acc;
         }, form);
-        return data;
     }
-    const arrayBuffer = await r.arrayBuffer();
-    return arrayBuffer;
-};
+    return body;
+}
 exports.parseBody = parseBody;

package/dist/utils/buffer.d.ts

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

package/dist/utils/cloudflare.d.ts

@@ -3,4 +3,4 @@ export declare type KVAssetOptions = {
     manifest?: object | string;
     namespace?: KVNamespace;
 };
-export declare const getContentFromKVAsset: (path: string, options?: KVAssetOptions) => Promise<ArrayBuffer | null>;
+export declare const getContentFromKVAsset: (path: string, options?: KVAssetOptions | undefined) => Promise<ArrayBuffer | null>;

package/dist/utils/crypto.d.ts

@@ -2,7 +2,7 @@ declare type Algorithm = {
     name: string;
     alias: string;
 };
-declare type Data = string | boolean | number | object | ArrayBufferView | ArrayBuffer;
+declare type Data = string | boolean | number | object | ArrayBufferView | ArrayBuffer | ReadableStream;
 export declare const sha256: (data: Data) => Promise<string | null>;
 export declare const sha1: (data: Data) => Promise<string | null>;
 export declare const md5: (data: Data) => Promise<string | null>;

package/dist/utils/crypto.js

@@ -21,6 +21,15 @@ const md5 = async (data) => {
 exports.md5 = md5;
 const createHash = async (data, algorithm) => {
     let sourceBuffer;
+    if (data instanceof ReadableStream) {
+        let body = '';
+        const reader = data.getReader();
+        await reader?.read().then(async (chuck) => {
+            const value = await (0, exports.createHash)(chuck.value || '', algorithm);
+            body += value;
+        });
+        return body;
+    }
     if (ArrayBuffer.isView(data) || data instanceof ArrayBuffer) {
         sourceBuffer = data;
     }

package/dist/utils/mime.js

@@ -34,7 +34,7 @@ const mimes = {
     gif: 'image/gif',
     htm: 'text/html',
     html: 'text/html',
-    ico: 'image/vnd.microsoft.icon',
+    ico: 'image/x-icon',
     ics: 'text/calendar',
     jar: 'application/java-archive',
     jpeg: 'image/jpeg',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hono",
-  "version": "2.0.7",
+  "version": "2.1.0",
   "description": "Ultrafast web framework for Cloudflare Workers.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -155,7 +155,7 @@
     "eslint-plugin-node": "^11.1.0",
     "form-data": "^4.0.0",
     "jest": "27.5.1",
-    "jest-environment-miniflare": "^2.6.0",
+    "jest-environment-miniflare": "^2.7.0",
     "np": "^7.6.2",
     "prettier": "^2.6.2",
     "rimraf": "^3.0.2",