pome-sh 0.6.6

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

@@ -0,0 +1,320 @@
+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, {
+  DEFAULT_OUTPUT_DIR: () => DEFAULT_OUTPUT_DIR,
+  combineAfterGenerateHooks: () => combineAfterGenerateHooks,
+  combineAfterResponseHooks: () => combineAfterResponseHooks,
+  combineBeforeRequestHooks: () => combineBeforeRequestHooks,
+  defaultExtensionMap: () => defaultExtensionMap,
+  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_plugins = require("./plugins");
+var import_utils2 = require("./utils");
+const DEFAULT_CONCURRENCY = 2;
+const DEFAULT_CONTENT_TYPE = "text/plain";
+const DEFAULT_OUTPUT_DIR = "./static";
+const generateFilePath = (routePath, outDir, mimeType, extensionMap) => {
+  const extension = determineExtension(mimeType, extensionMap);
+  let filePath;
+  if (routePath.endsWith(`.${extension}`)) {
+    filePath = (0, import_utils2.joinPaths)(outDir, routePath);
+  } else if (routePath === "/") {
+    filePath = (0, import_utils2.joinPaths)(outDir, `index.${extension}`);
+  } else if (routePath.endsWith("/")) {
+    filePath = (0, import_utils2.joinPaths)(outDir, routePath, `index.${extension}`);
+  } else {
+    filePath = (0, import_utils2.joinPaths)(outDir, `${routePath}.${extension}`);
+  }
+  (0, import_utils2.ensureWithinOutDir)(outDir, filePath);
+  return filePath;
+};
+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 defaultExtensionMap = {
+  "text/html": "html",
+  "text/xml": "xml",
+  "application/xml": "xml",
+  "application/atom+xml": "xml",
+  "application/rss+xml": "xml",
+  "application/yaml": "yaml"
+};
+const determineExtension = (mimeType, userExtensionMap) => {
+  const extensionMap = userExtensionMap || defaultExtensionMap;
+  if (mimeType in extensionMap) {
+    return extensionMap[mimeType];
+  }
+  return (0, import_mime.getExtension)(mimeType) || "html";
+};
+const combineBeforeRequestHooks = (hooks) => {
+  if (!Array.isArray(hooks)) {
+    return hooks;
+  }
+  return async (req) => {
+    let currentReq = req;
+    for (const hook of hooks) {
+      const result = await hook(currentReq);
+      if (result === false) {
+        return false;
+      }
+      if (result instanceof Request) {
+        currentReq = result;
+      }
+    }
+    return currentReq;
+  };
+};
+const combineAfterResponseHooks = (hooks) => {
+  if (!Array.isArray(hooks)) {
+    return hooks;
+  }
+  return async (res) => {
+    let currentRes = res;
+    for (const hook of hooks) {
+      const result = await hook(currentRes);
+      if (result === false) {
+        return false;
+      }
+      if (result instanceof Response) {
+        currentRes = result;
+      }
+    }
+    return currentRes;
+  };
+};
+const combineAfterGenerateHooks = (hooks, fsModule, options) => {
+  if (!Array.isArray(hooks)) {
+    return hooks;
+  }
+  return async (result) => {
+    for (const hook of hooks) {
+      await hook(result, fsModule, options);
+    }
+  };
+};
+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);
+    yield new Promise(async (resolveGetInfo, rejectGetInfo) => {
+      try {
+        if (beforeRequestHook) {
+          const maybeRequest = await beforeRequestHook(forGetInfoURLRequest);
+          if (!maybeRequest) {
+            resolveGetInfo(void 0);
+            return;
+          }
+          forGetInfoURLRequest = maybeRequest;
+        }
+        await pool.run(() => app.fetch(forGetInfoURLRequest, { [import_middleware.SSG_CONTEXT]: true }));
+        if (!forGetInfoURLRequest.ssgParams) {
+          if ((0, import_utils2.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.headers.get(import_middleware.X_HONO_DISABLE_SSG_HEADER_KEY)) {
+                    resolveReq(void 0);
+                    return;
+                  }
+                  if (afterResponseHook) {
+                    const maybeResponse = await afterResponseHook(response);
+                    if (!maybeResponse) {
+                      resolveReq(void 0);
+                      return;
+                    }
+                    response = maybeResponse;
+                  }
+                  const mimeType = response.headers.get("Content-Type")?.split(";")[0] || DEFAULT_CONTENT_TYPE;
+                  const content = await parseResponseContent(response);
+                  resolveReq({
+                    routePath: replacedUrlParam,
+                    mimeType,
+                    content
+                  });
+                } catch (error) {
+                  rejectReq(error);
+                }
+              });
+            }
+          })()
+        );
+      } catch (error) {
+        rejectGetInfo(error);
+      }
+    });
+  }
+};
+const createdDirs = /* @__PURE__ */ new Set();
+const saveContentToFile = async (data, fsModule, outDir, extensionMap) => {
+  const awaitedData = await data;
+  if (!awaitedData) {
+    return;
+  }
+  const { routePath, content, mimeType } = awaitedData;
+  const filePath = generateFilePath(routePath, outDir, mimeType, extensionMap);
+  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;
+  const getInfoPromises = [];
+  const savePromises = [];
+  const plugins = options?.plugins || [(0, import_plugins.defaultPlugin)()];
+  const beforeRequestHooks = [];
+  const afterResponseHooks = [];
+  const afterGenerateHooks = [];
+  if (options?.beforeRequestHook) {
+    beforeRequestHooks.push(
+      ...Array.isArray(options.beforeRequestHook) ? options.beforeRequestHook : [options.beforeRequestHook]
+    );
+  }
+  if (options?.afterResponseHook) {
+    afterResponseHooks.push(
+      ...Array.isArray(options.afterResponseHook) ? options.afterResponseHook : [options.afterResponseHook]
+    );
+  }
+  if (options?.afterGenerateHook) {
+    afterGenerateHooks.push(
+      ...Array.isArray(options.afterGenerateHook) ? options.afterGenerateHook : [options.afterGenerateHook]
+    );
+  }
+  for (const plugin of plugins) {
+    if (plugin.beforeRequestHook) {
+      beforeRequestHooks.push(
+        ...Array.isArray(plugin.beforeRequestHook) ? plugin.beforeRequestHook : [plugin.beforeRequestHook]
+      );
+    }
+    if (plugin.afterResponseHook) {
+      afterResponseHooks.push(
+        ...Array.isArray(plugin.afterResponseHook) ? plugin.afterResponseHook : [plugin.afterResponseHook]
+      );
+    }
+    if (plugin.afterGenerateHook) {
+      afterGenerateHooks.push(
+        ...Array.isArray(plugin.afterGenerateHook) ? plugin.afterGenerateHook : [plugin.afterGenerateHook]
+      );
+    }
+  }
+  try {
+    const outputDir = options?.dir ?? DEFAULT_OUTPUT_DIR;
+    const concurrency = options?.concurrency ?? DEFAULT_CONCURRENCY;
+    const combinedBeforeRequestHook = combineBeforeRequestHooks(
+      beforeRequestHooks.length > 0 ? beforeRequestHooks : [(req) => req]
+    );
+    const combinedAfterResponseHook = combineAfterResponseHooks(
+      afterResponseHooks.length > 0 ? afterResponseHooks : [(req) => req]
+    );
+    const getInfoGen = fetchRoutesContent(
+      app,
+      combinedBeforeRequestHook,
+      combinedAfterResponseHook,
+      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, options?.extensionMap).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 };
+  }
+  if (afterGenerateHooks.length > 0) {
+    const combinedAfterGenerateHooks = combineAfterGenerateHooks(afterGenerateHooks, fs, options);
+    await combinedAfterGenerateHooks(result, fs, options);
+  }
+  return result;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_OUTPUT_DIR,
+  combineAfterGenerateHooks,
+  combineAfterResponseHooks,
+  combineBeforeRequestHooks,
+  defaultExtensionMap,
+  fetchRoutesContent,
+  saveContentToFile,
+  toSSG
+});

package/node_modules/hono/dist/cjs/helper/ssg/utils.js

@@ -0,0 +1,93 @@
+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 utils_exports = {};
+__export(utils_exports, {
+  dirname: () => dirname,
+  ensureWithinOutDir: () => ensureWithinOutDir,
+  filterStaticGenerateRoutes: () => filterStaticGenerateRoutes,
+  isDynamicRoute: () => isDynamicRoute,
+  joinPaths: () => joinPaths
+});
+module.exports = __toCommonJS(utils_exports);
+var import_router = require("../../router");
+var import_handler = require("../../utils/handler");
+const dirname = (path) => {
+  const separatedPath = path.split(/[\/\\]/);
+  return separatedPath.slice(0, -1).join("/");
+};
+const normalizePath = (path) => {
+  return path.replace(/(\\)/g, "/").replace(/\/$/g, "");
+};
+const handleParent = (resultPaths, beforeParentFlag) => {
+  if (resultPaths.length === 0 || beforeParentFlag) {
+    resultPaths.push("..");
+  } else {
+    resultPaths.pop();
+  }
+};
+const handleNonDot = (path, resultPaths) => {
+  path = path.replace(/^\.(?!.)/, "");
+  if (path !== "") {
+    resultPaths.push(path);
+  }
+};
+const handleSegments = (paths, resultPaths) => {
+  let beforeParentFlag = false;
+  for (const path of paths) {
+    if (path === "..") {
+      handleParent(resultPaths, beforeParentFlag);
+      beforeParentFlag = true;
+    } else {
+      handleNonDot(path, resultPaths);
+      beforeParentFlag = false;
+    }
+  }
+};
+const joinPaths = (...paths) => {
+  paths = paths.map(normalizePath);
+  const resultPaths = [];
+  handleSegments(paths.join("/").split("/"), resultPaths);
+  return (paths[0][0] === "/" ? "/" : "") + resultPaths.join("/");
+};
+const filterStaticGenerateRoutes = (hono) => {
+  return hono.routes.reduce((acc, { method, handler, path }) => {
+    const targetHandler = (0, import_handler.findTargetHandler)(handler);
+    if (["GET", import_router.METHOD_NAME_ALL].includes(method) && !(0, import_handler.isMiddleware)(targetHandler)) {
+      acc.push({ path });
+    }
+    return acc;
+  }, []);
+};
+const isDynamicRoute = (path) => {
+  return path.split("/").some((segment) => segment.startsWith(":") || segment.includes("*"));
+};
+const ensureWithinOutDir = (outDir, filePath) => {
+  const normalizedOutDir = joinPaths("/", outDir);
+  const normalizedFilePath = joinPaths("/", filePath);
+  if (normalizedFilePath !== normalizedOutDir && !normalizedFilePath.startsWith(`${normalizedOutDir}/`)) {
+    throw new Error(`Path traversal detected: "${filePath}" is outside the output directory`);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  dirname,
+  ensureWithinOutDir,
+  filterStaticGenerateRoutes,
+  isDynamicRoute,
+  joinPaths
+});

package/node_modules/hono/dist/cjs/helper/streaming/index.js

@@ -0,0 +1,35 @@
+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 streaming_exports = {};
+__export(streaming_exports, {
+  SSEStreamingApi: () => import_sse.SSEStreamingApi,
+  stream: () => import_stream.stream,
+  streamSSE: () => import_sse.streamSSE,
+  streamText: () => import_text.streamText
+});
+module.exports = __toCommonJS(streaming_exports);
+var import_stream = require("./stream");
+var import_sse = require("./sse");
+var import_text = require("./text");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SSEStreamingApi,
+  stream,
+  streamSSE,
+  streamText
+});

package/node_modules/hono/dist/cjs/helper/streaming/sse.js

@@ -0,0 +1,90 @@
+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 sse_exports = {};
+__export(sse_exports, {
+  SSEStreamingApi: () => SSEStreamingApi,
+  streamSSE: () => streamSSE
+});
+module.exports = __toCommonJS(sse_exports);
+var import_html = require("../../utils/html");
+var import_stream = require("../../utils/stream");
+var import_utils = require("./utils");
+class SSEStreamingApi extends import_stream.StreamingApi {
+  constructor(writable, readable) {
+    super(writable, readable);
+  }
+  async writeSSE(message) {
+    const data = await (0, import_html.resolveCallback)(message.data, import_html.HtmlEscapedCallbackPhase.Stringify, false, {});
+    const dataLines = data.split(/\r\n|\r|\n/).map((line) => {
+      return `data: ${line}`;
+    }).join("\n");
+    for (const key of ["event", "id", "retry"]) {
+      if (message[key] && /[\r\n]/.test(message[key])) {
+        throw new Error(`${key} must not contain "\\r" or "\\n"`);
+      }
+    }
+    const sseData = [
+      message.event && `event: ${message.event}`,
+      dataLines,
+      message.id && `id: ${message.id}`,
+      message.retry && `retry: ${message.retry}`
+    ].filter(Boolean).join("\n") + "\n\n";
+    await this.write(sseData);
+  }
+}
+const run = async (stream, cb, onError) => {
+  try {
+    await cb(stream);
+  } catch (e) {
+    if (e instanceof Error && onError) {
+      await onError(e, stream);
+      await stream.writeSSE({
+        event: "error",
+        data: e.message
+      });
+    } else {
+      console.error(e);
+    }
+  } finally {
+    stream.close();
+  }
+};
+const contextStash = /* @__PURE__ */ new WeakMap();
+const streamSSE = (c, cb, onError) => {
+  const { readable, writable } = new TransformStream();
+  const stream = new SSEStreamingApi(writable, readable);
+  if ((0, import_utils.isOldBunVersion)()) {
+    c.req.raw.signal.addEventListener("abort", () => {
+      if (!stream.closed) {
+        stream.abort();
+      }
+    });
+  }
+  contextStash.set(stream.responseReadable, c);
+  c.header("Transfer-Encoding", "chunked");
+  c.header("Content-Type", "text/event-stream");
+  c.header("Cache-Control", "no-cache");
+  c.header("Connection", "keep-alive");
+  run(stream, cb, onError);
+  return c.newResponse(stream.responseReadable);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SSEStreamingApi,
+  streamSSE
+});

package/node_modules/hono/dist/cjs/helper/streaming/stream.js

@@ -0,0 +1,56 @@
+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 stream_exports = {};
+__export(stream_exports, {
+  stream: () => stream
+});
+module.exports = __toCommonJS(stream_exports);
+var import_stream = require("../../utils/stream");
+var import_utils = require("./utils");
+const contextStash = /* @__PURE__ */ new WeakMap();
+const stream = (c, cb, onError) => {
+  const { readable, writable } = new TransformStream();
+  const stream2 = new import_stream.StreamingApi(writable, readable);
+  if ((0, import_utils.isOldBunVersion)()) {
+    c.req.raw.signal.addEventListener("abort", () => {
+      if (!stream2.closed) {
+        stream2.abort();
+      }
+    });
+  }
+  contextStash.set(stream2.responseReadable, c);
+  (async () => {
+    try {
+      await cb(stream2);
+    } catch (e) {
+      if (e === void 0) {
+      } else if (e instanceof Error && onError) {
+        await onError(e, stream2);
+      } else {
+        console.error(e);
+      }
+    } finally {
+      stream2.close();
+    }
+  })();
+  return c.newResponse(stream2.responseReadable);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  stream
+});

package/node_modules/hono/dist/cjs/helper/streaming/text.js

@@ -0,0 +1,34 @@
+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 text_exports = {};
+__export(text_exports, {
+  streamText: () => streamText
+});
+module.exports = __toCommonJS(text_exports);
+var import_context = require("../../context");
+var import__ = require("./");
+const streamText = (c, cb, onError) => {
+  c.header("Content-Type", import_context.TEXT_PLAIN);
+  c.header("X-Content-Type-Options", "nosniff");
+  c.header("Transfer-Encoding", "chunked");
+  return (0, import__.stream)(c, cb, onError);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  streamText
+});

package/node_modules/hono/dist/cjs/helper/streaming/utils.js

@@ -0,0 +1,35 @@
+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 utils_exports = {};
+__export(utils_exports, {
+  isOldBunVersion: () => isOldBunVersion
+});
+module.exports = __toCommonJS(utils_exports);
+let isOldBunVersion = () => {
+  const version = typeof Bun !== "undefined" ? Bun.version : void 0;
+  if (version === void 0) {
+    return false;
+  }
+  const result = version.startsWith("1.1") || version.startsWith("1.0") || version.startsWith("0.");
+  isOldBunVersion = () => result;
+  return result;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isOldBunVersion
+});