hono 4.6.9 → 4.6.10

package/dist/adapter/deno/serve-static.js

@@ -5,6 +5,9 @@ var serveStatic = (options) => {
   return async function serveStatic2(c, next) {
     const getContent = async (path) => {
       try {
+        if (isDir(path)) {
+          return null;
+        }
         const file = await open(path);
         return file.readable;
       } catch (e) {

package/dist/cjs/adapter/deno/serve-static.js

@@ -27,6 +27,9 @@ const serveStatic = (options) => {
   return async function serveStatic2(c, next) {
     const getContent = async (path) => {
       try {
+        if (isDir(path)) {
+          return null;
+        }
         const file = await open(path);
         return file.readable;
       } catch (e) {

package/dist/cjs/hono-base.js

@@ -62,9 +62,7 @@ class Hono {
           this.#addRoute(method, this.#path, args1);
         }
         args.forEach((handler) => {
-          if (typeof handler !== "string") {
-            this.#addRoute(method, this.#path, handler);
-          }
+          this.#addRoute(method, this.#path, handler);
         });
         return this;
       };
@@ -234,15 +232,17 @@ class Hono {
   };
   request = (input, requestInit, Env, executionCtx) => {
     if (input instanceof Request) {
-      if (requestInit !== void 0) {
-        input = new Request(input, requestInit);
-      }
-      return this.fetch(input, Env, executionCtx);
+      return this.fetch(requestInit ? new Request(input, requestInit) : input, Env, executionCtx);
     }
     input = input.toString();
-    const path = /^https?:\/\//.test(input) ? input : `http://localhost${(0, import_url.mergePath)("/", input)}`;
-    const req = new Request(path, requestInit);
-    return this.fetch(req, Env, executionCtx);
+    return this.fetch(
+      new Request(
+        /^https?:\/\//.test(input) ? input : `http://localhost${(0, import_url.mergePath)("/", input)}`,
+        requestInit
+      ),
+      Env,
+      executionCtx
+    );
   };
   fire = () => {
     addEventListener("fetch", (event) => {

package/dist/cjs/middleware/combine/index.js

@@ -51,16 +51,22 @@ const some = (...middleware) => {
   };
 };
 const every = (...middleware) => {
-  const wrappedMiddleware = middleware.map((m) => async (c, next) => {
-    const res = await m(c, next);
-    if (res === false) {
-      throw new Error("Unmet condition");
-    }
-    return res;
-  });
-  const handler = async (c, next) => (0, import_compose.compose)(wrappedMiddleware.map((m) => [[m, void 0], c.req.param()]))(c, next);
   return async function every2(c, next) {
-    await handler(c, next);
+    const currentRouteIndex = c.req.routeIndex;
+    await (0, import_compose.compose)(
+      middleware.map((m) => [
+        [
+          async (c2, next2) => {
+            c2.req.routeIndex = currentRouteIndex;
+            const res = await m(c2, next2);
+            if (res === false) {
+              throw new Error("Unmet condition");
+            }
+            return res;
+          }
+        ]
+      ])
+    )(c, next);
   };
 };
 const except = (condition, ...middleware) => {

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

@@ -28,17 +28,17 @@ const splitPathRe = /\/(:\w+(?:{(?:(?:{[\d,]+})|[^}])+})?)|\/[^\/\?]+|(\?)/g;
 const splitByStarRe = /\*/;
 class LinearRouter {
   name = "LinearRouter";
-  routes = [];
+  #routes = [];
   add(method, path, 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]);
+      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];
+      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) {
           if (routePath === "*" || routePath === "/*") {
             handlers.push([handler, emptyParams]);

package/dist/cjs/router/reg-exp-router/node.js

@@ -47,18 +47,18 @@ function compareKey(a, b) {
   return a.length === b.length ? a < b ? -1 : 1 : b.length - a.length;
 }
 class Node {
-  index;
-  varIndex;
-  children = /* @__PURE__ */ Object.create(null);
+  #index;
+  #varIndex;
+  #children = /* @__PURE__ */ Object.create(null);
   insert(tokens, index, paramMap, context, pathErrorCheckOnly) {
     if (tokens.length === 0) {
-      if (this.index !== void 0) {
+      if (this.#index !== void 0) {
         throw PATH_ERROR;
       }
       if (pathErrorCheckOnly) {
         return;
       }
-      this.index = index;
+      this.#index = index;
       return;
     }
     const [token, ...restTokens] = tokens;
@@ -73,9 +73,9 @@ class Node {
           throw PATH_ERROR;
         }
       }
-      node = this.children[regexpStr];
+      node = this.#children[regexpStr];
       if (!node) {
-        if (Object.keys(this.children).some(
+        if (Object.keys(this.#children).some(
           (k) => k !== ONLY_WILDCARD_REG_EXP_STR && k !== TAIL_WILDCARD_REG_EXP_STR
         )) {
           throw PATH_ERROR;
@@ -83,18 +83,18 @@ class Node {
         if (pathErrorCheckOnly) {
           return;
         }
-        node = this.children[regexpStr] = new Node();
+        node = this.#children[regexpStr] = new Node();
         if (name !== "") {
-          node.varIndex = context.varIndex++;
+          node.#varIndex = context.varIndex++;
         }
       }
       if (!pathErrorCheckOnly && name !== "") {
-        paramMap.push([name, node.varIndex]);
+        paramMap.push([name, node.#varIndex]);
       }
     } else {
-      node = this.children[token];
+      node = this.#children[token];
       if (!node) {
-        if (Object.keys(this.children).some(
+        if (Object.keys(this.#children).some(
           (k) => k.length > 1 && k !== ONLY_WILDCARD_REG_EXP_STR && k !== TAIL_WILDCARD_REG_EXP_STR
         )) {
           throw PATH_ERROR;
@@ -102,19 +102,19 @@ class Node {
         if (pathErrorCheckOnly) {
           return;
         }
-        node = this.children[token] = new Node();
+        node = this.#children[token] = new Node();
       }
     }
     node.insert(restTokens, index, paramMap, context, pathErrorCheckOnly);
   }
   buildRegExpStr() {
-    const childKeys = Object.keys(this.children).sort(compareKey);
+    const childKeys = Object.keys(this.#children).sort(compareKey);
     const strList = childKeys.map((k) => {
-      const c = this.children[k];
-      return (typeof c.varIndex === "number" ? `(${k})@${c.varIndex}` : regExpMetaChars.has(k) ? `\\${k}` : k) + c.buildRegExpStr();
+      const c = this.#children[k];
+      return (typeof c.#varIndex === "number" ? `(${k})@${c.#varIndex}` : regExpMetaChars.has(k) ? `\\${k}` : k) + c.buildRegExpStr();
     });
-    if (typeof this.index === "number") {
-      strList.unshift(`#${this.index}`);
+    if (typeof this.#index === "number") {
+      strList.unshift(`#${this.#index}`);
     }
     if (strList.length === 0) {
       return "";

package/dist/cjs/router/reg-exp-router/router.js

@@ -109,14 +109,15 @@ function findMiddleware(middleware, path) {
 }
 class RegExpRouter {
   name = "RegExpRouter";
-  middleware;
-  routes;
+  #middleware;
+  #routes;
   constructor() {
-    this.middleware = { [import_router.METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
-    this.routes = { [import_router.METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
+    this.#middleware = { [import_router.METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
+    this.#routes = { [import_router.METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
   }
   add(method, path, handler) {
-    const { middleware, routes } = this;
+    const middleware = this.#middleware;
+    const routes = this.#routes;
     if (!middleware || !routes) {
       throw new Error(import_router.MESSAGE_MATCHER_IS_ALREADY_BUILT);
     }
@@ -191,16 +192,16 @@ class RegExpRouter {
   }
   #buildAllMatchers() {
     const matchers = /* @__PURE__ */ Object.create(null);
-    Object.keys(this.routes).concat(Object.keys(this.middleware)).forEach((method) => {
+    Object.keys(this.#routes).concat(Object.keys(this.#middleware)).forEach((method) => {
       matchers[method] ||= this.#buildMatcher(method);
     });
-    this.middleware = this.routes = void 0;
+    this.#middleware = this.#routes = void 0;
     return matchers;
   }
   #buildMatcher(method) {
     const routes = [];
     let hasOwnRoute = method === import_router.METHOD_NAME_ALL;
-    [this.middleware, this.routes].forEach((r) => {
+    [this.#middleware, this.#routes].forEach((r) => {
       const ownRoute = r[method] ? Object.keys(r[method]).map((path) => [path, r[method][path]]) : [];
       if (ownRoute.length !== 0) {
         hasOwnRoute ||= true;

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

@@ -23,8 +23,8 @@ __export(trie_exports, {
 module.exports = __toCommonJS(trie_exports);
 var import_node = require("./node");
 class Trie {
-  context = { varIndex: 0 };
-  root = new import_node.Node();
+  #context = { varIndex: 0 };
+  #root = new import_node.Node();
   insert(path, index, pathErrorCheckOnly) {
     const paramAssoc = [];
     const groups = [];
@@ -51,11 +51,11 @@ class Trie {
         }
       }
     }
-    this.root.insert(tokens, index, paramAssoc, this.context, pathErrorCheckOnly);
+    this.#root.insert(tokens, index, paramAssoc, this.#context, pathErrorCheckOnly);
     return paramAssoc;
   }
   buildRegExp() {
-    let regexp = this.root.buildRegExpStr();
+    let regexp = this.#root.buildRegExpStr();
     if (regexp === "") {
       return [/^$/, [], []];
     }

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

@@ -24,22 +24,23 @@ module.exports = __toCommonJS(router_exports);
 var import_router = require("../../router");
 class SmartRouter {
   name = "SmartRouter";
-  routers = [];
-  routes = [];
+  #routers = [];
+  #routes = [];
   constructor(init) {
-    Object.assign(this, init);
+    this.#routers = init.routers;
   }
   add(method, path, handler) {
-    if (!this.routes) {
+    if (!this.#routes) {
       throw new Error(import_router.MESSAGE_MATCHER_IS_ALREADY_BUILT);
     }
-    this.routes.push([method, path, handler]);
+    this.#routes.push([method, path, handler]);
   }
   match(method, path) {
-    if (!this.routes) {
+    if (!this.#routes) {
       throw new Error("Fatal error");
     }
-    const { routers, routes } = this;
+    const routers = this.#routers;
+    const routes = this.#routes;
     const len = routers.length;
     let i = 0;
     let res;
@@ -57,8 +58,8 @@ class SmartRouter {
         throw e;
       }
       this.match = router.match.bind(router);
-      this.routers = [router];
-      this.routes = void 0;
+      this.#routers = [router];
+      this.#routes = void 0;
       break;
     }
     if (i === len) {
@@ -68,10 +69,10 @@ class SmartRouter {
     return res;
   }
   get activeRouter() {
-    if (this.routes || this.routers.length !== 1) {
+    if (this.#routes || this.#routers.length !== 1) {
       throw new Error("No active router has been determined yet.");
     }
-    return this.routers[0];
+    return this.#routers[0];
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

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

@@ -24,63 +24,60 @@ module.exports = __toCommonJS(node_exports);
 var import_router = require("../../router");
 var import_url = require("../../utils/url");
 class Node {
-  methods;
-  children;
-  patterns;
-  order = 0;
-  params = /* @__PURE__ */ Object.create(null);
+  #methods;
+  #children;
+  #patterns;
+  #order = 0;
+  #params = /* @__PURE__ */ Object.create(null);
   constructor(method, handler, children) {
-    this.children = children || /* @__PURE__ */ Object.create(null);
-    this.methods = [];
+    this.#children = children || /* @__PURE__ */ Object.create(null);
+    this.#methods = [];
     if (method && handler) {
       const m = /* @__PURE__ */ Object.create(null);
       m[method] = { handler, possibleKeys: [], score: 0 };
-      this.methods = [m];
+      this.#methods = [m];
     }
-    this.patterns = [];
+    this.#patterns = [];
   }
   insert(method, path, handler) {
-    this.order = ++this.order;
+    this.#order = ++this.#order;
     let curNode = this;
     const parts = (0, import_url.splitRoutingPath)(path);
     const possibleKeys = [];
     for (let i = 0, len = parts.length; i < len; i++) {
       const p = parts[i];
-      if (Object.keys(curNode.children).includes(p)) {
-        curNode = curNode.children[p];
+      if (Object.keys(curNode.#children).includes(p)) {
+        curNode = curNode.#children[p];
         const pattern2 = (0, import_url.getPattern)(p);
         if (pattern2) {
           possibleKeys.push(pattern2[1]);
         }
         continue;
       }
-      curNode.children[p] = new Node();
+      curNode.#children[p] = new Node();
       const pattern = (0, import_url.getPattern)(p);
       if (pattern) {
-        curNode.patterns.push(pattern);
+        curNode.#patterns.push(pattern);
         possibleKeys.push(pattern[1]);
       }
-      curNode = curNode.children[p];
-    }
-    if (!curNode.methods.length) {
-      curNode.methods = [];
+      curNode = curNode.#children[p];
     }
     const m = /* @__PURE__ */ Object.create(null);
     const handlerSet = {
       handler,
       possibleKeys: possibleKeys.filter((v, i, a) => a.indexOf(v) === i),
-      score: this.order
+      score: this.#order
     };
     m[method] = handlerSet;
-    curNode.methods.push(m);
+    curNode.#methods.push(m);
     return curNode;
   }
-  #gHSets(node, method, nodeParams, params) {
+  #getHandlerSets(node, method, nodeParams, params) {
     const handlerSets = [];
-    for (let i = 0, len = node.methods.length; i < len; i++) {
-      const m = node.methods[i];
+    for (let i = 0, len = node.#methods.length; i < len; i++) {
+      const m = node.#methods[i];
       const handlerSet = m[method] || m[import_router.METHOD_NAME_ALL];
-      const processedSet = /* @__PURE__ */ Object.create(null);
+      const processedSet = {};
       if (handlerSet !== void 0) {
         handlerSet.params = /* @__PURE__ */ Object.create(null);
         for (let i2 = 0, len2 = handlerSet.possibleKeys.length; i2 < len2; i2++) {
@@ -96,7 +93,7 @@ class Node {
   }
   search(method, path) {
     const handlerSets = [];
-    this.params = /* @__PURE__ */ Object.create(null);
+    this.#params = /* @__PURE__ */ Object.create(null);
     const curNode = this;
     let curNodes = [curNode];
     const parts = (0, import_url.splitPath)(path);
@@ -106,27 +103,36 @@ class Node {
       const tempNodes = [];
       for (let j = 0, len2 = curNodes.length; j < len2; j++) {
         const node = curNodes[j];
-        const nextNode = node.children[part];
+        const nextNode = node.#children[part];
         if (nextNode) {
-          nextNode.params = node.params;
+          nextNode.#params = node.#params;
           if (isLast) {
-            if (nextNode.children["*"]) {
+            if (nextNode.#children["*"]) {
               handlerSets.push(
-                ...this.#gHSets(nextNode.children["*"], method, node.params, /* @__PURE__ */ Object.create(null))
+                ...this.#getHandlerSets(
+                  nextNode.#children["*"],
+                  method,
+                  node.#params,
+                  /* @__PURE__ */ Object.create(null)
+                )
               );
             }
-            handlerSets.push(...this.#gHSets(nextNode, method, node.params, /* @__PURE__ */ Object.create(null)));
+            handlerSets.push(
+              ...this.#getHandlerSets(nextNode, method, node.#params, /* @__PURE__ */ Object.create(null))
+            );
           } else {
             tempNodes.push(nextNode);
           }
         }
-        for (let k = 0, len3 = node.patterns.length; k < len3; k++) {
-          const pattern = node.patterns[k];
-          const params = { ...node.params };
+        for (let k = 0, len3 = node.#patterns.length; k < len3; k++) {
+          const pattern = node.#patterns[k];
+          const params = { ...node.#params };
           if (pattern === "*") {
-            const astNode = node.children["*"];
+            const astNode = node.#children["*"];
             if (astNode) {
-              handlerSets.push(...this.#gHSets(astNode, method, node.params, /* @__PURE__ */ Object.create(null)));
+              handlerSets.push(
+                ...this.#getHandlerSets(astNode, method, node.#params, /* @__PURE__ */ Object.create(null))
+              );
               tempNodes.push(astNode);
             }
             continue;
@@ -135,27 +141,25 @@ class Node {
             continue;
           }
           const [key, name, matcher] = pattern;
-          const child = node.children[key];
+          const child = node.#children[key];
           const restPathString = parts.slice(i).join("/");
           if (matcher instanceof RegExp && matcher.test(restPathString)) {
             params[name] = restPathString;
-            handlerSets.push(...this.#gHSets(child, method, node.params, params));
+            handlerSets.push(...this.#getHandlerSets(child, method, node.#params, params));
             continue;
           }
           if (matcher === true || matcher.test(part)) {
-            if (typeof key === "string") {
-              params[name] = part;
-              if (isLast) {
-                handlerSets.push(...this.#gHSets(child, method, params, node.params));
-                if (child.children["*"]) {
-                  handlerSets.push(
-                    ...this.#gHSets(child.children["*"], method, params, node.params)
-                  );
-                }
-              } else {
-                child.params = params;
-                tempNodes.push(child);
+            params[name] = part;
+            if (isLast) {
+              handlerSets.push(...this.#getHandlerSets(child, method, params, node.#params));
+              if (child.#children["*"]) {
+                handlerSets.push(
+                  ...this.#getHandlerSets(child.#children["*"], method, params, node.#params)
+                );
               }
+            } else {
+              child.#params = params;
+              tempNodes.push(child);
             }
           }
         }

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

@@ -25,22 +25,22 @@ var import_url = require("../../utils/url");
 var import_node = require("./node");
 class TrieRouter {
   name = "TrieRouter";
-  node;
+  #node;
   constructor() {
-    this.node = new import_node.Node();
+    this.#node = new import_node.Node();
   }
   add(method, path, handler) {
     const results = (0, import_url.checkOptionalParameter)(path);
     if (results) {
       for (let i = 0, len = results.length; i < len; i++) {
-        this.node.insert(method, results[i], handler);
+        this.#node.insert(method, results[i], handler);
       }
       return;
     }
-    this.node.insert(method, path, handler);
+    this.#node.insert(method, path, handler);
   }
   match(method, path) {
-    return this.node.search(method, path);
+    return this.#node.search(method, path);
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/hono-base.js

@@ -39,9 +39,7 @@ var Hono = class {
           this.#addRoute(method, this.#path, args1);
         }
         args.forEach((handler) => {
-          if (typeof handler !== "string") {
-            this.#addRoute(method, this.#path, handler);
-          }
+          this.#addRoute(method, this.#path, handler);
         });
         return this;
       };
@@ -211,15 +209,17 @@ var Hono = class {
   };
   request = (input, requestInit, Env, executionCtx) => {
     if (input instanceof Request) {
-      if (requestInit !== void 0) {
-        input = new Request(input, requestInit);
-      }
-      return this.fetch(input, Env, executionCtx);
+      return this.fetch(requestInit ? new Request(input, requestInit) : input, Env, executionCtx);
     }
     input = input.toString();
-    const path = /^https?:\/\//.test(input) ? input : `http://localhost${mergePath("/", input)}`;
-    const req = new Request(path, requestInit);
-    return this.fetch(req, Env, executionCtx);
+    return this.fetch(
+      new Request(
+        /^https?:\/\//.test(input) ? input : `http://localhost${mergePath("/", input)}`,
+        requestInit
+      ),
+      Env,
+      executionCtx
+    );
   };
   fire = () => {
     addEventListener("fetch", (event) => {

package/dist/middleware/combine/index.js

@@ -27,16 +27,22 @@ var some = (...middleware) => {
   };
 };
 var every = (...middleware) => {
-  const wrappedMiddleware = middleware.map((m) => async (c, next) => {
-    const res = await m(c, next);
-    if (res === false) {
-      throw new Error("Unmet condition");
-    }
-    return res;
-  });
-  const handler = async (c, next) => compose(wrappedMiddleware.map((m) => [[m, void 0], c.req.param()]))(c, next);
   return async function every2(c, next) {
-    await handler(c, next);
+    const currentRouteIndex = c.req.routeIndex;
+    await compose(
+      middleware.map((m) => [
+        [
+          async (c2, next2) => {
+            c2.req.routeIndex = currentRouteIndex;
+            const res = await m(c2, next2);
+            if (res === false) {
+              throw new Error("Unmet condition");
+            }
+            return res;
+          }
+        ]
+      ])
+    )(c, next);
   };
 };
 var except = (condition, ...middleware) => {

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

@@ -6,17 +6,17 @@ var splitPathRe = /\/(:\w+(?:{(?:(?:{[\d,]+})|[^}])+})?)|\/[^\/\?]+|(\?)/g;
 var splitByStarRe = /\*/;
 var LinearRouter = class {
   name = "LinearRouter";
-  routes = [];
+  #routes = [];
   add(method, path, handler) {
     for (let i = 0, paths = checkOptionalParameter(path) || [path], len = paths.length; i < len; i++) {
-      this.routes.push([method, paths[i], handler]);
+      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];
+      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) {
           if (routePath === "*" || routePath === "/*") {
             handlers.push([handler, emptyParams]);

package/dist/router/reg-exp-router/node.js

@@ -24,18 +24,18 @@ function compareKey(a, b) {
   return a.length === b.length ? a < b ? -1 : 1 : b.length - a.length;
 }
 var Node = class {
-  index;
-  varIndex;
-  children = /* @__PURE__ */ Object.create(null);
+  #index;
+  #varIndex;
+  #children = /* @__PURE__ */ Object.create(null);
   insert(tokens, index, paramMap, context, pathErrorCheckOnly) {
     if (tokens.length === 0) {
-      if (this.index !== void 0) {
+      if (this.#index !== void 0) {
         throw PATH_ERROR;
       }
       if (pathErrorCheckOnly) {
         return;
       }
-      this.index = index;
+      this.#index = index;
       return;
     }
     const [token, ...restTokens] = tokens;
@@ -50,9 +50,9 @@ var Node = class {
           throw PATH_ERROR;
         }
       }
-      node = this.children[regexpStr];
+      node = this.#children[regexpStr];
       if (!node) {
-        if (Object.keys(this.children).some(
+        if (Object.keys(this.#children).some(
           (k) => k !== ONLY_WILDCARD_REG_EXP_STR && k !== TAIL_WILDCARD_REG_EXP_STR
         )) {
           throw PATH_ERROR;
@@ -60,18 +60,18 @@ var Node = class {
         if (pathErrorCheckOnly) {
           return;
         }
-        node = this.children[regexpStr] = new Node();
+        node = this.#children[regexpStr] = new Node();
         if (name !== "") {
-          node.varIndex = context.varIndex++;
+          node.#varIndex = context.varIndex++;
         }
       }
       if (!pathErrorCheckOnly && name !== "") {
-        paramMap.push([name, node.varIndex]);
+        paramMap.push([name, node.#varIndex]);
       }
     } else {
-      node = this.children[token];
+      node = this.#children[token];
       if (!node) {
-        if (Object.keys(this.children).some(
+        if (Object.keys(this.#children).some(
           (k) => k.length > 1 && k !== ONLY_WILDCARD_REG_EXP_STR && k !== TAIL_WILDCARD_REG_EXP_STR
         )) {
           throw PATH_ERROR;
@@ -79,19 +79,19 @@ var Node = class {
         if (pathErrorCheckOnly) {
           return;
         }
-        node = this.children[token] = new Node();
+        node = this.#children[token] = new Node();
       }
     }
     node.insert(restTokens, index, paramMap, context, pathErrorCheckOnly);
   }
   buildRegExpStr() {
-    const childKeys = Object.keys(this.children).sort(compareKey);
+    const childKeys = Object.keys(this.#children).sort(compareKey);
     const strList = childKeys.map((k) => {
-      const c = this.children[k];
-      return (typeof c.varIndex === "number" ? `(${k})@${c.varIndex}` : regExpMetaChars.has(k) ? `\\${k}` : k) + c.buildRegExpStr();
+      const c = this.#children[k];
+      return (typeof c.#varIndex === "number" ? `(${k})@${c.#varIndex}` : regExpMetaChars.has(k) ? `\\${k}` : k) + c.buildRegExpStr();
     });
-    if (typeof this.index === "number") {
-      strList.unshift(`#${this.index}`);
+    if (typeof this.#index === "number") {
+      strList.unshift(`#${this.#index}`);
     }
     if (strList.length === 0) {
       return "";

package/dist/router/reg-exp-router/router.js

@@ -91,14 +91,15 @@ function findMiddleware(middleware, path) {
 }
 var RegExpRouter = class {
   name = "RegExpRouter";
-  middleware;
-  routes;
+  #middleware;
+  #routes;
   constructor() {
-    this.middleware = { [METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
-    this.routes = { [METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
+    this.#middleware = { [METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
+    this.#routes = { [METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
   }
   add(method, path, handler) {
-    const { middleware, routes } = this;
+    const middleware = this.#middleware;
+    const routes = this.#routes;
     if (!middleware || !routes) {
       throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
     }
@@ -173,16 +174,16 @@ var RegExpRouter = class {
   }
   #buildAllMatchers() {
     const matchers = /* @__PURE__ */ Object.create(null);
-    Object.keys(this.routes).concat(Object.keys(this.middleware)).forEach((method) => {
+    Object.keys(this.#routes).concat(Object.keys(this.#middleware)).forEach((method) => {
       matchers[method] ||= this.#buildMatcher(method);
     });
-    this.middleware = this.routes = void 0;
+    this.#middleware = this.#routes = void 0;
     return matchers;
   }
   #buildMatcher(method) {
     const routes = [];
     let hasOwnRoute = method === METHOD_NAME_ALL;
-    [this.middleware, this.routes].forEach((r) => {
+    [this.#middleware, this.#routes].forEach((r) => {
       const ownRoute = r[method] ? Object.keys(r[method]).map((path) => [path, r[method][path]]) : [];
       if (ownRoute.length !== 0) {
         hasOwnRoute ||= true;

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

@@ -1,8 +1,8 @@
 // src/router/reg-exp-router/trie.ts
 import { Node } from "./node.js";
 var Trie = class {
-  context = { varIndex: 0 };
-  root = new Node();
+  #context = { varIndex: 0 };
+  #root = new Node();
   insert(path, index, pathErrorCheckOnly) {
     const paramAssoc = [];
     const groups = [];
@@ -29,11 +29,11 @@ var Trie = class {
         }
       }
     }
-    this.root.insert(tokens, index, paramAssoc, this.context, pathErrorCheckOnly);
+    this.#root.insert(tokens, index, paramAssoc, this.#context, pathErrorCheckOnly);
     return paramAssoc;
   }
   buildRegExp() {
-    let regexp = this.root.buildRegExpStr();
+    let regexp = this.#root.buildRegExpStr();
     if (regexp === "") {
       return [/^$/, [], []];
     }

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

@@ -2,22 +2,23 @@
 import { MESSAGE_MATCHER_IS_ALREADY_BUILT, UnsupportedPathError } from "../../router.js";
 var SmartRouter = class {
   name = "SmartRouter";
-  routers = [];
-  routes = [];
+  #routers = [];
+  #routes = [];
   constructor(init) {
-    Object.assign(this, init);
+    this.#routers = init.routers;
   }
   add(method, path, handler) {
-    if (!this.routes) {
+    if (!this.#routes) {
       throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
     }
-    this.routes.push([method, path, handler]);
+    this.#routes.push([method, path, handler]);
   }
   match(method, path) {
-    if (!this.routes) {
+    if (!this.#routes) {
       throw new Error("Fatal error");
     }
-    const { routers, routes } = this;
+    const routers = this.#routers;
+    const routes = this.#routes;
     const len = routers.length;
     let i = 0;
     let res;
@@ -35,8 +36,8 @@ var SmartRouter = class {
         throw e;
       }
       this.match = router.match.bind(router);
-      this.routers = [router];
-      this.routes = void 0;
+      this.#routers = [router];
+      this.#routes = void 0;
       break;
     }
     if (i === len) {
@@ -46,10 +47,10 @@ var SmartRouter = class {
     return res;
   }
   get activeRouter() {
-    if (this.routes || this.routers.length !== 1) {
+    if (this.#routes || this.#routers.length !== 1) {
       throw new Error("No active router has been determined yet.");
     }
-    return this.routers[0];
+    return this.#routers[0];
   }
 };
 export {

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

@@ -2,63 +2,60 @@
 import { METHOD_NAME_ALL } from "../../router.js";
 import { getPattern, splitPath, splitRoutingPath } from "../../utils/url.js";
 var Node = class {
-  methods;
-  children;
-  patterns;
-  order = 0;
-  params = /* @__PURE__ */ Object.create(null);
+  #methods;
+  #children;
+  #patterns;
+  #order = 0;
+  #params = /* @__PURE__ */ Object.create(null);
   constructor(method, handler, children) {
-    this.children = children || /* @__PURE__ */ Object.create(null);
-    this.methods = [];
+    this.#children = children || /* @__PURE__ */ Object.create(null);
+    this.#methods = [];
     if (method && handler) {
       const m = /* @__PURE__ */ Object.create(null);
       m[method] = { handler, possibleKeys: [], score: 0 };
-      this.methods = [m];
+      this.#methods = [m];
     }
-    this.patterns = [];
+    this.#patterns = [];
   }
   insert(method, path, handler) {
-    this.order = ++this.order;
+    this.#order = ++this.#order;
     let curNode = this;
     const parts = splitRoutingPath(path);
     const possibleKeys = [];
     for (let i = 0, len = parts.length; i < len; i++) {
       const p = parts[i];
-      if (Object.keys(curNode.children).includes(p)) {
-        curNode = curNode.children[p];
+      if (Object.keys(curNode.#children).includes(p)) {
+        curNode = curNode.#children[p];
         const pattern2 = getPattern(p);
         if (pattern2) {
           possibleKeys.push(pattern2[1]);
         }
         continue;
       }
-      curNode.children[p] = new Node();
+      curNode.#children[p] = new Node();
       const pattern = getPattern(p);
       if (pattern) {
-        curNode.patterns.push(pattern);
+        curNode.#patterns.push(pattern);
         possibleKeys.push(pattern[1]);
       }
-      curNode = curNode.children[p];
-    }
-    if (!curNode.methods.length) {
-      curNode.methods = [];
+      curNode = curNode.#children[p];
     }
     const m = /* @__PURE__ */ Object.create(null);
     const handlerSet = {
       handler,
       possibleKeys: possibleKeys.filter((v, i, a) => a.indexOf(v) === i),
-      score: this.order
+      score: this.#order
     };
     m[method] = handlerSet;
-    curNode.methods.push(m);
+    curNode.#methods.push(m);
     return curNode;
   }
-  #gHSets(node, method, nodeParams, params) {
+  #getHandlerSets(node, method, nodeParams, params) {
     const handlerSets = [];
-    for (let i = 0, len = node.methods.length; i < len; i++) {
-      const m = node.methods[i];
+    for (let i = 0, len = node.#methods.length; i < len; i++) {
+      const m = node.#methods[i];
       const handlerSet = m[method] || m[METHOD_NAME_ALL];
-      const processedSet = /* @__PURE__ */ Object.create(null);
+      const processedSet = {};
       if (handlerSet !== void 0) {
         handlerSet.params = /* @__PURE__ */ Object.create(null);
         for (let i2 = 0, len2 = handlerSet.possibleKeys.length; i2 < len2; i2++) {
@@ -74,7 +71,7 @@ var Node = class {
   }
   search(method, path) {
     const handlerSets = [];
-    this.params = /* @__PURE__ */ Object.create(null);
+    this.#params = /* @__PURE__ */ Object.create(null);
     const curNode = this;
     let curNodes = [curNode];
     const parts = splitPath(path);
@@ -84,27 +81,36 @@ var Node = class {
       const tempNodes = [];
       for (let j = 0, len2 = curNodes.length; j < len2; j++) {
         const node = curNodes[j];
-        const nextNode = node.children[part];
+        const nextNode = node.#children[part];
         if (nextNode) {
-          nextNode.params = node.params;
+          nextNode.#params = node.#params;
           if (isLast) {
-            if (nextNode.children["*"]) {
+            if (nextNode.#children["*"]) {
               handlerSets.push(
-                ...this.#gHSets(nextNode.children["*"], method, node.params, /* @__PURE__ */ Object.create(null))
+                ...this.#getHandlerSets(
+                  nextNode.#children["*"],
+                  method,
+                  node.#params,
+                  /* @__PURE__ */ Object.create(null)
+                )
               );
             }
-            handlerSets.push(...this.#gHSets(nextNode, method, node.params, /* @__PURE__ */ Object.create(null)));
+            handlerSets.push(
+              ...this.#getHandlerSets(nextNode, method, node.#params, /* @__PURE__ */ Object.create(null))
+            );
           } else {
             tempNodes.push(nextNode);
           }
         }
-        for (let k = 0, len3 = node.patterns.length; k < len3; k++) {
-          const pattern = node.patterns[k];
-          const params = { ...node.params };
+        for (let k = 0, len3 = node.#patterns.length; k < len3; k++) {
+          const pattern = node.#patterns[k];
+          const params = { ...node.#params };
           if (pattern === "*") {
-            const astNode = node.children["*"];
+            const astNode = node.#children["*"];
             if (astNode) {
-              handlerSets.push(...this.#gHSets(astNode, method, node.params, /* @__PURE__ */ Object.create(null)));
+              handlerSets.push(
+                ...this.#getHandlerSets(astNode, method, node.#params, /* @__PURE__ */ Object.create(null))
+              );
               tempNodes.push(astNode);
             }
             continue;
@@ -113,27 +119,25 @@ var Node = class {
             continue;
           }
           const [key, name, matcher] = pattern;
-          const child = node.children[key];
+          const child = node.#children[key];
           const restPathString = parts.slice(i).join("/");
           if (matcher instanceof RegExp && matcher.test(restPathString)) {
             params[name] = restPathString;
-            handlerSets.push(...this.#gHSets(child, method, node.params, params));
+            handlerSets.push(...this.#getHandlerSets(child, method, node.#params, params));
             continue;
           }
           if (matcher === true || matcher.test(part)) {
-            if (typeof key === "string") {
-              params[name] = part;
-              if (isLast) {
-                handlerSets.push(...this.#gHSets(child, method, params, node.params));
-                if (child.children["*"]) {
-                  handlerSets.push(
-                    ...this.#gHSets(child.children["*"], method, params, node.params)
-                  );
-                }
-              } else {
-                child.params = params;
-                tempNodes.push(child);
+            params[name] = part;
+            if (isLast) {
+              handlerSets.push(...this.#getHandlerSets(child, method, params, node.#params));
+              if (child.#children["*"]) {
+                handlerSets.push(
+                  ...this.#getHandlerSets(child.#children["*"], method, params, node.#params)
+                );
               }
+            } else {
+              child.#params = params;
+              tempNodes.push(child);
             }
           }
         }

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

@@ -3,22 +3,22 @@ import { checkOptionalParameter } from "../../utils/url.js";
 import { Node } from "./node.js";
 var TrieRouter = class {
   name = "TrieRouter";
-  node;
+  #node;
   constructor() {
-    this.node = new Node();
+    this.#node = new Node();
   }
   add(method, path, handler) {
     const results = checkOptionalParameter(path);
     if (results) {
       for (let i = 0, len = results.length; i < len; i++) {
-        this.node.insert(method, results[i], handler);
+        this.#node.insert(method, results[i], handler);
       }
       return;
     }
-    this.node.insert(method, path, handler);
+    this.#node.insert(method, path, handler);
   }
   match(method, path) {
-    return this.node.search(method, path);
+    return this.#node.search(method, path);
   }
 };
 export {

package/dist/types/adapter/service-worker/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * Cloudflare Workers Adapter for Hono.
+ * Service Worker Adapter for Hono.
  * @module
  */
 export { handle } from './handler';

package/dist/types/compose.d.ts

@@ -1,4 +1,3 @@
-import type { ParamIndexMap, Params } from './router';
 import type { Env, ErrorHandler, NotFoundHandler } from './types';
 /**
  * Interface representing the context for a composition operation.
@@ -31,6 +30,10 @@ export declare const compose: <C extends ComposeContext, E extends Env = Env>(mi
         Function,
         unknown
     ],
-    ParamIndexMap | Params
+    unknown
+][] | [
+    [
+        Function
+    ]
 ][], onError?: ErrorHandler<E>, onNotFound?: NotFoundHandler<E>) => ((context: C, next?: Function) => Promise<C>);
 export {};

package/dist/types/router/linear-router/router.d.ts

@@ -1,11 +1,6 @@
 import type { Result, Router } from '../../router';
 export declare class LinearRouter<T> implements Router<T> {
     name: string;
-    routes: [
-        string,
-        string,
-        T
-    ][];
     add(method: string, path: string, handler: T): void;
     match(method: string, path: string): Result<T>;
 }

package/dist/types/router/reg-exp-router/node.d.ts

@@ -7,9 +7,6 @@ export interface Context {
     varIndex: number;
 }
 export declare class Node {
-    index?: number;
-    varIndex?: number;
-    children: Record<string, Node>;
     insert(tokens: readonly string[], index: number, paramMap: ParamAssocArray, context: Context, pathErrorCheckOnly: boolean): void;
     buildRegExpStr(): string;
 }

package/dist/types/router/reg-exp-router/router.d.ts

@@ -1,14 +1,7 @@
 import type { Result, Router } from '../../router';
-type HandlerWithMetadata<T> = [
-    T,
-    number
-];
 export declare class RegExpRouter<T> implements Router<T> {
     name: string;
-    middleware?: Record<string, Record<string, HandlerWithMetadata<T>[]>>;
-    routes?: Record<string, Record<string, HandlerWithMetadata<T>[]>>;
     constructor();
     add(method: string, path: string, handler: T): void;
     match(method: string, path: string): Result<T>;
 }
-export {};

package/dist/types/router/reg-exp-router/trie.d.ts

@@ -1,9 +1,6 @@
-import type { Context, ParamAssocArray } from './node';
-import { Node } from './node';
+import type { ParamAssocArray } from './node';
 export type ReplacementMap = number[];
 export declare class Trie {
-    context: Context;
-    root: Node;
     insert(path: string, index: number, pathErrorCheckOnly: boolean): ParamAssocArray;
     buildRegExp(): [
         RegExp,

package/dist/types/router/smart-router/router.d.ts

@@ -1,13 +1,9 @@
 import type { Result, Router } from '../../router';
 export declare class SmartRouter<T> implements Router<T> {
     name: string;
-    routers: Router<T>[];
-    routes?: [
-        string,
-        string,
-        T
-    ][];
-    constructor(init: Pick<SmartRouter<T>, "routers">);
+    constructor(init: {
+        routers: Router<T>[];
+    });
     add(method: string, path: string, handler: T): void;
     match(method: string, path: string): Result<T>;
     get activeRouter(): Router<T>;

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

@@ -1,16 +1,5 @@
 import type { Params } from '../../router';
-import type { Pattern } from '../../utils/url';
-type HandlerSet<T> = {
-    handler: T;
-    possibleKeys: string[];
-    score: number;
-};
 export declare class Node<T> {
-    methods: Record<string, HandlerSet<T>>[];
-    children: Record<string, Node<T>>;
-    patterns: Pattern[];
-    order: number;
-    params: Record<string, string>;
     constructor(method?: string, handler?: T, children?: Record<string, Node<T>>);
     insert(method: string, path: string, handler: T): Node<T>;
     search(method: string, path: string): [
@@ -20,4 +9,3 @@ export declare class Node<T> {
         ][]
     ];
 }
-export {};

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

@@ -1,8 +1,6 @@
 import type { Result, Router } from '../../router';
-import { Node } from './node';
 export declare class TrieRouter<T> implements Router<T> {
     name: string;
-    node: Node<T>;
     constructor();
     add(method: string, path: string, handler: T): void;
     match(method: string, path: string): Result<T>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hono",
-  "version": "4.6.9",
+  "version": "4.6.10",
   "description": "Web framework built on Web Standards",
   "main": "dist/cjs/index.js",
   "type": "module",
@@ -39,6 +39,11 @@
       "import": "./dist/index.js",
       "require": "./dist/cjs/index.js"
     },
+    "./request": {
+      "types": "./dist/types/request.d.ts",
+      "import": "./dist/request.js",
+      "require": "./dist/cjs/request.js"
+    },
     "./types": {
       "types": "./dist/types/types.d.ts",
       "import": "./dist/types.js",
@@ -387,6 +392,9 @@
   },
   "typesVersions": {
     "*": {
+      "request": [
+        "./dist/types/request"
+      ],
       "types": [
         "./dist/types/types"
       ],
@@ -619,29 +627,29 @@
   ],
   "devDependencies": {
     "@hono/eslint-config": "^1.0.2",
-    "@hono/node-server": "^1.8.2",
-    "@types/glob": "^8.0.0",
-    "@types/jsdom": "^21.1.4",
+    "@hono/node-server": "^1.13.5",
+    "@types/glob": "^8.1.0",
+    "@types/jsdom": "^21.1.7",
     "@types/node": "20.11.4",
-    "@types/supertest": "^2.0.12",
+    "@types/supertest": "^2.0.16",
     "@vitest/coverage-v8": "^2.0.5",
     "arg": "^5.0.2",
-    "bun-types": "^1.1.30",
-    "esbuild": "^0.15.12",
+    "bun-types": "^1.1.34",
+    "esbuild": "^0.15.18",
     "eslint": "^9.10.0",
     "glob": "^11.0.0",
     "jsdom": "^22.1.0",
-    "msw": "^2.3.0",
+    "msw": "^2.6.0",
     "np": "7.7.0",
     "prettier": "^2.6.2",
-    "publint": "^0.1.8",
-    "supertest": "^6.3.3",
+    "publint": "^0.1.16",
+    "supertest": "^6.3.4",
     "typescript": "^5.3.3",
     "vite-plugin-fastly-js-compute": "^0.4.2",
     "vitest": "^2.0.5",
     "wrangler": "3.58.0",
-    "ws": "^8.17.0",
-    "zod": "^3.20.2"
+    "ws": "^8.18.0",
+    "zod": "^3.23.8"
   },
   "engines": {
     "node": ">=16.9.0"