hono 4.13.13 → 5.0.0-rc.0

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

@@ -1,173 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_utils_crypto = require("../../utils/crypto.js");
-const require_request = require("../../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);
-};
-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 require_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) {
-					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 require_utils_crypto.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
-exports.cache = cache;

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

@@ -1,141 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_compose = require("../../compose.js");
-require("../../router.js");
-const require_router_trie_router_router = require("../../router/trie-router/router.js");
-require("../../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 require_compose.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 require_router_trie_router_router.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
-exports.every = every;
-exports.except = except;
-exports.some = some;

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

@@ -1,82 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_utils_accept = require("../../utils/accept.js");
-const require_utils_compress = require("../../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 = require_utils_accept.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 ?? require_utils_compress.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
-exports.COMPRESSIBLE_CONTENT_TYPE_REGEX = require_utils_compress.COMPRESSIBLE_CONTENT_TYPE_REGEX;
-exports.compress = compress;

package/dist/cjs/middleware/context-storage/index.js

@@ -1,55 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-//#region src/middleware/context-storage/index.ts
-/**
-* @module
-* Context Storage Middleware for Hono.
-*/
-const asyncLocalStorage = new (require("node:async_hooks")).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
-exports.contextStorage = contextStorage;
-exports.getContext = getContext;
-exports.tryGetContext = tryGetContext;

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

@@ -1,109 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-//#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
-exports.cors = cors;

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

@@ -1,106 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_http_exception = require("../../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 require_http_exception.HTTPException(403, { res });
-		}
-		await next();
-	};
-};
-//#endregion
-exports.csrf = csrf;