hono 4.9.9 → 4.9.11

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

@@ -1,5 +1,12 @@
 // src/adapter/aws-lambda/handler.ts
 import { decodeBase64, encodeBase64 } from "../../utils/encode.js";
+function sanitizeHeaderValue(value) {
+  const hasNonAscii = /[^\x00-\x7F]/.test(value);
+  if (!hasNonAscii) {
+    return value;
+  }
+  return encodeURIComponent(value);
+}
 var getRequestContext = (event) => {
   return event.requestContext;
 };
@@ -180,7 +187,7 @@ var EventV1Processor = class extends EventProcessor {
     if (event.headers) {
       for (const [k, v] of Object.entries(event.headers)) {
         if (v) {
-          headers.set(k, v);
+          headers.set(k, sanitizeHeaderValue(v));
         }
       }
     }
@@ -188,7 +195,10 @@ var EventV1Processor = class extends EventProcessor {
       for (const [k, values] of Object.entries(event.multiValueHeaders)) {
         if (values) {
           const foundK = headers.get(k);
-          values.forEach((v) => (!foundK || !foundK.includes(v)) && headers.append(k, v));
+          values.forEach((v) => {
+            const sanitizedValue = sanitizeHeaderValue(v);
+            return (!foundK || !foundK.includes(sanitizedValue)) && headers.append(k, sanitizedValue);
+          });
         }
       }
     }
@@ -207,13 +217,14 @@ var ALBProcessor = class extends EventProcessor {
     if (event.multiValueHeaders) {
       for (const [key, values] of Object.entries(event.multiValueHeaders)) {
         if (values && Array.isArray(values)) {
-          headers.set(key, values.join("; "));
+          const sanitizedValue = sanitizeHeaderValue(values.join("; "));
+          headers.set(key, sanitizedValue);
         }
       }
     } else {
       for (const [key, value] of Object.entries(event.headers ?? {})) {
         if (value) {
-          headers.set(key, value);
+          headers.set(key, sanitizeHeaderValue(value));
         }
       }
     }

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

@@ -30,6 +30,13 @@ __export(handler_exports, {
 });
 module.exports = __toCommonJS(handler_exports);
 var import_encode = require("../../utils/encode");
+function sanitizeHeaderValue(value) {
+  const hasNonAscii = /[^\x00-\x7F]/.test(value);
+  if (!hasNonAscii) {
+    return value;
+  }
+  return encodeURIComponent(value);
+}
 const getRequestContext = (event) => {
   return event.requestContext;
 };
@@ -210,7 +217,7 @@ class EventV1Processor extends EventProcessor {
     if (event.headers) {
       for (const [k, v] of Object.entries(event.headers)) {
         if (v) {
-          headers.set(k, v);
+          headers.set(k, sanitizeHeaderValue(v));
         }
       }
     }
@@ -218,7 +225,10 @@ class EventV1Processor extends EventProcessor {
       for (const [k, values] of Object.entries(event.multiValueHeaders)) {
         if (values) {
           const foundK = headers.get(k);
-          values.forEach((v) => (!foundK || !foundK.includes(v)) && headers.append(k, v));
+          values.forEach((v) => {
+            const sanitizedValue = sanitizeHeaderValue(v);
+            return (!foundK || !foundK.includes(sanitizedValue)) && headers.append(k, sanitizedValue);
+          });
         }
       }
     }
@@ -237,13 +247,14 @@ class ALBProcessor extends EventProcessor {
     if (event.multiValueHeaders) {
       for (const [key, values] of Object.entries(event.multiValueHeaders)) {
         if (values && Array.isArray(values)) {
-          headers.set(key, values.join("; "));
+          const sanitizedValue = sanitizeHeaderValue(values.join("; "));
+          headers.set(key, sanitizedValue);
         }
       }
     } else {
       for (const [key, value] of Object.entries(event.headers ?? {})) {
         if (value) {
-          headers.set(key, value);
+          headers.set(key, sanitizeHeaderValue(value));
         }
       }
     }

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

@@ -18,11 +18,18 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var reg_exp_router_exports = {};
 __export(reg_exp_router_exports, {
-  RegExpRouter: () => import_router.RegExpRouter
+  PreparedRegExpRouter: () => import_prepared_router.PreparedRegExpRouter,
+  RegExpRouter: () => import_router.RegExpRouter,
+  buildInitParams: () => import_prepared_router.buildInitParams,
+  serializeInitParams: () => import_prepared_router.serializeInitParams
 });
 module.exports = __toCommonJS(reg_exp_router_exports);
 var import_router = require("./router");
+var import_prepared_router = require("./prepared-router");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  RegExpRouter
+  PreparedRegExpRouter,
+  RegExpRouter,
+  buildInitParams,
+  serializeInitParams
 });

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

@@ -0,0 +1,52 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var matcher_exports = {};
+__export(matcher_exports, {
+  buildAllMatchersKey: () => buildAllMatchersKey,
+  emptyParam: () => emptyParam,
+  match: () => match
+});
+module.exports = __toCommonJS(matcher_exports);
+var import_router = require("../../router");
+const emptyParam = [];
+const buildAllMatchersKey = Symbol("buildAllMatchers");
+function match(method, path) {
+  const matchers = this[buildAllMatchersKey]();
+  const match2 = (method2, path2) => {
+    const matcher = matchers[method2] || matchers[import_router.METHOD_NAME_ALL];
+    const staticMatch = matcher[2][path2];
+    if (staticMatch) {
+      return staticMatch;
+    }
+    const match3 = path2.match(matcher[0]);
+    if (!match3) {
+      return [[], emptyParam];
+    }
+    const index = match3.indexOf("", 1);
+    return [matcher[1][index], match3];
+  };
+  this.match = match2;
+  return match2(method, path);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildAllMatchersKey,
+  emptyParam,
+  match
+});

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

@@ -0,0 +1,151 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var prepared_router_exports = {};
+__export(prepared_router_exports, {
+  PreparedRegExpRouter: () => PreparedRegExpRouter,
+  buildInitParams: () => buildInitParams,
+  serializeInitParams: () => serializeInitParams
+});
+module.exports = __toCommonJS(prepared_router_exports);
+var import_router = require("../../router");
+var import_matcher = require("./matcher");
+var import_router2 = require("./router");
+class PreparedRegExpRouter {
+  name = "PreparedRegExpRouter";
+  #matchers;
+  #relocateMap;
+  constructor(matchers, relocateMap) {
+    this.#matchers = matchers;
+    this.#relocateMap = relocateMap;
+  }
+  add(method, path, handler) {
+    const all = this.#matchers[import_router.METHOD_NAME_ALL];
+    this.#matchers[method] ||= [
+      all[0],
+      all[1].map((list) => Array.isArray(list) ? list.slice() : 0),
+      Object.keys(all[2]).reduce((obj, key) => {
+        obj[key] = [all[2][key][0].slice(), import_matcher.emptyParam];
+        return obj;
+      }, {})
+    ];
+    if (path === "/*" || path === "*") {
+      const defaultHandlerData = [handler, {}];
+      (method === import_router.METHOD_NAME_ALL ? Object.keys(this.#matchers) : [method]).forEach((m) => {
+        const matcher = this.#matchers[m];
+        matcher[1].forEach((list) => list && list.push(defaultHandlerData));
+        Object.values(matcher[2]).forEach(
+          (list) => list[0].push(defaultHandlerData)
+        );
+      });
+      return;
+    }
+    const data = this.#relocateMap[path];
+    if (!data) {
+      throw new Error(`Path ${path} is not registered`);
+    }
+    for (const [indexes, map] of data) {
+      ;
+      (method === import_router.METHOD_NAME_ALL ? Object.keys(this.#matchers) : [method]).forEach((m) => {
+        const matcher = this.#matchers[m];
+        if (!map) {
+          matcher[2][path][0].push([handler, {}]);
+        } else {
+          indexes.forEach((index) => {
+            if (typeof index === "number") {
+              matcher[1][index].push([handler, map]);
+            } else {
+              ;
+              matcher[2][index || path][0].push([handler, map]);
+            }
+          });
+        }
+      });
+    }
+  }
+  [import_matcher.buildAllMatchersKey]() {
+    return this.#matchers;
+  }
+  match = import_matcher.match;
+}
+const buildInitParams = ({ paths }) => {
+  const router = new import_router2.RegExpRouter();
+  for (const path of paths) {
+    router.add(import_router.METHOD_NAME_ALL, path, path);
+  }
+  const matchers = router[import_matcher.buildAllMatchersKey]();
+  const all = matchers[import_router.METHOD_NAME_ALL];
+  const relocateMap = {};
+  for (const path of paths) {
+    all[1].forEach((list, i) => {
+      list.forEach(([p, map]) => {
+        if (p === path) {
+          if (relocateMap[path]) {
+            relocateMap[path][0][1] = {
+              ...relocateMap[path][0][1],
+              ...map
+            };
+          } else {
+            relocateMap[path] = [[[], map]];
+          }
+          if (relocateMap[path][0][0].findIndex((j) => j === i) === -1) {
+            relocateMap[path][0][0].push(i);
+          }
+        }
+      });
+    });
+    for (const path2 in all[2]) {
+      all[2][path2][0].forEach(([p]) => {
+        if (p === path) {
+          relocateMap[path] ||= [[[], void 0]];
+          const value = path2 === path ? "" : path2;
+          if (relocateMap[path][0][0].findIndex((v) => v === value) === -1) {
+            relocateMap[path][0][0].push(value);
+          }
+        }
+      });
+    }
+  }
+  for (let i = 0, len = all[1].length; i < len; i++) {
+    all[1][i] = all[1][i] ? [] : 0;
+  }
+  for (const path in all[2]) {
+    all[2][path][0] = [];
+  }
+  return [matchers, relocateMap];
+};
+const serializeInitParams = ([matchers, relocateMap]) => {
+  for (const method in matchers) {
+    const matcher = matchers[method];
+    matcher[0].toJSON = function() {
+      return `@${this.toString()}@`;
+    };
+  }
+  const matchersStr = JSON.stringify(matchers).replace(
+    /"@(.+?)@"/g,
+    (_, str) => str.replace(/\\\\/g, "\\")
+  );
+  const relocateMapStr = JSON.stringify(relocateMap);
+  return `[${matchersStr},${relocateMapStr}]`;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PreparedRegExpRouter,
+  buildInitParams,
+  serializeInitParams
+});

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

@@ -23,9 +23,9 @@ __export(router_exports, {
 module.exports = __toCommonJS(router_exports);
 var import_router = require("../../router");
 var import_url = require("../../utils/url");
+var import_matcher = require("./matcher");
 var import_node = require("./node");
 var import_trie = require("./trie");
-const emptyParam = [];
 const nullMatcher = [/^$/, [], /* @__PURE__ */ Object.create(null)];
 let wildcardRegExpCache = /* @__PURE__ */ Object.create(null);
 function buildWildcardRegExp(path) {
@@ -54,7 +54,7 @@ function buildMatcherFromPreprocessedRoutes(routes) {
   for (let i = 0, j = -1, len = routesWithStaticPathFlag.length; i < len; i++) {
     const [pathErrorCheckOnly, path, handlers] = routesWithStaticPathFlag[i];
     if (pathErrorCheckOnly) {
-      staticMap[path] = [handlers.map(([h]) => [h, /* @__PURE__ */ Object.create(null)]), emptyParam];
+      staticMap[path] = [handlers.map(([h]) => [h, /* @__PURE__ */ Object.create(null)]), import_matcher.emptyParam];
     } else {
       j++;
     }
@@ -172,30 +172,14 @@ class RegExpRouter {
       });
     }
   }
-  match(method, path) {
-    clearWildcardRegExpCache();
-    const matchers = this.#buildAllMatchers();
-    this.match = (method2, path2) => {
-      const matcher = matchers[method2] || matchers[import_router.METHOD_NAME_ALL];
-      const staticMatch = matcher[2][path2];
-      if (staticMatch) {
-        return staticMatch;
-      }
-      const match = path2.match(matcher[0]);
-      if (!match) {
-        return [[], emptyParam];
-      }
-      const index = match.indexOf("", 1);
-      return [matcher[1][index], match];
-    };
-    return this.match(method, path);
-  }
-  #buildAllMatchers() {
+  match = import_matcher.match;
+  [import_matcher.buildAllMatchersKey]() {
     const matchers = /* @__PURE__ */ Object.create(null);
     Object.keys(this.#routes).concat(Object.keys(this.#middleware)).forEach((method) => {
       matchers[method] ||= this.#buildMatcher(method);
     });
     this.#middleware = this.#routes = void 0;
+    clearWildcardRegExpCache();
     return matchers;
   }
   #buildMatcher(method) {

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

@@ -1,5 +1,9 @@
 // src/router/reg-exp-router/index.ts
 import { RegExpRouter } from "./router.js";
+import { PreparedRegExpRouter, buildInitParams, serializeInitParams } from "./prepared-router.js";
 export {
-  RegExpRouter
+  PreparedRegExpRouter,
+  RegExpRouter,
+  buildInitParams,
+  serializeInitParams
 };

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

@@ -0,0 +1,27 @@
+// src/router/reg-exp-router/matcher.ts
+import { METHOD_NAME_ALL } from "../../router.js";
+var emptyParam = [];
+var buildAllMatchersKey = Symbol("buildAllMatchers");
+function match(method, path) {
+  const matchers = this[buildAllMatchersKey]();
+  const match2 = (method2, path2) => {
+    const matcher = matchers[method2] || matchers[METHOD_NAME_ALL];
+    const staticMatch = matcher[2][path2];
+    if (staticMatch) {
+      return staticMatch;
+    }
+    const match3 = path2.match(matcher[0]);
+    if (!match3) {
+      return [[], emptyParam];
+    }
+    const index = match3.indexOf("", 1);
+    return [matcher[1][index], match3];
+  };
+  this.match = match2;
+  return match2(method, path);
+}
+export {
+  buildAllMatchersKey,
+  emptyParam,
+  match
+};

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

@@ -0,0 +1,126 @@
+// src/router/reg-exp-router/prepared-router.ts
+import { METHOD_NAME_ALL } from "../../router.js";
+import { match, buildAllMatchersKey, emptyParam } from "./matcher.js";
+import { RegExpRouter } from "./router.js";
+var PreparedRegExpRouter = class {
+  name = "PreparedRegExpRouter";
+  #matchers;
+  #relocateMap;
+  constructor(matchers, relocateMap) {
+    this.#matchers = matchers;
+    this.#relocateMap = relocateMap;
+  }
+  add(method, path, handler) {
+    const all = this.#matchers[METHOD_NAME_ALL];
+    this.#matchers[method] ||= [
+      all[0],
+      all[1].map((list) => Array.isArray(list) ? list.slice() : 0),
+      Object.keys(all[2]).reduce((obj, key) => {
+        obj[key] = [all[2][key][0].slice(), emptyParam];
+        return obj;
+      }, {})
+    ];
+    if (path === "/*" || path === "*") {
+      const defaultHandlerData = [handler, {}];
+      (method === METHOD_NAME_ALL ? Object.keys(this.#matchers) : [method]).forEach((m) => {
+        const matcher = this.#matchers[m];
+        matcher[1].forEach((list) => list && list.push(defaultHandlerData));
+        Object.values(matcher[2]).forEach(
+          (list) => list[0].push(defaultHandlerData)
+        );
+      });
+      return;
+    }
+    const data = this.#relocateMap[path];
+    if (!data) {
+      throw new Error(`Path ${path} is not registered`);
+    }
+    for (const [indexes, map] of data) {
+      ;
+      (method === METHOD_NAME_ALL ? Object.keys(this.#matchers) : [method]).forEach((m) => {
+        const matcher = this.#matchers[m];
+        if (!map) {
+          matcher[2][path][0].push([handler, {}]);
+        } else {
+          indexes.forEach((index) => {
+            if (typeof index === "number") {
+              matcher[1][index].push([handler, map]);
+            } else {
+              ;
+              matcher[2][index || path][0].push([handler, map]);
+            }
+          });
+        }
+      });
+    }
+  }
+  [buildAllMatchersKey]() {
+    return this.#matchers;
+  }
+  match = match;
+};
+var buildInitParams = ({ paths }) => {
+  const router = new RegExpRouter();
+  for (const path of paths) {
+    router.add(METHOD_NAME_ALL, path, path);
+  }
+  const matchers = router[buildAllMatchersKey]();
+  const all = matchers[METHOD_NAME_ALL];
+  const relocateMap = {};
+  for (const path of paths) {
+    all[1].forEach((list, i) => {
+      list.forEach(([p, map]) => {
+        if (p === path) {
+          if (relocateMap[path]) {
+            relocateMap[path][0][1] = {
+              ...relocateMap[path][0][1],
+              ...map
+            };
+          } else {
+            relocateMap[path] = [[[], map]];
+          }
+          if (relocateMap[path][0][0].findIndex((j) => j === i) === -1) {
+            relocateMap[path][0][0].push(i);
+          }
+        }
+      });
+    });
+    for (const path2 in all[2]) {
+      all[2][path2][0].forEach(([p]) => {
+        if (p === path) {
+          relocateMap[path] ||= [[[], void 0]];
+          const value = path2 === path ? "" : path2;
+          if (relocateMap[path][0][0].findIndex((v) => v === value) === -1) {
+            relocateMap[path][0][0].push(value);
+          }
+        }
+      });
+    }
+  }
+  for (let i = 0, len = all[1].length; i < len; i++) {
+    all[1][i] = all[1][i] ? [] : 0;
+  }
+  for (const path in all[2]) {
+    all[2][path][0] = [];
+  }
+  return [matchers, relocateMap];
+};
+var serializeInitParams = ([matchers, relocateMap]) => {
+  for (const method in matchers) {
+    const matcher = matchers[method];
+    matcher[0].toJSON = function() {
+      return `@${this.toString()}@`;
+    };
+  }
+  const matchersStr = JSON.stringify(matchers).replace(
+    /"@(.+?)@"/g,
+    (_, str) => str.replace(/\\\\/g, "\\")
+  );
+  const relocateMapStr = JSON.stringify(relocateMap);
+  return `[${matchersStr},${relocateMapStr}]`;
+};
+export {
+  PreparedRegExpRouter,
+  buildInitParams,
+  serializeInitParams
+};

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

@@ -5,9 +5,9 @@ import {
   UnsupportedPathError
 } from "../../router.js";
 import { checkOptionalParameter } from "../../utils/url.js";
+import { match, emptyParam, buildAllMatchersKey } from "./matcher.js";
 import { PATH_ERROR } from "./node.js";
 import { Trie } from "./trie.js";
-var emptyParam = [];
 var nullMatcher = [/^$/, [], /* @__PURE__ */ Object.create(null)];
 var wildcardRegExpCache = /* @__PURE__ */ Object.create(null);
 function buildWildcardRegExp(path) {
@@ -154,30 +154,14 @@ var RegExpRouter = class {
       });
     }
   }
-  match(method, path) {
-    clearWildcardRegExpCache();
-    const matchers = this.#buildAllMatchers();
-    this.match = (method2, path2) => {
-      const matcher = matchers[method2] || matchers[METHOD_NAME_ALL];
-      const staticMatch = matcher[2][path2];
-      if (staticMatch) {
-        return staticMatch;
-      }
-      const match = path2.match(matcher[0]);
-      if (!match) {
-        return [[], emptyParam];
-      }
-      const index = match.indexOf("", 1);
-      return [matcher[1][index], match];
-    };
-    return this.match(method, path);
-  }
-  #buildAllMatchers() {
+  match = match;
+  [buildAllMatchersKey]() {
     const matchers = /* @__PURE__ */ Object.create(null);
     Object.keys(this.#routes).concat(Object.keys(this.#middleware)).forEach((method) => {
       matchers[method] ||= this.#buildMatcher(method);
     });
     this.#middleware = this.#routes = void 0;
+    clearWildcardRegExpCache();
     return matchers;
   }
   #buildMatcher(method) {

package/dist/types/context.d.ts

@@ -137,7 +137,7 @@ interface JSONRespond {
  *
  * @returns {Response & TypedResponse<JSONParsed<T>, U, 'json'>} - The response after rendering the JSON object, typed with the provided object and status code types.
  */
-export type JSONRespondReturn<T extends JSONValue | {} | InvalidJSONValue, U extends ContentfulStatusCode> = Response & TypedResponse<JSONParsed<T>, U, "json">;
+type JSONRespondReturn<T extends JSONValue | {} | InvalidJSONValue, U extends ContentfulStatusCode> = Response & TypedResponse<JSONParsed<T>, U, "json">;
 /**
  * Interface representing a function that responds with HTML content.
  *

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

@@ -3,3 +3,4 @@
  * RegExpRouter for Hono.
  */
 export { RegExpRouter } from './router';
+export { PreparedRegExpRouter, buildInitParams, serializeInitParams } from './prepared-router';

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

@@ -0,0 +1,15 @@
+import type { ParamIndexMap, Result, Router } from '../../router';
+export type HandlerData<T> = [
+    T,
+    ParamIndexMap
+][];
+export type StaticMap<T> = Record<string, Result<T>>;
+export type Matcher<T> = [
+    RegExp,
+    HandlerData<T>[],
+    StaticMap<T>
+];
+export type MatcherMap<T> = Record<string, Matcher<T> | null>;
+export declare const emptyParam: string[];
+export declare const buildAllMatchersKey: unique symbol;
+export declare function match<R extends Router<T>, T>(this: R, method: string, path: string): Result<T>;

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

@@ -0,0 +1,19 @@
+import type { ParamIndexMap, Router } from '../../router';
+import type { MatcherMap } from './matcher';
+import { match, buildAllMatchersKey } from './matcher';
+type RelocateMap = Record<string, [
+    (number | string)[],
+    ParamIndexMap | undefined
+][]>;
+export declare class PreparedRegExpRouter<T> implements Router<T> {
+    name: string;
+    constructor(matchers: MatcherMap<T>, relocateMap: RelocateMap);
+    add(method: string, path: string, handler: T): void;
+    [buildAllMatchersKey](): MatcherMap<T>;
+    match: typeof match<Router<T>, T>;
+}
+export declare const buildInitParams: (params: {
+    paths: string[];
+}) => ConstructorParameters<typeof PreparedRegExpRouter>;
+export declare const serializeInitParams: (params: ConstructorParameters<typeof PreparedRegExpRouter>) => string;
+export {};

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

@@ -1,7 +1,10 @@
-import type { Result, Router } from '../../router';
+import type { Router } from '../../router';
+import type { MatcherMap } from './matcher';
+import { match, buildAllMatchersKey } from './matcher';
 export declare class RegExpRouter<T> implements Router<T> {
     name: string;
     constructor();
     add(method: string, path: string, handler: T): void;
-    match(method: string, path: string): Result<T>;
+    match: typeof match<Router<T>, T>;
+    [buildAllMatchersKey](): MatcherMap<T>;
 }

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

@@ -36,7 +36,7 @@ export type JSONValue = JSONObject | JSONArray | JSONPrimitive;
  * which defaults to `bigint | ReadonlyArray<bigint>`.
  * You can set it to `never` to disable this check.
  */
-export type JSONParsed<T, TError = bigint | ReadonlyArray<bigint>> = T extends TError ? never : T extends {
+export type JSONParsed<T, TError = bigint | ReadonlyArray<bigint>> = T extends {
     toJSON(): infer J;
 } ? (() => J) extends () => JSONPrimitive ? J : (() => J) extends () => {
     toJSON(): unknown;
@@ -44,7 +44,7 @@ export type JSONParsed<T, TError = bigint | ReadonlyArray<bigint>> = T extends T
     [K in keyof T]: JSONParsed<InvalidToNull<T[K]>, TError>;
 } : T extends Set<unknown> | Map<unknown, unknown> | Record<string, never> ? {} : T extends object ? T[keyof T] extends TError ? never : {
     [K in keyof OmitSymbolKeys<T> as IsInvalid<T[K]> extends true ? never : K]: boolean extends IsInvalid<T[K]> ? JSONParsed<T[K], TError> | undefined : JSONParsed<T[K], TError>;
-} : T extends unknown ? JSONValue : never;
+} : T extends unknown ? T extends TError ? never : JSONValue : never;
 /**
  * Useful to flatten the type output to improve type hints shown in editors. And also to transform an interface into a type to aide with assignability.
  * @copyright from sindresorhus/type-fest

package/package.json

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