acrylblends 1.0.4 → 1.0.6

package/lib/kv/json.js

@@ -1,224 +1,2 @@
-import { a as compareKeys, c as runChange, o as decodeValue, r as checkKey, s as encodeValue } from "../src-DRFVEQQb.js";
-import { mkdir, open, readFile, readdir, rename, rm } from "node:fs/promises";
-import { basename, dirname, join, resolve } from "node:path";
-//#region ../../plugins/acryl-kv-json/src/open.ts
-/**
-* The plain way to open the JSON-file provider, for code without Cordis (an acrylblends app): `openKv({ path })` reads one JSON file into
-* memory and resolves the `kv` port with the function that closes it. The Cordis plugin is a thin wrapper over this, so both run one code
-* path. This entry imports nothing from Cordis.
-*
-* Every write persists the whole map: serialize to a temporary file in the same folder, flush it, rename it over the file, and flush the
-* folder where the platform allows. The call resolves after the rename, so a crash leaves the old file or the new one, never half of one.
-* Writes are grouped: the calls made in one turn of the event loop, and those that queue while a file write is in flight, are applied in
-* call order and persisted together by one write, so a burst of calls costs one flush and one rename, not one each (on Windows each costs
-* tens of milliseconds). One process owns the
-* file: two writers would overwrite each other.
-*/
-/** The file's own format version, for a later change of layout. */
-const FORMAT = 1;
-/** Stray temporary files from a crash end in `.tmp` and start with the file's name. */
-const tempPrefix = (file) => `${basename(file)}.`;
-/** The file content for a map of key to JSON text, keys in code point order, so the same data is the same bytes. */
-function serialize(entries) {
-	const body = [...entries.keys()].sort(compareKeys).map((key) => `${JSON.stringify(key)}:${entries.get(key)}`).join(",");
-	return `{"version":${FORMAT},"entries":{${body}}}\n`;
-}
-function unreadable(file, reason) {
-	return /* @__PURE__ */ new Error(`acryl-kv-json: ${file} is not a readable kv file (${reason}); it was not changed`);
-}
-/** The entries of a file, or none when it does not exist. A file that exists and does not parse is an error: it is never started over. */
-async function load(file) {
-	let text;
-	try {
-		text = await readFile(file, "utf8");
-	} catch (error) {
-		if (error.code === "ENOENT") return /* @__PURE__ */ new Map();
-		throw error;
-	}
-	let parsed;
-	try {
-		parsed = JSON.parse(text);
-	} catch (error) {
-		throw unreadable(file, error.message);
-	}
-	if (typeof parsed !== "object" || parsed === null || parsed.version !== FORMAT) throw unreadable(file, "not a version 1 kv file");
-	const entries = parsed.entries;
-	if (typeof entries !== "object" || entries === null || Array.isArray(entries)) throw unreadable(file, "no entries object");
-	return new Map(Object.entries(entries).map(([key, value]) => [key, JSON.stringify(value)]));
-}
-/** Remove the temporary files an earlier crash left beside the file. */
-async function removeStrays(file) {
-	const prefix = tempPrefix(file);
-	for (const name of await readdir(dirname(file))) if (name.startsWith(prefix) && name.endsWith(".tmp")) await rm(join(dirname(file), name), { force: true });
-}
-const RENAME_RETRIES = 8;
-/** Rename over the target. Windows refuses while a scanner or an indexer holds the target for a moment, so it is retried briefly. */
-async function replace(from, to) {
-	for (let attempt = 0;; attempt += 1) try {
-		await rename(from, to);
-		return;
-	} catch (error) {
-		const code = error.code;
-		if (attempt >= RENAME_RETRIES || code !== "EPERM" && code !== "EBUSY" && code !== "EACCES") throw error;
-		await new Promise((resolveWait) => setTimeout(resolveWait, 10 * (attempt + 1)));
-	}
-}
-/** Flush the folder entry of a renamed file (POSIX); Windows cannot open a folder, and a filesystem that refuses is no worse than before. */
-async function flushFolder(folder) {
-	if (process.platform === "win32") return;
-	try {
-		const handle = await open(folder, "r");
-		try {
-			await handle.sync();
-		} finally {
-			await handle.close();
-		}
-	} catch {}
-}
-/** Open (and create, when missing) a JSON-file store. @throws when the file exists and is not a readable kv file. */
-async function openKv(options) {
-	const file = resolve(options.path);
-	await mkdir(dirname(file), { recursive: true });
-	await removeStrays(file);
-	let state = await load(file);
-	let closed = false;
-	let sequence = 0;
-	/** Calls waiting for the next file write, in call order. */
-	let queue = [];
-	/** Whether the loop that writes the queue runs; cleared by the loop itself, so a call queued after it ends starts a new one. */
-	let draining = false;
-	/** The latest loop, for `close` to wait on. */
-	let drained = Promise.resolve();
-	const guard = () => {
-		if (closed) throw new Error(`acryl-kv-json: ${file} is closed`);
-	};
-	/** Persist a map: the file is the old one or this one, never between. */
-	const persist = async (next) => {
-		sequence += 1;
-		const temp = join(dirname(file), `${tempPrefix(file)}${process.pid}.${sequence}.tmp`);
-		try {
-			const handle = await open(temp, "w");
-			try {
-				await handle.writeFile(serialize(next), "utf8");
-				await handle.sync();
-			} finally {
-				await handle.close();
-			}
-			await replace(temp, file);
-		} catch (error) {
-			await rm(temp, { force: true });
-			throw error;
-		}
-		await flushFolder(dirname(file));
-	};
-	/**
-	* Write the queue until it is empty. Each round takes every call queued so far and applies them in order to one copy of the state. A call
-	* whose change throws rejects with its error and changes nothing, and the others in the round still apply. The copy becomes the state
-	* only once it is on disk. A failed file write rejects every call in its round and leaves the state as it was.
-	*/
-	const drain = async () => {
-		try {
-			await Promise.resolve();
-			await rounds();
-		} finally {
-			draining = false;
-		}
-	};
-	const rounds = async () => {
-		while (queue.length > 0) {
-			const round = queue;
-			queue = [];
-			const draft = new Map(state);
-			const applied = [];
-			for (const call of round) {
-				let change;
-				try {
-					change = call.change((key) => draft.get(key));
-				} catch (error) {
-					call.reject(error);
-					continue;
-				}
-				if (change.text === void 0) draft.delete(change.key);
-				else draft.set(change.key, change.text);
-				applied.push({
-					call,
-					result: change.result
-				});
-			}
-			if (applied.length === 0) continue;
-			try {
-				await persist(draft);
-			} catch (error) {
-				for (const { call } of applied) call.reject(error);
-				continue;
-			}
-			state = draft;
-			for (const { call, result } of applied) call.resolve(result);
-		}
-	};
-	/** Queue one change behind every earlier call; it resolves once a file write that contains it is on disk. */
-	const write = (change) => {
-		guard();
-		const done = new Promise((resolveCall, rejectCall) => {
-			queue.push({
-				change,
-				resolve: resolveCall,
-				reject: rejectCall
-			});
-		});
-		if (!draining) {
-			draining = true;
-			drained = drain();
-		}
-		return done;
-	};
-	return {
-		kv: {
-			async get(key) {
-				guard();
-				checkKey(key);
-				const text = state.get(key);
-				return text === void 0 ? void 0 : decodeValue(text);
-			},
-			async set(key, value) {
-				checkKey(key);
-				const text = encodeValue(value);
-				await write(() => ({
-					key,
-					text,
-					result: void 0
-				}));
-			},
-			async update(key, change) {
-				checkKey(key);
-				return write((read) => {
-					const text = read(key);
-					const encoded = encodeValue(runChange(change, text === void 0 ? void 0 : decodeValue(text)));
-					return {
-						key,
-						text: encoded,
-						result: decodeValue(encoded)
-					};
-				});
-			},
-			async delete(key) {
-				checkKey(key);
-				await write(() => ({
-					key,
-					text: void 0,
-					result: void 0
-				}));
-			},
-			async list(prefix = "") {
-				guard();
-				return [...state.keys()].filter((key) => key.startsWith(prefix)).sort(compareKeys);
-			}
-		},
-		close: async () => {
-			closed = true;
-			await drained;
-		}
-	};
-}
-//#endregion
+import { t as openKv } from "../open-Dp4sxspc.js";
 export { openKv };

package/lib/{language-D9a4zqvn.js → language-DeGRtLJt.js}

@@ -1,5 +1,5 @@
-import { parseAccept } from "./utils/accept.js";
-import { getCookie, setCookie } from "./cookie.js";
+import { t as parseAccept } from "./accept-CNNHu4Cf.js";
+import { i as getCookie, o as setCookie } from "./cookie-BHIduy2T.js";
 //#region ../../plugins/acryl-router/src/core/middleware/language/language.ts
 const DEFAULT_OPTIONS = {
 	order: [

package/lib/language.js

@@ -1,2 +1,2 @@
-import { a as languageDetector, i as detectFromQuery, n as detectFromHeader, r as detectFromPath, t as detectFromCookie } from "./language-D9a4zqvn.js";
+import { a as languageDetector, i as detectFromQuery, n as detectFromHeader, r as detectFromPath, t as detectFromCookie } from "./language-DeGRtLJt.js";
 export { detectFromCookie, detectFromHeader, detectFromPath, detectFromQuery, languageDetector };

package/lib/{linear-router-C3FPib6h.js → linear-router-CmZn_JLV.js}

@@ -1,5 +1,5 @@
-import { checkOptionalParameter } from "./utils/url.js";
-import { UnsupportedPathError } from "./router.js";
+import { t as checkOptionalParameter } from "./url-BPh4d6j-.js";
+import { a as UnsupportedPathError } from "./router-Be_o6nFu.js";
 //#region ../../plugins/acryl-router/src/core/router/linear-router/router.ts
 const emptyParams = Object.create(null);
 const splitPathRe = /\/(:\w+(?:{(?:(?:{[\d,]+})|[^}])+})?)|\/[^\/\?]+|(\?)/g;

package/lib/logger-Ckxu8diz.js

@@ -0,0 +1,54 @@
+import { n as getColorEnabledAsync } from "./color-COa3DplO.js";
+//#region ../../plugins/acryl-router/src/core/middleware/logger/index.ts
+const LogPrefix = {
+	Outgoing: "-->",
+	Incoming: "<--",
+	Error: "xxx"
+};
+const humanize = (times) => {
+	const [delimiter, separator] = [",", "."];
+	return times.map((v) => v.replace(/(\d)(?=(\d\d\d)+(?!\d))/g, "$1" + delimiter)).join(separator);
+};
+const time = (start) => {
+	const delta = Date.now() - start;
+	return humanize([delta < 1e3 ? delta + "ms" : Math.round(delta / 1e3) + "s"]);
+};
+const colorStatus = async (status) => {
+	if (await getColorEnabledAsync()) switch (status / 100 | 0) {
+		case 5: return `\x1b[31m${status}\x1b[0m`;
+		case 4: return `\x1b[33m${status}\x1b[0m`;
+		case 3: return `\x1b[36m${status}\x1b[0m`;
+		case 2: return `\x1b[32m${status}\x1b[0m`;
+	}
+	return `${status}`;
+};
+async function log(fn, prefix, method, path, status = 0, elapsed) {
+	fn(prefix === LogPrefix.Incoming ? `${prefix} ${method} ${path}` : `${prefix} ${method} ${path} ${await colorStatus(status)} ${elapsed}`);
+}
+/**
+* Logger Middleware for Acryl.
+*
+*
+* @param {PrintFunc} [fn=console.log] - Optional function for customized logging behavior.
+* @returns {MiddlewareHandler} The middleware handler function.
+*
+* @example
+* ```ts
+* const app = new Acryl()
+*
+* app.use(logger())
+* app.get('/', (c) => c.text('Hello Acryl!'))
+* ```
+*/
+const logger = (fn = console.log) => {
+	return async function logger(c, next) {
+		const { method, url } = c.req;
+		const path = url.slice(url.indexOf("/", 8));
+		await log(fn, LogPrefix.Incoming, method, path);
+		const start = Date.now();
+		await next();
+		await log(fn, LogPrefix.Outgoing, method, path, c.res.status, time(start));
+	};
+};
+//#endregion
+export { logger as t };

package/lib/logger.js

@@ -1,54 +1,2 @@
-import { getColorEnabledAsync } from "./utils/color.js";
-//#region ../../plugins/acryl-router/src/core/middleware/logger/index.ts
-const LogPrefix = {
-	Outgoing: "-->",
-	Incoming: "<--",
-	Error: "xxx"
-};
-const humanize = (times) => {
-	const [delimiter, separator] = [",", "."];
-	return times.map((v) => v.replace(/(\d)(?=(\d\d\d)+(?!\d))/g, "$1" + delimiter)).join(separator);
-};
-const time = (start) => {
-	const delta = Date.now() - start;
-	return humanize([delta < 1e3 ? delta + "ms" : Math.round(delta / 1e3) + "s"]);
-};
-const colorStatus = async (status) => {
-	if (await getColorEnabledAsync()) switch (status / 100 | 0) {
-		case 5: return `\x1b[31m${status}\x1b[0m`;
-		case 4: return `\x1b[33m${status}\x1b[0m`;
-		case 3: return `\x1b[36m${status}\x1b[0m`;
-		case 2: return `\x1b[32m${status}\x1b[0m`;
-	}
-	return `${status}`;
-};
-async function log(fn, prefix, method, path, status = 0, elapsed) {
-	fn(prefix === LogPrefix.Incoming ? `${prefix} ${method} ${path}` : `${prefix} ${method} ${path} ${await colorStatus(status)} ${elapsed}`);
-}
-/**
-* Logger Middleware for Acryl.
-*
-*
-* @param {PrintFunc} [fn=console.log] - Optional function for customized logging behavior.
-* @returns {MiddlewareHandler} The middleware handler function.
-*
-* @example
-* ```ts
-* const app = new Acryl()
-*
-* app.use(logger())
-* app.get('/', (c) => c.text('Hello Acryl!'))
-* ```
-*/
-const logger = (fn = console.log) => {
-	return async function logger(c, next) {
-		const { method, url } = c.req;
-		const path = url.slice(url.indexOf("/", 8));
-		await log(fn, LogPrefix.Incoming, method, path);
-		const start = Date.now();
-		await next();
-		await log(fn, LogPrefix.Outgoing, method, path, c.res.status, time(start));
-	};
-};
-//#endregion
+import { t as logger } from "./logger-Ckxu8diz.js";
 export { logger };

package/lib/loopback-only-BbasoF7R.js

@@ -0,0 +1,90 @@
+import { t as connectionOf } from "./connection-C7xgP1hP.js";
+import { BlockList, isIP } from "node:net";
+//#region ../../plugins/acryl-router/src/middleware/loopback-only.ts
+const loopback = new BlockList();
+loopback.addSubnet("127.0.0.0", 8, "ipv4");
+loopback.addSubnet("::1", 128, "ipv6");
+const SAFE_METHODS = /* @__PURE__ */ new Set([
+	"GET",
+	"HEAD",
+	"OPTIONS"
+]);
+/**
+* The authority a loopback request addressed: the `Host` header as a URL, or `undefined` when the request does not come from a loopback peer to the
+* real local port, names another host, or is marked cross-site by the browser. The peer and the port come from the transport (`connectionOf(c)`), never
+* from a header; an in-process call has neither and is refused.
+*/
+const LOOPBACK_HOSTNAMES = [
+	"127.0.0.1",
+	"localhost",
+	"[::1]"
+];
+function loopbackAuthority(c, hostnames = LOOPBACK_HOSTNAMES) {
+	const { remoteAddress, localPort } = connectionOf(c);
+	const host = c.req.header("host");
+	if (remoteAddress === void 0 || localPort === void 0 || host === void 0) return void 0;
+	const address = (remoteAddress.replace(/^\[|\]$/gu, "").split("%", 1)[0] ?? "").replace(/^::ffff:/iu, "");
+	const family = isIP(address);
+	if (family === 0 || !loopback.check(address, family === 4 ? "ipv4" : "ipv6")) return void 0;
+	let authority;
+	try {
+		authority = new URL(`http://${host}`);
+	} catch {
+		return;
+	}
+	if (authority.protocol !== "http:" || Number(authority.port || "80") !== localPort || !hostnames.includes(authority.hostname) || c.req.header("sec-fetch-site") === "cross-site") return void 0;
+	return authority;
+}
+/** Whether a changing request is acceptable by its `Origin`: absent (not a browser cross-origin change) or naming this same authority. `null` and any other origin are not. */
+function sameOrigin(c, authority) {
+	const origin = c.req.header("origin");
+	if (origin === void 0) return true;
+	try {
+		const parsed = new URL(origin);
+		return parsed.protocol === "http:" && parsed.host === authority.host && parsed.pathname === "/";
+	} catch {
+		return false;
+	}
+}
+function originOf(value) {
+	if (value === void 0) return void 0;
+	try {
+		return new URL(value).origin;
+	} catch {
+		return;
+	}
+}
+/** Whether the request comes from a page served by this authority itself: the `own-page` rule of {@link LoopbackOptions.callers}. */
+function fromOwnPage(c, authority) {
+	const origin = c.req.header("origin");
+	const fetchSite = c.req.header("sec-fetch-site");
+	if (origin !== void 0 && originOf(origin) === origin && origin === authority.origin) return fetchSite === void 0 || fetchSite === "same-origin";
+	return SAFE_METHODS.has(c.req.method) && fetchSite === "same-origin" && originOf(c.req.header("referer")) === authority.origin;
+}
+/**
+* Only requests from this machine to this app: loopback peer, the real port, an allowed `Host`, and for mutations a matching `Origin` (with
+* `callers: 'own-page'`, every request from this app's own page). Everything else gets a 403.
+*/
+function loopbackOnly(options = {}) {
+	const mutations = options.mutations ?? "same-origin";
+	const inProcess = options.inProcess ?? "deny";
+	const ownPage = options.callers === "own-page";
+	return async (c, next) => {
+		const connection = connectionOf(c);
+		if (inProcess === "allow" && connection.remoteAddress === void 0 && connection.localPort === void 0) {
+			await next();
+			return;
+		}
+		const authority = loopbackAuthority(c, options.hostnames);
+		if (authority === void 0) return c.json({ error: "request authority rejected" }, 403);
+		if (ownPage) {
+			if (!fromOwnPage(c, authority)) return c.json({ error: "only this app's own page may call this" }, 403);
+			await next();
+			return;
+		}
+		if (mutations === "same-origin" && !SAFE_METHODS.has(c.req.method) && !sameOrigin(c, authority)) return c.json({ error: "a change must come from this app's own origin" }, 403);
+		await next();
+	};
+}
+//#endregion
+export { sameOrigin as a, loopbackOnly as i, fromOwnPage as n, loopbackAuthority as r, LOOPBACK_HOSTNAMES as t };

package/lib/loopback-only.js

@@ -1,90 +1,2 @@
-import { t as connectionOf } from "./connection-C7xgP1hP.js";
-import { BlockList, isIP } from "node:net";
-//#region ../../plugins/acryl-router/src/middleware/loopback-only.ts
-const loopback = new BlockList();
-loopback.addSubnet("127.0.0.0", 8, "ipv4");
-loopback.addSubnet("::1", 128, "ipv6");
-const SAFE_METHODS = /* @__PURE__ */ new Set([
-	"GET",
-	"HEAD",
-	"OPTIONS"
-]);
-/**
-* The authority a loopback request addressed: the `Host` header as a URL, or `undefined` when the request does not come from a loopback peer to the
-* real local port, names another host, or is marked cross-site by the browser. The peer and the port come from the transport (`connectionOf(c)`), never
-* from a header; an in-process call has neither and is refused.
-*/
-const LOOPBACK_HOSTNAMES = [
-	"127.0.0.1",
-	"localhost",
-	"[::1]"
-];
-function loopbackAuthority(c, hostnames = LOOPBACK_HOSTNAMES) {
-	const { remoteAddress, localPort } = connectionOf(c);
-	const host = c.req.header("host");
-	if (remoteAddress === void 0 || localPort === void 0 || host === void 0) return void 0;
-	const address = (remoteAddress.replace(/^\[|\]$/gu, "").split("%", 1)[0] ?? "").replace(/^::ffff:/iu, "");
-	const family = isIP(address);
-	if (family === 0 || !loopback.check(address, family === 4 ? "ipv4" : "ipv6")) return void 0;
-	let authority;
-	try {
-		authority = new URL(`http://${host}`);
-	} catch {
-		return;
-	}
-	if (authority.protocol !== "http:" || Number(authority.port || "80") !== localPort || !hostnames.includes(authority.hostname) || c.req.header("sec-fetch-site") === "cross-site") return void 0;
-	return authority;
-}
-/** Whether a changing request is acceptable by its `Origin`: absent (not a browser cross-origin change) or naming this same authority. `null` and any other origin are not. */
-function sameOrigin(c, authority) {
-	const origin = c.req.header("origin");
-	if (origin === void 0) return true;
-	try {
-		const parsed = new URL(origin);
-		return parsed.protocol === "http:" && parsed.host === authority.host && parsed.pathname === "/";
-	} catch {
-		return false;
-	}
-}
-function originOf(value) {
-	if (value === void 0) return void 0;
-	try {
-		return new URL(value).origin;
-	} catch {
-		return;
-	}
-}
-/** Whether the request comes from a page served by this authority itself: the `own-page` rule of {@link LoopbackOptions.callers}. */
-function fromOwnPage(c, authority) {
-	const origin = c.req.header("origin");
-	const fetchSite = c.req.header("sec-fetch-site");
-	if (origin !== void 0 && originOf(origin) === origin && origin === authority.origin) return fetchSite === void 0 || fetchSite === "same-origin";
-	return SAFE_METHODS.has(c.req.method) && fetchSite === "same-origin" && originOf(c.req.header("referer")) === authority.origin;
-}
-/**
-* Only requests from this machine to this app: loopback peer, the real port, an allowed `Host`, and for mutations a matching `Origin` (with
-* `callers: 'own-page'`, every request from this app's own page). Everything else gets a 403.
-*/
-function loopbackOnly(options = {}) {
-	const mutations = options.mutations ?? "same-origin";
-	const inProcess = options.inProcess ?? "deny";
-	const ownPage = options.callers === "own-page";
-	return async (c, next) => {
-		const connection = connectionOf(c);
-		if (inProcess === "allow" && connection.remoteAddress === void 0 && connection.localPort === void 0) {
-			await next();
-			return;
-		}
-		const authority = loopbackAuthority(c, options.hostnames);
-		if (authority === void 0) return c.json({ error: "request authority rejected" }, 403);
-		if (ownPage) {
-			if (!fromOwnPage(c, authority)) return c.json({ error: "only this app's own page may call this" }, 403);
-			await next();
-			return;
-		}
-		if (mutations === "same-origin" && !SAFE_METHODS.has(c.req.method) && !sameOrigin(c, authority)) return c.json({ error: "a change must come from this app's own origin" }, 403);
-		await next();
-	};
-}
-//#endregion
+import { a as sameOrigin, i as loopbackOnly, n as fromOwnPage, r as loopbackAuthority, t as LOOPBACK_HOSTNAMES } from "./loopback-only-BbasoF7R.js";
 export { LOOPBACK_HOSTNAMES, fromOwnPage, loopbackAuthority, loopbackOnly, sameOrigin };

package/lib/method-not-allowed-TO2_hnfl.js

@@ -0,0 +1,82 @@
+import "./router-Be_o6nFu.js";
+import { t as TrieRouter } from "./trie-router-JydLKUa2.js";
+import { r as matchedRoutes, t as basePath } from "./route-D8m-a2I1.js";
+//#region ../../plugins/acryl-router/src/core/middleware/method-not-allowed/index.ts
+/**
+* Method Not Allowed Middleware for Acryl.
+*
+* Returns a `405 Method Not Allowed` response with an `Allow` header when the request path
+* matches a registered route but the request method is not supported.
+*
+* @param {MethodNotAllowedOptions} options - The options for the middleware.
+* @param {Acryl} options.app - The Acryl instance used by the application.
+* @param {MethodNotAllowedHandler} [options.onMethodNotAllowed] - Generates the response, including its `Allow` header.
+* @returns {MiddlewareHandler} The middleware handler function.
+*
+* @example
+* ```ts
+* const app = new Acryl()
+*
+* app.use(methodNotAllowed({ app }))
+*
+* app.get('/hello', (c) => c.text('Hello!'))
+* app.post('/hello', (c) => c.text('Posted!'))
+*
+* // PUT /hello -> 405 Method Not Allowed
+* // Allow: GET, HEAD, POST
+* ```
+*
+* @example
+* ```ts
+* app.use(
+*   methodNotAllowed({
+*     app,
+*     onMethodNotAllowed: (c, methods) =>
+*       c.json({ error: 'Method Not Allowed' }, 405, { Allow: methods.join(', ') }),
+*   })
+* )
+* ```
+*/
+const methodNotAllowed = (options) => {
+	let methodRouter;
+	return async function methodNotAllowed(c, next) {
+		const routeIndex = c.req.routeIndex;
+		await next();
+		if (c.res.status !== 404) return;
+		if (c.error) return;
+		if (!methodRouter) {
+			const methodsByPath = /* @__PURE__ */ new Map();
+			for (const route of options.app.routes) {
+				if (route.method === "ALL" || route.method === "HEAD") continue;
+				const methods = methodsByPath.get(route.path) ?? /* @__PURE__ */ new Set();
+				methods.add(route.method);
+				if (route.method === "GET") methods.add("HEAD");
+				methodsByPath.set(route.path, methods);
+			}
+			methodRouter = new TrieRouter();
+			for (const [path, methods] of methodsByPath) methodRouter.add("ALL", path, [...methods]);
+		}
+		let requestPath = c.req.path;
+		const currentRoute = matchedRoutes(c)[routeIndex];
+		const sourceRoute = options.app.routes.find((route) => route.handler === methodNotAllowed);
+		if (currentRoute && sourceRoute) {
+			const currentBasePathParts = basePath(c, routeIndex).split("/").filter(Boolean);
+			const sourceBasePathLength = sourceRoute.basePath.split("/").filter(Boolean).length;
+			const mountBasePathParts = currentBasePathParts.slice(0, currentBasePathParts.length - sourceBasePathLength);
+			if (mountBasePathParts.length > 0) {
+				const mountBasePath = `/${mountBasePathParts.join("/")}`;
+				requestPath = c.req.path.slice(mountBasePath.length) || "/";
+			}
+		}
+		const allowedMethods = /* @__PURE__ */ new Set();
+		for (const [methods] of methodRouter.match("ALL", requestPath)[0]) for (const method of methods) allowedMethods.add(method);
+		if (allowedMethods.size === 0 || allowedMethods.has(c.req.method)) return;
+		c.res.headers.delete("Allow");
+		c.res.headers.delete("Content-Length");
+		const methods = [...allowedMethods];
+		const allow = methods.join(", ");
+		c.res = options.onMethodNotAllowed ? await options.onMethodNotAllowed(c, methods) : c.text("Method Not Allowed", 405, { Allow: allow });
+	};
+};
+//#endregion
+export { methodNotAllowed as t };