hono 4.0.10 → 4.1.0

package/dist/cjs/helper/factory/index.js

@@ -24,9 +24,7 @@ __export(factory_exports, {
 });
 module.exports = __toCommonJS(factory_exports);
 class Factory {
-  constructor() {
-    this.createMiddleware = (middleware) => middleware;
-  }
+  createMiddleware = (middleware) => middleware;
   createHandlers(...handlers) {
     return handlers.filter((handler) => handler !== void 0);
   }

package/dist/cjs/helper/ssg/index.js

@@ -15,174 +15,24 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var ssg_exports = {};
 __export(ssg_exports, {
-  SSG_DISABLED_RESPONSE: () => SSG_DISABLED_RESPONSE,
-  disableSSG: () => disableSSG,
-  fetchRoutesContent: () => fetchRoutesContent,
-  isSSGContext: () => isSSGContext,
-  onlySSG: () => onlySSG,
-  saveContentToFiles: () => saveContentToFiles,
-  ssgParams: () => ssgParams,
-  toSSG: () => toSSG
+  SSG_DISABLED_RESPONSE: () => import_middleware.SSG_DISABLED_RESPONSE,
+  disableSSG: () => import_middleware.disableSSG,
+  isSSGContext: () => import_middleware.isSSGContext,
+  onlySSG: () => import_middleware.onlySSG,
+  ssgParams: () => import_middleware.ssgParams
 });
 module.exports = __toCommonJS(ssg_exports);
-var import_utils = require("../../client/utils");
-var import_mime = require("../../utils/mime");
-var import_utils2 = require("./utils");
-const SSG_CONTEXT = "HONO_SSG_CONTEXT";
-const SSG_DISABLED_RESPONSE = new Response("SSG is disabled", { status: 404 });
-const generateFilePath = (routePath, outDir, mimeType) => {
-  const extension = determineExtension(mimeType);
-  if (routePath.endsWith(`.${extension}`)) {
-    return (0, import_utils2.joinPaths)(outDir, routePath);
-  }
-  if (routePath === "/") {
-    return (0, import_utils2.joinPaths)(outDir, `index.${extension}`);
-  }
-  if (routePath.endsWith("/")) {
-    return (0, import_utils2.joinPaths)(outDir, routePath, `index.${extension}`);
-  }
-  return (0, import_utils2.joinPaths)(outDir, `${routePath}.${extension}`);
-};
-const parseResponseContent = async (response) => {
-  const contentType = response.headers.get("Content-Type");
-  try {
-    if (contentType?.includes("text") || contentType?.includes("json")) {
-      return await response.text();
-    } else {
-      return await response.arrayBuffer();
-    }
-  } catch (error) {
-    throw new Error(
-      `Error processing response: ${error instanceof Error ? error.message : "Unknown error"}`
-    );
-  }
-};
-const determineExtension = (mimeType) => {
-  switch (mimeType) {
-    case "text/html":
-      return "html";
-    case "text/xml":
-    case "application/xml":
-      return "xml";
-    default: {
-      return (0, import_mime.getExtension)(mimeType) || "html";
-    }
-  }
-};
-const ssgParams = (params) => async (c, next) => {
-  ;
-  c.req.raw.ssgParams = Array.isArray(params) ? params : await params(c);
-  await next();
-};
-const fetchRoutesContent = async (app, beforeRequestHook, afterResponseHook) => {
-  const htmlMap = /* @__PURE__ */ new Map();
-  const baseURL = "http://localhost";
-  for (const route of (0, import_utils2.filterStaticGenerateRoutes)(app)) {
-    const thisRouteBaseURL = new URL(route.path, baseURL).toString();
-    let forGetInfoURLRequest = new Request(thisRouteBaseURL);
-    if (beforeRequestHook) {
-      const maybeRequest = beforeRequestHook(forGetInfoURLRequest);
-      if (!maybeRequest) {
-        continue;
-      }
-      forGetInfoURLRequest = maybeRequest;
-    }
-    await app.fetch(forGetInfoURLRequest);
-    if (!forGetInfoURLRequest.ssgParams) {
-      if (isDynamicRoute(route.path)) {
-        continue;
-      }
-      forGetInfoURLRequest.ssgParams = [{}];
-    }
-    const requestInit = {
-      method: forGetInfoURLRequest.method,
-      headers: forGetInfoURLRequest.headers
-    };
-    for (const param of forGetInfoURLRequest.ssgParams) {
-      const replacedUrlParam = (0, import_utils.replaceUrlParam)(route.path, param);
-      let response = await app.request(replacedUrlParam, requestInit, {
-        [SSG_CONTEXT]: true
-      });
-      if (response === SSG_DISABLED_RESPONSE) {
-        continue;
-      }
-      if (afterResponseHook) {
-        const maybeResponse = afterResponseHook(response);
-        if (!maybeResponse) {
-          continue;
-        }
-        response = maybeResponse;
-      }
-      const mimeType = response.headers.get("Content-Type")?.split(";")[0] || "text/plain";
-      const content = await parseResponseContent(response);
-      htmlMap.set(replacedUrlParam, {
-        mimeType,
-        content
-      });
-    }
-  }
-  return htmlMap;
-};
-const isDynamicRoute = (path) => {
-  return path.split("/").some((segment) => segment.startsWith(":") || segment.includes("*"));
-};
-const saveContentToFiles = async (htmlMap, fsModule, outDir) => {
-  const files = [];
-  for (const [routePath, { content, mimeType }] of htmlMap) {
-    const filePath = generateFilePath(routePath, outDir, mimeType);
-    const dirPath = (0, import_utils2.dirname)(filePath);
-    await fsModule.mkdir(dirPath, { recursive: true });
-    if (typeof content === "string") {
-      await fsModule.writeFile(filePath, content);
-    } else if (content instanceof ArrayBuffer) {
-      await fsModule.writeFile(filePath, new Uint8Array(content));
-    }
-    files.push(filePath);
-  }
-  return files;
-};
-const toSSG = async (app, fs, options) => {
-  let result = void 0;
-  try {
-    const outputDir = options?.dir ?? "./static";
-    const maps = await fetchRoutesContent(
-      app,
-      options?.beforeRequestHook,
-      options?.afterResponseHook
-    );
-    const files = await saveContentToFiles(maps, fs, outputDir);
-    result = { success: true, files };
-  } catch (error) {
-    const errorObj = error instanceof Error ? error : new Error(String(error));
-    result = { success: false, files: [], error: errorObj };
-  }
-  await options?.afterGenerateHook?.(result);
-  return result;
-};
-const isSSGContext = (c) => !!c.env?.[SSG_CONTEXT];
-const disableSSG = () => async function disableSSG2(c, next) {
-  if (isSSGContext(c)) {
-    return SSG_DISABLED_RESPONSE;
-  }
-  await next();
-};
-const onlySSG = () => async function onlySSG2(c, next) {
-  if (!isSSGContext(c)) {
-    return c.notFound();
-  }
-  await next();
-};
+__reExport(ssg_exports, require("./ssg"), module.exports);
+var import_middleware = require("./middleware");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   SSG_DISABLED_RESPONSE,
   disableSSG,
-  fetchRoutesContent,
   isSSGContext,
   onlySSG,
-  saveContentToFiles,
-  ssgParams,
-  toSSG
+  ssgParams
 });

package/dist/cjs/helper/ssg/middleware.js

@@ -0,0 +1,57 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var middleware_exports = {};
+__export(middleware_exports, {
+  SSG_CONTEXT: () => SSG_CONTEXT,
+  SSG_DISABLED_RESPONSE: () => SSG_DISABLED_RESPONSE,
+  disableSSG: () => disableSSG,
+  isSSGContext: () => isSSGContext,
+  onlySSG: () => onlySSG,
+  ssgParams: () => ssgParams
+});
+module.exports = __toCommonJS(middleware_exports);
+const SSG_CONTEXT = "HONO_SSG_CONTEXT";
+const SSG_DISABLED_RESPONSE = new Response("SSG is disabled", { status: 404 });
+const ssgParams = (params) => async (c, next) => {
+  ;
+  c.req.raw.ssgParams = Array.isArray(params) ? params : await params(c);
+  await next();
+};
+const isSSGContext = (c) => !!c.env?.[SSG_CONTEXT];
+const disableSSG = () => async function disableSSG2(c, next) {
+  if (isSSGContext(c)) {
+    return SSG_DISABLED_RESPONSE;
+  }
+  await next();
+};
+const onlySSG = () => async function onlySSG2(c, next) {
+  if (!isSSGContext(c)) {
+    return c.notFound();
+  }
+  await next();
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SSG_CONTEXT,
+  SSG_DISABLED_RESPONSE,
+  disableSSG,
+  isSSGContext,
+  onlySSG,
+  ssgParams
+});

package/dist/cjs/helper/ssg/ssg.js

@@ -0,0 +1,212 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ssg_exports = {};
+__export(ssg_exports, {
+  fetchRoutesContent: () => fetchRoutesContent,
+  saveContentToFile: () => saveContentToFile,
+  toSSG: () => toSSG
+});
+module.exports = __toCommonJS(ssg_exports);
+var import_utils = require("../../client/utils");
+var import_concurrent = require("../../utils/concurrent");
+var import_mime = require("../../utils/mime");
+var import_middleware = require("./middleware");
+var import_utils2 = require("./utils");
+const DEFAULT_CONCURRENCY = 2;
+const generateFilePath = (routePath, outDir, mimeType) => {
+  const extension = determineExtension(mimeType);
+  if (routePath.endsWith(`.${extension}`)) {
+    return (0, import_utils2.joinPaths)(outDir, routePath);
+  }
+  if (routePath === "/") {
+    return (0, import_utils2.joinPaths)(outDir, `index.${extension}`);
+  }
+  if (routePath.endsWith("/")) {
+    return (0, import_utils2.joinPaths)(outDir, routePath, `index.${extension}`);
+  }
+  return (0, import_utils2.joinPaths)(outDir, `${routePath}.${extension}`);
+};
+const parseResponseContent = async (response) => {
+  const contentType = response.headers.get("Content-Type");
+  try {
+    if (contentType?.includes("text") || contentType?.includes("json")) {
+      return await response.text();
+    } else {
+      return await response.arrayBuffer();
+    }
+  } catch (error) {
+    throw new Error(
+      `Error processing response: ${error instanceof Error ? error.message : "Unknown error"}`
+    );
+  }
+};
+const determineExtension = (mimeType) => {
+  switch (mimeType) {
+    case "text/html":
+      return "html";
+    case "text/xml":
+    case "application/xml":
+      return "xml";
+    default: {
+      return (0, import_mime.getExtension)(mimeType) || "html";
+    }
+  }
+};
+const fetchRoutesContent = function* (app, beforeRequestHook, afterResponseHook, concurrency) {
+  const baseURL = "http://localhost";
+  const pool = (0, import_concurrent.createPool)({ concurrency });
+  for (const route of (0, import_utils2.filterStaticGenerateRoutes)(app)) {
+    const thisRouteBaseURL = new URL(route.path, baseURL).toString();
+    let forGetInfoURLRequest = new Request(thisRouteBaseURL);
+    if (beforeRequestHook) {
+      const maybeRequest = beforeRequestHook(forGetInfoURLRequest);
+      if (!maybeRequest) {
+        continue;
+      }
+      forGetInfoURLRequest = maybeRequest;
+    }
+    yield new Promise(async (resolveGetInfo, rejectGetInfo) => {
+      try {
+        await pool.run(() => app.fetch(forGetInfoURLRequest));
+        if (!forGetInfoURLRequest.ssgParams) {
+          if (isDynamicRoute(route.path)) {
+            resolveGetInfo(void 0);
+            return;
+          }
+          forGetInfoURLRequest.ssgParams = [{}];
+        }
+        const requestInit = {
+          method: forGetInfoURLRequest.method,
+          headers: forGetInfoURLRequest.headers
+        };
+        resolveGetInfo(
+          function* () {
+            for (const param of forGetInfoURLRequest.ssgParams) {
+              yield new Promise(async (resolveReq, rejectReq) => {
+                try {
+                  const replacedUrlParam = (0, import_utils.replaceUrlParam)(route.path, param);
+                  let response = await pool.run(
+                    () => app.request(replacedUrlParam, requestInit, {
+                      [import_middleware.SSG_CONTEXT]: true
+                    })
+                  );
+                  if (response === import_middleware.SSG_DISABLED_RESPONSE) {
+                    resolveReq(void 0);
+                    return;
+                  }
+                  if (afterResponseHook) {
+                    const maybeResponse = afterResponseHook(response);
+                    if (!maybeResponse) {
+                      resolveReq(void 0);
+                      return;
+                    }
+                    response = maybeResponse;
+                  }
+                  const mimeType = response.headers.get("Content-Type")?.split(";")[0] || "text/plain";
+                  const content = await parseResponseContent(response);
+                  resolveReq({
+                    routePath: replacedUrlParam,
+                    mimeType,
+                    content
+                  });
+                } catch (error) {
+                  rejectReq(error);
+                }
+              });
+            }
+          }()
+        );
+      } catch (error) {
+        rejectGetInfo(error);
+      }
+    });
+  }
+};
+const isDynamicRoute = (path) => {
+  return path.split("/").some((segment) => segment.startsWith(":") || segment.includes("*"));
+};
+const createdDirs = /* @__PURE__ */ new Set();
+const saveContentToFile = async (data, fsModule, outDir) => {
+  const awaitedData = await data;
+  if (!awaitedData) {
+    return;
+  }
+  const { routePath, content, mimeType } = awaitedData;
+  const filePath = generateFilePath(routePath, outDir, mimeType);
+  const dirPath = (0, import_utils2.dirname)(filePath);
+  if (!createdDirs.has(dirPath)) {
+    await fsModule.mkdir(dirPath, { recursive: true });
+    createdDirs.add(dirPath);
+  }
+  if (typeof content === "string") {
+    await fsModule.writeFile(filePath, content);
+  } else if (content instanceof ArrayBuffer) {
+    await fsModule.writeFile(filePath, new Uint8Array(content));
+  }
+  return filePath;
+};
+const toSSG = async (app, fs, options) => {
+  let result = void 0;
+  const getInfoPromises = [];
+  const savePromises = [];
+  try {
+    const outputDir = options?.dir ?? "./static";
+    const concurrency = options?.concurrency ?? DEFAULT_CONCURRENCY;
+    const getInfoGen = fetchRoutesContent(
+      app,
+      options?.beforeRequestHook,
+      options?.afterResponseHook,
+      concurrency
+    );
+    for (const getInfo of getInfoGen) {
+      getInfoPromises.push(
+        getInfo.then((getContentGen) => {
+          if (!getContentGen) {
+            return;
+          }
+          for (const content of getContentGen) {
+            savePromises.push(saveContentToFile(content, fs, outputDir).catch((e) => e));
+          }
+        })
+      );
+    }
+    await Promise.all(getInfoPromises);
+    const files = [];
+    for (const savePromise of savePromises) {
+      const fileOrError = await savePromise;
+      if (typeof fileOrError === "string") {
+        files.push(fileOrError);
+      } else if (fileOrError) {
+        throw fileOrError;
+      }
+    }
+    result = { success: true, files };
+  } catch (error) {
+    const errorObj = error instanceof Error ? error : new Error(String(error));
+    result = { success: false, files: [], error: errorObj };
+  }
+  await options?.afterGenerateHook?.(result);
+  return result;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  fetchRoutesContent,
+  saveContentToFile,
+  toSSG
+});

package/dist/cjs/helper/websocket/index.js

@@ -0,0 +1,32 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var websocket_exports = {};
+__export(websocket_exports, {
+  createWSMessageEvent: () => createWSMessageEvent
+});
+module.exports = __toCommonJS(websocket_exports);
+const createWSMessageEvent = (source) => {
+  return new MessageEvent("message", {
+    data: source
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createWSMessageEvent
+});

package/dist/cjs/helper.js

@@ -25,3 +25,4 @@ __reExport(helper_exports, require("./helper/streaming"), module.exports);
 __reExport(helper_exports, require("./helper/testing"), module.exports);
 __reExport(helper_exports, require("./helper/dev"), module.exports);
 __reExport(helper_exports, require("./adapter/deno/ssg"), module.exports);
+__reExport(helper_exports, require("./adapter/deno/websocket"), module.exports);

package/dist/cjs/hono-base.js

@@ -16,24 +16,6 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __accessCheck = (obj, member, msg) => {
-  if (!member.has(obj))
-    throw TypeError("Cannot " + msg);
-};
-var __privateGet = (obj, member, getter) => {
-  __accessCheck(obj, member, "read from private field");
-  return getter ? getter.call(obj) : member.get(obj);
-};
-var __privateAdd = (obj, member, value) => {
-  if (member.has(obj))
-    throw TypeError("Cannot add the same private member more than once");
-  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-};
-var __privateSet = (obj, member, value, setter) => {
-  __accessCheck(obj, member, "write to private field");
-  setter ? setter.call(obj, value) : member.set(obj, value);
-  return value;
-};
 var hono_base_exports = {};
 __export(hono_base_exports, {
   COMPOSED_HANDLER: () => COMPOSED_HANDLER,
@@ -46,7 +28,6 @@ var import_http_exception = require("./http-exception");
 var import_request = require("./request");
 var import_router = require("./router");
 var import_url = require("./utils/url");
-var _path;
 const COMPOSED_HANDLER = Symbol("composedHandler");
 function defineDynamicClass() {
   return class {
@@ -62,53 +43,25 @@ const errorHandler = (err, c) => {
   console.error(err);
   return c.text("Internal Server Error", 500);
 };
-const _Hono = class extends defineDynamicClass() {
+class Hono extends defineDynamicClass() {
+  router;
+  getPath;
+  _basePath = "/";
+  #path = "/";
+  routes = [];
   constructor(options = {}) {
     super();
-    this._basePath = "/";
-    __privateAdd(this, _path, "/");
-    this.routes = [];
-    this.notFoundHandler = notFoundHandler;
-    this.errorHandler = errorHandler;
-    this.onError = (handler) => {
-      this.errorHandler = handler;
-      return this;
-    };
-    this.notFound = (handler) => {
-      this.notFoundHandler = handler;
-      return this;
-    };
-    this.fetch = (request, Env, executionCtx) => {
-      return this.dispatch(request, executionCtx, Env, request.method);
-    };
-    this.request = (input, requestInit, Env, executionCtx) => {
-      if (input instanceof Request) {
-        if (requestInit !== void 0) {
-          input = new Request(input, requestInit);
-        }
-        return this.fetch(input, Env, executionCtx);
-      }
-      input = input.toString();
-      const path = /^https?:\/\//.test(input) ? input : `http://localhost${(0, import_url.mergePath)("/", input)}`;
-      const req = new Request(path, requestInit);
-      return this.fetch(req, Env, executionCtx);
-    };
-    this.fire = () => {
-      addEventListener("fetch", (event) => {
-        event.respondWith(this.dispatch(event.request, event, void 0, event.request.method));
-      });
-    };
     const allMethods = [...import_router.METHODS, import_router.METHOD_NAME_ALL_LOWERCASE];
     allMethods.map((method) => {
       this[method] = (args1, ...args) => {
         if (typeof args1 === "string") {
-          __privateSet(this, _path, args1);
+          this.#path = args1;
         } else {
-          this.addRoute(method, __privateGet(this, _path), args1);
+          this.addRoute(method, this.#path, args1);
         }
         args.map((handler) => {
           if (typeof handler !== "string") {
-            this.addRoute(method, __privateGet(this, _path), handler);
+            this.addRoute(method, this.#path, handler);
           }
         });
         return this;
@@ -119,10 +72,10 @@ const _Hono = class extends defineDynamicClass() {
         return this;
       }
       for (const p of [path].flat()) {
-        __privateSet(this, _path, p);
+        this.#path = p;
         for (const m of [method].flat()) {
           handlers.map((handler) => {
-            this.addRoute(m.toUpperCase(), __privateGet(this, _path), handler);
+            this.addRoute(m.toUpperCase(), this.#path, handler);
           });
         }
       }
@@ -130,13 +83,13 @@ const _Hono = class extends defineDynamicClass() {
     };
     this.use = (arg1, ...handlers) => {
       if (typeof arg1 === "string") {
-        __privateSet(this, _path, arg1);
+        this.#path = arg1;
       } else {
-        __privateSet(this, _path, "*");
+        this.#path = "*";
         handlers.unshift(arg1);
       }
       handlers.map((handler) => {
-        this.addRoute(import_router.METHOD_NAME_ALL, __privateGet(this, _path), handler);
+        this.addRoute(import_router.METHOD_NAME_ALL, this.#path, handler);
       });
       return this;
     };
@@ -146,13 +99,15 @@ const _Hono = class extends defineDynamicClass() {
     this.getPath = strict ? options.getPath ?? import_url.getPath : import_url.getPathNoStrict;
   }
   clone() {
-    const clone = new _Hono({
+    const clone = new Hono({
       router: this.router,
       getPath: this.getPath
     });
     clone.routes = this.routes;
     return clone;
   }
+  notFoundHandler = notFoundHandler;
+  errorHandler = errorHandler;
   route(path, app) {
     const subApp = this.basePath(path);
     if (!app) {
@@ -175,6 +130,14 @@ const _Hono = class extends defineDynamicClass() {
     subApp._basePath = (0, import_url.mergePath)(this._basePath, path);
     return subApp;
   }
+  onError = (handler) => {
+    this.errorHandler = handler;
+    return this;
+  };
+  notFound = (handler) => {
+    this.notFoundHandler = handler;
+    return this;
+  };
   mount(path, applicationHandler, optionHandler) {
     const mergedPath = (0, import_url.mergePath)(this._basePath, path);
     const pathPrefixLength = mergedPath === "/" ? 0 : mergedPath.length;
@@ -257,9 +220,27 @@ const _Hono = class extends defineDynamicClass() {
       }
     })();
   }
-};
-let Hono = _Hono;
-_path = new WeakMap();
+  fetch = (request, Env, executionCtx) => {
+    return this.dispatch(request, executionCtx, Env, request.method);
+  };
+  request = (input, requestInit, Env, executionCtx) => {
+    if (input instanceof Request) {
+      if (requestInit !== void 0) {
+        input = new Request(input, requestInit);
+      }
+      return this.fetch(input, Env, executionCtx);
+    }
+    input = input.toString();
+    const path = /^https?:\/\//.test(input) ? input : `http://localhost${(0, import_url.mergePath)("/", input)}`;
+    const req = new Request(path, requestInit);
+    return this.fetch(req, Env, executionCtx);
+  };
+  fire = () => {
+    addEventListener("fetch", (event) => {
+      event.respondWith(this.dispatch(event.request, event, void 0, event.request.method));
+    });
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   COMPOSED_HANDLER,