hono 4.6.6 → 4.6.7

package/dist/adapter/bun/websocket.js

@@ -1,44 +1,40 @@
 // src/adapter/bun/websocket.ts
-import { createWSMessageEvent } from "../../helper/websocket/index.js";
+import { createWSMessageEvent, defineWebSocketHelper, WSContext } from "../../helper/websocket/index.js";
 import { getBunServer } from "./server.js";
 var createWSContext = (ws) => {
-  return {
+  return new WSContext({
     send: (source, options) => {
-      const sendingData = typeof source === "string" ? source : source instanceof Uint8Array ? source.buffer : source;
-      ws.send(sendingData, options?.compress);
+      ws.send(source, options?.compress);
     },
     raw: ws,
-    binaryType: "arraybuffer",
     readyState: ws.readyState,
     url: ws.data.url,
     protocol: ws.data.protocol,
     close(code, reason) {
       ws.close(code, reason);
     }
-  };
+  });
 };
 var createBunWebSocket = () => {
   const websocketConns = [];
-  const upgradeWebSocket = (createEvents) => {
-    return async (c, next) => {
-      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: {
-          connId,
-          url: new URL(c.req.url),
-          protocol: c.req.url
-        }
-      });
-      if (upgradeResult) {
-        return new Response(null);
+  const upgradeWebSocket = defineWebSocketHelper((c, events) => {
+    const server = getBunServer(c);
+    if (!server) {
+      throw new TypeError("env has to include the 2nd argument of fetch.");
+    }
+    const connId = websocketConns.push(events) - 1;
+    const upgradeResult = server.upgrade(c.req.raw, {
+      data: {
+        connId,
+        url: new URL(c.req.url),
+        protocol: c.req.url
       }
-      await next();
-    };
-  };
+    });
+    if (upgradeResult) {
+      return new Response(null);
+    }
+    return;
+  });
   const websocket = {
     open(ws) {
       const websocketListeners = websocketConns[ws.data.connId];
@@ -75,5 +71,6 @@ var createBunWebSocket = () => {
   };
 };
 export {
-  createBunWebSocket
+  createBunWebSocket,
+  createWSContext
 };

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

@@ -1,44 +1,45 @@
 // src/adapter/cloudflare-workers/websocket.ts
-var upgradeWebSocket = (createEvents) => async (c, next) => {
-  const events = await createEvents(c);
-  const upgradeHeader = c.req.header("Upgrade");
-  if (upgradeHeader !== "websocket") {
-    return await next();
+import { WSContext, defineWebSocketHelper } from "../../helper/websocket/index.js";
+var upgradeWebSocket = defineWebSocketHelper(
+  async (c, events) => {
+    const upgradeHeader = c.req.header("Upgrade");
+    if (upgradeHeader !== "websocket") {
+      return;
+    }
+    const webSocketPair = new WebSocketPair();
+    const client = webSocketPair[0];
+    const server = webSocketPair[1];
+    const wsContext = new WSContext({
+      close: (code, reason) => server.close(code, reason),
+      get protocol() {
+        return server.protocol;
+      },
+      raw: server,
+      get readyState() {
+        return server.readyState;
+      },
+      url: server.url ? new URL(server.url) : null,
+      send: (source) => server.send(source)
+    });
+    if (events.onOpen) {
+      server.addEventListener("open", (evt) => events.onOpen?.(evt, wsContext));
+    }
+    if (events.onClose) {
+      server.addEventListener("close", (evt) => events.onClose?.(evt, wsContext));
+    }
+    if (events.onMessage) {
+      server.addEventListener("message", (evt) => events.onMessage?.(evt, wsContext));
+    }
+    if (events.onError) {
+      server.addEventListener("error", (evt) => events.onError?.(evt, wsContext));
+    }
+    server.accept?.();
+    return new Response(null, {
+      status: 101,
+      webSocket: client
+    });
   }
-  const webSocketPair = new WebSocketPair();
-  const client = webSocketPair[0];
-  const server = webSocketPair[1];
-  const wsContext = {
-    binaryType: "arraybuffer",
-    close: (code, reason) => server.close(code, reason),
-    get protocol() {
-      return server.protocol;
-    },
-    raw: server,
-    get readyState() {
-      return server.readyState;
-    },
-    url: server.url ? new URL(server.url) : null,
-    send: (source) => server.send(source)
-  };
-  if (events.onOpen) {
-    server.addEventListener("open", (evt) => events.onOpen?.(evt, wsContext));
-  }
-  if (events.onClose) {
-    server.addEventListener("close", (evt) => events.onClose?.(evt, wsContext));
-  }
-  if (events.onMessage) {
-    server.addEventListener("message", (evt) => events.onMessage?.(evt, wsContext));
-  }
-  if (events.onError) {
-    server.addEventListener("error", (evt) => events.onError?.(evt, wsContext));
-  }
-  server.accept?.();
-  return new Response(null, {
-    status: 101,
-    webSocket: client
-  });
-};
+);
 export {
   upgradeWebSocket
 };

package/dist/adapter/deno/websocket.js

@@ -1,12 +1,11 @@
 // src/adapter/deno/websocket.ts
-var upgradeWebSocket = (createEvents, options) => async (c, next) => {
+import { WSContext, defineWebSocketHelper } from "../../helper/websocket/index.js";
+var upgradeWebSocket = defineWebSocketHelper(async (c, events, options) => {
   if (c.req.header("upgrade") !== "websocket") {
-    return await next();
+    return;
   }
-  const events = await createEvents(c);
-  const { response, socket } = Deno.upgradeWebSocket(c.req.raw, options || {});
-  const wsContext = {
-    binaryType: "arraybuffer",
+  const { response, socket } = Deno.upgradeWebSocket(c.req.raw, options ?? {});
+  const wsContext = new WSContext({
     close: (code, reason) => socket.close(code, reason),
     get protocol() {
       return socket.protocol;
@@ -17,13 +16,13 @@ var upgradeWebSocket = (createEvents, options) => async (c, next) => {
     },
     url: socket.url ? new URL(socket.url) : null,
     send: (source) => socket.send(source)
-  };
+  });
   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 {
   upgradeWebSocket
 };

package/dist/adapter/vercel/handler.js

@@ -1,6 +1,6 @@
 // src/adapter/vercel/handler.ts
-var handle = (app) => (req, requestContext) => {
-  return app.fetch(req, {}, requestContext);
+var handle = (app) => (req) => {
+  return app.fetch(req);
 };
 export {
   handle

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

@@ -18,49 +18,46 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var websocket_exports = {};
 __export(websocket_exports, {
-  createBunWebSocket: () => createBunWebSocket
+  createBunWebSocket: () => createBunWebSocket,
+  createWSContext: () => createWSContext
 });
 module.exports = __toCommonJS(websocket_exports);
 var import_websocket = require("../../helper/websocket");
 var import_server = require("./server");
 const createWSContext = (ws) => {
-  return {
+  return new import_websocket.WSContext({
     send: (source, options) => {
-      const sendingData = typeof source === "string" ? source : source instanceof Uint8Array ? source.buffer : source;
-      ws.send(sendingData, options?.compress);
+      ws.send(source, options?.compress);
     },
     raw: ws,
-    binaryType: "arraybuffer",
     readyState: ws.readyState,
     url: ws.data.url,
     protocol: ws.data.protocol,
     close(code, reason) {
       ws.close(code, reason);
     }
-  };
+  });
 };
 const createBunWebSocket = () => {
   const websocketConns = [];
-  const upgradeWebSocket = (createEvents) => {
-    return async (c, next) => {
-      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: {
-          connId,
-          url: new URL(c.req.url),
-          protocol: c.req.url
-        }
-      });
-      if (upgradeResult) {
-        return new Response(null);
+  const upgradeWebSocket = (0, import_websocket.defineWebSocketHelper)((c, events) => {
+    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(events) - 1;
+    const upgradeResult = server.upgrade(c.req.raw, {
+      data: {
+        connId,
+        url: new URL(c.req.url),
+        protocol: c.req.url
       }
-      await next();
-    };
-  };
+    });
+    if (upgradeResult) {
+      return new Response(null);
+    }
+    return;
+  });
   const websocket = {
     open(ws) {
       const websocketListeners = websocketConns[ws.data.connId];
@@ -98,5 +95,6 @@ const createBunWebSocket = () => {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  createBunWebSocket
+  createBunWebSocket,
+  createWSContext
 });

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

@@ -21,46 +21,47 @@ __export(websocket_exports, {
   upgradeWebSocket: () => upgradeWebSocket
 });
 module.exports = __toCommonJS(websocket_exports);
-const upgradeWebSocket = (createEvents) => async (c, next) => {
-  const events = await createEvents(c);
-  const upgradeHeader = c.req.header("Upgrade");
-  if (upgradeHeader !== "websocket") {
-    return await next();
+var import_websocket = require("../../helper/websocket");
+const upgradeWebSocket = (0, import_websocket.defineWebSocketHelper)(
+  async (c, events) => {
+    const upgradeHeader = c.req.header("Upgrade");
+    if (upgradeHeader !== "websocket") {
+      return;
+    }
+    const webSocketPair = new WebSocketPair();
+    const client = webSocketPair[0];
+    const server = webSocketPair[1];
+    const wsContext = new import_websocket.WSContext({
+      close: (code, reason) => server.close(code, reason),
+      get protocol() {
+        return server.protocol;
+      },
+      raw: server,
+      get readyState() {
+        return server.readyState;
+      },
+      url: server.url ? new URL(server.url) : null,
+      send: (source) => server.send(source)
+    });
+    if (events.onOpen) {
+      server.addEventListener("open", (evt) => events.onOpen?.(evt, wsContext));
+    }
+    if (events.onClose) {
+      server.addEventListener("close", (evt) => events.onClose?.(evt, wsContext));
+    }
+    if (events.onMessage) {
+      server.addEventListener("message", (evt) => events.onMessage?.(evt, wsContext));
+    }
+    if (events.onError) {
+      server.addEventListener("error", (evt) => events.onError?.(evt, wsContext));
+    }
+    server.accept?.();
+    return new Response(null, {
+      status: 101,
+      webSocket: client
+    });
   }
-  const webSocketPair = new WebSocketPair();
-  const client = webSocketPair[0];
-  const server = webSocketPair[1];
-  const wsContext = {
-    binaryType: "arraybuffer",
-    close: (code, reason) => server.close(code, reason),
-    get protocol() {
-      return server.protocol;
-    },
-    raw: server,
-    get readyState() {
-      return server.readyState;
-    },
-    url: server.url ? new URL(server.url) : null,
-    send: (source) => server.send(source)
-  };
-  if (events.onOpen) {
-    server.addEventListener("open", (evt) => events.onOpen?.(evt, wsContext));
-  }
-  if (events.onClose) {
-    server.addEventListener("close", (evt) => events.onClose?.(evt, wsContext));
-  }
-  if (events.onMessage) {
-    server.addEventListener("message", (evt) => events.onMessage?.(evt, wsContext));
-  }
-  if (events.onError) {
-    server.addEventListener("error", (evt) => events.onError?.(evt, wsContext));
-  }
-  server.accept?.();
-  return new Response(null, {
-    status: 101,
-    webSocket: client
-  });
-};
+);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   upgradeWebSocket

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

@@ -21,14 +21,13 @@ __export(websocket_exports, {
   upgradeWebSocket: () => upgradeWebSocket
 });
 module.exports = __toCommonJS(websocket_exports);
-const upgradeWebSocket = (createEvents, options) => async (c, next) => {
+var import_websocket = require("../../helper/websocket");
+const upgradeWebSocket = (0, import_websocket.defineWebSocketHelper)(async (c, events, options) => {
   if (c.req.header("upgrade") !== "websocket") {
-    return await next();
+    return;
   }
-  const events = await createEvents(c);
-  const { response, socket } = Deno.upgradeWebSocket(c.req.raw, options || {});
-  const wsContext = {
-    binaryType: "arraybuffer",
+  const { response, socket } = Deno.upgradeWebSocket(c.req.raw, options ?? {});
+  const wsContext = new import_websocket.WSContext({
     close: (code, reason) => socket.close(code, reason),
     get protocol() {
       return socket.protocol;
@@ -39,13 +38,13 @@ const upgradeWebSocket = (createEvents, options) => async (c, next) => {
     },
     url: socket.url ? new URL(socket.url) : null,
     send: (source) => socket.send(source)
-  };
+  });
   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:
 0 && (module.exports = {
   upgradeWebSocket

package/dist/cjs/adapter/vercel/handler.js

@@ -21,8 +21,8 @@ __export(handler_exports, {
   handle: () => handle
 });
 module.exports = __toCommonJS(handler_exports);
-const handle = (app) => (req, requestContext) => {
-  return app.fetch(req, {}, requestContext);
+const handle = (app) => (req) => {
+  return app.fetch(req);
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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

@@ -18,15 +18,56 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var websocket_exports = {};
 __export(websocket_exports, {
-  createWSMessageEvent: () => createWSMessageEvent
+  WSContext: () => WSContext,
+  createWSMessageEvent: () => createWSMessageEvent,
+  defineWebSocketHelper: () => defineWebSocketHelper
 });
 module.exports = __toCommonJS(websocket_exports);
+class WSContext {
+  #init;
+  constructor(init) {
+    this.#init = init;
+    this.raw = init.raw;
+    this.url = init.url ? new URL(init.url) : null;
+    this.protocol = init.protocol ?? null;
+  }
+  send(source, options) {
+    this.#init.send(
+      typeof source === "string" ? source : source instanceof Uint8Array ? source.buffer : source,
+      options ?? {}
+    );
+  }
+  raw;
+  binaryType = "arraybuffer";
+  get readyState() {
+    return this.#init.readyState;
+  }
+  url;
+  protocol;
+  close(code, reason) {
+    this.#init.close(code, reason);
+  }
+}
 const createWSMessageEvent = (source) => {
   return new MessageEvent("message", {
     data: source
   });
 };
+const defineWebSocketHelper = (handler) => {
+  return (createEvents, options) => {
+    return async function UpgradeWebSocket(c, next) {
+      const events = await createEvents(c);
+      const result = await handler(c, events, options);
+      if (result) {
+        return result;
+      }
+      await next();
+    };
+  };
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  createWSMessageEvent
+  WSContext,
+  createWSMessageEvent,
+  defineWebSocketHelper
 });

package/dist/cjs/router/linear-router/router.js

@@ -30,104 +30,102 @@ class LinearRouter {
   name = "LinearRouter";
   routes = [];
   add(method, path, handler) {
-    ;
-    ((0, import_url.checkOptionalParameter)(path) || [path]).forEach((p) => {
-      this.routes.push([method, p, handler]);
-    });
+    for (let i = 0, paths = (0, import_url.checkOptionalParameter)(path) || [path], len = paths.length; i < len; i++) {
+      this.routes.push([method, paths[i], handler]);
+    }
   }
   match(method, path) {
     const handlers = [];
     ROUTES_LOOP:
       for (let i = 0, len = this.routes.length; i < len; i++) {
         const [routeMethod, routePath, handler] = this.routes[i];
-        if (routeMethod !== method && routeMethod !== import_router.METHOD_NAME_ALL) {
-          continue;
-        }
-        if (routePath === "*" || routePath === "/*") {
-          handlers.push([handler, emptyParams]);
-          continue;
-        }
-        const hasStar = routePath.indexOf("*") !== -1;
-        const hasLabel = routePath.indexOf(":") !== -1;
-        if (!hasStar && !hasLabel) {
-          if (routePath === path || routePath + "/" === path) {
+        if (routeMethod === method || routeMethod === import_router.METHOD_NAME_ALL) {
+          if (routePath === "*" || routePath === "/*") {
             handlers.push([handler, emptyParams]);
+            continue;
           }
-        } else if (hasStar && !hasLabel) {
-          const endsWithStar = routePath.charCodeAt(routePath.length - 1) === 42;
-          const parts = (endsWithStar ? routePath.slice(0, -2) : routePath).split(splitByStarRe);
-          const lastIndex = parts.length - 1;
-          for (let j = 0, pos = 0, len2 = parts.length; j < len2; j++) {
-            const part = parts[j];
-            const index = path.indexOf(part, pos);
-            if (index !== pos) {
-              continue ROUTES_LOOP;
+          const hasStar = routePath.indexOf("*") !== -1;
+          const hasLabel = routePath.indexOf(":") !== -1;
+          if (!hasStar && !hasLabel) {
+            if (routePath === path || routePath + "/" === path) {
+              handlers.push([handler, emptyParams]);
             }
-            pos += part.length;
-            if (j === lastIndex) {
-              if (!endsWithStar && pos !== path.length && !(pos === path.length - 1 && path.charCodeAt(pos) === 47)) {
-                continue ROUTES_LOOP;
-              }
-            } else {
-              const index2 = path.indexOf("/", pos);
-              if (index2 === -1) {
+          } else if (hasStar && !hasLabel) {
+            const endsWithStar = routePath.charCodeAt(routePath.length - 1) === 42;
+            const parts = (endsWithStar ? routePath.slice(0, -2) : routePath).split(splitByStarRe);
+            const lastIndex = parts.length - 1;
+            for (let j = 0, pos = 0, len2 = parts.length; j < len2; j++) {
+              const part = parts[j];
+              const index = path.indexOf(part, pos);
+              if (index !== pos) {
                 continue ROUTES_LOOP;
               }
-              pos = index2;
-            }
-          }
-          handlers.push([handler, emptyParams]);
-        } else if (hasLabel && !hasStar) {
-          const params = /* @__PURE__ */ Object.create(null);
-          const parts = routePath.match(splitPathRe);
-          const lastIndex = parts.length - 1;
-          for (let j = 0, pos = 0, len2 = parts.length; j < len2; j++) {
-            if (pos === -1 || pos >= path.length) {
-              continue ROUTES_LOOP;
-            }
-            const part = parts[j];
-            if (part.charCodeAt(1) === 58) {
-              let name = part.slice(2);
-              let value;
-              if (name.charCodeAt(name.length - 1) === 125) {
-                const openBracePos = name.indexOf("{");
-                const pattern = name.slice(openBracePos + 1, -1);
-                const restPath = path.slice(pos + 1);
-                const match = new RegExp(pattern, "d").exec(restPath);
-                if (!match || match.indices[0][0] !== 0 || match.indices[0][1] === 0) {
+              pos += part.length;
+              if (j === lastIndex) {
+                if (!endsWithStar && pos !== path.length && !(pos === path.length - 1 && path.charCodeAt(pos) === 47)) {
                   continue ROUTES_LOOP;
                 }
-                name = name.slice(0, openBracePos);
-                value = restPath.slice(...match.indices[0]);
-                pos += match.indices[0][1] + 1;
               } else {
-                let endValuePos = path.indexOf("/", pos + 1);
-                if (endValuePos === -1) {
-                  if (pos + 1 === path.length) {
-                    continue ROUTES_LOOP;
-                  }
-                  endValuePos = path.length;
+                const index2 = path.indexOf("/", pos);
+                if (index2 === -1) {
+                  continue ROUTES_LOOP;
                 }
-                value = path.slice(pos + 1, endValuePos);
-                pos = endValuePos;
-              }
-              params[name] ||= value;
-            } else {
-              const index = path.indexOf(part, pos);
-              if (index !== pos) {
-                continue ROUTES_LOOP;
+                pos = index2;
               }
-              pos += part.length;
             }
-            if (j === lastIndex) {
-              if (pos !== path.length && !(pos === path.length - 1 && path.charCodeAt(pos) === 47)) {
+            handlers.push([handler, emptyParams]);
+          } else if (hasLabel && !hasStar) {
+            const params = /* @__PURE__ */ Object.create(null);
+            const parts = routePath.match(splitPathRe);
+            const lastIndex = parts.length - 1;
+            for (let j = 0, pos = 0, len2 = parts.length; j < len2; j++) {
+              if (pos === -1 || pos >= path.length) {
                 continue ROUTES_LOOP;
               }
+              const part = parts[j];
+              if (part.charCodeAt(1) === 58) {
+                let name = part.slice(2);
+                let value;
+                if (name.charCodeAt(name.length - 1) === 125) {
+                  const openBracePos = name.indexOf("{");
+                  const pattern = name.slice(openBracePos + 1, -1);
+                  const restPath = path.slice(pos + 1);
+                  const match = new RegExp(pattern, "d").exec(restPath);
+                  if (!match || match.indices[0][0] !== 0 || match.indices[0][1] === 0) {
+                    continue ROUTES_LOOP;
+                  }
+                  name = name.slice(0, openBracePos);
+                  value = restPath.slice(...match.indices[0]);
+                  pos += match.indices[0][1] + 1;
+                } else {
+                  let endValuePos = path.indexOf("/", pos + 1);
+                  if (endValuePos === -1) {
+                    if (pos + 1 === path.length) {
+                      continue ROUTES_LOOP;
+                    }
+                    endValuePos = path.length;
+                  }
+                  value = path.slice(pos + 1, endValuePos);
+                  pos = endValuePos;
+                }
+                params[name] ||= value;
+              } else {
+                const index = path.indexOf(part, pos);
+                if (index !== pos) {
+                  continue ROUTES_LOOP;
+                }
+                pos += part.length;
+              }
+              if (j === lastIndex) {
+                if (pos !== path.length && !(pos === path.length - 1 && path.charCodeAt(pos) === 47)) {
+                  continue ROUTES_LOOP;
+                }
+              }
             }
+            handlers.push([handler, params]);
+          } else if (hasLabel && hasStar) {
+            throw new import_router.UnsupportedPathError();
           }
-          handlers.push([handler, params]);
-        } else if (hasLabel && hasStar) {
-          throw new import_router.UnsupportedPathError();
         }
       }
     return [handlers];

package/dist/cjs/router/pattern-router/router.js

@@ -50,8 +50,9 @@ class PatternRouter {
   }
   match(method, path) {
     const handlers = [];
-    for (const [pattern, routeMethod, handler] of this.routes) {
-      if (routeMethod === import_router.METHOD_NAME_ALL || routeMethod === method) {
+    for (let i = 0, len = this.routes.length; i < len; i++) {
+      const [pattern, routeMethod, handler] = this.routes[i];
+      if (routeMethod === method || routeMethod === import_router.METHOD_NAME_ALL) {
         const match = pattern.exec(path);
         if (match) {
           handlers.push([handler, match.groups || /* @__PURE__ */ Object.create(null)]);

package/dist/cjs/router/smart-router/router.js

@@ -46,9 +46,9 @@ class SmartRouter {
     for (; i < len; i++) {
       const router = routers[i];
       try {
-        routes.forEach((args) => {
-          router.add(...args);
-        });
+        for (let i2 = 0, len2 = routes.length; i2 < len2; i2++) {
+          router.add(...routes[i2]);
+        }
         res = router.match(method, path);
       } catch (e) {
         if (e instanceof import_router.UnsupportedPathError) {

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

@@ -28,21 +28,18 @@ class Node {
   children;
   patterns;
   order = 0;
-  name;
   params = /* @__PURE__ */ Object.create(null);
   constructor(method, handler, children) {
     this.children = children || /* @__PURE__ */ Object.create(null);
     this.methods = [];
-    this.name = "";
     if (method && handler) {
       const m = /* @__PURE__ */ Object.create(null);
-      m[method] = { handler, possibleKeys: [], score: 0, name: this.name };
+      m[method] = { handler, possibleKeys: [], score: 0 };
       this.methods = [m];
     }
     this.patterns = [];
   }
   insert(method, path, handler) {
-    this.name = `${method} ${path}`;
     this.order = ++this.order;
     let curNode = this;
     const parts = (0, import_url.splitRoutingPath)(path);
@@ -72,7 +69,6 @@ class Node {
     const handlerSet = {
       handler,
       possibleKeys: possibleKeys.filter((v, i, a) => a.indexOf(v) === i),
-      name: this.name,
       score: this.order
     };
     m[method] = handlerSet;
@@ -87,11 +83,12 @@ class Node {
       const processedSet = /* @__PURE__ */ Object.create(null);
       if (handlerSet !== void 0) {
         handlerSet.params = /* @__PURE__ */ Object.create(null);
-        handlerSet.possibleKeys.forEach((key) => {
-          const processed = processedSet[handlerSet.name];
+        for (let i2 = 0, len2 = handlerSet.possibleKeys.length; i2 < len2; i2++) {
+          const key = handlerSet.possibleKeys[i2];
+          const processed = processedSet[handlerSet.score];
           handlerSet.params[key] = params[key] && !processed ? params[key] : nodeParams[key] ?? params[key];
-          processedSet[handlerSet.name] = true;
-        });
+          processedSet[handlerSet.score] = true;
+        }
         handlerSets.push(handlerSet);
       }
     }
@@ -112,7 +109,7 @@ class Node {
         const nextNode = node.children[part];
         if (nextNode) {
           nextNode.params = node.params;
-          if (isLast === true) {
+          if (isLast) {
             if (nextNode.children["*"]) {
               handlerSets.push(
                 ...this.gHSets(nextNode.children["*"], method, node.params, /* @__PURE__ */ Object.create(null))
@@ -145,10 +142,10 @@ class Node {
             handlerSets.push(...this.gHSets(child, method, node.params, params));
             continue;
           }
-          if (matcher === true || matcher instanceof RegExp && matcher.test(part)) {
+          if (matcher === true || matcher.test(part)) {
             if (typeof key === "string") {
               params[name] = part;
-              if (isLast === true) {
+              if (isLast) {
                 handlerSets.push(...this.gHSets(child, method, params, node.params));
                 if (child.children["*"]) {
                   handlerSets.push(...this.gHSets(child.children["*"], method, params, node.params));

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

@@ -32,8 +32,8 @@ class TrieRouter {
   add(method, path, handler) {
     const results = (0, import_url.checkOptionalParameter)(path);
     if (results) {
-      for (const p of results) {
-        this.node.insert(method, p, handler);
+      for (let i = 0, len = results.length; i < len; i++) {
+        this.node.insert(method, results[i], handler);
       }
       return;
     }

package/dist/cjs/utils/jwt/jws.js

@@ -44,8 +44,10 @@ async function importPrivateKey(key, alg) {
     throw new Error("`crypto.subtle.importKey` is undefined. JWT auth middleware requires it.");
   }
   if (isCryptoKey(key)) {
-    if (key.type !== "private") {
-      throw new Error(`unexpected non private key: CryptoKey.type is ${key.type}`);
+    if (key.type !== "private" && key.type !== "secret") {
+      throw new Error(
+        `unexpected key type: CryptoKey.type is ${key.type}, expected private or secret`
+      );
     }
     return key;
   }

package/dist/helper/websocket/index.js

@@ -1,9 +1,48 @@
 // src/helper/websocket/index.ts
+var WSContext = class {
+  #init;
+  constructor(init) {
+    this.#init = init;
+    this.raw = init.raw;
+    this.url = init.url ? new URL(init.url) : null;
+    this.protocol = init.protocol ?? null;
+  }
+  send(source, options) {
+    this.#init.send(
+      typeof source === "string" ? source : source instanceof Uint8Array ? source.buffer : source,
+      options ?? {}
+    );
+  }
+  raw;
+  binaryType = "arraybuffer";
+  get readyState() {
+    return this.#init.readyState;
+  }
+  url;
+  protocol;
+  close(code, reason) {
+    this.#init.close(code, reason);
+  }
+};
 var createWSMessageEvent = (source) => {
   return new MessageEvent("message", {
     data: source
   });
 };
+var defineWebSocketHelper = (handler) => {
+  return (createEvents, options) => {
+    return async function UpgradeWebSocket(c, next) {
+      const events = await createEvents(c);
+      const result = await handler(c, events, options);
+      if (result) {
+        return result;
+      }
+      await next();
+    };
+  };
+};
 export {
-  createWSMessageEvent
+  WSContext,
+  createWSMessageEvent,
+  defineWebSocketHelper
 };

package/dist/router/linear-router/router.js

@@ -8,104 +8,102 @@ var LinearRouter = class {
   name = "LinearRouter";
   routes = [];
   add(method, path, handler) {
-    ;
-    (checkOptionalParameter(path) || [path]).forEach((p) => {
-      this.routes.push([method, p, handler]);
-    });
+    for (let i = 0, paths = checkOptionalParameter(path) || [path], len = paths.length; i < len; i++) {
+      this.routes.push([method, paths[i], handler]);
+    }
   }
   match(method, path) {
     const handlers = [];
     ROUTES_LOOP:
       for (let i = 0, len = this.routes.length; i < len; i++) {
         const [routeMethod, routePath, handler] = this.routes[i];
-        if (routeMethod !== method && routeMethod !== METHOD_NAME_ALL) {
-          continue;
-        }
-        if (routePath === "*" || routePath === "/*") {
-          handlers.push([handler, emptyParams]);
-          continue;
-        }
-        const hasStar = routePath.indexOf("*") !== -1;
-        const hasLabel = routePath.indexOf(":") !== -1;
-        if (!hasStar && !hasLabel) {
-          if (routePath === path || routePath + "/" === path) {
+        if (routeMethod === method || routeMethod === METHOD_NAME_ALL) {
+          if (routePath === "*" || routePath === "/*") {
             handlers.push([handler, emptyParams]);
+            continue;
           }
-        } else if (hasStar && !hasLabel) {
-          const endsWithStar = routePath.charCodeAt(routePath.length - 1) === 42;
-          const parts = (endsWithStar ? routePath.slice(0, -2) : routePath).split(splitByStarRe);
-          const lastIndex = parts.length - 1;
-          for (let j = 0, pos = 0, len2 = parts.length; j < len2; j++) {
-            const part = parts[j];
-            const index = path.indexOf(part, pos);
-            if (index !== pos) {
-              continue ROUTES_LOOP;
+          const hasStar = routePath.indexOf("*") !== -1;
+          const hasLabel = routePath.indexOf(":") !== -1;
+          if (!hasStar && !hasLabel) {
+            if (routePath === path || routePath + "/" === path) {
+              handlers.push([handler, emptyParams]);
             }
-            pos += part.length;
-            if (j === lastIndex) {
-              if (!endsWithStar && pos !== path.length && !(pos === path.length - 1 && path.charCodeAt(pos) === 47)) {
-                continue ROUTES_LOOP;
-              }
-            } else {
-              const index2 = path.indexOf("/", pos);
-              if (index2 === -1) {
+          } else if (hasStar && !hasLabel) {
+            const endsWithStar = routePath.charCodeAt(routePath.length - 1) === 42;
+            const parts = (endsWithStar ? routePath.slice(0, -2) : routePath).split(splitByStarRe);
+            const lastIndex = parts.length - 1;
+            for (let j = 0, pos = 0, len2 = parts.length; j < len2; j++) {
+              const part = parts[j];
+              const index = path.indexOf(part, pos);
+              if (index !== pos) {
                 continue ROUTES_LOOP;
               }
-              pos = index2;
-            }
-          }
-          handlers.push([handler, emptyParams]);
-        } else if (hasLabel && !hasStar) {
-          const params = /* @__PURE__ */ Object.create(null);
-          const parts = routePath.match(splitPathRe);
-          const lastIndex = parts.length - 1;
-          for (let j = 0, pos = 0, len2 = parts.length; j < len2; j++) {
-            if (pos === -1 || pos >= path.length) {
-              continue ROUTES_LOOP;
-            }
-            const part = parts[j];
-            if (part.charCodeAt(1) === 58) {
-              let name = part.slice(2);
-              let value;
-              if (name.charCodeAt(name.length - 1) === 125) {
-                const openBracePos = name.indexOf("{");
-                const pattern = name.slice(openBracePos + 1, -1);
-                const restPath = path.slice(pos + 1);
-                const match = new RegExp(pattern, "d").exec(restPath);
-                if (!match || match.indices[0][0] !== 0 || match.indices[0][1] === 0) {
+              pos += part.length;
+              if (j === lastIndex) {
+                if (!endsWithStar && pos !== path.length && !(pos === path.length - 1 && path.charCodeAt(pos) === 47)) {
                   continue ROUTES_LOOP;
                 }
-                name = name.slice(0, openBracePos);
-                value = restPath.slice(...match.indices[0]);
-                pos += match.indices[0][1] + 1;
               } else {
-                let endValuePos = path.indexOf("/", pos + 1);
-                if (endValuePos === -1) {
-                  if (pos + 1 === path.length) {
-                    continue ROUTES_LOOP;
-                  }
-                  endValuePos = path.length;
+                const index2 = path.indexOf("/", pos);
+                if (index2 === -1) {
+                  continue ROUTES_LOOP;
                 }
-                value = path.slice(pos + 1, endValuePos);
-                pos = endValuePos;
-              }
-              params[name] ||= value;
-            } else {
-              const index = path.indexOf(part, pos);
-              if (index !== pos) {
-                continue ROUTES_LOOP;
+                pos = index2;
               }
-              pos += part.length;
             }
-            if (j === lastIndex) {
-              if (pos !== path.length && !(pos === path.length - 1 && path.charCodeAt(pos) === 47)) {
+            handlers.push([handler, emptyParams]);
+          } else if (hasLabel && !hasStar) {
+            const params = /* @__PURE__ */ Object.create(null);
+            const parts = routePath.match(splitPathRe);
+            const lastIndex = parts.length - 1;
+            for (let j = 0, pos = 0, len2 = parts.length; j < len2; j++) {
+              if (pos === -1 || pos >= path.length) {
                 continue ROUTES_LOOP;
               }
+              const part = parts[j];
+              if (part.charCodeAt(1) === 58) {
+                let name = part.slice(2);
+                let value;
+                if (name.charCodeAt(name.length - 1) === 125) {
+                  const openBracePos = name.indexOf("{");
+                  const pattern = name.slice(openBracePos + 1, -1);
+                  const restPath = path.slice(pos + 1);
+                  const match = new RegExp(pattern, "d").exec(restPath);
+                  if (!match || match.indices[0][0] !== 0 || match.indices[0][1] === 0) {
+                    continue ROUTES_LOOP;
+                  }
+                  name = name.slice(0, openBracePos);
+                  value = restPath.slice(...match.indices[0]);
+                  pos += match.indices[0][1] + 1;
+                } else {
+                  let endValuePos = path.indexOf("/", pos + 1);
+                  if (endValuePos === -1) {
+                    if (pos + 1 === path.length) {
+                      continue ROUTES_LOOP;
+                    }
+                    endValuePos = path.length;
+                  }
+                  value = path.slice(pos + 1, endValuePos);
+                  pos = endValuePos;
+                }
+                params[name] ||= value;
+              } else {
+                const index = path.indexOf(part, pos);
+                if (index !== pos) {
+                  continue ROUTES_LOOP;
+                }
+                pos += part.length;
+              }
+              if (j === lastIndex) {
+                if (pos !== path.length && !(pos === path.length - 1 && path.charCodeAt(pos) === 47)) {
+                  continue ROUTES_LOOP;
+                }
+              }
             }
+            handlers.push([handler, params]);
+          } else if (hasLabel && hasStar) {
+            throw new UnsupportedPathError();
           }
-          handlers.push([handler, params]);
-        } else if (hasLabel && hasStar) {
-          throw new UnsupportedPathError();
         }
       }
     return [handlers];

package/dist/router/pattern-router/router.js

@@ -28,8 +28,9 @@ var PatternRouter = class {
   }
   match(method, path) {
     const handlers = [];
-    for (const [pattern, routeMethod, handler] of this.routes) {
-      if (routeMethod === METHOD_NAME_ALL || routeMethod === method) {
+    for (let i = 0, len = this.routes.length; i < len; i++) {
+      const [pattern, routeMethod, handler] = this.routes[i];
+      if (routeMethod === method || routeMethod === METHOD_NAME_ALL) {
         const match = pattern.exec(path);
         if (match) {
           handlers.push([handler, match.groups || /* @__PURE__ */ Object.create(null)]);

package/dist/router/smart-router/router.js

@@ -24,9 +24,9 @@ var SmartRouter = class {
     for (; i < len; i++) {
       const router = routers[i];
       try {
-        routes.forEach((args) => {
-          router.add(...args);
-        });
+        for (let i2 = 0, len2 = routes.length; i2 < len2; i2++) {
+          router.add(...routes[i2]);
+        }
         res = router.match(method, path);
       } catch (e) {
         if (e instanceof UnsupportedPathError) {

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

@@ -6,21 +6,18 @@ var Node = class {
   children;
   patterns;
   order = 0;
-  name;
   params = /* @__PURE__ */ Object.create(null);
   constructor(method, handler, children) {
     this.children = children || /* @__PURE__ */ Object.create(null);
     this.methods = [];
-    this.name = "";
     if (method && handler) {
       const m = /* @__PURE__ */ Object.create(null);
-      m[method] = { handler, possibleKeys: [], score: 0, name: this.name };
+      m[method] = { handler, possibleKeys: [], score: 0 };
       this.methods = [m];
     }
     this.patterns = [];
   }
   insert(method, path, handler) {
-    this.name = `${method} ${path}`;
     this.order = ++this.order;
     let curNode = this;
     const parts = splitRoutingPath(path);
@@ -50,7 +47,6 @@ var Node = class {
     const handlerSet = {
       handler,
       possibleKeys: possibleKeys.filter((v, i, a) => a.indexOf(v) === i),
-      name: this.name,
       score: this.order
     };
     m[method] = handlerSet;
@@ -65,11 +61,12 @@ var Node = class {
       const processedSet = /* @__PURE__ */ Object.create(null);
       if (handlerSet !== void 0) {
         handlerSet.params = /* @__PURE__ */ Object.create(null);
-        handlerSet.possibleKeys.forEach((key) => {
-          const processed = processedSet[handlerSet.name];
+        for (let i2 = 0, len2 = handlerSet.possibleKeys.length; i2 < len2; i2++) {
+          const key = handlerSet.possibleKeys[i2];
+          const processed = processedSet[handlerSet.score];
           handlerSet.params[key] = params[key] && !processed ? params[key] : nodeParams[key] ?? params[key];
-          processedSet[handlerSet.name] = true;
-        });
+          processedSet[handlerSet.score] = true;
+        }
         handlerSets.push(handlerSet);
       }
     }
@@ -90,7 +87,7 @@ var Node = class {
         const nextNode = node.children[part];
         if (nextNode) {
           nextNode.params = node.params;
-          if (isLast === true) {
+          if (isLast) {
             if (nextNode.children["*"]) {
               handlerSets.push(
                 ...this.gHSets(nextNode.children["*"], method, node.params, /* @__PURE__ */ Object.create(null))
@@ -123,10 +120,10 @@ var Node = class {
             handlerSets.push(...this.gHSets(child, method, node.params, params));
             continue;
           }
-          if (matcher === true || matcher instanceof RegExp && matcher.test(part)) {
+          if (matcher === true || matcher.test(part)) {
             if (typeof key === "string") {
               params[name] = part;
-              if (isLast === true) {
+              if (isLast) {
                 handlerSets.push(...this.gHSets(child, method, params, node.params));
                 if (child.children["*"]) {
                   handlerSets.push(...this.gHSets(child.children["*"], method, params, node.params));

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

@@ -10,8 +10,8 @@ var TrieRouter = class {
   add(method, path, handler) {
     const results = checkOptionalParameter(path);
     if (results) {
-      for (const p of results) {
-        this.node.insert(method, p, handler);
+      for (let i = 0, len = results.length; i < len; i++) {
+        this.node.insert(method, results[i], handler);
       }
       return;
     }

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

@@ -1,5 +1,9 @@
 import type { UpgradeWebSocket } from '../../helper/websocket';
-interface BunServerWebSocket<T> {
+import { WSContext } from '../../helper/websocket';
+/**
+ * @internal
+ */
+export interface BunServerWebSocket<T> {
     send(data: string | ArrayBufferLike, compress?: boolean): void;
     close(code?: number, reason?: string): void;
     data: T;
@@ -19,5 +23,9 @@ export interface BunWebSocketData {
     url: URL;
     protocol: string;
 }
+/**
+ * @internal
+ */
+export declare const createWSContext: (ws: BunServerWebSocket<BunWebSocketData>) => WSContext;
 export declare const createBunWebSocket: <T>() => CreateWebSocket<T>;
 export {};

package/dist/types/adapter/vercel/handler.d.ts

@@ -1,3 +1,2 @@
 import type { Hono } from '../../hono';
-import type { FetchEventLike } from '../../types';
-export declare const handle: (app: Hono<any, any, any>) => (req: Request, requestContext: FetchEventLike) => Response | Promise<Response>;
+export declare const handle: (app: Hono<any, any, any>) => (req: Request) => Response | Promise<Response>;

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

@@ -19,17 +19,46 @@ export interface WSEvents<T = unknown> {
 export type UpgradeWebSocket<T = unknown, U = any> = (createEvents: (c: Context) => WSEvents<T> | Promise<WSEvents<T>>, options?: U) => MiddlewareHandler<any, string, {
     outputFormat: "ws";
 }>;
+/**
+ * ReadyState for WebSocket
+ */
 export type WSReadyState = 0 | 1 | 2 | 3;
-export type WSContext<T = unknown> = {
-    send(source: string | ArrayBuffer | Uint8Array, options?: {
-        compress: boolean;
-    }): void;
+/**
+ * An argument for WSContext class
+ */
+export interface WSContestInit<T = unknown> {
+    send(data: string | ArrayBuffer, options: SendOptions): void;
+    close(code?: number, reason?: string): void;
     raw?: T;
-    binaryType: BinaryType;
     readyState: WSReadyState;
+    url?: string | URL | null;
+    protocol?: string | null;
+}
+/**
+ * Options for sending message
+ */
+export interface SendOptions {
+    compress?: boolean;
+}
+/**
+ * A context for controlling WebSockets
+ */
+export declare class WSContext<T = unknown> {
+    constructor(init: WSContestInit<T>);
+    send(source: string | ArrayBuffer | Uint8Array, options?: SendOptions): void;
+    raw?: T;
+    binaryType: BinaryType;
+    get readyState(): WSReadyState;
     url: URL | null;
     protocol: string | null;
     close(code?: number, reason?: string): void;
-};
+}
 export type WSMessageReceive = string | Blob | ArrayBufferLike;
 export declare const createWSMessageEvent: (source: WSMessageReceive) => MessageEvent<WSMessageReceive>;
+export interface WebSocketHelperDefineContext {
+}
+export type WebSocketHelperDefineHandler<T, U> = (c: Context, events: WSEvents<T>, options?: U) => Promise<Response | void> | Response | void;
+/**
+ * Create a WebSocket adapter/helper
+ */
+export declare const defineWebSocketHelper: <T = unknown, U = any>(handler: WebSocketHelperDefineHandler<T, U>) => UpgradeWebSocket<T, U>;

package/dist/types/router/trie-router/node.d.ts

@@ -4,14 +4,12 @@ type HandlerSet<T> = {
     handler: T;
     possibleKeys: string[];
     score: number;
-    name: string;
 };
 export declare class Node<T> {
     methods: Record<string, HandlerSet<T>>[];
     children: Record<string, Node<T>>;
     patterns: Pattern[];
     order: number;
-    name: string;
     params: Record<string, string>;
     constructor(method?: string, handler?: T, children?: Record<string, Node<T>>);
     insert(method: string, path: string, handler: T): Node<T>;

package/dist/utils/jwt/jws.js

@@ -21,8 +21,10 @@ async function importPrivateKey(key, alg) {
     throw new Error("`crypto.subtle.importKey` is undefined. JWT auth middleware requires it.");
   }
   if (isCryptoKey(key)) {
-    if (key.type !== "private") {
-      throw new Error(`unexpected non private key: CryptoKey.type is ${key.type}`);
+    if (key.type !== "private" && key.type !== "secret") {
+      throw new Error(
+        `unexpected key type: CryptoKey.type is ${key.type}, expected private or secret`
+      );
     }
     return key;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hono",
-  "version": "4.6.6",
+  "version": "4.6.7",
   "description": "Web framework built on Web Standards",
   "main": "dist/cjs/index.js",
   "type": "module",