hono 2.0.6 → 2.0.9

package/README.md

@@ -46,13 +46,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 424,449 ops/sec ±4.98% (77 runs sampled)
+hono - regexp-router x 516,228 ops/sec ±4.79% (81 runs sampled)
+itty-router x 206,641 ops/sec ±3.59% (87 runs sampled)
+sunder x 319,500 ops/sec ±1.33% (93 runs sampled)
+worktop x 187,280 ops/sec ±3.09% (87 runs sampled)
 Fastest is hono - regexp-router
-✨  Done in 43.56s.
+✨  Done in 38.32s.
 ```
 
 ## Documentation

package/dist/compose.d.ts

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

@@ -52,8 +52,10 @@ export declare class HonoContext<RequestParamKeyType extends string = string, E
     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: string, value: any): void;
-    get(key: string): any;
+    get<Key extends keyof ContextVariableMap>(key: Key): ContextVariableMap[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

@@ -50,7 +50,7 @@ export declare class Hono<E extends Env = Env, P extends string = '/'> extends H
     private matchRoute;
     private dispatch;
     handleEvent(event: FetchEvent): Promise<Response>;
-    fetch: (request: Request, env?: E | undefined, executionCtx?: ExecutionContext | undefined) => Promise<Response>;
+    fetch: (request: Request, env?: E, executionCtx?: ExecutionContext) => Promise<Response>;
     request(input: RequestInfo, requestInit?: RequestInit): Promise<Response>;
 }
 export {};

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 | undefined) => (ctx: Context, next: Next) => Promise<void>;
+export declare const compress: (options?: CompressionOptions) => (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 | undefined) => (c: Context, next: Next) => Promise<void>;
+export declare const cors: (options?: CORSOptions) => (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/html/index.d.ts

@@ -1,5 +1,3 @@
-export declare type HtmlEscapedString = string & {
-    isEscaped: true;
-};
+import type { HtmlEscapedString } from '../../utils/html';
 export declare const raw: (value: any) => HtmlEscapedString;
 export declare const html: (strings: TemplateStringsArray, ...values: any[]) => HtmlEscapedString;

package/dist/middleware/html/index.js

@@ -9,24 +9,28 @@ const raw = (value) => {
 };
 exports.raw = raw;
 const html = (strings, ...values) => {
-    let result = '';
+    const buffer = [''];
     for (let i = 0, len = strings.length - 1; i < len; i++) {
-        result += strings[i];
+        buffer[0] += strings[i];
         const children = values[i] instanceof Array ? values[i].flat(Infinity) : [values[i]];
         for (let i = 0, len = children.length; i < len; i++) {
             const child = children[i];
-            if (typeof child === 'boolean' || child === null || child === undefined) {
+            if (typeof child === 'string') {
+                (0, html_1.escapeToBuffer)(child, buffer);
+            }
+            else if (typeof child === 'boolean' || child === null || child === undefined) {
                 continue;
             }
-            else if (typeof child === 'object' && child.isEscaped) {
-                result += child;
+            else if ((typeof child === 'object' && child.isEscaped) ||
+                typeof child === 'number') {
+                buffer[0] += child;
             }
             else {
-                result += (0, html_1.escape)(child.toString());
+                (0, html_1.escapeToBuffer)(child.toString(), buffer);
             }
         }
     }
-    result += strings[strings.length - 1];
-    return (0, exports.raw)(result);
+    buffer[0] += strings[strings.length - 1];
+    return (0, exports.raw)(buffer[0]);
 };
 exports.html = html;

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

@@ -1,4 +1,4 @@
-import type { HtmlEscapedString } from '../../utils/html';
+import type { StringBuffer, HtmlEscaped, HtmlEscapedString } from '../../utils/html';
 declare global {
     namespace jsx.JSX {
         interface IntrinsicElements {
@@ -6,11 +6,21 @@ declare global {
         }
     }
 }
+declare type Child = string | number | JSXNode | Child[];
+export declare class JSXNode implements HtmlEscaped {
+    tag: string | Function;
+    props: Record<string, any>;
+    children: Child[];
+    isEscaped: true;
+    constructor(tag: string | Function, props: Record<string, any>, children: Child[]);
+    toString(): string;
+    toStringToBuffer(buffer: StringBuffer): void;
+}
 export { jsxFn as jsx };
-declare const jsxFn: (tag: string | Function, props: Record<string, any>, ...children: (string | HtmlEscapedString)[]) => HtmlEscapedString;
+declare const jsxFn: (tag: string | Function, props: Record<string, any>, ...children: (string | HtmlEscapedString)[]) => JSXNode;
 declare type FC<T = Record<string, any>> = (props: T) => HtmlEscapedString;
 export declare const memo: <T>(component: FC<T>, propsAreEqual?: (prevProps: Readonly<T>, nextProps: Readonly<T>) => boolean) => FC<T>;
 export declare const Fragment: (props: {
     key?: string;
     children?: any;
-}) => HtmlEscapedString;
+}) => JSXNode;

package/dist/middleware/jsx/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Fragment = exports.memo = exports.jsx = void 0;
+exports.Fragment = exports.memo = exports.jsx = exports.JSXNode = void 0;
 const html_1 = require("../../utils/html");
 const emptyTags = [
     'area',
@@ -19,68 +19,144 @@ const emptyTags = [
     'track',
     'wbr',
 ];
-const booleanAttributes = ['checked', 'selected', 'disabled', 'readonly', 'multiple'];
-const newHtmlEscapedString = (str) => {
-    const escapedString = new String(str);
-    escapedString.isEscaped = true;
-    return escapedString;
-};
-const jsxFn = (tag, props, ...children) => {
-    if (typeof tag === 'function') {
-        return tag.call(null, { ...props, children: children.length <= 1 ? children[0] : children });
-    }
-    let result = tag !== '' ? `<${tag}` : '';
-    const propsKeys = Object.keys(props || {});
-    for (let i = 0, len = propsKeys.length; i < len; i++) {
-        const v = props[propsKeys[i]];
-        if (typeof v === 'string') {
-            result += ` ${propsKeys[i]}="${(0, html_1.escape)(v)}"`;
-        }
-        else if (typeof v === 'number') {
-            result += ` ${propsKeys[i]}="${v}"`;
+const booleanAttributes = [
+    'allowfullscreen',
+    'async',
+    'autofocus',
+    'autoplay',
+    'checked',
+    'controls',
+    'default',
+    'defer',
+    'disabled',
+    'formnovalidate',
+    'hidden',
+    'inert',
+    'ismap',
+    'itemscope',
+    'loop',
+    'multiple',
+    'muted',
+    'nomodule',
+    'novalidate',
+    'open',
+    'playsinline',
+    'readonly',
+    'required',
+    'reversed',
+    'selected',
+];
+const childrenToStringToBuffer = (children, buffer) => {
+    for (let i = 0, len = children.length; i < len; i++) {
+        const child = children[i];
+        if (typeof child === 'string') {
+            (0, html_1.escapeToBuffer)(child, buffer);
         }
-        else if (v === null || v === undefined) {
-            // Do nothing
+        else if (typeof child === 'boolean' || child === null || child === undefined) {
+            continue;
         }
-        else if (typeof v === 'boolean' && booleanAttributes.includes(propsKeys[i])) {
-            if (v) {
-                result += ` ${propsKeys[i]}=""`;
-            }
+        else if (child instanceof JSXNode) {
+            child.toStringToBuffer(buffer);
         }
-        else if (propsKeys[i] === 'dangerouslySetInnerHTML') {
-            if (children.length > 0) {
-                throw 'Can only set one of `children` or `props.dangerouslySetInnerHTML`.';
-            }
-            children = [newHtmlEscapedString(v.__html)];
+        else if (typeof child === 'number' || child.isEscaped) {
+            buffer[0] += child;
         }
         else {
-            result += ` ${propsKeys[i]}="${(0, html_1.escape)(v.toString())}"`;
+            // `child` type is `Child[]`, so stringify recursively
+            childrenToStringToBuffer(child, buffer);
         }
     }
-    if (emptyTags.includes(tag)) {
-        result += '/>';
-        return newHtmlEscapedString(result);
+};
+class JSXNode {
+    constructor(tag, props, children) {
+        this.isEscaped = true;
+        this.tag = tag;
+        this.props = props;
+        this.children = children;
     }
-    if (tag !== '') {
-        result += '>';
+    toString() {
+        const buffer = [''];
+        this.toStringToBuffer(buffer);
+        return buffer[0];
     }
-    const flattenChildren = children.flat(Infinity);
-    for (let i = 0, len = flattenChildren.length; i < len; i++) {
-        const child = flattenChildren[i];
-        if (typeof child === 'boolean' || child === null || child === undefined) {
-            continue;
+    toStringToBuffer(buffer) {
+        const tag = this.tag;
+        const props = this.props;
+        let { children } = this;
+        buffer[0] += `<${tag}`;
+        const propsKeys = Object.keys(props || {});
+        for (let i = 0, len = propsKeys.length; i < len; i++) {
+            const v = props[propsKeys[i]];
+            if (typeof v === 'string') {
+                buffer[0] += ` ${propsKeys[i]}="`;
+                (0, html_1.escapeToBuffer)(v, buffer);
+                buffer[0] += '"';
+            }
+            else if (typeof v === 'number') {
+                buffer[0] += ` ${propsKeys[i]}="${v}"`;
+            }
+            else if (v === null || v === undefined) {
+                // Do nothing
+            }
+            else if (typeof v === 'boolean' && booleanAttributes.includes(propsKeys[i])) {
+                if (v) {
+                    buffer[0] += ` ${propsKeys[i]}=""`;
+                }
+            }
+            else if (propsKeys[i] === 'dangerouslySetInnerHTML') {
+                if (children.length > 0) {
+                    throw 'Can only set one of `children` or `props.dangerouslySetInnerHTML`.';
+                }
+                const escapedString = new String(v.__html);
+                escapedString.isEscaped = true;
+                children = [escapedString];
+            }
+            else {
+                buffer[0] += ` ${propsKeys[i]}="`;
+                (0, html_1.escapeToBuffer)(v.toString(), buffer);
+                buffer[0] += '"';
+            }
+        }
+        if (emptyTags.includes(tag)) {
+            buffer[0] += '/>';
+            return;
         }
-        else if (typeof child === 'object' && child.isEscaped) {
-            result += child;
+        buffer[0] += '>';
+        childrenToStringToBuffer(children, buffer);
+        buffer[0] += `</${tag}>`;
+    }
+}
+exports.JSXNode = JSXNode;
+class JSXFunctionNode extends JSXNode {
+    toStringToBuffer(buffer) {
+        const { children } = this;
+        const res = this.tag.call(null, {
+            ...this.props,
+            children: children.length <= 1 ? children[0] : children,
+        });
+        if (res instanceof JSXNode) {
+            res.toStringToBuffer(buffer);
+        }
+        else if (typeof res === 'number' || res.isEscaped) {
+            buffer[0] += res;
         }
         else {
-            result += (0, html_1.escape)(child.toString());
+            (0, html_1.escapeToBuffer)(res, buffer);
         }
     }
-    if (tag !== '') {
-        result += `</${tag}>`;
+}
+class JSXFragmentNode extends JSXNode {
+    toStringToBuffer(buffer) {
+        childrenToStringToBuffer(this.children, buffer);
+    }
+}
+const jsxFn = (tag, props, ...children) => {
+    if (typeof tag === 'function') {
+        return new JSXFunctionNode(tag, props, children);
+    }
+    else {
+        return new JSXNode(tag, props, children);
     }
-    return newHtmlEscapedString(result);
 };
 exports.jsx = jsxFn;
 const shallowEqual = (a, b) => {
@@ -112,6 +188,6 @@ const memo = (component, propsAreEqual = shallowEqual) => {
 };
 exports.memo = memo;
 const Fragment = (props) => {
-    return jsxFn('', {}, ...(props.children || []));
+    return new JSXFragmentNode('', {}, props.children || []);
 };
 exports.Fragment = Fragment;

package/dist/middleware/jsx/jsx-dev-runtime.d.ts

@@ -1,2 +1,2 @@
-import type { HtmlEscapedString } from '../html';
-export declare function jsxDEV(tag: string | Function, props: Record<string, any>): HtmlEscapedString;
+import type { JSXNode } from '.';
+export declare function jsxDEV(tag: string | Function, props: Record<string, any>): JSXNode;

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

@@ -2,5 +2,6 @@ import type { Context } from '../../context';
 import type { Next } from '../../hono';
 export declare const jwt: (options: {
     secret: string;
+    cookie?: string;
     alg?: string;
 }) => (ctx: Context, next: Next) => Promise<void>;

package/dist/middleware/jwt/index.js

@@ -11,17 +11,26 @@ const jwt = (options) => {
     }
     return async (ctx, next) => {
         const credentials = ctx.req.headers.get('Authorization');
-        if (!credentials) {
-            ctx.res = new Response('Unauthorized', {
-                status: 401,
-                headers: {
-                    'WWW-Authenticate': `Bearer realm="${ctx.req.url}",error="invalid_request",error_description="no authorization included in request"`,
-                },
-            });
-            return;
+        let token;
+        if (credentials) {
+            const parts = credentials.split(/\s+/);
+            if (parts.length !== 2) {
+                ctx.res = new Response('Unauthorized', {
+                    status: 401,
+                    headers: {
+                        'WWW-Authenticate': `Bearer realm="${ctx.req.url}",error="invalid_request",error_description="invalid credentials structure"`,
+                    },
+                });
+                return;
+            }
+            else {
+                token = parts[1];
+            }
+        }
+        else if (options.cookie) {
+            token = ctx.req.cookie(options.cookie);
         }
-        const parts = credentials.split(/\s+/);
-        if (parts.length !== 2) {
+        if (!token) {
             ctx.res = new Response('Unauthorized', {
                 status: 401,
                 headers: {
@@ -33,7 +42,7 @@ const jwt = (options) => {
         let authorized = false;
         let msg = '';
         try {
-            authorized = await jwt_1.Jwt.verify(parts[1], options.secret, options.alg);
+            authorized = await jwt_1.Jwt.verify(token, options.secret, options.alg);
         }
         catch (e) {
             msg = `${e}`;

package/dist/request.d.ts

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

package/dist/utils/body.d.ts

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

package/dist/utils/body.js

@@ -25,6 +25,7 @@ const parseBody = async (r) => {
         }, form);
         return data;
     }
-    return r.arrayBuffer();
+    const arrayBuffer = await r.arrayBuffer();
+    return arrayBuffer;
 };
 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 | undefined) => Promise<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/cloudflare.d.ts

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

package/dist/utils/crypto.d.ts

@@ -2,7 +2,7 @@ declare type Algorithm = {
     name: string;
     alias: string;
 };
-declare type Data = string | object | boolean;
+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

@@ -20,10 +20,29 @@ 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;
+    }
+    else {
+        if (typeof data === 'object') {
+            data = JSON.stringify(data);
+        }
+        sourceBuffer = new TextEncoder().encode(String(data));
+    }
     if (crypto && crypto.subtle) {
         const buffer = await crypto.subtle.digest({
             name: algorithm.name,
-        }, new TextEncoder().encode(String(data)));
+        }, sourceBuffer);
         const hash = Array.prototype.map
             .call(new Uint8Array(buffer), (x) => ('00' + x.toString(16)).slice(-2))
             .join('');

package/dist/utils/html.d.ts

@@ -1,4 +1,6 @@
-export declare type HtmlEscapedString = string & {
+export declare type HtmlEscaped = {
     isEscaped: true;
 };
-export declare const escape: (str: string) => string;
+export declare type HtmlEscapedString = string & HtmlEscaped;
+export declare type StringBuffer = [string];
+export declare const escapeToBuffer: (str: string, buffer: StringBuffer) => void;

package/dist/utils/html.js

@@ -1,15 +1,38 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.escape = void 0;
-const entityMap = {
-    '&': '&',
-    '<': '&lt;',
-    '>': '&gt;',
-    '"': '&quot;',
+exports.escapeToBuffer = void 0;
+// The `escapeToBuffer` implementation is based on code from the MIT licensed `react-dom` package.
+// https://github.com/facebook/react/blob/main/packages/react-dom/src/server/escapeTextForBrowser.js
+const escapeRe = /[&<>"]/;
+const escapeToBuffer = (str, buffer) => {
+    const match = str.search(escapeRe);
+    if (match === -1) {
+        buffer[0] += str;
+        return;
+    }
+    let escape;
+    let index;
+    let lastIndex = 0;
+    for (index = match; index < str.length; index++) {
+        switch (str.charCodeAt(index)) {
+            case 34: // "
+                escape = '&quot;';
+                break;
+            case 38: // &
+                escape = '&amp;';
+                break;
+            case 60: // <
+                escape = '&lt;';
+                break;
+            case 62: // >
+                escape = '&gt;';
+                break;
+            default:
+                continue;
+        }
+        buffer[0] += str.substring(lastIndex, index) + escape;
+        lastIndex = index + 1;
+    }
+    buffer[0] += str.substring(lastIndex, index);
 };
-const escapeRe = new RegExp(`[${Object.keys(entityMap).join('')}]`, 'g');
-const replaceFn = (m) => entityMap[m];
-const escape = (str) => {
-    return str.replace(escapeRe, replaceFn);
-};
-exports.escape = escape;
+exports.escapeToBuffer = escapeToBuffer;

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.6",
+  "version": "2.0.9",
   "description": "Ultrafast web framework for Cloudflare Workers.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",