@nocobase/plugin-mcp-server 2.4.0-alpha.1 → 2.4.0-alpha.11

package/dist/node_modules/hono/dist/middleware/bearer-auth/index.js

@@ -1,92 +1,96 @@
-// src/middleware/bearer-auth/index.ts
 import { HTTPException } from "../../http-exception.js";
 import { timingSafeEqual } from "../../utils/buffer.js";
-var TOKEN_STRINGS = "[A-Za-z0-9._~+/-]+=*";
-var PREFIX = "Bearer";
-var HEADER = "Authorization";
-var bearerAuth = (options) => {
-  if (!("token" in options || "verifyToken" in options)) {
-    throw new Error('bearer auth middleware requires options for "token"');
-  }
-  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 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 timingSafeEqual(options.token, tokenValue, options.hashFunction);
-        } else if (Array.isArray(options.token) && options.token.length > 0) {
-          for (const token of options.token) {
-            if (await 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();
-  };
-};
-export {
-  bearerAuth
+//#region src/middleware/bearer-auth/index.ts
+const TOKEN_STRINGS = "[A-Za-z0-9._~+/-]+=*";
+const PREFIX = "Bearer";
+const HEADER = "Authorization";
+/**
+* Bearer Auth Middleware for Hono.
+*
+* @see {@link https://hono.dev/docs/middleware/builtin/bearer-auth}
+*
+* @template E - The environment type.
+* @param {BearerAuthOptions} options - The options for the bearer authentication middleware.
+* @param {string | string[]} [options.token] - The string or array of strings to validate the incoming bearer token against.
+* @param {Function} [options.verifyToken] - The function to verify the token.
+* @param {string} [options.realm=""] - The domain name of the realm, as part of the returned WWW-Authenticate challenge header.
+* @param {string} [options.prefix="Bearer"] - The prefix (or known as `schema`) for the Authorization header value. If set to the empty string, no prefix is expected.
+* @param {string} [options.headerName=Authorization] - The header name.
+* @param {Function} [options.hashFunction] - A function to handle hashing for safe comparison of authentication tokens.
+* @param {string | object | MessageFunction} [options.noAuthenticationHeader.message="Unauthorized"] - The no authentication header message.
+* @param {string | object | MessageFunction} [options.noAuthenticationHeader.wwwAuthenticateHeader="Bearer realm=\"\""] - The response header value for the WWW-Authenticate header when no authentication header is provided.
+* @param {string | object | MessageFunction} [options.invalidAuthenticationHeader.message="Bad Request"] - The invalid authentication header message.
+* @param {string | object | MessageFunction} [options.invalidAuthenticationHeader.wwwAuthenticateHeader="Bearer error=\"invalid_request\""] - The response header value for the WWW-Authenticate header when authentication header is invalid.
+* @param {string | object | MessageFunction} [options.invalidToken.message="Unauthorized"] - The invalid token message.
+* @param {string | object | MessageFunction} [options.invalidToken.wwwAuthenticateHeader="Bearer error=\"invalid_token\""] - The response header value for the WWW-Authenticate header when token is invalid.
+* @returns {MiddlewareHandler<E>} The middleware handler function.
+* @throws {Error} If neither "token" nor "verifyToken" options are provided.
+* @throws {HTTPException} If authentication fails, with 401 status code for missing or invalid token, or 400 status code for invalid request.
+*
+* @example
+* ```ts
+* const app = new Hono()
+*
+* const token = 'honoishot'
+*
+* app.use('/api/*', bearerAuth({ token }))
+*
+* app.get('/api/page', (c) => {
+*   return c.json({ message: 'You are authorized' })
+* })
+* ```
+*/
+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 HTTPException(status, { res });
+	};
+	return async function bearerAuth(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 timingSafeEqual(options.token, tokenValue, options.hashFunction);
+				else if (Array.isArray(options.token) && options.token.length > 0) {
+					for (const token of options.token) if (await 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();
+	};
 };
+//#endregion
+export { bearerAuth };

package/dist/node_modules/hono/dist/middleware/body-limit/index.js

@@ -1,62 +1,68 @@
-// src/middleware/body-limit/index.ts
 import { HTTPException } from "../../http-exception.js";
-var ERROR_MESSAGE = "Payload Too Large";
-var BodyLimitError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "BodyLimitError";
-  }
-};
-var bodyLimit = (options) => {
-  const onError = options.onError || (() => {
-    const res = new Response(ERROR_MESSAGE, {
-      status: 413
-    });
-    throw new 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 (hasTransferEncoding && hasContentLength) {
-    }
-    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 rawReader = c.req.raw.body.getReader();
-    const reader = new ReadableStream({
-      async start(controller) {
-        try {
-          for (; ; ) {
-            const { done, value } = await rawReader.read();
-            if (done) {
-              break;
-            }
-            size += value.length;
-            if (size > maxSize) {
-              controller.error(new BodyLimitError(ERROR_MESSAGE));
-              break;
-            }
-            controller.enqueue(value);
-          }
-        } finally {
-          controller.close();
-        }
-      }
-    });
-    const requestInit = { body: reader, duplex: "half" };
-    c.req.raw = new Request(c.req.raw, requestInit);
-    await next();
-    if (c.error instanceof BodyLimitError) {
-      c.res = await onError(c);
-    }
-  };
-};
-export {
-  bodyLimit
+//#region src/middleware/body-limit/index.ts
+const ERROR_MESSAGE = "Payload Too Large";
+/**
+* Body Limit Middleware for Hono.
+*
+* @see {@link https://hono.dev/docs/middleware/builtin/body-limit}
+*
+* @param {BodyLimitOptions} options - The options for the body limit middleware.
+* @param {number} options.maxSize - The maximum body size allowed.
+* @param {OnError} [options.onError] - The error handler to be invoked if the specified body size is exceeded.
+* @returns {MiddlewareHandler} The middleware handler function.
+*
+* @example
+* ```ts
+* const app = new Hono()
+*
+* app.post(
+*   '/upload',
+*   bodyLimit({
+*     maxSize: 50 * 1024, // 50kb
+*     onError: (c) => {
+*       return c.text('overflow :(', 413)
+*     },
+*   }),
+*   async (c) => {
+*     const body = await c.req.parseBody()
+*     if (body['file'] instanceof File) {
+*       console.log(`Got file sized: ${body['file'].size}`)
+*     }
+*     return c.text('pass :)')
+*   }
+* )
+* ```
+*/
+const bodyLimit = (options) => {
+	const onError = options.onError || (() => {
+		const res = new Response(ERROR_MESSAGE, { status: 413 });
+		throw new HTTPException(413, { res });
+	});
+	const maxSize = options.maxSize;
+	return async function bodyLimit(c, next) {
+		if (!c.req.raw.body) return next();
+		const hasTransferEncoding = c.req.raw.headers.has("transfer-encoding");
+		if (c.req.raw.headers.has("content-length") && !hasTransferEncoding) return parseInt(c.req.raw.headers.get("content-length") || "0", 10) > 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();
+	};
 };
+//#endregion
+export { bodyLimit };

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

@@ -1,89 +1,172 @@
-// src/middleware/cache/index.ts
-var defaultCacheableStatusCodes = [200];
-var shouldSkipCache = (res) => {
-  const vary = res.headers.get("Vary");
-  if (vary && vary.includes("*")) {
-    return true;
-  }
-  const cacheControl = res.headers.get("Cache-Control");
-  if (cacheControl && /(?:^|,\s*)(?:private|no-(?:store|cache))(?:\s*(?:=|,|$))/i.test(cacheControl)) {
-    return true;
-  }
-  if (res.headers.has("Set-Cookie")) {
-    return true;
-  }
-  return false;
+import { sha256 } from "../../utils/crypto.js";
+import { cloneRawRequest } from "../../request.js";
+//#region src/middleware/cache/index.ts
+/**
+* status codes that can be cached by default.
+*/
+const defaultCacheableStatusCodes = [200];
+const defaultMaxQueryBodySize = 65536;
+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);
 };
-var cache = (options) => {
-  if (!globalThis.caches) {
-    console.log("Cache Middleware is not enabled because caches is not defined.");
-    return async (_c, next) => await next();
-  }
-  if (options.wait === void 0) {
-    options.wait = false;
-  }
-  const cacheControlDirectives = options.cacheControl?.split(",").map((directive) => directive.toLowerCase());
-  const varyDirectives = Array.isArray(options.vary) ? options.vary : options.vary?.split(",").map((directive) => directive.trim());
-  if (options.vary?.includes("*")) {
-    throw new Error(
-      'Middleware vary configuration cannot include "*", as it disallows effective caching.'
-    );
-  }
-  const cacheableStatusCodes = new Set(
-    options.cacheableStatusCodes ?? defaultCacheableStatusCodes
-  );
-  const addHeader = (c) => {
-    if (cacheControlDirectives) {
-      const existingDirectives = c.res.headers.get("Cache-Control")?.split(",").map((d) => d.trim().split("=", 1)[0]) ?? [];
-      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) {
-      const existingDirectives = c.res.headers.get("Vary")?.split(",").map((d) => d.trim()) ?? [];
-      const vary = Array.from(
-        new Set(
-          [...existingDirectives, ...varyDirectives].map((directive) => directive.toLowerCase())
-        )
-      ).sort();
-      if (vary.includes("*")) {
-        c.header("Vary", "*");
-      } else {
-        c.header("Vary", vary.join(", "));
-      }
-    }
-  };
-  return async function cache2(c, next) {
-    let key = c.req.url;
-    if (options.keyGenerator) {
-      key = await options.keyGenerator(c);
-    }
-    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;
-    }
-    addHeader(c);
-    if (shouldSkipCache(c.res)) {
-      return;
-    }
-    const res = c.res.clone();
-    if (options.wait) {
-      await cache3.put(key, res);
-    } else {
-      c.executionCtx.waitUntil(cache3.put(key, res));
-    }
-  };
+const createCacheKey = (key, requestUrl, request, varyHeaders) => {
+	const url = new URL(cacheKeyPath, requestUrl);
+	url.searchParams.append(cacheKeyParameter, key);
+	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;
 };
-export {
-  cache
+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;
+	if (c.req.raw.bodyUsed && Object.keys(c.req.bodyCache)[0] === "formData") return;
+	try {
+		const requestHeaders = c.req.raw.headers;
+		const metadata = new TextEncoder().encode(JSON.stringify(queryRepresentationMetadataHeaders.map((header) => [header, requestHeaders.get(header)])));
+		const body = (await 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) {
+					reader.cancel().catch(() => {});
+					return;
+				}
+				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 sha256(data) ?? void 0;
+	} catch {
+		return;
+	}
+};
+/**
+* Cache Middleware for Hono.
+*
+* @see {@link https://hono.dev/docs/middleware/builtin/cache}
+*
+* @param {Object} options - The options for the cache middleware.
+* @param {string | Function} options.cacheName - The name of the cache. Can be used to store multiple caches with different identifiers.
+* @param {boolean} [options.wait=false] - A boolean indicating if Hono should wait for the Promise of the `cache.put` function to resolve before continuing with the request. Required to be true for the Deno environment.
+* @param {string} [options.cacheControl] - A string of directives for the `Cache-Control` header.
+* @param {string | string[]} [options.vary] - Adds the configured request headers to the cache key variants and sets the `Vary` header in the response. If the original response header already contains a `Vary` header, the values are merged, removing any duplicates.
+* @param {Function} [options.keyGenerator] - Generates keys for every request in the `cacheName` store. This can be used to cache data based on request parameters or context parameters. QUERY keys additionally include a digest of the request content and its representation metadata.
+* @param {number} [options.maxQueryBodySize=65536] - The maximum QUERY request body size in bytes that can be cached. Larger QUERY requests bypass the cache.
+* @param {number[]} [options.cacheableStatusCodes=[200]] - An array of status codes that can be cached.
+* @param {Function | false} [options.onCacheNotAvailable] - A callback invoked with the reason when `globalThis.caches` is not available or QUERY caching cannot use Web Crypto. By default, the reason is logged to the console. Set to `false` to suppress the log, or provide a custom function.
+* @returns {MiddlewareHandler} The middleware handler function.
+* @throws {Error} If the `vary` option includes "*".
+*
+* @example
+* ```ts
+* app.use(
+*   '*',
+*   cache({
+*     cacheName: 'my-app',
+*     cacheControl: 'max-age=3600',
+*   })
+* )
+* ```
+*/
+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 cache(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 cache = await caches.open(cacheName);
+		const response = await cache.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 cache.put(key, res);
+		else c.executionCtx.waitUntil(cache.put(key, res));
+	};
+};
+//#endregion
+export { cache };