@weavecode/weave 0.1.1 → 0.1.3

package/node_modules/@modelcontextprotocol/sdk/node_modules/hono/dist/middleware/combine/index.js

@@ -0,0 +1,138 @@
+import { compose } from "../../compose.js";
+import "../../router.js";
+import { TrieRouter } from "../../router/trie-router/router.js";
+import "../../router/trie-router/index.js";
+//#region src/middleware/combine/index.ts
+/**
+* @module
+* Combine Middleware for Hono.
+*/
+/**
+* Create a composed middleware that runs the first middleware that returns true.
+*
+* @param middleware - An array of MiddlewareHandler or Condition functions.
+* Middleware is applied in the order it is passed, and if any middleware exits without returning
+* an exception first, subsequent middleware will not be executed.
+* You can also pass a condition function that returns a boolean value. If returns true
+* the evaluation will be halted, and rest of the middleware will not be executed.
+* @returns A composed middleware.
+*
+* @example
+* ```ts
+* import { some } from 'hono/combine'
+* import { bearerAuth } from 'hono/bearer-auth'
+* import { myRateLimit } from '@/rate-limit'
+*
+* // If client has a valid token, then skip rate limiting.
+* // Otherwise, apply rate limiting.
+* app.use('/api/*', some(
+*   bearerAuth({ token }),
+*   myRateLimit({ limit: 100 }),
+* ));
+* ```
+*/
+const some = (...middleware) => {
+	return async function some(c, next) {
+		let isNextCalled = false;
+		const wrappedNext = () => {
+			isNextCalled = true;
+			return next();
+		};
+		let lastError;
+		let response;
+		for (const handler of middleware) try {
+			const result = await handler(c, wrappedNext);
+			if (result === true && !c.finalized) await wrappedNext();
+			else if (result === false) {
+				lastError = /* @__PURE__ */ new Error("No successful middleware found");
+				continue;
+			} else if (result && result !== true) response = result;
+			lastError = void 0;
+			break;
+		} catch (error) {
+			lastError = error;
+			if (isNextCalled) break;
+		}
+		if (lastError) throw lastError;
+		return response;
+	};
+};
+/**
+* Create a composed middleware that runs all middleware and throws an error if any of them fail.
+*
+* @param middleware - An array of MiddlewareHandler or Condition functions.
+* Middleware is applied in the order it is passed, and if any middleware throws an error,
+* subsequent middleware will not be executed.
+* You can also pass a condition function that returns a boolean value. If returns false
+* the evaluation will be halted, and rest of the middleware will not be executed.
+* @returns A composed middleware.
+*
+* @example
+* ```ts
+* import { some, every } from 'hono/combine'
+* import { bearerAuth } from 'hono/bearer-auth'
+* import { myCheckLocalNetwork } from '@/check-local-network'
+* import { myRateLimit } from '@/rate-limit'
+*
+* // If client is in local network, then skip authentication and rate limiting.
+* // Otherwise, apply authentication and rate limiting.
+* app.use('/api/*', some(
+*   myCheckLocalNetwork(),
+*   every(
+*     bearerAuth({ token }),
+*     myRateLimit({ limit: 100 }),
+*   ),
+* ));
+* ```
+*/
+const every = (...middleware) => {
+	return async function every(c, next) {
+		const currentRouteIndex = c.req.routeIndex;
+		await compose(middleware.map((m) => [[async (c, next) => {
+			c.req.routeIndex = currentRouteIndex;
+			const res = await m(c, next);
+			if (res === false) throw new Error("Unmet condition");
+			return res;
+		}]]))(c, next);
+	};
+};
+/**
+* Create a composed middleware that runs all middleware except when the condition is met.
+*
+* @param condition - A string or Condition function.
+* If there are multiple targets to match any of them, they can be passed as an array.
+* If a string is passed, it will be treated as a path pattern to match.
+* If a Condition function is passed, it will be evaluated against the request context.
+* @param middleware - Middleware to run when the condition is not met.
+* Multiple middleware can be passed, and they are applied in the order they are passed.
+* @returns A composed middleware.
+*
+* @example
+* ```ts
+* import { except } from 'hono/combine'
+* import { bearerAuth } from 'hono/bearer-auth'
+*
+* // If client is accessing public API, then skip authentication.
+* // Otherwise, require a valid token.
+* app.use('/api/*', except(
+*   '/api/public/*',
+*   bearerAuth({ token }),
+* ));
+* ```
+*/
+const except = (condition, ...middleware) => {
+	let router = void 0;
+	const conditions = (Array.isArray(condition) ? condition : [condition]).map((condition) => {
+		if (typeof condition === "string") {
+			router ||= new TrieRouter();
+			router.add("ALL", condition, true);
+		} else return condition;
+	}).filter(Boolean);
+	if (router) conditions.unshift((c) => !!router?.match("ALL", c.req.path)?.[0]?.[0]?.[0]);
+	const handler = some((c) => conditions.some((cond) => cond(c)), every(...middleware));
+	return async function except(c, next) {
+		await handler(c, next);
+	};
+};
+//#endregion
+export { every, except, some };

package/node_modules/@modelcontextprotocol/sdk/node_modules/hono/dist/middleware/compress/index.js

@@ -0,0 +1,80 @@
+import { parseAccept } from "../../utils/accept.js";
+import { COMPRESSIBLE_CONTENT_TYPE_REGEX } from "../../utils/compress.js";
+//#region src/middleware/compress/index.ts
+const ENCODING_TYPES = ["gzip", "deflate"];
+const cacheControlNoTransformRegExp = /(?:^|,)\s*?no-transform\s*?(?:,|$)/i;
+const selectEncoding = (header, candidates) => {
+	if (header === void 0) return;
+	const accepts = parseAccept(header);
+	const wildcardQ = accepts.find((a) => a.type === "*")?.q;
+	let best;
+	for (const enc of candidates) {
+		const explicit = accepts.find((a) => a.type.toLowerCase() === enc);
+		const q = explicit ? explicit.q : wildcardQ ?? 0;
+		if (q === 1) return enc;
+		else if (q > 0 && (!best || q > best.q)) best = {
+			encoding: enc,
+			q
+		};
+	}
+	return best?.encoding;
+};
+const varyAcceptEncodingRegExp = /(?:^|,)\s*accept-encoding\s*(?:,|$)/i;
+/**
+* Compress Middleware for Hono.
+*
+* @see {@link https://hono.dev/docs/middleware/builtin/compress}
+*
+* @param {CompressionOptions} [options] - The options for the compress middleware.
+* @param {'gzip' | 'deflate'} [options.encoding] - The compression scheme to allow for response compression. Either 'gzip' or 'deflate'. If not defined, both are allowed and will be used based on the Accept-Encoding header. 'gzip' is prioritized if this option is not provided and the client provides both in the Accept-Encoding header.
+* @param {number} [options.threshold=1024] - The minimum size in bytes to compress. Defaults to 1024 bytes.
+* @param {RegExp | Function} [options.contentTypeFilter=COMPRESSIBLE_CONTENT_TYPE_REGEX] - A RegExp or function to determine if the response Content-Type should be compressed.
+* @returns {MiddlewareHandler} The middleware handler function.
+*
+* @example
+* ```ts
+* const app = new Hono()
+*
+* app.use(compress())
+*
+* // Compress only JSON responses
+* app.use(compress({ contentTypeFilter: /^application\/json/ }))
+*
+* // Compress based on custom Content-Type logic
+* app.use(compress({ contentTypeFilter: (type) => COMPRESSIBLE_CONTENT_TYPE_REGEX.test(type) || type === "application/x-myformat" }))
+* ```
+*/
+const compress = (options) => {
+	const threshold = options?.threshold ?? 1024;
+	const candidates = options?.encoding ? [options.encoding] : ENCODING_TYPES;
+	const contentTypeFilter = options?.contentTypeFilter ?? COMPRESSIBLE_CONTENT_TYPE_REGEX;
+	const shouldCompress = typeof contentTypeFilter === "function" ? (res) => {
+		const type = res.headers.get("Content-Type");
+		return type && contentTypeFilter(type);
+	} : (res) => {
+		const type = res.headers.get("Content-Type");
+		return type && contentTypeFilter.test(type);
+	};
+	return async function compress(ctx, next) {
+		await next();
+		const contentLength = ctx.res.headers.get("Content-Length");
+		if (ctx.res.status === 206 || ctx.res.headers.has("Content-Encoding") || ctx.res.headers.has("Transfer-Encoding") || ctx.req.method === "HEAD" || contentLength && Number(contentLength) < threshold || !shouldCompress(ctx.res) || !shouldTransform(ctx.res)) return;
+		const current = ctx.res.headers.get("Vary");
+		if (current !== "*" && !(current && varyAcceptEncodingRegExp.test(current))) ctx.header("Vary", current ? `${current}, Accept-Encoding` : "Accept-Encoding");
+		const accepted = ctx.req.header("Accept-Encoding");
+		const encoding = selectEncoding(accepted, candidates);
+		if (!encoding || !ctx.res.body) return;
+		const stream = new CompressionStream(encoding);
+		ctx.res = new Response(ctx.res.body.pipeThrough(stream), ctx.res);
+		ctx.res.headers.delete("Content-Length");
+		ctx.res.headers.set("Content-Encoding", encoding);
+		const etag = ctx.res.headers.get("ETag");
+		if (etag && !etag.startsWith("W/")) ctx.res.headers.set("ETag", `W/${etag}`);
+	};
+};
+const shouldTransform = (res) => {
+	const cacheControl = res.headers.get("Cache-Control");
+	return !cacheControl || !cacheControlNoTransformRegExp.test(cacheControl);
+};
+//#endregion
+export { COMPRESSIBLE_CONTENT_TYPE_REGEX, compress };

package/node_modules/@modelcontextprotocol/sdk/node_modules/hono/dist/middleware/context-storage/index.js

@@ -0,0 +1,53 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+//#region src/middleware/context-storage/index.ts
+/**
+* @module
+* Context Storage Middleware for Hono.
+*/
+const asyncLocalStorage = new AsyncLocalStorage();
+/**
+* Context Storage Middleware for Hono.
+*
+* @see {@link https://hono.dev/docs/middleware/builtin/context-storage}
+*
+* @returns {MiddlewareHandler} The middleware handler function.
+*
+* @example
+* ```ts
+* type Env = {
+*   Variables: {
+*     message: string
+*   }
+* }
+*
+* const app = new Hono<Env>()
+*
+* app.use(contextStorage())
+*
+* app.use(async (c, next) => {
+*   c.set('message', 'Hono is hot!!')
+*   await next()
+* })
+*
+* app.get('/', async (c) => c.text(getMessage()))
+*
+* const getMessage = () => {
+*   return getContext<Env>().var.message
+* }
+* ```
+*/
+const contextStorage = () => {
+	return async function contextStorage(c, next) {
+		await asyncLocalStorage.run(c, next);
+	};
+};
+const tryGetContext = () => {
+	return asyncLocalStorage.getStore();
+};
+const getContext = () => {
+	const context = tryGetContext();
+	if (!context) throw new Error("Context is not available");
+	return context;
+};
+//#endregion
+export { contextStorage, getContext, tryGetContext };

package/node_modules/@modelcontextprotocol/sdk/node_modules/hono/dist/middleware/cors/index.js

@@ -0,0 +1,108 @@
+//#region src/middleware/cors/index.ts
+/**
+* CORS Middleware for Hono.
+*
+* @see {@link https://hono.dev/docs/middleware/builtin/cors}
+*
+* @param {CORSOptions} [options] - The options for the CORS middleware.
+* @param {string | string[] | ((origin: string, c: Context) => Promise<string | undefined | null> | string | undefined | null)} [options.origin='*'] - The value of "Access-Control-Allow-Origin" CORS header.
+* @param {string[] | ((origin: string, c: Context) => Promise<string[]> | string[])} [options.allowMethods=['GET', 'HEAD', 'PUT', 'POST', 'DELETE', 'PATCH', 'QUERY']] - The value of "Access-Control-Allow-Methods" CORS header.
+* @param {string[]} [options.allowHeaders=[]] - The value of "Access-Control-Allow-Headers" CORS header.
+* @param {number} [options.maxAge] - The value of "Access-Control-Max-Age" CORS header.
+* @param {boolean} [options.credentials] - The value of "Access-Control-Allow-Credentials" CORS header.
+* @param {string[]} [options.exposeHeaders=[]] - The value of "Access-Control-Expose-Headers" CORS header.
+* @returns {MiddlewareHandler} The middleware handler function.
+*
+* @example
+* ```ts
+* const app = new Hono()
+*
+* app.use('/api/*', cors())
+* app.use(
+*   '/api2/*',
+*   cors({
+*     origin: 'http://example.com',
+*     allowHeaders: ['X-Custom-Header', 'Upgrade-Insecure-Requests'],
+*     allowMethods: ['POST', 'GET', 'OPTIONS'],
+*     exposeHeaders: ['Content-Length', 'X-Kuma-Revision'],
+*     maxAge: 600,
+*     credentials: true,
+*   })
+* )
+*
+* app.all('/api/abc', (c) => {
+*   return c.json({ success: true })
+* })
+* app.all('/api2/abc', (c) => {
+*   return c.json({ success: true })
+* })
+* ```
+*/
+const cors = (options) => {
+	const opts = {
+		origin: "*",
+		allowMethods: [
+			"GET",
+			"HEAD",
+			"PUT",
+			"POST",
+			"DELETE",
+			"PATCH",
+			"QUERY"
+		],
+		allowHeaders: [],
+		exposeHeaders: [],
+		...options
+	};
+	const exposeHeadersStr = opts.exposeHeaders?.length ? opts.exposeHeaders.join(",") : void 0;
+	const allowHeadersStr = opts.allowHeaders?.length ? opts.allowHeaders.join(",") : void 0;
+	const findAllowOrigin = ((optsOrigin) => {
+		if (typeof optsOrigin === "string") {
+			if (optsOrigin === "*") return () => optsOrigin;
+			else return (origin) => optsOrigin === origin ? origin : null;
+		} else if (typeof optsOrigin === "function") return optsOrigin;
+		else return (origin) => optsOrigin.includes(origin) ? origin : null;
+	})(opts.origin);
+	const findAllowMethods = ((optsAllowMethods) => {
+		if (typeof optsAllowMethods === "function") return async (origin, c) => (await optsAllowMethods(origin, c)).join(",");
+		else if (Array.isArray(optsAllowMethods)) {
+			const methodsStr = optsAllowMethods.join(",");
+			return () => methodsStr;
+		} else return () => "";
+	})(opts.allowMethods);
+	return async function cors(c, next) {
+		function set(key, value) {
+			c.res.headers.set(key, value);
+		}
+		const allowOrigin = await findAllowOrigin(c.req.header("origin") || "", c);
+		if (allowOrigin) set("Access-Control-Allow-Origin", allowOrigin);
+		if (opts.credentials) set("Access-Control-Allow-Credentials", "true");
+		if (exposeHeadersStr) set("Access-Control-Expose-Headers", exposeHeadersStr);
+		if (c.req.method === "OPTIONS") {
+			if (opts.origin !== "*") c.res.headers.append("Vary", "Origin");
+			if (opts.maxAge != null) set("Access-Control-Max-Age", opts.maxAge.toString());
+			const allowMethods = await findAllowMethods(c.req.header("origin") || "", c);
+			if (allowMethods) set("Access-Control-Allow-Methods", allowMethods);
+			let headersStr = allowHeadersStr;
+			if (!headersStr) {
+				const requestHeaders = c.req.header("Access-Control-Request-Headers");
+				if (requestHeaders) headersStr = requestHeaders.split(",").map((h) => h.trim()).join(",");
+			}
+			if (headersStr) {
+				set("Access-Control-Allow-Headers", headersStr);
+				c.res.headers.append("Vary", "Access-Control-Request-Headers");
+			}
+			c.res.headers.delete("Content-Length");
+			c.res.headers.delete("Content-Type");
+			return new Response(null, {
+				headers: c.res.headers,
+				status: 204,
+				statusText: "No Content"
+			});
+		}
+		await next();
+		if (opts.origin !== "*") c.header("Vary", "Origin", { append: true });
+	};
+};
+//#endregion
+export { cors };

package/node_modules/@modelcontextprotocol/sdk/node_modules/hono/dist/middleware/csrf/index.js

@@ -0,0 +1,105 @@
+import { HTTPException } from "../../http-exception.js";
+//#region src/middleware/csrf/index.ts
+const secFetchSiteValues = [
+	"same-origin",
+	"same-site",
+	"none",
+	"cross-site"
+];
+const isSecFetchSite = (value) => secFetchSiteValues.includes(value);
+const isSafeMethodRe = /^(GET|HEAD|OPTIONS)$/;
+const isRequestedByFormElementRe = /^\b(application\/x-www-form-urlencoded|multipart\/form-data|text\/plain)\b/i;
+/**
+* CSRF Protection Middleware for Hono.
+*
+* Protects against Cross-Site Request Forgery attacks by validating request origins
+* and sec-fetch-site headers. The request is allowed if either validation passes.
+*
+* @see {@link https://hono.dev/docs/middleware/builtin/csrf}
+*
+* @param {CSRFOptions} [options] - The options for the CSRF protection middleware.
+* @param {string|string[]|(origin: string, context: Context) => boolean} [options.origin] -
+*   Allowed origins for requests.
+*   - string: Single allowed origin (e.g., 'https://example.com')
+*   - string[]: Multiple allowed origins
+*   - function: Custom validation logic
+*   - Default: Only same origin as the request URL
+* @param {string|string[]|(secFetchSite: string, context: Context) => boolean} [options.secFetchSite] -
+*   Sec-Fetch-Site header validation. Standard values include 'same-origin', 'same-site', 'cross-site', 'none'.
+*   - string: Single allowed value (e.g., 'same-origin')
+*   - string[]: Multiple allowed values (e.g., ['same-origin', 'same-site'])
+*   - function: Custom validation with access to context
+*   - Default: Only allows 'same-origin'
+* @returns {MiddlewareHandler} The middleware handler function.
+*
+* @example
+* ```ts
+* const app = new Hono()
+*
+* // Default: both origin and sec-fetch-site validation
+* app.use('*', csrf())
+*
+* // Allow specific origins
+* app.use('*', csrf({ origin: 'https://example.com' }))
+* app.use('*', csrf({ origin: ['https://app.com', 'https://api.com'] }))
+*
+* // Allow specific sec-fetch-site values
+* app.use('*', csrf({ secFetchSite: 'same-origin' }))
+* app.use('*', csrf({ secFetchSite: ['same-origin', 'same-site'] }))
+*
+* // Dynamic sec-fetch-site validation
+* app.use('*', csrf({
+*   secFetchSite: (secFetchSite, c) => {
+*     // Always allow same-origin
+*     if (secFetchSite === 'same-origin') return true
+*     // Allow cross-site for webhook endpoints
+*     if (secFetchSite === 'cross-site' && c.req.path.startsWith('/webhook/')) {
+*       return true
+*     }
+*     return false
+*   }
+* }))
+*
+* // Dynamic origin validation
+* app.use('*', csrf({
+*   origin: (origin, c) => {
+*     // Allow same origin
+*     if (origin === new URL(c.req.url).origin) return true
+*     // Allow specific trusted domains
+*     return ['https://app.example.com', 'https://admin.example.com'].includes(origin)
+*   }
+* }))
+* ```
+*/
+const csrf = (options) => {
+	const originHandler = ((optsOrigin) => {
+		if (!optsOrigin) return (origin, c) => origin === new URL(c.req.url).origin;
+		else if (typeof optsOrigin === "string") return (origin) => origin === optsOrigin;
+		else if (typeof optsOrigin === "function") return optsOrigin;
+		else return (origin) => optsOrigin.includes(origin);
+	})(options?.origin);
+	const isAllowedOrigin = async (origin, c) => {
+		if (origin === void 0) return false;
+		return await originHandler(origin, c);
+	};
+	const secFetchSiteHandler = ((optsSecFetchSite) => {
+		if (!optsSecFetchSite) return (secFetchSite) => secFetchSite === "same-origin";
+		else if (typeof optsSecFetchSite === "string") return (secFetchSite) => secFetchSite === optsSecFetchSite;
+		else if (typeof optsSecFetchSite === "function") return optsSecFetchSite;
+		else return (secFetchSite) => optsSecFetchSite.includes(secFetchSite);
+	})(options?.secFetchSite);
+	const isAllowedSecFetchSite = async (secFetchSite, c) => {
+		if (secFetchSite === void 0) return false;
+		if (!isSecFetchSite(secFetchSite)) return false;
+		return await secFetchSiteHandler(secFetchSite, c);
+	};
+	return async function csrf(c, next) {
+		if (!isSafeMethodRe.test(c.req.method) && isRequestedByFormElementRe.test(c.req.header("content-type") || "text/plain") && !await isAllowedSecFetchSite(c.req.header("sec-fetch-site"), c) && !await isAllowedOrigin(c.req.header("origin"), c)) {
+			const res = new Response("Forbidden", { status: 403 });
+			throw new HTTPException(403, { res });
+		}
+		await next();
+	};
+};
+//#endregion
+export { csrf };

package/node_modules/@modelcontextprotocol/sdk/node_modules/hono/dist/middleware/etag/digest.js

@@ -0,0 +1,61 @@
+//#region src/middleware/etag/digest.ts
+const mergeBuffers = (buffer1, buffer2) => {
+	if (!buffer1) return buffer2;
+	const merged = new Uint8Array(new ArrayBuffer(buffer1.byteLength + buffer2.byteLength));
+	merged.set(new Uint8Array(buffer1), 0);
+	merged.set(buffer2, buffer1.byteLength);
+	return merged;
+};
+const CHUNK_SIZE = 262144;
+const generateDigest = async (stream, generator) => {
+	if (!stream) return null;
+	let result = void 0;
+	let chunk;
+	let chunkLength = 0;
+	const digest = async (body) => {
+		result = await generator(mergeBuffers(result, body));
+	};
+	const reader = stream.getReader();
+	for (;;) {
+		const { value, done } = await reader.read();
+		if (done) break;
+		let offset = 0;
+		while (offset < value.byteLength) {
+			const remaining = value.byteLength - offset;
+			if (chunkLength === 0 && remaining >= CHUNK_SIZE) {
+				await digest(value.subarray(offset, offset + CHUNK_SIZE));
+				offset += CHUNK_SIZE;
+				continue;
+			}
+			const requiredLength = chunkLength + remaining;
+			if (requiredLength < CHUNK_SIZE) {
+				if (!chunk) chunk = value.slice(offset);
+				else {
+					if (chunk.byteLength < requiredLength) {
+						const nextChunk = new Uint8Array(new ArrayBuffer(Math.min(CHUNK_SIZE, Math.max(requiredLength, chunk.byteLength * 2))));
+						nextChunk.set(chunk.subarray(0, chunkLength));
+						chunk = nextChunk;
+					}
+					chunk.set(value.subarray(offset), chunkLength);
+				}
+				chunkLength = requiredLength;
+				break;
+			}
+			const length = CHUNK_SIZE - chunkLength;
+			if (chunk?.byteLength !== CHUNK_SIZE) {
+				const nextChunk = new Uint8Array(/* @__PURE__ */ new ArrayBuffer(CHUNK_SIZE));
+				if (chunk) nextChunk.set(chunk.subarray(0, chunkLength));
+				chunk = nextChunk;
+			}
+			chunk.set(value.subarray(offset, offset + length), chunkLength);
+			await digest(chunk);
+			chunkLength = 0;
+			offset += length;
+		}
+	}
+	if (chunk && chunkLength > 0) await digest(chunk.subarray(0, chunkLength));
+	if (!result) return null;
+	return Array.prototype.map.call(new Uint8Array(result), (x) => x.toString(16).padStart(2, "0")).join("");
+};
+//#endregion
+export { generateDigest };

package/node_modules/@modelcontextprotocol/sdk/node_modules/hono/dist/middleware/etag/index.js

@@ -0,0 +1,77 @@
+import { generateDigest } from "./digest.js";
+//#region src/middleware/etag/index.ts
+/**
+* Default headers to pass through on 304 responses. From the spec:
+* > The response must not contain a body and must include the headers that
+* > would have been sent in an equivalent 200 OK response: Cache-Control,
+* > Content-Location, Date, ETag, Expires, and Vary.
+*/
+const RETAINED_304_HEADERS = [
+	"cache-control",
+	"content-location",
+	"date",
+	"etag",
+	"expires",
+	"vary"
+];
+const stripWeak = (tag) => tag.replace(/^W\//, "");
+function etagMatches(etag, ifNoneMatch) {
+	return ifNoneMatch != null && ifNoneMatch.split(",").some((t) => stripWeak(t.trim()) === stripWeak(etag));
+}
+function initializeGenerator(generator) {
+	if (!generator) {
+		if (crypto && crypto.subtle) generator = (body) => crypto.subtle.digest({ name: "SHA-1" }, body);
+	}
+	return generator;
+}
+/**
+* ETag Middleware for Hono.
+*
+* @see {@link https://hono.dev/docs/middleware/builtin/etag}
+*
+* @param {ETagOptions} [options] - The options for the ETag middleware.
+* @param {boolean} [options.weak=false] - Define using or not using a weak validation. If true is set, then `W/` is added to the prefix of the value.
+* @param {string[]} [options.retainedHeaders=RETAINED_304_HEADERS] - The headers that you want to retain in the 304 Response.
+* @param {function(Uint8Array): ArrayBuffer | Promise<ArrayBuffer>} [options.generateDigest] -
+* A custom digest generation function. By default, it uses 'SHA-1'
+* This function is called with the response body as a `Uint8Array` and should return a hash as an `ArrayBuffer` or a Promise of one.
+* @returns {MiddlewareHandler} The middleware handler function.
+*
+* @example
+* ```ts
+* const app = new Hono()
+*
+* app.use('/etag/*', etag())
+* app.get('/etag/abc', (c) => {
+*   return c.text('Hono is hot')
+* })
+* ```
+*/
+const etag = (options) => {
+	const retainedHeaders = new Set((options?.retainedHeaders ?? RETAINED_304_HEADERS).map((header) => header.toLowerCase()));
+	const weak = options?.weak ?? false;
+	const generator = initializeGenerator(options?.generateDigest);
+	return async function etag(c, next) {
+		const ifNoneMatch = c.req.header("If-None-Match") ?? null;
+		await next();
+		if (!(c.req.method === "GET" || c.req.method === "HEAD" || c.req.method === "QUERY") || !c.res.ok) return;
+		const res = c.res;
+		let etag = res.headers.get("ETag");
+		if (!etag) {
+			if (!generator) return;
+			const hash = await generateDigest(res.clone().body, generator);
+			if (hash === null) return;
+			etag = weak ? `W/"${hash}"` : `"${hash}"`;
+		}
+		if (ifNoneMatch === "*" || etagMatches(etag, ifNoneMatch)) {
+			c.res = new Response(null, {
+				status: 304,
+				statusText: "Not Modified",
+				headers: { ETag: etag }
+			});
+			for (const key of Array.from(c.res.headers.keys())) if (!retainedHeaders.has(key.toLowerCase())) c.res.headers.delete(key);
+		} else c.res.headers.set("ETag", etag);
+	};
+};
+//#endregion
+export { RETAINED_304_HEADERS, etag };