hono 4.6.19 → 4.7.0

package/dist/cjs/middleware/language/language.js

@@ -0,0 +1,210 @@
+"use strict";
+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 language_exports = {};
+__export(language_exports, {
+  DEFAULT_OPTIONS: () => DEFAULT_OPTIONS,
+  detectFromCookie: () => detectFromCookie,
+  detectFromHeader: () => detectFromHeader,
+  detectFromPath: () => detectFromPath,
+  detectFromQuery: () => detectFromQuery,
+  detectors: () => detectors,
+  languageDetector: () => languageDetector,
+  normalizeLanguage: () => normalizeLanguage,
+  parseAcceptLanguage: () => parseAcceptLanguage,
+  validateOptions: () => validateOptions
+});
+module.exports = __toCommonJS(language_exports);
+var import_cookie = require("../../helper/cookie");
+var import_accept = require("../../utils/accept");
+const DEFAULT_OPTIONS = {
+  order: ["querystring", "cookie", "header"],
+  lookupQueryString: "lang",
+  lookupCookie: "language",
+  lookupFromHeaderKey: "accept-language",
+  lookupFromPathIndex: 0,
+  caches: ["cookie"],
+  ignoreCase: true,
+  fallbackLanguage: "en",
+  supportedLanguages: ["en"],
+  cookieOptions: {
+    sameSite: "Strict",
+    secure: true,
+    maxAge: 365 * 24 * 60 * 60,
+    httpOnly: true
+  },
+  debug: false
+};
+function parseAcceptLanguage(header) {
+  return (0, import_accept.parseAccept)(header).map(({ type, q }) => ({ lang: type, q }));
+}
+const normalizeLanguage = (lang, options) => {
+  if (!lang) {
+    return void 0;
+  }
+  try {
+    let normalizedLang = lang.trim();
+    if (options.convertDetectedLanguage) {
+      normalizedLang = options.convertDetectedLanguage(normalizedLang);
+    }
+    const compLang = options.ignoreCase ? normalizedLang.toLowerCase() : normalizedLang;
+    const compSupported = options.supportedLanguages.map(
+      (l) => options.ignoreCase ? l.toLowerCase() : l
+    );
+    const matchedLang = compSupported.find((l) => l === compLang);
+    return matchedLang ? options.supportedLanguages[compSupported.indexOf(matchedLang)] : void 0;
+  } catch {
+    return void 0;
+  }
+};
+const detectFromQuery = (c, options) => {
+  try {
+    const query = c.req.query(options.lookupQueryString);
+    return normalizeLanguage(query, options);
+  } catch {
+    return void 0;
+  }
+};
+const detectFromCookie = (c, options) => {
+  try {
+    const cookie = (0, import_cookie.getCookie)(c, options.lookupCookie);
+    return normalizeLanguage(cookie, options);
+  } catch {
+    return void 0;
+  }
+};
+function detectFromHeader(c, options) {
+  try {
+    const acceptLanguage = c.req.header(options.lookupFromHeaderKey);
+    if (!acceptLanguage) {
+      return void 0;
+    }
+    const languages = parseAcceptLanguage(acceptLanguage);
+    for (const { lang } of languages) {
+      const normalizedLang = normalizeLanguage(lang, options);
+      if (normalizedLang) {
+        return normalizedLang;
+      }
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+function detectFromPath(c, options) {
+  try {
+    const pathSegments = c.req.path.split("/").filter(Boolean);
+    const langSegment = pathSegments[options.lookupFromPathIndex];
+    return normalizeLanguage(langSegment, options);
+  } catch {
+    return void 0;
+  }
+}
+const detectors = {
+  querystring: detectFromQuery,
+  cookie: detectFromCookie,
+  header: detectFromHeader,
+  path: detectFromPath
+};
+function validateOptions(options) {
+  if (!options.supportedLanguages.includes(options.fallbackLanguage)) {
+    throw new Error("Fallback language must be included in supported languages");
+  }
+  if (options.lookupFromPathIndex < 0) {
+    throw new Error("Path index must be non-negative");
+  }
+  if (!options.order.every((detector) => Object.keys(detectors).includes(detector))) {
+    throw new Error("Invalid detector type in order array");
+  }
+}
+function cacheLanguage(c, language, options) {
+  if (!Array.isArray(options.caches) || !options.caches.includes("cookie")) {
+    return;
+  }
+  try {
+    (0, import_cookie.setCookie)(c, options.lookupCookie, language, options.cookieOptions);
+  } catch (error) {
+    if (options.debug) {
+      console.error("Failed to cache language:", error);
+    }
+  }
+}
+const detectLanguage = (c, options) => {
+  let detectedLang;
+  for (const detectorName of options.order) {
+    const detector = detectors[detectorName];
+    if (!detector) {
+      continue;
+    }
+    try {
+      detectedLang = detector(c, options);
+      if (detectedLang) {
+        if (options.debug) {
+          console.log(`Language detected from ${detectorName}: ${detectedLang}`);
+        }
+        break;
+      }
+    } catch (error) {
+      if (options.debug) {
+        console.error(`Error in ${detectorName} detector:`, error);
+      }
+      continue;
+    }
+  }
+  const finalLang = detectedLang || options.fallbackLanguage;
+  if (detectedLang && options.caches) {
+    cacheLanguage(c, finalLang, options);
+  }
+  return finalLang;
+};
+const languageDetector = (userOptions) => {
+  const options = {
+    ...DEFAULT_OPTIONS,
+    ...userOptions,
+    cookieOptions: {
+      ...DEFAULT_OPTIONS.cookieOptions,
+      ...userOptions.cookieOptions
+    }
+  };
+  validateOptions(options);
+  return async function languageDetector2(ctx, next) {
+    try {
+      const lang = detectLanguage(ctx, options);
+      ctx.set("language", lang);
+    } catch (error) {
+      if (options.debug) {
+        console.error("Language detection failed:", error);
+      }
+      ctx.set("language", options.fallbackLanguage);
+    }
+    await next();
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_OPTIONS,
+  detectFromCookie,
+  detectFromHeader,
+  detectFromPath,
+  detectFromQuery,
+  detectors,
+  languageDetector,
+  normalizeLanguage,
+  parseAcceptLanguage,
+  validateOptions
+});

package/dist/cjs/middleware/logger/index.js

@@ -22,7 +22,6 @@ __export(logger_exports, {
 });
 module.exports = __toCommonJS(logger_exports);
 var import_color = require("../../utils/color");
-var import_url = require("../../utils/url");
 var LogPrefix = /* @__PURE__ */ ((LogPrefix2) => {
   LogPrefix2["Outgoing"] = "-->";
   LogPrefix2["Incoming"] = "<--";
@@ -60,8 +59,8 @@ function log(fn, prefix, method, path, status = 0, elapsed) {
 }
 const logger = (fn = console.log) => {
   return async function logger2(c, next) {
-    const { method } = c.req;
-    const path = (0, import_url.getPath)(c.req.raw);
+    const { method, url } = c.req;
+    const path = url.slice(url.indexOf("/", 8));
     log(fn, "<--" /* Incoming */, method, path);
     const start = Date.now();
     await next();

package/dist/cjs/request.js

@@ -67,7 +67,7 @@ class HonoRequest {
   }
   header(name) {
     if (name) {
-      return this.raw.headers.get(name.toLowerCase()) ?? void 0;
+      return this.raw.headers.get(name) ?? void 0;
     }
     const headerData = {};
     this.raw.headers.forEach((value, key) => {

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

@@ -88,7 +88,9 @@ class LinearRouter {
                 let value;
                 if (name.charCodeAt(name.length - 1) === 125) {
                   const openBracePos = name.indexOf("{");
-                  const pattern = name.slice(openBracePos + 1, -1);
+                  const next = parts[j + 1];
+                  const lookahead = next && next[1] !== ":" && next[1] !== "*" ? `(?=${next})` : "";
+                  const pattern = name.slice(openBracePos + 1, -1) + lookahead;
                   const restPath = path.slice(pos + 1);
                   const match = new RegExp(pattern, "d").exec(restPath);
                   if (!match || match.indices[0][0] !== 0 || match.indices[0][1] === 0) {

package/dist/cjs/router/trie-router/node.js

@@ -47,21 +47,23 @@ class Node {
     const possibleKeys = [];
     for (let i = 0, len = parts.length; i < len; i++) {
       const p = parts[i];
-      if (Object.keys(curNode.#children).includes(p)) {
-        curNode = curNode.#children[p];
-        const pattern2 = (0, import_url.getPattern)(p);
+      const nextP = parts[i + 1];
+      const pattern = (0, import_url.getPattern)(p, nextP);
+      const key = Array.isArray(pattern) ? pattern[0] : p;
+      if (Object.keys(curNode.#children).includes(key)) {
+        curNode = curNode.#children[key];
+        const pattern2 = (0, import_url.getPattern)(p, nextP);
         if (pattern2) {
           possibleKeys.push(pattern2[1]);
         }
         continue;
       }
-      curNode.#children[p] = new Node();
-      const pattern = (0, import_url.getPattern)(p);
+      curNode.#children[key] = new Node();
       if (pattern) {
         curNode.#patterns.push(pattern);
         possibleKeys.push(pattern[1]);
       }
-      curNode = curNode.#children[p];
+      curNode = curNode.#children[key];
     }
     const m = /* @__PURE__ */ Object.create(null);
     const handlerSet = {
@@ -100,6 +102,7 @@ class Node {
     const curNode = this;
     let curNodes = [curNode];
     const parts = (0, import_url.splitPath)(path);
+    const curNodesQueue = [];
     for (let i = 0, len = parts.length; i < len; i++) {
       const part = parts[i];
       const isLast = i === len - 1;
@@ -127,6 +130,7 @@ class Node {
             const astNode = node.#children["*"];
             if (astNode) {
               handlerSets.push(...this.#getHandlerSets(astNode, method, node.#params));
+              astNode.#params = params;
               tempNodes.push(astNode);
             }
             continue;
@@ -137,10 +141,19 @@ class Node {
           const [key, name, matcher] = pattern;
           const child = node.#children[key];
           const restPathString = parts.slice(i).join("/");
-          if (matcher instanceof RegExp && matcher.test(restPathString)) {
-            params[name] = restPathString;
-            handlerSets.push(...this.#getHandlerSets(child, method, node.#params, params));
-            continue;
+          if (matcher instanceof RegExp) {
+            const m = matcher.exec(restPathString);
+            if (m) {
+              params[name] = m[0];
+              handlerSets.push(...this.#getHandlerSets(child, method, node.#params, params));
+              if (Object.keys(child.#children).length) {
+                child.#params = params;
+                const componentCount = m[0].match(/\//)?.length ?? 0;
+                const targetCurNodes = curNodesQueue[componentCount] ||= [];
+                targetCurNodes.push(child);
+              }
+              continue;
+            }
           }
           if (matcher === true || matcher.test(part)) {
             params[name] = part;
@@ -158,7 +171,7 @@ class Node {
           }
         }
       }
-      curNodes = tempNodes;
+      curNodes = tempNodes.concat(curNodesQueue.shift() ?? []);
     }
     if (handlerSets.length > 1) {
       handlerSets.sort((a, b) => {

package/dist/cjs/utils/accept.js

@@ -0,0 +1,86 @@
+"use strict";
+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 accept_exports = {};
+__export(accept_exports, {
+  parseAccept: () => parseAccept
+});
+module.exports = __toCommonJS(accept_exports);
+const parseAccept = (acceptHeader) => {
+  if (!acceptHeader) {
+    return [];
+  }
+  const acceptValues = acceptHeader.split(",").map((value, index) => ({ value, index }));
+  return acceptValues.map(parseAcceptValue).filter((item) => Boolean(item)).sort(sortByQualityAndIndex).map(({ type, params, q }) => ({ type, params, q }));
+};
+const parseAcceptValueRegex = /;(?=(?:(?:[^"]*"){2})*[^"]*$)/;
+const parseAcceptValue = ({ value, index }) => {
+  const parts = value.trim().split(parseAcceptValueRegex).map((s) => s.trim());
+  const type = parts[0];
+  if (!type) {
+    return null;
+  }
+  const params = parseParams(parts.slice(1));
+  const q = parseQuality(params.q);
+  return { type, params, q, index };
+};
+const parseParams = (paramParts) => {
+  return paramParts.reduce((acc, param) => {
+    const [key, val] = param.split("=").map((s) => s.trim());
+    if (key && val) {
+      acc[key] = val;
+    }
+    return acc;
+  }, {});
+};
+const parseQuality = (qVal) => {
+  if (qVal === void 0) {
+    return 1;
+  }
+  if (qVal === "") {
+    return 1;
+  }
+  if (qVal === "NaN") {
+    return 0;
+  }
+  const num = Number(qVal);
+  if (num === Infinity) {
+    return 1;
+  }
+  if (num === -Infinity) {
+    return 0;
+  }
+  if (Number.isNaN(num)) {
+    return 1;
+  }
+  if (num < 0 || num > 1) {
+    return 1;
+  }
+  return num;
+};
+const sortByQualityAndIndex = (a, b) => {
+  const qDiff = b.q - a.q;
+  if (qDiff !== 0) {
+    return qDiff;
+  }
+  return a.index - b.index;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parseAccept
+});

package/dist/cjs/utils/jwt/index.js

@@ -22,7 +22,7 @@ __export(jwt_exports, {
 });
 module.exports = __toCommonJS(jwt_exports);
 var import_jwt = require("./jwt");
-const Jwt = { sign: import_jwt.sign, verify: import_jwt.verify, decode: import_jwt.decode };
+const Jwt = { sign: import_jwt.sign, verify: import_jwt.verify, decode: import_jwt.decode, verifyFromJwks: import_jwt.verifyFromJwks };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Jwt

package/dist/cjs/utils/jwt/jwt.js

@@ -19,9 +19,11 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var jwt_exports = {};
 __export(jwt_exports, {
   decode: () => decode,
+  decodeHeader: () => decodeHeader,
   isTokenHeader: () => isTokenHeader,
   sign: () => sign,
-  verify: () => verify
+  verify: () => verify,
+  verifyFromJwks: () => verifyFromJwks
 });
 module.exports = __toCommonJS(jwt_exports);
 var import_encode = require("../../utils/encode");
@@ -41,7 +43,13 @@ function isTokenHeader(obj) {
 }
 const sign = async (payload, privateKey, alg = "HS256") => {
   const encodedPayload = encodeJwtPart(payload);
-  const encodedHeader = encodeJwtPart({ alg, typ: "JWT" });
+  let encodedHeader;
+  if (typeof privateKey === "object" && "alg" in privateKey) {
+    alg = privateKey.alg;
+    encodedHeader = encodeJwtPart({ alg, typ: "JWT", kid: privateKey.kid });
+  } else {
+    encodedHeader = encodeJwtPart({ alg, typ: "JWT" });
+  }
   const partialToken = `${encodedHeader}.${encodedPayload}`;
   const signaturePart = await (0, import_jws.signing)(privateKey, alg, import_utf8.utf8Encoder.encode(partialToken));
   const signature = encodeSignaturePart(signaturePart);
@@ -78,6 +86,41 @@ const verify = async (token, publicKey, alg = "HS256") => {
   }
   return payload;
 };
+const verifyFromJwks = async (token, options, init) => {
+  const header = decodeHeader(token);
+  if (!isTokenHeader(header)) {
+    throw new import_types.JwtHeaderInvalid(header);
+  }
+  if (!header.kid) {
+    throw new import_types.JwtHeaderRequiresKid(header);
+  }
+  let keys = typeof options.keys === "function" ? await options.keys() : options.keys;
+  if (options.jwks_uri) {
+    const response = await fetch(options.jwks_uri, init);
+    if (!response.ok) {
+      throw new Error(`failed to fetch JWKS from ${options.jwks_uri}`);
+    }
+    const data = await response.json();
+    if (!data.keys) {
+      throw new Error('invalid JWKS response. "keys" field is missing');
+    }
+    if (!Array.isArray(data.keys)) {
+      throw new Error('invalid JWKS response. "keys" field is not an array');
+    }
+    if (keys) {
+      keys.push(...data.keys);
+    } else {
+      keys = data.keys;
+    }
+  } else if (!keys) {
+    throw new Error('verifyFromJwks requires options for either "keys" or "jwks_uri" or both');
+  }
+  const matchingKey = keys.find((key) => key.kid === header.kid);
+  if (!matchingKey) {
+    throw new import_types.JwtTokenInvalid(token);
+  }
+  return await verify(token, matchingKey, matchingKey.alg);
+};
 const decode = (token) => {
   try {
     const [h, p] = token.split(".");
@@ -91,10 +134,20 @@ const decode = (token) => {
     throw new import_types.JwtTokenInvalid(token);
   }
 };
+const decodeHeader = (token) => {
+  try {
+    const [h] = token.split(".");
+    return decodeJwtPart(h);
+  } catch {
+    throw new import_types.JwtTokenInvalid(token);
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   decode,
+  decodeHeader,
   isTokenHeader,
   sign,
-  verify
+  verify,
+  verifyFromJwks
 });

package/dist/cjs/utils/jwt/types.js

@@ -21,6 +21,7 @@ __export(types_exports, {
   CryptoKeyUsage: () => CryptoKeyUsage,
   JwtAlgorithmNotImplemented: () => JwtAlgorithmNotImplemented,
   JwtHeaderInvalid: () => JwtHeaderInvalid,
+  JwtHeaderRequiresKid: () => JwtHeaderRequiresKid,
   JwtTokenExpired: () => JwtTokenExpired,
   JwtTokenInvalid: () => JwtTokenInvalid,
   JwtTokenIssuedAt: () => JwtTokenIssuedAt,
@@ -64,6 +65,12 @@ class JwtHeaderInvalid extends Error {
     this.name = "JwtHeaderInvalid";
   }
 }
+class JwtHeaderRequiresKid extends Error {
+  constructor(header) {
+    super(`required "kid" in jwt header: ${JSON.stringify(header)}`);
+    this.name = "JwtHeaderRequiresKid";
+  }
+}
 class JwtTokenSignatureMismatched extends Error {
   constructor(token) {
     super(`token(${token}) signature mismatched`);
@@ -86,6 +93,7 @@ var CryptoKeyUsage = /* @__PURE__ */ ((CryptoKeyUsage2) => {
   CryptoKeyUsage,
   JwtAlgorithmNotImplemented,
   JwtHeaderInvalid,
+  JwtHeaderRequiresKid,
   JwtTokenExpired,
   JwtTokenInvalid,
   JwtTokenIssuedAt,

package/dist/cjs/utils/url.js

@@ -66,20 +66,21 @@ const replaceGroupMarks = (paths, groups) => {
   return paths;
 };
 const patternCache = {};
-const getPattern = (label) => {
+const getPattern = (label, next) => {
   if (label === "*") {
     return "*";
   }
   const match = label.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
   if (match) {
-    if (!patternCache[label]) {
+    const cacheKey = `${label}#${next}`;
+    if (!patternCache[cacheKey]) {
       if (match[2]) {
-        patternCache[label] = [label, match[1], new RegExp("^" + match[2] + "$")];
+        patternCache[cacheKey] = next && next[0] !== ":" && next[0] !== "*" ? [cacheKey, match[1], new RegExp(`^${match[2]}(?=/${next})`)] : [label, match[1], new RegExp(`^${match[2]}$`)];
       } else {
-        patternCache[label] = [label, match[1], true];
+        patternCache[cacheKey] = [label, match[1], true];
       }
     }
-    return patternCache[label];
+    return patternCache[cacheKey];
   }
   return null;
 };

package/dist/helper/accepts/accepts.js

@@ -1,25 +1,5 @@
 // src/helper/accepts/accepts.ts
-var parseAccept = (acceptHeader) => {
-  const accepts2 = acceptHeader.split(",");
-  return accepts2.map((accept) => {
-    const parts = accept.trim().split(";");
-    const type = parts[0];
-    const params = parts.slice(1);
-    const q = params.find((param) => param.startsWith("q="));
-    const paramsObject = params.reduce((acc, param) => {
-      const keyValue = param.split("=");
-      const key = keyValue[0].trim();
-      const value = keyValue[1].trim();
-      acc[key] = value;
-      return acc;
-    }, {});
-    return {
-      type,
-      params: paramsObject,
-      q: q ? parseFloat(q.split("=")[1]) : 1
-    };
-  });
-};
+import { parseAccept } from "../../utils/accept.js";
 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));
@@ -36,6 +16,5 @@ var accepts = (c, options) => {
 };
 export {
   accepts,
-  defaultMatch,
-  parseAccept
+  defaultMatch
 };

package/dist/helper/factory/index.js

@@ -2,11 +2,15 @@
 import { Hono } from "../../hono.js";
 var Factory = class {
   initApp;
+  #defaultAppOptions;
   constructor(init) {
     this.initApp = init?.initApp;
+    this.#defaultAppOptions = init?.defaultAppOptions;
   }
-  createApp = () => {
-    const app = new Hono();
+  createApp = (options) => {
+    const app = new Hono(
+      options && this.#defaultAppOptions ? { ...this.#defaultAppOptions, ...options } : options ?? this.#defaultAppOptions
+    );
     if (this.initApp) {
       this.initApp(app);
     }

package/dist/helper/proxy/index.js

@@ -0,0 +1,52 @@
+// src/helper/proxy/index.ts
+var hopByHopHeaders = [
+  "connection",
+  "keep-alive",
+  "proxy-authenticate",
+  "proxy-authorization",
+  "te",
+  "trailers",
+  "transfer-encoding"
+];
+var buildRequestInitFromRequest = (request) => {
+  if (!request) {
+    return {};
+  }
+  const headers = new Headers(request.headers);
+  hopByHopHeaders.forEach((header) => {
+    headers.delete(header);
+  });
+  return {
+    method: request.method,
+    body: request.body,
+    duplex: request.body ? "half" : void 0,
+    headers
+  };
+};
+var proxy = async (input, proxyInit) => {
+  const { raw, ...requestInit } = proxyInit ?? {};
+  const req = new Request(
+    input,
+    {
+      ...buildRequestInitFromRequest(raw),
+      ...requestInit
+    }
+  );
+  req.headers.delete("accept-encoding");
+  const res = await fetch(req);
+  const resHeaders = new Headers(res.headers);
+  hopByHopHeaders.forEach((header) => {
+    resHeaders.delete(header);
+  });
+  if (resHeaders.has("content-encoding")) {
+    resHeaders.delete("content-encoding");
+    resHeaders.delete("content-length");
+  }
+  return new Response(res.body, {
+    ...res,
+    headers: resHeaders
+  });
+};
+export {
+  proxy
+};