hono 4.4.0 → 4.4.2

package/dist/adapter/aws-lambda/handler.js

@@ -198,21 +198,6 @@ var ALBProcessor = class extends EventProcessor {
     }
     return headers;
   }
-  setHeadersToResult(event, result, headers) {
-    if (event.multiValueHeaders) {
-      const multiValueHeaders = {};
-      for (const [key, value] of headers.entries()) {
-        multiValueHeaders[key] = [value];
-      }
-      result.multiValueHeaders = multiValueHeaders;
-    } else {
-      const singleValueHeaders = {};
-      for (const [key, value] of headers.entries()) {
-        singleValueHeaders[key] = value;
-      }
-      result.headers = singleValueHeaders;
-    }
-  }
   getPath(event) {
     return event.path;
   }
@@ -220,10 +205,10 @@ var ALBProcessor = class extends EventProcessor {
     return event.httpMethod;
   }
   getQueryString(event) {
-    if (event.queryStringParameters) {
-      return Object.entries(event.queryStringParameters || {}).filter(([, value]) => value).map(([key, value]) => `${key}=${value}`).join("&");
-    } else {
+    if (event.multiValueQueryStringParameters) {
       return Object.entries(event.multiValueQueryStringParameters || {}).filter(([, value]) => value).map(([key, value]) => `${key}=${value.join(`&${key}=`)}`).join("&");
+    } else {
+      return Object.entries(event.queryStringParameters || {}).filter(([, value]) => value).map(([key, value]) => `${key}=${value}`).join("&");
     }
   }
   getCookies(event, headers) {
@@ -256,10 +241,10 @@ var getProcessor = (event) => {
   return v1Processor;
 };
 var isProxyEventALB = (event) => {
-  return Object.prototype.hasOwnProperty.call(event.requestContext, "elb");
+  return Object.hasOwn(event.requestContext, "elb");
 };
 var isProxyEventV2 = (event) => {
-  return Object.prototype.hasOwnProperty.call(event, "rawPath");
+  return Object.hasOwn(event, "rawPath");
 };
 var isContentTypeBinary = (contentType) => {
   return !/^(text\/(plain|html|css|javascript|csv).*|application\/(.*json|.*xml).*|image\/svg\+xml.*)$/.test(

package/dist/adapter/bun/conninfo.js

@@ -1,6 +1,7 @@
 // src/adapter/bun/conninfo.ts
+import { getBunServer } from "./server.js";
 var getConnInfo = (c) => {
-  const server = "server" in c.env ? c.env.server : c.env;
+  const server = getBunServer(c);
   if (!server) {
     throw new TypeError("env has to include the 2nd argument of fetch.");
   }

package/dist/adapter/bun/server.js

@@ -0,0 +1,5 @@
+// src/adapter/bun/server.ts
+var getBunServer = (c) => "server" in c.env ? c.env.server : c.env;
+export {
+  getBunServer
+};

package/dist/adapter/bun/websocket.js

@@ -1,5 +1,6 @@
 // src/adapter/bun/websocket.ts
 import { createWSMessageEvent } from "../../helper/websocket/index.js";
+import { getBunServer } from "./server.js";
 var createWSContext = (ws) => {
   return {
     send: (source, options) => {
@@ -20,7 +21,10 @@ var createBunWebSocket = () => {
   const websocketConns = [];
   const upgradeWebSocket = (createEvents) => {
     return async (c, next) => {
-      const server = c.env;
+      const server = getBunServer(c);
+      if (!server) {
+        throw new TypeError("env has to include the 2nd argument of fetch.");
+      }
       const connId = websocketConns.push(await createEvents(c)) - 1;
       const upgradeResult = server.upgrade(c.req.raw, {
         data: {

package/dist/adapter/cloudflare-workers/websocket.js

@@ -22,29 +22,19 @@ var upgradeWebSocket = (createEvents) => async (c, next) => {
     send: (source) => server.send(source)
   };
   if (events.onOpen) {
-    server.addEventListener("open", (evt) => events.onOpen && events.onOpen(evt, wsContext));
+    server.addEventListener("open", (evt) => events.onOpen?.(evt, wsContext));
   }
   if (events.onClose) {
-    server.addEventListener(
-      "close",
-      (evt) => events.onClose && events.onClose(evt, wsContext)
-    );
+    server.addEventListener("close", (evt) => events.onClose?.(evt, wsContext));
   }
   if (events.onMessage) {
-    server.addEventListener(
-      "message",
-      (evt) => events.onMessage && events.onMessage(evt, wsContext)
-    );
+    server.addEventListener("message", (evt) => events.onMessage?.(evt, wsContext));
   }
   if (events.onError) {
-    server.addEventListener(
-      "error",
-      (evt) => events.onError && events.onError(evt, wsContext)
-    );
+    server.addEventListener("error", (evt) => events.onError?.(evt, wsContext));
   }
-  server.accept();
+  server.accept?.();
   return new Response(null, {
-    status: 101,
     webSocket: client
   });
 };

package/dist/adapter/deno/websocket.js

@@ -18,10 +18,10 @@ var upgradeWebSocket = (createEvents) => async (c, next) => {
     url: socket.url ? new URL(socket.url) : null,
     send: (source) => socket.send(source)
   };
-  socket.onopen = (evt) => events.onOpen && events.onOpen(evt, wsContext);
-  socket.onmessage = (evt) => events.onMessage && events.onMessage(evt, wsContext);
-  socket.onclose = (evt) => events.onClose && events.onClose(evt, wsContext);
-  socket.onerror = (evt) => events.onError && events.onError(evt, wsContext);
+  socket.onopen = (evt) => events.onOpen?.(evt, wsContext);
+  socket.onmessage = (evt) => events.onMessage?.(evt, wsContext);
+  socket.onclose = (evt) => events.onClose?.(evt, wsContext);
+  socket.onerror = (evt) => events.onError?.(evt, wsContext);
   return response;
 };
 export {

package/dist/cjs/adapter/aws-lambda/handler.js

@@ -230,21 +230,6 @@ class ALBProcessor extends EventProcessor {
     }
     return headers;
   }
-  setHeadersToResult(event, result, headers) {
-    if (event.multiValueHeaders) {
-      const multiValueHeaders = {};
-      for (const [key, value] of headers.entries()) {
-        multiValueHeaders[key] = [value];
-      }
-      result.multiValueHeaders = multiValueHeaders;
-    } else {
-      const singleValueHeaders = {};
-      for (const [key, value] of headers.entries()) {
-        singleValueHeaders[key] = value;
-      }
-      result.headers = singleValueHeaders;
-    }
-  }
   getPath(event) {
     return event.path;
   }
@@ -252,10 +237,10 @@ class ALBProcessor extends EventProcessor {
     return event.httpMethod;
   }
   getQueryString(event) {
-    if (event.queryStringParameters) {
-      return Object.entries(event.queryStringParameters || {}).filter(([, value]) => value).map(([key, value]) => `${key}=${value}`).join("&");
-    } else {
+    if (event.multiValueQueryStringParameters) {
       return Object.entries(event.multiValueQueryStringParameters || {}).filter(([, value]) => value).map(([key, value]) => `${key}=${value.join(`&${key}=`)}`).join("&");
+    } else {
+      return Object.entries(event.queryStringParameters || {}).filter(([, value]) => value).map(([key, value]) => `${key}=${value}`).join("&");
     }
   }
   getCookies(event, headers) {
@@ -288,10 +273,10 @@ const getProcessor = (event) => {
   return v1Processor;
 };
 const isProxyEventALB = (event) => {
-  return Object.prototype.hasOwnProperty.call(event.requestContext, "elb");
+  return Object.hasOwn(event.requestContext, "elb");
 };
 const isProxyEventV2 = (event) => {
-  return Object.prototype.hasOwnProperty.call(event, "rawPath");
+  return Object.hasOwn(event, "rawPath");
 };
 const isContentTypeBinary = (contentType) => {
   return !/^(text\/(plain|html|css|javascript|csv).*|application\/(.*json|.*xml).*|image\/svg\+xml.*)$/.test(

package/dist/cjs/adapter/bun/conninfo.js

@@ -21,8 +21,9 @@ __export(conninfo_exports, {
   getConnInfo: () => getConnInfo
 });
 module.exports = __toCommonJS(conninfo_exports);
+var import_server = require("./server");
 const getConnInfo = (c) => {
-  const server = "server" in c.env ? c.env.server : c.env;
+  const server = (0, import_server.getBunServer)(c);
   if (!server) {
     throw new TypeError("env has to include the 2nd argument of fetch.");
   }

package/dist/cjs/adapter/bun/server.js

@@ -0,0 +1,28 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var server_exports = {};
+__export(server_exports, {
+  getBunServer: () => getBunServer
+});
+module.exports = __toCommonJS(server_exports);
+const getBunServer = (c) => "server" in c.env ? c.env.server : c.env;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getBunServer
+});

package/dist/cjs/adapter/bun/websocket.js

@@ -22,6 +22,7 @@ __export(websocket_exports, {
 });
 module.exports = __toCommonJS(websocket_exports);
 var import_websocket = require("../../helper/websocket");
+var import_server = require("./server");
 const createWSContext = (ws) => {
   return {
     send: (source, options) => {
@@ -42,7 +43,10 @@ const createBunWebSocket = () => {
   const websocketConns = [];
   const upgradeWebSocket = (createEvents) => {
     return async (c, next) => {
-      const server = c.env;
+      const server = (0, import_server.getBunServer)(c);
+      if (!server) {
+        throw new TypeError("env has to include the 2nd argument of fetch.");
+      }
       const connId = websocketConns.push(await createEvents(c)) - 1;
       const upgradeResult = server.upgrade(c.req.raw, {
         data: {

package/dist/cjs/adapter/cloudflare-workers/websocket.js

@@ -44,29 +44,19 @@ const upgradeWebSocket = (createEvents) => async (c, next) => {
     send: (source) => server.send(source)
   };
   if (events.onOpen) {
-    server.addEventListener("open", (evt) => events.onOpen && events.onOpen(evt, wsContext));
+    server.addEventListener("open", (evt) => events.onOpen?.(evt, wsContext));
   }
   if (events.onClose) {
-    server.addEventListener(
-      "close",
-      (evt) => events.onClose && events.onClose(evt, wsContext)
-    );
+    server.addEventListener("close", (evt) => events.onClose?.(evt, wsContext));
   }
   if (events.onMessage) {
-    server.addEventListener(
-      "message",
-      (evt) => events.onMessage && events.onMessage(evt, wsContext)
-    );
+    server.addEventListener("message", (evt) => events.onMessage?.(evt, wsContext));
   }
   if (events.onError) {
-    server.addEventListener(
-      "error",
-      (evt) => events.onError && events.onError(evt, wsContext)
-    );
+    server.addEventListener("error", (evt) => events.onError?.(evt, wsContext));
   }
-  server.accept();
+  server.accept?.();
   return new Response(null, {
-    status: 101,
     webSocket: client
   });
 };

package/dist/cjs/adapter/deno/websocket.js

@@ -40,10 +40,10 @@ const upgradeWebSocket = (createEvents) => async (c, next) => {
     url: socket.url ? new URL(socket.url) : null,
     send: (source) => socket.send(source)
   };
-  socket.onopen = (evt) => events.onOpen && events.onOpen(evt, wsContext);
-  socket.onmessage = (evt) => events.onMessage && events.onMessage(evt, wsContext);
-  socket.onclose = (evt) => events.onClose && events.onClose(evt, wsContext);
-  socket.onerror = (evt) => events.onError && events.onError(evt, wsContext);
+  socket.onopen = (evt) => events.onOpen?.(evt, wsContext);
+  socket.onmessage = (evt) => events.onMessage?.(evt, wsContext);
+  socket.onclose = (evt) => events.onClose?.(evt, wsContext);
+  socket.onerror = (evt) => events.onError?.(evt, wsContext);
   return response;
 };
 // Annotate the CommonJS export names for ESM import in node:

package/dist/cjs/client/client.js

@@ -72,7 +72,13 @@ class ClientRequestImpl {
       if (args.form) {
         const form = new FormData();
         for (const [k, v] of Object.entries(args.form)) {
-          form.append(k, v);
+          if (Array.isArray(v)) {
+            for (const v2 of v) {
+              form.append(k, v2);
+            }
+          } else {
+            form.append(k, v);
+          }
         }
         this.rBody = form;
       }

package/dist/cjs/helper/adapter/index.js

@@ -18,8 +18,10 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var adapter_exports = {};
 __export(adapter_exports, {
+  checkUserAgentEquals: () => checkUserAgentEquals,
   env: () => env,
-  getRuntimeKey: () => getRuntimeKey
+  getRuntimeKey: () => getRuntimeKey,
+  knownUserAgents: () => knownUserAgents
 });
 module.exports = __toCommonJS(adapter_exports);
 const env = (c, runtime) => {
@@ -39,16 +41,21 @@ const env = (c, runtime) => {
   };
   return runtimeEnvHandlers[runtime]();
 };
+const knownUserAgents = {
+  deno: "Deno",
+  bun: "Bun",
+  workerd: "Cloudflare-Workers",
+  node: "Node.js"
+};
 const getRuntimeKey = () => {
   const global = globalThis;
-  if (global?.Deno !== void 0) {
-    return "deno";
-  }
-  if (global?.Bun !== void 0) {
-    return "bun";
-  }
-  if (typeof global?.WebSocketPair === "function") {
-    return "workerd";
+  const userAgentSupported = typeof navigator !== "undefined" && typeof navigator.userAgent === "string";
+  if (userAgentSupported) {
+    for (const [runtimeKey, userAgent] of Object.entries(knownUserAgents)) {
+      if (checkUserAgentEquals(userAgent)) {
+        return runtimeKey;
+      }
+    }
   }
   if (typeof global?.EdgeRuntime === "string") {
     return "edge-light";
@@ -61,8 +68,14 @@ const getRuntimeKey = () => {
   }
   return "other";
 };
+const checkUserAgentEquals = (platform) => {
+  const userAgent = navigator.userAgent;
+  return userAgent.startsWith(platform);
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  checkUserAgentEquals,
   env,
-  getRuntimeKey
+  getRuntimeKey,
+  knownUserAgents
 });

package/dist/cjs/helper/ssg/utils.js

@@ -32,8 +32,8 @@ const dirname = (path) => {
 const normalizePath = (path) => {
   return path.replace(/(\\)/g, "/").replace(/\/$/g, "");
 };
-const handleDotDot = (resultPaths) => {
-  if (resultPaths.length === 0) {
+const handleParent = (resultPaths, beforeParentFlag) => {
+  if (resultPaths.length === 0 || beforeParentFlag) {
     resultPaths.push("..");
   } else {
     resultPaths.pop();
@@ -46,11 +46,14 @@ const handleNonDot = (path, resultPaths) => {
   }
 };
 const handleSegments = (paths, resultPaths) => {
+  let beforeParentFlag = false;
   for (const path of paths) {
     if (path === "..") {
-      handleDotDot(resultPaths);
+      handleParent(resultPaths, beforeParentFlag);
+      beforeParentFlag = true;
     } else {
       handleNonDot(path, resultPaths);
+      beforeParentFlag = false;
     }
   }
 };

package/dist/cjs/jsx/utils.js

@@ -30,9 +30,12 @@ const normalizeIntrinsicElementProps = (props) => {
 };
 const styleObjectForEach = (style, fn) => {
   for (const [k, v] of Object.entries(style)) {
+    const key = k[0] === "-" || !/[A-Z]/.test(k) ? k : k.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
     fn(
-      k[0] === "-" ? k : k.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`),
-      v == null ? null : typeof v === "number" ? v + "px" : v
+      key,
+      v == null ? null : typeof v === "number" ? !key.match(
+        /^(?:a|border-im|column(?:-c|s)|flex(?:$|-[^b])|grid-(?:ar|[^a])|font-w|li|or|sca|st|ta|wido|z)|ty$/
+      ) ? `${v}px` : `${v}` : v
     );
   }
 };

package/dist/cjs/middleware/body-limit/index.js

@@ -67,7 +67,8 @@ const bodyLimit = (options) => {
         }
       }
     });
-    c.req.raw = new Request(c.req.raw, { body: reader });
+    const requestInit = { body: reader, duplex: "half" };
+    c.req.raw = new Request(c.req.raw, requestInit);
     await next();
     if (c.error instanceof BodyLimitError) {
       c.res = await onError(c);

package/dist/cjs/middleware/pretty-json/index.js

@@ -23,7 +23,7 @@ __export(pretty_json_exports, {
 module.exports = __toCommonJS(pretty_json_exports);
 const prettyJSON = (options = { space: 2 }) => {
   return async function prettyJSON2(c, next) {
-    const pretty = c.req.query("pretty") || c.req.query("pretty") === "" ? true : false;
+    const pretty = c.req.query("pretty") || c.req.query("pretty") === "";
     await next();
     if (pretty && c.res.headers.get("Content-Type")?.startsWith("application/json")) {
       const obj = await c.res.json();

package/dist/cjs/validator/validator.js

@@ -30,7 +30,7 @@ const validator = (target, validationFunc) => {
     const contentType = c.req.header("Content-Type");
     switch (target) {
       case "json":
-        if (!contentType || !/^application\/([a-z-]+\+)?json/.test(contentType)) {
+        if (!contentType || !/^application\/([a-z-\.]+\+)?json/.test(contentType)) {
           const message = `Invalid HTTP header: Content-Type=${contentType}`;
           throw new import_http_exception.HTTPException(400, { message });
         }

package/dist/client/client.js

@@ -56,7 +56,13 @@ var ClientRequestImpl = class {
       if (args.form) {
         const form = new FormData();
         for (const [k, v] of Object.entries(args.form)) {
-          form.append(k, v);
+          if (Array.isArray(v)) {
+            for (const v2 of v) {
+              form.append(k, v2);
+            }
+          } else {
+            form.append(k, v);
+          }
         }
         this.rBody = form;
       }

package/dist/helper/adapter/index.js

@@ -16,16 +16,21 @@ var env = (c, runtime) => {
   };
   return runtimeEnvHandlers[runtime]();
 };
+var knownUserAgents = {
+  deno: "Deno",
+  bun: "Bun",
+  workerd: "Cloudflare-Workers",
+  node: "Node.js"
+};
 var getRuntimeKey = () => {
   const global = globalThis;
-  if (global?.Deno !== void 0) {
-    return "deno";
-  }
-  if (global?.Bun !== void 0) {
-    return "bun";
-  }
-  if (typeof global?.WebSocketPair === "function") {
-    return "workerd";
+  const userAgentSupported = typeof navigator !== "undefined" && typeof navigator.userAgent === "string";
+  if (userAgentSupported) {
+    for (const [runtimeKey, userAgent] of Object.entries(knownUserAgents)) {
+      if (checkUserAgentEquals(userAgent)) {
+        return runtimeKey;
+      }
+    }
   }
   if (typeof global?.EdgeRuntime === "string") {
     return "edge-light";
@@ -38,7 +43,13 @@ var getRuntimeKey = () => {
   }
   return "other";
 };
+var checkUserAgentEquals = (platform) => {
+  const userAgent = navigator.userAgent;
+  return userAgent.startsWith(platform);
+};
 export {
+  checkUserAgentEquals,
   env,
-  getRuntimeKey
+  getRuntimeKey,
+  knownUserAgents
 };

package/dist/helper/ssg/utils.js

@@ -8,8 +8,8 @@ var dirname = (path) => {
 var normalizePath = (path) => {
   return path.replace(/(\\)/g, "/").replace(/\/$/g, "");
 };
-var handleDotDot = (resultPaths) => {
-  if (resultPaths.length === 0) {
+var handleParent = (resultPaths, beforeParentFlag) => {
+  if (resultPaths.length === 0 || beforeParentFlag) {
     resultPaths.push("..");
   } else {
     resultPaths.pop();
@@ -22,11 +22,14 @@ var handleNonDot = (path, resultPaths) => {
   }
 };
 var handleSegments = (paths, resultPaths) => {
+  let beforeParentFlag = false;
   for (const path of paths) {
     if (path === "..") {
-      handleDotDot(resultPaths);
+      handleParent(resultPaths, beforeParentFlag);
+      beforeParentFlag = true;
     } else {
       handleNonDot(path, resultPaths);
+      beforeParentFlag = false;
     }
   }
 };

package/dist/jsx/utils.js

@@ -7,9 +7,12 @@ var normalizeIntrinsicElementProps = (props) => {
 };
 var styleObjectForEach = (style, fn) => {
   for (const [k, v] of Object.entries(style)) {
+    const key = k[0] === "-" || !/[A-Z]/.test(k) ? k : k.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
     fn(
-      k[0] === "-" ? k : k.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`),
-      v == null ? null : typeof v === "number" ? v + "px" : v
+      key,
+      v == null ? null : typeof v === "number" ? !key.match(
+        /^(?:a|border-im|column(?:-c|s)|flex(?:$|-[^b])|grid-(?:ar|[^a])|font-w|li|or|sca|st|ta|wido|z)|ty$/
+      ) ? `${v}px` : `${v}` : v
     );
   }
 };

package/dist/middleware/body-limit/index.js

@@ -45,7 +45,8 @@ var bodyLimit = (options) => {
         }
       }
     });
-    c.req.raw = new Request(c.req.raw, { body: reader });
+    const requestInit = { body: reader, duplex: "half" };
+    c.req.raw = new Request(c.req.raw, requestInit);
     await next();
     if (c.error instanceof BodyLimitError) {
       c.res = await onError(c);

package/dist/middleware/pretty-json/index.js

@@ -1,7 +1,7 @@
 // src/middleware/pretty-json/index.ts
 var prettyJSON = (options = { space: 2 }) => {
   return async function prettyJSON2(c, next) {
-    const pretty = c.req.query("pretty") || c.req.query("pretty") === "" ? true : false;
+    const pretty = c.req.query("pretty") || c.req.query("pretty") === "";
     await next();
     if (pretty && c.res.headers.get("Content-Type")?.startsWith("application/json")) {
       const obj = await c.res.json();

package/dist/types/adapter/bun/server.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Getting Bun Server Object for Bun adapters
+ * @module
+ */
+import type { Context } from '../../context';
+/**
+ * Bun Server Object
+ */
+export interface BunServer {
+    requestIP?: (req: Request) => {
+        address: string;
+        family: string;
+        port: number;
+    };
+    upgrade<T>(req: Request, options?: {
+        data: T;
+    }): boolean;
+}
+/**
+ * Get Bun Server Object from Context
+ * @param c Context
+ * @returns Bun Server
+ */
+export declare const getBunServer: (c: Context) => BunServer | undefined;

package/dist/types/compose.d.ts

@@ -1,8 +1,30 @@
 import type { ParamIndexMap, Params } from './router';
 import type { Env, ErrorHandler, NotFoundHandler } from './types';
+/**
+ * Interface representing the context for a composition operation.
+ */
 interface ComposeContext {
+    /**
+     * Indicates whether the composition process has been finalized.
+     */
     finalized: boolean;
+    /**
+     * The result of the composition process. The type is unknown and should be
+     * specified based on the context where this interface is used.
+     */
     res: unknown;
 }
+/**
+ * Compose middleware functions into a single function based on `koa-compose` package.
+ *
+ * @template C - The context type.
+ * @template E - The environment type.
+ *
+ * @param {[[Function, unknown], ParamIndexMap | Params][]} middleware - An array of middleware functions and their corresponding parameters.
+ * @param {ErrorHandler<E>} [onError] - An optional error handler function.
+ * @param {NotFoundHandler<E>} [onNotFound] - An optional not-found handler function.
+ *
+ * @returns {(context: C, next?: Function) => Promise<C>} - A composed middleware function.
+ */
 export declare const compose: <C extends ComposeContext, E extends Env = Env>(middleware: [[Function, unknown], ParamIndexMap | Params][], onError?: ErrorHandler<E> | undefined, onNotFound?: NotFoundHandler<E> | undefined) => (context: C, next?: Function) => Promise<C>;
 export {};

package/dist/types/context.d.ts

@@ -3,50 +3,149 @@ import type { Env, FetchEventLike, Input, NotFoundHandler, TypedResponse } from
 import type { RedirectStatusCode, StatusCode } from './utils/http-status';
 import type { IsAny, JSONParsed, JSONValue, Simplify } from './utils/types';
 type HeaderRecord = Record<string, string | string[]>;
+/**
+ * Data type can be a string, ArrayBuffer, or ReadableStream.
+ */
 export type Data = string | ArrayBuffer | ReadableStream;
+/**
+ * Interface for the execution context in a web worker or similar environment.
+ */
 export interface ExecutionContext {
+    /**
+     * Extends the lifetime of the event callback until the promise is settled.
+     *
+     * @param promise - A promise to wait for.
+     */
     waitUntil(promise: Promise<unknown>): void;
+    /**
+     * Allows the event to be passed through to subsequent event listeners.
+     */
     passThroughOnException(): void;
 }
+/**
+ * Interface for context variable mapping.
+ */
 export interface ContextVariableMap {
 }
+/**
+ * Interface for context renderer.
+ */
 export interface ContextRenderer {
 }
+/**
+ * Interface representing a renderer for content.
+ *
+ * @interface DefaultRenderer
+ * @param {string | Promise<string>} content - The content to be rendered, which can be either a string or a Promise resolving to a string.
+ * @returns {Response | Promise<Response>} - The response after rendering the content, which can be either a Response or a Promise resolving to a Response.
+ */
 interface DefaultRenderer {
     (content: string | Promise<string>): Response | Promise<Response>;
 }
+/**
+ * Renderer type which can either be a ContextRenderer or DefaultRenderer.
+ */
 export type Renderer = ContextRenderer extends Function ? ContextRenderer : DefaultRenderer;
+/**
+ * Extracts the props for the renderer.
+ */
 export type PropsForRenderer = [...Required<Parameters<Renderer>>] extends [unknown, infer Props] ? Props : unknown;
 export type Layout<T = Record<string, any>> = (props: T) => any;
+/**
+ * Interface for getting context variables.
+ *
+ * @template E - Environment type.
+ */
 interface Get<E extends Env> {
     <Key extends keyof ContextVariableMap>(key: Key): ContextVariableMap[Key];
     <Key extends keyof E['Variables']>(key: Key): E['Variables'][Key];
 }
+/**
+ * Interface for setting context variables.
+ *
+ * @template E - Environment type.
+ */
 interface Set<E extends Env> {
     <Key extends keyof ContextVariableMap>(key: Key, value: ContextVariableMap[Key]): void;
     <Key extends keyof E['Variables']>(key: Key, value: E['Variables'][Key]): void;
 }
+/**
+ * Interface for creating a new response.
+ */
 interface NewResponse {
     (data: Data | null, status?: StatusCode, headers?: HeaderRecord): Response;
     (data: Data | null, init?: ResponseInit): Response;
 }
+/**
+ * Interface for responding with a body.
+ */
 interface BodyRespond extends NewResponse {
 }
+/**
+ * Interface for responding with text.
+ *
+ * @interface TextRespond
+ * @template T - The type of the text content.
+ * @template U - The type of the status code.
+ *
+ * @param {T} text - The text content to be included in the response.
+ * @param {U} [status] - An optional status code for the response.
+ * @param {HeaderRecord} [headers] - An optional record of headers to include in the response.
+ *
+ * @returns {Response & TypedResponse<T, U, 'text'>} - The response after rendering the text content, typed with the provided text and status code types.
+ */
 interface TextRespond {
     <T extends string, U extends StatusCode>(text: T, status?: U, headers?: HeaderRecord): Response & TypedResponse<T, U, 'text'>;
     <T extends string, U extends StatusCode>(text: T, init?: ResponseInit): Response & TypedResponse<T, U, 'text'>;
 }
+/**
+ * Interface for responding with JSON.
+ *
+ * @interface JSONRespond
+ * @template T - The type of the JSON value or simplified unknown type.
+ * @template U - The type of the status code.
+ *
+ * @param {T} object - The JSON object to be included in the response.
+ * @param {U} [status] - An optional status code for the response.
+ * @param {HeaderRecord} [headers] - An optional record of headers to include in the response.
+ *
+ * @returns {Response & TypedResponse<Simplify<T> extends JSONValue ? (JSONValue extends Simplify<T> ? never : JSONParsed<T>) : never, U, 'json'>} - The response after rendering the JSON object, typed with the provided object and status code types.
+ */
 interface JSONRespond {
     <T extends JSONValue | Simplify<unknown>, U extends StatusCode>(object: T, status?: U, headers?: HeaderRecord): Response & TypedResponse<Simplify<T> extends JSONValue ? JSONValue extends Simplify<T> ? never : JSONParsed<T> : never, U, 'json'>;
     <T extends JSONValue | Simplify<unknown>, U extends StatusCode>(object: Simplify<T> extends JSONValue ? T : Simplify<T>, init?: ResponseInit): Response & TypedResponse<Simplify<T> extends JSONValue ? JSONValue extends Simplify<T> ? never : JSONParsed<T> : never, U, 'json'>;
 }
+/**
+ * Interface representing a function that responds with HTML content.
+ *
+ * @param html - The HTML content to respond with, which can be a string or a Promise that resolves to a string.
+ * @param status - (Optional) The HTTP status code for the response.
+ * @param headers - (Optional) A record of headers to include in the response.
+ * @param init - (Optional) The response initialization object.
+ *
+ * @returns A Response object or a Promise that resolves to a Response object.
+ */
 interface HTMLRespond {
     (html: string | Promise<string>, status?: StatusCode, headers?: HeaderRecord): Response | Promise<Response>;
     (html: string | Promise<string>, init?: ResponseInit): Response | Promise<Response>;
 }
+/**
+ * Options for configuring the context.
+ *
+ * @template E - Environment type.
+ */
 type ContextOptions<E extends Env> = {
+    /**
+     * Bindings for the environment.
+     */
     env: E['Bindings'];
+    /**
+     * Execution context for the request.
+     */
     executionCtx?: FetchEventLike | ExecutionContext | undefined;
+    /**
+     * Handler for not found responses.
+     */
     notFoundHandler?: NotFoundHandler<E>;
 };
 export declare const TEXT_PLAIN = "text/plain; charset=UTF-8";
@@ -87,22 +186,44 @@ export declare class Context<E extends Env = any, P extends string = any, I exte
     private layout;
     private renderer;
     private notFoundHandler;
+    /**
+     * Creates an instance of the Context class.
+     *
+     * @param req - The HonoRequest object.
+     * @param options - Optional configuration options for the context.
+     */
     constructor(req: HonoRequest<P, I['out']>, options?: ContextOptions<E>);
     /**
+     * The FetchEvent associated with the current request.
+     *
+     * @throws Will throw an error if the context does not have a FetchEvent.
+     *
      * @see https://hono.dev/api/context#event
      */
     get event(): FetchEventLike;
     /**
+     * The ExecutionContext associated with the current request.
+     *
+     * @throws Will throw an error if the context does not have an ExecutionContext.
+     *
      * @see https://hono.dev/api/context#executionctx
      */
     get executionCtx(): ExecutionContext;
     /**
+     * The Response object for the current request.
+     *
      * @see https://hono.dev/api/context#res
      */
     get res(): Response;
+    /**
+     * Sets the Response object for the current request.
+     *
+     * @param _res - The Response object to set.
+     */
     set res(_res: Response | undefined);
     /**
-     * `.render()` can create a response within a layout.
+     * Renders a response within a layout.
+     *
      * @example
      * ```ts
      * app.get('/', (c) => {
@@ -112,11 +233,22 @@ export declare class Context<E extends Env = any, P extends string = any, I exte
      * @see https://hono.dev/api/context#render-setrenderer
      */
     render: Renderer;
+    /**
+     * Sets the layout for the response.
+     *
+     * @param layout - The layout to set.
+     * @returns The layout function.
+     */
     setLayout: (layout: Layout<PropsForRenderer & {
         Layout: Layout;
     }>) => Layout<PropsForRenderer & {
         Layout: Layout;
     }>;
+    /**
+     * Gets the current layout for the response.
+     *
+     * @returns The current layout function.
+     */
     getLayout: () => Layout<{
         Layout: Layout;
     }> | undefined;

package/dist/types/helper/adapter/index.d.ts

@@ -5,4 +5,6 @@
 import type { Context } from '../../context';
 export type Runtime = 'node' | 'deno' | 'bun' | 'workerd' | 'fastly' | 'edge-light' | 'other';
 export declare const env: <T extends Record<string, unknown>, C extends Context<any, any, {}> = Context<{}, any, {}>>(c: C, runtime?: Runtime) => T & C["env"];
+export declare const knownUserAgents: Partial<Record<Runtime, string>>;
 export declare const getRuntimeKey: () => Runtime;
+export declare const checkUserAgentEquals: (platform: string) => boolean;

package/dist/types/helper/testing/index.d.ts

@@ -5,7 +5,8 @@
 import type { Client } from '../../client/types';
 import type { ExecutionContext } from '../../context';
 import type { Hono } from '../../hono';
+import type { Schema } from '../../types';
 import type { UnionToIntersection } from '../../utils/types';
-type ExtractEnv<T> = T extends Hono<infer E, any, any> ? E : never;
-export declare const testClient: <T extends Hono<any, any, any>>(app: T, Env?: {} | ExtractEnv<T>["Bindings"] | undefined, executionCtx?: ExecutionContext) => UnionToIntersection<Client<T>>;
+type ExtractEnv<T> = T extends Hono<infer E, Schema, string> ? E : never;
+export declare const testClient: <T extends Hono<any, Schema, string>>(app: T, Env?: {} | ExtractEnv<T>["Bindings"] | undefined, executionCtx?: ExecutionContext) => UnionToIntersection<Client<T>>;
 export {};

package/dist/types/hono-base.d.ts

@@ -6,6 +6,9 @@ import { Context } from './context';
 import type { ExecutionContext } from './context';
 import type { Router } from './router';
 import type { Env, ErrorHandler, H, HandlerInterface, MergePath, MergeSchemaPath, MiddlewareHandlerInterface, NotFoundHandler, OnHandlerInterface, RouterRoute, Schema } from './types';
+/**
+ * Symbol used to mark a composed handler.
+ */
 export declare const COMPOSED_HANDLER: unique symbol;
 type GetPath<E extends Env> = (request: Request, options?: {
     env?: E['Bindings'];
@@ -94,6 +97,23 @@ declare class Hono<E extends Env = Env, S extends Schema = {}, BasePath extends
      * @see https://hono.dev/api/hono#not-found
      */
     notFound: (handler: NotFoundHandler<E>) => Hono<E, S, BasePath>;
+    /**
+     * Mounts an external application handler to the specified path.
+     *
+     * @param path - The path where the external application handler should be mounted.
+     * @param applicationHandler - The external application handler function that processes requests.
+     * @param optionHandler - Optional function to handle additional options, such as environment variables and execution context.
+     *
+     * @returns The current instance of Hono for chaining.
+     *
+     * @example
+     * ```ts
+     * const app = new Hono()
+     * const externalAppHandler = () => new Response('External App')
+     * app.mount('/external', externalAppHandler)
+     * ```
+     * @see https://hono.dev/api/hono#mount
+     */
     mount(path: string, applicationHandler: (request: Request, ...args: any) => Response | Promise<Response>, optionHandler?: (c: Context) => unknown): Hono<E, S, BasePath>;
     private addRoute;
     private matchRoute;

package/dist/types/hono.d.ts

@@ -1,6 +1,19 @@
 import { HonoBase } from './hono-base';
 import type { HonoOptions } from './hono-base';
-import type { BlankSchema, Env, Schema } from './types';
-export declare class Hono<E extends Env = Env, S extends Schema = BlankSchema, BasePath extends string = '/'> extends HonoBase<E, S, BasePath> {
+import type { BlankEnv, BlankSchema, Env, Schema } from './types';
+/**
+ * The Hono class extends the functionality of the HonoBase class.
+ * It sets up routing and allows for custom options to be passed.
+ *
+ * @template E - The environment type.
+ * @template S - The schema type.
+ * @template BasePath - The base path type.
+ */
+export declare class Hono<E extends Env = BlankEnv, S extends Schema = BlankSchema, BasePath extends string = '/'> extends HonoBase<E, S, BasePath> {
+    /**
+     * Creates an instance of the Hono class.
+     *
+     * @param options - Optional configuration options for the Hono instance.
+     */
     constructor(options?: HonoOptions<E>);
 }

package/dist/types/http-exception.d.ts

@@ -3,6 +3,12 @@
  * This module provides the `HTTPException` class.
  */
 import type { StatusCode } from './utils/http-status';
+/**
+ * Options for creating an `HTTPException`.
+ * @property res - Optional response object to use.
+ * @property message - Optional custom error message.
+ * @property cause - Optional cause of the error.
+ */
 type HTTPExceptionOptions = {
     res?: Response;
     message?: string;
@@ -29,7 +35,17 @@ type HTTPExceptionOptions = {
 export declare class HTTPException extends Error {
     readonly res?: Response;
     readonly status: StatusCode;
+    /**
+     * Creates an instance of `HTTPException`.
+     * @param status - HTTP status code for the exception. Defaults to 500.
+     * @param options - Additional options for the exception.
+     */
     constructor(status?: StatusCode, options?: HTTPExceptionOptions);
+    /**
+     * Returns the response object associated with the exception.
+     * If a response object is not provided, a new response is created with the error message and status code.
+     * @returns The response object.
+     */
     getResponse(): Response;
 }
 export {};

package/dist/types/index.d.ts

@@ -14,8 +14,23 @@
  * ```
  */
 import { Hono } from './hono';
+/**
+ * Types for environment variables, error handlers, handlers, middleware handlers, and more.
+ */
 export type { Env, ErrorHandler, Handler, MiddlewareHandler, Next, NotFoundHandler, ValidationTargets, Input, Schema, ToSchema, TypedResponse, } from './types';
+/**
+ * Types for context, context variable map, context renderer, and execution context.
+ */
 export type { Context, ContextVariableMap, ContextRenderer, ExecutionContext } from './context';
+/**
+ * Type for HonoRequest.
+ */
 export type { HonoRequest } from './request';
+/**
+ * Types for inferring request and response types and client request options.
+ */
 export type { InferRequestType, InferResponseType, ClientRequestOptions } from './client';
+/**
+ * Hono framework for building web applications.
+ */
 export { Hono };

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

@@ -1,2 +1,2 @@
 export declare const normalizeIntrinsicElementProps: (props: Record<string, unknown>) => void;
-export declare const styleObjectForEach: (style: Record<string, string>, fn: (key: string, value: string | null) => void) => void;
+export declare const styleObjectForEach: (style: Record<string, string | number>, fn: (key: string, value: string | null) => void) => void;

package/dist/types/preset/quick.d.ts

@@ -4,7 +4,7 @@
  */
 import { HonoBase } from '../hono-base';
 import type { HonoOptions } from '../hono-base';
-import type { BlankSchema, Env, Schema } from '../types';
-export declare class Hono<E extends Env = Env, S extends Schema = BlankSchema, BasePath extends string = '/'> extends HonoBase<E, S, BasePath> {
+import type { BlankEnv, BlankSchema, Env, Schema } from '../types';
+export declare class Hono<E extends Env = BlankEnv, S extends Schema = BlankSchema, BasePath extends string = '/'> extends HonoBase<E, S, BasePath> {
     constructor(options?: HonoOptions<E>);
 }

package/dist/types/preset/tiny.d.ts

@@ -4,7 +4,7 @@
  */
 import { HonoBase } from '../hono-base';
 import type { HonoOptions } from '../hono-base';
-import type { BlankSchema, Env, Schema } from '../types';
-export declare class Hono<E extends Env = Env, S extends Schema = BlankSchema, BasePath extends string = '/'> extends HonoBase<E, S, BasePath> {
+import type { BlankEnv, BlankSchema, Env, Schema } from '../types';
+export declare class Hono<E extends Env = BlankEnv, S extends Schema = BlankSchema, BasePath extends string = '/'> extends HonoBase<E, S, BasePath> {
     constructor(options?: HonoOptions<E>);
 }

package/dist/types/request.d.ts

@@ -147,9 +147,43 @@ export declare class HonoRequest<P extends string = '/', I extends Input['out']
      * @see https://hono.dev/api/request#arraybuffer
      */
     arrayBuffer(): Promise<ArrayBuffer>;
+    /**
+     * Parses the request body as a `Blob`.
+     * @example
+     * ```ts
+     * app.post('/entry', async (c) => {
+     *   const body = await c.req.blob();
+     * });
+     * ```
+     * @see https://hono.dev/api/request#blob
+     */
     blob(): Promise<Blob>;
+    /**
+     * Parses the request body as `FormData`.
+     * @example
+     * ```ts
+     * app.post('/entry', async (c) => {
+     *   const body = await c.req.formData();
+     * });
+     * ```
+     * @see https://hono.dev/api/request#formdata
+     */
     formData(): Promise<FormData>;
+    /**
+     * Adds validated data to the request.
+     *
+     * @param target - The target of the validation.
+     * @param data - The validated data to add.
+     */
     addValidatedData(target: keyof ValidationTargets, data: {}): void;
+    /**
+     * Gets validated data from the request.
+     *
+     * @param target - The target of the validation.
+     * @returns The validated data.
+     *
+     * @see https://hono.dev/api/request#valid
+     */
     valid<T extends keyof I & keyof ValidationTargets>(target: T): InputToDataByTarget<I, T>;
     /**
      * `.url()` can get the request url strings.

package/dist/types/router.d.ts

@@ -2,18 +2,96 @@
  * @module
  * This module provides types definitions and variables for the routers.
  */
+/**
+ * Constant representing all HTTP methods in uppercase.
+ */
 export declare const METHOD_NAME_ALL: "ALL";
+/**
+ * Constant representing all HTTP methods in lowercase.
+ */
 export declare const METHOD_NAME_ALL_LOWERCASE: "all";
+/**
+ * Array of supported HTTP methods.
+ */
 export declare const METHODS: readonly ["get", "post", "put", "delete", "options", "patch"];
+/**
+ * Error message indicating that a route cannot be added because the matcher is already built.
+ */
 export declare const MESSAGE_MATCHER_IS_ALREADY_BUILT = "Can not add a route since the matcher is already built.";
+/**
+ * Interface representing a router.
+ *
+ * @template T - The type of the handler.
+ */
 export interface Router<T> {
+    /**
+     * The name of the router.
+     */
     name: string;
+    /**
+     * Adds a route to the router.
+     *
+     * @param method - The HTTP method (e.g., 'get', 'post').
+     * @param path - The path for the route.
+     * @param handler - The handler for the route.
+     */
     add(method: string, path: string, handler: T): void;
+    /**
+     * Matches a route based on the given method and path.
+     *
+     * @param method - The HTTP method (e.g., 'get', 'post').
+     * @param path - The path to match.
+     * @returns The result of the match.
+     */
     match(method: string, path: string): Result<T>;
 }
+/**
+ * Type representing a map of parameter indices.
+ */
 export type ParamIndexMap = Record<string, number>;
+/**
+ * Type representing a stash of parameters.
+ */
 export type ParamStash = string[];
+/**
+ * Type representing a map of parameters.
+ */
 export type Params = Record<string, string>;
+/**
+ * Type representing the result of a route match.
+ *
+ * The result can be in one of two formats:
+ * 1. An array of handlers with their corresponding parameter index maps, followed by a parameter stash.
+ * 2. An array of handlers with their corresponding parameter maps.
+ *
+ * Example:
+ *
+ * [[handler, paramIndexMap][], paramArray]
+ * ```typescript
+ * [
+ *   [
+ *     [middlewareA, {}],                     // '*'
+ *     [funcA,       {'id': 0}],              // '/user/:id/*'
+ *     [funcB,       {'id': 0, 'action': 1}], // '/user/:id/:action'
+ *   ],
+ *   ['123', 'abc']
+ * ]
+ * ```
+ *
+ * [[handler, params][]]
+ * ```typescript
+ * [
+ *   [
+ *     [middlewareA, {}],                             // '*'
+ *     [funcA,       {'id': '123'}],                  // '/user/:id/*'
+ *     [funcB,       {'id': '123', 'action': 'abc'}], // '/user/:id/:action'
+ *   ]
+ * ]
+ * ```
+ */
 export type Result<T> = [[T, ParamIndexMap][], ParamStash] | [[T, Params][]];
+/**
+ * Error class representing an unsupported path error.
+ */
 export declare class UnsupportedPathError extends Error {
 }

package/dist/types/types.d.ts

@@ -8,6 +8,7 @@ import type { StatusCode } from './utils/http-status';
 import type { IfAnyThenEmptyObject, IsAny, JSONValue, Prettify, RemoveBlankRecord, Simplify, UnionToIntersection } from './utils/types';
 export type Bindings = Record<string, unknown>;
 export type Variables = Record<string, unknown>;
+export type BlankEnv = {};
 export type Env = {
     Bindings?: Bindings;
     Variables?: Variables;
@@ -32,7 +33,7 @@ export type MiddlewareHandler<E extends Env = any, P extends string = string, I
 export type H<E extends Env = any, P extends string = any, I extends Input = BlankInput, R extends HandlerResponse<any> = any> = Handler<E, P, I, R> | MiddlewareHandler<E, P, I>;
 export type NotFoundHandler<E extends Env = any> = (c: Context<E>) => Response | Promise<Response>;
 export type ErrorHandler<E extends Env = any> = (err: Error, c: Context<E>) => Response | Promise<Response>;
-export interface HandlerInterface<E extends Env = Env, M extends string = string, S extends Schema = {}, BasePath extends string = '/'> {
+export interface HandlerInterface<E extends Env = Env, M extends string = string, S extends Schema = BlankSchema, BasePath extends string = '/'> {
     <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, I extends Input = BlankInput, R extends HandlerResponse<any> = any, E2 extends Env = E>(handler: H<E2, P, I, R>): Hono<IntersectNonAnyTypes<[E, E2]>, S & ToSchema<M, P, I, MergeTypedResponse<R>>, BasePath>;
     <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, E2 extends Env = E>(path: P, handler: H<E2, MergedPath, I, R>): Hono<IntersectNonAnyTypes<[E, E2]>, S & ToSchema<M, MergePath<BasePath, P>, I, MergeTypedResponse<R>>, BasePath>;
     <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, I extends Input = BlankInput, I2 extends Input = I, R extends HandlerResponse<any> = any, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>>(...handlers: [H<E2, P, I>, H<E3, P, I2, R>]): Hono<IntersectNonAnyTypes<[E, E2, E3]>, S & ToSchema<M, P, I2, MergeTypedResponse<R>>, BasePath>;
@@ -156,9 +157,9 @@ export interface HandlerInterface<E extends Env = Env, M extends string = string
     ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11]>, S & ToSchema<M, MergePath<BasePath, P>, I10, MergeTypedResponse<R>>, BasePath>;
     <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, I extends Input = BlankInput, R extends HandlerResponse<any> = any>(...handlers: H<E, P, I, R>[]): Hono<E, S & ToSchema<M, P, I, MergeTypedResponse<R>>, BasePath>;
     <P extends string, I extends Input = BlankInput, R extends HandlerResponse<any> = any>(path: P, ...handlers: H<E, MergePath<BasePath, P>, I, R>[]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I, MergeTypedResponse<R>>, BasePath>;
-    <P extends string, R extends HandlerResponse<any> = any, I extends Input = {}>(path: P): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I, MergeTypedResponse<R>>, BasePath>;
+    <P extends string, R extends HandlerResponse<any> = any, I extends Input = BlankInput>(path: P): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I, MergeTypedResponse<R>>, BasePath>;
 }
-export interface MiddlewareHandlerInterface<E extends Env = Env, S extends Schema = {}, BasePath extends string = '/'> {
+export interface MiddlewareHandlerInterface<E extends Env = Env, S extends Schema = BlankSchema, BasePath extends string = '/'> {
     <E2 extends Env = E>(...handlers: MiddlewareHandler<E2, MergePath<BasePath, ExtractKey<S>>>[]): Hono<IntersectNonAnyTypes<[E, E2]>, S, BasePath>;
     <E2 extends Env = E>(handler: MiddlewareHandler<E2, MergePath<BasePath, ExtractKey<S>>>): Hono<IntersectNonAnyTypes<[E, E2]>, S, BasePath>;
     <E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, P extends string = MergePath<BasePath, ExtractKey<S>>>(...handlers: [MiddlewareHandler<E2, P>, MiddlewareHandler<E3, P>]): Hono<IntersectNonAnyTypes<[E, E2, E3]>, S, BasePath>;
@@ -228,7 +229,7 @@ export interface MiddlewareHandlerInterface<E extends Env = Env, S extends Schem
     ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11]>, S, BasePath>;
     <P extends string, E2 extends Env = E>(path: P, ...handlers: MiddlewareHandler<E2, MergePath<BasePath, P>>[]): Hono<E, S, BasePath>;
 }
-export interface OnHandlerInterface<E extends Env = Env, S extends Schema = {}, BasePath extends string = '/'> {
+export interface OnHandlerInterface<E extends Env = Env, S extends Schema = BlankSchema, BasePath extends string = '/'> {
     <M extends string, P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, E2 extends Env = E>(method: M, path: P, handler: H<E2, MergedPath, I, R>): Hono<IntersectNonAnyTypes<[E, E2]>, S & ToSchema<M, MergePath<BasePath, P>, I, MergeTypedResponse<R>>, BasePath>;
     <M extends string, P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>>(method: M, path: P, ...handlers: [H<E2, MergedPath, I>, H<E3, MergedPath, I2, R>]): Hono<IntersectNonAnyTypes<[E, E2, E3]>, S & ToSchema<M, MergePath<BasePath, P>, I2, MergeTypedResponse<R>>, BasePath>;
     <M extends string, P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, E2 extends Env = E, E3 extends Env = E, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>>(method: M, path: P, ...handlers: [H<E2, MergedPath, I>, H<E3, MergedPath, I2>, H<E4, MergedPath, I3, R>]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4]>, S & ToSchema<M, MergePath<BasePath, P>, I3, MergeTypedResponse<R>>, BasePath>;
@@ -295,7 +296,7 @@ export interface OnHandlerInterface<E extends Env = Env, S extends Schema = {},
         H<E10, MergedPath, I9>,
         H<E11, MergedPath, I10>
     ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11]>, S & ToSchema<M, MergePath<BasePath, P>, I10, MergeTypedResponse<HandlerResponse<any>>>, BasePath>;
-    <M extends string, P extends string, R extends HandlerResponse<any> = any, I extends Input = {}>(method: M, path: P, ...handlers: H<E, MergePath<BasePath, P>, I, R>[]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I, MergeTypedResponse<R>>, BasePath>;
+    <M extends string, P extends string, R extends HandlerResponse<any> = any, I extends Input = BlankInput>(method: M, path: P, ...handlers: H<E, MergePath<BasePath, P>, I, R>[]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I, MergeTypedResponse<R>>, BasePath>;
     <Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, E2 extends Env = E>(methods: Ms, path: P, handler: H<E2, MergedPath, I, R>): Hono<IntersectNonAnyTypes<[E, E2]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I, MergeTypedResponse<R>>, BasePath>;
     <Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>>(methods: Ms, path: P, ...handlers: [H<E2, MergedPath, I>, H<E3, MergedPath, I2, R>]): Hono<IntersectNonAnyTypes<[E, E2, E3]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I2, MergeTypedResponse<R>>, BasePath>;
     <Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, E2 extends Env = E, E3 extends Env = E, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>>(methods: Ms, path: P, ...handlers: [H<E2, MergedPath, I>, H<E3, MergedPath, I2>, H<E4, MergedPath, I3, R>]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I3, MergeTypedResponse<R>>, BasePath>;
@@ -362,7 +363,7 @@ export interface OnHandlerInterface<E extends Env = Env, S extends Schema = {},
         H<E10, MergedPath, I9>,
         H<E11, MergedPath, I10>
     ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I10, MergeTypedResponse<HandlerResponse<any>>>, BasePath>;
-    <P extends string, R extends HandlerResponse<any> = any, I extends Input = {}>(methods: string[], path: P, ...handlers: H<E, MergePath<BasePath, P>, I, R>[]): Hono<E, S & ToSchema<string, MergePath<BasePath, P>, I, MergeTypedResponse<R>>, BasePath>;
+    <P extends string, R extends HandlerResponse<any> = any, I extends Input = BlankInput>(methods: string[], path: P, ...handlers: H<E, MergePath<BasePath, P>, I, R>[]): Hono<E, S & ToSchema<string, MergePath<BasePath, P>, I, MergeTypedResponse<R>>, BasePath>;
     <I extends Input = BlankInput, R extends HandlerResponse<any> = any>(methods: string | string[], paths: string[], ...handlers: H<E, any, I, R>[]): Hono<E, S & ToSchema<string, string, I, MergeTypedResponse<R>>, BasePath>;
 }
 type ExtractKey<S> = S extends Record<infer Key, unknown> ? Key extends string ? Key : never : string;

package/dist/validator/validator.js

@@ -8,7 +8,7 @@ var validator = (target, validationFunc) => {
     const contentType = c.req.header("Content-Type");
     switch (target) {
       case "json":
-        if (!contentType || !/^application\/([a-z-]+\+)?json/.test(contentType)) {
+        if (!contentType || !/^application\/([a-z-\.]+\+)?json/.test(contentType)) {
           const message = `Invalid HTTP header: Content-Type=${contentType}`;
           throw new HTTPException(400, { message });
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hono",
-  "version": "4.4.0",
+  "version": "4.4.2",
   "description": "Ultrafast web framework for the Edges",
   "main": "dist/cjs/index.js",
   "type": "module",
@@ -583,7 +583,7 @@
     "eslint": "^8.55.0",
     "glob": "7.2.3",
     "jsdom": "^22.1.0",
-    "msw": "1.3.2",
+    "msw": "^2.3.0",
     "np": "7.7.0",
     "prettier": "^2.6.2",
     "publint": "^0.1.8",