@piagent/platform 1.2.16 → 1.3.0-ie.8

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/cjs/jsx/utils.js

@@ -0,0 +1,200 @@
+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, {
+  isValidAttributeName: () => isValidAttributeName,
+  isValidTagName: () => isValidTagName,
+  normalizeIntrinsicElementKey: () => normalizeIntrinsicElementKey,
+  styleObjectForEach: () => styleObjectForEach
+});
+module.exports = __toCommonJS(utils_exports);
+const normalizeElementKeyMap = /* @__PURE__ */ new Map([
+  ["className", "class"],
+  ["htmlFor", "for"],
+  ["crossOrigin", "crossorigin"],
+  ["httpEquiv", "http-equiv"],
+  ["itemProp", "itemprop"],
+  ["fetchPriority", "fetchpriority"],
+  ["noModule", "nomodule"],
+  ["formAction", "formaction"]
+]);
+const normalizeIntrinsicElementKey = (key) => normalizeElementKeyMap.get(key) || key;
+const invalidAttributeNameCharRe = /[\s"'<>/=`\\\x00-\x1f\x7f-\x9f]/;
+const validAttributeNameCache = /* @__PURE__ */ new Set();
+const validAttributeNameCacheMax = 1024;
+const invalidTagNameCharRe = /^[!?]|[\s"'<>/=`\\\x00-\x1f\x7f-\x9f]/;
+const validTagNameCache = /* @__PURE__ */ new Set();
+const validTagNameCacheMax = 256;
+const cacheValidName = (cache, max, name) => {
+  if (cache.size >= max) {
+    cache.clear();
+  }
+  cache.add(name);
+};
+const isValidTagName = (name) => {
+  if (validTagNameCache.has(name)) {
+    return true;
+  }
+  if (typeof name !== "string") {
+    return false;
+  }
+  if (name.length === 0) {
+    return true;
+  }
+  if (invalidTagNameCharRe.test(name)) {
+    return false;
+  }
+  cacheValidName(validTagNameCache, validTagNameCacheMax, name);
+  return true;
+};
+const isValidAttributeName = (name) => {
+  if (validAttributeNameCache.has(name)) {
+    return true;
+  }
+  const len = name.length;
+  if (len === 0) {
+    return false;
+  }
+  for (let i = 0; i < len; i++) {
+    const c = name.charCodeAt(i);
+    if (!(c >= 97 && c <= 122 || // a-z
+    c >= 65 && c <= 90 || // A-Z
+    c >= 48 && c <= 57 || // 0-9
+    c === 45 || // -
+    c === 95 || // _
+    c === 46 || // .
+    c === 58)) {
+      if (!invalidAttributeNameCharRe.test(name)) {
+        cacheValidName(validAttributeNameCache, validAttributeNameCacheMax, name);
+        return true;
+      } else {
+        return false;
+      }
+    }
+  }
+  cacheValidName(validAttributeNameCache, validAttributeNameCacheMax, name);
+  return true;
+};
+const invalidStylePropertyNameCharRe = /[\s"'():;\\/\[\]{}\x00-\x1f\x7f-\x9f]/;
+const validStylePropertyNameCache = /* @__PURE__ */ new Set();
+const validStylePropertyNameCacheMax = 1024;
+const isValidStylePropertyName = (name) => {
+  if (validStylePropertyNameCache.has(name)) {
+    return true;
+  }
+  const len = name.length;
+  if (len === 0) {
+    return false;
+  }
+  for (let i = 0; i < len; i++) {
+    const c = name.charCodeAt(i);
+    if (!(c >= 97 && c <= 122 || // a-z
+    c >= 65 && c <= 90 || // A-Z
+    c >= 48 && c <= 57 || // 0-9
+    c === 45 || // -
+    c === 95)) {
+      if (!invalidStylePropertyNameCharRe.test(name)) {
+        cacheValidName(validStylePropertyNameCache, validStylePropertyNameCacheMax, name);
+        return true;
+      } else {
+        return false;
+      }
+    }
+  }
+  cacheValidName(validStylePropertyNameCache, validStylePropertyNameCacheMax, name);
+  return true;
+};
+const unsafeStyleValueCharRe = /[;"'\\/\[\](){}]/;
+const hasUnsafeStyleValue = (value) => {
+  if (!unsafeStyleValueCharRe.test(value)) {
+    return false;
+  }
+  let quote = 0;
+  const blockStack = [];
+  for (let i = 0, len = value.length; i < len; i++) {
+    const c = value.charCodeAt(i);
+    if (c === 92) {
+      if (i === len - 1) {
+        return true;
+      }
+      i++;
+    } else if (quote !== 0) {
+      if (c === 10 || c === 12 || c === 13) {
+        return true;
+      }
+      if (c === quote) {
+        quote = 0;
+      }
+    } else if (c === 47 && value.charCodeAt(i + 1) === 42) {
+      const end = value.indexOf("*/", i + 2);
+      if (end === -1) {
+        return true;
+      }
+      i = end + 1;
+    } else if (c === 34 || c === 39) {
+      quote = c;
+    } else if (c === 40) {
+      blockStack.push(41);
+    } else if (c === 91) {
+      blockStack.push(93);
+    } else if (c === 123 || c === 125) {
+      return true;
+    } else if (c === 41 || c === 93) {
+      if (blockStack[blockStack.length - 1] !== c) {
+        return true;
+      }
+      blockStack.pop();
+    } else if (c === 59 && blockStack.length === 0) {
+      return true;
+    }
+  }
+  return quote !== 0 || blockStack.length !== 0;
+};
+const styleObjectForEach = (style, fn) => {
+  for (const [k, v] of Object.entries(style)) {
+    const key = k[0] === "-" || !/[A-Z]/.test(k) ? k : k.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
+    if (!isValidStylePropertyName(key)) {
+      continue;
+    }
+    if (v == null) {
+      fn(key, null);
+      continue;
+    }
+    let value;
+    if (typeof v === "number") {
+      value = !key.match(
+        /^(?:a|border-im|column(?:-c|s)|flex(?:$|-[^b])|grid-(?:ar|[^a])|font-w|li|or|sca|st|ta|wido|z)|ty$/
+      ) ? `${v}px` : `${v}`;
+    } else if (typeof v === "string") {
+      if (hasUnsafeStyleValue(v)) {
+        continue;
+      }
+      value = v;
+    } else {
+      continue;
+    }
+    fn(key, value);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isValidAttributeName,
+  isValidTagName,
+  normalizeIntrinsicElementKey,
+  styleObjectForEach
+});

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/cjs/middleware/basic-auth/index.js

@@ -0,0 +1,88 @@
+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 basic_auth_exports = {};
+__export(basic_auth_exports, {
+  basicAuth: () => basicAuth
+});
+module.exports = __toCommonJS(basic_auth_exports);
+var import_http_exception = require("../../http-exception");
+var import_basic_auth = require("../../utils/basic-auth");
+var import_buffer = require("../../utils/buffer");
+const basicAuth = (options, ...users) => {
+  const usernamePasswordInOptions = "username" in options && "password" in options;
+  const verifyUserInOptions = "verifyUser" in options;
+  if (!(usernamePasswordInOptions || verifyUserInOptions)) {
+    throw new Error(
+      'basic auth middleware requires options for "username and password" or "verifyUser"'
+    );
+  }
+  if (!options.realm) {
+    options.realm = "Secure Area";
+  }
+  if (!options.invalidUserMessage) {
+    options.invalidUserMessage = "Unauthorized";
+  }
+  if (usernamePasswordInOptions) {
+    users.unshift({ username: options.username, password: options.password });
+  }
+  return async function basicAuth2(ctx, next) {
+    const requestUser = (0, import_basic_auth.auth)(ctx.req.raw);
+    if (requestUser) {
+      if (verifyUserInOptions) {
+        if (await options.verifyUser(requestUser.username, requestUser.password, ctx)) {
+          if (options.onAuthSuccess) {
+            await options.onAuthSuccess(ctx, requestUser.username);
+          }
+          await next();
+          return;
+        }
+      } else {
+        for (const user of users) {
+          const [usernameEqual, passwordEqual] = await Promise.all([
+            (0, import_buffer.timingSafeEqual)(user.username, requestUser.username, options.hashFunction),
+            (0, import_buffer.timingSafeEqual)(user.password, requestUser.password, options.hashFunction)
+          ]);
+          if (usernameEqual && passwordEqual) {
+            if (options.onAuthSuccess) {
+              await options.onAuthSuccess(ctx, requestUser.username);
+            }
+            await next();
+            return;
+          }
+        }
+      }
+    }
+    const status = 401;
+    const headers = {
+      "WWW-Authenticate": 'Basic realm="' + options.realm?.replace(/"/g, '\\"') + '"'
+    };
+    const responseMessage = typeof options.invalidUserMessage === "function" ? await options.invalidUserMessage(ctx) : options.invalidUserMessage;
+    const res = typeof responseMessage === "string" ? new Response(responseMessage, { status, headers }) : new Response(JSON.stringify(responseMessage), {
+      status,
+      headers: {
+        ...headers,
+        "content-type": "application/json"
+      }
+    });
+    throw new import_http_exception.HTTPException(status, { res });
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  basicAuth
+});

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/cjs/middleware/bearer-auth/index.js

@@ -0,0 +1,114 @@
+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 bearer_auth_exports = {};
+__export(bearer_auth_exports, {
+  bearerAuth: () => bearerAuth
+});
+module.exports = __toCommonJS(bearer_auth_exports);
+var import_http_exception = require("../../http-exception");
+var import_buffer = require("../../utils/buffer");
+const TOKEN_STRINGS = "[A-Za-z0-9._~+/-]+=*";
+const PREFIX = "Bearer";
+const HEADER = "Authorization";
+const bearerAuth = (options) => {
+  if (!("token" in options || "verifyToken" in options)) {
+    throw new Error('bearer auth middleware requires options for "token" or "verifyToken"');
+  }
+  if (!options.realm) {
+    options.realm = "";
+  }
+  if (options.prefix === void 0) {
+    options.prefix = PREFIX;
+  }
+  const realm = options.realm?.replace(/"/g, '\\"');
+  const prefix = options.prefix;
+  const tokenRegexp = new RegExp(`^${TOKEN_STRINGS}$`);
+  const wwwAuthenticatePrefix = prefix === "" ? "" : `${prefix} `;
+  const throwHTTPException = async (c, status, wwwAuthenticateHeader, messageOption) => {
+    const wwwAuthenticateHeaderValue = typeof wwwAuthenticateHeader === "function" ? await wwwAuthenticateHeader(c) : wwwAuthenticateHeader;
+    const headers = {
+      "WWW-Authenticate": typeof wwwAuthenticateHeaderValue === "string" ? wwwAuthenticateHeaderValue : `${wwwAuthenticatePrefix}${Object.entries(wwwAuthenticateHeaderValue).map(([key, value]) => `${key}="${value}"`).join(",")}`
+    };
+    const responseMessage = typeof messageOption === "function" ? await messageOption(c) : messageOption;
+    const res = typeof responseMessage === "string" ? new Response(responseMessage, { status, headers }) : new Response(JSON.stringify(responseMessage), {
+      status,
+      headers: {
+        ...headers,
+        "content-type": "application/json"
+      }
+    });
+    throw new import_http_exception.HTTPException(status, { res });
+  };
+  return async function bearerAuth2(c, next) {
+    const headerToken = c.req.header(options.headerName || HEADER);
+    if (!headerToken) {
+      await throwHTTPException(
+        c,
+        401,
+        options.noAuthenticationHeader?.wwwAuthenticateHeader || `${wwwAuthenticatePrefix}realm="${realm}"`,
+        options.noAuthenticationHeader?.message || options.noAuthenticationHeaderMessage || "Unauthorized"
+      );
+    } else {
+      let tokenValue;
+      if (prefix === "") {
+        tokenValue = headerToken;
+      } else {
+        const headerLower = headerToken.toLowerCase();
+        const prefixLower = prefix.toLowerCase();
+        if (headerLower.startsWith(prefixLower) && headerToken[prefix.length] === " ") {
+          tokenValue = headerToken.slice(prefix.length).trimStart();
+        }
+      }
+      if (!tokenValue || !tokenRegexp.test(tokenValue)) {
+        await throwHTTPException(
+          c,
+          400,
+          options.invalidAuthenticationHeader?.wwwAuthenticateHeader || `${wwwAuthenticatePrefix}error="invalid_request"`,
+          options.invalidAuthenticationHeader?.message || options.invalidAuthenticationHeaderMessage || "Bad Request"
+        );
+      } else {
+        let equal = false;
+        if ("verifyToken" in options) {
+          equal = await options.verifyToken(tokenValue, c);
+        } else if (typeof options.token === "string") {
+          equal = await (0, import_buffer.timingSafeEqual)(options.token, tokenValue, options.hashFunction);
+        } else if (Array.isArray(options.token) && options.token.length > 0) {
+          for (const token of options.token) {
+            if (await (0, import_buffer.timingSafeEqual)(token, tokenValue, options.hashFunction)) {
+              equal = true;
+              break;
+            }
+          }
+        }
+        if (!equal) {
+          await throwHTTPException(
+            c,
+            401,
+            options.invalidToken?.wwwAuthenticateHeader || `${wwwAuthenticatePrefix}error="invalid_token"`,
+            options.invalidToken?.message || options.invalidTokenMessage || "Unauthorized"
+          );
+        }
+      }
+    }
+    await next();
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  bearerAuth
+});

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/cjs/middleware/body-limit/index.js

@@ -0,0 +1,75 @@
+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 body_limit_exports = {};
+__export(body_limit_exports, {
+  bodyLimit: () => bodyLimit
+});
+module.exports = __toCommonJS(body_limit_exports);
+var import_http_exception = require("../../http-exception");
+const ERROR_MESSAGE = "Payload Too Large";
+const bodyLimit = (options) => {
+  const onError = options.onError || (() => {
+    const res = new Response(ERROR_MESSAGE, {
+      status: 413
+    });
+    throw new import_http_exception.HTTPException(413, { res });
+  });
+  const maxSize = options.maxSize;
+  return async function bodyLimit2(c, next) {
+    if (!c.req.raw.body) {
+      return next();
+    }
+    const hasTransferEncoding = c.req.raw.headers.has("transfer-encoding");
+    const hasContentLength = c.req.raw.headers.has("content-length");
+    if (hasContentLength && !hasTransferEncoding) {
+      const contentLength = parseInt(c.req.raw.headers.get("content-length") || "0", 10);
+      return contentLength > maxSize ? onError(c) : next();
+    }
+    let size = 0;
+    const chunks = [];
+    const rawReader = c.req.raw.body.getReader();
+    for (; ; ) {
+      const { done, value } = await rawReader.read();
+      if (done) {
+        break;
+      }
+      size += value.length;
+      if (size > maxSize) {
+        return onError(c);
+      }
+      chunks.push(value);
+    }
+    const requestInit = {
+      body: new ReadableStream({
+        start(controller) {
+          for (const chunk of chunks) {
+            controller.enqueue(chunk);
+          }
+          controller.close();
+        }
+      }),
+      duplex: "half"
+    };
+    c.req.raw = new Request(c.req.raw, requestInit);
+    return next();
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  bodyLimit
+});

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/cjs/middleware/cache/index.js

@@ -0,0 +1,219 @@
+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 cache_exports = {};
+__export(cache_exports, {
+  cache: () => cache
+});
+module.exports = __toCommonJS(cache_exports);
+var import_request = require("../../request");
+var import_crypto = require("../../utils/crypto");
+const defaultCacheableStatusCodes = [200];
+const defaultMaxQueryBodySize = 64 * 1024;
+const cacheKeyPath = "/.hono/cache";
+const cacheKeyParameter = "__hono_cache_key";
+const cacheMethodKeyParameter = "__hono_cache_method";
+const queryDigestKeyParameter = "__hono_query_digest";
+const cacheVaryKeyParameter = "__hono_cache_vary";
+const queryRepresentationMetadataHeaders = [
+  "content-type",
+  "content-encoding",
+  "content-language",
+  "content-location"
+];
+const shouldSkipCacheControl = (cacheControl) => !!cacheControl && /(?:^|,\s*)(?:private|no-(?:store|cache))(?:\s*(?:=|,|$))/i.test(cacheControl);
+const parseVaryDirectives = (vary) => {
+  if (vary == null) {
+    return [];
+  }
+  return (Array.isArray(vary) ? vary : vary.split(",")).map((directive) => directive.trim().toLowerCase()).filter(Boolean);
+};
+const createCacheKey = (key, requestUrl, request, varyHeaders) => {
+  const url = new URL(cacheKeyPath, requestUrl);
+  url.searchParams.append(cacheKeyParameter, key.split("#", 1)[0]);
+  url.searchParams.append(cacheMethodKeyParameter, request.method);
+  if (request.method === "QUERY") {
+    url.searchParams.append(queryDigestKeyParameter, request.digest);
+  }
+  for (const header of varyHeaders) {
+    url.searchParams.append(cacheVaryKeyParameter, JSON.stringify(header));
+  }
+  return url.href;
+};
+const shouldSkipCache = (res, optionsVaryDirectives, responseVary) => responseVary.length && (!optionsVaryDirectives || responseVary.some((name) => !optionsVaryDirectives.has(name))) || shouldSkipCacheControl(res.headers.get("Cache-Control")) || res.headers.has("Set-Cookie");
+const reportCacheNotAvailable = (onCacheNotAvailable, reason) => {
+  if (onCacheNotAvailable === false) {
+  } else if (onCacheNotAvailable) {
+    onCacheNotAvailable(reason);
+  } else {
+    console.log(reason);
+  }
+};
+const createQueryDigest = async (c, maxQueryBodySize) => {
+  if (!globalThis.crypto?.subtle) {
+    return void 0;
+  }
+  if (c.req.raw.bodyUsed && Object.keys(c.req.bodyCache)[0] === "formData") {
+    return void 0;
+  }
+  try {
+    const requestHeaders = c.req.raw.headers;
+    const metadata = new TextEncoder().encode(
+      JSON.stringify(
+        queryRepresentationMetadataHeaders.map((header) => [header, requestHeaders.get(header)])
+      )
+    );
+    const body = (await (0, import_request.cloneRawRequest)(c.req)).body;
+    const chunks = [];
+    let bodySize = 0;
+    if (body) {
+      const reader = body.getReader();
+      for (; ; ) {
+        const { done, value } = await reader.read();
+        if (done) {
+          break;
+        }
+        bodySize += value.byteLength;
+        if (bodySize > maxQueryBodySize) {
+          void reader.cancel().catch(() => {
+          });
+          return void 0;
+        }
+        chunks.push(value);
+      }
+    }
+    const data = new Uint8Array(metadata.byteLength + bodySize);
+    data.set(metadata);
+    let offset = metadata.byteLength;
+    for (const chunk of chunks) {
+      data.set(chunk, offset);
+      offset += chunk.byteLength;
+    }
+    return await (0, import_crypto.sha256)(data) ?? void 0;
+  } catch {
+    return void 0;
+  }
+};
+const cache = (options) => {
+  if (!globalThis.caches) {
+    reportCacheNotAvailable(
+      options.onCacheNotAvailable,
+      "Cache Middleware is not enabled because caches is not defined."
+    );
+    return async (_c, next) => await next();
+  }
+  if (!globalThis.crypto?.subtle) {
+    reportCacheNotAvailable(
+      options.onCacheNotAvailable,
+      "Cache Middleware cannot cache QUERY requests because Web Crypto is not available."
+    );
+  }
+  if (options.wait === void 0) {
+    options.wait = false;
+  }
+  const cacheControlDirectives = options.cacheControl?.split(",").map((directive) => directive.toLowerCase());
+  const optionsVaryList = parseVaryDirectives(options.vary);
+  const varyDirectives = optionsVaryList.length ? new Set(optionsVaryList) : void 0;
+  if (varyDirectives?.has("*")) {
+    throw new Error(
+      'Middleware vary configuration cannot include "*", as it disallows effective caching.'
+    );
+  }
+  const cacheableStatusCodes = new Set(
+    options.cacheableStatusCodes ?? defaultCacheableStatusCodes
+  );
+  const maxQueryBodySize = options.maxQueryBodySize ?? defaultMaxQueryBodySize;
+  const addHeader = (c, responseVary) => {
+    if (cacheControlDirectives) {
+      const existingDirectives = c.res.headers.get("Cache-Control")?.split(",").map((d) => d.trim().split("=", 1)[0].toLowerCase()) ?? [];
+      for (const directive of cacheControlDirectives) {
+        let [name, value] = directive.trim().split("=", 2);
+        name = name.toLowerCase();
+        if (!existingDirectives.includes(name)) {
+          c.header("Cache-Control", `${name}${value ? `=${value}` : ""}`, { append: true });
+        }
+      }
+    }
+    if (varyDirectives) {
+      if (responseVary.length === 0) {
+        c.header("Vary", Array.from(varyDirectives).join(", "));
+      } else {
+        const merged = new Set(varyDirectives);
+        for (const directive of responseVary) {
+          merged.add(directive);
+        }
+        if (merged.has("*")) {
+          c.header("Vary", "*");
+        } else {
+          c.header("Vary", Array.from(merged).join(", "));
+        }
+      }
+    }
+  };
+  return async function cache2(c, next) {
+    if (c.req.method !== "GET" && c.req.method !== "QUERY" || c.req.raw.headers.has("Authorization")) {
+      await next();
+      return;
+    }
+    let cacheKeyRequest = { method: "GET" };
+    if (c.req.method === "QUERY") {
+      const digest = await createQueryDigest(c, maxQueryBodySize);
+      if (digest === void 0) {
+        await next();
+        return;
+      }
+      cacheKeyRequest = { method: "QUERY", digest };
+    }
+    let key = c.req.url;
+    if (options.keyGenerator) {
+      key = await options.keyGenerator(c);
+    }
+    const varyHeaders = [];
+    if (varyDirectives) {
+      for (const directive of varyDirectives) {
+        const value = c.req.raw.headers.get(directive) ?? "";
+        varyHeaders.push([directive, value]);
+      }
+    }
+    key = createCacheKey(key, c.req.url, cacheKeyRequest, varyHeaders);
+    const cacheName = typeof options.cacheName === "function" ? await options.cacheName(c) : options.cacheName;
+    const cache3 = await caches.open(cacheName);
+    const response = await cache3.match(key);
+    if (response) {
+      return new Response(response.body, response);
+    }
+    await next();
+    if (!cacheableStatusCodes.has(c.res.status)) {
+      return;
+    }
+    const responseVary = parseVaryDirectives(c.res.headers.get("Vary"));
+    addHeader(c, responseVary);
+    if (shouldSkipCache(c.res, varyDirectives, responseVary)) {
+      return;
+    }
+    const res = c.res.clone();
+    if (options.wait) {
+      await cache3.put(key, res);
+    } else {
+      c.executionCtx.waitUntil(cache3.put(key, res));
+    }
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cache
+});