@zuplo/cli 6.73.16 → 6.73.18

package/node_modules/@hono/node-server/dist/serve-static.cjs

@@ -0,0 +1,151 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_utils_stream = require('./utils/stream.cjs');
+let hono_utils_mime = require("hono/utils/mime");
+let node_fs = require("node:fs");
+let node_path = require("node:path");
+
+//#region src/serve-static.ts
+const COMPRESSIBLE_CONTENT_TYPE_REGEX = /^\s*(?:text\/[^;\s]+|application\/(?:javascript|json|xml|xml-dtd|ecmascript|dart|postscript|rtf|tar|toml|vnd\.dart|vnd\.ms-fontobject|vnd\.ms-opentype|wasm|x-httpd-php|x-javascript|x-ns-proxy-autoconfig|x-sh|x-tar|x-virtualbox-hdd|x-virtualbox-ova|x-virtualbox-ovf|x-virtualbox-vbox|x-virtualbox-vdi|x-virtualbox-vhd|x-virtualbox-vmdk|x-www-form-urlencoded)|font\/(?:otf|ttf)|image\/(?:bmp|vnd\.adobe\.photoshop|vnd\.microsoft\.icon|vnd\.ms-dds|x-icon|x-ms-bmp)|message\/rfc822|model\/gltf-binary|x-shader\/x-fragment|x-shader\/x-vertex|[^;\s]+?\+(?:json|text|xml|yaml))(?:[;\s]|$)/i;
+const ENCODINGS = {
+	br: ".br",
+	zstd: ".zst",
+	gzip: ".gz"
+};
+const ENCODINGS_ORDERED_KEYS = Object.keys(ENCODINGS);
+const getStats = (path) => {
+	let stats;
+	try {
+		stats = (0, node_fs.statSync)(path);
+	} catch {}
+	return stats;
+};
+const BYTE_RANGE_PATTERN = /^(?:bytes=)?(?!-$)(\d*)-(\d*)$/;
+const parseByteRange = (range) => {
+	const match = range.match(BYTE_RANGE_PATTERN);
+	if (!match) return;
+	const [, start, end] = match;
+	if (start === "") return {
+		type: "suffix",
+		length: Number(end)
+	};
+	if (end === "") return {
+		type: "open-ended",
+		start: Number(start)
+	};
+	return {
+		type: "bounded",
+		start: Number(start),
+		end: Number(end)
+	};
+};
+const resolveByteRange = (spec, size) => {
+	if (size === 0) return;
+	if (spec.type === "suffix") {
+		if (spec.length === 0) return;
+		return {
+			start: Math.max(size - spec.length, 0),
+			end: size - 1
+		};
+	}
+	const end = spec.type === "bounded" ? Math.min(spec.end, size - 1) : size - 1;
+	if (spec.start >= size || spec.start > end) return;
+	return {
+		start: spec.start,
+		end
+	};
+};
+const tryDecode = (str, decoder) => {
+	try {
+		return decoder(str);
+	} catch {
+		return str.replace(/(?:%[0-9A-Fa-f]{2})+/g, (match) => {
+			try {
+				return decoder(match);
+			} catch {
+				return match;
+			}
+		});
+	}
+};
+const tryDecodeURI = (str) => tryDecode(str, decodeURI);
+const serveStatic = (options = { root: "" }) => {
+	const root = options.root || "";
+	const optionPath = options.path;
+	if (root !== "" && !(0, node_fs.existsSync)(root)) console.error(`serveStatic: root path '${root}' is not found, are you sure it's correct?`);
+	return async (c, next) => {
+		if (c.finalized) return next();
+		let filename;
+		if (optionPath) filename = optionPath;
+		else try {
+			filename = tryDecodeURI(c.req.path);
+			if (/(?:^|[\/\\])\.{1,2}(?:$|[\/\\])|[\/\\]{2,}|\\/.test(filename)) throw new Error();
+		} catch {
+			await options.onNotFound?.(c.req.path, c);
+			return next();
+		}
+		let path = (0, node_path.join)(root, !optionPath && options.rewriteRequestPath ? options.rewriteRequestPath(filename, c) : filename);
+		let stats = getStats(path);
+		if (stats && stats.isDirectory()) {
+			const indexFile = options.index ?? "index.html";
+			path = (0, node_path.join)(path, indexFile);
+			stats = getStats(path);
+		}
+		if (!stats) {
+			await options.onNotFound?.(path, c);
+			return next();
+		}
+		const mimeType = (0, hono_utils_mime.getMimeType)(path);
+		c.header("Content-Type", mimeType || "application/octet-stream");
+		if (options.precompressed && (!mimeType || mimeType === "application/octet-stream" || COMPRESSIBLE_CONTENT_TYPE_REGEX.test(mimeType))) {
+			const acceptEncodingSet = new Set(c.req.header("Accept-Encoding")?.split(",").map((encoding) => encoding.trim()));
+			for (const encoding of ENCODINGS_ORDERED_KEYS) {
+				if (!acceptEncodingSet.has(encoding)) continue;
+				const precompressedStats = getStats(path + ENCODINGS[encoding]);
+				if (precompressedStats) {
+					c.header("Content-Encoding", encoding);
+					c.header("Vary", "Accept-Encoding", { append: true });
+					stats = precompressedStats;
+					path = path + ENCODINGS[encoding];
+					break;
+				}
+			}
+		}
+		let result;
+		const size = stats.size;
+		const range = c.req.header("range") || "";
+		c.header("Last-Modified", stats.mtime.toUTCString());
+		if (c.req.method == "HEAD" || c.req.method == "OPTIONS") {
+			c.header("Content-Length", size.toString());
+			c.status(200);
+			result = c.body(null);
+		} else if (!range) {
+			c.header("Content-Length", size.toString());
+			result = c.body(require_utils_stream.createStreamBody((0, node_fs.createReadStream)(path)), 200);
+		} else {
+			c.header("Accept-Ranges", "bytes");
+			const resolvedRange = resolveByteRange(parseByteRange(range) ?? {
+				type: "open-ended",
+				start: 0
+			}, size);
+			if (!resolvedRange) {
+				c.header("Content-Range", `bytes */${size}`);
+				result = c.body(null, 416);
+			} else {
+				const { start, end } = resolvedRange;
+				const chunkSize = end - start + 1;
+				const stream = (0, node_fs.createReadStream)(path, {
+					start,
+					end
+				});
+				c.header("Content-Length", chunkSize.toString());
+				c.header("Content-Range", `bytes ${start}-${end}/${size}`);
+				result = c.body(require_utils_stream.createStreamBody(stream), 206);
+			}
+		}
+		await options.onFound?.(path, c);
+		return result;
+	};
+};
+
+//#endregion
+exports.serveStatic = serveStatic;

package/node_modules/@hono/node-server/dist/serve-static.d.cts

@@ -0,0 +1,18 @@
+import { Context, Env, MiddlewareHandler } from "hono";
+
+//#region src/serve-static.d.ts
+type ServeStaticOptions<E extends Env = Env> = {
+  /**
+   * Root path. Relative path is based on current working directory from which the app was started.
+   */
+  root?: string;
+  path?: string;
+  index?: string;
+  precompressed?: boolean;
+  rewriteRequestPath?: (path: string, c: Context<E>) => string;
+  onFound?: (path: string, c: Context<E>) => void | Promise<void>;
+  onNotFound?: (path: string, c: Context<E>) => void | Promise<void>;
+};
+declare const serveStatic: <E extends Env = any>(options?: ServeStaticOptions<E>) => MiddlewareHandler<E>;
+//#endregion
+export { ServeStaticOptions, serveStatic };

package/node_modules/@hono/node-server/dist/serve-static.d.mts

@@ -1,17 +1,18 @@
-import { Env, Context, MiddlewareHandler } from 'hono';
+import { Context, Env, MiddlewareHandler } from "hono";
 
+//#region src/serve-static.d.ts
 type ServeStaticOptions<E extends Env = Env> = {
-    /**
-     * Root path, relative to current working directory from which the app was started. Absolute paths are not supported.
-     */
-    root?: string;
-    path?: string;
-    index?: string;
-    precompressed?: boolean;
-    rewriteRequestPath?: (path: string, c: Context<E>) => string;
-    onFound?: (path: string, c: Context<E>) => void | Promise<void>;
-    onNotFound?: (path: string, c: Context<E>) => void | Promise<void>;
+  /**
+   * Root path. Relative path is based on current working directory from which the app was started.
+   */
+  root?: string;
+  path?: string;
+  index?: string;
+  precompressed?: boolean;
+  rewriteRequestPath?: (path: string, c: Context<E>) => string;
+  onFound?: (path: string, c: Context<E>) => void | Promise<void>;
+  onNotFound?: (path: string, c: Context<E>) => void | Promise<void>;
 };
 declare const serveStatic: <E extends Env = any>(options?: ServeStaticOptions<E>) => MiddlewareHandler<E>;
-
-export { type ServeStaticOptions, serveStatic };
+//#endregion
+export { ServeStaticOptions, serveStatic };

package/node_modules/@hono/node-server/dist/serve-static.mjs

@@ -1,152 +1,150 @@
-// src/serve-static.ts
+import { createStreamBody } from "./utils/stream.mjs";
 import { getMimeType } from "hono/utils/mime";
-import { createReadStream, statSync, existsSync } from "fs";
-import { join } from "path";
-import { versions } from "process";
-import { Readable } from "stream";
-var COMPRESSIBLE_CONTENT_TYPE_REGEX = /^\s*(?:text\/[^;\s]+|application\/(?:javascript|json|xml|xml-dtd|ecmascript|dart|postscript|rtf|tar|toml|vnd\.dart|vnd\.ms-fontobject|vnd\.ms-opentype|wasm|x-httpd-php|x-javascript|x-ns-proxy-autoconfig|x-sh|x-tar|x-virtualbox-hdd|x-virtualbox-ova|x-virtualbox-ovf|x-virtualbox-vbox|x-virtualbox-vdi|x-virtualbox-vhd|x-virtualbox-vmdk|x-www-form-urlencoded)|font\/(?:otf|ttf)|image\/(?:bmp|vnd\.adobe\.photoshop|vnd\.microsoft\.icon|vnd\.ms-dds|x-icon|x-ms-bmp)|message\/rfc822|model\/gltf-binary|x-shader\/x-fragment|x-shader\/x-vertex|[^;\s]+?\+(?:json|text|xml|yaml))(?:[;\s]|$)/i;
-var ENCODINGS = {
-  br: ".br",
-  zstd: ".zst",
-  gzip: ".gz"
+import { createReadStream, existsSync, statSync } from "node:fs";
+import { join } from "node:path";
+
+//#region src/serve-static.ts
+const COMPRESSIBLE_CONTENT_TYPE_REGEX = /^\s*(?:text\/[^;\s]+|application\/(?:javascript|json|xml|xml-dtd|ecmascript|dart|postscript|rtf|tar|toml|vnd\.dart|vnd\.ms-fontobject|vnd\.ms-opentype|wasm|x-httpd-php|x-javascript|x-ns-proxy-autoconfig|x-sh|x-tar|x-virtualbox-hdd|x-virtualbox-ova|x-virtualbox-ovf|x-virtualbox-vbox|x-virtualbox-vdi|x-virtualbox-vhd|x-virtualbox-vmdk|x-www-form-urlencoded)|font\/(?:otf|ttf)|image\/(?:bmp|vnd\.adobe\.photoshop|vnd\.microsoft\.icon|vnd\.ms-dds|x-icon|x-ms-bmp)|message\/rfc822|model\/gltf-binary|x-shader\/x-fragment|x-shader\/x-vertex|[^;\s]+?\+(?:json|text|xml|yaml))(?:[;\s]|$)/i;
+const ENCODINGS = {
+	br: ".br",
+	zstd: ".zst",
+	gzip: ".gz"
 };
-var ENCODINGS_ORDERED_KEYS = Object.keys(ENCODINGS);
-var pr54206Applied = () => {
-  const [major, minor] = versions.node.split(".").map((component) => parseInt(component));
-  return major >= 23 || major === 22 && minor >= 7 || major === 20 && minor >= 18;
+const ENCODINGS_ORDERED_KEYS = Object.keys(ENCODINGS);
+const getStats = (path) => {
+	let stats;
+	try {
+		stats = statSync(path);
+	} catch {}
+	return stats;
 };
-var useReadableToWeb = pr54206Applied();
-var createStreamBody = (stream) => {
-  if (useReadableToWeb) {
-    return Readable.toWeb(stream);
-  }
-  const body = new ReadableStream({
-    start(controller) {
-      stream.on("data", (chunk) => {
-        controller.enqueue(chunk);
-      });
-      stream.on("error", (err) => {
-        controller.error(err);
-      });
-      stream.on("end", () => {
-        controller.close();
-      });
-    },
-    cancel() {
-      stream.destroy();
-    }
-  });
-  return body;
+const BYTE_RANGE_PATTERN = /^(?:bytes=)?(?!-$)(\d*)-(\d*)$/;
+const parseByteRange = (range) => {
+	const match = range.match(BYTE_RANGE_PATTERN);
+	if (!match) return;
+	const [, start, end] = match;
+	if (start === "") return {
+		type: "suffix",
+		length: Number(end)
+	};
+	if (end === "") return {
+		type: "open-ended",
+		start: Number(start)
+	};
+	return {
+		type: "bounded",
+		start: Number(start),
+		end: Number(end)
+	};
 };
-var getStats = (path) => {
-  let stats;
-  try {
-    stats = statSync(path);
-  } catch {
-  }
-  return stats;
+const resolveByteRange = (spec, size) => {
+	if (size === 0) return;
+	if (spec.type === "suffix") {
+		if (spec.length === 0) return;
+		return {
+			start: Math.max(size - spec.length, 0),
+			end: size - 1
+		};
+	}
+	const end = spec.type === "bounded" ? Math.min(spec.end, size - 1) : size - 1;
+	if (spec.start >= size || spec.start > end) return;
+	return {
+		start: spec.start,
+		end
+	};
 };
-var tryDecode = (str, decoder) => {
-  try {
-    return decoder(str);
-  } catch {
-    return str.replace(/(?:%[0-9A-Fa-f]{2})+/g, (match) => {
-      try {
-        return decoder(match);
-      } catch {
-        return match;
-      }
-    });
-  }
+const tryDecode = (str, decoder) => {
+	try {
+		return decoder(str);
+	} catch {
+		return str.replace(/(?:%[0-9A-Fa-f]{2})+/g, (match) => {
+			try {
+				return decoder(match);
+			} catch {
+				return match;
+			}
+		});
+	}
 };
-var tryDecodeURI = (str) => tryDecode(str, decodeURI);
-var serveStatic = (options = { root: "" }) => {
-  const root = options.root || "";
-  const optionPath = options.path;
-  if (root !== "" && !existsSync(root)) {
-    console.error(`serveStatic: root path '${root}' is not found, are you sure it's correct?`);
-  }
-  return async (c, next) => {
-    if (c.finalized) {
-      return next();
-    }
-    let filename;
-    if (optionPath) {
-      filename = optionPath;
-    } else {
-      try {
-        filename = tryDecodeURI(c.req.path);
-        if (/(?:^|[\/\\])\.{1,2}(?:$|[\/\\])|[\/\\]{2,}|\\/.test(filename)) {
-          throw new Error();
-        }
-      } catch {
-        await options.onNotFound?.(c.req.path, c);
-        return next();
-      }
-    }
-    let path = join(
-      root,
-      !optionPath && options.rewriteRequestPath ? options.rewriteRequestPath(filename, c) : filename
-    );
-    let stats = getStats(path);
-    if (stats && stats.isDirectory()) {
-      const indexFile = options.index ?? "index.html";
-      path = join(path, indexFile);
-      stats = getStats(path);
-    }
-    if (!stats) {
-      await options.onNotFound?.(path, c);
-      return next();
-    }
-    const mimeType = getMimeType(path);
-    c.header("Content-Type", mimeType || "application/octet-stream");
-    if (options.precompressed && (!mimeType || COMPRESSIBLE_CONTENT_TYPE_REGEX.test(mimeType))) {
-      const acceptEncodingSet = new Set(
-        c.req.header("Accept-Encoding")?.split(",").map((encoding) => encoding.trim())
-      );
-      for (const encoding of ENCODINGS_ORDERED_KEYS) {
-        if (!acceptEncodingSet.has(encoding)) {
-          continue;
-        }
-        const precompressedStats = getStats(path + ENCODINGS[encoding]);
-        if (precompressedStats) {
-          c.header("Content-Encoding", encoding);
-          c.header("Vary", "Accept-Encoding", { append: true });
-          stats = precompressedStats;
-          path = path + ENCODINGS[encoding];
-          break;
-        }
-      }
-    }
-    let result;
-    const size = stats.size;
-    const range = c.req.header("range") || "";
-    if (c.req.method == "HEAD" || c.req.method == "OPTIONS") {
-      c.header("Content-Length", size.toString());
-      c.status(200);
-      result = c.body(null);
-    } else if (!range) {
-      c.header("Content-Length", size.toString());
-      result = c.body(createStreamBody(createReadStream(path)), 200);
-    } else {
-      c.header("Accept-Ranges", "bytes");
-      c.header("Date", stats.birthtime.toUTCString());
-      const parts = range.replace(/bytes=/, "").split("-", 2);
-      const start = parseInt(parts[0], 10) || 0;
-      let end = parseInt(parts[1], 10) || size - 1;
-      if (size < end - start + 1) {
-        end = size - 1;
-      }
-      const chunksize = end - start + 1;
-      const stream = createReadStream(path, { start, end });
-      c.header("Content-Length", chunksize.toString());
-      c.header("Content-Range", `bytes ${start}-${end}/${stats.size}`);
-      result = c.body(createStreamBody(stream), 206);
-    }
-    await options.onFound?.(path, c);
-    return result;
-  };
-};
-export {
-  serveStatic
+const tryDecodeURI = (str) => tryDecode(str, decodeURI);
+const serveStatic = (options = { root: "" }) => {
+	const root = options.root || "";
+	const optionPath = options.path;
+	if (root !== "" && !existsSync(root)) console.error(`serveStatic: root path '${root}' is not found, are you sure it's correct?`);
+	return async (c, next) => {
+		if (c.finalized) return next();
+		let filename;
+		if (optionPath) filename = optionPath;
+		else try {
+			filename = tryDecodeURI(c.req.path);
+			if (/(?:^|[\/\\])\.{1,2}(?:$|[\/\\])|[\/\\]{2,}|\\/.test(filename)) throw new Error();
+		} catch {
+			await options.onNotFound?.(c.req.path, c);
+			return next();
+		}
+		let path = join(root, !optionPath && options.rewriteRequestPath ? options.rewriteRequestPath(filename, c) : filename);
+		let stats = getStats(path);
+		if (stats && stats.isDirectory()) {
+			const indexFile = options.index ?? "index.html";
+			path = join(path, indexFile);
+			stats = getStats(path);
+		}
+		if (!stats) {
+			await options.onNotFound?.(path, c);
+			return next();
+		}
+		const mimeType = getMimeType(path);
+		c.header("Content-Type", mimeType || "application/octet-stream");
+		if (options.precompressed && (!mimeType || mimeType === "application/octet-stream" || COMPRESSIBLE_CONTENT_TYPE_REGEX.test(mimeType))) {
+			const acceptEncodingSet = new Set(c.req.header("Accept-Encoding")?.split(",").map((encoding) => encoding.trim()));
+			for (const encoding of ENCODINGS_ORDERED_KEYS) {
+				if (!acceptEncodingSet.has(encoding)) continue;
+				const precompressedStats = getStats(path + ENCODINGS[encoding]);
+				if (precompressedStats) {
+					c.header("Content-Encoding", encoding);
+					c.header("Vary", "Accept-Encoding", { append: true });
+					stats = precompressedStats;
+					path = path + ENCODINGS[encoding];
+					break;
+				}
+			}
+		}
+		let result;
+		const size = stats.size;
+		const range = c.req.header("range") || "";
+		c.header("Last-Modified", stats.mtime.toUTCString());
+		if (c.req.method == "HEAD" || c.req.method == "OPTIONS") {
+			c.header("Content-Length", size.toString());
+			c.status(200);
+			result = c.body(null);
+		} else if (!range) {
+			c.header("Content-Length", size.toString());
+			result = c.body(createStreamBody(createReadStream(path)), 200);
+		} else {
+			c.header("Accept-Ranges", "bytes");
+			const resolvedRange = resolveByteRange(parseByteRange(range) ?? {
+				type: "open-ended",
+				start: 0
+			}, size);
+			if (!resolvedRange) {
+				c.header("Content-Range", `bytes */${size}`);
+				result = c.body(null, 416);
+			} else {
+				const { start, end } = resolvedRange;
+				const chunkSize = end - start + 1;
+				const stream = createReadStream(path, {
+					start,
+					end
+				});
+				c.header("Content-Length", chunkSize.toString());
+				c.header("Content-Range", `bytes ${start}-${end}/${size}`);
+				result = c.body(createStreamBody(stream), 206);
+			}
+		}
+		await options.onFound?.(path, c);
+		return result;
+	};
 };
+
+//#endregion
+export { serveStatic };

package/node_modules/@hono/node-server/dist/utils/response.cjs

@@ -0,0 +1,8 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_constants = require('../constants-BXAKTxRC.cjs');
+
+//#region src/utils/response.ts
+const RESPONSE_ALREADY_SENT = new Response(null, { headers: { [require_constants.X_ALREADY_SENT]: "true" } });
+
+//#endregion
+exports.RESPONSE_ALREADY_SENT = RESPONSE_ALREADY_SENT;

package/node_modules/@hono/node-server/dist/utils/response.d.cts

@@ -0,0 +1,4 @@
+//#region src/utils/response.d.ts
+declare const RESPONSE_ALREADY_SENT: Response;
+//#endregion
+export { RESPONSE_ALREADY_SENT };

package/node_modules/@hono/node-server/dist/utils/response.d.mts

@@ -1,3 +1,4 @@
+//#region src/utils/response.d.ts
 declare const RESPONSE_ALREADY_SENT: Response;
-
-export { RESPONSE_ALREADY_SENT };
+//#endregion
+export { RESPONSE_ALREADY_SENT };

package/node_modules/@hono/node-server/dist/utils/response.mjs

@@ -1,10 +1,7 @@
-// src/utils/response/constants.ts
-var X_ALREADY_SENT = "x-hono-already-sent";
+import { t as X_ALREADY_SENT } from "../constants-BLSFu_RU.mjs";
 
-// src/utils/response.ts
-var RESPONSE_ALREADY_SENT = new Response(null, {
-  headers: { [X_ALREADY_SENT]: "true" }
-});
-export {
-  RESPONSE_ALREADY_SENT
-};
+//#region src/utils/response.ts
+const RESPONSE_ALREADY_SENT = new Response(null, { headers: { [X_ALREADY_SENT]: "true" } });
+
+//#endregion
+export { RESPONSE_ALREADY_SENT };

package/node_modules/@hono/node-server/dist/utils/stream.cjs

@@ -0,0 +1,65 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+let node_stream = require("node:stream");
+let node_process = require("node:process");
+
+//#region src/utils/stream.ts
+const pr54206Applied = () => {
+	const [major, minor] = node_process.versions.node.split(".").map((component) => parseInt(component));
+	return major >= 23 || major === 22 && minor >= 7 || major === 20 && minor >= 18;
+};
+const useReadableToWeb = pr54206Applied();
+const createStreamBody = (stream, useNativeReadableToWeb = useReadableToWeb) => {
+	if (useNativeReadableToWeb) return node_stream.Readable.toWeb(stream);
+	let controller;
+	let settled = false;
+	const cleanup = () => {
+		stream.off("data", onData);
+		stream.off("error", onError);
+		stream.off("end", onTerminate);
+		stream.off("close", onTerminate);
+	};
+	const settle = (callback) => {
+		if (settled) return;
+		settled = true;
+		cleanup();
+		callback?.();
+	};
+	const onData = (chunk) => {
+		if (settled || !controller) return;
+		controller.enqueue(chunk);
+		if ((controller.desiredSize ?? 0) <= 0) stream.pause();
+	};
+	const onError = (error) => {
+		settle(() => {
+			controller?.error(error);
+		});
+	};
+	const onTerminate = () => {
+		settle(() => {
+			controller?.close();
+		});
+	};
+	return new ReadableStream({
+		start(streamController) {
+			controller = streamController;
+			stream.on("data", onData);
+			stream.on("error", onError);
+			stream.on("end", onTerminate);
+			stream.on("close", onTerminate);
+			stream.pause();
+		},
+		pull() {
+			if (!settled) stream.resume();
+		},
+		cancel() {
+			settle();
+			const ignoreError = () => {};
+			stream.on("error", ignoreError);
+			stream.once("close", () => stream.off("error", ignoreError));
+			stream.destroy();
+		}
+	});
+};
+
+//#endregion
+exports.createStreamBody = createStreamBody;

package/node_modules/@hono/node-server/dist/utils/stream.d.cts

@@ -0,0 +1,6 @@
+import { ReadStream } from "node:fs";
+
+//#region src/utils/stream.d.ts
+declare const createStreamBody: (stream: ReadStream, useNativeReadableToWeb?: boolean) => ReadableStream<Uint8Array>;
+//#endregion
+export { createStreamBody };

package/node_modules/@hono/node-server/dist/utils/stream.d.mts

@@ -0,0 +1,6 @@
+import { ReadStream } from "node:fs";
+
+//#region src/utils/stream.d.ts
+declare const createStreamBody: (stream: ReadStream, useNativeReadableToWeb?: boolean) => ReadableStream<Uint8Array>;
+//#endregion
+export { createStreamBody };