hono 3.0.2 → 3.0.3

package/README.md

@@ -49,7 +49,7 @@ npm create hono@latest my-app
 - **Ultrafast** - The routers are really fast and smart. Not using linear loops. Fast.
 - **Multi-runtime** - Works on Cloudflare Workers, Fastly Compute@Edge, Deno, Bun, Lagon, or Node.js. The same code runs on all platforms.
 - **Batteries Included** - Hono has built-in middleware, custom middleware, and third-party middleware. Batteries included.
-- **Fine DX** - First-class TypeScript support. Now, we've got "Types".
+- **Delightful DX** - First-class TypeScript support. Now, we've got "Types".
 - **Small** - About 20kB. Zero-dependencies. Using only Web Standard API.
 
 ## Benchmarks

package/dist/adapter/cloudflare-pages/handler.js

@@ -1,7 +1,10 @@
 // src/adapter/cloudflare-pages/handler.ts
 import { Hono } from "../../hono.js";
-var handle = (subApp, path = "/") => ({ request, env, waitUntil }) => new Hono().route(path, subApp).fetch(request, env, { waitUntil, passThroughOnException: () => {
-} });
+var handle = (subApp, path) => ({ request, env, waitUntil }) => {
+  const app = path ? new Hono().route(path, subApp) : subApp;
+  return app.fetch(request, env, { waitUntil, passThroughOnException: () => {
+  } });
+};
 export {
   handle
 };

package/dist/adapter/nextjs/handler.js

@@ -1,6 +1,9 @@
 // src/adapter/nextjs/handler.ts
 import { Hono } from "../../hono.js";
-var handle = (subApp, path = "/") => async (req) => new Hono().route(path, subApp).fetch(req);
+var handle = (subApp, path) => (req) => {
+  const app = path ? new Hono().route(path, subApp) : subApp;
+  return app.fetch(req);
+};
 export {
   handle
 };

package/dist/cjs/adapter/cloudflare-pages/handler.js

@@ -22,8 +22,11 @@ __export(handler_exports, {
 });
 module.exports = __toCommonJS(handler_exports);
 var import_hono = require("../../hono");
-const handle = (subApp, path = "/") => ({ request, env, waitUntil }) => new import_hono.Hono().route(path, subApp).fetch(request, env, { waitUntil, passThroughOnException: () => {
-} });
+const handle = (subApp, path) => ({ request, env, waitUntil }) => {
+  const app = path ? new import_hono.Hono().route(path, subApp) : subApp;
+  return app.fetch(request, env, { waitUntil, passThroughOnException: () => {
+  } });
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   handle

package/dist/cjs/adapter/nextjs/handler.js

@@ -22,7 +22,10 @@ __export(handler_exports, {
 });
 module.exports = __toCommonJS(handler_exports);
 var import_hono = require("../../hono");
-const handle = (subApp, path = "/") => async (req) => new import_hono.Hono().route(path, subApp).fetch(req);
+const handle = (subApp, path) => (req) => {
+  const app = path ? new import_hono.Hono().route(path, subApp) : subApp;
+  return app.fetch(req);
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   handle

package/dist/cjs/hono.js

@@ -51,7 +51,7 @@ class Hono extends defineDynamicClass() {
       routers: [new import_reg_exp_router.RegExpRouter(), new import_trie_router.TrieRouter()]
     });
     this.strict = true;
-    this._tempPath = "";
+    this.basePath = "";
     this.path = "*";
     this.routes = [];
     this.notFoundHandler = notFoundHandler;
@@ -64,8 +64,12 @@ class Hono extends defineDynamicClass() {
     };
     this.request = async (input, requestInit) => {
       if (input instanceof Request) {
+        if (requestInit !== void 0) {
+          input = new Request(input, requestInit);
+        }
         return await this.fetch(input);
       }
+      input = input.toString();
       const path = /^https?:\/\//.test(input) ? input : `http://localhost${(0, import_url.mergePath)("/", input)}`;
       const req = new Request(path, requestInit);
       return await this.fetch(req);
@@ -110,16 +114,24 @@ class Hono extends defineDynamicClass() {
     };
     Object.assign(this, init);
   }
+  clone() {
+    const clone = new Hono({
+      router: this.router,
+      strict: this.strict
+    });
+    clone.routes = this.routes;
+    return clone;
+  }
   route(path, app) {
-    this._tempPath = path;
+    const subApp = this.clone();
+    subApp.basePath = (0, import_url.mergePath)(this.basePath, path);
     if (app) {
       app.routes.map((r) => {
         const handler = app.errorHandler === errorHandler ? r.handler : async (c, next) => (await (0, import_compose.compose)([r.handler], app.errorHandler)(c, next)).res;
-        this.addRoute(r.method, r.path, handler);
+        subApp.addRoute(r.method, r.path, handler);
       });
-      this._tempPath = "";
     }
-    return this;
+    return subApp;
   }
   onError(handler) {
     this.errorHandler = handler;
@@ -139,8 +151,8 @@ class Hono extends defineDynamicClass() {
   }
   addRoute(method, path, handler) {
     method = method.toUpperCase();
-    if (this._tempPath) {
-      path = (0, import_url.mergePath)(this._tempPath, path);
+    if (this.basePath) {
+      path = (0, import_url.mergePath)(this.basePath, path);
     }
     this.router.add(method, path, handler);
     const r = { path, method, handler };

package/dist/hono.js

@@ -29,7 +29,7 @@ var Hono = class extends defineDynamicClass() {
       routers: [new RegExpRouter(), new TrieRouter()]
     });
     this.strict = true;
-    this._tempPath = "";
+    this.basePath = "";
     this.path = "*";
     this.routes = [];
     this.notFoundHandler = notFoundHandler;
@@ -42,8 +42,12 @@ var Hono = class extends defineDynamicClass() {
     };
     this.request = async (input, requestInit) => {
       if (input instanceof Request) {
+        if (requestInit !== void 0) {
+          input = new Request(input, requestInit);
+        }
         return await this.fetch(input);
       }
+      input = input.toString();
       const path = /^https?:\/\//.test(input) ? input : `http://localhost${mergePath("/", input)}`;
       const req = new Request(path, requestInit);
       return await this.fetch(req);
@@ -88,16 +92,24 @@ var Hono = class extends defineDynamicClass() {
     };
     Object.assign(this, init);
   }
+  clone() {
+    const clone = new Hono({
+      router: this.router,
+      strict: this.strict
+    });
+    clone.routes = this.routes;
+    return clone;
+  }
   route(path, app) {
-    this._tempPath = path;
+    const subApp = this.clone();
+    subApp.basePath = mergePath(this.basePath, path);
     if (app) {
       app.routes.map((r) => {
         const handler = app.errorHandler === errorHandler ? r.handler : async (c, next) => (await compose([r.handler], app.errorHandler)(c, next)).res;
-        this.addRoute(r.method, r.path, handler);
+        subApp.addRoute(r.method, r.path, handler);
       });
-      this._tempPath = "";
     }
-    return this;
+    return subApp;
   }
   onError(handler) {
     this.errorHandler = handler;
@@ -117,8 +129,8 @@ var Hono = class extends defineDynamicClass() {
   }
   addRoute(method, path, handler) {
     method = method.toUpperCase();
-    if (this._tempPath) {
-      path = mergePath(this._tempPath, path);
+    if (this.basePath) {
+      path = mergePath(this.basePath, path);
     }
     this.router.add(method, path, handler);
     const r = { path, method, handler };

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

@@ -1,7 +1,7 @@
 import { Hono } from '../../hono';
 import type { Env } from '../../types';
 interface HandleInterface {
-    <E extends Env>(subApp: Hono<E>, path?: string): (req: Request) => Promise<Response>;
+    <E extends Env>(subApp: Hono<E>, path?: string): (req: Request) => Response | Promise<Response>;
 }
 export declare const handle: HandleInterface;
 export {};

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

@@ -1,4 +1,4 @@
 import type { Hono } from '../hono';
 import type { UnionToIntersection } from '../utils/types';
 import type { Client, RequestOptions } from './types';
-export declare const hc: <T extends Hono<any, {}>>(baseUrl: string, options?: RequestOptions) => UnionToIntersection<Client<T>>;
+export declare const hc: <T extends Hono<any, any, any>>(baseUrl: string, options?: RequestOptions) => UnionToIntersection<Client<T>>;

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

@@ -1,5 +1,6 @@
 import type { Hono } from '../hono';
 import type { ValidationTargets } from '../types';
+import type { RemoveBlankRecord } from '../utils/types';
 declare type MethodName = `$${string}`;
 declare type Endpoint = Record<MethodName, Data>;
 declare type Data = {
@@ -16,20 +17,20 @@ declare type ClientRequest<S extends Data> = {
     [M in keyof S]: S[M] extends {
         input: infer R;
         output: infer O;
-    } ? (args?: R, options?: RequestOptions) => Promise<ClientResponse<O>> : never;
+    } ? RemoveBlankRecord<R> extends never ? (args?: {}, options?: RequestOptions) => Promise<ClientResponse<O>> : (args: R, options?: RequestOptions) => Promise<ClientResponse<O>> : never;
 };
 export interface ClientResponse<T> extends Response {
     json(): Promise<T>;
 }
 export declare type Fetch<T> = (args?: InferRequestType<T>, opt?: RequestOptions) => Promise<ClientResponse<InferResponseType<T>>>;
-export declare type InferResponseType<T> = T extends () => Promise<ClientResponse<infer O>> ? O : never;
+export declare type InferResponseType<T> = T extends (args: any | undefined) => Promise<ClientResponse<infer O>> ? O : never;
 export declare type InferRequestType<T> = T extends (args: infer R) => Promise<ClientResponse<unknown>> ? NonNullable<R> : never;
 declare type PathToChain<Path extends string, E extends Endpoint, Original extends string = ''> = Path extends `/${infer P}` ? PathToChain<P, E, Path> : Path extends `${infer P}/${infer R}` ? {
     [K in P]: PathToChain<R, E, Original>;
 } : {
     [K in Path extends '' ? 'index' : Path]: ClientRequest<E extends Record<string, unknown> ? E[Original] : never>;
 };
-export declare type Client<T> = T extends Hono<any, infer S> ? S extends Record<infer K, Endpoint> ? K extends string ? PathToChain<K, S> : never : never : never;
+export declare type Client<T> = T extends Hono<any, infer S, any> ? S extends Record<infer K, Endpoint> ? K extends string ? PathToChain<K, S> : never : never : never;
 export declare type Callback = (opts: CallbackOptions) => unknown;
 interface CallbackOptions {
     path: string[];

package/dist/types/context.d.ts

@@ -3,6 +3,7 @@ import type { TypedResponse } from './types';
 import type { Env, NotFoundHandler, Input } from './types';
 import type { CookieOptions } from './utils/cookie';
 import type { StatusCode } from './utils/http-status';
+import type { PrettyJSON, JSONValue } from './utils/types';
 declare type Runtime = 'node' | 'deno' | 'bun' | 'workerd' | 'fastly' | 'edge-light' | 'lagon' | 'other';
 declare type HeaderRecord = Record<string, string | string[]>;
 declare type Data = string | ArrayBuffer | ReadableStream;
@@ -52,7 +53,7 @@ export declare class Context<E extends Env = any, P extends string = any, I exte
     body: (data: Data | null, status?: StatusCode, headers?: HeaderRecord) => Response;
     text: (text: string, status?: StatusCode, headers?: HeaderRecord) => Response;
     json: <T = object>(object: T, status?: StatusCode, headers?: HeaderRecord) => Response;
-    jsonT: <T = object>(object: T, status?: StatusCode, headers?: HeaderRecord) => TypedResponse<T>;
+    jsonT: <T>(object: T extends JSONValue ? T : JSONValue, status?: StatusCode, headers?: HeaderRecord) => TypedResponse<T extends JSONValue ? JSONValue extends T ? never : PrettyJSON<T> : never>;
     html: (html: string, status?: StatusCode, headers?: HeaderRecord) => Response;
     redirect: (location: string, status?: StatusCode) => Response;
     cookie: (name: string, value: string, opt?: CookieOptions) => void;

package/dist/types/hono.d.ts

@@ -1,35 +1,37 @@
 import type { ExecutionContext } from './context';
 import type { Router } from './router';
-import type { Env, ErrorHandler, H, HandlerInterface, MiddlewareHandlerInterface, NotFoundHandler, OnHandlerInterface, MergeSchemaPath, RemoveBlankRecord } from './types';
+import type { Env, ErrorHandler, H, HandlerInterface, MiddlewareHandlerInterface, NotFoundHandler, OnHandlerInterface, MergePath, MergeSchemaPath } from './types';
+import type { RemoveBlankRecord } from './utils/types';
 interface RouterRoute {
     path: string;
     method: string;
     handler: H;
 }
-declare const Hono_base: new <E_1 extends Env = Env, S_1 = {}>() => {
-    all: HandlerInterface<E_1, "all", S_1>;
-    get: HandlerInterface<E_1, "get", S_1>;
-    post: HandlerInterface<E_1, "post", S_1>;
-    put: HandlerInterface<E_1, "put", S_1>;
-    delete: HandlerInterface<E_1, "delete", S_1>;
-    head: HandlerInterface<E_1, "head", S_1>;
-    options: HandlerInterface<E_1, "options", S_1>;
-    patch: HandlerInterface<E_1, "patch", S_1>;
+declare const Hono_base: new <E_1 extends Env = Env, S_1 = {}, BasePath_1 extends string = "">() => {
+    all: HandlerInterface<E_1, "all", S_1, BasePath_1>;
+    get: HandlerInterface<E_1, "get", S_1, BasePath_1>;
+    post: HandlerInterface<E_1, "post", S_1, BasePath_1>;
+    put: HandlerInterface<E_1, "put", S_1, BasePath_1>;
+    delete: HandlerInterface<E_1, "delete", S_1, BasePath_1>;
+    head: HandlerInterface<E_1, "head", S_1, BasePath_1>;
+    options: HandlerInterface<E_1, "options", S_1, BasePath_1>;
+    patch: HandlerInterface<E_1, "patch", S_1, BasePath_1>;
 } & {
-    on: OnHandlerInterface<E_1, S_1>;
+    on: OnHandlerInterface<E_1, S_1, BasePath_1>;
 } & {
-    use: MiddlewareHandlerInterface<E_1, S_1>;
+    use: MiddlewareHandlerInterface<E_1, S_1, BasePath_1>;
 };
-export declare class Hono<E extends Env = Env, S = {}> extends Hono_base<E, S> {
+export declare class Hono<E extends Env = Env, S = {}, BasePath extends string = ''> extends Hono_base<E, S, BasePath> {
     readonly router: Router<H>;
     readonly strict: boolean;
-    private _tempPath;
+    private basePath;
     private path;
     routes: RouterRoute[];
     constructor(init?: Partial<Pick<Hono, 'router' | 'strict'>>);
+    private clone;
     private notFoundHandler;
     private errorHandler;
-    route<SubPath extends string, SubEnv extends Env, SubSchema>(path: SubPath, app?: Hono<SubEnv, SubSchema>): Hono<E, RemoveBlankRecord<MergeSchemaPath<SubSchema, SubPath> | S>>;
+    route<SubPath extends string, SubEnv extends Env, SubSchema>(path: SubPath, app?: Hono<SubEnv, SubSchema>): Hono<E, RemoveBlankRecord<MergeSchemaPath<SubSchema, SubPath> | S>, MergePath<BasePath, SubPath>>;
     onError(handler: ErrorHandler<E>): this;
     notFound(handler: NotFoundHandler<E>): this;
     showRoutes(): void;
@@ -39,6 +41,6 @@ export declare class Hono<E extends Env = Env, S = {}> extends Hono_base<E, S> {
     private dispatch;
     handleEvent: (event: FetchEvent) => Response | Promise<Response>;
     fetch: (request: Request, Env?: E['Bindings'] | {}, executionCtx?: ExecutionContext) => Response | Promise<Response>;
-    request: (input: Request | string, requestInit?: RequestInit) => Promise<Response>;
+    request: (input: Request | string | URL, requestInit?: RequestInit) => Promise<Response>;
 }
 export {};

package/dist/types/types.d.ts

@@ -1,6 +1,6 @@
 import type { Context } from './context';
 import type { Hono } from './hono';
-import type { UnionToIntersection } from './utils/types';
+import type { UnionToIntersection, RemoveBlankRecord } from './utils/types';
 export declare type Bindings = Record<string, unknown>;
 export declare type Variables = Record<string, unknown>;
 export declare type Env = {
@@ -14,7 +14,7 @@ export declare type MiddlewareHandler<E extends Env = any, P extends string = an
 export declare type H<E extends Env = any, P extends string = any, I extends Input = {}, O = {}> = Handler<E, P, I, O> | MiddlewareHandler<E, P, I>;
 export declare type NotFoundHandler<E extends Env = any> = (c: Context<E>) => Response | Promise<Response>;
 export declare type ErrorHandler<E extends Env = any> = (err: Error, c: Context<E>) => Response;
-export interface HandlerInterface<E extends Env = Env, M extends string = any, S = {}> {
+export interface HandlerInterface<E extends Env = Env, M extends string = any, S = {}, BasePath extends string = ''> {
     <I = {}, O = {}>(...handlers: [H<E, ExtractKey<S>, I, O>, H<E, ExtractKey<S>, I, O>]): Hono<E, RemoveBlankRecord<S | Schema<M, ExtractKey<S>, I, O>>>;
     <P extends string, O = {}, I = {}, I2 = I, I3 = I & I2>(...handlers: [H<E, ExtractKey<S>, I, O>, H<E, ExtractKey<S>, I2, O>, H<E, ExtractKey<S>, I3, O>]): Hono<E, RemoveBlankRecord<S | Schema<M, ExtractKey<S>, I3, O>>>;
     <P extends string, O = {}, I = {}, I2 = I, I3 = I & I2, I4 = I2 & I3>(...handlers: [
@@ -31,23 +31,53 @@ export interface HandlerInterface<E extends Env = Env, M extends string = any, S
         H<E, ExtractKey<S>, I5, O>
     ]): Hono<E, RemoveBlankRecord<S | Schema<M, ExtractKey<S>, I5, O>>>;
     <I = {}, O = {}>(...handlers: Handler<E, ExtractKey<S>, I, O>[]): Hono<E, RemoveBlankRecord<S | Schema<M, ExtractKey<S>, I, O>>>;
-    <P extends string, O = {}, I = {}>(path: P, ...handlers: [H<E, P, I, O>, H<E, P, I, O>]): Hono<E, RemoveBlankRecord<S | Schema<M, P, I, O>>>;
-    <P extends string, O = {}, I = {}, I2 = I, I3 = I & I2>(path: P, ...handlers: [H<E, P, I, O>, H<E, P, I2, O>, H<E, P, I3, O>]): Hono<E, RemoveBlankRecord<S | Schema<M, P, I3, O>>>;
-    <P extends string, O = {}, I = {}, I2 = I, I3 = I & I2, I4 = I2 & I3>(path: P, ...handlers: [H<E, P, I, O>, H<E, P, I2, O>, H<E, P, I3, O>, H<E, P, I4, O>]): Hono<E, RemoveBlankRecord<S | Schema<M, P, I4, O>>>;
-    <P extends string, O = {}, I = {}, I2 = I, I3 = I & I2, I4 = I2 & I3, I5 = I3 & I4>(path: P, ...handlers: [H<E, P, I, O>, H<E, P, I2, O>, H<E, P, I3, O>, H<E, P, I4, O>, H<E, P, I5, O>]): Hono<E, RemoveBlankRecord<S | Schema<M, P, I5, O>>>;
-    <P extends string, I = {}, O = {}>(path: P, ...handlers: H<E, P, I, O>[]): Hono<E, RemoveBlankRecord<S | Schema<M, P, I, O>>>;
+    <P extends string, O = {}, I = {}>(path: P, ...handlers: [H<E, P, I, O>, H<E, P, I, O>]): Hono<E, RemoveBlankRecord<S | Schema<M, MergePath<BasePath, P>, I, O>>>;
+    <P extends string, O = {}, I = {}, I2 = I, I3 = I & I2>(path: P, ...handlers: [
+        H<E, MergePath<BasePath, P>, I, O>,
+        H<E, MergePath<BasePath, P>, I2, O>,
+        H<E, MergePath<BasePath, P>, I3, O>
+    ]): Hono<E, RemoveBlankRecord<S | Schema<M, MergePath<BasePath, P>, I3, O>>>;
+    <P extends string, O = {}, I = {}, I2 = I, I3 = I & I2, I4 = I2 & I3>(path: P, ...handlers: [
+        H<E, MergePath<BasePath, P>, I, O>,
+        H<E, MergePath<BasePath, P>, I2, O>,
+        H<E, MergePath<BasePath, P>, I3, O>,
+        H<E, MergePath<BasePath, P>, I4, O>
+    ]): Hono<E, RemoveBlankRecord<S | Schema<M, MergePath<BasePath, P>, I4, O>>>;
+    <P extends string, O = {}, I = {}, I2 = I, I3 = I & I2, I4 = I2 & I3, I5 = I3 & I4>(path: P, ...handlers: [
+        H<E, MergePath<BasePath, P>, I, O>,
+        H<E, MergePath<BasePath, P>, I2, O>,
+        H<E, MergePath<BasePath, P>, I3, O>,
+        H<E, MergePath<BasePath, P>, I4, O>,
+        H<E, MergePath<BasePath, P>, I5, O>
+    ]): Hono<E, RemoveBlankRecord<S | Schema<M, MergePath<BasePath, P>, I5, O>>>;
+    <P extends string, I = {}, O = {}>(path: P, ...handlers: H<E, MergePath<BasePath, P>, I, O>[]): Hono<E, RemoveBlankRecord<S | Schema<M, MergePath<BasePath, P>, I, O>>>;
 }
-export interface MiddlewareHandlerInterface<E extends Env = Env, S = {}> {
-    (...handlers: MiddlewareHandler<E, ExtractKey<S>>[]): Hono<E, S>;
-    <P extends string>(path: P, ...handlers: MiddlewareHandler<E, P>[]): Hono<E, S>;
+export interface MiddlewareHandlerInterface<E extends Env = Env, S = {}, BasePath extends string = ''> {
+    (...handlers: MiddlewareHandler<E, MergePath<BasePath, ExtractKey<S>>>[]): Hono<E, S, BasePath>;
+    <P extends string>(path: P, ...handlers: MiddlewareHandler<E, MergePath<BasePath, P>>[]): Hono<E, S, BasePath>;
 }
-export interface OnHandlerInterface<E extends Env = Env, S = {}> {
-    <M extends string, P extends string, O = {}, I = {}>(method: M, path: P, ...handlers: [H<E, P, I, O>, H<E, P, I, O>]): Hono<E, RemoveBlankRecord<S | Schema<M, P, I, O>>>;
-    <M extends string, P extends string, O = {}, I = {}, I2 = I, I3 = I & I2>(method: M, path: P, ...handlers: [H<E, P, I, O>, H<E, P, I2, O>, H<E, P, I3, O>]): Hono<E, RemoveBlankRecord<S | Schema<M, P, I3, O>>>;
-    <M extends string, P extends string, O = {}, I = {}, I2 = I, I3 = I & I2, I4 = I2 & I3>(method: M, path: P, ...handlers: [H<E, P, I, O>, H<E, P, I2, O>, H<E, P, I3, O>, H<E, P, I4, O>]): Hono<E, RemoveBlankRecord<S | Schema<M, P, I4, O>>>;
-    <M extends string, P extends string, O = {}, I = {}, I2 = I, I3 = I & I2, I4 = I2 & I3, I5 = I3 & I4>(method: M, path: P, ...handlers: [H<E, P, I, O>, H<E, P, I2, O>, H<E, P, I3, O>, H<E, P, I4, O>, H<E, P, I5, O>]): Hono<E, S | Schema<M, P, I5, O>>;
-    <M extends string, P extends string, O extends {} = {}, I = {}>(method: M, path: P, ...handlers: H<E, P, I, O>[]): Hono<E, RemoveBlankRecord<S | Schema<M, P, I, O>>>;
-    <P extends string, O extends {} = {}, I = {}>(methods: string[], path: P, ...handlers: H<E, P, I, O>[]): Hono<E, RemoveBlankRecord<S | Schema<string, P, I, O>>>;
+export interface OnHandlerInterface<E extends Env = Env, S = {}, BasePath extends string = ''> {
+    <M extends string, P extends string, O = {}, I = {}>(method: M, path: P, ...handlers: [H<E, MergePath<BasePath, P>, I, O>, H<E, MergePath<BasePath, P>, I, O>]): Hono<E, RemoveBlankRecord<S | Schema<M, MergePath<BasePath, P>, I, O>>, BasePath>;
+    <M extends string, P extends string, O = {}, I = {}, I2 = I, I3 = I & I2>(method: M, path: P, ...handlers: [
+        H<E, MergePath<BasePath, P>, I, O>,
+        H<E, MergePath<BasePath, P>, I2, O>,
+        H<E, MergePath<BasePath, P>, I3, O>
+    ]): Hono<E, RemoveBlankRecord<S | Schema<M, MergePath<BasePath, P>, I3, O>>, BasePath>;
+    <M extends string, P extends string, O = {}, I = {}, I2 = I, I3 = I & I2, I4 = I2 & I3>(method: M, path: P, ...handlers: [
+        H<E, MergePath<BasePath, P>, I, O>,
+        H<E, MergePath<BasePath, P>, I2, O>,
+        H<E, MergePath<BasePath, P>, I3, O>,
+        H<E, MergePath<BasePath, P>, I4, O>
+    ]): Hono<E, RemoveBlankRecord<S | Schema<M, MergePath<BasePath, P>, I4, O>>, BasePath>;
+    <M extends string, P extends string, O = {}, I = {}, I2 = I, I3 = I & I2, I4 = I2 & I3, I5 = I3 & I4>(method: M, path: P, ...handlers: [
+        H<E, MergePath<BasePath, P>, I, O>,
+        H<E, MergePath<BasePath, P>, I2, O>,
+        H<E, MergePath<BasePath, P>, I3, O>,
+        H<E, MergePath<BasePath, P>, I4, O>,
+        H<E, MergePath<BasePath, P>, I5, O>
+    ]): Hono<E, S | Schema<M, MergePath<BasePath, P>, I5, O>, BasePath>;
+    <M extends string, P extends string, O extends {} = {}, I = {}>(method: M, path: P, ...handlers: H<E, MergePath<BasePath, P>, I, O>[]): Hono<E, RemoveBlankRecord<S | Schema<M, MergePath<BasePath, P>, I, O>>, BasePath>;
+    <P extends string, O extends {} = {}, I = {}>(methods: string[], path: P, ...handlers: H<E, MergePath<BasePath, P>, I, O>[]): Hono<E, RemoveBlankRecord<S | Schema<string, MergePath<BasePath, P>, I, O>>, BasePath>;
 }
 declare type ExtractKey<S> = S extends Record<infer Key, unknown> ? Key extends string ? Key : never : string;
 export declare type Schema<M extends string, P extends string, I extends Input, O> = {
@@ -65,7 +95,7 @@ export declare type AddDollar<T> = T extends Record<infer K, infer R> ? K extend
     [MethodName in `$${Lowercase<K>}`]: R;
 } : never : never;
 export declare type MergeSchemaPath<S, P extends string> = S extends Record<infer Key, infer T> ? Key extends string ? Record<MergePath<P, Key>, T> : never : never;
-export declare type MergePath<A extends string, B extends string> = A extends `${infer P}/` ? `${P}${B}` : `${A}${B}`;
+export declare type MergePath<A extends string, B extends string> = A extends '' ? B : A extends `${infer P}/` ? B extends `/${infer Q}` ? `${P}/${Q}` : `${P}/${B}` : B extends `/${infer Q}` ? `${A}/${Q}` : `${A}/${B}`;
 export declare type TypedResponse<T = unknown> = {
     response: Response | Promise<Response>;
     data: T;
@@ -89,5 +119,4 @@ export declare type InputToDataByTarget<T extends Input, Target extends keyof Va
 export declare type RemoveQuestion<T> = T extends `${infer R}?` ? R : T;
 export declare type UndefinedIfHavingQuestion<T> = T extends `${infer _}?` ? string | undefined : string;
 export declare type ExtractSchema<T> = T extends Hono<infer _, infer S> ? S : never;
-export declare type RemoveBlankRecord<T> = T extends Record<infer K, unknown> ? K extends string ? T : never : never;
 export {};

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

@@ -2,3 +2,15 @@ export declare type Expect<T extends true> = T;
 export declare type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? true : false;
 export declare type NotEqual<X, Y> = true extends Equal<X, Y> ? false : true;
 export declare type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+export declare type RemoveBlankRecord<T> = T extends Record<infer K, unknown> ? K extends string ? T : never : never;
+export declare type JSONPrimitive = string | boolean | number | null | undefined;
+export declare type JSONArray = (JSONPrimitive | JSONObject | JSONArray)[];
+export declare type JSONObject = {
+    [key: string]: JSONPrimitive | JSONArray | JSONObject;
+};
+export declare type JSONValue = JSONObject | JSONArray | JSONPrimitive;
+declare type TrueAndFalseToBoolean<T> = T extends true ? boolean : T extends false ? boolean : T;
+export declare type PrettyJSON<T> = T extends JSONPrimitive ? TrueAndFalseToBoolean<T> : T extends JSONArray ? PrettyJSON<T[number]> : T extends JSONObject ? {
+    [K in keyof T]: PrettyJSON<T[K]>;
+} : never;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hono",
-  "version": "3.0.2",
+  "version": "3.0.3",
   "description": "Ultrafast web framework for the Edge",
   "main": "dist/cjs/index.js",
   "type": "module",