@suveren/gateway 0.7.4 → 0.7.6

package/node_modules/fast-uri/test/security-normalization.test.js

@@ -37,3 +37,104 @@ test('equal does not treat reserved path escapes as live path syntax', (t) => {
 
   t.end()
 })
+
+test('serialize preserves literal RFC 3986 reserved path characters', (t) => {
+  // GHSA-7mh8-fcmq-x23c: literal reserved path chars must not be rewritten to
+  // percent escapes by the escape()-style safe set.
+  const cases = [
+    'http://example.com/a;b',
+    'http://example.com/a=b',
+    'http://example.com/a&b',
+    'http://example.com/a$b',
+    'http://example.com/a:b',
+    'http://example.com/a@b'
+  ]
+
+  t.plan(cases.length)
+
+  cases.forEach((uri) => {
+    t.equal(fastURI.serialize(fastURI.parse(uri)), uri, uri)
+  })
+  t.end()
+})
+
+test('serialize preserves existing reserved path escapes as data', (t) => {
+  // GHSA-7mh8-fcmq-x23c: an existing %3A escape must stay %3A instead of being
+  // rewritten into a live colon.
+  const cases = [
+    'http://example.com/a%3Ab',
+    'http://example.com/a%3Bb',
+    'http://example.com/a%3D%3D'
+  ]
+
+  t.plan(cases.length)
+
+  cases.forEach((uri) => {
+    t.equal(fastURI.serialize(fastURI.parse(uri)), uri, uri)
+  })
+  t.end()
+})
+
+test('serialize keeps path-noscheme colon escaping', (t) => {
+  // Without a scheme a literal colon would be reparsed as a scheme separator,
+  // so it must stay percent-escaped while an existing %3A is preserved.
+  t.equal(fastURI.serialize({ path: 'foo:bar' }), 'foo%3Abar')
+  t.equal(fastURI.serialize({ path: 'a%3Ab' }), 'a%3Ab')
+  t.end()
+})
+
+test('hostname normalization never decodes an escape more than once', (t) => {
+  const encodedLocalhost = 'http://%256c%256f%2563%2561%256c%2568%256f%2573%2574/'
+  const encodedLoopback = '//127%252e0%252e0%252e1/private'
+  const encodedMetadataAddress = '//169%252E254%252E169%252E254/latest/meta-data/'
+
+  t.equal(fastURI.normalize(encodedLocalhost), encodedLocalhost, 'nested hostname letters remain encoded')
+  t.equal(fastURI.normalize(encodedLoopback), encodedLoopback, 'nested IPv4 dots remain encoded')
+  t.equal(
+    fastURI.resolve('https://safe.example/', encodedLoopback),
+    'https://127%252e0%252e0%252e1/private',
+    'resolve does not turn nested dots into a loopback address'
+  )
+  t.equal(
+    fastURI.resolve('https://allowed.com/api/v1/', encodedMetadataAddress),
+    'https://169%252e254%252e169%252e254/latest/meta-data/',
+    'resolve does not turn nested dots into a metadata address'
+  )
+  t.equal(
+    fastURI.normalize('http://allowed.com%255Cevil.com/'),
+    'http://allowed.com%255Cevil.com/',
+    'normalize does not activate a nested backslash'
+  )
+  t.equal(
+    fastURI.serialize({ scheme: 'http', host: '%256cocalhost', path: '/' }),
+    'http://%256cocalhost/',
+    'component serialization preserves an encoded percent sign'
+  )
+  t.equal(
+    fastURI.equal(encodedLocalhost, 'http://localhost/', {}),
+    false,
+    'nested escapes do not compare equal to their twice-decoded target'
+  )
+  t.end()
+})
+
+test('hostname normalization decodes only current unreserved escapes', (t) => {
+  t.equal(fastURI.normalize('x://%6cocalhost/'), 'x://localhost/', 'a current unreserved escape is decoded')
+  t.equal(fastURI.normalize('x://%256cocalhost/'), 'x://%256cocalhost/', 'an encoded percent is preserved')
+  t.equal(fastURI.normalize('x://host%2540evil/'), 'x://host%2540evil/', 'a nested authority delimiter stays inert')
+  t.equal(fastURI.normalize('x://%2525/'), 'x://%2525/', 'nested encoded percent signs stay encoded')
+  t.end()
+})
+
+test('host conversion failures are not treated as comparable URLs', (t) => {
+  const malformedHost = 'http://trusted.test%2540evil.test/'
+
+  t.equal(fastURI.normalize(malformedHost), malformedHost, 'normalization preserves the failing input')
+  t.equal(fastURI.equal(malformedHost, malformedHost, {}), false, 'equal rejects a failed host conversion')
+  t.throws(
+    () => fastURI.resolve(malformedHost, 'child', { domainHost: true }),
+    /Host's domain name can not be converted to ASCII/,
+    'resolve propagates a host conversion failure'
+  )
+  t.end()
+})

package/node_modules/fast-uri/test/security.test.js

@@ -125,11 +125,13 @@ test('serialize escapes authority delimiters in host field', (t) => {
 })
 
 test('normalize does not double-decode %2540 into a live @', (t) => {
-  const result = fastURI.normalize('http://trusted.com%2540evil.com/')
+  const input = 'http://trusted.com%2540evil.com/'
+  const result = fastURI.normalize(input)
   const parsed = fastURI.parse(result)
 
-  t.plan(1)
-  t.notEqual(parsed.host, 'trusted.com@evil.com', 'http://trusted.com%2540evil.com/')
+  t.plan(2)
+  t.equal(result, input, 'the encoded percent sign is preserved')
+  t.notEqual(parsed.host, 'trusted.com@evil.com', input)
 })
 
 test('parse canonicalises IDN / Unicode hosts to their ASCII form', (t) => {
@@ -160,6 +162,76 @@ test('parse canonicalises IDN / Unicode hosts to their ASCII form', (t) => {
   })
 })
 
+test('resolve canonicalises the host using the final resolved scheme', (t) => {
+  const cases = [
+    {
+      base: 'http://trusted.example/base',
+      relative: '//127\u30020\u30020\u30021/private',
+      expected: 'http://127.0.0.1/private',
+      expectedHost: '127.0.0.1',
+      description: 'scheme-relative loopback host'
+    },
+    {
+      base: 'https://ex\u00ADample.com/base',
+      relative: 'child',
+      expected: 'https://example.com/child',
+      expectedHost: 'example.com',
+      description: 'host inherited from the base'
+    },
+    {
+      base: 'http://trusted.example/base',
+      relative: 'http://ex\u200Bample.com/',
+      expected: 'http://example.com/',
+      expectedHost: 'example.com',
+      description: 'absolute relative reference'
+    }
+  ]
+
+  t.plan(cases.length * 2)
+
+  cases.forEach(({ base, relative, expected, expectedHost, description }) => {
+    const resolved = fastURI.resolve(base, relative)
+    t.equal(resolved, expected, description)
+    t.equal(fastURI.parse(resolved).host, expectedHost, `${description} reparses consistently`)
+  })
+})
+
+test('resolve applies domain canonicalisation only when the effective scheme opts in', (t) => {
+  const host = 'ex\u00ADample.com'
+
+  t.plan(2)
+  t.equal(
+    fastURI.resolve('uri://trusted.example/', `//${host}/`),
+    `uri://${host}/`,
+    'an unsupported scheme preserves the host'
+  )
+  t.equal(
+    fastURI.resolve('http://trusted.example/', `//${host}/`, { unicodeSupport: true }),
+    `http://${host}/`,
+    'unicodeSupport preserves the Unicode host'
+  )
+})
+
+test('resolve throws when the final scheme cannot canonicalise the host', (t) => {
+  const invalidHost = '\u200D.example'
+  const cases = [
+    ['http://trusted.example/', `//${invalidHost}/`],
+    [`https://${invalidHost}/base`, 'child'],
+    ['http://trusted.example/', `http://${invalidHost}/`],
+    ['http://trusted.example/', `//${invalidHost}%2Etest/`]
+  ]
+
+  t.plan(cases.length)
+
+  cases.forEach(([base, relative]) => {
+    t.throws(
+      () => fastURI.resolve(base, relative),
+      /Host's domain name can not be converted to ASCII/,
+      `${base} + ${relative}`
+    )
+  })
+})
+
 test('parse rejects a literal backslash in the authority as malformed (RFC 3986)', (t) => {
   // Regression for the host-confusion bypass: a literal "\" is invalid RFC 3986
   // syntax and must be flagged malformed, not silently rewritten. Otherwise "\"

package/node_modules/fast-uri/test/urn-full-input.test.js

@@ -0,0 +1,29 @@
+'use strict'
+
+const test = require('tape')
+const fastURI = require('..')
+
+test('URN parsing validates the complete scheme-specific input', (t) => {
+  const embedded = fastURI.parse('urn:x|foo:bar')
+  t.equal(embedded.error, 'URN can not be parsed.', 'does not search for a later nid:nss substring')
+  t.equal(embedded.nid, undefined, 'does not adopt the later nid')
+  t.equal(embedded.nss, undefined, 'does not adopt the later nss')
+
+  const trailing = fastURI.parse('urn:foo:bar|ignored')
+  t.equal(trailing.error, 'URN can not be parsed.', 'rejects trailing input outside the RFC 2141 NSS grammar')
+  t.equal(trailing.nid, undefined, 'does not return an nid from a partial match')
+  t.equal(trailing.nss, undefined, 'does not return a truncated nss')
+
+  t.end()
+})
+
+test('URN parsing preserves the complete RFC 2141 NSS', (t) => {
+  const parsed = fastURI.parse('urn:foo:allowed/evil')
+  t.equal(parsed.error, undefined, 'accepts slash in an RFC 2141 NSS')
+  t.equal(parsed.nid, 'foo', 'parses the nid')
+  t.equal(parsed.nss, 'allowed/evil', 'preserves the complete NSS')
+  t.equal(fastURI.normalize('urn:foo:allowed/evil'), 'urn:foo:allowed/evil', 'normalization retains slash data')
+  t.equal(fastURI.equal('urn:foo:allowed/evil', 'urn:foo:allowed'), false, 'distinct NSS values do not compare equal')
+
+  t.end()
+})

package/node_modules/fast-uri/test/websocket-query-preservation.test.js

@@ -0,0 +1,24 @@
+'use strict'
+
+const test = require('tape')
+const fastURI = require('..')
+
+test('WebSocket queries preserve additional question marks', (t) => {
+  for (const scheme of ['ws', 'wss']) {
+    const uri = `${scheme}://example.com/chat?a?b`
+    const truncatedURI = `${scheme}://example.com/chat?a`
+    const parsed = fastURI.parse(uri)
+
+    t.equal(parsed.resourceName, '/chat?a?b', `${scheme} parse preserves the resource name`)
+    t.equal(fastURI.serialize(parsed), uri, `${scheme} parsed components round-trip`)
+    t.equal(
+      fastURI.serialize({ scheme, host: 'example.com', resourceName: '/chat?a?b' }),
+      uri,
+      `${scheme} resource name serializes without truncation`
+    )
+    t.equal(fastURI.normalize(uri), uri, `${scheme} normalization preserves the full query`)
+    t.equal(fastURI.equal(uri, truncatedURI), false, `${scheme} equality distinguishes the full query`)
+  }
+
+  t.end()
+})

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

@@ -40,6 +40,10 @@ const createProxy = (callback, path) => {
   });
   return proxy;
 };
+const appendQueryParams = (url, searchParams) => {
+  const queryString = searchParams.toString();
+  return queryString ? `${url}?${queryString}` : url;
+};
 class ClientRequestImpl {
   url;
   method;
@@ -66,6 +70,9 @@ class ClientRequestImpl {
           }
           if (Array.isArray(v)) {
             for (const v2 of v) {
+              if (v2 === void 0) {
+                continue;
+              }
               form.append(k, v2);
             }
           } else {
@@ -90,19 +97,29 @@ class ClientRequestImpl {
     if (args?.cookie) {
       const cookies = [];
       for (const [key, value] of Object.entries(args.cookie)) {
+        if (value === void 0) {
+          continue;
+        }
         cookies.push((0, import_cookie.serialize)(key, value));
       }
-      headerValues["Cookie"] = cookies.join("; ");
+      if (cookies.length > 0) {
+        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 = (0, import_utils.removeIndexString)(url);
     url = (0, import_utils.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");
@@ -146,7 +163,7 @@ const hc = (baseUrl, options) => createProxy(function proxyCallback(opts) {
         result = (0, import_utils.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 = (0, import_utils.removeIndexString)(result);
@@ -157,18 +174,15 @@ const hc = (baseUrl, options) => createProxy(function proxyCallback(opts) {
   }
   if (method === "ws") {
     const webSocketUrl = (0, import_utils.replaceUrlProtocol)(
-      opts.args[0] && opts.args[0].param ? (0, import_utils.replaceUrlParam)(url, opts.args[0].param) : url,
+      opts.args[0]?.param ? (0, import_utils.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/cjs/client/utils.js

@@ -37,7 +37,7 @@ const mergePath = (base, path) => {
 const 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;
 };
@@ -49,6 +49,9 @@ const 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/cjs/context.js

@@ -224,6 +224,10 @@ class Context {
    *   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/cjs/helper/accepts/accepts.js

@@ -22,10 +22,44 @@ __export(accepts_exports, {
 });
 module.exports = __toCommonJS(accepts_exports);
 var import_accept = require("../../utils/accept");
+const 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;
+};
+const getSpecificity = (type) => {
+  if (type === "*/*" || type === "*") {
+    return 1;
+  }
+  if (type.endsWith("/*")) {
+    return 2;
+  }
+  return 3;
+};
 const 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;
 };
 const accepts = (c, options) => {
   const acceptHeader = c.req.header(options.header);

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

@@ -206,7 +206,7 @@ const saveContentToFile = async (data, fsModule, outDir, extensionMap) => {
   const { routePath, content, mimeType } = awaitedData;
   const filePath = generateFilePath(routePath, outDir, mimeType, extensionMap);
   const dirPath = (0, import_utils2.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/cjs/helper/ssg/utils.js

@@ -33,8 +33,14 @@ const dirname = (path) => {
 const normalizePath = (path) => {
   return path.replace(/(\\)/g, "/").replace(/\/$/g, "");
 };
-const handleParent = (resultPaths, beforeParentFlag) => {
-  if (resultPaths.length === 0 || beforeParentFlag) {
+const getUncRoot = (path) => {
+  const uncRoot = path.replace(/\\/g, "/").match(/^\/\/([^/]+)\/([^/]+)/);
+  if (uncRoot) {
+    return `${uncRoot[1].toLowerCase()}/${uncRoot[2].toLowerCase()}`;
+  }
+};
+const handleParent = (resultPaths) => {
+  if (resultPaths.length === 0 || resultPaths[resultPaths.length - 1] === "..") {
     resultPaths.push("..");
   } else {
     resultPaths.pop();
@@ -47,22 +53,20 @@ const handleNonDot = (path, resultPaths) => {
   }
 };
 const 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;
     }
   }
 };
 const 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("/");
 };
 const filterStaticGenerateRoutes = (hono) => {
   return hono.routes.reduce((acc, { method, handler, path }) => {
@@ -76,10 +80,26 @@ const filterStaticGenerateRoutes = (hono) => {
 const isDynamicRoute = (path) => {
   return path.split("/").some((segment) => segment.startsWith(":") || segment.includes("*"));
 };
+const toSegments = (path) => path === "" ? [] : path.split("/");
+const 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";
+};
 const 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/cjs/jsx/dom/render.js

@@ -101,6 +101,7 @@ const 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));
@@ -165,6 +166,7 @@ const 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/cjs/middleware/cache/index.js

@@ -44,7 +44,7 @@ const parseVaryDirectives = (vary) => {
 };
 const 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/cjs/middleware/cors/index.js

@@ -69,7 +69,7 @@ const cors = (options) => {
     }
     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());

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

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

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

@@ -59,7 +59,7 @@ const generateDigest = async (stream, generator) => {
       const requiredLength = chunkLength + remaining;
       if (requiredLength < CHUNK_SIZE) {
         if (!chunk) {
-          chunk = value.subarray(offset);
+          chunk = value.slice(offset);
         } else {
           if (chunk.byteLength < requiredLength) {
             const nextChunk = new Uint8Array(

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

@@ -32,7 +32,7 @@ const RETAINED_304_HEADERS = [
 ];
 const 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) {
@@ -82,11 +82,11 @@ const 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);
     }

package/node_modules/hono/dist/cjs/middleware/pretty-json/index.js

@@ -20,12 +20,14 @@ __export(pretty_json_exports, {
   prettyJSON: () => prettyJSON
 });
 module.exports = __toCommonJS(pretty_json_exports);
+const jsonContentTypeRegex = /^application\/(?:[a-z0-9._-]+\+)?json(?=$|[;\s])/i;
 const prettyJSON = (options) => {
   const targetQuery = options?.query ?? "pretty";
   return async function prettyJSON2(c, next) {
     const pretty = options?.force || c.req.query(targetQuery) || c.req.query(targetQuery) === "";
     await next();
-    if (pretty && c.res.headers.get("Content-Type")?.startsWith("application/json")) {
+    const contentType = c.res.headers.get("Content-Type");
+    if (pretty && contentType && jsonContentTypeRegex.test(contentType)) {
       const obj = await c.res.json();
       c.res = new Response(JSON.stringify(obj, null, options?.space ?? 2), c.res);
     }

package/node_modules/hono/dist/cjs/request.js

@@ -68,13 +68,13 @@ class HonoRequest {
     return key ? this.#getDecodedParam(key) : this.#getAllDecodedParams();
   }
   #getDecodedParam(key) {
-    const paramKey = this.#matchResult[0][this.routeIndex][1][key];
+    const paramKey = this.#matchResult[0][this.routeIndex]?.[1][key];
     const param = this.#getParamValue(paramKey);
     return param && (0, import_url.tryDecodeURIComponent)(param);
   }
   #getAllDecodedParams() {
     const decoded = {};
-    const keys = Object.keys(this.#matchResult[0][this.routeIndex][1]);
+    const keys = Object.keys(this.#matchResult[0][this.routeIndex]?.[1] ?? {});
     for (const key of keys) {
       const value = this.#getParamValue(this.#matchResult[0][this.routeIndex][1][key]);
       if (value !== void 0) {
@@ -314,10 +314,14 @@ const cloneRawRequest = async (req) => {
       message: "Cannot clone request: body was already consumed and not cached. Please use HonoRequest methods (e.g., req.json(), req.text()) instead of consuming req.raw directly."
     });
   }
-  const body = await req[cacheKey]();
+  let body = await req[cacheKey]();
   const headers = req.header();
-  if (body instanceof FormData) {
+  if (cacheKey === "json") {
+    body = JSON.stringify(body);
+    delete headers["content-length"];
+  } else if (body instanceof FormData) {
     delete headers["content-type"];
+    delete headers["content-length"];
   }
   const requestInit = {
     body,

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

@@ -50,7 +50,8 @@ class LinearRouter {
           }
         } else if (hasStar && !hasLabel) {
           const endsWithStar = routePath.charCodeAt(routePath.length - 1) === 42;
-          const parts = (endsWithStar ? routePath.slice(0, -2) : routePath).split(splitByStarRe);
+          const endsWithSlashStar = routePath.endsWith("/*");
+          const parts = (endsWithStar ? routePath.slice(0, endsWithSlashStar ? -2 : -1) : routePath).split(splitByStarRe);
           const lastIndex = parts.length - 1;
           for (let j = 0, pos = 0, len2 = parts.length; j < len2; j++) {
             const part = parts[j];
@@ -60,7 +61,11 @@ class LinearRouter {
             }
             pos += part.length;
             if (j === lastIndex) {
-              if (!endsWithStar && pos !== path.length && !(pos === path.length - 1 && path.charCodeAt(pos) === 47)) {
+              if (endsWithSlashStar) {
+                if (pos !== path.length && path.charCodeAt(pos) !== 47) {
+                  continue ROUTES_LOOP;
+                }
+              } else if (!endsWithStar && pos !== path.length && !(pos === path.length - 1 && path.charCodeAt(pos) === 47)) {
                 continue ROUTES_LOOP;
               }
             } else {