hono 4.6.2 → 4.6.4

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: (value: T_11) => 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: (value: T_11) => 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: (value: T) => 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: (value: T_15) => 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/jsx/jsx-runtime.d.ts

@@ -8,5 +8,5 @@ export type { JSX } from './jsx-dev-runtime';
 import { html } from '../helper/html';
 import type { HtmlEscapedString } from '../utils/html';
 export { html as jsxTemplate };
-export declare const jsxAttr: (name: string, value: string | Promise<string>) => HtmlEscapedString | Promise<HtmlEscapedString>;
+export declare const jsxAttr: (key: string, v: string | Promise<string> | Record<string, string | number | null | undefined | boolean>) => HtmlEscapedString | Promise<HtmlEscapedString>;
 export declare const jsxEscape: (value: string) => string;

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

@@ -3,6 +3,7 @@
  * This module enables JSX to supports streaming Response.
  */
 import type { HtmlEscapedString } from '../utils/html';
+import { JSXNode } from './base';
 import type { FC, PropsWithChildren } from './';
 /**
  * @experimental
@@ -17,4 +18,4 @@ export declare const Suspense: FC<PropsWithChildren<{
  * `renderToReadableStream()` is an experimental feature.
  * The API might be changed.
  */
-export declare const renderToReadableStream: (str: HtmlEscapedString | Promise<HtmlEscapedString>, onError?: (e: unknown) => string | void) => ReadableStream<Uint8Array>;
+export declare const renderToReadableStream: (content: HtmlEscapedString | JSXNode | Promise<HtmlEscapedString>, onError?: (e: unknown) => string | void) => ReadableStream<Uint8Array>;

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

@@ -7,8 +7,8 @@ import type { CookiePrefixOptions } from '../../utils/cookie';
 import '../../context';
 import type { SignatureAlgorithm } from '../../utils/jwt/jwa';
 import type { SignatureKey } from '../../utils/jwt/jws';
-export type JwtVariables = {
-    jwtPayload: any;
+export type JwtVariables<T = any> = {
+    jwtPayload: T;
 };
 /**
  * JWT Auth Middleware for Hono.
@@ -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/secure-headers/secure-headers.d.ts

@@ -51,6 +51,7 @@ type PermissionsPolicyOptions = Partial<Record<PermissionsPolicyDirective, Permi
 type overridableHeader = boolean | string;
 interface SecureHeadersOptions {
     contentSecurityPolicy?: ContentSecurityPolicyOptions;
+    contentSecurityPolicyReportOnly?: ContentSecurityPolicyOptions;
     crossOriginEmbedderPolicy?: overridableHeader;
     crossOriginResourcePolicy?: overridableHeader;
     crossOriginOpenerPolicy?: overridableHeader;
@@ -76,6 +77,7 @@ export declare const NONCE: ContentSecurityPolicyOptionHandler;
  *
  * @param {Partial<SecureHeadersOptions>} [customOptions] - The options for the secure headers middleware.
  * @param {ContentSecurityPolicyOptions} [customOptions.contentSecurityPolicy] - Settings for the Content-Security-Policy header.
+ * @param {ContentSecurityPolicyOptions} [customOptions.contentSecurityPolicyReportOnly] - Settings for the Content-Security-Policy-Report-Only header.
  * @param {overridableHeader} [customOptions.crossOriginEmbedderPolicy=false] - Settings for the Cross-Origin-Embedder-Policy header.
  * @param {overridableHeader} [customOptions.crossOriginResourcePolicy=true] - Settings for the Cross-Origin-Resource-Policy header.
  * @param {overridableHeader} [customOptions.crossOriginOpenerPolicy=true] - Settings for the Cross-Origin-Opener-Policy header.

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;