hono 4.6.3 → 4.6.4

package/dist/adapter/service-worker/handler.js

@@ -1,6 +1,6 @@
 // src/adapter/service-worker/handler.ts
 var handle = (app, opts = {
-  fetch: globalThis.self !== void 0 ? globalThis.self.fetch : fetch
+  fetch: globalThis.fetch.bind(globalThis)
 }) => {
   return (evt) => {
     evt.respondWith(

package/dist/cjs/adapter/service-worker/handler.js

@@ -22,7 +22,7 @@ __export(handler_exports, {
 });
 module.exports = __toCommonJS(handler_exports);
 const handle = (app, opts = {
-  fetch: globalThis.self !== void 0 ? globalThis.self.fetch : fetch
+  fetch: globalThis.fetch.bind(globalThis)
 }) => {
   return (evt) => {
     evt.respondWith(

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

@@ -70,7 +70,7 @@ export declare const streamHandle: <E extends Env = Env, S extends Schema = {},
 /**
  * Accepts events from API Gateway/ELB(`APIGatewayProxyEvent`) and directly through Function Url(`APIGatewayProxyEventV2`)
  */
-export declare const handle: <E extends Env = Env, S extends Schema = {}, BasePath extends string = "/">(app: Hono<E, S, BasePath>) => (event: LambdaEvent, lambdaContext?: LambdaContext) => Promise<APIGatewayProxyResult>;
+export declare const handle: <E extends Env = Env, S extends Schema = {}, BasePath extends string = "/">(app: Hono<E, S, BasePath>) => ((event: LambdaEvent, lambdaContext?: LambdaContext) => Promise<APIGatewayProxyResult>);
 declare abstract class EventProcessor<E extends LambdaEvent> {
     protected abstract getPath(event: E): string;
     protected abstract getMethod(event: E): string;

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

@@ -16,7 +16,7 @@ export type EventContext<Env = {}, P extends string = any, Data = Record<string,
     data: Data;
 };
 declare type PagesFunction<Env = unknown, Params extends string = any, Data extends Record<string, unknown> = Record<string, unknown>> = (context: EventContext<Env, Params, Data>) => Response | Promise<Response>;
-export declare const handle: <E extends Env = Env, S extends Schema = BlankSchema, BasePath extends string = "/">(app: Hono<E, S, BasePath>) => PagesFunction<E["Bindings"], any, Record<string, unknown>>;
+export declare const handle: <E extends Env = Env, S extends Schema = BlankSchema, BasePath extends string = "/">(app: Hono<E, S, BasePath>) => PagesFunction<E["Bindings"]>;
 export declare function handleMiddleware<E extends Env = {}, P extends string = any, I extends Input = {}>(middleware: MiddlewareHandler<E & {
     Bindings: {
         eventContext: EventContext;

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

@@ -81,7 +81,7 @@ interface CloudFrontResult {
     body?: string;
     bodyEncoding?: 'text' | 'base64';
 }
-export declare const handle: (app: Hono<any>) => (event: CloudFrontEdgeEvent, context?: CloudFrontContext, callback?: Callback) => Promise<CloudFrontResult>;
-export declare const createBody: (method: string, requestBody: CloudFrontRequest['body']) => string | Uint8Array | undefined;
+export declare const handle: (app: Hono<any>) => ((event: CloudFrontEdgeEvent, context?: CloudFrontContext, callback?: Callback) => Promise<CloudFrontResult>);
+export declare const createBody: (method: string, requestBody: CloudFrontRequest["body"]) => string | Uint8Array | undefined;
 export declare const isContentTypeBinary: (contentType: string) => boolean;
 export {};

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

@@ -1,2 +1,2 @@
 import type { Hono } from '../../hono';
-export declare const handle: (app: Hono<any, any>) => (req: Request, context: any) => Response | Promise<Response>;
+export declare const handle: (app: Hono<any, any>) => ((req: Request, context: any) => Response | Promise<Response>);

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

@@ -1,5 +1,5 @@
 export declare const mergePath: (base: string, path: string) => string;
 export declare const replaceUrlParam: (urlString: string, params: Record<string, string | undefined>) => string;
-export declare const replaceUrlProtocol: (urlString: string, protocol: 'ws' | 'http') => string;
+export declare const replaceUrlProtocol: (urlString: string, protocol: "ws" | "http") => string;
 export declare const removeIndexString: (urlSting: string) => string;
 export declare function deepMerge<T>(target: T, source: Record<string, unknown>): T;

package/dist/types/compose.d.ts

@@ -26,5 +26,5 @@ interface ComposeContext {
  *
  * @returns {(context: C, next?: Function) => Promise<C>} - A composed middleware function.
  */
-export declare const compose: <C extends ComposeContext, E extends Env = Env>(middleware: [[Function, unknown], ParamIndexMap | Params][], onError?: ErrorHandler<E> | undefined, onNotFound?: NotFoundHandler<E> | undefined) => (context: C, next?: Function) => Promise<C>;
+export declare const compose: <C extends ComposeContext, E extends Env = Env>(middleware: [[Function, unknown], ParamIndexMap | Params][], onError?: ErrorHandler<E>, onNotFound?: NotFoundHandler<E>) => ((context: C, next?: Function) => Promise<C>);
 export {};

package/dist/types/context.d.ts

@@ -424,7 +424,7 @@ export declare class Context<E extends Env = any, P extends string = any, I exte
      * })
      * ```
      */
-    redirect: <T extends RedirectStatusCode = 302>(location: string, status?: T | undefined) => Response & TypedResponse<undefined, T, "redirect">;
+    redirect: <T extends RedirectStatusCode = 302>(location: string, status?: T) => Response & TypedResponse<undefined, T, "redirect">;
     /**
      * `.notFound()` can return the Not Found Response.
      *

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

@@ -4,7 +4,7 @@
  */
 import type { Context } from '../../context';
 export type Runtime = 'node' | 'deno' | 'bun' | 'workerd' | 'fastly' | 'edge-light' | '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 env: <T extends Record<string, unknown>, C extends Context = Context<{}, any, {}>>(c: 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/dev/index.d.ts

@@ -14,7 +14,7 @@ interface RouteData {
     name: string;
     isMiddleware: boolean;
 }
-export declare const inspectRoutes: <E extends Env>(hono: Hono<E, import("../../types").BlankSchema, "/">) => RouteData[];
-export declare const showRoutes: <E extends Env>(hono: Hono<E, import("../../types").BlankSchema, "/">, opts?: ShowRoutesOptions) => void;
-export declare const getRouterName: <E extends Env>(app: Hono<E, import("../../types").BlankSchema, "/">) => string;
+export declare const inspectRoutes: <E extends Env>(hono: Hono<E>) => RouteData[];
+export declare const showRoutes: <E extends Env>(hono: Hono<E>, opts?: ShowRoutesOptions) => void;
+export declare const getRouterName: <E extends Env>(app: Hono<E>) => string;
 export {};

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

@@ -67,7 +67,10 @@ export declare class Factory<E extends Env = any, P extends string = any> {
     createHandlers: CreateHandlersInterface<E, P>;
 }
 export declare const createFactory: <E extends Env = any, P extends string = any>(init?: {
-    initApp?: InitApp<E> | undefined;
-} | undefined) => 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>;
+    initApp?: InitApp<E>;
+}) => Factory<E, P>;
+export declare const createMiddleware: <E extends Env = any, P extends string = string, I extends Input = {}, E2 extends Env = {
+    Bindings: undefined extends E["Bindings"] ? any : E["Bindings"];
+    Variables: undefined extends E["Variables"] ? any : E["Variables"];
+}>(middleware: MiddlewareHandler<E2, P, I>) => MiddlewareHandler<E2, P, I>;
 export {};

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

@@ -10,5 +10,5 @@ export declare const joinPaths: (...paths: string[]) => string;
 interface FilterStaticGenerateRouteData {
     path: string;
 }
-export declare const filterStaticGenerateRoutes: <E extends Env>(hono: Hono<E, import("../../types").BlankSchema, "/">) => FilterStaticGenerateRouteData[];
+export declare const filterStaticGenerateRoutes: <E extends Env>(hono: Hono<E>) => FilterStaticGenerateRouteData[];
 export {};

package/dist/types/helper/streaming/sse.d.ts

@@ -10,4 +10,4 @@ export declare class SSEStreamingApi extends StreamingApi {
     constructor(writable: WritableStream, readable: ReadableStream);
     writeSSE(message: SSEMessage): Promise<void>;
 }
-export declare const streamSSE: (c: Context, cb: (stream: SSEStreamingApi) => Promise<void>, onError?: ((e: Error, stream: SSEStreamingApi) => Promise<void>) | undefined) => Response;
+export declare const streamSSE: (c: Context, cb: (stream: SSEStreamingApi) => Promise<void>, onError?: (e: Error, stream: SSEStreamingApi) => Promise<void>) => Response;

package/dist/types/helper/streaming/stream.d.ts

@@ -1,3 +1,3 @@
 import type { Context } from '../../context';
 import { StreamingApi } from '../../utils/stream';
-export declare const stream: (c: Context, cb: (stream: StreamingApi) => Promise<void>, onError?: ((e: Error, stream: StreamingApi) => Promise<void>) | undefined) => Response;
+export declare const stream: (c: Context, cb: (stream: StreamingApi) => Promise<void>, onError?: (e: Error, stream: StreamingApi) => Promise<void>) => Response;

package/dist/types/helper/streaming/text.d.ts

@@ -1,3 +1,3 @@
 import type { Context } from '../../context';
 import type { StreamingApi } from '../../utils/stream';
-export declare const streamText: (c: Context, cb: (stream: StreamingApi) => Promise<void>, onError?: ((e: Error, stream: StreamingApi) => Promise<void>) | undefined) => Response;
+export declare const streamText: (c: Context, cb: (stream: StreamingApi) => Promise<void>, onError?: (e: Error, stream: StreamingApi) => Promise<void>) => Response;

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

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

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

@@ -207,7 +207,7 @@ declare class Hono<E extends Env = Env, S extends Schema = {}, BasePath extends
      * ```
      * @see https://hono.dev/docs/api/hono#request
      */
-    request: (input: RequestInfo | URL, requestInit?: RequestInit, Env?: E['Bindings'] | {}, executionCtx?: ExecutionContext) => Response | Promise<Response>;
+    request: (input: RequestInfo | URL, requestInit?: RequestInit, Env?: E["Bindings"] | {}, executionCtx?: ExecutionContext) => Response | Promise<Response>;
     /**
      * `.fire()` automatically adds a global fetch event listener.
      * This can be useful for environments that adhere to the Service Worker API, such as non-ES module Cloudflare Workers.

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

@@ -16,6 +16,9 @@ export declare namespace JSX {
     interface IntrinsicElements extends IntrinsicElementsDefined {
         [tagName: string]: Props;
     }
+    interface IntrinsicAttributes {
+        key?: string | number | bigint | null | undefined;
+    }
 }
 export declare const getNameSpaceContext: () => Context<string> | undefined;
 export declare const booleanAttributes: string[];
@@ -41,7 +44,7 @@ export declare const jsx: (tag: string | Function, props: Props | null, ...child
 export declare const jsxFn: (tag: string | Function, props: Props, children: (string | number | HtmlEscapedString)[]) => JSXNode;
 export declare const memo: <T>(component: FC<T>, propsAreEqual?: (prevProps: Readonly<T>, nextProps: Readonly<T>) => boolean) => FC<T>;
 export declare const Fragment: ({ children, }: {
-    key?: string | undefined;
+    key?: string;
     children?: Child | HtmlEscapedString;
 }) => HtmlEscapedString;
 export declare const isValidElement: (element: unknown) => element is JSXNode;

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

@@ -20,29 +20,29 @@ declare const _default: {
     version: string;
     useState: {
         <T>(initialState: T | (() => T)): [T, (newState: T | ((currentState: T) => T)) => void];
-        <T_1 = undefined>(): [T_1 | undefined, (newState: T_1 | ((currentState: T_1 | undefined) => T_1 | undefined) | undefined) => void];
+        <T = undefined>(): [T | undefined, (newState: T | ((currentState: T | undefined) => T | undefined) | undefined) => void];
     };
-    useEffect: (effect: () => void | (() => void), deps?: readonly unknown[] | undefined) => void;
-    useRef: <T_2>(initialValue: T_2 | null) => import("../hooks").RefObject<T_2>;
-    useCallback: <T_3 extends Function>(callback: T_3, deps: readonly unknown[]) => T_3;
-    use: <T_4>(promise: Promise<T_4>) => T_4;
+    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];
-    useDeferredValue: <T_5>(value: T_5, initialValue?: T_5 | undefined) => T_5;
+    useDeferredValue: <T>(value: T, initialValue?: T) => T;
     startViewTransition: (callback: () => void) => void;
     useViewTransition: () => [boolean, (callback: () => void) => void];
-    useMemo: <T_6>(factory: () => T_6, deps: readonly unknown[]) => T_6;
-    useLayoutEffect: (effect: () => void | (() => void), deps?: readonly unknown[] | undefined) => void;
-    useInsertionEffect: (effect: () => void | (() => void), deps?: readonly unknown[] | undefined) => void;
-    useReducer: <T_7, A>(reducer: (state: T_7, action: A) => T_7, initialArg: T_7, init?: ((initialState: T_7) => T_7) | undefined) => [T_7, (action: A) => 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];
     useId: () => string;
-    useDebugValue: (_value: unknown, _formatter?: ((value: unknown) => string) | undefined) => void;
-    createRef: <T_8>() => import("../hooks").RefObject<T_8>;
-    forwardRef: <T_9, P = {}>(Component: (props: P, ref?: import("../hooks").RefObject<T_9> | undefined) => JSX.Element) => (props: P & {
-        ref?: import("../hooks").RefObject<T_9> | undefined;
-    }) => JSX.Element;
-    useImperativeHandle: <T_10>(ref: import("../hooks").RefObject<T_10>, createHandle: () => T_10, deps: readonly unknown[]) => void;
-    useSyncExternalStore: <T_11>(subscribe: (callback: () => void) => () => void, getSnapshot: () => T_11, getServerSnapshot?: (() => T_11) | undefined) => T_11;
+    useDebugValue: (_value: unknown, _formatter?: (value: unknown) => string) => void;
+    createRef: <T>() => import("..").RefObject<T>;
+    forwardRef: <T, P = {}>(Component: (props: P, ref?: import("..").RefObject<T>) => JSX.Element) => ((props: P & {
+        ref?: import("..").RefObject<T>;
+    }) => JSX.Element);
+    useImperativeHandle: <T>(ref: import("..").RefObject<T>, createHandle: () => T, deps: readonly unknown[]) => void;
+    useSyncExternalStore: <T>(subscribe: (callback: () => void) => () => void, getSnapshot: () => T, getServerSnapshot?: () => T) => T;
     useFormStatus: () => {
         pending: false;
         data: null;
@@ -54,22 +54,22 @@ declare const _default: {
         method: "get" | "post";
         action: string | ((formData: FormData) => void | Promise<void>);
     };
-    useActionState: <T_12>(fn: Function, initialState: T_12, permalink?: string | undefined) => [T_12, Function];
-    useOptimistic: <T_13, N>(state: T_13, updateState: (currentState: T_13, action: N) => T_13) => [T_13, (action: N) => void];
-    Suspense: import("../base").FC<import("../types").PropsWithChildren<{
+    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: import("..").FC<import("..").PropsWithChildren<{
         fallback: any;
     }>>;
-    ErrorBoundary: import("../base").FC<import("../types").PropsWithChildren<{
+    ErrorBoundary: import("..").FC<import("..").PropsWithChildren<{
         fallback?: Child;
-        fallbackRender?: import("../components").FallbackRender | undefined;
-        onError?: import("../components").ErrorHandler | undefined;
+        fallbackRender?: import("../components").FallbackRender;
+        onError?: import("../components").ErrorHandler;
     }>>;
-    createContext: <T_14>(defaultValue: T_14) => import("../context").Context<T_14>;
-    useContext: <T_15>(context: import("../context").Context<T_15>) => T_15;
-    memo: <T_16>(component: import("../base").FC<T_16>, propsAreEqual?: (prevProps: Readonly<T_16>, nextProps: Readonly<T_16>) => boolean) => import("../base").FC<T_16>;
+    createContext: <T>(defaultValue: T) => import("..").Context<T>;
+    useContext: <T>(context: import("..").Context<T>) => T;
+    memo: <T>(component: import("..").FC<T>, propsAreEqual?: (prevProps: Readonly<T>, nextProps: Readonly<T>) => boolean) => import("..").FC<T>;
     isValidElement: (element: unknown) => element is JSXNode;
     createElement: (tag: string | ((props: Props) => JSXNode), props: Props | null, ...children: Child[]) => JSXNode;
-    cloneElement: <T_17 extends JSXNode | JSX.Element>(element: T_17, props: Props, ...children: Child[]) => T_17;
+    cloneElement: <T extends JSXNode | JSX.Element>(element: T, props: Props, ...children: Child[]) => T;
     Children: {
         map: (children: Child[], fn: (child: Child, index: number) => Child) => Child[];
         forEach: (children: Child[], fn: (child: Child, index: number) => void) => void;
@@ -80,7 +80,7 @@ declare const _default: {
     Fragment: (props: Record<string, unknown>) => JSXNode;
     StrictMode: (props: Record<string, unknown>) => JSXNode;
     flushSync: (callback: () => void) => void;
-    createPortal: (children: Child, container: HTMLElement, key?: string | undefined) => Child;
+    createPortal: (children: Child, container: HTMLElement, key?: string) => Child;
 };
 export default _default;
 export type { Context } from '../context';

package/dist/types/jsx/dom/intrinsic-element/components.d.ts

@@ -1,7 +1,7 @@
 import type { IntrinsicElements } from '../../intrinsic-elements';
 import type { FC, PropsWithChildren, RefObject } from '../../types';
 export declare const clearCache: () => void;
-export declare const composeRef: <T>(ref: Function | RefObject<T> | undefined, cb: (e: T) => void | (() => void)) => (e: T) => () => void;
+export declare const composeRef: <T>(ref: RefObject<T> | Function | undefined, cb: (e: T) => void | (() => void)) => ((e: T) => () => void);
 export declare const title: FC<PropsWithChildren>;
 export declare const script: FC<PropsWithChildren<IntrinsicElements['script']>>;
 export declare const style: FC<PropsWithChildren<IntrinsicElements['style']>>;

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

@@ -40,29 +40,29 @@ declare const _default: {
         version: string;
         useState: {
             <T>(initialState: T | (() => T)): [T, (newState: T | ((currentState: T) => T)) => void];
-            <T_1 = undefined>(): [T_1 | undefined, (newState: T_1 | ((currentState: T_1 | undefined) => T_1 | undefined) | undefined) => void];
+            <T = undefined>(): [T | undefined, (newState: T | ((currentState: T | undefined) => T | undefined) | undefined) => void];
         };
-        useEffect: (effect: () => void | (() => void), deps?: readonly unknown[] | undefined) => void;
-        useRef: <T_2>(initialValue: T_2 | null) => import("./").RefObject<T_2>;
-        useCallback: <T_3 extends Function>(callback: T_3, deps: readonly unknown[]) => T_3;
-        use: <T_4>(promise: Promise<T_4>) => T_4;
+        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];
-        useDeferredValue: <T_5>(value: T_5, initialValue?: T_5 | undefined) => T_5;
+        useDeferredValue: <T>(value: T, initialValue?: T) => T;
         startViewTransition: (callback: () => void) => void;
         useViewTransition: () => [boolean, (callback: () => void) => void];
-        useMemo: <T_6>(factory: () => T_6, deps: readonly unknown[]) => T_6;
-        useLayoutEffect: (effect: () => void | (() => void), deps?: readonly unknown[] | undefined) => void;
-        useInsertionEffect: (effect: () => void | (() => void), deps?: readonly unknown[] | undefined) => void;
-        useReducer: <T_7, A>(reducer: (state: T_7, action: A) => T_7, initialArg: T_7, init?: ((initialState: T_7) => T_7) | undefined) => [T_7, (action: A) => 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];
         useId: () => string;
-        useDebugValue: (_value: unknown, _formatter?: ((value: unknown) => string) | undefined) => void;
-        createRef: <T_8>() => import("./").RefObject<T_8>;
-        forwardRef: <T_9, P = {}>(Component: (props: P, ref?: import("./").RefObject<T_9> | undefined) => import("../base").JSX.Element) => (props: P & {
-            ref?: import("./").RefObject<T_9> | undefined;
-        }) => import("../base").JSX.Element;
-        useImperativeHandle: <T_10>(ref: import("./").RefObject<T_10>, createHandle: () => T_10, deps: readonly unknown[]) => void;
-        useSyncExternalStore: <T_11>(subscribe: (callback: () => void) => () => void, getSnapshot: () => T_11, getServerSnapshot?: (() => T_11) | undefined) => T_11;
+        useDebugValue: (_value: unknown, _formatter?: (value: unknown) => string) => void;
+        createRef: <T>() => import("..").RefObject<T>;
+        forwardRef: <T, P = {}>(Component: (props: P, ref?: import("..").RefObject<T>) => import("../base").JSX.Element) => ((props: P & {
+            ref?: import("..").RefObject<T>;
+        }) => import("../base").JSX.Element);
+        useImperativeHandle: <T>(ref: import("..").RefObject<T>, createHandle: () => T, deps: readonly unknown[]) => void;
+        useSyncExternalStore: <T>(subscribe: (callback: () => void) => () => void, getSnapshot: () => T, getServerSnapshot?: () => T) => T;
         useFormStatus: () => {
             pending: false;
             data: null;
@@ -74,22 +74,22 @@ declare const _default: {
             method: "get" | "post";
             action: string | ((formData: FormData) => void | Promise<void>);
         };
-        useActionState: <T_12>(fn: Function, initialState: T_12, permalink?: string | undefined) => [T_12, Function];
-        useOptimistic: <T_13, N>(state: T_13, updateState: (currentState: T_13, action: N) => T_13) => [T_13, (action: N) => void];
-        Suspense: import("./").FC<import("./").PropsWithChildren<{
+        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: import("..").FC<import("..").PropsWithChildren<{
             fallback: any;
         }>>;
-        ErrorBoundary: import("./").FC<import("./").PropsWithChildren<{
+        ErrorBoundary: import("..").FC<import("..").PropsWithChildren<{
             fallback?: Child;
-            fallbackRender?: import("../components").FallbackRender | undefined;
-            onError?: import("../components").ErrorHandler | undefined;
+            fallbackRender?: import("../components").FallbackRender;
+            onError?: import("../components").ErrorHandler;
         }>>;
-        createContext: <T_14>(defaultValue: T_14) => import("./").Context<T_14>;
-        useContext: <T_15>(context: import("./").Context<T_15>) => T_15;
-        memo: <T_16>(component: import("./").FC<T_16>, propsAreEqual?: (prevProps: Readonly<T_16>, nextProps: Readonly<T_16>) => boolean) => import("./").FC<T_16>;
-        isValidElement: (element: unknown) => element is import("./").JSXNode;
-        createElement: (tag: string | ((props: import("../base").Props) => import("./").JSXNode), props: import("../base").Props | null, ...children: Child[]) => import("./").JSXNode;
-        cloneElement: <T_17 extends import("./").JSXNode | import("../base").JSX.Element>(element: T_17, props: import("../base").Props, ...children: Child[]) => T_17;
+        createContext: <T>(defaultValue: T) => import("..").Context<T>;
+        useContext: <T>(context: import("..").Context<T>) => T;
+        memo: <T>(component: import("..").FC<T>, propsAreEqual?: (prevProps: Readonly<T>, nextProps: Readonly<T>) => boolean) => import("..").FC<T>;
+        isValidElement: (element: unknown) => element is import("..").JSXNode;
+        createElement: (tag: string | ((props: import("../base").Props) => import("..").JSXNode), props: import("../base").Props | null, ...children: Child[]) => import("..").JSXNode;
+        cloneElement: <T extends import("..").JSXNode | import("../base").JSX.Element>(element: T, props: import("../base").Props, ...children: Child[]) => T;
         Children: {
             map: (children: Child[], fn: (child: Child, index: number) => Child) => Child[];
             forEach: (children: Child[], fn: (child: Child, index: number) => void) => void;
@@ -97,10 +97,10 @@ declare const _default: {
             only: (_children: Child[]) => Child;
             toArray: (children: Child) => Child[];
         };
-        Fragment: (props: Record<string, unknown>) => import("./").JSXNode;
-        StrictMode: (props: Record<string, unknown>) => import("./").JSXNode;
+        Fragment: (props: Record<string, unknown>) => import("..").JSXNode;
+        StrictMode: (props: Record<string, unknown>) => import("..").JSXNode;
         flushSync: (callback: () => void) => void;
-        createPortal: (children: Child, container: HTMLElement, key?: string | undefined) => Child;
+        createPortal: (children: Child, container: HTMLElement, key?: string) => Child;
     };
 };
 export default _default;

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

@@ -23,7 +23,7 @@ type UseStateType = {
     <T = undefined>(): [T | undefined, UpdateStateFunction<T | undefined>];
 };
 export declare const useState: UseStateType;
-export declare const useReducer: <T, A>(reducer: (state: T, action: A) => T, initialArg: T, init?: ((initialState: T) => T) | undefined) => [T, (action: A) => void];
+export declare const useReducer: <T, A>(reducer: (state: T, action: A) => T, initialArg: T, init?: (initialState: T) => T) => [T, (action: A) => void];
 export declare const useEffect: (effect: () => void | (() => void), deps?: readonly unknown[]) => void;
 export declare const useLayoutEffect: (effect: () => void | (() => void), deps?: readonly unknown[]) => void;
 export declare const useInsertionEffect: (effect: () => void | (() => void), deps?: readonly unknown[]) => void;
@@ -35,11 +35,11 @@ export declare const useRef: <T>(initialValue: T | null) => RefObject<T>;
 export declare const use: <T>(promise: Promise<T>) => T;
 export declare const useMemo: <T>(factory: () => T, deps: readonly unknown[]) => T;
 export declare const useId: () => string;
-export declare const useDebugValue: (_value: unknown, _formatter?: ((value: unknown) => string) | undefined) => void;
+export declare const useDebugValue: (_value: unknown, _formatter?: (value: unknown) => string) => void;
 export declare const createRef: <T>() => RefObject<T>;
-export declare const forwardRef: <T, P = {}>(Component: (props: P, ref?: RefObject<T> | undefined) => JSX.Element) => (props: P & {
-    ref?: RefObject<T> | undefined;
-}) => JSX.Element;
+export declare const forwardRef: <T, P = {}>(Component: (props: P, ref?: RefObject<T>) => JSX.Element) => ((props: P & {
+    ref?: RefObject<T>;
+}) => JSX.Element);
 export declare const useImperativeHandle: <T>(ref: RefObject<T>, createHandle: () => T, deps: readonly unknown[]) => void;
-export declare const useSyncExternalStore: <T>(subscribe: (callback: () => void) => () => void, getSnapshot: () => T, getServerSnapshot?: (() => T) | undefined) => T;
+export declare const useSyncExternalStore: <T>(subscribe: (callback: () => void) => () => void, getSnapshot: () => T, getServerSnapshot?: () => T) => T;
 export {};

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

@@ -15,50 +15,50 @@ declare const _default: {
     version: string;
     memo: <T>(component: import("./base").FC<T>, propsAreEqual?: (prevProps: Readonly<T>, nextProps: Readonly<T>) => boolean) => import("./base").FC<T>;
     Fragment: ({ children, }: {
-        key?: string | undefined;
-        children?: import("../utils/html").HtmlEscapedString | import("./base").Child;
+        key?: string;
+        children?: import("./base").Child | import("../utils/html").HtmlEscapedString;
     }) => import("../utils/html").HtmlEscapedString;
     StrictMode: ({ children, }: {
-        key?: string | undefined;
-        children?: import("../utils/html").HtmlEscapedString | import("./base").Child;
+        key?: string;
+        children?: import("./base").Child | import("../utils/html").HtmlEscapedString;
     }) => import("../utils/html").HtmlEscapedString;
     isValidElement: (element: unknown) => element is import("./base").JSXNode;
     createElement: (tag: string | Function, props: import("./base").Props | null, ...children: (string | number | import("../utils/html").HtmlEscapedString)[]) => import("./base").JSXNode;
-    cloneElement: <T_1 extends import("./base").JSXNode | import("./base").JSX.Element>(element: T_1, props: Partial<import("./base").Props>, ...children: import("./base").Child[]) => T_1;
+    cloneElement: <T extends import("./base").JSXNode | import("./base").JSX.Element>(element: T, props: Partial<import("./base").Props>, ...children: import("./base").Child[]) => T;
     ErrorBoundary: import("./base").FC<import("./types").PropsWithChildren<{
         fallback?: import("./base").Child;
-        fallbackRender?: import("./components").FallbackRender | undefined;
-        onError?: import("./components").ErrorHandler | undefined;
+        fallbackRender?: import("./components").FallbackRender;
+        onError?: import("./components").ErrorHandler;
     }>>;
-    createContext: <T_2>(defaultValue: T_2) => import("./context").Context<T_2>;
-    useContext: <T_3>(context: import("./context").Context<T_3>) => T_3;
+    createContext: <T>(defaultValue: T) => import("./context").Context<T>;
+    useContext: <T>(context: import("./context").Context<T>) => T;
     useState: {
-        <T_4>(initialState: T_4 | (() => T_4)): [T_4, (newState: T_4 | ((currentState: T_4) => T_4)) => void];
-        <T_5 = undefined>(): [T_5 | undefined, (newState: T_5 | ((currentState: T_5 | undefined) => T_5 | 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[] | undefined) => void;
-    useRef: <T_6>(initialValue: T_6 | null) => import("./hooks").RefObject<T_6>;
-    useCallback: <T_7 extends Function>(callback: T_7, deps: readonly unknown[]) => T_7;
-    useReducer: <T_8, A>(reducer: (state: T_8, action: A) => T_8, initialArg: T_8, init?: ((initialState: T_8) => T_8) | undefined) => [T_8, (action: A) => void];
+    useEffect: (effect: () => void | (() => void), deps?: readonly unknown[]) => void;
+    useRef: <T>(initialValue: T | null) => import("./hooks").RefObject<T>;
+    useCallback: <T extends Function>(callback: T, deps: readonly unknown[]) => T;
+    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) | undefined) => void;
-    use: <T_9>(promise: Promise<T_9>) => T_9;
+    useDebugValue: (_value: unknown, _formatter?: (value: unknown) => string) => void;
+    use: <T>(promise: Promise<T>) => T;
     startTransition: (callback: () => void) => void;
     useTransition: () => [boolean, (callback: () => void | Promise<void>) => void];
-    useDeferredValue: <T_10>(value: T_10, initialValue?: T_10 | undefined) => T_10;
+    useDeferredValue: <T>(value: T, initialValue?: T) => T;
     startViewTransition: (callback: () => void) => void;
     useViewTransition: () => [boolean, (callback: () => void) => void];
-    useMemo: <T_11>(factory: () => T_11, deps: readonly unknown[]) => T_11;
-    useLayoutEffect: (effect: () => void | (() => void), deps?: readonly unknown[] | undefined) => void;
-    useInsertionEffect: (effect: () => void | (() => void), deps?: readonly unknown[] | undefined) => void;
-    createRef: <T_12>() => import("./hooks").RefObject<T_12>;
-    forwardRef: <T_13, P = {}>(Component: (props: P, ref?: import("./hooks").RefObject<T_13> | undefined) => import("./base").JSX.Element) => (props: P & {
-        ref?: import("./hooks").RefObject<T_13> | undefined;
-    }) => import("./base").JSX.Element;
-    useImperativeHandle: <T_14>(ref: import("./hooks").RefObject<T_14>, createHandle: () => T_14, deps: readonly unknown[]) => void;
-    useSyncExternalStore: <T_15>(subscribe: (callback: () => void) => () => void, getSnapshot: () => T_15, getServerSnapshot?: (() => T_15) | undefined) => T_15;
-    useActionState: <T_16>(fn: Function, initialState: T_16, permalink?: string | undefined) => [T_16, Function];
-    useOptimistic: <T_17, N>(state: T_17, updateState: (currentState: T_17, action: N) => T_17) => [T_17, (action: N) => 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;
+    createRef: <T>() => import("./hooks").RefObject<T>;
+    forwardRef: <T, P = {}>(Component: (props: P, ref?: import("./hooks").RefObject<T>) => import("./base").JSX.Element) => ((props: P & {
+        ref?: import("./hooks").RefObject<T>;
+    }) => import("./base").JSX.Element);
+    useImperativeHandle: <T>(ref: import("./hooks").RefObject<T>, createHandle: () => T, deps: readonly unknown[]) => void;
+    useSyncExternalStore: <T>(subscribe: (callback: () => void) => () => void, getSnapshot: () => T, getServerSnapshot?: () => T) => T;
+    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: import("./base").FC<import("./types").PropsWithChildren<{
         fallback: any;
     }>>;

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

@@ -31,8 +31,8 @@ import type { MiddlewareHandler } from '../../types';
  */
 export declare const cache: (options: {
     cacheName: string | ((c: Context) => Promise<string> | string);
-    wait?: boolean | undefined;
-    cacheControl?: string | undefined;
-    vary?: string | string[] | undefined;
-    keyGenerator?: ((c: Context) => Promise<string> | string) | undefined;
+    wait?: boolean;
+    cacheControl?: string;
+    vary?: string | string[];
+    keyGenerator?: (c: Context) => Promise<string> | string;
 }) => MiddlewareHandler;

package/dist/types/middleware/context-storage/index.d.ts

@@ -36,4 +36,4 @@ import type { Env, MiddlewareHandler } from '../../types';
  * ```
  */
 export declare const contextStorage: () => MiddlewareHandler;
-export declare const getContext: <E extends Env = Env>() => Context<E, any, {}>;
+export declare const getContext: <E extends Env = Env>() => Context<E>;

package/dist/types/middleware/ip-restriction/index.d.ts

@@ -24,8 +24,8 @@ export interface IPRestrictionRules {
  *
  * @param getIP function to get IP Address
  */
-export declare const ipRestriction: (getIP: GetIPAddr, { denyList, allowList }: IPRestrictionRules, onError?: ((remote: {
+export declare const ipRestriction: (getIP: GetIPAddr, { denyList, allowList }: IPRestrictionRules, onError?: (remote: {
     addr: string;
     type: AddressType;
-}, c: Context) => Response | Promise<Response>) | undefined) => MiddlewareHandler;
+}, c: Context) => Response | Promise<Response>) => MiddlewareHandler;
 export {};

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

@@ -46,9 +46,9 @@ export declare const jwt: (options: {
     };
     alg?: SignatureAlgorithm;
 }) => MiddlewareHandler;
-export declare const verify: (token: string, publicKey: SignatureKey, alg?: "HS256" | "HS384" | "HS512" | "RS256" | "RS384" | "RS512" | "PS256" | "PS384" | "PS512" | "ES256" | "ES384" | "ES512" | "EdDSA") => Promise<import("../../utils/jwt/types").JWTPayload>;
+export declare const verify: (token: string, publicKey: SignatureKey, alg?: SignatureAlgorithm) => Promise<import("../../utils/jwt/types").JWTPayload>;
 export declare const decode: (token: string) => {
     header: import("../../utils/jwt/jwt").TokenHeader;
     payload: import("../../utils/jwt/types").JWTPayload;
 };
-export declare const sign: (payload: import("../../utils/jwt/types").JWTPayload, privateKey: SignatureKey, alg?: "HS256" | "HS384" | "HS512" | "RS256" | "RS384" | "RS512" | "PS256" | "PS384" | "PS512" | "ES256" | "ES384" | "ES512" | "EdDSA") => Promise<string>;
+export declare const sign: (payload: import("../../utils/jwt/types").JWTPayload, privateKey: SignatureKey, alg?: SignatureAlgorithm) => Promise<string>;

package/dist/types/middleware/serve-static/index.d.ts

@@ -17,7 +17,7 @@ export type ServeStaticOptions<E extends Env = Env> = {
  * This middleware is not directly used by the user. Create a wrapper specifying `getContent()` by the environment such as Deno or Bun.
  */
 export declare const serveStatic: <E extends Env = Env>(options: ServeStaticOptions<E> & {
-    getContent: (path: string, c: Context<E, any, {}>) => Promise<Data | Response | null>;
-    pathResolve?: ((path: string) => string) | undefined;
-    isDir?: ((path: string) => boolean | undefined | Promise<boolean | undefined>) | undefined;
+    getContent: (path: string, c: Context<E>) => Promise<Data | Response | null>;
+    pathResolve?: (path: string) => string;
+    isDir?: (path: string) => boolean | undefined | Promise<boolean | undefined>;
 }) => MiddlewareHandler;

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

@@ -6,6 +6,6 @@ export interface Pool {
     run<T>(fn: () => T): Promise<T>;
 }
 export declare const createPool: ({ concurrency, interval, }?: {
-    concurrency?: number | undefined;
-    interval?: number | undefined;
+    concurrency?: number;
+    interval?: number;
 }) => Pool;

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

@@ -35,6 +35,6 @@ export type CookiePrefixOptions = 'host' | 'secure';
 export type CookieConstraint<Name> = Name extends `__Secure-${string}` ? CookieOptions & SecureCookieConstraint : Name extends `__Host-${string}` ? CookieOptions & HostCookieConstraint : CookieOptions;
 export declare const parse: (cookie: string, name?: string) => Cookie;
 export declare const parseSigned: (cookie: string, secret: string | BufferSource, name?: string) => Promise<SignedCookie>;
-export declare const serialize: <Name extends string>(name: Name, value: string, opt?: CookieConstraint<Name> | undefined) => string;
+export declare const serialize: <Name extends string>(name: Name, value: string, opt?: CookieConstraint<Name>) => string;
 export declare const serializeSigned: (name: string, value: string, secret: string | BufferSource, opt?: CookieOptions) => Promise<string>;
 export {};

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

@@ -8,5 +8,5 @@ type FilePathOptions = {
     defaultDocument?: string;
 };
 export declare const getFilePath: (options: FilePathOptions) => string | undefined;
-export declare const getFilePathWithoutDefaultDocument: (options: Omit<FilePathOptions, 'defaultDocument'>) => string | undefined;
+export declare const getFilePathWithoutDefaultDocument: (options: Omit<FilePathOptions, "defaultDocument">) => string | undefined;
 export {};

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

@@ -3,8 +3,8 @@
  * JWT utility.
  */
 export declare const Jwt: {
-    sign: (payload: import("./types").JWTPayload, privateKey: import("./jws").SignatureKey, alg?: "HS256" | "HS384" | "HS512" | "RS256" | "RS384" | "RS512" | "PS256" | "PS384" | "PS512" | "ES256" | "ES384" | "ES512" | "EdDSA") => Promise<string>;
-    verify: (token: string, publicKey: import("./jws").SignatureKey, alg?: "HS256" | "HS384" | "HS512" | "RS256" | "RS384" | "RS512" | "PS256" | "PS384" | "PS512" | "ES256" | "ES384" | "ES512" | "EdDSA") => Promise<import("./types").JWTPayload>;
+    sign: (payload: import("./types").JWTPayload, privateKey: import("./jws").SignatureKey, alg?: import("./jwa").SignatureAlgorithm) => Promise<string>;
+    verify: (token: string, publicKey: import("./jws").SignatureKey, alg?: import("./jwa").SignatureAlgorithm) => Promise<import("./types").JWTPayload>;
     decode: (token: string) => {
         header: import("./jwt").TokenHeader;
         payload: import("./types").JWTPayload;

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

@@ -6,9 +6,9 @@ export type ValidationFunction<InputType, OutputType, E extends Env = {}, P exte
 type ExcludeResponseType<T> = T extends Response & TypedResponse<any> ? never : T;
 export declare const validator: <InputType, P extends string, M extends string, U extends ValidationTargetByMethod<M>, OutputType = ValidationTargets[U], OutputTypeExcludeResponseType = ExcludeResponseType<OutputType>, P2 extends string = P, V extends {
     in: { [K in U]: K extends "json" ? unknown extends InputType ? OutputTypeExcludeResponseType : InputType : { [K2 in keyof OutputTypeExcludeResponseType]: ValidationTargets[K][K2]; }; };
-    out: { [K_1 in U]: OutputTypeExcludeResponseType; };
+    out: { [K in U]: OutputTypeExcludeResponseType; };
 } = {
-    in: { [K_2 in U]: K_2 extends "json" ? unknown extends InputType ? OutputTypeExcludeResponseType : InputType : { [K2_1 in keyof OutputTypeExcludeResponseType]: ValidationTargets[K_2][K2_1]; }; };
-    out: { [K_3 in U]: OutputTypeExcludeResponseType; };
+    in: { [K in U]: K extends "json" ? unknown extends InputType ? OutputTypeExcludeResponseType : InputType : { [K2 in keyof OutputTypeExcludeResponseType]: ValidationTargets[K][K2]; }; };
+    out: { [K in U]: OutputTypeExcludeResponseType; };
 }, E extends Env = any>(target: U, validationFunc: ValidationFunction<unknown extends InputType ? ValidationTargets[U] : InputType, OutputType, E, P2>) => MiddlewareHandler<E, P, V>;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hono",
-  "version": "4.6.3",
+  "version": "4.6.4",
   "description": "Web framework built on Web Standards",
   "main": "dist/cjs/index.js",
   "type": "module",
@@ -618,16 +618,14 @@
     "nodejs"
   ],
   "devDependencies": {
-    "@hono/eslint-config": "^1.0.1",
+    "@hono/eslint-config": "^1.0.2",
     "@hono/node-server": "^1.8.2",
-    "@types/crypto-js": "^4.1.1",
     "@types/glob": "^8.0.0",
     "@types/jsdom": "^21.1.4",
     "@types/node": "20.11.4",
     "@types/supertest": "^2.0.12",
     "@vitest/coverage-v8": "^2.0.5",
     "arg": "^5.0.2",
-    "crypto-js": "^4.1.1",
     "esbuild": "^0.15.12",
     "eslint": "^9.10.0",
     "glob": "7.2.3",
@@ -640,7 +638,7 @@
     "typescript": "^5.3.3",
     "vite-plugin-fastly-js-compute": "^0.4.2",
     "vitest": "^2.0.5",
-    "wrangler": "^3.58.0",
+    "wrangler": "3.58.0",
     "ws": "^8.17.0",
     "zod": "^3.20.2"
   },