hono 4.4.10 → 4.4.12

package/dist/types/middleware/trailing-slash/index.d.ts

@@ -6,7 +6,7 @@ import type { MiddlewareHandler } from '../../types';
 /**
  * Trailing Slash Middleware for Hono.
  *
- * @see {@link https://hono.dev/middleware/builtin/trailing-slash}
+ * @see {@link https://hono.dev/docs/middleware/builtin/trailing-slash}
  *
  * @returns {MiddlewareHandler} The middleware handler function.
  *
@@ -23,7 +23,7 @@ export declare const trimTrailingSlash: () => MiddlewareHandler;
  * Append trailing slash middleware for Hono.
  * Append a trailing slash to the URL if it doesn't have one. For example, `/path/to/page` will be redirected to `/path/to/page/`.
  *
- * @see {@link https://hono.dev/middleware/builtin/trailing-slash}
+ * @see {@link https://hono.dev/docs/middleware/builtin/trailing-slash}
  *
  * @returns {MiddlewareHandler} The middleware handler function.
  *

package/dist/types/request.d.ts

@@ -17,7 +17,7 @@ export declare class HonoRequest<P extends string = '/', I extends Input['out']
     /**
      * `.raw` can get the raw Request object.
      *
-     * @see {@link https://hono.dev/api/request#raw}
+     * @see {@link https://hono.dev/docs/api/request#raw}
      *
      * @example
      * ```ts
@@ -33,7 +33,7 @@ export declare class HonoRequest<P extends string = '/', I extends Input['out']
     /**
      * `.path` can get the pathname of the request.
      *
-     * @see {@link https://hono.dev/api/request#path}
+     * @see {@link https://hono.dev/docs/api/request#path}
      *
      * @example
      * ```ts
@@ -48,7 +48,7 @@ export declare class HonoRequest<P extends string = '/', I extends Input['out']
     /**
      * `.req.param()` gets the path parameters.
      *
-     * @see {@link https://hono.dev/api/routing#path-parameter}
+     * @see {@link https://hono.dev/docs/api/routing#path-parameter}
      *
      * @example
      * ```ts
@@ -67,7 +67,7 @@ export declare class HonoRequest<P extends string = '/', I extends Input['out']
     /**
      * `.query()` can get querystring parameters.
      *
-     * @see {@link https://hono.dev/api/request#query}
+     * @see {@link https://hono.dev/docs/api/request#query}
      *
      * @example
      * ```ts
@@ -87,7 +87,7 @@ export declare class HonoRequest<P extends string = '/', I extends Input['out']
     /**
      * `.queries()` can get multiple querystring parameter values, e.g. /search?tags=A&tags=B
      *
-     * @see {@link https://hono.dev/api/request#queries}
+     * @see {@link https://hono.dev/docs/api/request#queries}
      *
      * @example
      * ```ts
@@ -102,7 +102,7 @@ export declare class HonoRequest<P extends string = '/', I extends Input['out']
     /**
      * `.header()` can get the request header value.
      *
-     * @see {@link https://hono.dev/api/request#header}
+     * @see {@link https://hono.dev/docs/api/request#header}
      *
      * @example
      * ```ts
@@ -116,7 +116,7 @@ export declare class HonoRequest<P extends string = '/', I extends Input['out']
     /**
      * `.parseBody()` can parse Request body of type `multipart/form-data` or `application/x-www-form-urlencoded`
      *
-     * @see {@link https://hono.dev/api/request#parsebody}
+     * @see {@link https://hono.dev/docs/api/request#parsebody}
      *
      * @example
      * ```ts
@@ -131,7 +131,7 @@ export declare class HonoRequest<P extends string = '/', I extends Input['out']
     /**
      * `.json()` can parse Request body of type `application/json`
      *
-     * @see {@link https://hono.dev/api/request#json}
+     * @see {@link https://hono.dev/docs/api/request#json}
      *
      * @example
      * ```ts
@@ -144,7 +144,7 @@ export declare class HonoRequest<P extends string = '/', I extends Input['out']
     /**
      * `.text()` can parse Request body of type `text/plain`
      *
-     * @see {@link https://hono.dev/api/request#text}
+     * @see {@link https://hono.dev/docs/api/request#text}
      *
      * @example
      * ```ts
@@ -157,7 +157,7 @@ export declare class HonoRequest<P extends string = '/', I extends Input['out']
     /**
      * `.arrayBuffer()` parse Request body as an `ArrayBuffer`
      *
-     * @see {@link https://hono.dev/api/request#arraybuffer}
+     * @see {@link https://hono.dev/docs/api/request#arraybuffer}
      *
      * @example
      * ```ts
@@ -175,7 +175,7 @@ export declare class HonoRequest<P extends string = '/', I extends Input['out']
      *   const body = await c.req.blob();
      * });
      * ```
-     * @see https://hono.dev/api/request#blob
+     * @see https://hono.dev/docs/api/request#blob
      */
     blob(): Promise<Blob>;
     /**
@@ -186,7 +186,7 @@ export declare class HonoRequest<P extends string = '/', I extends Input['out']
      *   const body = await c.req.formData();
      * });
      * ```
-     * @see https://hono.dev/api/request#formdata
+     * @see https://hono.dev/docs/api/request#formdata
      */
     formData(): Promise<FormData>;
     /**
@@ -202,13 +202,13 @@ export declare class HonoRequest<P extends string = '/', I extends Input['out']
      * @param target - The target of the validation.
      * @returns The validated data.
      *
-     * @see https://hono.dev/api/request#valid
+     * @see https://hono.dev/docs/api/request#valid
      */
     valid<T extends keyof I & keyof ValidationTargets>(target: T): InputToDataByTarget<I, T>;
     /**
      * `.url()` can get the request url strings.
      *
-     * @see {@link https://hono.dev/api/request#url}
+     * @see {@link https://hono.dev/docs/api/request#url}
      *
      * @example
      * ```ts
@@ -222,7 +222,7 @@ export declare class HonoRequest<P extends string = '/', I extends Input['out']
     /**
      * `.method()` can get the method name of the request.
      *
-     * @see {@link https://hono.dev/api/request#method}
+     * @see {@link https://hono.dev/docs/api/request#method}
      *
      * @example
      * ```ts
@@ -235,7 +235,7 @@ export declare class HonoRequest<P extends string = '/', I extends Input['out']
     /**
      * `.matchedRoutes()` can return a matched route in the handler
      *
-     * @see {@link https://hono.dev/api/request#matchedroutes}
+     * @see {@link https://hono.dev/docs/api/request#matchedroutes}
      *
      * @example
      * ```ts
@@ -259,7 +259,7 @@ export declare class HonoRequest<P extends string = '/', I extends Input['out']
     /**
      * `routePath()` can retrieve the path registered within the handler
      *
-     * @see {@link https://hono.dev/api/request#routepath}
+     * @see {@link https://hono.dev/docs/api/request#routepath}
      *
      * @example
      * ```ts

package/dist/types/types.d.ts

@@ -38,26 +38,19 @@ export interface HTTPResponseError extends Error {
 export type ErrorHandler<E extends Env = any> = (err: Error | HTTPResponseError, c: Context<E>) => Response | Promise<Response>;
 export interface HandlerInterface<E extends Env = Env, M extends string = string, S extends Schema = BlankSchema, BasePath extends string = '/'> {
     <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, I extends Input = BlankInput, R extends HandlerResponse<any> = any, E2 extends Env = E>(handler: H<E2, P, I, R>): Hono<IntersectNonAnyTypes<[E, E2]>, S & ToSchema<M, P, I, MergeTypedResponse<R>>, BasePath>;
-    <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, E2 extends Env = E>(path: P, handler: H<E2, MergedPath, I, R>): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I, MergeTypedResponse<R>>, BasePath>;
     <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, I extends Input = BlankInput, I2 extends Input = I, R extends HandlerResponse<any> = any, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>>(...handlers: [H<E2, P, I>, H<E3, P, I2, R>]): Hono<IntersectNonAnyTypes<[E, E2, E3]>, S & ToSchema<M, P, I2, MergeTypedResponse<R>>, BasePath>;
-    <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>>(path: P, ...handlers: [H<E2, MergedPath, I>, H<E3, MergedPath, I2, R>]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I2, MergeTypedResponse<R>>, BasePath>;
+    <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, E2 extends Env = E>(path: P, handler: H<E2, MergedPath, I, R>): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I, MergeTypedResponse<R>>, BasePath>;
     <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, E2 extends Env = E, E3 extends Env = E, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>>(...handlers: [H<E2, P, I>, H<E3, P, I2>, H<E4, P, I3, R>]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4]>, S & ToSchema<M, P, I3, MergeTypedResponse<R>>, BasePath>;
-    <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, E2 extends Env = E, E3 extends Env = E, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>>(path: P, ...handlers: [H<E2, MergedPath, I>, H<E3, MergedPath, I2>, H<E4, MergedPath, I3, R>]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I3, MergeTypedResponse<R>>, BasePath>;
+    <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>>(path: P, ...handlers: [H<E2, MergedPath, I>, H<E3, MergedPath, I2, R>]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I2, MergeTypedResponse<R>>, BasePath>;
     <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>>(...handlers: [H<E2, P, I>, H<E3, P, I2>, H<E4, P, I3>, H<E5, P, I4, R>]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, S & ToSchema<M, P, I4, MergeTypedResponse<R>>, BasePath>;
+    <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, E2 extends Env = E, E3 extends Env = E, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>>(path: P, ...handlers: [H<E2, MergedPath, I>, H<E3, MergedPath, I2>, H<E4, MergedPath, I3, R>]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I3, MergeTypedResponse<R>>, BasePath>;
+    <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>>(...handlers: [H<E2, P, I>, H<E3, P, I2>, H<E4, P, I3>, H<E5, P, I4>, H<E6, P, I5, R>]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, S & ToSchema<M, P, I5, MergeTypedResponse<R>>, BasePath>;
     <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>>(path: P, ...handlers: [
         H<E2, MergedPath, I>,
         H<E3, MergedPath, I2>,
         H<E4, MergedPath, I3>,
         H<E5, MergedPath, I4, R>
     ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I4, MergeTypedResponse<R>>, BasePath>;
-    <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>>(...handlers: [H<E2, P, I>, H<E3, P, I2>, H<E4, P, I3>, H<E5, P, I4>, H<E6, P, I5, R>]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, S & ToSchema<M, P, I5, MergeTypedResponse<R>>, BasePath>;
-    <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>>(path: P, ...handlers: [
-        H<E2, MergedPath, I>,
-        H<E3, MergedPath, I2>,
-        H<E4, MergedPath, I3>,
-        H<E5, MergedPath, I4>,
-        H<E6, MergedPath, I5, R>
-    ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I5, MergeTypedResponse<R>>, BasePath>;
     <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>>(...handlers: [
         H<E2, P, I>,
         H<E3, P, I2>,
@@ -66,14 +59,13 @@ export interface HandlerInterface<E extends Env = Env, M extends string = string
         H<E6, P, I5>,
         H<E7, P, I6, R>
     ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, S & ToSchema<M, P, I6, MergeTypedResponse<R>>, BasePath>;
-    <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>>(path: P, ...handlers: [
+    <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>>(path: P, ...handlers: [
         H<E2, MergedPath, I>,
         H<E3, MergedPath, I2>,
         H<E4, MergedPath, I3>,
         H<E5, MergedPath, I4>,
-        H<E6, MergedPath, I5>,
-        H<E7, MergedPath, I6, R>
-    ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I6, MergeTypedResponse<R>>, BasePath>;
+        H<E6, MergedPath, I5, R>
+    ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I5, MergeTypedResponse<R>>, BasePath>;
     <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>>(...handlers: [
         H<E2, P, I>,
         H<E3, P, I2>,
@@ -83,15 +75,14 @@ export interface HandlerInterface<E extends Env = Env, M extends string = string
         H<E7, P, I6>,
         H<E8, P, I7, R>
     ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, S & ToSchema<M, P, I7, MergeTypedResponse<R>>, BasePath>;
-    <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>>(path: P, ...handlers: [
+    <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>>(path: P, ...handlers: [
         H<E2, MergedPath, I>,
         H<E3, MergedPath, I2>,
         H<E4, MergedPath, I3>,
         H<E5, MergedPath, I4>,
         H<E6, MergedPath, I5>,
-        H<E7, MergedPath, I6>,
-        H<E8, MergedPath, I7, R>
-    ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I7, MergeTypedResponse<R>>, BasePath>;
+        H<E7, MergedPath, I6, R>
+    ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I6, MergeTypedResponse<R>>, BasePath>;
     <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>>(...handlers: [
         H<E2, P, I>,
         H<E3, P, I2>,
@@ -102,16 +93,15 @@ export interface HandlerInterface<E extends Env = Env, M extends string = string
         H<E8, P, I7>,
         H<E9, P, I8, R>
     ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>, S & ToSchema<M, P, I8, MergeTypedResponse<R>>, BasePath>;
-    <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>>(path: P, ...handlers: [
+    <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>>(path: P, ...handlers: [
         H<E2, MergedPath, I>,
         H<E3, MergedPath, I2>,
         H<E4, MergedPath, I3>,
         H<E5, MergedPath, I4>,
         H<E6, MergedPath, I5>,
         H<E7, MergedPath, I6>,
-        H<E8, MergedPath, I7>,
-        H<E9, MergedPath, I8, R>
-    ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I8, MergeTypedResponse<R>>, BasePath>;
+        H<E8, MergedPath, I7, R>
+    ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I7, MergeTypedResponse<R>>, BasePath>;
     <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, I9 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = E, E10 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>>(...handlers: [
         H<E2, P, I>,
         H<E3, P, I2>,
@@ -123,7 +113,7 @@ export interface HandlerInterface<E extends Env = Env, M extends string = string
         H<E9, P, I8>,
         H<E10, P, I9, R>
     ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10]>, S & ToSchema<M, P, I9, MergeTypedResponse<R>>, BasePath>;
-    <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, I9 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = E, E10 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>>(path: P, ...handlers: [
+    <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>>(path: P, ...handlers: [
         H<E2, MergedPath, I>,
         H<E3, MergedPath, I2>,
         H<E4, MergedPath, I3>,
@@ -131,9 +121,8 @@ export interface HandlerInterface<E extends Env = Env, M extends string = string
         H<E6, MergedPath, I5>,
         H<E7, MergedPath, I6>,
         H<E8, MergedPath, I7>,
-        H<E9, MergedPath, I8>,
-        H<E10, MergedPath, I9, R>
-    ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I9, MergeTypedResponse<R>>, BasePath>;
+        H<E9, MergedPath, I8, R>
+    ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I8, MergeTypedResponse<R>>, BasePath>;
     <P extends string = ExtractKey<S> extends never ? BasePath : ExtractKey<S>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, I9 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8, I10 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8 & I9, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = E, E10 extends Env = E, E11 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10]>>(...handlers: [
         H<E2, P, I>,
         H<E3, P, I2>,
@@ -146,6 +135,17 @@ export interface HandlerInterface<E extends Env = Env, M extends string = string
         H<E10, P, I9>,
         H<E11, P, I10, R>
     ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11]>, S & ToSchema<M, P, I10, MergeTypedResponse<R>>, BasePath>;
+    <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, I9 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = E, E10 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>>(path: P, ...handlers: [
+        H<E2, MergedPath, I>,
+        H<E3, MergedPath, I2>,
+        H<E4, MergedPath, I3>,
+        H<E5, MergedPath, I4>,
+        H<E6, MergedPath, I5>,
+        H<E7, MergedPath, I6>,
+        H<E8, MergedPath, I7>,
+        H<E9, MergedPath, I8>,
+        H<E10, MergedPath, I9, R>
+    ]): Hono<E, S & ToSchema<M, MergePath<BasePath, P>, I9, MergeTypedResponse<R>>, BasePath>;
     <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, R extends HandlerResponse<any> = any, I extends Input = BlankInput, I2 extends Input = I, I3 extends Input = I & I2, I4 extends Input = I & I2 & I3, I5 extends Input = I & I2 & I3 & I4, I6 extends Input = I & I2 & I3 & I4 & I5, I7 extends Input = I & I2 & I3 & I4 & I5 & I6, I8 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7, I9 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8, I10 extends Input = I & I2 & I3 & I4 & I5 & I6 & I7 & I8 & I9, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = E, E10 extends Env = E, E11 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10]>>(path: P, ...handlers: [
         H<E2, MergedPath, I>,
         H<E3, MergedPath, I2>,
@@ -166,13 +166,16 @@ export interface MiddlewareHandlerInterface<E extends Env = Env, S extends Schem
     <E2 extends Env = E>(...handlers: MiddlewareHandler<E2, MergePath<BasePath, ExtractKey<S>>>[]): Hono<IntersectNonAnyTypes<[E, E2]>, S, BasePath>;
     <E2 extends Env = E>(handler: MiddlewareHandler<E2, MergePath<BasePath, ExtractKey<S>>>): Hono<IntersectNonAnyTypes<[E, E2]>, S, BasePath>;
     <E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>, P extends string = MergePath<BasePath, ExtractKey<S>>>(...handlers: [MiddlewareHandler<E2, P>, MiddlewareHandler<E3, P>]): Hono<IntersectNonAnyTypes<[E, E2, E3]>, S, BasePath>;
+    <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, E2 extends Env = E>(path: P, handler: MiddlewareHandler<E2, MergedPath>): Hono<IntersectNonAnyTypes<[E, E2]>, ChangePathOfSchema<S, MergedPath>, BasePath>;
     <E2 extends Env = E, E3 extends Env = E, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>, P extends string = MergePath<BasePath, ExtractKey<S>>>(...handlers: [MiddlewareHandler<E2, P>, MiddlewareHandler<E3, P>, MiddlewareHandler<E4, P>]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4]>, S, BasePath>;
+    <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, E2 extends Env = E, E3 extends Env = IntersectNonAnyTypes<[E, E2]>>(path: P, ...handlers: [MiddlewareHandler<E2, P>, MiddlewareHandler<E3, P>]): Hono<IntersectNonAnyTypes<[E, E2, E3]>, ChangePathOfSchema<S, MergedPath>, BasePath>;
     <E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>, P extends string = MergePath<BasePath, ExtractKey<S>>>(...handlers: [
         MiddlewareHandler<E2, P>,
         MiddlewareHandler<E3, P>,
         MiddlewareHandler<E4, P>,
         MiddlewareHandler<E5, P>
     ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, S, BasePath>;
+    <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, E2 extends Env = E, E3 extends Env = E, E4 extends Env = IntersectNonAnyTypes<[E, E2, E3]>>(path: P, ...handlers: [MiddlewareHandler<E2, P>, MiddlewareHandler<E3, P>, MiddlewareHandler<E4, P>]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4]>, ChangePathOfSchema<S, MergedPath>, BasePath>;
     <E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, P extends string = MergePath<BasePath, ExtractKey<S>>>(...handlers: [
         MiddlewareHandler<E2, P>,
         MiddlewareHandler<E3, P>,
@@ -180,6 +183,12 @@ export interface MiddlewareHandlerInterface<E extends Env = Env, S extends Schem
         MiddlewareHandler<E5, P>,
         MiddlewareHandler<E6, P>
     ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, S, BasePath>;
+    <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4]>>(path: P, ...handlers: [
+        MiddlewareHandler<E2, P>,
+        MiddlewareHandler<E3, P>,
+        MiddlewareHandler<E4, P>,
+        MiddlewareHandler<E5, P>
+    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5]>, ChangePathOfSchema<S, MergedPath>, BasePath>;
     <E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, P extends string = MergePath<BasePath, ExtractKey<S>>>(...handlers: [
         MiddlewareHandler<E2, P>,
         MiddlewareHandler<E3, P>,
@@ -188,6 +197,13 @@ export interface MiddlewareHandlerInterface<E extends Env = Env, S extends Schem
         MiddlewareHandler<E6, P>,
         MiddlewareHandler<E7, P>
     ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, S, BasePath>;
+    <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5]>>(path: P, ...handlers: [
+        MiddlewareHandler<E2, P>,
+        MiddlewareHandler<E3, P>,
+        MiddlewareHandler<E4, P>,
+        MiddlewareHandler<E5, P>,
+        MiddlewareHandler<E6, P>
+    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>, ChangePathOfSchema<S, MergedPath>, BasePath>;
     <E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, P extends string = MergePath<BasePath, ExtractKey<S>>>(...handlers: [
         MiddlewareHandler<E2, P>,
         MiddlewareHandler<E3, P>,
@@ -197,6 +213,14 @@ export interface MiddlewareHandlerInterface<E extends Env = Env, S extends Schem
         MiddlewareHandler<E7, P>,
         MiddlewareHandler<E8, P>
     ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, S, BasePath>;
+    <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6]>>(path: P, ...handlers: [
+        MiddlewareHandler<E2, P>,
+        MiddlewareHandler<E3, P>,
+        MiddlewareHandler<E4, P>,
+        MiddlewareHandler<E5, P>,
+        MiddlewareHandler<E6, P>,
+        MiddlewareHandler<E7, P>
+    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>, ChangePathOfSchema<S, MergedPath>, BasePath>;
     <E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, P extends string = MergePath<BasePath, ExtractKey<S>>>(...handlers: [
         MiddlewareHandler<E2, P>,
         MiddlewareHandler<E3, P>,
@@ -207,6 +231,15 @@ export interface MiddlewareHandlerInterface<E extends Env = Env, S extends Schem
         MiddlewareHandler<E8, P>,
         MiddlewareHandler<E9, P>
     ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>, S, BasePath>;
+    <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7]>>(path: P, ...handlers: [
+        MiddlewareHandler<E2, P>,
+        MiddlewareHandler<E3, P>,
+        MiddlewareHandler<E4, P>,
+        MiddlewareHandler<E5, P>,
+        MiddlewareHandler<E6, P>,
+        MiddlewareHandler<E7, P>,
+        MiddlewareHandler<E8, P>
+    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>, ChangePathOfSchema<S, MergedPath>, BasePath>;
     <E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = E, E10 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>, P extends string = MergePath<BasePath, ExtractKey<S>>>(...handlers: [
         MiddlewareHandler<E2, P>,
         MiddlewareHandler<E3, P>,
@@ -218,6 +251,16 @@ export interface MiddlewareHandlerInterface<E extends Env = Env, S extends Schem
         MiddlewareHandler<E9, P>,
         MiddlewareHandler<E10, P>
     ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10]>, S, BasePath>;
+    <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8]>>(path: P, ...handlers: [
+        MiddlewareHandler<E2, P>,
+        MiddlewareHandler<E3, P>,
+        MiddlewareHandler<E4, P>,
+        MiddlewareHandler<E5, P>,
+        MiddlewareHandler<E6, P>,
+        MiddlewareHandler<E7, P>,
+        MiddlewareHandler<E8, P>,
+        MiddlewareHandler<E9, P>
+    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>, ChangePathOfSchema<S, MergedPath>, BasePath>;
     <E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = E, E10 extends Env = E, E11 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10]>, P extends string = MergePath<BasePath, ExtractKey<S>>>(...handlers: [
         MiddlewareHandler<E2, P>,
         MiddlewareHandler<E3, P>,
@@ -230,6 +273,17 @@ export interface MiddlewareHandlerInterface<E extends Env = Env, S extends Schem
         MiddlewareHandler<E10, P>,
         MiddlewareHandler<E11, P>
     ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11]>, S, BasePath>;
+    <P extends string, MergedPath extends MergePath<BasePath, P> = MergePath<BasePath, P>, E2 extends Env = E, E3 extends Env = E, E4 extends Env = E, E5 extends Env = E, E6 extends Env = E, E7 extends Env = E, E8 extends Env = E, E9 extends Env = E, E10 extends Env = IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9]>>(path: P, ...handlers: [
+        MiddlewareHandler<E2, P>,
+        MiddlewareHandler<E3, P>,
+        MiddlewareHandler<E4, P>,
+        MiddlewareHandler<E5, P>,
+        MiddlewareHandler<E6, P>,
+        MiddlewareHandler<E7, P>,
+        MiddlewareHandler<E8, P>,
+        MiddlewareHandler<E9, P>,
+        MiddlewareHandler<E10, P>
+    ]): Hono<IntersectNonAnyTypes<[E, E2, E3, E4, E5, E6, E7, E8, E9, E10]>, ChangePathOfSchema<S, MergedPath>, BasePath>;
     <P extends string, E2 extends Env = E>(path: P, ...handlers: MiddlewareHandler<E2, MergePath<BasePath, P>>[]): Hono<E, S, BasePath>;
 }
 export interface OnHandlerInterface<E extends Env = Env, S extends Schema = BlankSchema, BasePath extends string = '/'> {
@@ -398,6 +452,11 @@ export type Schema = {
         [Method: `$${Lowercase<string>}`]: Endpoint;
     };
 };
+type ChangePathOfSchema<S extends Schema, Path extends string> = keyof S extends never ? {
+    [K in Path]: never;
+} : {
+    [K in keyof S as Path]: S[K];
+};
 export type Endpoint = {
     input: Partial<ValidationTargets>;
     output: any;

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

@@ -1,3 +1,8 @@
+/**
+ * @module
+ * JSON Web Algorithms (JWA)
+ * https://datatracker.ietf.org/doc/html/rfc7518
+ */
 export declare enum AlgorithmTypes {
     HS256 = "HS256",
     HS384 = "HS384",

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

@@ -1,3 +1,8 @@
+/**
+ * @module
+ * JSON Web Signature (JWS)
+ * https://datatracker.ietf.org/doc/html/rfc7515
+ */
 import type { SignatureAlgorithm } from './jwa';
 export type SignatureKey = string | JsonWebKey | CryptoKey;
 export declare function signing(privateKey: SignatureKey, alg: SignatureAlgorithm, data: BufferSource): Promise<ArrayBuffer>;

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

@@ -1,3 +1,8 @@
+/**
+ * @module
+ * JSON Web Token (JWT)
+ * https://datatracker.ietf.org/doc/html/rfc7519
+ */
 import type { SignatureAlgorithm } from './jwa';
 import type { SignatureKey } from './jws';
 import type { JWTPayload } from './types';

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

@@ -1,3 +1,7 @@
+/**
+ * @module
+ * Type definitions for JWT utilities.
+ */
 export declare class JwtAlgorithmNotImplemented extends Error {
     constructor(alg: string);
 }

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

@@ -1,2 +1,6 @@
+/**
+ * @module
+ * Functions for encoding/decoding UTF8.
+ */
 export declare const utf8Encoder: TextEncoder;
 export declare const utf8Decoder: TextDecoder;

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

@@ -12,6 +12,10 @@ export declare class StreamingApi {
      * Whether the stream has been aborted.
      */
     aborted: boolean;
+    /**
+     * Whether the stream has been closed normally.
+     */
+    closed: boolean;
     constructor(writable: WritableStream, _readable: ReadableStream);
     write(input: Uint8Array | string): Promise<StreamingApi>;
     writeln(input: string): Promise<StreamingApi>;

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

@@ -8,16 +8,27 @@ export type NotEqual<X, Y> = true extends Equal<X, Y> ? false : true;
 export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
 export type RemoveBlankRecord<T> = T extends Record<infer K, unknown> ? K extends string ? T : never : never;
 export type IfAnyThenEmptyObject<T> = 0 extends 1 & T ? {} : T;
-export type JSONPrimitive = string | boolean | number | null | undefined;
+export type JSONPrimitive = string | boolean | number | null;
 export type JSONArray = (JSONPrimitive | JSONObject | JSONArray)[];
 export type JSONObject = {
     [key: string]: JSONPrimitive | JSONArray | JSONObject | object;
 };
+export type InvalidJSONValue = undefined | symbol | ((...args: unknown[]) => unknown);
+type InvalidToNull<T> = T extends InvalidJSONValue ? null : T;
+type IsInvalid<T> = T extends InvalidJSONValue ? true : false;
+/**
+ * symbol keys are omitted through `JSON.stringify`
+ */
+type OmitSymbolKeys<T> = {
+    [K in keyof T as K extends symbol ? never : K]: T[K];
+};
 export type JSONValue = JSONObject | JSONArray | JSONPrimitive;
 export type JSONParsed<T> = T extends {
     toJSON(): infer J;
-} ? (() => J) extends () => JSONObject ? J : JSONParsed<J> : T extends JSONPrimitive ? T : T extends Array<infer U> ? Array<JSONParsed<U>> : T extends object ? {
-    [K in keyof T]: JSONParsed<T[K]>;
+} ? (() => J) extends () => JSONPrimitive ? J : (() => J) extends () => {
+    toJSON(): unknown;
+} ? {} : JSONParsed<J> : T extends JSONPrimitive ? T : T extends InvalidJSONValue ? never : T extends [] ? [] : T extends readonly [infer R, ...infer U] ? [JSONParsed<InvalidToNull<R>>, ...JSONParsed<U>] : T extends Array<infer U> ? Array<JSONParsed<InvalidToNull<U>>> : T extends Set<unknown> | Map<unknown, unknown> ? {} : T extends object ? {
+    [K in keyof OmitSymbolKeys<T> as IsInvalid<T[K]> extends true ? never : K]: boolean extends IsInvalid<T[K]> ? JSONParsed<T[K]> | undefined : JSONParsed<T[K]>;
 } : never;
 /**
  * Useful to flatten the type output to improve type hints shown in editors. And also to transform an interface into a type to aide with assignability.
@@ -40,3 +51,4 @@ export type RequiredKeysOf<BaseType extends object> = Exclude<{
 }[keyof BaseType], undefined>;
 export type HasRequiredKeys<BaseType extends object> = RequiredKeysOf<BaseType> extends never ? false : true;
 export type IsAny<T> = boolean extends (T extends never ? true : false) ? true : false;
+export {};

package/dist/utils/stream.js

@@ -6,6 +6,7 @@ var StreamingApi = class {
   abortSubscribers = [];
   responseReadable;
   aborted = false;
+  closed = false;
   constructor(writable, _readable) {
     this.writable = writable;
     this.writer = writable.getWriter();
@@ -46,6 +47,7 @@ var StreamingApi = class {
       await this.writer.close();
     } catch (e) {
     }
+    this.closed = true;
   }
   async pipe(body) {
     this.writer.releaseLock();

package/dist/validator/validator.js

@@ -23,33 +23,34 @@ var validator = (target, validationFunc) => {
         if (!contentType) {
           break;
         }
+        let formData;
         if (c.req.bodyCache.formData) {
-          value = await c.req.bodyCache.formData;
-          break;
+          formData = await c.req.bodyCache.formData;
+        } else {
+          try {
+            const arrayBuffer = await c.req.arrayBuffer();
+            formData = await bufferToFormData(arrayBuffer, contentType);
+            c.req.bodyCache.formData = formData;
+          } catch (e) {
+            let message = "Malformed FormData request.";
+            message += e instanceof Error ? ` ${e.message}` : ` ${String(e)}`;
+            throw new HTTPException(400, { message });
+          }
         }
-        try {
-          const arrayBuffer = await c.req.arrayBuffer();
-          const formData = await bufferToFormData(arrayBuffer, contentType);
-          const form = {};
-          formData.forEach((value2, key) => {
-            if (key.endsWith("[]")) {
-              if (form[key] === void 0) {
-                form[key] = [value2];
-              } else if (Array.isArray(form[key])) {
-                ;
-                form[key].push(value2);
-              }
-            } else {
-              form[key] = value2;
+        const form = {};
+        formData.forEach((value2, key) => {
+          if (key.endsWith("[]")) {
+            if (form[key] === void 0) {
+              form[key] = [value2];
+            } else if (Array.isArray(form[key])) {
+              ;
+              form[key].push(value2);
             }
-          });
-          value = form;
-          c.req.bodyCache.formData = formData;
-        } catch (e) {
-          let message = "Malformed FormData request.";
-          message += e instanceof Error ? ` ${e.message}` : ` ${String(e)}`;
-          throw new HTTPException(400, { message });
-        }
+          } else {
+            form[key] = value2;
+          }
+        });
+        value = form;
         break;
       }
       case "query":

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hono",
-  "version": "4.4.10",
+  "version": "4.4.12",
   "description": "Web framework built on Web Standards",
   "main": "dist/cjs/index.js",
   "type": "module",