hono 4.13.13 → 5.0.0-rc.1

package/dist/request.js

@@ -4,36 +4,10 @@ import { parseBody } from "./utils/body.js";
 import { getQueryParam, getQueryParams, tryDecodeURIComponent } from "./utils/url.js";
 //#region src/request.ts
 var HonoRequest = class {
-	/**
-	* `.raw` can get the raw Request object.
-	*
-	* @see {@link https://hono.dev/docs/api/request#raw}
-	*
-	* @example
-	* ```ts
-	* // For Cloudflare Workers
-	* app.post('/', async (c) => {
-	*   const metadata = c.req.raw.cf?.hostMetadata?
-	*   ...
-	* })
-	* ```
-	*/
 	raw;
 	#validatedData;
 	#matchResult;
 	routeIndex = 0;
-	/**
-	* `.path` can get the pathname of the request.
-	*
-	* @see {@link https://hono.dev/docs/api/request#path}
-	*
-	* @example
-	* ```ts
-	* app.get('/about/me', (c) => {
-	*   const pathname = c.req.path // `/about/me`
-	* })
-	* ```
-	*/
 	path;
 	bodyCache = {};
 	constructor(request, path = "/", matchResult = [[]]) {
@@ -89,219 +63,40 @@ var HonoRequest = class {
 		});
 		return bodyCache[key] = raw[key]();
 	};
-	/**
-	* `.json()` can parse Request body of type `application/json`
-	*
-	* @see {@link https://hono.dev/docs/api/request#json}
-	*
-	* @example
-	* ```ts
-	* app.post('/entry', async (c) => {
-	*   const body = await c.req.json()
-	* })
-	* ```
-	*/
 	json() {
 		return this.#cachedBody("text").then((text) => JSON.parse(text));
 	}
-	/**
-	* `.text()` can parse Request body of type `text/plain`
-	*
-	* @see {@link https://hono.dev/docs/api/request#text}
-	*
-	* @example
-	* ```ts
-	* app.post('/entry', async (c) => {
-	*   const body = await c.req.text()
-	* })
-	* ```
-	*/
 	text() {
 		return this.#cachedBody("text");
 	}
-	/**
-	* `.arrayBuffer()` parse Request body as an `ArrayBuffer`
-	*
-	* @see {@link https://hono.dev/docs/api/request#arraybuffer}
-	*
-	* @example
-	* ```ts
-	* app.post('/entry', async (c) => {
-	*   const body = await c.req.arrayBuffer()
-	* })
-	* ```
-	*/
 	arrayBuffer() {
 		return this.#cachedBody("arrayBuffer");
 	}
-	/**
-	* `.bytes()` parses the request body as a `Uint8Array`.
-	*
-	* @see {@link https://hono.dev/docs/api/request#bytes}
-	*
-	* @example
-	* ```ts
-	* app.post('/entry', async (c) => {
-	*   const body = await c.req.bytes()
-	* })
-	* ```
-	*/
 	bytes() {
 		return this.#cachedBody("arrayBuffer").then((buffer) => new Uint8Array(buffer));
 	}
-	/**
-	* Parses the request body as a `Blob`.
-	* @example
-	* ```ts
-	* app.post('/entry', async (c) => {
-	*   const body = await c.req.blob();
-	* });
-	* ```
-	* @see https://hono.dev/docs/api/request#blob
-	*/
 	blob() {
 		return this.#cachedBody("blob");
 	}
-	/**
-	* Parses the request body as `FormData`.
-	* @example
-	* ```ts
-	* app.post('/entry', async (c) => {
-	*   const body = await c.req.formData();
-	* });
-	* ```
-	* @see https://hono.dev/docs/api/request#formdata
-	*/
 	formData() {
 		return this.#cachedBody("formData");
 	}
-	/**
-	* Adds validated data to the request.
-	*
-	* @param target - The target of the validation.
-	* @param data - The validated data to add.
-	*/
 	addValidatedData(target, data) {
 		(this.#validatedData ??= {})[target] = data;
 	}
 	valid(target) {
 		return this.#validatedData?.[target];
 	}
-	/**
-	* `.url` can get the request url strings.
-	*
-	* @see {@link https://hono.dev/docs/api/request#url}
-	*
-	* @example
-	* ```ts
-	* app.get('/about/me', (c) => {
-	*   const url = c.req.url // `http://localhost:8787/about/me`
-	*   ...
-	* })
-	* ```
-	*/
 	get url() {
 		return this.raw.url;
 	}
-	/**
-	* `.method` can get the method name of the request.
-	*
-	* @see {@link https://hono.dev/docs/api/request#method}
-	*
-	* @example
-	* ```ts
-	* app.get('/about/me', (c) => {
-	*   const method = c.req.method // `GET`
-	* })
-	* ```
-	*/
 	get method() {
 		return this.raw.method;
 	}
 	get [GET_MATCH_RESULT]() {
 		return this.#matchResult;
 	}
-	/**
-	* `.matchedRoutes` can return a matched route in the handler
-	*
-	* @deprecated
-	*
-	* Use matchedRoutes helper defined in "hono/route" instead.
-	*
-	* @see {@link https://hono.dev/docs/api/request#matchedroutes}
-	*
-	* @example
-	* ```ts
-	* app.use('*', async function logger(c, next) {
-	*   await next()
-	*   c.req.matchedRoutes.forEach(({ handler, method, path }, i) => {
-	*     const name = handler.name || (handler.length < 2 ? '[handler]' : '[middleware]')
-	*     console.log(
-	*       method,
-	*       ' ',
-	*       path,
-	*       ' '.repeat(Math.max(10 - path.length, 0)),
-	*       name,
-	*       i === c.req.routeIndex ? '<- respond from here' : ''
-	*     )
-	*   })
-	* })
-	* ```
-	*/
-	get matchedRoutes() {
-		return this.#matchResult[0].map(([[, route]]) => route);
-	}
-	/**
-	* `.routePath` can retrieve the path registered within the handler
-	*
-	* @deprecated
-	*
-	* Use routePath helper defined in "hono/route" instead.
-	*
-	* @see {@link https://hono.dev/docs/api/request#routepath}
-	*
-	* @example
-	* ```ts
-	* app.get('/posts/:id', (c) => {
-	*   return c.json({ path: c.req.routePath })
-	* })
-	* ```
-	*/
-	get routePath() {
-		return this.#matchResult[0].map(([[, route]]) => route)[this.routeIndex].path;
-	}
 };
-/**
-* Clones a HonoRequest's underlying raw Request object.
-*
-* This utility handles both consumed and unconsumed request bodies:
-* - If the request body hasn't been consumed, it uses the native `clone()` method
-* - If the request body has been consumed, it reconstructs a new Request using cached body data
-*
-* This is particularly useful when you need to:
-* - Process the same request body multiple times
-* - Pass requests to external services after validation
-*
-* @param req - The HonoRequest object to clone
-* @returns A Promise that resolves to a new Request object with the same properties
-* @throws {HTTPException} If the request body was consumed directly via `req.raw`
-*   without using HonoRequest methods (e.g., `req.json()`, `req.text()`), making it
-*   impossible to reconstruct the body from cache
-*
-* @example
-* ```ts
-* // Clone after consuming the body (e.g., after validation)
-* app.post('/forward',
-*   validator('json', (data) => data),
-*   async (c) => {
-*     const validated = c.req.valid('json')
-*     // Body has been consumed, but cloneRawRequest still works
-*     const clonedReq = await cloneRawRequest(c.req)
-*     return fetch('http://backend-service.com', clonedReq)
-*   }
-* )
-* ```
-*/
 const cloneRawRequest = async (req) => {
 	if (!req.raw.bodyUsed) return req.raw.clone();
 	const cacheKey = Object.keys(req.bodyCache)[0];

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

@@ -2,12 +2,14 @@ import { checkOptionalParameter } from "../../utils/url.js";
 import { UnsupportedPathError } from "../../router.js";
 //#region src/router/linear-router/router.ts
 const emptyParams = Object.create(null);
-const splitPathRe = /\/(:\w+(?:{(?:(?:{[\d,]+})|[^}])+})?)|\/[^\/\?]+|(\?)/g;
+const splitPathRe = /\/(:\w+(?:{(?:(?:{[\d,]+})|[^}])+})?)|\/[^\/\?]+|\/$|(\?)/g;
 const splitByStarRe = /\*/;
 var LinearRouter = class {
 	name = "LinearRouter";
 	#routes = [];
 	add(method, path, handler) {
+		const starIndex = path.indexOf("*");
+		if (starIndex !== -1 && path.includes(":") && (!path.endsWith("/*") || starIndex !== path.length - 1)) throw new UnsupportedPathError();
 		for (let i = 0, paths = checkOptionalParameter(path) || [path], len = paths.length; i < len; i++) this.#routes.push([
 			method,
 			paths[i],
@@ -26,7 +28,7 @@ var LinearRouter = class {
 				const hasStar = routePath.indexOf("*") !== -1;
 				const hasLabel = routePath.indexOf(":") !== -1;
 				if (!hasStar && !hasLabel) {
-					if (routePath === path || routePath + "/" === path) handlers.push([handler, emptyParams]);
+					if (routePath === path) handlers.push([handler, emptyParams]);
 				} else if (hasStar && !hasLabel) {
 					const endsWithStar = routePath.charCodeAt(routePath.length - 1) === 42;
 					const endsWithSlashStar = routePath.endsWith("/*");
@@ -39,17 +41,18 @@ var LinearRouter = class {
 						if (j === lastIndex) {
 							if (endsWithSlashStar) {
 								if (pos !== path.length && path.charCodeAt(pos) !== 47) continue ROUTES_LOOP;
-							} else if (!endsWithStar && pos !== path.length && !(pos === path.length - 1 && path.charCodeAt(pos) === 47)) continue ROUTES_LOOP;
+							} else if (!endsWithStar && pos !== path.length) continue ROUTES_LOOP;
 						} else {
-							const index = path.indexOf("/", pos);
+							const standalone = part.charCodeAt(part.length - 1) === 47;
+							const index = path.indexOf("/", standalone ? pos + 1 : pos);
 							if (index === -1) continue ROUTES_LOOP;
 							pos = index;
 						}
 					}
 					handlers.push([handler, emptyParams]);
-				} else if (hasLabel && !hasStar) {
+				} else {
 					const params = Object.create(null);
-					const parts = routePath.match(splitPathRe);
+					const parts = (hasStar ? routePath.slice(0, -2) : routePath).match(splitPathRe);
 					const lastIndex = parts.length - 1;
 					for (let j = 0, pos = 0, len = parts.length; j < len; j++) {
 						if (pos === -1 || pos >= path.length) continue ROUTES_LOOP;
@@ -61,10 +64,15 @@ var LinearRouter = class {
 							if (name.charCodeAt(name.length - 1) === 125) {
 								const openBracePos = name.indexOf("{");
 								const next = parts[j + 1];
-								const lookahead = next && next[1] !== ":" && next[1] !== "*" ? `(?=${next})` : "";
-								const pattern = name.slice(openBracePos + 1, -1) + lookahead;
+								const lookahead = next && next[1] !== ":" && next[1] !== "*" ? `(?=${next})` : hasStar ? "(?=/|$)" : "";
+								const pattern = `(?:${name.slice(openBracePos + 1, -1)})${lookahead}`;
 								const restPath = path.slice(pos + 1);
-								const match = new RegExp(pattern, "d").exec(restPath);
+								const regexp = new RegExp(pattern, "d");
+								let match = regexp.exec(restPath);
+								if (hasStar && match?.index !== 0) {
+									const slashPos = restPath.indexOf("/");
+									if (slashPos !== -1) match = regexp.exec(restPath.slice(0, slashPos));
+								}
 								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]);
@@ -81,12 +89,10 @@ var LinearRouter = class {
 							if (path.indexOf(part, pos) !== 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;
-						}
+						if (j === lastIndex && pos !== path.length && !(hasStar && path.charCodeAt(pos) === 47)) continue ROUTES_LOOP;
 					}
 					handlers.push([handler, params]);
-				} else if (hasLabel && hasStar) throw new UnsupportedPathError();
+				}
 			}
 		}
 		return [handlers];

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

@@ -5,15 +5,15 @@ var PatternRouter = class {
 	name = "PatternRouter";
 	#routes = [];
 	add(method, path, handler) {
-		const suffix = path.endsWith("/*") ? "(?:$|/)" : path.endsWith("*") ? "" : "/?$";
+		const suffix = path.endsWith("/*") ? "(?:$|/)" : path.endsWith("*") ? "" : path.endsWith("/") ? "/$" : "$";
 		path = path.replace(/\*$/, "");
 		if (path.at(-1) === "?") {
 			path = path.slice(0, -1);
-			this.add(method, path.replace(/\/[^/]+$/, ""), handler);
+			this.add(method, path.replace(/\/[^/]+$/, "") || "/", handler);
 		}
 		const parts = (path.match(/\/?(:\w+(?:{(?:(?:{[\d,]+})|[^}])+})?)|\/?[^\/\?]+/g) || []).map((part) => {
 			const match = part.match(/^\/:([^{]+)(?:{(.*)})?/);
-			return match ? `/(?<${match[1]}>${match[2] || "[^/]+"})` : part === "/*" ? "/[^/]+" : part.replace(/[.\\+*[^\]$()]/g, "\\$&");
+			return match ? `/(?<${match[1]}>${match[2] || "[^/]+"})` : part === "/*" ? "/[^/]+" : part.endsWith("*") ? part.slice(0, -1).replace(/[.\\+*[^\]$()]/g, "\\$&") + "[^/]*" : part.replace(/[.\\+*[^\]$()]/g, "\\$&");
 		});
 		try {
 			this.#routes.push([

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

@@ -2,16 +2,10 @@ import { createNullObject } from "../utils.js";
 //#region src/router/reg-exp-router/node.ts
 const LABEL_REG_EXP_STR = "[^/]+";
 const ONLY_WILDCARD_REG_EXP_STR = ".*";
+const PREFIXED_WILDCARD_REG_EXP_STR = "[^/]*";
 const TAIL_WILDCARD_REG_EXP_STR = "(?:|/.*)";
 const PATH_ERROR = Symbol();
 const regExpMetaChars = /* @__PURE__ */ new Set(".\\+*[^]$()");
-/**
-* Sort order:
-* 1. literal
-* 2. special pattern (e.g. :label{[0-9]+})
-* 3. common label pattern (e.g. :label)
-* 4. wildcard
-*/
 function compareKey(a, b) {
 	if (a.length === 1) return b.length === 1 ? a < b ? -1 : 1 : -1;
 	if (b.length === 1) return 1;
@@ -33,10 +27,14 @@ var Node = class Node {
 				"",
 				"",
 				".*"
-			] : [
+			] : tokens[i + 1][0] !== "/" ? null : tokens[i - 1] === "/" ? [
 				"",
 				"",
 				LABEL_REG_EXP_STR
+			] : [
+				"",
+				"",
+				PREFIXED_WILDCARD_REG_EXP_STR
 			] : null : token === "/*" ? [
 				"",
 				"",
@@ -47,15 +45,15 @@ var Node = class Node {
 				const name = pattern[1];
 				let regexpStr = pattern[2] || "[^/]+";
 				if (name && pattern[2]) {
-					if (regexpStr === ".*") throw PATH_ERROR;
+					if (new RegExp(regexpStr).test("")) throw PATH_ERROR;
 					regexpStr = regexpStr.replace(/^\((?!\?:)(?=[^)]+\)$)/, "(?:");
 					if (/\((?!\?:)/.test(regexpStr)) throw PATH_ERROR;
 					if (regexpStr.length === 1 && regExpMetaChars.has(regexpStr)) throw PATH_ERROR;
 				}
 				nextNode = node.#children[regexpStr];
 				if (!nextNode) {
-					if (regexpStr !== ".*" && regexpStr !== "(?:|/.*)") {
-						for (const k in node.#children) if ((regexpStr.length > 1 || k.length > 1) && k !== ".*" && k !== "(?:|/.*)") throw PATH_ERROR;
+					if (regexpStr !== ".*" && (regexpStr !== "(?:|/.*)" || node.#children[PREFIXED_WILDCARD_REG_EXP_STR])) {
+						for (const k in node.#children) if ((regexpStr.length > 1 || k.length > 1) && k !== ".*" && (k !== "(?:|/.*)" || regexpStr === PREFIXED_WILDCARD_REG_EXP_STR)) throw PATH_ERROR;
 					}
 					nextNode = node.#children[regexpStr] = new Node();
 				}

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

@@ -25,11 +25,6 @@ var Trie = class {
 			});
 			if (!replaced) break;
 		}
-		/**
-		*  - pattern (:label, :label{0-9]+}, ...)
-		*  - /* wildcard
-		*  - character
-		*/
 		const tokens = markedPath.match(/(?::[^\/]+)|(?:\/\*$)|./g) || [];
 		for (let i = groups.length - 1; i >= 0; i--) {
 			const [mark] = groups[i];

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

@@ -17,7 +17,7 @@ var Node = class Node {
 		let i = 0;
 		for (const p of parts) {
 			const nextP = parts[++i];
-			const pattern = getPattern(p, nextP) || (nextP === void 0 && p && p.indexOf("*") === p.length - 1 ? p : null);
+			const pattern = getPattern(p, nextP) || (p && p.indexOf("*") === p.length - 1 ? p : null);
 			const isParam = Array.isArray(pattern);
 			const key = isParam ? pattern[0] : pattern || p;
 			const child = curNode.#children[key] ||= new Node();
@@ -66,9 +66,9 @@ var Node = class Node {
 				if (nextNode) {
 					nextNode.#params = node.#params;
 					if (isLast) {
-						if (nextNode.#children["*"]) this.#pushHandlerSets(handlerSets, nextNode.#children["*"], method, node.#params);
-						this.#pushHandlerSets(handlerSets, nextNode, method, node.#params);
-					} else tempNodes.push(nextNode);
+						if (nextNode.#children["*"] && !Array.isArray(nextNode.#pattern)) this.#pushHandlerSets(handlerSets, nextNode.#children["*"], method, node.#params);
+						if (nextNode.#pattern === void 0) this.#pushHandlerSets(handlerSets, nextNode, method, node.#params);
+					} else if (nextNode.#pattern !== "*" && !Array.isArray(nextNode.#pattern)) tempNodes.push(nextNode);
 				}
 				for (const child of node.#patterns) {
 					const pattern = child.#pattern;
@@ -76,7 +76,7 @@ var Node = class Node {
 					if (typeof pattern === "string") {
 						if (pattern === "*" || part.startsWith(pattern.slice(0, -1))) {
 							this.#pushHandlerSets(handlerSets, child, method, node.#params);
-							if (pattern === "*") {
+							if (pattern !== "*" || part !== "") {
 								child.#params = params;
 								tempNodes.push(child);
 							}

package/dist/router.js

@@ -1,19 +1,6 @@
 //#region src/router.ts
-/**
-* @module
-* This module provides types definitions and variables for the routers.
-*/
-/**
-* Constant representing all HTTP methods in uppercase.
-*/
 const METHOD_NAME_ALL = "ALL";
-/**
-* Constant representing all HTTP methods in lowercase.
-*/
 const METHOD_NAME_ALL_LOWERCASE = "all";
-/**
-* Array of supported HTTP methods.
-*/
 const METHODS = [
 	"get",
 	"post",
@@ -23,13 +10,7 @@ const METHODS = [
 	"patch",
 	"query"
 ];
-/**
-* Error message indicating that a route cannot be added because the matcher is already built.
-*/
 const MESSAGE_MATCHER_IS_ALREADY_BUILT = "Can not add a route since the matcher is already built.";
-/**
-* Error class representing an unsupported path error.
-*/
 var UnsupportedPathError = class extends Error {};
 //#endregion
 export { MESSAGE_MATCHER_IS_ALREADY_BUILT, METHODS, METHOD_NAME_ALL, METHOD_NAME_ALL_LOWERCASE, UnsupportedPathError };

package/dist/{types/types.d.ts → types.d.ts}

@@ -1,8 +1,8 @@
-import { HonoBase as Hono } from "./hono-base.js";
 import { CustomHeader, RequestHeader } from "./utils/headers.js";
 import { StatusCode } from "./utils/http-status.js";
 import { IfAnyThenEmptyObject, IsAny, JSONValue, RemoveBlankRecord, Simplify, UnionToIntersection } from "./utils/types.js";
 import { Context } from "./context.js";
+import { HonoBase as Hono } from "./hono-base.js";
 //#region src/types.d.ts
 export type Bindings = object;
 export type Variables = object;
@@ -25,6 +25,8 @@ export interface RouterRoute {
   path: string;
   method: string;
   handler: H;
+  /** Number of application boundaries crossed by `route()`. */
+  depth?: number;
 }
 export type HandlerResponse<O> = Response | TypedResponse<O> | Promise<Response | TypedResponse<O>> | Promise<void>;
 export type Handler<E extends Env = any, P extends string = any, I extends Input = BlankInput, R extends HandlerResponse<any> = any> = (c: Context<E, P, I>, next: Next) => R;
@@ -43,7 +45,8 @@ export type NotFoundHandler<E extends Env = any> = (c: Context<E>) => NotFoundRe
 export interface HTTPResponseError extends Error {
   getResponse: () => Response;
 }
-export type ErrorHandler<E extends Env = any> = (err: Error | HTTPResponseError, c: Context<E>) => Response | Promise<Response>;
+/** Error middleware registered with `onError()`. The error is available as `c.error`. */
+export type ErrorHandler<E extends Env = any> = H<E>;
 export interface HandlerInterface<E extends Env = Env, M extends string = string, S extends Schema = BlankSchema, BasePath extends string = '/', CurrentPath extends string = BasePath> {
   <P extends string = CurrentPath, I extends Input = BlankInput, R extends HandlerResponse<any> = any, E2 extends Env = E>(handler: H<E2, P, I, R>): Hono<IntersectNonAnyTypes<[E, E2]>, S & ToSchema<M, P, I, MergeTypedResponse<R>>, BasePath, CurrentPath>;
   <P extends string = CurrentPath, I extends Input = BlankInput, I2 extends Input = I, R extends HandlerResponse<any> = any, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, M1 extends H<E2, P, I> = H<E2, P, I>>(...handlers: [H<E2, P, I> & M1, H<E3, P, I2, R>]): Hono<IntersectNonAnyTypes<[E, E2, E3]>, S & ToSchema<M, P, I2, MergeTypedResponse<R> | MergeMiddlewareResponse<M1>>, BasePath, CurrentPath>;
@@ -69,6 +72,34 @@ export interface HandlerInterface<E extends Env = Env, M extends string = string
   <P extends string, I extends Input = BlankInput, R extends HandlerResponse<any> = any>(path: P, ...handlers: [H<E, MergePath<BasePath, P>, I, R>, ...H<E, MergePath<BasePath, P>, I, R>[]]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I, MergeTypedResponse<R>>, BasePath, MergePath<BasePath, P>>;
   <P extends string, R extends HandlerResponse<any> = any, I extends Input = BlankInput>(path: P): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I, MergeTypedResponse<R>>, BasePath, MergePath<BasePath, P>>;
 }
+/**
+ * Fallback middleware composes environments without changing the route schema or current path.
+ * Its scope does not determine request parameters, which come from the original route.
+ */
+export interface FallbackHandlerInterface<E extends Env, S extends Schema, BasePath extends string, CurrentPath extends string> {
+  <E2 extends Env = E>(...handlers: [H<E2, string, any, any>]): Hono<IntersectNonAnyTypes<[E, E2]>, S, BasePath, CurrentPath>;
+  <Path extends string, E2 extends Env = E>(path: Path, ...handlers: [H<E2, string, any, any>]): Hono<IntersectNonAnyTypes<[E, E2]>, S, BasePath, CurrentPath>;
+  <E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>>(...handlers: [H<E2, string, any, any>, H<E3, string, any, any>]): Hono<IntersectNonAnyTypes<[E, E2, E3]>, S, BasePath, CurrentPath>;
+  <Path extends string, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>>(path: Path, ...handlers: [H<E2, string, any, any>, H<E3, string, any, any>]): Hono<IntersectNonAnyTypes<[E, E2, E3]>, S, BasePath, CurrentPath>;
+  <E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>>(...handlers: [H<E2, string, any, any>, H<E3, string, any, any>, H<E4, string, any, any>]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4]>, S, BasePath, CurrentPath>;
+  <Path extends string, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>>(path: Path, ...handlers: [H<E2, string, any, any>, H<E3, string, any, any>, H<E4, string, any, any>]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4]>, S, BasePath, CurrentPath>;
+  <E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>>(...handlers: [H<E2, string, any, any>, H<E3, string, any, any>, H<E4, string, any, any>, H<E5, string, any, any>]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, S, BasePath, CurrentPath>;
+  <Path extends string, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>>(path: Path, ...handlers: [H<E2, string, any, any>, H<E3, string, any, any>, H<E4, string, any, any>, H<E5, string, any, any>]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, S, BasePath, CurrentPath>;
+  <E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>>(...handlers: [H<E2, string, any, any>, H<E3, string, any, any>, H<E4, string, any, any>, H<E5, string, any, any>, H<E6, string, any, any>]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, S, BasePath, CurrentPath>;
+  <Path extends string, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>>(path: Path, ...handlers: [H<E2, string, any, any>, H<E3, string, any, any>, H<E4, string, any, any>, H<E5, string, any, any>, H<E6, string, any, any>]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, S, BasePath, CurrentPath>;
+  <E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>>(...handlers: [H<E2, string, any, any>, H<E3, string, any, any>, H<E4, string, any, any>, H<E5, string, any, any>, H<E6, string, any, any>, H<E7, string, any, any>]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, S, BasePath, CurrentPath>;
+  <Path extends string, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>>(path: Path, ...handlers: [H<E2, string, any, any>, H<E3, string, any, any>, H<E4, string, any, any>, H<E5, string, any, any>, H<E6, string, any, any>, H<E7, string, any, any>]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, S, BasePath, CurrentPath>;
+  <E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>>(...handlers: [H<E2, string, any, any>, H<E3, string, any, any>, H<E4, string, any, any>, H<E5, string, any, any>, H<E6, string, any, any>, H<E7, string, any, any>, H<E8, string, any, any>]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, S, BasePath, CurrentPath>;
+  <Path extends string, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>>(path: Path, ...handlers: [H<E2, string, any, any>, H<E3, string, any, any>, H<E4, string, any, any>, H<E5, string, any, any>, H<E6, string, any, any>, H<E7, string, any, any>, H<E8, string, any, any>]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, S, BasePath, CurrentPath>;
+  <E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, E9 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>>(...handlers: [H<E2, string, any, any>, H<E3, string, any, any>, H<E4, string, any, any>, H<E5, string, any, any>, H<E6, string, any, any>, H<E7, string, any, any>, H<E8, string, any, any>, H<E9, string, any, any>]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>, S, BasePath, CurrentPath>;
+  <Path extends string, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, E9 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>>(path: Path, ...handlers: [H<E2, string, any, any>, H<E3, string, any, any>, H<E4, string, any, any>, H<E5, string, any, any>, H<E6, string, any, any>, H<E7, string, any, any>, H<E8, string, any, any>, H<E9, string, any, any>]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>, S, BasePath, CurrentPath>;
+  <E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, E9 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, E10 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>>(...handlers: [H<E2, string, any, any>, H<E3, string, any, any>, H<E4, string, any, any>, H<E5, string, any, any>, H<E6, string, any, any>, H<E7, string, any, any>, H<E8, string, any, any>, H<E9, string, any, any>, H<E10, string, any, any>]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10]>, S, BasePath, CurrentPath>;
+  <Path extends string, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, E9 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, E10 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>>(path: Path, ...handlers: [H<E2, string, any, any>, H<E3, string, any, any>, H<E4, string, any, any>, H<E5, string, any, any>, H<E6, string, any, any>, H<E7, string, any, any>, H<E8, string, any, any>, H<E9, string, any, any>, H<E10, string, any, any>]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10]>, S, BasePath, CurrentPath>;
+  <E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, E9 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, E10 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>, E11 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10]>>(...handlers: [H<E2, string, any, any>, H<E3, string, any, any>, H<E4, string, any, any>, H<E5, string, any, any>, H<E6, string, any, any>, H<E7, string, any, any>, H<E8, string, any, any>, H<E9, string, any, any>, H<E10, string, any, any>, H<E11, string, any, any>]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11]>, S, BasePath, CurrentPath>;
+  <Path extends string, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, E9 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, E10 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>, E11 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10]>>(path: Path, ...handlers: [H<E2, string, any, any>, H<E3, string, any, any>, H<E4, string, any, any>, H<E5, string, any, any>, H<E6, string, any, any>, H<E7, string, any, any>, H<E8, string, any, any>, H<E9, string, any, any>, H<E10, string, any, any>, H<E11, string, any, any>]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11]>, S, BasePath, CurrentPath>;
+  <E2 extends Env = E>(...handlers: H<E2, string, any, any>[]): Hono<IntersectNonAnyTypes<[E, E2]>, S, BasePath, CurrentPath>;
+  <Path extends string, E2 extends Env = E>(path: Path, ...handlers: H<E2, string, any, any>[]): Hono<IntersectNonAnyTypes<[E, E2]>, S, BasePath, CurrentPath>;
+}
 export interface MiddlewareHandlerInterface<E extends Env = Env, S extends Schema = BlankSchema, BasePath extends string = '/'> {
   <E2 extends Env = E>(...handlers: MiddlewareHandler<E2, MergePath<BasePath, '*'>>[]): Hono<IntersectNonAnyTypes<[E, E2]>, S, BasePath, MergePath<BasePath, '*'>>;
   <E2 extends Env = E>(handler: MiddlewareHandler<E2, MergePath<BasePath, '*'>>): Hono<IntersectNonAnyTypes<[E, E2]>, S, BasePath, MergePath<BasePath, '*'>>;

package/dist/utils/body.js

@@ -11,14 +11,6 @@ const parseBody = async (request, options = Object.create(null)) => {
 	});
 	return {};
 };
-/**
-* Parses form data from a request.
-*
-* @template T - The type of the parsed body data.
-* @param {HonoRequest | Request} request - The request object containing form data.
-* @param {ParseBodyOptions} options - Options for parsing the form data.
-* @returns {Promise<T>} The parsed body data.
-*/
 async function parseFormData(request, options) {
 	if (!isRawRequest(request) && request.bodyCache.formData) return convertFormDataToBodyData(await request.bodyCache.formData, options);
 	const headers = isRawRequest(request) ? request.headers : request.raw.headers;
@@ -29,14 +21,6 @@ async function parseFormData(request, options) {
 	if (formData) return convertFormDataToBodyData(formData, options);
 	return {};
 }
-/**
-* Converts form data to body data based on the provided options.
-*
-* @template T - The type of the parsed body data.
-* @param {FormData} formData - The form data to convert.
-* @param {ParseBodyOptions} options - Options for parsing the form data.
-* @returns {T} The converted body data.
-*/
 function convertFormDataToBodyData(formData, options) {
 	const form = Object.create(null);
 	const nestingState = { count: 0 };
@@ -52,13 +36,6 @@ function convertFormDataToBodyData(formData, options) {
 	});
 	return form;
 }
-/**
-* Handles parsing all values for a given key, supporting multiple values as arrays.
-*
-* @param {BodyData} form - The form data object.
-* @param {string} key - The key to parse.
-* @param {FormDataEntryValue} value - The value to assign.
-*/
 const handleParsingAllValues = (form, key, value) => {
 	if (form[key] !== void 0) {
 		if (Array.isArray(form[key])) form[key].push(value);
@@ -66,13 +43,6 @@ const handleParsingAllValues = (form, key, value) => {
 	} else if (!key.endsWith("[]")) form[key] = value;
 	else form[key] = [value];
 };
-/**
-* Handles parsing nested values using dot notation keys.
-*
-* @param {BodyData} form - The form data object.
-* @param {string} key - The dot notation key.
-* @param {BodyDataValue} value - The value to assign.
-*/
 const handleParsingNestedValues = (form, key, value, state) => {
 	if (/(?:^|\.)__proto__\./.test(key)) return;
 	let nestedForm = form;

package/dist/utils/buffer.d.ts

@@ -0,0 +1,11 @@
+//#region src/utils/buffer.d.ts
+/**
+ * @module
+ * Buffer utility.
+ */
+export declare const equal: (a: ArrayBuffer, b: ArrayBuffer) => boolean;
+export type StringHashFunction = (input: string) => string | null | Promise<string | null>;
+export declare const timingSafeEqual: (a: string, b: string, hashFunction?: StringHashFunction) => Promise<boolean>;
+export declare const bufferToString: (buffer: ArrayBuffer) => string;
+export declare const bufferToFormData: (arrayBuffer: ArrayBuffer, contentType: string) => Promise<FormData>;
+//#endregion