@suveren/gateway 0.7.3 → 0.7.6

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

@@ -24,19 +24,11 @@ var import_url = require("../../utils/url");
 var import_node = require("./node");
 class TrieRouter {
   name = "TrieRouter";
-  #node;
-  constructor() {
-    this.#node = new import_node.Node();
-  }
+  #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);
-      }
-      return;
+    for (const result of (0, import_url.checkOptionalParameter)(path) || [path]) {
+      this.#node.insert(method, result, handler);
     }
-    this.#node.insert(method, path, handler);
   }
   match(method, path) {
     return this.#node.search(method, path);

package/node_modules/hono/dist/cjs/router/utils.js

@@ -0,0 +1,27 @@
+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, {
+  createNullObject: () => createNullObject
+});
+module.exports = __toCommonJS(utils_exports);
+const createNullObject = () => /* @__PURE__ */ Object.create(null);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createNullObject
+});

package/node_modules/hono/dist/cjs/utils/body.js

@@ -21,6 +21,8 @@ __export(body_exports, {
 });
 module.exports = __toCommonJS(body_exports);
 var import_buffer = require("./buffer");
+const MAX_NESTING_DEPTH = 32;
+const MAX_NESTED_OBJECTS = 1e4;
 const isRawRequest = (request) => "headers" in request;
 const parseBody = async (request, options = /* @__PURE__ */ Object.create(null)) => {
   const { all = false, dot = false } = options;
@@ -53,6 +55,7 @@ async function parseFormData(request, options) {
 }
 function convertFormDataToBodyData(formData, options) {
   const form = /* @__PURE__ */ Object.create(null);
+  const nestingState = { count: 0 };
   formData.forEach((value, key) => {
     const shouldParseAllValues = options.all || key.endsWith("[]");
     if (!shouldParseAllValues) {
@@ -65,7 +68,7 @@ function convertFormDataToBodyData(formData, options) {
     Object.entries(form).forEach(([key, value]) => {
       const shouldParseDotValues = key.includes(".");
       if (shouldParseDotValues) {
-        handleParsingNestedValues(form, key, value);
+        handleParsingNestedValues(form, key, value, nestingState);
         delete form[key];
       }
     });
@@ -88,23 +91,32 @@ const handleParsingAllValues = (form, key, value) => {
     }
   }
 };
-const handleParsingNestedValues = (form, key, value) => {
+const handleParsingNestedValues = (form, key, value, state) => {
   if (/(?:^|\.)__proto__\./.test(key)) {
     return;
   }
   let nestedForm = form;
-  const keys = key.split(".");
+  const keys = key.split(".", MAX_NESTING_DEPTH + 2);
+  if (keys.length > MAX_NESTING_DEPTH + 1) {
+    throwNestingLimitExceeded();
+  }
   keys.forEach((key2, index) => {
     if (index === keys.length - 1) {
       nestedForm[key2] = value;
     } else {
       if (!nestedForm[key2] || typeof nestedForm[key2] !== "object" || Array.isArray(nestedForm[key2]) || nestedForm[key2] instanceof File) {
+        if (state.count++ >= MAX_NESTED_OBJECTS) {
+          throwNestingLimitExceeded();
+        }
         nestedForm[key2] = /* @__PURE__ */ Object.create(null);
       }
       nestedForm = nestedForm[key2];
     }
   });
 };
+const throwNestingLimitExceeded = () => {
+  throw new Error("Nesting limit exceeded");
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   parseBody

package/node_modules/hono/dist/cjs/utils/cookie.js

@@ -101,7 +101,7 @@ const parseSigned = async (cookie, secret, name) => {
   const secretKey = await getCryptoKey(secret);
   for (const [key, value] of Object.entries(parse(cookie, name))) {
     const signatureStartPos = value.lastIndexOf(".");
-    if (signatureStartPos < 1) {
+    if (signatureStartPos < 0) {
       continue;
     }
     const signedValue = value.substring(0, signatureStartPos);

package/node_modules/hono/dist/cjs/utils/ipaddr.js

@@ -30,12 +30,14 @@ __export(ipaddr_exports, {
 module.exports = __toCommonJS(ipaddr_exports);
 const expandIPv6 = (ipV6) => {
   const sections = ipV6.split(":");
-  if (IPV4_REGEX.test(sections.at(-1))) {
+  const lastSection = sections.at(-1);
+  if (IPV4_REGEX.test(lastSection)) {
+    const octets = lastSection.split(".").map(Number);
     sections.splice(
       -1,
       1,
-      ...convertIPv6BinaryToString(convertIPv4ToBinary(sections.at(-1))).substring(2).split(":")
-      // => ['7f00', '0001']
+      (octets[0] << 8 | octets[1]).toString(16),
+      (octets[2] << 8 | octets[3]).toString(16)
     );
   }
   for (let i = 0; i < sections.length; i++) {

package/node_modules/hono/dist/cjs/utils/stream.js

@@ -96,7 +96,13 @@ class StreamingApi {
   abort() {
     if (!this.aborted) {
       this.aborted = true;
-      this.abortSubscribers.forEach((subscriber) => subscriber());
+      this.abortSubscribers.forEach((subscriber) => {
+        try {
+          void Promise.resolve(subscriber()).catch(() => {
+          });
+        } catch {
+        }
+      });
     }
   }
 }

package/node_modules/hono/dist/cjs/utils/url.js

@@ -119,7 +119,11 @@ const getPath = (request) => {
 };
 const getQueryStrings = (url) => {
   const queryIndex = url.indexOf("?", 8);
-  return queryIndex === -1 ? "" : "?" + url.slice(queryIndex + 1);
+  if (queryIndex === -1) {
+    return "";
+  }
+  const hashIndex = url.indexOf("#", 8);
+  return hashIndex === -1 ? url.slice(queryIndex) : queryIndex < hashIndex ? url.slice(queryIndex, hashIndex) : "";
 };
 const getPathNoStrict = (request) => {
   const result = getPath(request);
@@ -142,13 +146,13 @@ const checkOptionalParameter = (path) => {
     if (segment !== "" && !/\:/.test(segment)) {
       basePath += "/" + segment;
     } else if (/\:/.test(segment)) {
-      if (/\?/.test(segment)) {
+      if (segment.charCodeAt(segment.length - 1) === 63) {
         if (results.length === 0 && basePath === "") {
           results.push("/");
         } else {
           results.push(basePath);
         }
-        const optionalSegment = segment.replace("?", "");
+        const optionalSegment = segment.slice(0, -1);
         basePath += "/" + optionalSegment;
         results.push(basePath);
       } else {
@@ -166,6 +170,10 @@ const _decodeURI = (value) => {
   return tryDecodeURIComponent(value);
 };
 const _getQueryParam = (url, key, multiple) => {
+  const hashIndex = url.indexOf("#", 8);
+  if (hashIndex !== -1) {
+    url = url.slice(0, hashIndex);
+  }
   let encoded;
   if (!multiple && key && key.indexOf("%") === -1 && key.indexOf("+") === -1) {
     let keyIndex2 = url.indexOf("?", 8);

package/node_modules/hono/dist/client/client.js

@@ -26,6 +26,10 @@ var createProxy = (callback, path) => {
   });
   return proxy;
 };
+var appendQueryParams = (url, searchParams) => {
+  const queryString = searchParams.toString();
+  return queryString ? `${url}?${queryString}` : url;
+};
 var ClientRequestImpl = class {
   url;
   method;
@@ -52,6 +56,9 @@ var ClientRequestImpl = class {
           }
           if (Array.isArray(v)) {
             for (const v2 of v) {
+              if (v2 === void 0) {
+                continue;
+              }
               form.append(k, v2);
             }
           } else {
@@ -60,7 +67,7 @@ var ClientRequestImpl = class {
         }
         this.rBody = form;
       }
-      if (args.json) {
+      if (args.json !== void 0) {
         this.rBody = JSON.stringify(args.json);
         this.cType = "application/json";
       }
@@ -76,19 +83,29 @@ var ClientRequestImpl = class {
     if (args?.cookie) {
       const cookies = [];
       for (const [key, value] of Object.entries(args.cookie)) {
-        cookies.push(serialize(key, value, { path: "/" }));
+        if (value === void 0) {
+          continue;
+        }
+        cookies.push(serialize(key, value));
+      }
+      if (cookies.length > 0) {
+        headerValues["Cookie"] = cookies.join("; ");
       }
-      headerValues["Cookie"] = cookies.join(",");
     }
     if (this.cType) {
       headerValues["Content-Type"] = this.cType;
     }
-    const headers = new Headers(headerValues ?? void 0);
+    const headers = new Headers();
+    for (const [key, value] of Object.entries(headerValues)) {
+      if (value !== void 0) {
+        headers.set(key, value);
+      }
+    }
     let url = this.url;
     url = removeIndexString(url);
     url = replaceUrlParam(url, this.pathParams);
     if (this.queryParams) {
-      url = url + "?" + this.queryParams.toString();
+      url = appendQueryParams(url, this.queryParams);
     }
     methodUpperCase = this.method.toUpperCase();
     const setBody = !(methodUpperCase === "GET" || methodUpperCase === "HEAD");
@@ -132,7 +149,7 @@ var hc = (baseUrl, options) => createProxy(function proxyCallback(opts) {
         result = replaceUrlParam(url, opts.args[0].param);
       }
       if (opts.args[0].query) {
-        result = result + "?" + buildSearchParamsOption(opts.args[0].query).toString();
+        result = appendQueryParams(result, buildSearchParamsOption(opts.args[0].query));
       }
     }
     result = removeIndexString(result);
@@ -143,18 +160,15 @@ var hc = (baseUrl, options) => createProxy(function proxyCallback(opts) {
   }
   if (method === "ws") {
     const webSocketUrl = replaceUrlProtocol(
-      opts.args[0] && opts.args[0].param ? replaceUrlParam(url, opts.args[0].param) : url,
+      opts.args[0]?.param ? replaceUrlParam(url, opts.args[0].param) : url,
       "ws"
     );
     const targetUrl = new URL(webSocketUrl);
     const queryParams = opts.args[0]?.query;
     if (queryParams) {
-      Object.entries(queryParams).forEach(([key, value]) => {
-        if (Array.isArray(value)) {
-          value.forEach((item) => targetUrl.searchParams.append(key, item));
-        } else {
-          targetUrl.searchParams.set(key, value);
-        }
+      const searchParams = buildSearchParamsOption(queryParams);
+      searchParams.forEach((value, key) => {
+        targetUrl.searchParams.append(key, value);
       });
     }
     const establishWebSocket = (...args) => {

package/node_modules/hono/dist/client/utils.js

@@ -9,7 +9,7 @@ var mergePath = (base, path) => {
 var replaceUrlParam = (urlString, params) => {
   for (const [k, v] of Object.entries(params)) {
     const reg = new RegExp("/:" + k + "(?:{[^/]+})?\\??(?=/|$)");
-    urlString = urlString.replace(reg, v ? `/${v}` : "");
+    urlString = urlString.replace(reg, () => v ? `/${v}` : "");
   }
   return urlString;
 };
@@ -21,6 +21,9 @@ var buildSearchParams = (query) => {
     }
     if (Array.isArray(v)) {
       for (const v2 of v) {
+        if (v2 === void 0) {
+          continue;
+        }
         searchParams.append(k, v2);
       }
     } else {

package/node_modules/hono/dist/context.js

@@ -202,6 +202,10 @@ var Context = class {
    *   c.header('X-Message', 'Hello!')
    *   c.header('Content-Type', 'text/plain')
    *
+   *   // Append multiple headers using the append option (e.g. Vary)
+   *   c.header('Vary', 'Accept-Encoding', { append: true })
+   *   c.header('Vary', 'User-Agent', { append: true })
+   *
    *   return c.body('Thank you for coming')
    * })
    * ```

package/node_modules/hono/dist/helper/accepts/accepts.js

@@ -1,9 +1,43 @@
 // src/helper/accepts/accepts.ts
 import { parseAccept } from "../../utils/accept.js";
+var matchType = (acceptType, supportedType) => {
+  if (acceptType === supportedType) {
+    return true;
+  }
+  if (acceptType === "*/*" || acceptType === "*") {
+    return false;
+  }
+  if (acceptType.endsWith("/*")) {
+    const [acceptMain] = acceptType.split("/");
+    const [supportedMain] = supportedType.split("/");
+    return acceptMain === supportedMain;
+  }
+  return false;
+};
+var getSpecificity = (type) => {
+  if (type === "*/*" || type === "*") {
+    return 1;
+  }
+  if (type.endsWith("/*")) {
+    return 2;
+  }
+  return 3;
+};
 var defaultMatch = (accepts2, config) => {
   const { supports, default: defaultSupport } = config;
-  const accept = accepts2.sort((a, b) => b.q - a.q).find((accept2) => supports.includes(accept2.type));
-  return accept ? accept.type : defaultSupport;
+  const sortedAccepts = accepts2.slice().sort((a, b) => {
+    if (b.q !== a.q) {
+      return b.q - a.q;
+    }
+    return getSpecificity(b.type) - getSpecificity(a.type);
+  });
+  for (const accept of sortedAccepts) {
+    const matched = supports.find((supported) => matchType(accept.type, supported));
+    if (matched) {
+      return matched;
+    }
+  }
+  return defaultSupport;
 };
 var accepts = (c, options) => {
   const acceptHeader = c.req.header(options.header);

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

@@ -184,7 +184,7 @@ var saveContentToFile = async (data, fsModule, outDir, extensionMap) => {
   const { routePath, content, mimeType } = awaitedData;
   const filePath = generateFilePath(routePath, outDir, mimeType, extensionMap);
   const dirPath = dirname(filePath);
-  if (!createdDirs.has(dirPath)) {
+  if (dirPath !== "" && !createdDirs.has(dirPath)) {
     await fsModule.mkdir(dirPath, { recursive: true });
     createdDirs.add(dirPath);
   }

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

@@ -8,8 +8,14 @@ var dirname = (path) => {
 var normalizePath = (path) => {
   return path.replace(/(\\)/g, "/").replace(/\/$/g, "");
 };
-var handleParent = (resultPaths, beforeParentFlag) => {
-  if (resultPaths.length === 0 || beforeParentFlag) {
+var getUncRoot = (path) => {
+  const uncRoot = path.replace(/\\/g, "/").match(/^\/\/([^/]+)\/([^/]+)/);
+  if (uncRoot) {
+    return `${uncRoot[1].toLowerCase()}/${uncRoot[2].toLowerCase()}`;
+  }
+};
+var handleParent = (resultPaths) => {
+  if (resultPaths.length === 0 || resultPaths[resultPaths.length - 1] === "..") {
     resultPaths.push("..");
   } else {
     resultPaths.pop();
@@ -22,22 +28,20 @@ var handleNonDot = (path, resultPaths) => {
   }
 };
 var handleSegments = (paths, resultPaths) => {
-  let beforeParentFlag = false;
   for (const path of paths) {
     if (path === "..") {
-      handleParent(resultPaths, beforeParentFlag);
-      beforeParentFlag = true;
+      handleParent(resultPaths);
     } else {
       handleNonDot(path, resultPaths);
-      beforeParentFlag = false;
     }
   }
 };
 var joinPaths = (...paths) => {
+  const hasUncPrefix = getUncRoot(paths[0]) !== void 0;
   paths = paths.map(normalizePath);
   const resultPaths = [];
   handleSegments(paths.join("/").split("/"), resultPaths);
-  return (paths[0][0] === "/" ? "/" : "") + resultPaths.join("/");
+  return (hasUncPrefix ? "//" : paths[0][0] === "/" ? "/" : "") + resultPaths.join("/");
 };
 var filterStaticGenerateRoutes = (hono) => {
   return hono.routes.reduce((acc, { method, handler, path }) => {
@@ -51,10 +55,26 @@ var filterStaticGenerateRoutes = (hono) => {
 var isDynamicRoute = (path) => {
   return path.split("/").some((segment) => segment.startsWith(":") || segment.includes("*"));
 };
+var toSegments = (path) => path === "" ? [] : path.split("/");
+var getPathRoot = (path) => {
+  const normalizedPath = path.replace(/\\/g, "/");
+  const uncRoot = getUncRoot(normalizedPath);
+  if (uncRoot) {
+    return `unc:${uncRoot}`;
+  }
+  const driveRoot = normalizedPath.match(/^([A-Za-z]):/);
+  if (driveRoot) {
+    const kind = normalizedPath[2] === "/" ? "drive-absolute" : "drive-relative";
+    return `${kind}:${driveRoot[1].toLowerCase()}`;
+  }
+  return normalizedPath.startsWith("/") ? "absolute" : "relative";
+};
 var ensureWithinOutDir = (outDir, filePath) => {
-  const normalizedOutDir = joinPaths("/", outDir);
-  const normalizedFilePath = joinPaths("/", filePath);
-  if (normalizedFilePath !== normalizedOutDir && !normalizedFilePath.startsWith(`${normalizedOutDir}/`)) {
+  const outDirSegments = toSegments(joinPaths(outDir));
+  const filePathSegments = toSegments(joinPaths(filePath));
+  const hasMismatchedPathRoot = getPathRoot(outDir) !== getPathRoot(filePath);
+  const climbsAboveOutDir = filePathSegments[outDirSegments.length] === "..";
+  if (hasMismatchedPathRoot || filePathSegments.length <= outDirSegments.length || !outDirSegments.every((segment, i) => segment === filePathSegments[i]) || climbsAboveOutDir) {
     throw new Error(`Path traversal detected: "${filePath}" is outside the output directory`);
   }
 };

package/node_modules/hono/dist/jsx/dom/render.js

@@ -78,6 +78,7 @@ var applyProps = (container, attributes, oldAttributes) => {
       } else if (key === "dangerouslySetInnerHTML" && value) {
         container.innerHTML = value.__html;
       } else if (key === "ref") {
+        refCleanupMap.get(container)?.();
         let cleanup;
         if (typeof value === "function") {
           cleanup = value(container) || (() => value(null));
@@ -142,6 +143,7 @@ var applyProps = (container, attributes, oldAttributes) => {
           container.removeEventListener(eventSpec[0], value, eventSpec[1]);
         } else if (key === "ref") {
           refCleanupMap.get(container)?.();
+          refCleanupMap.delete(container);
         } else {
           try {
             container.removeAttribute(toAttributeName(container, key));

package/node_modules/hono/dist/jsx/intrinsic-element/components.js

@@ -78,7 +78,7 @@ var documentMetadataTag = (tag, children, props, sort) => {
   const string = new JSXNode(tag, restProps, toArray(children || [])).toString();
   if (string instanceof Promise) {
     return string.then(
-      (resString) => raw(string, [
+      (resString) => raw(resString, [
         ...resString.callbacks || [],
         insertIntoHead(tag, resString, restProps, precedence)
       ])

package/node_modules/hono/dist/middleware/cache/index.js

@@ -23,7 +23,7 @@ var parseVaryDirectives = (vary) => {
 };
 var createCacheKey = (key, requestUrl, request, varyHeaders) => {
   const url = new URL(cacheKeyPath, requestUrl);
-  url.searchParams.append(cacheKeyParameter, key.split("#", 1)[0]);
+  url.searchParams.append(cacheKeyParameter, key);
   url.searchParams.append(cacheMethodKeyParameter, request.method);
   if (request.method === "QUERY") {
     url.searchParams.append(queryDigestKeyParameter, request.digest);

package/node_modules/hono/dist/middleware/cors/index.js

@@ -7,6 +7,8 @@ var cors = (options) => {
     exposeHeaders: [],
     ...options
   };
+  const exposeHeadersStr = opts.exposeHeaders?.length ? opts.exposeHeaders.join(",") : void 0;
+  const allowHeadersStr = opts.allowHeaders?.length ? opts.allowHeaders.join(",") : void 0;
   const findAllowOrigin = ((optsOrigin) => {
     if (typeof optsOrigin === "string") {
       if (optsOrigin === "*") {
@@ -22,11 +24,12 @@ var cors = (options) => {
   })(opts.origin);
   const findAllowMethods = ((optsAllowMethods) => {
     if (typeof optsAllowMethods === "function") {
-      return optsAllowMethods;
+      return async (origin, c) => (await optsAllowMethods(origin, c)).join(",");
     } else if (Array.isArray(optsAllowMethods)) {
-      return () => optsAllowMethods;
+      const methodsStr = optsAllowMethods.join(",");
+      return () => methodsStr;
     } else {
-      return () => [];
+      return () => "";
     }
   })(opts.allowMethods);
   return async function cors2(c, next) {
@@ -40,29 +43,29 @@ var cors = (options) => {
     if (opts.credentials) {
       set("Access-Control-Allow-Credentials", "true");
     }
-    if (opts.exposeHeaders?.length) {
-      set("Access-Control-Expose-Headers", opts.exposeHeaders.join(","));
+    if (exposeHeadersStr) {
+      set("Access-Control-Expose-Headers", exposeHeadersStr);
     }
     if (c.req.method === "OPTIONS") {
       if (opts.origin !== "*") {
-        set("Vary", "Origin");
+        c.res.headers.append("Vary", "Origin");
       }
       if (opts.maxAge != null) {
         set("Access-Control-Max-Age", opts.maxAge.toString());
       }
       const allowMethods = await findAllowMethods(c.req.header("origin") || "", c);
-      if (allowMethods.length) {
-        set("Access-Control-Allow-Methods", allowMethods.join(","));
+      if (allowMethods) {
+        set("Access-Control-Allow-Methods", allowMethods);
       }
-      let headers = opts.allowHeaders;
-      if (!headers?.length) {
+      let headersStr = allowHeadersStr;
+      if (!headersStr) {
         const requestHeaders = c.req.header("Access-Control-Request-Headers");
         if (requestHeaders) {
-          headers = requestHeaders.split(",").map((h) => h.trim());
+          headersStr = requestHeaders.split(",").map((h) => h.trim()).join(",");
         }
       }
-      if (headers?.length) {
-        set("Access-Control-Allow-Headers", headers.join(","));
+      if (headersStr) {
+        set("Access-Control-Allow-Headers", headersStr);
         c.res.headers.append("Vary", "Access-Control-Request-Headers");
       }
       c.res.headers.delete("Content-Length");

package/node_modules/hono/dist/middleware/csrf/index.js

@@ -2,7 +2,7 @@
 import { HTTPException } from "../../http-exception.js";
 var secFetchSiteValues = ["same-origin", "same-site", "none", "cross-site"];
 var isSecFetchSite = (value) => secFetchSiteValues.includes(value);
-var isSafeMethodRe = /^(GET|HEAD)$/;
+var isSafeMethodRe = /^(GET|HEAD|OPTIONS)$/;
 var isRequestedByFormElementRe = /^\b(application\/x-www-form-urlencoded|multipart\/form-data|text\/plain)\b/i;
 var csrf = (options) => {
   const originHandler = ((optsOrigin) => {

package/node_modules/hono/dist/middleware/etag/digest.js

@@ -10,18 +10,64 @@ var mergeBuffers = (buffer1, buffer2) => {
   merged.set(buffer2, buffer1.byteLength);
   return merged;
 };
+var CHUNK_SIZE = 256 * 1024;
 var generateDigest = async (stream, generator) => {
   if (!stream) {
     return null;
   }
   let result = void 0;
+  let chunk;
+  let chunkLength = 0;
+  const digest = async (body) => {
+    result = await generator(mergeBuffers(result, body));
+  };
   const reader = stream.getReader();
   for (; ; ) {
     const { value, done } = await reader.read();
     if (done) {
       break;
     }
-    result = await generator(mergeBuffers(result, value));
+    let offset = 0;
+    while (offset < value.byteLength) {
+      const remaining = value.byteLength - offset;
+      if (chunkLength === 0 && remaining >= CHUNK_SIZE) {
+        await digest(value.subarray(offset, offset + CHUNK_SIZE));
+        offset += CHUNK_SIZE;
+        continue;
+      }
+      const requiredLength = chunkLength + remaining;
+      if (requiredLength < CHUNK_SIZE) {
+        if (!chunk) {
+          chunk = value.slice(offset);
+        } else {
+          if (chunk.byteLength < requiredLength) {
+            const nextChunk = new Uint8Array(
+              new ArrayBuffer(Math.min(CHUNK_SIZE, Math.max(requiredLength, chunk.byteLength * 2)))
+            );
+            nextChunk.set(chunk.subarray(0, chunkLength));
+            chunk = nextChunk;
+          }
+          chunk.set(value.subarray(offset), chunkLength);
+        }
+        chunkLength = requiredLength;
+        break;
+      }
+      const length = CHUNK_SIZE - chunkLength;
+      if (chunk?.byteLength !== CHUNK_SIZE) {
+        const nextChunk = new Uint8Array(new ArrayBuffer(CHUNK_SIZE));
+        if (chunk) {
+          nextChunk.set(chunk.subarray(0, chunkLength));
+        }
+        chunk = nextChunk;
+      }
+      chunk.set(value.subarray(offset, offset + length), chunkLength);
+      await digest(chunk);
+      chunkLength = 0;
+      offset += length;
+    }
+  }
+  if (chunk && chunkLength > 0) {
+    await digest(chunk.subarray(0, chunkLength));
   }
   if (!result) {
     return null;

package/node_modules/hono/dist/middleware/etag/index.js

@@ -10,7 +10,7 @@ var RETAINED_304_HEADERS = [
 ];
 var stripWeak = (tag) => tag.replace(/^W\//, "");
 function etagMatches(etag2, ifNoneMatch) {
-  return ifNoneMatch != null && ifNoneMatch.split(/,\s*/).some((t) => stripWeak(t) === stripWeak(etag2));
+  return ifNoneMatch != null && ifNoneMatch.split(",").some((t) => stripWeak(t.trim()) === stripWeak(etag2));
 }
 function initializeGenerator(generator) {
   if (!generator) {
@@ -60,11 +60,11 @@ var etag = (options) => {
           ETag: etag3
         }
       });
-      c.res.headers.forEach((_, key) => {
+      for (const key of Array.from(c.res.headers.keys())) {
         if (retainedHeaders.indexOf(key.toLowerCase()) === -1) {
           c.res.headers.delete(key);
         }
-      });
+      }
     } else {
       c.res.headers.set("ETag", etag3);
     }