hono 4.6.20 → 4.7.1

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

@@ -3,10 +3,10 @@
  * Adapter Helper for Hono.
  */
 import type { Context } from '../../context';
-export type Runtime = 'node' | 'deno' | 'bun' | 'workerd' | 'fastly' | 'edge-light' | 'other';
+export type Runtime = "node" | "deno" | "bun" | "workerd" | "fastly" | "edge-light" | "other";
 export declare const env: <T extends Record<string, unknown>, C extends Context = Context<{
     Bindings: T;
-}, any, {}>>(c: C, runtime?: Runtime) => T & C["env"];
+}, any, {}>>(c: T extends Record<string, unknown> ? Context : C, runtime?: Runtime) => T & C["env"];
 export declare const knownUserAgents: Partial<Record<Runtime, string>>;
 export declare const getRuntimeKey: () => Runtime;
 export declare const checkUserAgentEquals: (platform: string) => boolean;

package/dist/types/helper/conninfo/types.d.ts

@@ -1,10 +1,10 @@
 import type { Context } from '../../context';
-export type AddressType = 'IPv6' | 'IPv4' | undefined;
+export type AddressType = "IPv6" | "IPv4" | undefined;
 export type NetAddrInfo = {
     /**
      * Transport protocol type
      */
-    transport?: 'tcp' | 'udp';
+    transport?: "tcp" | "udp";
     /**
      * Transport port number
      */

package/dist/types/helper/css/common.d.ts

@@ -29,7 +29,12 @@ type CssVariableBasicType = CssClassName | CssEscapedString | string | number |
 type CssVariableAsyncType = Promise<CssVariableBasicType>;
 type CssVariableArrayType = (CssVariableBasicType | CssVariableAsyncType)[];
 export type CssVariableType = CssVariableBasicType | CssVariableAsyncType | CssVariableArrayType;
-export declare const buildStyleString: (strings: TemplateStringsArray, values: CssVariableType[]) => [string, string, CssClassName[], string[]];
+export declare const buildStyleString: (strings: TemplateStringsArray, values: CssVariableType[]) => [
+    string,
+    string,
+    CssClassName[],
+    string[]
+];
 export declare const cssCommon: (strings: TemplateStringsArray, values: CssVariableType[]) => CssClassName;
 export declare const cxCommon: (args: (string | boolean | null | undefined | CssClassName)[]) => (string | boolean | null | undefined | CssClassName)[];
 export declare const keyframesCommon: (strings: TemplateStringsArray, ...values: CssVariableType[]) => CssClassName;

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

@@ -3,15 +3,101 @@
  * Factory Helper for Hono.
  */
 import { Hono } from '../../hono';
+import type { HonoOptions } from '../../hono-base';
 import type { Env, H, HandlerResponse, Input, IntersectNonAnyTypes, MiddlewareHandler } from '../../types';
 type InitApp<E extends Env = Env> = (app: Hono<E>) => void;
 export interface CreateHandlersInterface<E extends Env, P extends string> {
-    <I extends Input = {}, R extends HandlerResponse<any> = any, E2 extends Env = E>(handler1: H<E2, P, I, R>): [H<E2, P, I, R>];
-    <I extends Input = {}, I2 extends Input = I, R extends HandlerResponse<any> = any, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>>(handler1: H<E2, P, I, R>, handler2: H<E3, P, I2, R>): [H<E2, P, I, R>, H<E3, P, I2, R>];
-    <I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, R extends HandlerResponse<any> = any, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>>(handler1: H<E2, P, I, R>, handler2: H<E3, P, I2, R>, handler3: H<E4, P, I3, R>): [H<E2, P, I, R>, H<E3, P, I2, R>, H<E4, P, I3, R>];
-    <I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, R extends HandlerResponse<any> = any, 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]>>(handler1: H<E2, P, I, R>, handler2: H<E3, P, I2, R>, handler3: H<E4, P, I3, R>, handler4: H<E5, P, I4, R>): [H<E2, P, I, R>, H<E3, P, I2, R>, H<E4, P, I3, R>, H<E5, P, I4, R>];
-    <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, R extends HandlerResponse<any> = any, 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]>>(handler1: H<E2, P, I, R>, handler2: H<E3, P, I2, R>, handler3: H<E4, P, I3, R>, handler4: H<E5, P, I4, R>, handler5: H<E6, P, I5, R>): [H<E2, P, I, R>, H<E3, P, I2, R>, H<E4, P, I3, R>, H<E5, P, I4, R>, H<E6, P, I5, R>];
-    <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, R extends HandlerResponse<any> = any, 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]>>(handler1: H<E2, P, I, R>, handler2: H<E3, P, I2, R>, handler3: H<E4, P, I3, R>, handler4: H<E5, P, I4, R>, handler5: H<E6, P, I5, R>, handler6: H<E7, P, I6, R>): [
+    <I extends Input = {}, R extends HandlerResponse<any> = any, E2 extends Env = E>(handler1: H<E2, P, I, R>): [
+        H<E2, P, I, R>
+    ];
+    <I extends Input = {}, I2 extends Input = I, R extends HandlerResponse<any> = any, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[
+        E,
+        E2
+    ]>>(handler1: H<E2, P, I, R>, handler2: H<E3, P, I2, R>): [
+        H<E2, P, I, R>,
+        H<E3, P, I2, R>
+    ];
+    <I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, R extends HandlerResponse<any> = any, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[
+        E,
+        E2
+    ]>, E4 extends Env = IntersectNonAnyTypes<[
+        E,
+        E2,
+        E3
+    ]>>(handler1: H<E2, P, I, R>, handler2: H<E3, P, I2, R>, handler3: H<E4, P, I3, R>): [
+        H<E2, P, I, R>,
+        H<E3, P, I2, R>,
+        H<E4, P, I3, R>
+    ];
+    <I extends Input = {}, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, R extends HandlerResponse<any> = any, 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
+    ]>>(handler1: H<E2, P, I, R>, handler2: H<E3, P, I2, R>, handler3: H<E4, P, I3, R>, handler4: H<E5, P, I4, R>): [
+        H<E2, P, I, R>,
+        H<E3, P, I2, R>,
+        H<E4, P, I3, R>,
+        H<E5, P, I4, R>
+    ];
+    <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, R extends HandlerResponse<any> = any, 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
+    ]>>(handler1: H<E2, P, I, R>, handler2: H<E3, P, I2, R>, handler3: H<E4, P, I3, R>, handler4: H<E5, P, I4, R>, handler5: H<E6, P, I5, R>): [
+        H<E2, P, I, R>,
+        H<E3, P, I2, R>,
+        H<E4, P, I3, R>,
+        H<E5, P, I4, R>,
+        H<E6, P, I5, R>
+    ];
+    <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, R extends HandlerResponse<any> = any, 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
+    ]>>(handler1: H<E2, P, I, R>, handler2: H<E3, P, I2, R>, handler3: H<E4, P, I3, R>, handler4: H<E5, P, I4, R>, handler5: H<E6, P, I5, R>, handler6: H<E7, P, I6, R>): [
         H<E2, P, I, R>,
         H<E3, P, I2, R>,
         H<E4, P, I3, R>,
@@ -19,7 +105,40 @@ export interface CreateHandlersInterface<E extends Env, P extends string> {
         H<E6, P, I5, R>,
         H<E7, P, I6, R>
     ];
-    <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, R extends HandlerResponse<any> = any, 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]>>(handler1: H<E2, P, I, R>, handler2: H<E3, P, I2, R>, handler3: H<E4, P, I3, R>, handler4: H<E5, P, I4, R>, handler5: H<E6, P, I5, R>, handler6: H<E7, P, I6, R>, handler7: H<E8, P, I7, R>): [
+    <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, R extends HandlerResponse<any> = any, 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
+    ]>>(handler1: H<E2, P, I, R>, handler2: H<E3, P, I2, R>, handler3: H<E4, P, I3, R>, handler4: H<E5, P, I4, R>, handler5: H<E6, P, I5, R>, handler6: H<E7, P, I6, R>, handler7: H<E8, P, I7, R>): [
         H<E2, P, I, R>,
         H<E3, P, I2, R>,
         H<E4, P, I3, R>,
@@ -28,7 +147,49 @@ export interface CreateHandlersInterface<E extends Env, P extends string> {
         H<E7, P, I6, R>,
         H<E8, P, I7, R>
     ];
-    <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, R extends HandlerResponse<any> = any, 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]>>(handler1: H<E2, P, I, R>, handler2: H<E3, P, I2, R>, handler3: H<E4, P, I3, R>, handler4: H<E5, P, I4, R>, handler5: H<E6, P, I5, R>, handler6: H<E7, P, I6, R>, handler7: H<E8, P, I7, R>, handler8: H<E9, P, I8, R>): [
+    <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, R extends HandlerResponse<any> = any, 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
+    ]>>(handler1: H<E2, P, I, R>, handler2: H<E3, P, I2, R>, handler3: H<E4, P, I3, R>, handler4: H<E5, P, I4, R>, handler5: H<E6, P, I5, R>, handler6: H<E7, P, I6, R>, handler7: H<E8, P, I7, R>, handler8: H<E9, P, I8, R>): [
         H<E2, P, I, R>,
         H<E3, P, I2, R>,
         H<E4, P, I3, R>,
@@ -38,7 +199,59 @@ export interface CreateHandlersInterface<E extends Env, P extends string> {
         H<E8, P, I7, R>,
         H<E9, P, I8, R>
     ];
-    <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, R extends HandlerResponse<any> = any, 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]>>(handler1: H<E2, P, I, R>, handler2: H<E3, P, I2, R>, handler3: H<E4, P, I3, R>, handler4: H<E5, P, I4, R>, handler5: H<E6, P, I5, R>, handler6: H<E7, P, I6, R>, handler7: H<E8, P, I7, R>, handler8: H<E9, P, I8, R>, handler9: H<E10, P, I9, R>): [
+    <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, R extends HandlerResponse<any> = any, 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
+    ]>>(handler1: H<E2, P, I, R>, handler2: H<E3, P, I2, R>, handler3: H<E4, P, I3, R>, handler4: H<E5, P, I4, R>, handler5: H<E6, P, I5, R>, handler6: H<E7, P, I6, R>, handler7: H<E8, P, I7, R>, handler8: H<E9, P, I8, R>, handler9: H<E10, P, I9, R>): [
         H<E2, P, I, R>,
         H<E3, P, I2, R>,
         H<E4, P, I3, R>,
@@ -49,7 +262,70 @@ export interface CreateHandlersInterface<E extends Env, P extends string> {
         H<E9, P, I8, R>,
         H<E10, P, I9, R>
     ];
-    <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, R extends HandlerResponse<any> = any, 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]>>(handler1: H<E2, P, I, R>, handler2: H<E3, P, I2, R>, handler3: H<E4, P, I3, R>, handler4: H<E5, P, I4, R>, handler5: H<E6, P, I5, R>, handler6: H<E7, P, I6, R>, handler7: H<E8, P, I7, R>, handler8: H<E9, P, I8, R>, handler9: H<E10, P, I9, R>, handler10: H<E11, P, I10, R>): [
+    <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, R extends HandlerResponse<any> = any, 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
+    ]>>(handler1: H<E2, P, I, R>, handler2: H<E3, P, I2, R>, handler3: H<E4, P, I3, R>, handler4: H<E5, P, I4, R>, handler5: H<E6, P, I5, R>, handler6: H<E7, P, I6, R>, handler7: H<E8, P, I7, R>, handler8: H<E9, P, I8, R>, handler9: H<E10, P, I9, R>, handler10: H<E11, P, I10, R>): [
         H<E2, P, I, R>,
         H<E3, P, I2, R>,
         H<E4, P, I3, R>,
@@ -63,16 +339,17 @@ export interface CreateHandlersInterface<E extends Env, P extends string> {
     ];
 }
 export declare class Factory<E extends Env = Env, P extends string = string> {
-    private initApp?;
     constructor(init?: {
         initApp?: InitApp<E>;
+        defaultAppOptions?: HonoOptions<E>;
     });
-    createApp: () => Hono<E>;
+    createApp: (options?: HonoOptions<E>) => Hono<E>;
     createMiddleware: <I extends Input = {}>(middleware: MiddlewareHandler<E, P, I>) => MiddlewareHandler<E, P, I>;
     createHandlers: CreateHandlersInterface<E, P>;
 }
 export declare const createFactory: <E extends Env = Env, P extends string = string>(init?: {
     initApp?: InitApp<E>;
+    defaultAppOptions?: HonoOptions<E>;
 }) => Factory<E, P>;
 export declare const createMiddleware: <E extends Env = any, P extends string = string, I extends Input = {}>(middleware: MiddlewareHandler<E, P, I>) => MiddlewareHandler<E, P, I>;
 export {};

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

@@ -0,0 +1,54 @@
+/**
+ * @module
+ * Proxy Helper for Hono.
+ */
+import type { RequestHeader } from '../../utils/headers';
+interface ProxyRequestInit extends Omit<RequestInit, "headers"> {
+    raw?: Request;
+    headers?: HeadersInit | [
+        string,
+        string
+    ][] | Record<RequestHeader, string | undefined> | Record<string, string | undefined>;
+}
+interface ProxyFetch {
+    (input: string | URL | Request, init?: ProxyRequestInit): Promise<Response>;
+}
+/**
+ * Fetch API wrapper for proxy.
+ * The parameters and return value are the same as for `fetch` (except for the proxy-specific options).
+ *
+ * The “Accept-Encoding” header is replaced with an encoding that the current runtime can handle.
+ * Unnecessary response headers are deleted and a Response object is returned that can be returned
+ * as is as a response from the handler.
+ *
+ * @example
+ * ```ts
+ * app.get('/proxy/:path', (c) => {
+ *   return proxy(`http://${originServer}/${c.req.param('path')}`, {
+ *     headers: {
+ *       ...c.req.header(), // optional, specify only when forwarding all the request data (including credentials) is necessary.
+ *       'X-Forwarded-For': '127.0.0.1',
+ *       'X-Forwarded-Host': c.req.header('host'),
+ *       Authorization: undefined, // do not propagate request headers contained in c.req.header('Authorization')
+ *     },
+ *   }).then((res) => {
+ *     res.headers.delete('Set-Cookie')
+ *     return res
+ *   })
+ * })
+ *
+ * app.all('/proxy/:path', (c) => {
+ *   return proxy(`http://${originServer}/${c.req.param('path')}`, {
+ *     ...c.req, // optional, specify only when forwarding all the request data (including credentials) is necessary.
+ *     headers: {
+ *       ...c.req.header(),
+ *       'X-Forwarded-For': '127.0.0.1',
+ *       'X-Forwarded-Host': c.req.header('host'),
+ *       Authorization: undefined, // do not propagate request headers contained in c.req.header('Authorization')
+ *     },
+ *   })
+ * })
+ * ```
+ */
+export declare const proxy: ProxyFetch;
+export {};

package/dist/types/helper/ssg/ssg.d.ts

@@ -64,7 +64,7 @@ export interface ToSSGInterface {
  * `ToSSGAdaptorInterface` is an experimental feature.
  * The API might be changed.
  */
-export interface ToSSGAdaptorInterface<E extends Env = Env, S extends Schema = {}, BasePath extends string = '/'> {
+export interface ToSSGAdaptorInterface<E extends Env = Env, S extends Schema = {}, BasePath extends string = "/"> {
     (app: Hono<E, S, BasePath>, options?: ToSSGOptions): Promise<ToSSGResult>;
 }
 /**

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

@@ -17,7 +17,7 @@ export interface WSEvents<T = unknown> {
  * Upgrade WebSocket Type
  */
 export type UpgradeWebSocket<T = unknown, U = any, _WSEvents = WSEvents<T>> = (createEvents: (c: Context) => _WSEvents | Promise<_WSEvents>, options?: U) => MiddlewareHandler<any, string, {
-    outputFormat: 'ws';
+    outputFormat: "ws";
 }>;
 /**
  * ReadyState for WebSocket
@@ -44,7 +44,6 @@ export interface SendOptions {
  * A context for controlling WebSockets
  */
 export declare class WSContext<T = unknown> {
-    #private;
     constructor(init: WSContextInit<T>);
     send(source: string | ArrayBuffer | Uint8Array, options?: SendOptions): void;
     raw?: T;

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

@@ -7,7 +7,7 @@ import type { ExecutionContext } from './context';
 import type { Router } from './router';
 import type { Env, ErrorHandler, H, HandlerInterface, MergePath, MergeSchemaPath, MiddlewareHandlerInterface, NotFoundHandler, OnHandlerInterface, RouterRoute, Schema } from './types';
 type GetPath<E extends Env> = (request: Request, options?: {
-    env?: E['Bindings'];
+    env?: E["Bindings"];
 }) => string;
 export type HonoOptions<E extends Env> = {
     /**
@@ -28,7 +28,10 @@ export type HonoOptions<E extends Env> = {
      * const app = new Hono({ router: new RegExpRouter() })
      * ```
      */
-    router?: Router<[H, RouterRoute]>;
+    router?: Router<[
+        H,
+        RouterRoute
+    ]>;
     /**
      * `getPath` can handle the host header value.
      *
@@ -57,23 +60,23 @@ type MountOptions = MountOptionHandler | {
     optionHandler?: MountOptionHandler;
     replaceRequest?: MountReplaceRequest;
 };
-declare class Hono<E extends Env = Env, S extends Schema = {}, BasePath extends string = '/'> {
-    #private;
-    get: HandlerInterface<E, 'get', S, BasePath>;
-    post: HandlerInterface<E, 'post', S, BasePath>;
-    put: HandlerInterface<E, 'put', S, BasePath>;
-    delete: HandlerInterface<E, 'delete', S, BasePath>;
-    options: HandlerInterface<E, 'options', S, BasePath>;
-    patch: HandlerInterface<E, 'patch', S, BasePath>;
-    all: HandlerInterface<E, 'all', S, BasePath>;
+declare class Hono<E extends Env = Env, S extends Schema = {}, BasePath extends string = "/"> {
+    get: HandlerInterface<E, "get", S, BasePath>;
+    post: HandlerInterface<E, "post", S, BasePath>;
+    put: HandlerInterface<E, "put", S, BasePath>;
+    delete: HandlerInterface<E, "delete", S, BasePath>;
+    options: HandlerInterface<E, "options", S, BasePath>;
+    patch: HandlerInterface<E, "patch", S, BasePath>;
+    all: HandlerInterface<E, "all", S, BasePath>;
     on: OnHandlerInterface<E, S, BasePath>;
     use: MiddlewareHandlerInterface<E, S, BasePath>;
-    router: Router<[H, RouterRoute]>;
+    router: Router<[
+        H,
+        RouterRoute
+    ]>;
     readonly getPath: GetPath<E>;
-    private _basePath;
     routes: RouterRoute[];
     constructor(options?: HonoOptions<E>);
-    private errorHandler;
     /**
      * `.route()` allows grouping other Hono instance in routes.
      *
@@ -184,7 +187,7 @@ declare class Hono<E extends Env = Env, S extends Schema = {}, BasePath extends
      * @returns {Response | Promise<Response>} response of request
      *
      */
-    fetch: (request: Request, Env?: E['Bindings'] | {}, executionCtx?: ExecutionContext) => Response | Promise<Response>;
+    fetch: (request: Request, Env?: E["Bindings"] | {}, executionCtx?: ExecutionContext) => Response | Promise<Response>;
     /**
      * `.request()` is a useful method for testing.
      * You can pass a URL or pathname to send a GET request.

package/dist/types/hono.d.ts

@@ -9,7 +9,7 @@ import type { BlankEnv, BlankSchema, Env, Schema } from './types';
  * @template S - The schema type.
  * @template BasePath - The base path type.
  */
-export declare class Hono<E extends Env = BlankEnv, S extends Schema = BlankSchema, BasePath extends string = '/'> extends HonoBase<E, S, BasePath> {
+export declare class Hono<E extends Env = BlankEnv, S extends Schema = BlankSchema, BasePath extends string = "/"> extends HonoBase<E, S, BasePath> {
     /**
      * Creates an instance of the Hono class.
      *

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

@@ -23,7 +23,10 @@ export declare namespace JSX {
 }
 export declare const getNameSpaceContext: () => Context<string> | undefined;
 export declare const booleanAttributes: string[];
-type LocalContexts = [Context<unknown>, unknown][];
+type LocalContexts = [
+    Context<unknown>,
+    unknown
+][];
 export type Child = string | Promise<string> | number | JSXNode | null | undefined | boolean | Child[];
 export declare class JSXNode implements HtmlEscaped {
     tag: string | Function;

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

@@ -10,7 +10,7 @@ type FormStatus = {
 } | {
     pending: true;
     data: FormData;
-    method: 'get' | 'post';
+    method: "get" | "post";
     action: string | ((formData: FormData) => void | Promise<void>);
 };
 export declare const FormContext: Context<FormStatus>;
@@ -27,7 +27,10 @@ export declare const useFormStatus: () => FormStatus;
  * @param updateState
  * @returns [T, (action: N) => void]
  */
-export declare const useOptimistic: <T, N>(state: T, updateState: (currentState: T, action: N) => T) => [T, (action: N) => void];
+export declare const useOptimistic: <T, N>(state: T, updateState: (currentState: T, action: N) => T) => [
+    T,
+    (action: N) => void
+];
 /**
  * This hook returns the current state and a function to update the state by form action
  * @param fn
@@ -35,5 +38,8 @@ export declare const useOptimistic: <T, N>(state: T, updateState: (currentState:
  * @param permalink
  * @returns [T, (data: FormData) => void]
  */
-export declare const useActionState: <T>(fn: Function, initialState: T, permalink?: string) => [T, Function];
+export declare const useActionState: <T>(fn: Function, initialState: T, permalink?: string) => [
+    T,
+    Function
+];
 export {};

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

@@ -20,22 +20,37 @@ export { reactAPICompatVersion as version, createElement as jsx, useState, useEf
 declare const _default: {
     version: string;
     useState: {
-        <T>(initialState: T | (() => T)): [T, (newState: T | ((currentState: T) => T)) => void];
-        <T = undefined>(): [T | undefined, (newState: T | ((currentState: T | undefined) => T | undefined) | undefined) => void];
+        <T>(initialState: T | (() => T)): [
+            T,
+            (newState: T | ((currentState: T) => T)) => void
+        ];
+        <T = undefined>(): [
+            T | undefined,
+            (newState: T | ((currentState: T | undefined) => T | undefined) | undefined) => void
+        ];
     };
     useEffect: (effect: () => void | (() => void), deps?: readonly unknown[]) => void;
     useRef: <T>(initialValue: T | null) => import("..").RefObject<T>;
     useCallback: <T extends Function>(callback: T, deps: readonly unknown[]) => T;
     use: <T>(promise: Promise<T>) => T;
     startTransition: (callback: () => void) => void;
-    useTransition: () => [boolean, (callback: () => void | Promise<void>) => void];
+    useTransition: () => [
+        boolean,
+        (callback: () => void | Promise<void>) => void
+    ];
     useDeferredValue: <T>(value: T, initialValue?: T) => T;
     startViewTransition: (callback: () => void) => void;
-    useViewTransition: () => [boolean, (callback: () => void) => void];
+    useViewTransition: () => [
+        boolean,
+        (callback: () => void) => void
+    ];
     useMemo: <T>(factory: () => T, deps: readonly unknown[]) => T;
     useLayoutEffect: (effect: () => void | (() => void), deps?: readonly unknown[]) => void;
     useInsertionEffect: (effect: () => void | (() => void), deps?: readonly unknown[]) => void;
-    useReducer: <T, A>(reducer: (state: T, action: A) => T, initialArg: T, init?: (initialState: T) => T) => [T, (action: A) => void];
+    useReducer: <T, A>(reducer: (state: T, action: A) => T, initialArg: T, init?: (initialState: T) => T) => [
+        T,
+        (action: A) => void
+    ];
     useId: () => string;
     useDebugValue: (_value: unknown, _formatter?: (value: unknown) => string) => void;
     createRef: <T>() => import("..").RefObject<T>;
@@ -55,8 +70,14 @@ declare const _default: {
         method: "get" | "post";
         action: string | ((formData: FormData) => void | Promise<void>);
     };
-    useActionState: <T>(fn: Function, initialState: T, permalink?: string) => [T, Function];
-    useOptimistic: <T, N>(state: T, updateState: (currentState: T, action: N) => T) => [T, (action: N) => void];
+    useActionState: <T>(fn: Function, initialState: T, permalink?: string) => [
+        T,
+        Function
+    ];
+    useOptimistic: <T, N>(state: T, updateState: (currentState: T, action: N) => T) => [
+        T,
+        (action: N) => void
+    ];
     Suspense: FC<import("..").PropsWithChildren<{
         fallback: any;
     }>>;