hono 2.0.6 → 2.0.7

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/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/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;
 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,20 @@ const md5 = async (data) => {
 };
 exports.md5 = md5;
 const createHash = async (data, algorithm) => {
+    let sourceBuffer;
+    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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hono",
-  "version": "2.0.6",
+  "version": "2.0.7",
   "description": "Ultrafast web framework for Cloudflare Workers.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",