acrylblends 0.6.0 → 0.6.2

package/lib/mount.d.ts

@@ -0,0 +1,44 @@
+import { I as MiddlewareHandler, t as Context } from "./context-B5Y1lLha.js";
+
+//#region ../../plugins/acryl-router/src/core/middleware/mount/index.d.ts
+type ApplicationHandler = (request: Request, ...args: any) => Response | Promise<Response>;
+type MountOptionHandler = (c: Context) => unknown;
+type MountReplaceRequest = (originalRequest: Request) => Request;
+type MountOptions = MountOptionHandler | {
+  optionHandler?: MountOptionHandler;
+  replaceRequest?: MountReplaceRequest | false;
+};
+/**
+ * `mount()` allows you to mount applications built with other frameworks into your Acryl application.
+ *
+ *
+ * @param {Function} applicationHandler - other Request Handler
+ * @param {MountOptions} [options] - options of `mount()`
+ * @returns {MiddlewareHandler} handler to register with `app.all()`
+ *
+ * @example
+ * ```ts
+ * import { Router as IttyRouter } from 'itty-router'
+ * import { Acryl } from 'acrylblends'
+ * import { mount } from 'acrylblends/mount'
+ * // Create itty-router application
+ * const ittyRouter = IttyRouter()
+ * // GET /itty-router/hello
+ * ittyRouter.get('/hello', () => new Response('Hello from itty-router'))
+ *
+ * const app = new Acryl()
+ * app.all('/itty-router/*', mount(ittyRouter.handle))
+ * ```
+ *
+ * @example
+ * ```ts
+ * const app = new Acryl()
+ * // Send the request to another application without modification.
+ * app.all('/app/*', mount(anotherApp, {
+ *   replaceRequest: (req) => req,
+ * }))
+ * ```
+ */
+declare const mount: (applicationHandler: ApplicationHandler, options?: MountOptions) => MiddlewareHandler;
+//#endregion
+export { type ApplicationHandler, type MountOptionHandler, type MountOptions, type MountReplaceRequest, mount };

package/lib/mount.js

@@ -0,0 +1,67 @@
+import { routePath } from "./route.js";
+//#region ../../plugins/acryl-router/src/core/middleware/mount/index.ts
+const defaultReplaceRequest = (c) => {
+	const pathPrefix = routePath(c).replace(/\/\*$/, "");
+	const url = new URL(c.req.raw.url);
+	url.pathname = c.req.path.slice(pathPrefix.length) || "/";
+	return new Request(url, c.req.raw);
+};
+const defaultGetOptions = (c) => {
+	let executionContext = void 0;
+	try {
+		executionContext = c.executionCtx;
+	} catch {}
+	return [c.env, executionContext];
+};
+/**
+* `mount()` allows you to mount applications built with other frameworks into your Acryl application.
+*
+*
+* @param {Function} applicationHandler - other Request Handler
+* @param {MountOptions} [options] - options of `mount()`
+* @returns {MiddlewareHandler} handler to register with `app.all()`
+*
+* @example
+* ```ts
+* import { Router as IttyRouter } from 'itty-router'
+* import { Acryl } from 'acrylblends'
+* import { mount } from 'acrylblends/mount'
+* // Create itty-router application
+* const ittyRouter = IttyRouter()
+* // GET /itty-router/hello
+* ittyRouter.get('/hello', () => new Response('Hello from itty-router'))
+*
+* const app = new Acryl()
+* app.all('/itty-router/*', mount(ittyRouter.handle))
+* ```
+*
+* @example
+* ```ts
+* const app = new Acryl()
+* // Send the request to another application without modification.
+* app.all('/app/*', mount(anotherApp, {
+*   replaceRequest: (req) => req,
+* }))
+* ```
+*/
+const mount = (applicationHandler, options) => {
+	let replaceRequest;
+	let optionHandler;
+	if (options) if (typeof options === "function") optionHandler = options;
+	else {
+		optionHandler = options.optionHandler;
+		if (options.replaceRequest === false) replaceRequest = (request) => request;
+		else replaceRequest = options.replaceRequest;
+	}
+	const getOptions = optionHandler ? (c) => {
+		const options = optionHandler(c);
+		return Array.isArray(options) ? options : [options];
+	} : defaultGetOptions;
+	return async (c, next) => {
+		const res = await applicationHandler(replaceRequest ? replaceRequest(c.req.raw) : defaultReplaceRequest(c), ...getOptions(c));
+		if (res) return res;
+		await next();
+	};
+};
+//#endregion
+export { mount };

package/lib/node-server/conninfo.d.ts

@@ -1,4 +1,4 @@
-import { r as GetConnInfo } from "../types-CDO6I3B0.js";
+import { r as GetConnInfo } from "../types-ZM9gIiKh.js";
 
 //#region ../../plugins/acryl-node-server/src/adapter/conninfo.d.ts
 /**

package/lib/node-server/serve-static.d.ts

@@ -1,4 +1,4 @@
-import { I as MiddlewareHandler, _ as Env, t as Context } from "../context-Bm7rI-oK.js";
+import { I as MiddlewareHandler, _ as Env, t as Context } from "../context-B5Y1lLha.js";
 
 //#region ../../plugins/acryl-node-server/src/adapter/serve-static.d.ts
 type ServeStaticOptions<E extends Env = Env> = {

package/lib/node-server.d.ts

@@ -1,4 +1,4 @@
-import { n as UpgradeWebSocket } from "./index-UTBmM3GX.js";
+import { n as UpgradeWebSocket } from "./index-Kqou8Fjh.js";
 import { ServeStaticOptions, serveStatic } from "./node-server/serve-static.js";
 import { getConnInfo } from "./node-server/conninfo.js";
 import { AddressInfo } from "node:net";

package/lib/pattern-router-HZxjDGEQ.js

@@ -0,0 +1,41 @@
+import { UnsupportedPathError } from "./router.js";
+//#region ../../plugins/acryl-router/src/core/router/pattern-router/router.ts
+const emptyParams = Object.create(null);
+var PatternRouter = class {
+	name = "PatternRouter";
+	#routes = [];
+	add(method, path, handler) {
+		const suffix = path.endsWith("/*") ? "(?:$|/)" : path.endsWith("*") ? "" : "/?$";
+		path = path.replace(/\*$/, "");
+		if (path.at(-1) === "?") {
+			path = path.slice(0, -1);
+			this.add(method, path.replace(/\/[^/]+$/, ""), handler);
+		}
+		const parts = (path.match(/\/?(:\w+(?:{(?:(?:{[\d,]+})|[^}])+})?)|\/?[^\/\?]+/g) || []).map((part) => {
+			const match = part.match(/^\/:([^{]+)(?:{(.*)})?/);
+			return match ? `/(?<${match[1]}>${match[2] || "[^/]+"})` : part === "/*" ? "/[^/]+" : part.replace(/[.\\+*[^\]$()]/g, "\\$&");
+		});
+		try {
+			this.#routes.push([
+				new RegExp(`^${parts.join("")}${suffix}`),
+				method,
+				handler
+			]);
+		} catch {
+			throw new UnsupportedPathError();
+		}
+	}
+	match(method, path) {
+		const handlers = [];
+		for (let i = 0, len = this.#routes.length; i < len; i++) {
+			const [pattern, routeMethod, handler] = this.#routes[i];
+			if (routeMethod === method || routeMethod === "ALL") {
+				const match = pattern.exec(path);
+				if (match) handlers.push([handler, match.groups || emptyParams]);
+			}
+		}
+		return [handlers];
+	}
+};
+//#endregion
+export { PatternRouter as t };

package/lib/powered-by.d.ts

@@ -1,4 +1,4 @@
-import { I as MiddlewareHandler } from "./context-Bm7rI-oK.js";
+import { I as MiddlewareHandler } from "./context-B5Y1lLha.js";
 
 //#region ../../plugins/acryl-router/src/core/middleware/powered-by/index.d.ts
 type PoweredByOptions = {

package/lib/pretty-json.d.ts

@@ -1,4 +1,4 @@
-import { I as MiddlewareHandler } from "./context-Bm7rI-oK.js";
+import { I as MiddlewareHandler } from "./context-B5Y1lLha.js";
 
 //#region ../../plugins/acryl-router/src/core/middleware/pretty-json/index.d.ts
 interface PrettyOptions {

package/lib/proxy.d.ts

@@ -0,0 +1,72 @@
+import { r as RequestHeader } from "./headers-tu2YYN8T.js";
+import { c as HeadersInit } from "./types-D9DEXMjE.js";
+
+//#region ../../plugins/acryl-router/src/core/helper/proxy/index.d.ts
+interface ProxyRequestInit extends Omit<RequestInit, 'headers'> {
+  raw?: Request;
+  headers?: HeadersInit | [string, string][] | Record<RequestHeader, string | undefined> | Record<string, string | undefined>;
+  customFetch?: (request: Request) => Promise<Response>;
+  /**
+   * Enable strict RFC 9110 compliance for Connection header processing.
+   *
+   * - `false` (default): Ignores Connection header to prevent potential
+   *   Hop-by-Hop Header Injection attacks. Recommended for untrusted clients.
+   * - `true`: Processes Connection header per RFC 9110 and removes listed headers.
+   *   Only use in trusted environments.
+   *
+   * @default false
+   * @see https://datatracker.ietf.org/doc/html/rfc9110#section-7.6.1
+   */
+  strictConnectionProcessing?: boolean;
+}
+interface ProxyFetch {
+  (input: string | URL | Request, init?: ProxyRequestInit): Promise<Response>;
+}
+/**
+ * Fetch API wrapper for proxy.
+ * The parameters and return value are the same as for `fetch` (except for the proxy-specific options).
+ *
+ * The "Accept-Encoding" header is replaced with an encoding that the current runtime can handle.
+ * Unnecessary response headers are deleted and a Response object is returned that can be returned
+ * as is as a response from the handler.
+ *
+ * @example
+ * ```ts
+ * app.get('/proxy/:path', (c) => {
+ *   return proxy(`http://${originServer}/${c.req.param('path')}`, {
+ *     headers: {
+ *       ...c.req.header(), // optional, specify only when forwarding all the request data (including credentials) is necessary.
+ *       'X-Forwarded-For': '127.0.0.1',
+ *       'X-Forwarded-Host': c.req.header('host'),
+ *       Authorization: undefined, // do not propagate request headers contained in c.req.header('Authorization')
+ *     },
+ *   }).then((res) => {
+ *     res.headers.delete('Set-Cookie')
+ *     return res
+ *   })
+ * })
+ *
+ * app.all('/proxy/:path', (c) => {
+ *   return proxy(`http://${originServer}/${c.req.param('path')}`, {
+ *     ...c.req, // optional, specify only when forwarding all the request data (including credentials) is necessary.
+ *     headers: {
+ *       ...c.req.header(),
+ *       'X-Forwarded-For': '127.0.0.1',
+ *       'X-Forwarded-Host': c.req.header('host'),
+ *       Authorization: undefined, // do not propagate request headers contained in c.req.header('Authorization')
+ *     },
+ *   })
+ * })
+ *
+ * // Strict RFC compliance mode (use only in trusted environments)
+ * app.get('/internal-proxy/:path', (c) => {
+ *   return proxy(`http://${internalServer}/${c.req.param('path')}`, {
+ *     ...c.req,
+ *     strictConnectionProcessing: true,
+ *   })
+ * })
+ * ```
+ */
+declare const proxy: ProxyFetch;
+//#endregion
+export { proxy };

package/lib/proxy.js

@@ -0,0 +1,121 @@
+import { HTTPException } from "./http-exception.js";
+//#region ../../plugins/acryl-router/src/core/helper/proxy/index.ts
+/**
+* @module
+* Proxy Helper for Acryl.
+*/
+const hopByHopHeaders = [
+	"connection",
+	"keep-alive",
+	"proxy-authenticate",
+	"proxy-authorization",
+	"te",
+	"trailer",
+	"transfer-encoding",
+	"upgrade"
+];
+const ALLOWED_TOKEN_PATTERN = /^[!#$%&'*+\-.0-9A-Z^_`a-z|~]+$/;
+const buildRequestInitFromRequest = (request, strictConnectionProcessing) => {
+	if (!request) return {};
+	const headers = new Headers(request.headers);
+	if (strictConnectionProcessing) {
+		const connectionValue = headers.get("connection");
+		if (connectionValue) {
+			const headerNames = connectionValue.split(",").map((h) => h.trim());
+			const invalidHeaders = headerNames.filter((h) => !ALLOWED_TOKEN_PATTERN.test(h));
+			if (invalidHeaders.length > 0) throw new HTTPException(400, { message: `Invalid Connection header value: ${invalidHeaders.join(", ")}` });
+			headerNames.forEach((headerName) => {
+				headers.delete(headerName);
+			});
+		}
+	}
+	hopByHopHeaders.forEach((header) => {
+		headers.delete(header);
+	});
+	return {
+		method: request.method,
+		body: request.body,
+		duplex: request.body ? "half" : void 0,
+		headers,
+		signal: request.signal
+	};
+};
+const preprocessRequestInit = (requestInit) => {
+	if (!requestInit.headers || Array.isArray(requestInit.headers) || requestInit.headers instanceof Headers) return requestInit;
+	const headers = new Headers();
+	for (const [key, value] of Object.entries(requestInit.headers)) if (value == null) headers.delete(key);
+	else headers.set(key, value);
+	requestInit.headers = headers;
+	return requestInit;
+};
+/**
+* Fetch API wrapper for proxy.
+* The parameters and return value are the same as for `fetch` (except for the proxy-specific options).
+*
+* The "Accept-Encoding" header is replaced with an encoding that the current runtime can handle.
+* Unnecessary response headers are deleted and a Response object is returned that can be returned
+* as is as a response from the handler.
+*
+* @example
+* ```ts
+* app.get('/proxy/:path', (c) => {
+*   return proxy(`http://${originServer}/${c.req.param('path')}`, {
+*     headers: {
+*       ...c.req.header(), // optional, specify only when forwarding all the request data (including credentials) is necessary.
+*       'X-Forwarded-For': '127.0.0.1',
+*       'X-Forwarded-Host': c.req.header('host'),
+*       Authorization: undefined, // do not propagate request headers contained in c.req.header('Authorization')
+*     },
+*   }).then((res) => {
+*     res.headers.delete('Set-Cookie')
+*     return res
+*   })
+* })
+*
+* app.all('/proxy/:path', (c) => {
+*   return proxy(`http://${originServer}/${c.req.param('path')}`, {
+*     ...c.req, // optional, specify only when forwarding all the request data (including credentials) is necessary.
+*     headers: {
+*       ...c.req.header(),
+*       'X-Forwarded-For': '127.0.0.1',
+*       'X-Forwarded-Host': c.req.header('host'),
+*       Authorization: undefined, // do not propagate request headers contained in c.req.header('Authorization')
+*     },
+*   })
+* })
+*
+* // Strict RFC compliance mode (use only in trusted environments)
+* app.get('/internal-proxy/:path', (c) => {
+*   return proxy(`http://${internalServer}/${c.req.param('path')}`, {
+*     ...c.req,
+*     strictConnectionProcessing: true,
+*   })
+* })
+* ```
+*/
+const proxy = async (input, proxyInit) => {
+	const { raw, customFetch, strictConnectionProcessing = false, ...requestInit } = proxyInit instanceof Request ? { raw: proxyInit } : proxyInit ?? {};
+	const req = new Request(input, {
+		...buildRequestInitFromRequest(raw, strictConnectionProcessing),
+		...preprocessRequestInit(requestInit)
+	});
+	req.headers.delete("accept-encoding");
+	const res = await (customFetch || fetch)(req);
+	const resHeaders = new Headers(res.headers);
+	const connectionValue = resHeaders.get("connection");
+	if (connectionValue) connectionValue.split(",").map((h) => h.trim()).filter((h) => ALLOWED_TOKEN_PATTERN.test(h)).forEach((h) => resHeaders.delete(h));
+	hopByHopHeaders.forEach((header) => {
+		resHeaders.delete(header);
+	});
+	if (resHeaders.has("content-encoding")) {
+		resHeaders.delete("content-encoding");
+		resHeaders.delete("content-length");
+	}
+	return new Response(res.body, {
+		status: res.status,
+		statusText: res.statusText,
+		headers: resHeaders
+	});
+};
+//#endregion
+export { proxy };

package/lib/quick.d.ts

@@ -0,0 +1,8 @@
+import { $ as Acryl$1, J as Schema, _ as Env, et as AcrylOptions, h as BlankSchema, p as BlankEnv } from "./context-B5Y1lLha.js";
+
+//#region ../../plugins/acryl-router/src/core/preset/quick.d.ts
+declare class Acryl<E extends Env = BlankEnv, S extends Schema = BlankSchema, BasePath extends string = '/'> extends Acryl$1<E, S, BasePath> {
+  constructor(options?: AcrylOptions<E>);
+}
+//#endregion
+export { Acryl };

package/lib/quick.js

@@ -0,0 +1,17 @@
+import { AcrylBase as Acryl$1 } from "./acryl-base.js";
+import { t as SmartRouter } from "./smart-router-C5CZ5XSM.js";
+import { t as TrieRouter } from "./trie-router-CfFbapzL.js";
+import { t as LinearRouter } from "./linear-router-C3FPib6h.js";
+//#region ../../plugins/acryl-router/src/core/preset/quick.ts
+/**
+* @module
+* The preset that uses `LinearRouter`.
+*/
+var Acryl = class extends Acryl$1 {
+	constructor(options = {}) {
+		super(options);
+		this.router = new SmartRouter({ routers: [new LinearRouter(), new TrieRouter()] });
+	}
+};
+//#endregion
+export { Acryl };

package/lib/request-id.d.ts

@@ -1,4 +1,4 @@
-import { I as MiddlewareHandler, t as Context } from "./context-Bm7rI-oK.js";
+import { I as MiddlewareHandler, t as Context } from "./context-B5Y1lLha.js";
 
 //#region ../../plugins/acryl-router/src/core/middleware/request-id/request-id.d.ts
 type RequestIdVariables = {

package/lib/request.d.ts

@@ -1,2 +1,2 @@
-import { o as AcrylRequest, s as cloneRawRequest } from "./context-Bm7rI-oK.js";
+import { o as AcrylRequest, s as cloneRawRequest } from "./context-B5Y1lLha.js";
 export { AcrylRequest, cloneRawRequest };

package/lib/route.d.ts

@@ -1,4 +1,4 @@
-import { q as RouterRoute, t as Context } from "./context-Bm7rI-oK.js";
+import { q as RouterRoute, t as Context } from "./context-B5Y1lLha.js";
 
 //#region ../../plugins/acryl-router/src/core/helper/route/index.d.ts
 /**

package/lib/router/linear-router.js

@@ -1,96 +1,2 @@
-import { checkOptionalParameter } from "../utils/url.js";
-import { UnsupportedPathError } from "../router.js";
-//#region ../../plugins/acryl-router/src/core/router/linear-router/router.ts
-const emptyParams = Object.create(null);
-const splitPathRe = /\/(:\w+(?:{(?:(?:{[\d,]+})|[^}])+})?)|\/[^\/\?]+|(\?)/g;
-const splitByStarRe = /\*/;
-var LinearRouter = class {
-	name = "LinearRouter";
-	#routes = [];
-	add(method, path, handler) {
-		for (let i = 0, paths = checkOptionalParameter(path) || [path], len = paths.length; i < len; i++) this.#routes.push([
-			method,
-			paths[i],
-			handler
-		]);
-	}
-	match(method, path) {
-		const handlers = [];
-		ROUTES_LOOP: for (let i = 0, len = this.#routes.length; i < len; i++) {
-			const [routeMethod, routePath, handler] = this.#routes[i];
-			if (routeMethod === method || routeMethod === "ALL") {
-				if (routePath === "*" || routePath === "/*") {
-					handlers.push([handler, emptyParams]);
-					continue;
-				}
-				const hasStar = routePath.indexOf("*") !== -1;
-				const hasLabel = routePath.indexOf(":") !== -1;
-				if (!hasStar && !hasLabel) {
-					if (routePath === path || routePath + "/" === path) handlers.push([handler, emptyParams]);
-				} else if (hasStar && !hasLabel) {
-					const endsWithStar = routePath.charCodeAt(routePath.length - 1) === 42;
-					const endsWithSlashStar = routePath.endsWith("/*");
-					const parts = (endsWithStar ? routePath.slice(0, endsWithSlashStar ? -2 : -1) : routePath).split(splitByStarRe);
-					const lastIndex = parts.length - 1;
-					for (let j = 0, pos = 0, len = parts.length; j < len; j++) {
-						const part = parts[j];
-						if (path.indexOf(part, pos) !== pos) continue ROUTES_LOOP;
-						pos += part.length;
-						if (j === lastIndex) {
-							if (endsWithSlashStar) {
-								if (pos !== path.length && path.charCodeAt(pos) !== 47) continue ROUTES_LOOP;
-							} else if (!endsWithStar && pos !== path.length && !(pos === path.length - 1 && path.charCodeAt(pos) === 47)) continue ROUTES_LOOP;
-						} else {
-							const index = path.indexOf("/", pos);
-							if (index === -1) continue ROUTES_LOOP;
-							pos = index;
-						}
-					}
-					handlers.push([handler, emptyParams]);
-				} else if (hasLabel && !hasStar) {
-					const params = Object.create(null);
-					const parts = routePath.match(splitPathRe);
-					const lastIndex = parts.length - 1;
-					for (let j = 0, pos = 0, len = parts.length; j < len; j++) {
-						if (pos === -1 || pos >= path.length) continue ROUTES_LOOP;
-						const part = parts[j];
-						if (part.charCodeAt(1) === 58) {
-							if (path.charCodeAt(pos) !== 47) continue ROUTES_LOOP;
-							let name = part.slice(2);
-							let value;
-							if (name.charCodeAt(name.length - 1) === 125) {
-								const openBracePos = name.indexOf("{");
-								const next = parts[j + 1];
-								const lookahead = next && next[1] !== ":" && next[1] !== "*" ? `(?=${next})` : "";
-								const pattern = name.slice(openBracePos + 1, -1) + lookahead;
-								const restPath = path.slice(pos + 1);
-								const match = new RegExp(pattern, "d").exec(restPath);
-								if (!match || match.indices[0][0] !== 0 || match.indices[0][1] === 0) continue ROUTES_LOOP;
-								name = name.slice(0, openBracePos);
-								value = restPath.slice(...match.indices[0]);
-								pos += match.indices[0][1] + 1;
-							} else {
-								let endValuePos = path.indexOf("/", pos + 1);
-								if (endValuePos === -1) endValuePos = path.length;
-								if (endValuePos === pos + 1) continue ROUTES_LOOP;
-								value = path.slice(pos + 1, endValuePos);
-								pos = endValuePos;
-							}
-							params[name] ||= value;
-						} else {
-							if (path.indexOf(part, pos) !== pos) continue ROUTES_LOOP;
-							pos += part.length;
-						}
-						if (j === lastIndex) {
-							if (pos !== path.length && !(pos === path.length - 1 && path.charCodeAt(pos) === 47)) continue ROUTES_LOOP;
-						}
-					}
-					handlers.push([handler, params]);
-				} else if (hasLabel && hasStar) throw new UnsupportedPathError();
-			}
-		}
-		return [handlers];
-	}
-};
-//#endregion
+import { t as LinearRouter } from "../linear-router-C3FPib6h.js";
 export { LinearRouter };

package/lib/router/pattern-router.js

@@ -1,41 +1,2 @@
-import { UnsupportedPathError } from "../router.js";
-//#region ../../plugins/acryl-router/src/core/router/pattern-router/router.ts
-const emptyParams = Object.create(null);
-var PatternRouter = class {
-	name = "PatternRouter";
-	#routes = [];
-	add(method, path, handler) {
-		const suffix = path.endsWith("/*") ? "(?:$|/)" : path.endsWith("*") ? "" : "/?$";
-		path = path.replace(/\*$/, "");
-		if (path.at(-1) === "?") {
-			path = path.slice(0, -1);
-			this.add(method, path.replace(/\/[^/]+$/, ""), handler);
-		}
-		const parts = (path.match(/\/?(:\w+(?:{(?:(?:{[\d,]+})|[^}])+})?)|\/?[^\/\?]+/g) || []).map((part) => {
-			const match = part.match(/^\/:([^{]+)(?:{(.*)})?/);
-			return match ? `/(?<${match[1]}>${match[2] || "[^/]+"})` : part === "/*" ? "/[^/]+" : part.replace(/[.\\+*[^\]$()]/g, "\\$&");
-		});
-		try {
-			this.#routes.push([
-				new RegExp(`^${parts.join("")}${suffix}`),
-				method,
-				handler
-			]);
-		} catch {
-			throw new UnsupportedPathError();
-		}
-	}
-	match(method, path) {
-		const handlers = [];
-		for (let i = 0, len = this.#routes.length; i < len; i++) {
-			const [pattern, routeMethod, handler] = this.#routes[i];
-			if (routeMethod === method || routeMethod === "ALL") {
-				const match = pattern.exec(path);
-				if (match) handlers.push([handler, match.groups || emptyParams]);
-			}
-		}
-		return [handlers];
-	}
-};
-//#endregion
+import { t as PatternRouter } from "../pattern-router-HZxjDGEQ.js";
 export { PatternRouter };

package/lib/schema-validator.d.ts

@@ -1,4 +1,4 @@
-import { I as MiddlewareHandler, Z as ValidationTargets, _ as Env } from "./context-Bm7rI-oK.js";
+import { I as MiddlewareHandler, Z as ValidationTargets, _ as Env } from "./context-B5Y1lLha.js";
 
 //#region ../../plugins/acryl-router/src/helpers/schema-validator.d.ts
 /** The slice of the Standard Schema interface this needs; Schemastery (what Cordis uses), Zod and Valibot all implement it. */

package/lib/secure-headers.d.ts

@@ -1,4 +1,4 @@
-import { I as MiddlewareHandler, t as Context } from "./context-Bm7rI-oK.js";
+import { I as MiddlewareHandler, t as Context } from "./context-B5Y1lLha.js";
 
 //#region ../../plugins/acryl-router/src/core/middleware/secure-headers/permissions-policy.d.ts
 type PermissionsPolicyDirective = StandardizedFeatures | ProposedFeatures | ExperimentalFeatures;

package/lib/serve-static.d.ts

@@ -1,4 +1,4 @@
-import { I as MiddlewareHandler, _ as Env, i as Data, t as Context } from "./context-Bm7rI-oK.js";
+import { I as MiddlewareHandler, _ as Env, i as Data, t as Context } from "./context-B5Y1lLha.js";
 
 //#region ../../plugins/acryl-router/src/core/middleware/serve-static/index.d.ts
 type ServeStaticOptions<E extends Env = Env> = {

package/lib/streaming.d.ts

@@ -1,4 +1,4 @@
-import { t as Context } from "./context-Bm7rI-oK.js";
+import { t as Context } from "./context-B5Y1lLha.js";
 import { t as StreamingApi } from "./stream-CPdqZ0Fp.js";
 
 //#region ../../plugins/acryl-router/src/core/helper/streaming/stream.d.ts

package/lib/testing.d.ts

@@ -1,7 +1,7 @@
-import { J as Schema, a as ExecutionContext } from "./context-Bm7rI-oK.js";
-import { T as UnionToIntersection } from "./types-CwrQjlaM.js";
-import { t as Acryl } from "./app-CmAYW1Al.js";
-import { i as ClientRequestOptions, n as Client } from "./types-CHesD1KG.js";
+import { J as Schema, a as ExecutionContext } from "./context-B5Y1lLha.js";
+import { E as UnionToIntersection } from "./types-D9DEXMjE.js";
+import { t as Acryl } from "./app-BdrVHBlJ.js";
+import { i as ClientRequestOptions, n as Client } from "./types-Bd29gh2o.js";
 
 //#region ../../plugins/acryl-router/src/core/helper/testing/index.d.ts
 type ExtractEnv<T> = T extends Acryl<infer E, Schema, string> ? E : never;

package/lib/timeout.d.ts

@@ -1,4 +1,4 @@
-import { I as MiddlewareHandler, t as Context } from "./context-Bm7rI-oK.js";
+import { I as MiddlewareHandler, t as Context } from "./context-B5Y1lLha.js";
 import { HTTPException } from "./http-exception.js";
 
 //#region ../../plugins/acryl-router/src/core/middleware/timeout/index.d.ts

package/lib/timing.d.ts

@@ -1,4 +1,4 @@
-import { I as MiddlewareHandler, t as Context } from "./context-Bm7rI-oK.js";
+import { I as MiddlewareHandler, t as Context } from "./context-B5Y1lLha.js";
 
 //#region ../../plugins/acryl-router/src/core/middleware/timing/timing.d.ts
 type TimingVariables = {

package/lib/tiny.d.ts

@@ -0,0 +1,8 @@
+import { $ as Acryl$1, J as Schema, _ as Env, et as AcrylOptions, h as BlankSchema, p as BlankEnv } from "./context-B5Y1lLha.js";
+
+//#region ../../plugins/acryl-router/src/core/preset/tiny.d.ts
+declare class Acryl<E extends Env = BlankEnv, S extends Schema = BlankSchema, BasePath extends string = '/'> extends Acryl$1<E, S, BasePath> {
+  constructor(options?: AcrylOptions<E>);
+}
+//#endregion
+export { Acryl };

package/lib/tiny.js

@@ -0,0 +1,15 @@
+import { AcrylBase as Acryl$1 } from "./acryl-base.js";
+import { t as PatternRouter } from "./pattern-router-HZxjDGEQ.js";
+//#region ../../plugins/acryl-router/src/core/preset/tiny.ts
+/**
+* @module
+* The preset that uses `PatternRouter`.
+*/
+var Acryl = class extends Acryl$1 {
+	constructor(options = {}) {
+		super(options);
+		this.router = new PatternRouter();
+	}
+};
+//#endregion
+export { Acryl };