acrylblends 1.0.3 → 1.0.5

package/lib/bearer-auth.js

@@ -1,94 +1,2 @@
-import { HTTPException } from "./http-exception.js";
-import { timingSafeEqual } from "./utils/buffer.js";
-//#region ../../plugins/acryl-router/src/core/middleware/bearer-auth/index.ts
-const TOKEN_STRINGS = "[A-Za-z0-9._~+/-]+=*";
-const PREFIX = "Bearer";
-const HEADER = "Authorization";
-/**
-* Bearer Auth Middleware for Acryl.
-*
-*
-* @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 Acryl()
-*
-* const token = process.env.API_TOKEN // never a literal in source
-*
-* 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;
-		throw new HTTPException(status, { res: typeof responseMessage === "string" ? new Response(responseMessage, {
-			status,
-			headers
-		}) : new Response(JSON.stringify(responseMessage), {
-			status,
-			headers: {
-				...headers,
-				"content-type": "application/json"
-			}
-		}) });
-	};
-	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
+import { t as bearerAuth } from "./bearer-auth-Cwxt-vgS.js";
 export { bearerAuth };

package/lib/body-D7f4e7w_.js

@@ -0,0 +1,94 @@
+import { t as bufferToFormData } from "./buffer-CkEOJCcY.js";
+//#region ../../plugins/acryl-router/src/core/utils/body.ts
+const MAX_NESTED_OBJECTS = 1e4;
+const isRawRequest = (request) => "headers" in request;
+const parseBody = async (request, options = Object.create(null)) => {
+	const { all = false, dot = false } = options;
+	const mediaType = (isRawRequest(request) ? request.headers : request.raw.headers).get("Content-Type")?.split(";")[0].trim().toLowerCase();
+	if (mediaType === "multipart/form-data" || mediaType === "application/x-www-form-urlencoded") return parseFormData(request, {
+		all,
+		dot
+	});
+	return {};
+};
+/**
+* Parses form data from a request.
+*
+* @template T - The type of the parsed body data.
+* @param {AcrylRequest | Request} request - The request object containing form data.
+* @param {ParseBodyOptions} options - Options for parsing the form data.
+* @returns {Promise<T>} The parsed body data.
+*/
+async function parseFormData(request, options) {
+	if (!isRawRequest(request) && request.bodyCache.formData) return convertFormDataToBodyData(await request.bodyCache.formData, options);
+	const headers = isRawRequest(request) ? request.headers : request.raw.headers;
+	const formDataPromise = bufferToFormData(await request.arrayBuffer(), headers.get("Content-Type") || "");
+	if (!isRawRequest(request)) request.bodyCache.formData = formDataPromise;
+	const formData = await formDataPromise;
+	if (formData) return convertFormDataToBodyData(formData, options);
+	return {};
+}
+/**
+* Converts form data to body data based on the provided options.
+*
+* @template T - The type of the parsed body data.
+* @param {FormData} formData - The form data to convert.
+* @param {ParseBodyOptions} options - Options for parsing the form data.
+* @returns {T} The converted body data.
+*/
+function convertFormDataToBodyData(formData, options) {
+	const form = Object.create(null);
+	const nestingState = { count: 0 };
+	formData.forEach((value, key) => {
+		if (!(options.all || key.endsWith("[]"))) form[key] = value;
+		else handleParsingAllValues(form, key, value);
+	});
+	if (options.dot) Object.entries(form).forEach(([key, value]) => {
+		if (key.includes(".")) {
+			handleParsingNestedValues(form, key, value, nestingState);
+			delete form[key];
+		}
+	});
+	return form;
+}
+/**
+* Handles parsing all values for a given key, supporting multiple values as arrays.
+*
+* @param {BodyData} form - The form data object.
+* @param {string} key - The key to parse.
+* @param {FormDataEntryValue} value - The value to assign.
+*/
+const handleParsingAllValues = (form, key, value) => {
+	if (form[key] !== void 0) if (Array.isArray(form[key])) form[key].push(value);
+	else form[key] = [form[key], value];
+	else if (!key.endsWith("[]")) form[key] = value;
+	else form[key] = [value];
+};
+/**
+* Handles parsing nested values using dot notation keys.
+*
+* @param {BodyData} form - The form data object.
+* @param {string} key - The dot notation key.
+* @param {BodyDataValue} value - The value to assign.
+*/
+const handleParsingNestedValues = (form, key, value, state) => {
+	if (/(?:^|\.)__proto__\./.test(key)) return;
+	let nestedForm = form;
+	const keys = key.split(".", 34);
+	if (keys.length > 33) throwNestingLimitExceeded();
+	keys.forEach((key, index) => {
+		if (index === keys.length - 1) nestedForm[key] = value;
+		else {
+			if (!nestedForm[key] || typeof nestedForm[key] !== "object" || Array.isArray(nestedForm[key]) || nestedForm[key] instanceof File) {
+				if (state.count++ >= MAX_NESTED_OBJECTS) throwNestingLimitExceeded();
+				nestedForm[key] = Object.create(null);
+			}
+			nestedForm = nestedForm[key];
+		}
+	});
+};
+const throwNestingLimitExceeded = () => {
+	throw new Error("Nesting limit exceeded");
+};
+//#endregion
+export { parseBody as t };

package/lib/body-limit-WmIjWRLt.js

@@ -0,0 +1,66 @@
+import { t as HTTPException } from "./http-exception-MjWkT89V.js";
+//#region ../../plugins/acryl-router/src/core/middleware/body-limit/index.ts
+const ERROR_MESSAGE = "Payload Too Large";
+/**
+* Body Limit Middleware for Acryl.
+*
+*
+* @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 Acryl()
+*
+* 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 || (() => {
+		throw new HTTPException(413, { res: new Response(ERROR_MESSAGE, { status: 413 }) });
+	});
+	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 as t };

package/lib/body-limit.js

@@ -1,66 +1,2 @@
-import { HTTPException } from "./http-exception.js";
-//#region ../../plugins/acryl-router/src/core/middleware/body-limit/index.ts
-const ERROR_MESSAGE = "Payload Too Large";
-/**
-* Body Limit Middleware for Acryl.
-*
-*
-* @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 Acryl()
-*
-* 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 || (() => {
-		throw new HTTPException(413, { res: new Response(ERROR_MESSAGE, { status: 413 }) });
-	});
-	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
+import { t as bodyLimit } from "./body-limit-WmIjWRLt.js";
 export { bodyLimit };

package/lib/buffer-CkEOJCcY.js

@@ -0,0 +1,51 @@
+import { i as sha256 } from "./crypto-iVP-N-tS.js";
+//#region ../../plugins/acryl-router/src/core/utils/buffer.ts
+/**
+* @module
+* Buffer utility.
+*/
+const equal = (a, b) => {
+	if (a === b) return true;
+	if (a.byteLength !== b.byteLength) return false;
+	const va = new DataView(a);
+	const vb = new DataView(b);
+	let i = va.byteLength;
+	while (i--) if (va.getUint8(i) !== vb.getUint8(i)) return false;
+	return true;
+};
+const constantTimeEqualString = (a, b) => {
+	const aLen = a.length;
+	const bLen = b.length;
+	const maxLen = Math.max(aLen, bLen);
+	let out = aLen ^ bLen;
+	for (let i = 0; i < maxLen; i++) {
+		const aChar = i < aLen ? a.charCodeAt(i) : 0;
+		const bChar = i < bLen ? b.charCodeAt(i) : 0;
+		out |= aChar ^ bChar;
+	}
+	return out === 0;
+};
+const timingSafeEqualString = async (a, b, hashFunction) => {
+	if (!hashFunction) hashFunction = sha256;
+	const [sa, sb] = await Promise.all([hashFunction(a), hashFunction(b)]);
+	if (sa == null || sb == null || typeof sa !== "string" || typeof sb !== "string") return false;
+	const hashEqual = constantTimeEqualString(sa, sb);
+	const originalEqual = constantTimeEqualString(a, b);
+	return hashEqual && originalEqual;
+};
+const timingSafeEqual = async (a, b, hashFunction) => {
+	if (typeof a === "string" && typeof b === "string") return timingSafeEqualString(a, b, hashFunction);
+	if (!hashFunction) hashFunction = sha256;
+	const [sa, sb] = await Promise.all([hashFunction(a), hashFunction(b)]);
+	if (!sa || !sb || typeof sa !== "string" || typeof sb !== "string") return false;
+	return timingSafeEqualString(sa, sb);
+};
+const bufferToString = (buffer) => {
+	if (buffer instanceof ArrayBuffer) return new TextDecoder("utf-8").decode(buffer);
+	return buffer;
+};
+const bufferToFormData = (arrayBuffer, contentType) => {
+	return new Response(arrayBuffer, { headers: { "Content-Type": contentType.replace(/^[^;]+/, (mediaType) => mediaType.toLowerCase()) } }).formData();
+};
+//#endregion
+export { timingSafeEqual as i, bufferToString as n, equal as r, bufferToFormData as t };

package/lib/bun.js

@@ -1,6 +1,6 @@
-import { t as serveStatic$1 } from "./serve-static-Cp5adzGo.js";
-import { c as toSSG$1 } from "./ssg-BwjcA-Ge.js";
-import { WSContext, createWSMessageEvent, defineWebSocketHelper } from "./ws.js";
+import { t as serveStatic$1 } from "./serve-static-EiJf1zkO.js";
+import { c as toSSG$1 } from "./ssg-BEl7MHqg.js";
+import { n as createWSMessageEvent, r as defineWebSocketHelper, t as WSContext } from "./websocket-DsyBIKVA.js";
 import { stat } from "node:fs/promises";
 import { join } from "node:path";
 //#region ../../plugins/acryl-router/src/core/adapter/bun/serve-static.ts

package/lib/cache-B0bHH7s5.js

@@ -0,0 +1,169 @@
+import { i as sha256 } from "./crypto-iVP-N-tS.js";
+import { n as cloneRawRequest } from "./request-DvMgGtlW.js";
+//#region ../../plugins/acryl-router/src/core/middleware/cache/index.ts
+/**
+* status codes that can be cached by default.
+*/
+const defaultCacheableStatusCodes = [200];
+const defaultMaxQueryBodySize = 64 * 1024;
+const cacheKeyPath = "/.acryl-router/cache";
+const cacheKeyParameter = "__acryl_cache_key";
+const cacheMethodKeyParameter = "__acryl_cache_method";
+const queryDigestKeyParameter = "__acryl_query_digest";
+const cacheVaryKeyParameter = "__acryl_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);
+	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;
+	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 Acryl.
+*
+*
+* @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 Acryl 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 as t };