hono 3.11.6 → 3.11.8

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

@@ -47,6 +47,8 @@ const html = (strings, ...values) => {
         } else {
           buffer[0] += tmp;
         }
+      } else if (child instanceof Promise) {
+        buffer.unshift("", child);
       } else {
         (0, import_html.escapeToBuffer)(child.toString(), buffer);
       }

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

@@ -32,7 +32,7 @@ class Node {
     this.name = "";
     if (method && handler) {
       const m = {};
-      m[method] = { handler, params: {}, possibleKeys: [], score: 0, name: this.name };
+      m[method] = { handler, possibleKeys: [], score: 0, name: this.name };
       this.methods = [m];
     }
     this.patterns = [];
@@ -70,7 +70,6 @@ class Node {
     const m = {};
     const handlerSet = {
       handler,
-      params: {},
       possibleKeys,
       name: this.name,
       score: this.order
@@ -85,6 +84,7 @@ class Node {
       const m = node.methods[i];
       const handlerSet = m[method] || m[import_router.METHOD_NAME_ALL];
       if (handlerSet !== void 0) {
+        handlerSet.params = {};
         handlerSet.possibleKeys.map((key) => {
           handlerSet.params[key] = params[key];
         });
@@ -110,11 +110,9 @@ class Node {
         if (nextNode) {
           if (isLast === true) {
             if (nextNode.children["*"]) {
-              handlerSets.push(
-                ...this.gHSets(nextNode.children["*"], method, { ...params, ...node.params })
-              );
+              handlerSets.push(...this.gHSets(nextNode.children["*"], method, node.params));
             }
-            handlerSets.push(...this.gHSets(nextNode, method, { ...params, ...node.params }));
+            handlerSets.push(...this.gHSets(nextNode, method, node.params));
           } else {
             tempNodes.push(nextNode);
           }
@@ -124,7 +122,7 @@ class Node {
           if (pattern === "*") {
             const astNode = node.children["*"];
             if (astNode) {
-              handlerSets.push(...this.gHSets(astNode, method, { ...params, ...node.params }));
+              handlerSets.push(...this.gHSets(astNode, method, node.params));
               tempNodes.push(astNode);
             }
             continue;

package/dist/cjs/utils/html.js

@@ -28,16 +28,28 @@ const escapeRe = /[&<>'"]/;
 const stringBufferToString = async (buffer) => {
   let str = "";
   const callbacks = [];
-  for (let i = buffer.length - 1; i >= 0; i--) {
+  for (let i = buffer.length - 1; ; i--) {
+    str += buffer[i];
+    i--;
+    if (i < 0) {
+      break;
+    }
     let r = await buffer[i];
     if (typeof r === "object") {
       callbacks.push(...r.callbacks || []);
     }
+    const isEscaped = r.isEscaped;
     r = await (typeof r === "object" ? r.toString() : r);
     if (typeof r === "object") {
       callbacks.push(...r.callbacks || []);
     }
-    str += r;
+    if (r.isEscaped ?? isEscaped) {
+      str += r;
+    } else {
+      const buf = [str];
+      escapeToBuffer(r, buf);
+      str = buf[0];
+    }
   }
   return (0, import_html.raw)(str, callbacks);
 };

package/dist/helper/html/index.js

@@ -24,6 +24,8 @@ var html = (strings, ...values) => {
         } else {
           buffer[0] += tmp;
         }
+      } else if (child instanceof Promise) {
+        buffer.unshift("", child);
       } else {
         escapeToBuffer(child.toString(), buffer);
       }

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

@@ -10,7 +10,7 @@ var Node = class {
     this.name = "";
     if (method && handler) {
       const m = {};
-      m[method] = { handler, params: {}, possibleKeys: [], score: 0, name: this.name };
+      m[method] = { handler, possibleKeys: [], score: 0, name: this.name };
       this.methods = [m];
     }
     this.patterns = [];
@@ -48,7 +48,6 @@ var Node = class {
     const m = {};
     const handlerSet = {
       handler,
-      params: {},
       possibleKeys,
       name: this.name,
       score: this.order
@@ -63,6 +62,7 @@ var Node = class {
       const m = node.methods[i];
       const handlerSet = m[method] || m[METHOD_NAME_ALL];
       if (handlerSet !== void 0) {
+        handlerSet.params = {};
         handlerSet.possibleKeys.map((key) => {
           handlerSet.params[key] = params[key];
         });
@@ -88,11 +88,9 @@ var Node = class {
         if (nextNode) {
           if (isLast === true) {
             if (nextNode.children["*"]) {
-              handlerSets.push(
-                ...this.gHSets(nextNode.children["*"], method, { ...params, ...node.params })
-              );
+              handlerSets.push(...this.gHSets(nextNode.children["*"], method, node.params));
             }
-            handlerSets.push(...this.gHSets(nextNode, method, { ...params, ...node.params }));
+            handlerSets.push(...this.gHSets(nextNode, method, node.params));
           } else {
             tempNodes.push(nextNode);
           }
@@ -102,7 +100,7 @@ var Node = class {
           if (pattern === "*") {
             const astNode = node.children["*"];
             if (astNode) {
-              handlerSets.push(...this.gHSets(astNode, method, { ...params, ...node.params }));
+              handlerSets.push(...this.gHSets(astNode, method, node.params));
               tempNodes.push(astNode);
             }
             continue;

package/dist/types/adapter/aws-lambda/custom-context.d.ts

@@ -83,5 +83,5 @@ export interface ALBRequestContext {
 /**
  * @deprecated Use ApiGatewayRequestContextV2 instead.
  */
-export declare type LambdaFunctionUrlRequestContext = ApiGatewayRequestContextV2;
+export type LambdaFunctionUrlRequestContext = ApiGatewayRequestContextV2;
 export {};

package/dist/types/adapter/aws-lambda/handler.d.ts

@@ -2,7 +2,7 @@ import type { Hono } from '../../hono';
 import type { Env, Schema } from '../../types';
 import type { ApiGatewayRequestContext, ApiGatewayRequestContextV2, ALBRequestContext } from './custom-context';
 import type { LambdaContext } from './types';
-export declare type LambdaEvent = APIGatewayProxyEvent | APIGatewayProxyEventV2 | ALBProxyEvent;
+export type LambdaEvent = APIGatewayProxyEvent | APIGatewayProxyEventV2 | ALBProxyEvent;
 export interface APIGatewayProxyEventV2 {
     version: string;
     routeKey: string;
@@ -62,7 +62,7 @@ export interface APIGatewayProxyResult {
     };
     isBase64Encoded: boolean;
 }
-export declare const streamHandle: <E extends Env = Env, S extends Schema = {}, BasePath extends string = "/">(app: Hono<E, S, BasePath>) => import("./types").Handler<any, any>;
+export declare const streamHandle: <E extends Env = Env, S extends Schema = {}, BasePath extends string = "/">(app: Hono<E, S, BasePath>) => import("./types").Handler;
 /**
  * Accepts events from API Gateway/ELB(`APIGatewayProxyEvent`) and directly through Function Url(`APIGatewayProxyEventV2`)
  */

package/dist/types/adapter/aws-lambda/types.d.ts

@@ -38,6 +38,6 @@ export interface LambdaContext {
     clientContext?: ClientContext | undefined;
     getRemainingTimeInMillis(): number;
 }
-declare type Callback<TResult = any> = (error?: Error | string | null, result?: TResult) => void;
-export declare type Handler<TEvent = any, TResult = any> = (event: TEvent, context: LambdaContext, callback: Callback<TResult>) => void | Promise<TResult>;
+type Callback<TResult = any> = (error?: Error | string | null, result?: TResult) => void;
+export type Handler<TEvent = any, TResult = any> = (event: TEvent, context: LambdaContext, callback: Callback<TResult>) => void | Promise<TResult>;
 export {};

package/dist/types/adapter/bun/serve-static.d.ts

@@ -1,6 +1,6 @@
 import type { Context } from '../../context';
 import type { Next } from '../../types';
-export declare type ServeStaticOptions = {
+export type ServeStaticOptions = {
     root?: string;
     path?: string;
     rewriteRequestPath?: (path: string) => string;

package/dist/types/adapter/cloudflare-pages/handler.d.ts

@@ -1,7 +1,7 @@
 import { Hono } from '../../hono';
 import type { Env, MiddlewareHandler } from '../../types';
-declare type Params<P extends string = any> = Record<P, string | string[]>;
-export declare type EventContext<Env = {}, P extends string = any, Data = {}> = {
+type Params<P extends string = any> = Record<P, string | string[]>;
+export type EventContext<Env = {}, P extends string = any, Data = {}> = {
     request: Request;
     functionPath: string;
     waitUntil: (promise: Promise<unknown>) => void;

package/dist/types/adapter/cloudflare-workers/serve-static.d.ts

@@ -1,6 +1,6 @@
 import type { KVNamespace } from '@cloudflare/workers-types';
 import type { MiddlewareHandler } from '../../types';
-export declare type ServeStaticOptions = {
+export type ServeStaticOptions = {
     root?: string;
     path?: string;
     manifest?: object | string;

package/dist/types/adapter/cloudflare-workers/server-static-module.d.ts

@@ -1,3 +1,3 @@
 import type { ServeStaticOptions } from './serve-static';
-declare const module: (options?: ServeStaticOptions) => import("../..").MiddlewareHandler<any, string, {}>;
+declare const module: (options?: ServeStaticOptions) => import("../..").MiddlewareHandler;
 export { module as serveStatic };

package/dist/types/adapter/deno/serve-static.d.ts

@@ -1,6 +1,6 @@
 import type { Context } from '../../context';
 import type { Next } from '../../types';
-export declare type ServeStaticOptions = {
+export type ServeStaticOptions = {
     root?: string;
     path?: string;
     rewriteRequestPath?: (path: string) => string;

package/dist/types/adapter/lambda-edge/handler.d.ts

@@ -53,7 +53,7 @@ interface CloudFrontEvent {
 export interface CloudFrontEdgeEvent {
     Records: CloudFrontEvent[];
 }
-declare type CloudFrontContext = {};
+type CloudFrontContext = {};
 export interface Callback {
     (err: Error | null, result?: CloudFrontRequest | CloudFrontResult): void;
 }

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

@@ -1,6 +1,6 @@
 import type { Context } from 'https://edge.netlify.com/';
 import type { Hono } from '../../';
-export declare type Env = {
+export type Env = {
     Bindings: {
         context: Context;
     };

package/dist/types/client/types.d.ts

@@ -1,15 +1,15 @@
 import type { Hono } from '../hono';
 import type { Schema } from '../types';
 import type { HasRequiredKeys } from '../utils/types';
-declare type HonoRequest = typeof Hono.prototype['request'];
-export declare type ClientRequestOptions<T = unknown> = keyof T extends never ? {
+type HonoRequest = typeof Hono.prototype['request'];
+export type ClientRequestOptions<T = unknown> = keyof T extends never ? {
     headers?: Record<string, string>;
     fetch?: typeof fetch | HonoRequest;
 } : {
     headers: T;
     fetch?: typeof fetch | HonoRequest;
 };
-declare type ClientRequest<S extends Schema> = {
+export type ClientRequest<S extends Schema> = {
     [M in keyof S]: S[M] extends {
         input: infer R;
         output: infer O;
@@ -17,7 +17,7 @@ declare type ClientRequest<S extends Schema> = {
 } & {
     $url: () => URL;
 };
-declare type BlankRecordToNever<T> = T extends any ? (keyof T extends never ? never : T) : never;
+type BlankRecordToNever<T> = T extends any ? (keyof T extends never ? never : T) : never;
 export interface ClientResponse<T> {
     ok: boolean;
     status: number;
@@ -34,22 +34,22 @@ export interface ClientResponse<T> {
 }
 export interface Response extends ClientResponse<unknown> {
 }
-export declare type Fetch<T> = (args?: InferRequestType<T>, opt?: ClientRequestOptions) => Promise<ClientResponse<InferResponseType<T>>>;
-export declare type InferResponseType<T> = T extends (args: any | undefined, options: any | undefined) => Promise<ClientResponse<infer O>> ? O : never;
-export declare type InferRequestType<T> = T extends (args: infer R, options: any | undefined) => Promise<ClientResponse<unknown>> ? NonNullable<R> : never;
-export declare type InferRequestOptionsType<T> = T extends (args: any, options: infer R) => Promise<ClientResponse<unknown>> ? NonNullable<R> : never;
-declare type PathToChain<Path extends string, E extends Schema, Original extends string = ''> = Path extends `/${infer P}` ? PathToChain<P, E, Path> : Path extends `${infer P}/${infer R}` ? {
+export type Fetch<T> = (args?: InferRequestType<T>, opt?: ClientRequestOptions) => Promise<ClientResponse<InferResponseType<T>>>;
+export type InferResponseType<T> = T extends (args: any | undefined, options: any | undefined) => Promise<ClientResponse<infer O>> ? O : never;
+export type InferRequestType<T> = T extends (args: infer R, options: any | undefined) => Promise<ClientResponse<unknown>> ? NonNullable<R> : never;
+export type InferRequestOptionsType<T> = T extends (args: any, options: infer R) => Promise<ClientResponse<unknown>> ? NonNullable<R> : never;
+type PathToChain<Path extends string, E extends Schema, Original extends string = ''> = Path extends `/${infer P}` ? PathToChain<P, E, Path> : Path extends `${infer P}/${infer R}` ? {
     [K in P]: PathToChain<R, E, Original>;
 } : {
     [K in Path extends '' ? 'index' : Path]: ClientRequest<E extends Record<string, unknown> ? E[Original] : never>;
 };
-export declare type Client<T> = T extends Hono<any, infer S, any> ? S extends Record<infer K, Schema> ? K extends string ? PathToChain<K, S> : never : never : never;
-export declare type Callback = (opts: CallbackOptions) => unknown;
+export type Client<T> = T extends Hono<any, infer S, any> ? S extends Record<infer K, Schema> ? K extends string ? PathToChain<K, S> : never : never : never;
+export type Callback = (opts: CallbackOptions) => unknown;
 interface CallbackOptions {
     path: string[];
     args: any[];
 }
-export declare type ObjectType<T = unknown> = {
+export type ObjectType<T = unknown> = {
     [key: string]: T;
 };
 export {};

package/dist/types/context.d.ts

@@ -5,8 +5,8 @@ import type { CookieOptions } from './utils/cookie';
 import type { StatusCode } from './utils/http-status';
 import { StreamingApi } from './utils/stream';
 import type { JSONValue, InterfaceToType, JSONParsed } from './utils/types';
-declare type HeaderRecord = Record<string, string | string[]>;
-declare type Data = string | ArrayBuffer | ReadableStream;
+type HeaderRecord = Record<string, string | string[]>;
+type Data = string | ArrayBuffer | ReadableStream;
 export interface ExecutionContext {
     waitUntil(promise: Promise<unknown>): void;
     passThroughOnException(): void;
@@ -18,7 +18,7 @@ export interface ContextRenderer {
 interface DefaultRenderer {
     (content: string | Promise<string>): Response | Promise<Response>;
 }
-export declare type Renderer = ContextRenderer extends Function ? ContextRenderer : DefaultRenderer;
+export type Renderer = ContextRenderer extends Function ? ContextRenderer : DefaultRenderer;
 interface Get<E extends Env> {
     <Key extends keyof ContextVariableMap>(key: Key): ContextVariableMap[Key];
     <Key extends keyof E['Variables']>(key: Key): E['Variables'][Key];
@@ -45,7 +45,7 @@ interface HTMLRespond {
     (html: string | Promise<string>, status?: StatusCode, headers?: HeaderRecord): Response | Promise<Response>;
     (html: string | Promise<string>, init?: ResponseInit): Response | Promise<Response>;
 }
-declare type ContextOptions<E extends Env> = {
+type ContextOptions<E extends Env> = {
     env: E['Bindings'];
     executionCtx?: FetchEventLike | ExecutionContext | undefined;
     notFoundHandler?: NotFoundHandler<E>;

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

@@ -1,4 +1,4 @@
 import type { Context } from '../../context';
-export declare type Runtime = 'node' | 'deno' | 'bun' | 'workerd' | 'fastly' | 'edge-light' | 'lagon' | 'other';
+export type Runtime = 'node' | 'deno' | 'bun' | 'workerd' | 'fastly' | 'edge-light' | 'lagon' | 'other';
 export declare const env: <T extends Record<string, unknown>, C extends Context<any, any, {}> = Context<{}, any, {}>>(c: C, runtime?: Runtime) => T & C["env"];
 export declare const getRuntimeKey: () => "other" | "node" | "deno" | "bun" | "workerd" | "fastly" | "edge-light" | "lagon";

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

@@ -1,4 +1,4 @@
 import type { Hono } from '../../hono';
-declare type ExtractEnv<T> = T extends Hono<infer E, any, any> ? E : never;
+type ExtractEnv<T> = T extends Hono<infer E, any, any> ? E : never;
 export declare const testClient: <T extends Hono<any, any, any>>(app: T, Env?: {} | ExtractEnv<T>["Bindings"] | undefined, executionCtx?: any) => import("../../utils/types").UnionToIntersection<import("../../client/types").Client<T>>;
 export {};

package/dist/types/hono-base.d.ts

@@ -2,10 +2,10 @@ import { Context } from './context';
 import type { ExecutionContext } from './context';
 import type { Router } from './router';
 import type { Env, ErrorHandler, H, HandlerInterface, MiddlewareHandlerInterface, NotFoundHandler, OnHandlerInterface, MergePath, MergeSchemaPath, FetchEventLike, Schema, RouterRoute } from './types';
-declare type GetPath<E extends Env> = (request: Request, options?: {
+type GetPath<E extends Env> = (request: Request, options?: {
     env?: E['Bindings'];
 }) => string;
-export declare type HonoOptions<E extends Env> = {
+export type HonoOptions<E extends Env> = {
     strict?: boolean;
     router?: Router<[H, RouterRoute]>;
     getPath?: GetPath<E>;

package/dist/types/http-exception.d.ts

@@ -1,5 +1,5 @@
 import type { StatusCode } from './utils/http-status';
-declare type HTTPExceptionOptions = {
+type HTTPExceptionOptions = {
     res?: Response;
     message?: string;
 };

package/dist/types/jsx/components.d.ts

@@ -1,8 +1,8 @@
 import type { HtmlEscapedString } from '../utils/html';
 import type { FC, Child } from './index';
 export declare const childrenToString: (children: Child[]) => Promise<HtmlEscapedString[]>;
-declare type ErrorHandler = (error: Error) => void;
-declare type FallbackRender = (error: Error) => Child;
+type ErrorHandler = (error: Error) => void;
+type FallbackRender = (error: Error) => Child;
 /**
  * @experimental
  * `ErrorBoundary` is an experimental feature.

package/dist/types/jsx/index.d.ts

@@ -1,7 +1,7 @@
 import type { StringBuffer, HtmlEscaped, HtmlEscapedString } from '../utils/html';
 import type { IntrinsicElements as IntrinsicElementsDefined } from './intrinsic-elements';
 export { ErrorBoundary } from './components';
-declare type Props = Record<string, any>;
+type Props = Record<string, any>;
 declare global {
     namespace JSX {
         type Element = HtmlEscapedString | Promise<HtmlEscapedString>;
@@ -13,7 +13,7 @@ declare global {
         }
     }
 }
-export declare type Child = string | Promise<string> | number | JSXNode | Child[];
+export type Child = string | Promise<string> | number | JSXNode | Child[];
 export declare class JSXNode implements HtmlEscaped {
     tag: string | Function;
     props: Props;
@@ -25,7 +25,7 @@ export declare class JSXNode implements HtmlEscaped {
 }
 export { jsxFn as jsx };
 declare const jsxFn: (tag: string | Function, props: Props, ...children: (string | HtmlEscapedString)[]) => JSXNode;
-export declare type FC<T = Props> = (props: T & {
+export type FC<T = Props> = (props: T & {
     children?: Child;
 }) => HtmlEscapedString | Promise<HtmlEscapedString>;
 export declare const memo: <T>(component: FC<T>, propsAreEqual?: (prevProps: Readonly<T>, nextProps: Readonly<T>) => boolean) => FC<T>;

package/dist/types/middleware/cors/index.d.ts

@@ -1,5 +1,5 @@
 import type { MiddlewareHandler } from '../../types';
-declare type CORSOptions = {
+type CORSOptions = {
     origin: string | string[] | ((origin: string) => string | undefined | null);
     allowMethods?: string[];
     allowHeaders?: string[];

package/dist/types/middleware/etag/index.d.ts

@@ -1,5 +1,5 @@
 import type { MiddlewareHandler } from '../../types';
-declare type ETagOptions = {
+type ETagOptions = {
     retainedHeaders?: string[];
     weak?: boolean;
 };

package/dist/types/middleware/jsx-renderer/index.d.ts

@@ -2,8 +2,8 @@ import type { Context, Renderer } from '../../context';
 import type { FC } from '../../jsx';
 import type { Env, Input, MiddlewareHandler } from '../../types';
 export declare const RequestContext: import("../../jsx").Context<Context<any, any, {}> | null>;
-declare type PropsForRenderer = [...Required<Parameters<Renderer>>] extends [unknown, infer Props] ? Props : unknown;
-declare type RendererOptions = {
+type PropsForRenderer = [...Required<Parameters<Renderer>>] extends [unknown, infer Props] ? Props : unknown;
+type RendererOptions = {
     docType?: boolean | string;
     stream?: boolean | Record<string, string>;
 };

package/dist/types/middleware/logger/index.d.ts

@@ -1,4 +1,4 @@
 import type { MiddlewareHandler } from '../../types';
-declare type PrintFunc = (str: string, ...rest: string[]) => void;
+type PrintFunc = (str: string, ...rest: string[]) => void;
 export declare const logger: (fn?: PrintFunc) => MiddlewareHandler;
 export {};

package/dist/types/middleware/pretty-json/index.d.ts

@@ -1,5 +1,5 @@
 import type { MiddlewareHandler } from '../../types';
-declare type prettyOptions = {
+type prettyOptions = {
     space: number;
 };
 export declare const prettyJSON: (options?: prettyOptions) => MiddlewareHandler;

package/dist/types/middleware/secure-headers/index.d.ts

@@ -35,7 +35,7 @@ interface ReportingEndpointOptions {
     name: string;
     url: string;
 }
-declare type overridableHeader = boolean | string;
+type overridableHeader = boolean | string;
 interface SecureHeadersOptions {
     contentSecurityPolicy?: ContentSecurityPolicyOptions;
     crossOriginEmbedderPolicy?: overridableHeader;

package/dist/types/request.d.ts

@@ -3,14 +3,14 @@ import type { Input, InputToDataByTarget, ParamKeys, ParamKeyToRecord, RemoveQue
 import type { BodyData, ParseBodyOptions } from './utils/body';
 import type { Cookie } from './utils/cookie';
 import type { UnionToIntersection } from './utils/types';
-declare type Body = {
+type Body = {
     json: any;
     text: string;
     arrayBuffer: ArrayBuffer;
     blob: Blob;
     formData: FormData;
 };
-declare type BodyCache = Partial<Body & {
+type BodyCache = Partial<Body & {
     parsedBody: BodyData;
 }>;
 export declare class HonoRequest<P extends string = '/', I extends Input['out'] = {}> {

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

@@ -1,5 +1,5 @@
 export declare const PATH_ERROR: unique symbol;
-export declare type ParamAssocArray = [string, number][];
+export type ParamAssocArray = [string, number][];
 export interface Context {
     varIndex: number;
 }

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

@@ -1,5 +1,5 @@
 import type { Router, Result } from '../../router';
-declare type HandlerWithMetadata<T> = [T, number];
+type HandlerWithMetadata<T> = [T, number];
 export declare class RegExpRouter<T> implements Router<T> {
     name: string;
     middleware?: Record<string, Record<string, HandlerWithMetadata<T>[]>>;

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

@@ -1,6 +1,6 @@
 import type { ParamAssocArray, Context } from './node';
 import { Node } from './node';
-export declare type ReplacementMap = number[];
+export type ReplacementMap = number[];
 export declare class Trie {
     context: Context;
     root: Node;

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

@@ -1,8 +1,7 @@
 import type { Params } from '../../router';
 import type { Pattern } from '../../utils/url';
-declare type HandlerSet<T> = {
+type HandlerSet<T> = {
     handler: T;
-    params: Record<string, string>;
     possibleKeys: string[];
     score: number;
     name: string;

package/dist/types/router.d.ts

@@ -7,9 +7,9 @@ export interface Router<T> {
     add(method: string, path: string, handler: T): void;
     match(method: string, path: string): Result<T>;
 }
-export declare type ParamIndexMap = Record<string, number>;
-export declare type ParamStash = string[];
-export declare type Params = Record<string, string>;
-export declare type Result<T> = [[T, ParamIndexMap][], ParamStash] | [[T, Params][]];
+export type ParamIndexMap = Record<string, number>;
+export type ParamStash = string[];
+export type Params = Record<string, string>;
+export type Result<T> = [[T, ParamIndexMap][], ParamStash] | [[T, Params][]];
 export declare class UnsupportedPathError extends Error {
 }

package/dist/types/types.d.ts

@@ -1,14 +1,14 @@
 import type { Context } from './context';
 import type { Hono } from './hono';
 import type { IntersectNonAnyTypes, UnionToIntersection } from './utils/types';
-export declare type Bindings = Record<string, unknown>;
-export declare type Variables = Record<string, unknown>;
-export declare type Env = {
+export type Bindings = Record<string, unknown>;
+export type Variables = Record<string, unknown>;
+export type Env = {
     Bindings?: Bindings;
     Variables?: Variables;
 };
-export declare type Next = () => Promise<void>;
-export declare type Input = {
+export type Next = () => Promise<void>;
+export type Input = {
     in?: Partial<ValidationTargets>;
     out?: Partial<{
         [K in keyof ValidationTargets]: unknown;
@@ -19,12 +19,12 @@ export interface RouterRoute {
     method: string;
     handler: H;
 }
-export declare type HandlerResponse<O> = Response | TypedResponse<O> | Promise<Response | TypedResponse<O>>;
-export declare type Handler<E extends Env = any, P extends string = any, I extends Input = Input, R extends HandlerResponse<any> = any> = (c: Context<E, P, I>, next: Next) => R;
-export declare type MiddlewareHandler<E extends Env = any, P extends string = string, I extends Input = {}> = (c: Context<E, P, I>, next: Next) => Promise<Response | void>;
-export declare type H<E extends Env = any, P extends string = any, I extends Input = {}, R extends HandlerResponse<any> = any> = Handler<E, P, I, R> | MiddlewareHandler<E, P, I>;
-export declare type NotFoundHandler<E extends Env = any> = (c: Context<E>) => Response | Promise<Response>;
-export declare type ErrorHandler<E extends Env = any> = (err: Error, c: Context<E>) => Response | Promise<Response>;
+export type HandlerResponse<O> = Response | TypedResponse<O> | Promise<Response | TypedResponse<O>>;
+export type Handler<E extends Env = any, P extends string = any, I extends Input = Input, R extends HandlerResponse<any> = any> = (c: Context<E, P, I>, next: Next) => R;
+export type MiddlewareHandler<E extends Env = any, P extends string = string, I extends Input = {}> = (c: Context<E, P, I>, next: Next) => Promise<Response | void>;
+export type H<E extends Env = any, P extends string = any, I extends Input = {}, R extends HandlerResponse<any> = any> = Handler<E, P, I, R> | MiddlewareHandler<E, P, I>;
+export type NotFoundHandler<E extends Env = any> = (c: Context<E>) => Response | Promise<Response>;
+export type ErrorHandler<E extends Env = any> = (err: Error, c: Context<E>) => Response | Promise<Response>;
 export interface HandlerInterface<E extends Env = Env, M extends string = string, S extends Schema = {}, BasePath extends string = '/'> {
     <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, I extends Input = {}, R extends HandlerResponse<any> = any, E2 extends Env = E>(handler: H<E2, P, I, R>): Hono<IntersectNonAnyTypes<[E, E2]>, S & ToSchema<M, P, I['in'], MergeTypedResponseData<R>>, BasePath>;
     <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, I extends Input = {}, I2 extends Input = I, R extends HandlerResponse<any> = any, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>>(...handlers: [H<E2, P, I>, H<E3, P, I2, R>]): Hono<IntersectNonAnyTypes<[E, E2, E3]>, S & ToSchema<M, P, I2['in'], MergeTypedResponseData<R>>, BasePath>;
@@ -83,22 +83,22 @@ export interface HandlerInterface<E extends Env = Env, M extends string = string
     ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11]>, S & ToSchema<M, P, I10['in'], MergeTypedResponseData<R>>, BasePath>;
     <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, I extends Input = {}, R extends HandlerResponse<any> = any>(...handlers: H<E, P, I, R>[]): Hono<E, S & ToSchema<M, P, I['in'], MergeTypedResponseData<R>>, BasePath>;
     <P extends string, R extends HandlerResponse<any> = any, I extends Input = {}>(path: P): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I['in'], MergeTypedResponseData<R>>, BasePath>;
-    <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = {}, E2 extends Env = E>(path: P, handler: H<E2, MergedPath, I, R>): Hono<IntersectNonAnyTypes<[E, E2]>, S & ToSchema<M, MergedPath, I['in'], MergeTypedResponseData<R>>, BasePath>;
-    <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>>(path: P, ...handlers: [H<E2, MergedPath, I>, H<E3, MergedPath, I2, R>]): Hono<IntersectNonAnyTypes<[E, E2, E3]>, S & ToSchema<M, MergedPath, I2['in'], MergeTypedResponseData<R>>, BasePath>;
-    <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, E2 extends Env = E, E3 extends Env = E, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>>(path: P, ...handlers: [H<E2, MergedPath, I>, H<E3, MergedPath, I2>, H<E4, MergedPath, I3, R>]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4]>, S & ToSchema<M, MergedPath, I3['in'], MergeTypedResponseData<R>>, BasePath>;
+    <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = {}, E2 extends Env = E>(path: P, handler: H<E2, MergedPath, I, R>): Hono<IntersectNonAnyTypes<[E, E2]>, S & ToSchema<M, MergePath<BasePath, P>, I['in'], MergeTypedResponseData<R>>, BasePath>;
+    <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>>(path: P, ...handlers: [H<E2, MergedPath, I>, H<E3, MergedPath, I2, R>]): Hono<IntersectNonAnyTypes<[E, E2, E3]>, S & ToSchema<M, MergePath<BasePath, P>, I2['in'], MergeTypedResponseData<R>>, BasePath>;
+    <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, E2 extends Env = E, E3 extends Env = E, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>>(path: P, ...handlers: [H<E2, MergedPath, I>, H<E3, MergedPath, I2>, H<E4, MergedPath, I3, R>]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4]>, S & ToSchema<M, MergePath<BasePath, P>, I3['in'], MergeTypedResponseData<R>>, BasePath>;
     <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>>(path: P, ...handlers: [
         H<E2, MergedPath, I>,
         H<E3, MergedPath, I2>,
         H<E4, MergedPath, I3>,
         H<E5, MergedPath, I4, R>
-    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, S & ToSchema<M, MergedPath, I4['in'], MergeTypedResponseData<R>>, BasePath>;
+    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, S & ToSchema<M, MergePath<BasePath, P>, I4['in'], MergeTypedResponseData<R>>, BasePath>;
     <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>>(path: P, ...handlers: [
         H<E2, MergedPath, I>,
         H<E3, MergedPath, I2>,
         H<E4, MergedPath, I3>,
         H<E5, MergedPath, I4>,
         H<E6, MergedPath, I5, R>
-    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, S & ToSchema<M, MergedPath, I5['in'], MergeTypedResponseData<R>>, BasePath>;
+    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, S & ToSchema<M, MergePath<BasePath, P>, I5['in'], MergeTypedResponseData<R>>, BasePath>;
     <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>>(path: P, ...handlers: [
         H<E2, MergedPath, I>,
         H<E3, MergedPath, I2>,
@@ -106,7 +106,7 @@ export interface HandlerInterface<E extends Env = Env, M extends string = string
         H<E5, MergedPath, I4>,
         H<E6, MergedPath, I5>,
         H<E7, MergedPath, I6, R>
-    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, S & ToSchema<M, MergedPath, I6['in'], MergeTypedResponseData<R>>, BasePath>;
+    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, S & ToSchema<M, MergePath<BasePath, P>, I6['in'], MergeTypedResponseData<R>>, BasePath>;
     <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>>(path: P, ...handlers: [
         H<E2, MergedPath, I>,
         H<E3, MergedPath, I2>,
@@ -115,7 +115,7 @@ export interface HandlerInterface<E extends Env = Env, M extends string = string
         H<E6, MergedPath, I5>,
         H<E7, MergedPath, I6>,
         H<E8, MergedPath, I7, R>
-    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, S & ToSchema<M, MergedPath, I7['in'], MergeTypedResponseData<R>>, BasePath>;
+    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, S & ToSchema<M, MergePath<BasePath, P>, I7['in'], MergeTypedResponseData<R>>, BasePath>;
     <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>>(path: P, ...handlers: [
         H<E2, MergedPath, I>,
         H<E3, MergedPath, I2>,
@@ -125,7 +125,7 @@ export interface HandlerInterface<E extends Env = Env, M extends string = string
         H<E7, MergedPath, I6>,
         H<E8, MergedPath, I7>,
         H<E9, MergedPath, I8, R>
-    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>, S & ToSchema<M, MergedPath, I8['in'], MergeTypedResponseData<R>>, BasePath>;
+    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>, S & ToSchema<M, MergePath<BasePath, P>, I8['in'], MergeTypedResponseData<R>>, BasePath>;
     <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, I9 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = E, E10 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>>(path: P, ...handlers: [
         H<E2, MergedPath, I>,
         H<E3, MergedPath, I2>,
@@ -136,7 +136,7 @@ export interface HandlerInterface<E extends Env = Env, M extends string = string
         H<E8, MergedPath, I7>,
         H<E9, MergedPath, I8>,
         H<E10, MergedPath, I9, R>
-    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10]>, S & ToSchema<M, MergedPath, I9['in'], MergeTypedResponseData<R>>, BasePath>;
+    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10]>, S & ToSchema<M, MergePath<BasePath, P>, I9['in'], MergeTypedResponseData<R>>, BasePath>;
     <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, I9 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8, I10 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8 & I9, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = E, E10 extends Env = E, E11 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10]>>(path: P, ...handlers: [
         H<E2, MergedPath, I>,
         H<E3, MergedPath, I2>,
@@ -148,7 +148,7 @@ export interface HandlerInterface<E extends Env = Env, M extends string = string
         H<E9, MergedPath, I8>,
         H<E10, MergedPath, I9>,
         H<E11, MergedPath, I10, R>
-    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11]>, S & ToSchema<M, MergedPath, I10['in'], MergeTypedResponseData<R>>, BasePath>;
+    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11]>, S & ToSchema<M, MergePath<BasePath, P>, I10['in'], MergeTypedResponseData<R>>, BasePath>;
     <P extends string, I extends Input = {}, R extends HandlerResponse<any> = any>(path: P, ...handlers: H<E, MergePath<BasePath, P>, I, R>[]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I['in'], MergeTypedResponseData<R>>, BasePath>;
 }
 export interface MiddlewareHandlerInterface<E extends Env = Env, S extends Schema = {}, BasePath extends string = '/'> {
@@ -156,22 +156,22 @@ export interface MiddlewareHandlerInterface<E extends Env = Env, S extends Schem
     <P extends string, E2 extends Env = E>(path: P, ...handlers: MiddlewareHandler<E2, MergePath<BasePath, P>>[]): Hono<E, S, BasePath>;
 }
 export interface OnHandlerInterface<E extends Env = Env, S extends Schema = {}, BasePath extends string = '/'> {
-    <M extends string, P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = {}, E2 extends Env = E>(method: M, path: P, handler: H<E2, MergedPath, I, R>): Hono<IntersectNonAnyTypes<[E, E2]>, S & ToSchema<M, MergedPath, I['in'], MergeTypedResponseData<R>>, BasePath>;
-    <M extends string, P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>>(method: M, path: P, ...handlers: [H<E2, MergedPath, I>, H<E3, MergedPath, I2, R>]): Hono<IntersectNonAnyTypes<[E, E2, E3]>, S & ToSchema<M, MergedPath, I2['in'], MergeTypedResponseData<R>>, BasePath>;
-    <M extends string, P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, E2 extends Env = E, E3 extends Env = E, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>>(method: M, path: P, ...handlers: [H<E2, MergedPath, I>, H<E3, MergedPath, I2>, H<E4, MergedPath, I3, R>]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4]>, S & ToSchema<M, MergedPath, I3['in'], MergeTypedResponseData<R>>, BasePath>;
+    <M extends string, P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = {}, E2 extends Env = E>(method: M, path: P, handler: H<E2, MergedPath, I, R>): Hono<IntersectNonAnyTypes<[E, E2]>, S & ToSchema<M, MergePath<BasePath, P>, I['in'], MergeTypedResponseData<R>>, BasePath>;
+    <M extends string, P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>>(method: M, path: P, ...handlers: [H<E2, MergedPath, I>, H<E3, MergedPath, I2, R>]): Hono<IntersectNonAnyTypes<[E, E2, E3]>, S & ToSchema<M, MergePath<BasePath, P>, I2['in'], MergeTypedResponseData<R>>, BasePath>;
+    <M extends string, P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, E2 extends Env = E, E3 extends Env = E, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>>(method: M, path: P, ...handlers: [H<E2, MergedPath, I>, H<E3, MergedPath, I2>, H<E4, MergedPath, I3, R>]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4]>, S & ToSchema<M, MergePath<BasePath, P>, I3['in'], MergeTypedResponseData<R>>, BasePath>;
     <M extends string, P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>>(method: M, path: P, ...handlers: [
         H<E2, MergedPath, I>,
         H<E3, MergedPath, I2>,
         H<E4, MergedPath, I3>,
         H<E5, MergedPath, I4, R>
-    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, S & ToSchema<M, MergedPath, I4['in'], MergeTypedResponseData<R>>, BasePath>;
+    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, S & ToSchema<M, MergePath<BasePath, P>, I4['in'], MergeTypedResponseData<R>>, BasePath>;
     <M extends string, P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>>(method: M, path: P, ...handlers: [
         H<E2, MergedPath, I>,
         H<E3, MergedPath, I2>,
         H<E4, MergedPath, I3>,
         H<E5, MergedPath, I4>,
         H<E6, MergedPath, I5, R>
-    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, S & ToSchema<M, MergedPath, I5['in'], MergeTypedResponseData<R>>, BasePath>;
+    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, S & ToSchema<M, MergePath<BasePath, P>, I5['in'], MergeTypedResponseData<R>>, BasePath>;
     <M extends string, P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>>(method: M, path: P, ...handlers: [
         H<E2, MergedPath, I>,
         H<E3, MergedPath, I2>,
@@ -179,7 +179,7 @@ export interface OnHandlerInterface<E extends Env = Env, S extends Schema = {},
         H<E5, MergedPath, I4>,
         H<E6, MergedPath, I5>,
         H<E7, MergedPath, I6, R>
-    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, S & ToSchema<M, MergedPath, I6['in'], MergeTypedResponseData<R>>, BasePath>;
+    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, S & ToSchema<M, MergePath<BasePath, P>, I6['in'], MergeTypedResponseData<R>>, BasePath>;
     <M extends string, P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>>(method: M, path: P, ...handlers: [
         H<E2, MergedPath, I>,
         H<E3, MergedPath, I2>,
@@ -188,7 +188,7 @@ export interface OnHandlerInterface<E extends Env = Env, S extends Schema = {},
         H<E6, MergedPath, I5>,
         H<E7, MergedPath, I6>,
         H<E8, MergedPath, I7, R>
-    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, S & ToSchema<M, MergedPath, I7['in'], MergeTypedResponseData<R>>, BasePath>;
+    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, S & ToSchema<M, MergePath<BasePath, P>, I7['in'], MergeTypedResponseData<R>>, BasePath>;
     <M extends string, P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>>(method: M, path: P, ...handlers: [
         H<E2, MergedPath, I>,
         H<E3, MergedPath, I2>,
@@ -198,7 +198,7 @@ export interface OnHandlerInterface<E extends Env = Env, S extends Schema = {},
         H<E7, MergedPath, I6>,
         H<E8, MergedPath, I7>,
         H<E9, MergedPath, I8, R>
-    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>, S & ToSchema<M, MergedPath, I8['in'], MergeTypedResponseData<R>>, BasePath>;
+    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>, S & ToSchema<M, MergePath<BasePath, P>, I8['in'], MergeTypedResponseData<R>>, BasePath>;
     <M extends string, P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, I9 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = E, E10 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>>(method: M, path: P, ...handlers: [
         H<E2, MergedPath, I>,
         H<E3, MergedPath, I2>,
@@ -209,7 +209,7 @@ export interface OnHandlerInterface<E extends Env = Env, S extends Schema = {},
         H<E8, MergedPath, I7>,
         H<E9, MergedPath, I8>,
         H<E10, MergedPath, I9, R>
-    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10]>, S & ToSchema<M, MergedPath, I9['in'], MergeTypedResponseData<R>>, BasePath>;
+    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10]>, S & ToSchema<M, MergePath<BasePath, P>, I9['in'], MergeTypedResponseData<R>>, BasePath>;
     <M extends string, P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, I9 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8, I10 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8 & I9, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = E, E10 extends Env = E, E11 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10]>>(method: M, path: P, ...handlers: [
         H<E2, MergedPath, I>,
         H<E3, MergedPath, I2>,
@@ -221,24 +221,24 @@ export interface OnHandlerInterface<E extends Env = Env, S extends Schema = {},
         H<E9, MergedPath, I8>,
         H<E10, MergedPath, I9>,
         H<E11, MergedPath, I10>
-    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11]>, S & ToSchema<M, MergedPath, I10['in'], MergeTypedResponseData<HandlerResponse<any>>>, BasePath>;
+    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11]>, S & ToSchema<M, MergePath<BasePath, P>, I10['in'], MergeTypedResponseData<HandlerResponse<any>>>, BasePath>;
     <M extends string, P extends string, R extends HandlerResponse<any> = any, I extends Input = {}>(method: M, path: P, ...handlers: H<E, MergePath<BasePath, P>, I, R>[]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I['in'], MergeTypedResponseData<R>>, BasePath>;
-    <Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = {}, E2 extends Env = E>(methods: Ms, path: P, handler: H<E2, MergedPath, I, R>): Hono<IntersectNonAnyTypes<[E, E2]>, S & ToSchema<Ms[number], MergedPath, I['in'], MergeTypedResponseData<R>>, BasePath>;
-    <Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>>(methods: Ms, path: P, ...handlers: [H<E2, MergedPath, I>, H<E3, MergedPath, I2, R>]): Hono<IntersectNonAnyTypes<[E, E2, E3]>, S & ToSchema<Ms[number], MergedPath, I2['in'], MergeTypedResponseData<R>>, BasePath>;
-    <Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, E2 extends Env = E, E3 extends Env = E, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>>(methods: Ms, path: P, ...handlers: [H<E2, MergedPath, I>, H<E3, MergedPath, I2>, H<E4, MergedPath, I3, R>]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4]>, S & ToSchema<Ms[number], MergedPath, I3['in'], MergeTypedResponseData<R>>, BasePath>;
+    <Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = {}, E2 extends Env = E>(methods: Ms, path: P, handler: H<E2, MergedPath, I, R>): Hono<IntersectNonAnyTypes<[E, E2]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I['in'], MergeTypedResponseData<R>>, BasePath>;
+    <Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>>(methods: Ms, path: P, ...handlers: [H<E2, MergedPath, I>, H<E3, MergedPath, I2, R>]): Hono<IntersectNonAnyTypes<[E, E2, E3]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I2['in'], MergeTypedResponseData<R>>, BasePath>;
+    <Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, E2 extends Env = E, E3 extends Env = E, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>>(methods: Ms, path: P, ...handlers: [H<E2, MergedPath, I>, H<E3, MergedPath, I2>, H<E4, MergedPath, I3, R>]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I3['in'], MergeTypedResponseData<R>>, BasePath>;
     <Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>>(methods: Ms, path: P, ...handlers: [
         H<E2, MergedPath, I>,
         H<E3, MergedPath, I2>,
         H<E4, MergedPath, I3>,
         H<E5, MergedPath, I4, R>
-    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, S & ToSchema<Ms[number], MergedPath, I4['in'], MergeTypedResponseData<R>>, BasePath>;
+    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I4['in'], MergeTypedResponseData<R>>, BasePath>;
     <Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>>(methods: Ms, path: P, ...handlers: [
         H<E2, MergedPath, I>,
         H<E3, MergedPath, I2>,
         H<E4, MergedPath, I3>,
         H<E5, MergedPath, I4>,
         H<E6, MergedPath, I5, R>
-    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, S & ToSchema<Ms[number], MergedPath, I5['in'], MergeTypedResponseData<R>>, BasePath>;
+    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I5['in'], MergeTypedResponseData<R>>, BasePath>;
     <Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>>(methods: Ms, path: P, ...handlers: [
         H<E2, MergedPath, I>,
         H<E3, MergedPath, I2>,
@@ -246,7 +246,7 @@ export interface OnHandlerInterface<E extends Env = Env, S extends Schema = {},
         H<E5, MergedPath, I4>,
         H<E6, MergedPath, I5>,
         H<E7, MergedPath, I6, R>
-    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, S & ToSchema<Ms[number], MergedPath, I6['in'], MergeTypedResponseData<R>>, BasePath>;
+    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I6['in'], MergeTypedResponseData<R>>, BasePath>;
     <Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>>(methods: Ms, path: P, ...handlers: [
         H<E2, MergedPath, I>,
         H<E3, MergedPath, I2>,
@@ -255,7 +255,7 @@ export interface OnHandlerInterface<E extends Env = Env, S extends Schema = {},
         H<E6, MergedPath, I5>,
         H<E7, MergedPath, I6>,
         H<E8, MergedPath, I7, R>
-    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, S & ToSchema<Ms[number], MergedPath, I7['in'], MergeTypedResponseData<R>>, BasePath>;
+    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I7['in'], MergeTypedResponseData<R>>, BasePath>;
     <Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>>(methods: Ms, path: P, ...handlers: [
         H<E2, MergedPath, I>,
         H<E3, MergedPath, I2>,
@@ -265,7 +265,7 @@ export interface OnHandlerInterface<E extends Env = Env, S extends Schema = {},
         H<E7, MergedPath, I6>,
         H<E8, MergedPath, I7>,
         H<E9, MergedPath, I8, R>
-    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>, S & ToSchema<Ms[number], MergedPath, I8['in'], MergeTypedResponseData<R>>, BasePath>;
+    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I8['in'], MergeTypedResponseData<R>>, BasePath>;
     <Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, I9 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = E, E10 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>>(methods: Ms, path: P, ...handlers: [
         H<E2, MergedPath, I>,
         H<E3, MergedPath, I2>,
@@ -276,7 +276,7 @@ export interface OnHandlerInterface<E extends Env = Env, S extends Schema = {},
         H<E8, MergedPath, I7>,
         H<E9, MergedPath, I8>,
         H<E10, MergedPath, I9>
-    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10]>, S & ToSchema<Ms[number], MergedPath, I9['in'], MergeTypedResponseData<HandlerResponse<any>>>, BasePath>;
+    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I9['in'], MergeTypedResponseData<HandlerResponse<any>>>, BasePath>;
     <Ms extends string[], P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, I9 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8, I10 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8 & I9, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = E, E10 extends Env = E, E11 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10]>>(methods: Ms, path: P, ...handlers: [
         H<E2, MergedPath, I>,
         H<E3, MergedPath, I2>,
@@ -288,11 +288,11 @@ export interface OnHandlerInterface<E extends Env = Env, S extends Schema = {},
         H<E9, MergedPath, I8>,
         H<E10, MergedPath, I9>,
         H<E11, MergedPath, I10>
-    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11]>, S & ToSchema<Ms[number], MergedPath, I10['in'], MergeTypedResponseData<HandlerResponse<any>>>, BasePath>;
+    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11]>, S & ToSchema<Ms[number], MergePath<BasePath, P>, I10['in'], MergeTypedResponseData<HandlerResponse<any>>>, BasePath>;
     <P extends string, R extends HandlerResponse<any> = any, I extends Input = {}>(methods: string[], path: P, ...handlers: H<E, MergePath<BasePath, P>, I, R>[]): Hono<E, S & ToSchema<string, MergePath<BasePath, P>, I['in'], MergeTypedResponseData<R>>, BasePath>;
 }
-declare type ExtractKey<S> = S extends Record<infer Key, unknown> ? Key extends string ? Key : never : string;
-export declare type ToSchema<M extends string, P extends string, I extends Input['in'], O> = {
+type ExtractKey<S> = S extends Record<infer Key, unknown> ? Key extends string ? Key : never : string;
+export type ToSchema<M extends string, P extends string, I extends Input['in'], O> = {
     [K in P]: {
         [K2 in M as AddDollar<K2>]: {
             input: unknown extends I ? AddParam<{}, P> : AddParam<I, P>;
@@ -300,7 +300,7 @@ export declare type ToSchema<M extends string, P extends string, I extends Input
         };
     };
 };
-export declare type Schema = {
+export type Schema = {
     [Path: string]: {
         [Method: `$${Lowercase<string>}`]: {
             input: Partial<ValidationTargets> & {
@@ -310,21 +310,21 @@ export declare type Schema = {
         };
     };
 };
-export declare type MergeSchemaPath<OrigSchema, SubPath extends string> = {
+export type MergeSchemaPath<OrigSchema, SubPath extends string> = {
     [K in keyof OrigSchema as `${MergePath<SubPath, K & string>}`]: OrigSchema[K];
 };
-export declare type AddParam<I, P extends string> = ParamKeys<P> extends never ? I : I & {
+export type AddParam<I, P extends string> = ParamKeys<P> extends never ? I : I & {
     param: UnionToIntersection<ParamKeyToRecord<ParamKeys<P>>>;
 };
-declare type AddDollar<T extends string> = `$${Lowercase<T>}`;
-export declare type MergePath<A extends string, B extends string> = A extends '' ? B : A extends '/' ? B : A extends `${infer P}/` ? B extends `/${infer Q}` ? `${P}/${Q}` : `${P}/${B}` : B extends `/${infer Q}` ? Q extends '' ? A : `${A}/${Q}` : `${A}/${B}`;
-export declare type TypedResponse<T = unknown> = {
+type AddDollar<T extends string> = `$${Lowercase<T>}`;
+export type MergePath<A extends string, B extends string> = A extends '' ? B : A extends '/' ? B : A extends `${infer P}/` ? B extends `/${infer Q}` ? `${P}/${Q}` : `${P}/${B}` : B extends `/${infer Q}` ? Q extends '' ? A : `${A}/${Q}` : `${A}/${B}`;
+export type TypedResponse<T = unknown> = {
     data: T;
     format: 'json';
 };
-declare type ExtractResponseData<T> = T extends Promise<infer T2> ? T2 extends TypedResponse<infer U> ? U : {} : T extends TypedResponse<infer U> ? U : {};
-declare type MergeTypedResponseData<T> = ExtractResponseData<T>;
-export declare type ValidationTargets = {
+type ExtractResponseData<T> = T extends Promise<infer T2> ? T2 extends TypedResponse<infer U> ? U : {} : T extends TypedResponse<infer U> ? U : {};
+type MergeTypedResponseData<T> = ExtractResponseData<T>;
+export type ValidationTargets = {
     json: any;
     form: Record<string, string | File>;
     query: Record<string, string | string[]>;
@@ -333,18 +333,18 @@ export declare type ValidationTargets = {
     header: Record<string, string>;
     cookie: Record<string, string>;
 };
-declare type ParamKeyName<NameWithPattern> = NameWithPattern extends `${infer Name}{${infer Rest}` ? Rest extends `${infer _Pattern}?` ? `${Name}?` : Name : NameWithPattern;
-declare type ParamKey<Component> = Component extends `:${infer NameWithPattern}` ? ParamKeyName<NameWithPattern> : never;
-export declare type ParamKeys<Path> = Path extends `${infer Component}/${infer Rest}` ? ParamKey<Component> | ParamKeys<Rest> : ParamKey<Path>;
-export declare type ParamKeyToRecord<T extends string> = T extends `${infer R}?` ? Record<R, string | undefined> : {
+type ParamKeyName<NameWithPattern> = NameWithPattern extends `${infer Name}{${infer Rest}` ? Rest extends `${infer _Pattern}?` ? `${Name}?` : Name : NameWithPattern;
+type ParamKey<Component> = Component extends `:${infer NameWithPattern}` ? ParamKeyName<NameWithPattern> : never;
+export type ParamKeys<Path> = Path extends `${infer Component}/${infer Rest}` ? ParamKey<Component> | ParamKeys<Rest> : ParamKey<Path>;
+export type ParamKeyToRecord<T extends string> = T extends `${infer R}?` ? Record<R, string | undefined> : {
     [K in T]: string;
 };
-export declare type InputToDataByTarget<T extends Input['out'], Target extends keyof ValidationTargets> = T extends {
+export type InputToDataByTarget<T extends Input['out'], Target extends keyof ValidationTargets> = T extends {
     [K in Target]: infer R;
 } ? R : never;
-export declare type RemoveQuestion<T> = T extends `${infer R}?` ? R : T;
-export declare type UndefinedIfHavingQuestion<T> = T extends `${infer _}?` ? string | undefined : string;
-export declare type ExtractSchema<T> = UnionToIntersection<T extends Hono<infer _, infer S, any> ? S : never>;
+export type RemoveQuestion<T> = T extends `${infer R}?` ? R : T;
+export type UndefinedIfHavingQuestion<T> = T extends `${infer _}?` ? string | undefined : string;
+export type ExtractSchema<T> = UnionToIntersection<T extends Hono<infer _, infer S, any> ? S : never>;
 export declare abstract class FetchEventLike {
     abstract readonly request: Request;
     abstract respondWith(promise: Response | Promise<Response>): void;

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

@@ -1,6 +1,6 @@
 import type { HonoRequest } from '../request';
-export declare type BodyData = Record<string, string | File | (string | File)[]>;
-export declare type ParseBodyOptions = {
+export type BodyData = Record<string, string | File | (string | File)[]>;
+export type ParseBodyOptions = {
     /**
      * Parse all fields with multiple values should be parsed as an array.
      * @default false

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

@@ -1,5 +1,5 @@
 import type { KVNamespace } from '@cloudflare/workers-types';
-export declare type KVAssetOptions = {
+export type KVAssetOptions = {
     manifest?: object | string;
     namespace?: KVNamespace;
 };

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

@@ -1,6 +1,6 @@
-export declare type Cookie = Record<string, string>;
-export declare type SignedCookie = Record<string, string | false>;
-export declare type CookieOptions = {
+export type Cookie = Record<string, string>;
+export type SignedCookie = Record<string, string | false>;
+export type CookieOptions = {
     domain?: string;
     expires?: Date;
     httpOnly?: boolean;

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

@@ -1,8 +1,8 @@
-declare type Algorithm = {
+type Algorithm = {
     name: string;
     alias: string;
 };
-declare type Data = string | boolean | number | object | ArrayBufferView | ArrayBuffer | ReadableStream;
+type Data = string | boolean | number | object | ArrayBufferView | ArrayBuffer | ReadableStream;
 export declare const sha256: (data: Data) => Promise<string | null>;
 export declare const sha1: (data: Data) => Promise<string | null>;
 export declare const md5: (data: Data) => Promise<string | null>;

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

@@ -1,4 +1,4 @@
-declare type FilePathOptions = {
+type FilePathOptions = {
     filename: string;
     root?: string;
     defaultDocument?: string;

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

@@ -1,14 +1,28 @@
-declare type HtmlEscapedCallbackOpts = {
+type HtmlEscapedCallbackOpts = {
     error?: Error;
     buffer?: [string];
 };
-export declare type HtmlEscapedCallback = (opts: HtmlEscapedCallbackOpts) => Promise<string>;
-export declare type HtmlEscaped = {
+export type HtmlEscapedCallback = (opts: HtmlEscapedCallbackOpts) => Promise<string>;
+export type HtmlEscaped = {
     isEscaped: true;
     callbacks?: HtmlEscapedCallback[];
 };
-export declare type HtmlEscapedString = string & HtmlEscaped;
-export declare type StringBuffer = (string | Promise<string>)[];
+export type HtmlEscapedString = string & HtmlEscaped;
+/**
+ * StringBuffer contains string and Promise<string> alternately
+ * The length of the array will be odd, the odd numbered element will be a string,
+ * and the even numbered element will be a Promise<string>.
+ * When concatenating into a single string, it must be processed from the tail.
+ * @example
+ * [
+ *   'framework.',
+ *   Promise.resolve('ultra fast'),
+ *   'a ',
+ *   Promise.resolve('is '),
+ *   'Hono',
+ * ]
+ */
+export type StringBuffer = (string | Promise<string>)[];
 export declare const stringBufferToString: (buffer: StringBuffer) => Promise<HtmlEscapedString>;
 export declare const escapeToBuffer: (str: string, buffer: StringBuffer) => void;
 export declare const resolveStream: (str: string | HtmlEscapedString, buffer?: [string]) => Promise<string>;

package/dist/types/utils/http-status.d.ts

@@ -1 +1 @@
-export declare type StatusCode = number;
+export type StatusCode = number;

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

@@ -1,5 +1,5 @@
 import type { AlgorithmTypes } from './types';
-declare type AlgorithmTypeName = keyof typeof AlgorithmTypes;
+type AlgorithmTypeName = keyof typeof AlgorithmTypes;
 export declare const sign: (payload: unknown, secret: string, alg?: AlgorithmTypeName) => Promise<string>;
 export declare const verify: (token: string, secret: string, alg?: AlgorithmTypeName) => Promise<any>;
 export declare const decode: (token: string) => {

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

@@ -1,23 +1,23 @@
-export declare type Expect<T extends true> = T;
-export declare type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? true : false;
-export declare type NotEqual<X, Y> = true extends Equal<X, Y> ? false : true;
-export declare type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
-export declare type RemoveBlankRecord<T> = T extends Record<infer K, unknown> ? K extends string ? T : never : never;
-export declare type IfAnyThenEmptyObject<T> = 0 extends 1 & T ? {} : T;
-export declare type IntersectNonAnyTypes<T extends any[]> = T extends [infer Head, ...infer Rest] ? IfAnyThenEmptyObject<Head> & IntersectNonAnyTypes<Rest> : {};
-export declare type JSONPrimitive = string | boolean | number | null | undefined;
-export declare type JSONArray = (JSONPrimitive | JSONObject | JSONArray)[];
-export declare type JSONObject = {
+export type Expect<T extends true> = T;
+export type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? true : false;
+export type NotEqual<X, Y> = true extends Equal<X, Y> ? false : true;
+export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+export type RemoveBlankRecord<T> = T extends Record<infer K, unknown> ? K extends string ? T : never : never;
+export type IfAnyThenEmptyObject<T> = 0 extends 1 & T ? {} : T;
+export type IntersectNonAnyTypes<T extends any[]> = T extends [infer Head, ...infer Rest] ? IfAnyThenEmptyObject<Head> & IntersectNonAnyTypes<Rest> : {};
+export type JSONPrimitive = string | boolean | number | null | undefined;
+export type JSONArray = (JSONPrimitive | JSONObject | JSONArray)[];
+export type JSONObject = {
     [key: string]: JSONPrimitive | JSONArray | JSONObject | object;
 };
-export declare type JSONValue = JSONObject | JSONArray | JSONPrimitive;
-export declare type JSONParsed<T> = {
+export type JSONValue = JSONObject | JSONArray | JSONPrimitive;
+export type JSONParsed<T> = {
     [k in keyof T]: T[k] extends JSONValue ? T[k] : string;
 };
-export declare type InterfaceToType<T> = T extends Function ? T : {
+export type InterfaceToType<T> = T extends Function ? T : {
     [K in keyof T]: InterfaceToType<T[K]>;
 };
-export declare type RequiredKeysOf<BaseType extends object> = Exclude<{
+export type RequiredKeysOf<BaseType extends object> = Exclude<{
     [Key in keyof BaseType]: BaseType extends Record<Key, BaseType[Key]> ? Key : never;
 }[keyof BaseType], undefined>;
-export declare type HasRequiredKeys<BaseType extends object> = RequiredKeysOf<BaseType> extends never ? false : true;
+export type HasRequiredKeys<BaseType extends object> = RequiredKeysOf<BaseType> extends never ? false : true;

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

@@ -1,4 +1,4 @@
-export declare type Pattern = readonly [string, string, RegExp | true] | '*';
+export type Pattern = readonly [string, string, RegExp | true] | '*';
 export declare const splitPath: (path: string) => string[];
 export declare const splitRoutingPath: (path: string) => string[];
 export declare const getPattern: (label: string) => Pattern | null;

package/dist/types/validator/validator.d.ts

@@ -1,8 +1,8 @@
 import type { Context } from '../context';
 import type { Env, ValidationTargets, MiddlewareHandler } from '../types';
-declare type ValidationTargetKeysWithBody = 'form' | 'json';
-declare type ValidationTargetByMethod<M> = M extends 'get' | 'head' ? Exclude<keyof ValidationTargets, ValidationTargetKeysWithBody> : keyof ValidationTargets;
-export declare type ValidationFunction<InputType, OutputType, E extends Env = {}, P extends string = string> = (value: InputType, c: Context<E, P>) => OutputType | Response | Promise<OutputType> | Promise<Response>;
+type ValidationTargetKeysWithBody = 'form' | 'json';
+type ValidationTargetByMethod<M> = M extends 'get' | 'head' ? Exclude<keyof ValidationTargets, ValidationTargetKeysWithBody> : keyof ValidationTargets;
+export type ValidationFunction<InputType, OutputType, E extends Env = {}, P extends string = string> = (value: InputType, c: Context<E, P>) => OutputType | Response | Promise<OutputType> | Promise<Response>;
 export declare const validator: <InputType, P extends string, M extends string, U extends ValidationTargetByMethod<M>, OutputType = ValidationTargets[U], P2 extends string = P, V extends {
     in: { [K in U]: unknown extends InputType ? OutputType : InputType; };
     out: { [K_1 in U]: OutputType; };

package/dist/utils/html.js

@@ -4,16 +4,28 @@ var escapeRe = /[&<>'"]/;
 var stringBufferToString = async (buffer) => {
   let str = "";
   const callbacks = [];
-  for (let i = buffer.length - 1; i >= 0; i--) {
+  for (let i = buffer.length - 1; ; i--) {
+    str += buffer[i];
+    i--;
+    if (i < 0) {
+      break;
+    }
     let r = await buffer[i];
     if (typeof r === "object") {
       callbacks.push(...r.callbacks || []);
     }
+    const isEscaped = r.isEscaped;
     r = await (typeof r === "object" ? r.toString() : r);
     if (typeof r === "object") {
       callbacks.push(...r.callbacks || []);
     }
-    str += r;
+    if (r.isEscaped ?? isEscaped) {
+      str += r;
+    } else {
+      const buf = [str];
+      escapeToBuffer(r, buf);
+      str = buf[0];
+    }
   }
   return raw(str, callbacks);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hono",
-  "version": "3.11.6",
+  "version": "3.11.8",
   "description": "Ultrafast web framework for the Edges",
   "main": "dist/cjs/index.js",
   "type": "module",
@@ -20,8 +20,8 @@
     "test:lambda": "env NAME=Node vitest --run --config ./runtime_tests/lambda/vitest.config.ts",
     "test:lambda-edge": "env NAME=Node vitest --run --config ./runtime_tests/lambda-edge/vitest.config.ts",
     "test:all": "yarn test && yarn test:deno && yarn test:bun && yarn test:fastly && yarn test:lagon && yarn test:node && yarn test:wrangler && yarn test:lambda && yarn test:lambda-edge",
-    "lint": "eslint --ext js,ts src runtime_tests .eslintrc.cjs",
-    "lint:fix": "eslint --ext js,ts src runtime_tests .eslintrc.cjs --fix",
+    "lint": "eslint --ext js,ts src runtime_tests",
+    "lint:fix": "eslint --ext js,ts src runtime_tests --fix",
     "format": "prettier --check 'src/**/*.{js,ts}' 'runtime_tests/**/*.{js,ts}'",
     "format:fix": "prettier --write 'src/**/*.{js,ts}' 'runtime_tests/**/*.{js,ts}'",
     "denoify": "rimraf deno_dist && denoify && rimraf 'deno_dist/**/*.test.{ts,tsx}'",
@@ -441,8 +441,9 @@
     "nodejs"
   ],
   "devDependencies": {
-    "@cloudflare/workers-types": "^4.20221111.1",
-    "@hono/node-server": "^1.0.2",
+    "@cloudflare/workers-types": "^4.20231121.0",
+    "@hono/eslint-config": "^0.0.3",
+    "@hono/node-server": "^1.3.3",
     "@types/crypto-js": "^4.1.1",
     "@types/glob": "^8.0.0",
     "@types/jest": "^29.4.0",
@@ -450,21 +451,12 @@
     "@types/node": "^20.8.2",
     "@types/node-fetch": "^2.6.2",
     "@types/supertest": "^2.0.12",
-    "@typescript-eslint/eslint-plugin": "^5.59.2",
-    "@typescript-eslint/parser": "^5.59.2",
     "@vitest/coverage-v8": "^0.34.3",
     "arg": "^5.0.2",
     "crypto-js": "^4.1.1",
     "denoify": "^1.6.6",
     "esbuild": "^0.15.12",
-    "eslint": "^8.39.0",
-    "eslint-config-prettier": "^8.8.0",
-    "eslint-define-config": "^1.20.0",
-    "eslint-import-resolver-typescript": "^3.5.5",
-    "eslint-plugin-eslint-comments": "^3.2.0",
-    "eslint-plugin-flowtype": "^8.0.3",
-    "eslint-plugin-import": "^2.27.5",
-    "eslint-plugin-node": "^11.1.0",
+    "eslint": "^8.55.0",
     "form-data": "^4.0.0",
     "jest": "^29.6.4",
     "jest-preset-fastly-js-compute": "^1.3.0",
@@ -479,13 +471,12 @@
     "supertest": "^6.3.3",
     "ts-jest": "^29.1.1",
     "tsx": "^3.11.0",
-    "typescript": "^4.8.3",
+    "typescript": "^5.3.3",
     "vitest": "^0.34.3",
-    "wrangler": "^2.12.0",
+    "wrangler": "3.17.1",
     "zod": "^3.20.2"
   },
   "engines": {
     "node": ">=16.0.0"
-  },
-  "dependencies": {}
+  }
 }