hono 4.6.5 → 4.6.7

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/client/client.js

@@ -1,6 +1,7 @@
 // src/client/client.ts
 import { serialize } from "../utils/cookie.js";
 import {
+  buildSearchParams,
   deepMerge,
   mergePath,
   removeIndexString,
@@ -39,19 +40,7 @@ var ClientRequestImpl = class {
   fetch = async (args, opt) => {
     if (args) {
       if (args.query) {
-        for (const [k, v] of Object.entries(args.query)) {
-          if (v === void 0) {
-            continue;
-          }
-          this.queryParams ||= new URLSearchParams();
-          if (Array.isArray(v)) {
-            for (const v2 of v) {
-              this.queryParams.append(k, v2);
-            }
-          } else {
-            this.queryParams.set(k, v);
-          }
-        }
+        this.queryParams = buildSearchParams(args.query);
       }
       if (args.form) {
         const form = new FormData();
@@ -130,10 +119,16 @@ var hc = (baseUrl, options) => createProxy(function proxyCallback(opts) {
   const path = parts.join("/");
   const url = mergePath(baseUrl, path);
   if (method === "url") {
-    if (opts.args[0] && opts.args[0].param) {
-      return new URL(replaceUrlParam(url, opts.args[0].param));
+    let result = url;
+    if (opts.args[0]) {
+      if (opts.args[0].param) {
+        result = replaceUrlParam(url, opts.args[0].param);
+      }
+      if (opts.args[0].query) {
+        result = result + "?" + buildSearchParams(opts.args[0].query).toString();
+      }
     }
-    return new URL(url);
+    return new URL(result);
   }
   if (method === "ws") {
     const webSocketUrl = replaceUrlProtocol(

package/dist/client/utils.js

@@ -12,6 +12,22 @@ var replaceUrlParam = (urlString, params) => {
   }
   return urlString;
 };
+var buildSearchParams = (query) => {
+  const searchParams = new URLSearchParams();
+  for (const [k, v] of Object.entries(query)) {
+    if (v === void 0) {
+      continue;
+    }
+    if (Array.isArray(v)) {
+      for (const v2 of v) {
+        searchParams.append(k, v2);
+      }
+    } else {
+      searchParams.set(k, v);
+    }
+  }
+  return searchParams;
+};
 var replaceUrlProtocol = (urlString, protocol) => {
   switch (protocol) {
     case "ws":
@@ -45,6 +61,7 @@ function deepMerge(target, source) {
   return merged;
 }
 export {
+  buildSearchParams,
   deepMerge,
   mergePath,
   removeIndexString,

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/middleware/secure-headers/secure-headers.js

@@ -36,11 +36,12 @@ var generateNonce = () => {
   return encodeBase64(buffer);
 };
 var NONCE = (ctx) => {
-  const nonce = ctx.get("secureHeadersNonce") || (() => {
-    const newNonce = generateNonce();
-    ctx.set("secureHeadersNonce", newNonce);
-    return newNonce;
-  })();
+  const key = "secureHeadersNonce";
+  const init = ctx.get(key);
+  const nonce = init || generateNonce();
+  if (init == null) {
+    ctx.set(key, nonce);
+  }
   return `'nonce-${nonce}'`;
 };
 var secureHeaders = (customOptions) => {

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) {