hono 4.6.9 → 4.6.11

package/README.md

@@ -47,7 +47,7 @@ npm create hono@latest
 ## Features
 
 - **Ultrafast** 🚀 - The router `RegExpRouter` is really fast. Not using linear loops. Fast.
-- **Lightweight** 🪶 - The `hono/tiny` preset is under 13kB. Hono has zero dependencies and uses only the Web Standard API.
+- **Lightweight** 🪶 - The `hono/tiny` preset is under 12kB. Hono has zero dependencies and uses only the Web Standard API.
 - **Multi-runtime** 🌍 - Works on Cloudflare Workers, Fastly Compute, Deno, Bun, AWS Lambda, Lambda@Edge, 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.
 - **Delightful DX** 😃 - Super clean APIs. First-class TypeScript support. Now, we've got "Types".

package/dist/adapter/deno/serve-static.js

@@ -5,6 +5,9 @@ var serveStatic = (options) => {
   return async function serveStatic2(c, next) {
     const getContent = async (path) => {
       try {
+        if (isDir(path)) {
+          return null;
+        }
         const file = await open(path);
         return file.readable;
       } catch (e) {

package/dist/cjs/adapter/deno/serve-static.js

@@ -27,6 +27,9 @@ const serveStatic = (options) => {
   return async function serveStatic2(c, next) {
     const getContent = async (path) => {
       try {
+        if (isDir(path)) {
+          return null;
+        }
         const file = await open(path);
         return file.readable;
       } catch (e) {

package/dist/cjs/hono-base.js

@@ -62,9 +62,7 @@ class Hono {
           this.#addRoute(method, this.#path, args1);
         }
         args.forEach((handler) => {
-          if (typeof handler !== "string") {
-            this.#addRoute(method, this.#path, handler);
-          }
+          this.#addRoute(method, this.#path, handler);
         });
         return this;
       };
@@ -106,15 +104,15 @@ class Hono {
     return clone;
   }
   #notFoundHandler = notFoundHandler;
-  #errorHandler = errorHandler;
+  errorHandler = errorHandler;
   route(path, app) {
     const subApp = this.basePath(path);
     app.routes.map((r) => {
       let handler;
-      if (app.#errorHandler === errorHandler) {
+      if (app.errorHandler === errorHandler) {
         handler = r.handler;
       } else {
-        handler = async (c, next) => (await (0, import_compose.compose)([], app.#errorHandler)(c, () => r.handler(c, next))).res;
+        handler = async (c, next) => (await (0, import_compose.compose)([], app.errorHandler)(c, () => r.handler(c, next))).res;
         handler[COMPOSED_HANDLER] = r.handler;
       }
       subApp.#addRoute(r.method, r.path, handler);
@@ -127,7 +125,7 @@ class Hono {
     return subApp;
   }
   onError = (handler) => {
-    this.#errorHandler = handler;
+    this.errorHandler = handler;
     return this;
   };
   notFound = (handler) => {
@@ -184,7 +182,7 @@ class Hono {
   }
   #handleError(err, c) {
     if (err instanceof Error) {
-      return this.#errorHandler(err, c);
+      return this.errorHandler(err, c);
     }
     throw err;
   }
@@ -214,7 +212,7 @@ class Hono {
         (resolved) => resolved || (c.finalized ? c.res : this.#notFoundHandler(c))
       ).catch((err) => this.#handleError(err, c)) : res ?? this.#notFoundHandler(c);
     }
-    const composed = (0, import_compose.compose)(matchResult[0], this.#errorHandler, this.#notFoundHandler);
+    const composed = (0, import_compose.compose)(matchResult[0], this.errorHandler, this.#notFoundHandler);
     return (async () => {
       try {
         const context = await composed(c);
@@ -234,15 +232,17 @@ class Hono {
   };
   request = (input, requestInit, Env, executionCtx) => {
     if (input instanceof Request) {
-      if (requestInit !== void 0) {
-        input = new Request(input, requestInit);
-      }
-      return this.fetch(input, Env, executionCtx);
+      return this.fetch(requestInit ? new Request(input, requestInit) : 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);
+    return this.fetch(
+      new Request(
+        /^https?:\/\//.test(input) ? input : `http://localhost${(0, import_url.mergePath)("/", input)}`,
+        requestInit
+      ),
+      Env,
+      executionCtx
+    );
   };
   fire = () => {
     addEventListener("fetch", (event) => {

package/dist/cjs/middleware/combine/index.js

@@ -51,16 +51,22 @@ const some = (...middleware) => {
   };
 };
 const every = (...middleware) => {
-  const wrappedMiddleware = middleware.map((m) => async (c, next) => {
-    const res = await m(c, next);
-    if (res === false) {
-      throw new Error("Unmet condition");
-    }
-    return res;
-  });
-  const handler = async (c, next) => (0, import_compose.compose)(wrappedMiddleware.map((m) => [[m, void 0], c.req.param()]))(c, next);
   return async function every2(c, next) {
-    await handler(c, next);
+    const currentRouteIndex = c.req.routeIndex;
+    await (0, import_compose.compose)(
+      middleware.map((m) => [
+        [
+          async (c2, next2) => {
+            c2.req.routeIndex = currentRouteIndex;
+            const res = await m(c2, next2);
+            if (res === false) {
+              throw new Error("Unmet condition");
+            }
+            return res;
+          }
+        ]
+      ])
+    )(c, next);
   };
 };
 const except = (condition, ...middleware) => {

package/dist/cjs/router/linear-router/router.js

@@ -28,17 +28,17 @@ const splitPathRe = /\/(:\w+(?:{(?:(?:{[\d,]+})|[^}])+})?)|\/[^\/\?]+|(\?)/g;
 const splitByStarRe = /\*/;
 class LinearRouter {
   name = "LinearRouter";
-  routes = [];
+  #routes = [];
   add(method, path, handler) {
     for (let i = 0, paths = (0, import_url.checkOptionalParameter)(path) || [path], len = paths.length; i < len; i++) {
-      this.routes.push([method, paths[i], handler]);
+      this.#routes.push([method, paths[i], handler]);
     }
   }
   match(method, path) {
     const handlers = [];
     ROUTES_LOOP:
-      for (let i = 0, len = this.routes.length; i < len; i++) {
-        const [routeMethod, routePath, handler] = this.routes[i];
+      for (let i = 0, len = this.#routes.length; i < len; i++) {
+        const [routeMethod, routePath, handler] = this.#routes[i];
         if (routeMethod === method || routeMethod === import_router.METHOD_NAME_ALL) {
           if (routePath === "*" || routePath === "/*") {
             handlers.push([handler, emptyParams]);

package/dist/cjs/router/reg-exp-router/node.js

@@ -47,18 +47,18 @@ function compareKey(a, b) {
   return a.length === b.length ? a < b ? -1 : 1 : b.length - a.length;
 }
 class Node {
-  index;
-  varIndex;
-  children = /* @__PURE__ */ Object.create(null);
+  #index;
+  #varIndex;
+  #children = /* @__PURE__ */ Object.create(null);
   insert(tokens, index, paramMap, context, pathErrorCheckOnly) {
     if (tokens.length === 0) {
-      if (this.index !== void 0) {
+      if (this.#index !== void 0) {
         throw PATH_ERROR;
       }
       if (pathErrorCheckOnly) {
         return;
       }
-      this.index = index;
+      this.#index = index;
       return;
     }
     const [token, ...restTokens] = tokens;
@@ -73,9 +73,9 @@ class Node {
           throw PATH_ERROR;
         }
       }
-      node = this.children[regexpStr];
+      node = this.#children[regexpStr];
       if (!node) {
-        if (Object.keys(this.children).some(
+        if (Object.keys(this.#children).some(
           (k) => k !== ONLY_WILDCARD_REG_EXP_STR && k !== TAIL_WILDCARD_REG_EXP_STR
         )) {
           throw PATH_ERROR;
@@ -83,18 +83,18 @@ class Node {
         if (pathErrorCheckOnly) {
           return;
         }
-        node = this.children[regexpStr] = new Node();
+        node = this.#children[regexpStr] = new Node();
         if (name !== "") {
-          node.varIndex = context.varIndex++;
+          node.#varIndex = context.varIndex++;
         }
       }
       if (!pathErrorCheckOnly && name !== "") {
-        paramMap.push([name, node.varIndex]);
+        paramMap.push([name, node.#varIndex]);
       }
     } else {
-      node = this.children[token];
+      node = this.#children[token];
       if (!node) {
-        if (Object.keys(this.children).some(
+        if (Object.keys(this.#children).some(
           (k) => k.length > 1 && k !== ONLY_WILDCARD_REG_EXP_STR && k !== TAIL_WILDCARD_REG_EXP_STR
         )) {
           throw PATH_ERROR;
@@ -102,19 +102,19 @@ class Node {
         if (pathErrorCheckOnly) {
           return;
         }
-        node = this.children[token] = new Node();
+        node = this.#children[token] = new Node();
       }
     }
     node.insert(restTokens, index, paramMap, context, pathErrorCheckOnly);
   }
   buildRegExpStr() {
-    const childKeys = Object.keys(this.children).sort(compareKey);
+    const childKeys = Object.keys(this.#children).sort(compareKey);
     const strList = childKeys.map((k) => {
-      const c = this.children[k];
-      return (typeof c.varIndex === "number" ? `(${k})@${c.varIndex}` : regExpMetaChars.has(k) ? `\\${k}` : k) + c.buildRegExpStr();
+      const c = this.#children[k];
+      return (typeof c.#varIndex === "number" ? `(${k})@${c.#varIndex}` : regExpMetaChars.has(k) ? `\\${k}` : k) + c.buildRegExpStr();
     });
-    if (typeof this.index === "number") {
-      strList.unshift(`#${this.index}`);
+    if (typeof this.#index === "number") {
+      strList.unshift(`#${this.#index}`);
     }
     if (strList.length === 0) {
       return "";

package/dist/cjs/router/reg-exp-router/router.js

@@ -109,14 +109,15 @@ function findMiddleware(middleware, path) {
 }
 class RegExpRouter {
   name = "RegExpRouter";
-  middleware;
-  routes;
+  #middleware;
+  #routes;
   constructor() {
-    this.middleware = { [import_router.METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
-    this.routes = { [import_router.METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
+    this.#middleware = { [import_router.METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
+    this.#routes = { [import_router.METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
   }
   add(method, path, handler) {
-    const { middleware, routes } = this;
+    const middleware = this.#middleware;
+    const routes = this.#routes;
     if (!middleware || !routes) {
       throw new Error(import_router.MESSAGE_MATCHER_IS_ALREADY_BUILT);
     }
@@ -191,16 +192,16 @@ class RegExpRouter {
   }
   #buildAllMatchers() {
     const matchers = /* @__PURE__ */ Object.create(null);
-    Object.keys(this.routes).concat(Object.keys(this.middleware)).forEach((method) => {
+    Object.keys(this.#routes).concat(Object.keys(this.#middleware)).forEach((method) => {
       matchers[method] ||= this.#buildMatcher(method);
     });
-    this.middleware = this.routes = void 0;
+    this.#middleware = this.#routes = void 0;
     return matchers;
   }
   #buildMatcher(method) {
     const routes = [];
     let hasOwnRoute = method === import_router.METHOD_NAME_ALL;
-    [this.middleware, this.routes].forEach((r) => {
+    [this.#middleware, this.#routes].forEach((r) => {
       const ownRoute = r[method] ? Object.keys(r[method]).map((path) => [path, r[method][path]]) : [];
       if (ownRoute.length !== 0) {
         hasOwnRoute ||= true;

package/dist/cjs/router/reg-exp-router/trie.js

@@ -23,8 +23,8 @@ __export(trie_exports, {
 module.exports = __toCommonJS(trie_exports);
 var import_node = require("./node");
 class Trie {
-  context = { varIndex: 0 };
-  root = new import_node.Node();
+  #context = { varIndex: 0 };
+  #root = new import_node.Node();
   insert(path, index, pathErrorCheckOnly) {
     const paramAssoc = [];
     const groups = [];
@@ -51,11 +51,11 @@ class Trie {
         }
       }
     }
-    this.root.insert(tokens, index, paramAssoc, this.context, pathErrorCheckOnly);
+    this.#root.insert(tokens, index, paramAssoc, this.#context, pathErrorCheckOnly);
     return paramAssoc;
   }
   buildRegExp() {
-    let regexp = this.root.buildRegExpStr();
+    let regexp = this.#root.buildRegExpStr();
     if (regexp === "") {
       return [/^$/, [], []];
     }

package/dist/cjs/router/smart-router/router.js

@@ -24,22 +24,23 @@ module.exports = __toCommonJS(router_exports);
 var import_router = require("../../router");
 class SmartRouter {
   name = "SmartRouter";
-  routers = [];
-  routes = [];
+  #routers = [];
+  #routes = [];
   constructor(init) {
-    Object.assign(this, init);
+    this.#routers = init.routers;
   }
   add(method, path, handler) {
-    if (!this.routes) {
+    if (!this.#routes) {
       throw new Error(import_router.MESSAGE_MATCHER_IS_ALREADY_BUILT);
     }
-    this.routes.push([method, path, handler]);
+    this.#routes.push([method, path, handler]);
   }
   match(method, path) {
-    if (!this.routes) {
+    if (!this.#routes) {
       throw new Error("Fatal error");
     }
-    const { routers, routes } = this;
+    const routers = this.#routers;
+    const routes = this.#routes;
     const len = routers.length;
     let i = 0;
     let res;
@@ -57,8 +58,8 @@ class SmartRouter {
         throw e;
       }
       this.match = router.match.bind(router);
-      this.routers = [router];
-      this.routes = void 0;
+      this.#routers = [router];
+      this.#routes = void 0;
       break;
     }
     if (i === len) {
@@ -68,10 +69,10 @@ class SmartRouter {
     return res;
   }
   get activeRouter() {
-    if (this.routes || this.routers.length !== 1) {
+    if (this.#routes || this.#routers.length !== 1) {
       throw new Error("No active router has been determined yet.");
     }
-    return this.routers[0];
+    return this.#routers[0];
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/cjs/router/trie-router/node.js

@@ -24,63 +24,60 @@ module.exports = __toCommonJS(node_exports);
 var import_router = require("../../router");
 var import_url = require("../../utils/url");
 class Node {
-  methods;
-  children;
-  patterns;
-  order = 0;
-  params = /* @__PURE__ */ Object.create(null);
+  #methods;
+  #children;
+  #patterns;
+  #order = 0;
+  #params = /* @__PURE__ */ Object.create(null);
   constructor(method, handler, children) {
-    this.children = children || /* @__PURE__ */ Object.create(null);
-    this.methods = [];
+    this.#children = children || /* @__PURE__ */ Object.create(null);
+    this.#methods = [];
     if (method && handler) {
       const m = /* @__PURE__ */ Object.create(null);
       m[method] = { handler, possibleKeys: [], score: 0 };
-      this.methods = [m];
+      this.#methods = [m];
     }
-    this.patterns = [];
+    this.#patterns = [];
   }
   insert(method, path, handler) {
-    this.order = ++this.order;
+    this.#order = ++this.#order;
     let curNode = this;
     const parts = (0, import_url.splitRoutingPath)(path);
     const possibleKeys = [];
     for (let i = 0, len = parts.length; i < len; i++) {
       const p = parts[i];
-      if (Object.keys(curNode.children).includes(p)) {
-        curNode = curNode.children[p];
+      if (Object.keys(curNode.#children).includes(p)) {
+        curNode = curNode.#children[p];
         const pattern2 = (0, import_url.getPattern)(p);
         if (pattern2) {
           possibleKeys.push(pattern2[1]);
         }
         continue;
       }
-      curNode.children[p] = new Node();
+      curNode.#children[p] = new Node();
       const pattern = (0, import_url.getPattern)(p);
       if (pattern) {
-        curNode.patterns.push(pattern);
+        curNode.#patterns.push(pattern);
         possibleKeys.push(pattern[1]);
       }
-      curNode = curNode.children[p];
-    }
-    if (!curNode.methods.length) {
-      curNode.methods = [];
+      curNode = curNode.#children[p];
     }
     const m = /* @__PURE__ */ Object.create(null);
     const handlerSet = {
       handler,
       possibleKeys: possibleKeys.filter((v, i, a) => a.indexOf(v) === i),
-      score: this.order
+      score: this.#order
     };
     m[method] = handlerSet;
-    curNode.methods.push(m);
+    curNode.#methods.push(m);
     return curNode;
   }
-  #gHSets(node, method, nodeParams, params) {
+  #getHandlerSets(node, method, nodeParams, params) {
     const handlerSets = [];
-    for (let i = 0, len = node.methods.length; i < len; i++) {
-      const m = node.methods[i];
+    for (let i = 0, len = node.#methods.length; i < len; i++) {
+      const m = node.#methods[i];
       const handlerSet = m[method] || m[import_router.METHOD_NAME_ALL];
-      const processedSet = /* @__PURE__ */ Object.create(null);
+      const processedSet = {};
       if (handlerSet !== void 0) {
         handlerSet.params = /* @__PURE__ */ Object.create(null);
         for (let i2 = 0, len2 = handlerSet.possibleKeys.length; i2 < len2; i2++) {
@@ -96,7 +93,7 @@ class Node {
   }
   search(method, path) {
     const handlerSets = [];
-    this.params = /* @__PURE__ */ Object.create(null);
+    this.#params = /* @__PURE__ */ Object.create(null);
     const curNode = this;
     let curNodes = [curNode];
     const parts = (0, import_url.splitPath)(path);
@@ -106,27 +103,36 @@ class Node {
       const tempNodes = [];
       for (let j = 0, len2 = curNodes.length; j < len2; j++) {
         const node = curNodes[j];
-        const nextNode = node.children[part];
+        const nextNode = node.#children[part];
         if (nextNode) {
-          nextNode.params = node.params;
+          nextNode.#params = node.#params;
           if (isLast) {
-            if (nextNode.children["*"]) {
+            if (nextNode.#children["*"]) {
               handlerSets.push(
-                ...this.#gHSets(nextNode.children["*"], method, node.params, /* @__PURE__ */ Object.create(null))
+                ...this.#getHandlerSets(
+                  nextNode.#children["*"],
+                  method,
+                  node.#params,
+                  /* @__PURE__ */ Object.create(null)
+                )
               );
             }
-            handlerSets.push(...this.#gHSets(nextNode, method, node.params, /* @__PURE__ */ Object.create(null)));
+            handlerSets.push(
+              ...this.#getHandlerSets(nextNode, method, node.#params, /* @__PURE__ */ Object.create(null))
+            );
           } else {
             tempNodes.push(nextNode);
           }
         }
-        for (let k = 0, len3 = node.patterns.length; k < len3; k++) {
-          const pattern = node.patterns[k];
-          const params = { ...node.params };
+        for (let k = 0, len3 = node.#patterns.length; k < len3; k++) {
+          const pattern = node.#patterns[k];
+          const params = { ...node.#params };
           if (pattern === "*") {
-            const astNode = node.children["*"];
+            const astNode = node.#children["*"];
             if (astNode) {
-              handlerSets.push(...this.#gHSets(astNode, method, node.params, /* @__PURE__ */ Object.create(null)));
+              handlerSets.push(
+                ...this.#getHandlerSets(astNode, method, node.#params, /* @__PURE__ */ Object.create(null))
+              );
               tempNodes.push(astNode);
             }
             continue;
@@ -135,27 +141,25 @@ class Node {
             continue;
           }
           const [key, name, matcher] = pattern;
-          const child = node.children[key];
+          const child = node.#children[key];
           const restPathString = parts.slice(i).join("/");
           if (matcher instanceof RegExp && matcher.test(restPathString)) {
             params[name] = restPathString;
-            handlerSets.push(...this.#gHSets(child, method, node.params, params));
+            handlerSets.push(...this.#getHandlerSets(child, method, node.#params, params));
             continue;
           }
           if (matcher === true || matcher.test(part)) {
-            if (typeof key === "string") {
-              params[name] = part;
-              if (isLast) {
-                handlerSets.push(...this.#gHSets(child, method, params, node.params));
-                if (child.children["*"]) {
-                  handlerSets.push(
-                    ...this.#gHSets(child.children["*"], method, params, node.params)
-                  );
-                }
-              } else {
-                child.params = params;
-                tempNodes.push(child);
+            params[name] = part;
+            if (isLast) {
+              handlerSets.push(...this.#getHandlerSets(child, method, params, node.#params));
+              if (child.#children["*"]) {
+                handlerSets.push(
+                  ...this.#getHandlerSets(child.#children["*"], method, params, node.#params)
+                );
               }
+            } else {
+              child.#params = params;
+              tempNodes.push(child);
             }
           }
         }

package/dist/cjs/router/trie-router/router.js

@@ -25,22 +25,22 @@ var import_url = require("../../utils/url");
 var import_node = require("./node");
 class TrieRouter {
   name = "TrieRouter";
-  node;
+  #node;
   constructor() {
-    this.node = new import_node.Node();
+    this.#node = new import_node.Node();
   }
   add(method, path, handler) {
     const results = (0, import_url.checkOptionalParameter)(path);
     if (results) {
       for (let i = 0, len = results.length; i < len; i++) {
-        this.node.insert(method, results[i], handler);
+        this.#node.insert(method, results[i], handler);
       }
       return;
     }
-    this.node.insert(method, path, handler);
+    this.#node.insert(method, path, handler);
   }
   match(method, path) {
-    return this.node.search(method, path);
+    return this.#node.search(method, path);
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/hono-base.js

@@ -39,9 +39,7 @@ var Hono = class {
           this.#addRoute(method, this.#path, args1);
         }
         args.forEach((handler) => {
-          if (typeof handler !== "string") {
-            this.#addRoute(method, this.#path, handler);
-          }
+          this.#addRoute(method, this.#path, handler);
         });
         return this;
       };
@@ -83,15 +81,15 @@ var Hono = class {
     return clone;
   }
   #notFoundHandler = notFoundHandler;
-  #errorHandler = errorHandler;
+  errorHandler = errorHandler;
   route(path, app) {
     const subApp = this.basePath(path);
     app.routes.map((r) => {
       let handler;
-      if (app.#errorHandler === errorHandler) {
+      if (app.errorHandler === errorHandler) {
         handler = r.handler;
       } else {
-        handler = async (c, next) => (await compose([], app.#errorHandler)(c, () => r.handler(c, next))).res;
+        handler = async (c, next) => (await compose([], app.errorHandler)(c, () => r.handler(c, next))).res;
         handler[COMPOSED_HANDLER] = r.handler;
       }
       subApp.#addRoute(r.method, r.path, handler);
@@ -104,7 +102,7 @@ var Hono = class {
     return subApp;
   }
   onError = (handler) => {
-    this.#errorHandler = handler;
+    this.errorHandler = handler;
     return this;
   };
   notFound = (handler) => {
@@ -161,7 +159,7 @@ var Hono = class {
   }
   #handleError(err, c) {
     if (err instanceof Error) {
-      return this.#errorHandler(err, c);
+      return this.errorHandler(err, c);
     }
     throw err;
   }
@@ -191,7 +189,7 @@ var Hono = class {
         (resolved) => resolved || (c.finalized ? c.res : this.#notFoundHandler(c))
       ).catch((err) => this.#handleError(err, c)) : res ?? this.#notFoundHandler(c);
     }
-    const composed = compose(matchResult[0], this.#errorHandler, this.#notFoundHandler);
+    const composed = compose(matchResult[0], this.errorHandler, this.#notFoundHandler);
     return (async () => {
       try {
         const context = await composed(c);
@@ -211,15 +209,17 @@ var Hono = class {
   };
   request = (input, requestInit, Env, executionCtx) => {
     if (input instanceof Request) {
-      if (requestInit !== void 0) {
-        input = new Request(input, requestInit);
-      }
-      return this.fetch(input, Env, executionCtx);
+      return this.fetch(requestInit ? new Request(input, requestInit) : input, Env, executionCtx);
     }
     input = input.toString();
-    const path = /^https?:\/\//.test(input) ? input : `http://localhost${mergePath("/", input)}`;
-    const req = new Request(path, requestInit);
-    return this.fetch(req, Env, executionCtx);
+    return this.fetch(
+      new Request(
+        /^https?:\/\//.test(input) ? input : `http://localhost${mergePath("/", input)}`,
+        requestInit
+      ),
+      Env,
+      executionCtx
+    );
   };
   fire = () => {
     addEventListener("fetch", (event) => {