hono 4.0.10 → 4.1.0

package/dist/context.js

@@ -1,22 +1,3 @@
-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;
-};
-
 // src/context.ts
 import { resolveCallback, HtmlEscapedCallbackPhase } from "./utils/html.js";
 var TEXT_PLAIN = "text/plain; charset=UTF-8";
@@ -24,158 +5,25 @@ var setHeaders = (headers, map = {}) => {
   Object.entries(map).forEach(([key, value]) => headers.set(key, value));
   return headers;
 };
-var _status, _executionCtx, _headers, _preparedHeaders, _res, _isFresh;
 var Context = class {
+  req;
+  env = {};
+  _var = {};
+  finalized = false;
+  error = void 0;
+  #status = 200;
+  #executionCtx;
+  #headers = void 0;
+  #preparedHeaders = void 0;
+  #res;
+  #isFresh = true;
+  layout = void 0;
+  renderer = (content) => this.html(content);
+  notFoundHandler = () => new Response();
   constructor(req, options) {
-    this.env = {};
-    this._var = {};
-    this.finalized = false;
-    this.error = void 0;
-    __privateAdd(this, _status, 200);
-    __privateAdd(this, _executionCtx, void 0);
-    __privateAdd(this, _headers, void 0);
-    __privateAdd(this, _preparedHeaders, void 0);
-    __privateAdd(this, _res, void 0);
-    __privateAdd(this, _isFresh, true);
-    this.layout = void 0;
-    this.renderer = (content) => this.html(content);
-    this.notFoundHandler = () => new Response();
-    this.render = (...args) => this.renderer(...args);
-    this.setLayout = (layout) => this.layout = layout;
-    this.getLayout = () => this.layout;
-    this.setRenderer = (renderer) => {
-      this.renderer = renderer;
-    };
-    this.header = (name, value, options) => {
-      if (value === void 0) {
-        if (__privateGet(this, _headers)) {
-          __privateGet(this, _headers).delete(name);
-        } else if (__privateGet(this, _preparedHeaders)) {
-          delete __privateGet(this, _preparedHeaders)[name.toLocaleLowerCase()];
-        }
-        if (this.finalized) {
-          this.res.headers.delete(name);
-        }
-        return;
-      }
-      if (options?.append) {
-        if (!__privateGet(this, _headers)) {
-          __privateSet(this, _isFresh, false);
-          __privateSet(this, _headers, new Headers(__privateGet(this, _preparedHeaders)));
-          __privateSet(this, _preparedHeaders, {});
-        }
-        __privateGet(this, _headers).append(name, value);
-      } else {
-        if (__privateGet(this, _headers)) {
-          __privateGet(this, _headers).set(name, value);
-        } else {
-          __privateGet(this, _preparedHeaders) ?? __privateSet(this, _preparedHeaders, {});
-          __privateGet(this, _preparedHeaders)[name.toLowerCase()] = value;
-        }
-      }
-      if (this.finalized) {
-        if (options?.append) {
-          this.res.headers.append(name, value);
-        } else {
-          this.res.headers.set(name, value);
-        }
-      }
-    };
-    this.status = (status) => {
-      __privateSet(this, _isFresh, false);
-      __privateSet(this, _status, status);
-    };
-    this.set = (key, value) => {
-      this._var ?? (this._var = {});
-      this._var[key] = value;
-    };
-    this.get = (key) => {
-      return this._var ? this._var[key] : void 0;
-    };
-    this.newResponse = (data, arg, headers) => {
-      if (__privateGet(this, _isFresh) && !headers && !arg && __privateGet(this, _status) === 200) {
-        return new Response(data, {
-          headers: __privateGet(this, _preparedHeaders)
-        });
-      }
-      if (arg && typeof arg !== "number") {
-        const headers2 = setHeaders(new Headers(arg.headers), __privateGet(this, _preparedHeaders));
-        return new Response(data, {
-          headers: headers2,
-          status: arg.status ?? __privateGet(this, _status)
-        });
-      }
-      const status = typeof arg === "number" ? arg : __privateGet(this, _status);
-      __privateGet(this, _preparedHeaders) ?? __privateSet(this, _preparedHeaders, {});
-      __privateGet(this, _headers) ?? __privateSet(this, _headers, new Headers());
-      setHeaders(__privateGet(this, _headers), __privateGet(this, _preparedHeaders));
-      if (__privateGet(this, _res)) {
-        __privateGet(this, _res).headers.forEach((v, k) => {
-          __privateGet(this, _headers)?.set(k, v);
-        });
-        setHeaders(__privateGet(this, _headers), __privateGet(this, _preparedHeaders));
-      }
-      headers ?? (headers = {});
-      for (const [k, v] of Object.entries(headers)) {
-        if (typeof v === "string") {
-          __privateGet(this, _headers).set(k, v);
-        } else {
-          __privateGet(this, _headers).delete(k);
-          for (const v2 of v) {
-            __privateGet(this, _headers).append(k, v2);
-          }
-        }
-      }
-      return new Response(data, {
-        status,
-        headers: __privateGet(this, _headers)
-      });
-    };
-    this.body = (data, arg, headers) => {
-      return typeof arg === "number" ? this.newResponse(data, arg, headers) : this.newResponse(data, arg);
-    };
-    this.text = (text, arg, headers) => {
-      if (!__privateGet(this, _preparedHeaders)) {
-        if (__privateGet(this, _isFresh) && !headers && !arg) {
-          return new Response(text);
-        }
-        __privateSet(this, _preparedHeaders, {});
-      }
-      __privateGet(this, _preparedHeaders)["content-type"] = TEXT_PLAIN;
-      return typeof arg === "number" ? this.newResponse(text, arg, headers) : this.newResponse(text, arg);
-    };
-    this.json = (object, arg, headers) => {
-      const body = JSON.stringify(object);
-      __privateGet(this, _preparedHeaders) ?? __privateSet(this, _preparedHeaders, {});
-      __privateGet(this, _preparedHeaders)["content-type"] = "application/json; charset=UTF-8";
-      return typeof arg === "number" ? this.newResponse(body, arg, headers) : this.newResponse(body, arg);
-    };
-    this.html = (html, arg, headers) => {
-      __privateGet(this, _preparedHeaders) ?? __privateSet(this, _preparedHeaders, {});
-      __privateGet(this, _preparedHeaders)["content-type"] = "text/html; charset=UTF-8";
-      if (typeof html === "object") {
-        if (!(html instanceof Promise)) {
-          html = html.toString();
-        }
-        if (html instanceof Promise) {
-          return html.then((html2) => resolveCallback(html2, HtmlEscapedCallbackPhase.Stringify, false, {})).then((html2) => {
-            return typeof arg === "number" ? this.newResponse(html2, arg, headers) : this.newResponse(html2, arg);
-          });
-        }
-      }
-      return typeof arg === "number" ? this.newResponse(html, arg, headers) : this.newResponse(html, arg);
-    };
-    this.redirect = (location, status = 302) => {
-      __privateGet(this, _headers) ?? __privateSet(this, _headers, new Headers());
-      __privateGet(this, _headers).set("Location", location);
-      return this.newResponse(null, status);
-    };
-    this.notFound = () => {
-      return this.notFoundHandler(this);
-    };
     this.req = req;
     if (options) {
-      __privateSet(this, _executionCtx, options.executionCtx);
+      this.#executionCtx = options.executionCtx;
       this.env = options.env;
       if (options.notFoundHandler) {
         this.notFoundHandler = options.notFoundHandler;
@@ -183,52 +31,179 @@ var Context = class {
     }
   }
   get event() {
-    if (__privateGet(this, _executionCtx) && "respondWith" in __privateGet(this, _executionCtx)) {
-      return __privateGet(this, _executionCtx);
+    if (this.#executionCtx && "respondWith" in this.#executionCtx) {
+      return this.#executionCtx;
     } else {
       throw Error("This context has no FetchEvent");
     }
   }
   get executionCtx() {
-    if (__privateGet(this, _executionCtx)) {
-      return __privateGet(this, _executionCtx);
+    if (this.#executionCtx) {
+      return this.#executionCtx;
     } else {
       throw Error("This context has no ExecutionContext");
     }
   }
   get res() {
-    __privateSet(this, _isFresh, false);
-    return __privateGet(this, _res) || __privateSet(this, _res, new Response("404 Not Found", { status: 404 }));
+    this.#isFresh = false;
+    return this.#res ||= new Response("404 Not Found", { status: 404 });
   }
-  set res(_res2) {
-    __privateSet(this, _isFresh, false);
-    if (__privateGet(this, _res) && _res2) {
-      __privateGet(this, _res).headers.delete("content-type");
-      for (const [k, v] of __privateGet(this, _res).headers.entries()) {
+  set res(_res) {
+    this.#isFresh = false;
+    if (this.#res && _res) {
+      this.#res.headers.delete("content-type");
+      for (const [k, v] of this.#res.headers.entries()) {
         if (k === "set-cookie") {
-          const cookies = __privateGet(this, _res).headers.getSetCookie();
-          _res2.headers.delete("set-cookie");
+          const cookies = this.#res.headers.getSetCookie();
+          _res.headers.delete("set-cookie");
           for (const cookie of cookies) {
-            _res2.headers.append("set-cookie", cookie);
+            _res.headers.append("set-cookie", cookie);
           }
         } else {
-          _res2.headers.set(k, v);
+          _res.headers.set(k, v);
         }
       }
     }
-    __privateSet(this, _res, _res2);
+    this.#res = _res;
     this.finalized = true;
   }
+  render = (...args) => this.renderer(...args);
+  setLayout = (layout) => this.layout = layout;
+  getLayout = () => this.layout;
+  setRenderer = (renderer) => {
+    this.renderer = renderer;
+  };
+  header = (name, value, options) => {
+    if (value === void 0) {
+      if (this.#headers) {
+        this.#headers.delete(name);
+      } else if (this.#preparedHeaders) {
+        delete this.#preparedHeaders[name.toLocaleLowerCase()];
+      }
+      if (this.finalized) {
+        this.res.headers.delete(name);
+      }
+      return;
+    }
+    if (options?.append) {
+      if (!this.#headers) {
+        this.#isFresh = false;
+        this.#headers = new Headers(this.#preparedHeaders);
+        this.#preparedHeaders = {};
+      }
+      this.#headers.append(name, value);
+    } else {
+      if (this.#headers) {
+        this.#headers.set(name, value);
+      } else {
+        this.#preparedHeaders ??= {};
+        this.#preparedHeaders[name.toLowerCase()] = value;
+      }
+    }
+    if (this.finalized) {
+      if (options?.append) {
+        this.res.headers.append(name, value);
+      } else {
+        this.res.headers.set(name, value);
+      }
+    }
+  };
+  status = (status) => {
+    this.#isFresh = false;
+    this.#status = status;
+  };
+  set = (key, value) => {
+    this._var ??= {};
+    this._var[key] = value;
+  };
+  get = (key) => {
+    return this._var ? this._var[key] : void 0;
+  };
   get var() {
     return { ...this._var };
   }
+  newResponse = (data, arg, headers) => {
+    if (this.#isFresh && !headers && !arg && this.#status === 200) {
+      return new Response(data, {
+        headers: this.#preparedHeaders
+      });
+    }
+    if (arg && typeof arg !== "number") {
+      const headers2 = setHeaders(new Headers(arg.headers), this.#preparedHeaders);
+      return new Response(data, {
+        headers: headers2,
+        status: arg.status ?? this.#status
+      });
+    }
+    const status = typeof arg === "number" ? arg : this.#status;
+    this.#preparedHeaders ??= {};
+    this.#headers ??= new Headers();
+    setHeaders(this.#headers, this.#preparedHeaders);
+    if (this.#res) {
+      this.#res.headers.forEach((v, k) => {
+        this.#headers?.set(k, v);
+      });
+      setHeaders(this.#headers, this.#preparedHeaders);
+    }
+    headers ??= {};
+    for (const [k, v] of Object.entries(headers)) {
+      if (typeof v === "string") {
+        this.#headers.set(k, v);
+      } else {
+        this.#headers.delete(k);
+        for (const v2 of v) {
+          this.#headers.append(k, v2);
+        }
+      }
+    }
+    return new Response(data, {
+      status,
+      headers: this.#headers
+    });
+  };
+  body = (data, arg, headers) => {
+    return typeof arg === "number" ? this.newResponse(data, arg, headers) : this.newResponse(data, arg);
+  };
+  text = (text, arg, headers) => {
+    if (!this.#preparedHeaders) {
+      if (this.#isFresh && !headers && !arg) {
+        return new Response(text);
+      }
+      this.#preparedHeaders = {};
+    }
+    this.#preparedHeaders["content-type"] = TEXT_PLAIN;
+    return typeof arg === "number" ? this.newResponse(text, arg, headers) : this.newResponse(text, arg);
+  };
+  json = (object, arg, headers) => {
+    const body = JSON.stringify(object);
+    this.#preparedHeaders ??= {};
+    this.#preparedHeaders["content-type"] = "application/json; charset=UTF-8";
+    return typeof arg === "number" ? this.newResponse(body, arg, headers) : this.newResponse(body, arg);
+  };
+  html = (html, arg, headers) => {
+    this.#preparedHeaders ??= {};
+    this.#preparedHeaders["content-type"] = "text/html; charset=UTF-8";
+    if (typeof html === "object") {
+      if (!(html instanceof Promise)) {
+        html = html.toString();
+      }
+      if (html instanceof Promise) {
+        return html.then((html2) => resolveCallback(html2, HtmlEscapedCallbackPhase.Stringify, false, {})).then((html2) => {
+          return typeof arg === "number" ? this.newResponse(html2, arg, headers) : this.newResponse(html2, arg);
+        });
+      }
+    }
+    return typeof arg === "number" ? this.newResponse(html, arg, headers) : this.newResponse(html, arg);
+  };
+  redirect = (location, status = 302) => {
+    this.#headers ??= new Headers();
+    this.#headers.set("Location", location);
+    return this.newResponse(null, status);
+  };
+  notFound = () => {
+    return this.notFoundHandler(this);
+  };
 };
-_status = new WeakMap();
-_executionCtx = new WeakMap();
-_headers = new WeakMap();
-_preparedHeaders = new WeakMap();
-_res = new WeakMap();
-_isFresh = new WeakMap();
 export {
   Context,
   TEXT_PLAIN

package/dist/helper/adapter/index.js

@@ -2,7 +2,7 @@
 var env = (c, runtime) => {
   const global = globalThis;
   const globalEnv = global?.process?.env;
-  runtime ?? (runtime = getRuntimeKey());
+  runtime ??= getRuntimeKey();
   const runtimeEnvHandlers = {
     bun: () => globalEnv,
     node: () => globalEnv,

package/dist/helper/cookie/index.js

@@ -1,13 +1,19 @@
 // src/helper/cookie/index.ts
 import { parse, parseSigned, serialize, serializeSigned } from "../../utils/cookie.js";
-var getCookie = (c, key) => {
+var getCookie = (c, key, prefix) => {
   const cookie = c.req.raw.headers.get("Cookie");
   if (typeof key === "string") {
     if (!cookie) {
       return void 0;
     }
-    const obj2 = parse(cookie, key);
-    return obj2[key];
+    let finalKey = key;
+    if (prefix === "secure") {
+      finalKey = "__Secure-" + key;
+    } else if (prefix === "host") {
+      finalKey = "__Host-" + key;
+    }
+    const obj2 = parse(cookie, finalKey);
+    return obj2[finalKey];
   }
   if (!cookie) {
     return {};
@@ -15,14 +21,20 @@ var getCookie = (c, key) => {
   const obj = parse(cookie);
   return obj;
 };
-var getSignedCookie = async (c, secret, key) => {
+var getSignedCookie = async (c, secret, key, prefix) => {
   const cookie = c.req.raw.headers.get("Cookie");
   if (typeof key === "string") {
     if (!cookie) {
       return void 0;
     }
-    const obj2 = await parseSigned(cookie, secret, key);
-    return obj2[key];
+    let finalKey = key;
+    if (prefix === "secure") {
+      finalKey = "__Secure-" + key;
+    } else if (prefix === "host") {
+      finalKey = "__Host-" + key;
+    }
+    const obj2 = await parseSigned(cookie, secret, finalKey);
+    return obj2[finalKey];
   }
   if (!cookie) {
     return {};
@@ -31,11 +43,39 @@ var getSignedCookie = async (c, secret, key) => {
   return obj;
 };
 var setCookie = (c, name, value, opt) => {
-  const cookie = serialize(name, value, { path: "/", ...opt });
+  let cookie;
+  if (opt?.prefix === "secure") {
+    cookie = serialize("__Secure-" + name, value, { path: "/", ...opt, secure: true });
+  } else if (opt?.prefix === "host") {
+    cookie = serialize("__Host-" + name, value, {
+      ...opt,
+      path: "/",
+      secure: true,
+      domain: void 0
+    });
+  } else {
+    cookie = serialize(name, value, { path: "/", ...opt });
+  }
   c.header("set-cookie", cookie, { append: true });
 };
 var setSignedCookie = async (c, name, value, secret, opt) => {
-  const cookie = await serializeSigned(name, value, secret, { path: "/", ...opt });
+  let cookie;
+  if (opt?.prefix === "secure") {
+    cookie = await serializeSigned("__Secure-" + name, value, secret, {
+      path: "/",
+      ...opt,
+      secure: true
+    });
+  } else if (opt?.prefix === "host") {
+    cookie = await serializeSigned("__Host-" + name, value, secret, {
+      ...opt,
+      path: "/",
+      secure: true,
+      domain: void 0
+    });
+  } else {
+    cookie = await serializeSigned(name, value, secret, { path: "/", ...opt });
+  }
   c.header("set-cookie", cookie, { append: true });
 };
 var deleteCookie = (c, name, opt) => {

package/dist/helper/dev/index.js

@@ -1,4 +1,5 @@
 // src/helper/dev/index.ts
+import { getColorEnabled } from "../../utils/color.js";
 import { findTargetHandler, isMiddleware } from "../../utils/handler.js";
 var handlerName = (handler) => {
   return handler.name || (isMiddleware(handler) ? "[middleware]" : "[handler]");
@@ -15,15 +16,13 @@ var inspectRoutes = (hono) => {
   });
 };
 var showRoutes = (hono, opts) => {
-  const { process, Deno } = globalThis;
-  const isNoColor = typeof process !== "undefined" ? "NO_COLOR" in process?.env : typeof Deno?.noColor === "boolean" ? Deno.noColor : false;
-  const colorEnabled = opts?.colorize ?? !isNoColor;
+  const colorEnabled = opts?.colorize ?? getColorEnabled();
   const routeData = {};
   let maxMethodLength = 0;
   let maxPathLength = 0;
   inspectRoutes(hono).filter(({ isMiddleware: isMiddleware2 }) => opts?.verbose || !isMiddleware2).map((route) => {
     const key = `${route.method}-${route.path}`;
-    (routeData[key] || (routeData[key] = [])).push(route);
+    (routeData[key] ||= []).push(route);
     if (routeData[key].length > 1) {
       return;
     }

package/dist/helper/factory/index.js

@@ -1,8 +1,6 @@
 // src/helper/factory/index.ts
 var Factory = class {
-  constructor() {
-    this.createMiddleware = (middleware) => middleware;
-  }
+  createMiddleware = (middleware) => middleware;
   createHandlers(...handlers) {
     return handlers.filter((handler) => handler !== void 0);
   }

package/dist/helper/ssg/index.js

@@ -1,158 +1,10 @@
 // src/helper/ssg/index.ts
-import { replaceUrlParam } from "../../client/utils.js";
-import { getExtension } from "../../utils/mime.js";
-import { joinPaths, dirname, filterStaticGenerateRoutes } from "./utils.js";
-var SSG_CONTEXT = "HONO_SSG_CONTEXT";
-var SSG_DISABLED_RESPONSE = new Response("SSG is disabled", { status: 404 });
-var generateFilePath = (routePath, outDir, mimeType) => {
-  const extension = determineExtension(mimeType);
-  if (routePath.endsWith(`.${extension}`)) {
-    return joinPaths(outDir, routePath);
-  }
-  if (routePath === "/") {
-    return joinPaths(outDir, `index.${extension}`);
-  }
-  if (routePath.endsWith("/")) {
-    return joinPaths(outDir, routePath, `index.${extension}`);
-  }
-  return joinPaths(outDir, `${routePath}.${extension}`);
-};
-var 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"}`
-    );
-  }
-};
-var determineExtension = (mimeType) => {
-  switch (mimeType) {
-    case "text/html":
-      return "html";
-    case "text/xml":
-    case "application/xml":
-      return "xml";
-    default: {
-      return getExtension(mimeType) || "html";
-    }
-  }
-};
-var ssgParams = (params) => async (c, next) => {
-  ;
-  c.req.raw.ssgParams = Array.isArray(params) ? params : await params(c);
-  await next();
-};
-var fetchRoutesContent = async (app, beforeRequestHook, afterResponseHook) => {
-  const htmlMap = /* @__PURE__ */ new Map();
-  const baseURL = "http://localhost";
-  for (const route of 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 = 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;
-};
-var isDynamicRoute = (path) => {
-  return path.split("/").some((segment) => segment.startsWith(":") || segment.includes("*"));
-};
-var saveContentToFiles = async (htmlMap, fsModule, outDir) => {
-  const files = [];
-  for (const [routePath, { content, mimeType }] of htmlMap) {
-    const filePath = generateFilePath(routePath, outDir, mimeType);
-    const dirPath = 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;
-};
-var 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;
-};
-var isSSGContext = (c) => !!c.env?.[SSG_CONTEXT];
-var disableSSG = () => async function disableSSG2(c, next) {
-  if (isSSGContext(c)) {
-    return SSG_DISABLED_RESPONSE;
-  }
-  await next();
-};
-var onlySSG = () => async function onlySSG2(c, next) {
-  if (!isSSGContext(c)) {
-    return c.notFound();
-  }
-  await next();
-};
+export * from "./ssg.js";
+import { SSG_DISABLED_RESPONSE, ssgParams, isSSGContext, disableSSG, onlySSG } from "./middleware.js";
 export {
   SSG_DISABLED_RESPONSE,
   disableSSG,
-  fetchRoutesContent,
   isSSGContext,
   onlySSG,
-  saveContentToFiles,
-  ssgParams,
-  toSSG
+  ssgParams
 };