acrylblends 1.0.4 → 1.0.5

package/docs/framework/agents/index.md

@@ -35,18 +35,20 @@ See [Acryl in a Cordis app](../cordis/acryl-in-a-cordis-app.md), [Plugin lifecyc
 
 ## The agent panel and the terminals
 
-The panel is a chat button on every page of the running app, and `driver-pty` adds real terminals to it. Both are **development only** (see [what runs in production](../guides/production.md)). They need the rows of the `agent` template (`agent` and `extensions`, with the `model`, `tools` and `memory` the agent brings), so start from that template:
+The panel is a chat button on every page of the running app. **A new app from the `agent` template has it** (`npm create acrylblends@latest my-app agent`), and `driver-pty` adds real terminals to it. Both are **development only** (see [what runs in production](../guides/production.md)).
 
 ```sh
 npm create acrylblends@latest my-app agent
 cd my-app
 npm install
-npx acrylblends add agent-panel driver-pty
+npm run dev          # the panel is the button at the corner of the page
+npx acrylblends add driver-pty   # optional: real terminals (pty:claude, pty:codex, pty:pi) in the panel
 npm install
-npm run dev
 ```
 
-- `add` puts the `agent-panel` row (and `driver-pty`'s after it) in `blend.yaml` before the `routes` row and registers both in `src/app.ts`. On an app without the `agent` and `extensions` rows, such as `blank`, it refuses before it copies anything and says which rows are missing.
+- The panel needs the `agent` and `extensions` rows, which only the `agent` template has: `add agent-panel` on an app without them (a `blank` app) refuses before it copies anything and says which rows are missing, and on an `agent` app it says the panel is already there. An agent-template app made before 1.0.5 gets it with `npx acrylblends add agent-panel`.
+- `add driver-pty` puts the driver's row after the panel's in `blend.yaml` and registers it in `src/app.ts`.
+- A **run belongs to the app, not to the page**: when the page reloads (the door reloads it after a plugin change) the panel shows the question and the events so far and follows the run to its end; **Stop** is the only thing that cancels it.
 - **The panel's coding agents are yours.** `claude`, `codex` and `pi` run on the machine that runs the app, in the app folder, with the login of the person who started it: `claude` and `codex` use their own signed-in sessions, and `pi` is offered when `DEEPSEEK_API_KEY` is set or `pi` has stored a DeepSeek login (`~/.pi/agent/auth.json`, read from the `HOME` of the process that runs the app: an app started under another `HOME` does not see the login, and the panel then lists `pty:pi` but no chat `pi`). A program that is not installed, or is not logged in, is not offered; nothing is shared between machines, and a workshop laptop needs its own login. The panel's own `agent` (the offline scripted one) needs none.
 - `pi` has to be an executable on the `PATH`; a shell function that wraps the binary is fine as long as the binary itself is found by `which pi`.
 - `driver-pty` brings `node-pty`, which ships prebuilt binaries for macOS, Windows and Linux. npm 11 and pnpm warn that its install script was not run (they ask you to approve dependency install scripts); you can ignore the warning. If no `pty:` terminal is offered and the app prints why at start, approve and rebuild: `npm approve-scripts node-pty`, then `npm rebuild node-pty` (pnpm: `pnpm approve-builds`).

package/lib/accept-CNNHu4Cf.js

@@ -0,0 +1,193 @@
+//#region ../../plugins/acryl-router/src/core/utils/accept.ts
+const isWhitespace = (char) => char === 32 || char === 9 || char === 10 || char === 13;
+const consumeWhitespace = (acceptHeader, startIndex) => {
+	while (startIndex < acceptHeader.length) {
+		if (!isWhitespace(acceptHeader.charCodeAt(startIndex))) break;
+		startIndex++;
+	}
+	return startIndex;
+};
+const ignoreTrailingWhitespace = (acceptHeader, startIndex) => {
+	while (startIndex > 0) {
+		if (!isWhitespace(acceptHeader.charCodeAt(startIndex - 1))) break;
+		startIndex--;
+	}
+	return startIndex;
+};
+const skipInvalidParam = (acceptHeader, startIndex) => {
+	while (startIndex < acceptHeader.length) {
+		const char = acceptHeader.charCodeAt(startIndex);
+		if (char === 59) return [startIndex + 1, true];
+		if (char === 44) return [startIndex + 1, false];
+		startIndex++;
+	}
+	return [startIndex, false];
+};
+const skipInvalidAcceptValue = (acceptHeader, startIndex) => {
+	let i = startIndex;
+	let inQuotes = false;
+	while (i < acceptHeader.length) {
+		const char = acceptHeader.charCodeAt(i);
+		if (inQuotes && char === 92) i++;
+		else if (char === 34) inQuotes = !inQuotes;
+		else if (!inQuotes && char === 44) return i + 1;
+		i++;
+	}
+	return i;
+};
+const getNextParam = (acceptHeader, startIndex) => {
+	startIndex = consumeWhitespace(acceptHeader, startIndex);
+	let i = startIndex;
+	let key;
+	let value;
+	let hasNext = false;
+	while (i < acceptHeader.length) {
+		const char = acceptHeader.charCodeAt(i);
+		if (char === 61) {
+			key = acceptHeader.slice(startIndex, ignoreTrailingWhitespace(acceptHeader, i));
+			i++;
+			break;
+		}
+		if (char === 59) return [
+			i + 1,
+			void 0,
+			void 0,
+			true
+		];
+		if (char === 44) return [
+			i + 1,
+			void 0,
+			void 0,
+			false
+		];
+		i++;
+	}
+	if (key === void 0) return [
+		i,
+		void 0,
+		void 0,
+		false
+	];
+	i = consumeWhitespace(acceptHeader, i);
+	if (acceptHeader.charCodeAt(i) === 61) {
+		const skipResult = skipInvalidParam(acceptHeader, i + 1);
+		return [
+			skipResult[0],
+			key,
+			void 0,
+			skipResult[1]
+		];
+	}
+	let inQuotes = false;
+	const paramStartIndex = i;
+	while (i < acceptHeader.length) {
+		const char = acceptHeader.charCodeAt(i);
+		if (inQuotes && char === 92) i++;
+		else if (char === 34) {
+			if (inQuotes) {
+				let nextIndex = consumeWhitespace(acceptHeader, i + 1);
+				const nextChar = acceptHeader.charCodeAt(nextIndex);
+				if (nextIndex < acceptHeader.length && !(nextChar === 59 || nextChar === 44)) {
+					const skipResult = skipInvalidParam(acceptHeader, nextIndex);
+					return [
+						skipResult[0],
+						key,
+						void 0,
+						skipResult[1]
+					];
+				}
+				value = acceptHeader.slice(paramStartIndex + 1, i);
+				if (value.includes("\\")) value = value.replace(/\\(.)/g, "$1");
+				if (nextChar === 44) return [
+					nextIndex + 1,
+					key,
+					value,
+					false
+				];
+				if (nextChar === 59) {
+					hasNext = true;
+					nextIndex++;
+				}
+				i = nextIndex;
+				break;
+			}
+			inQuotes = true;
+		} else if (!inQuotes && (char === 59 || char === 44)) {
+			value = acceptHeader.slice(paramStartIndex, ignoreTrailingWhitespace(acceptHeader, i));
+			if (char === 59) hasNext = true;
+			i++;
+			break;
+		}
+		i++;
+	}
+	return [
+		i,
+		key,
+		value ?? acceptHeader.slice(paramStartIndex, ignoreTrailingWhitespace(acceptHeader, i)),
+		hasNext
+	];
+};
+const getNextAcceptValue = (acceptHeader, startIndex) => {
+	const accept = {
+		type: "",
+		params: Object.create(null),
+		q: 1
+	};
+	startIndex = consumeWhitespace(acceptHeader, startIndex);
+	let i = startIndex;
+	while (i < acceptHeader.length) {
+		const char = acceptHeader.charCodeAt(i);
+		if (char === 59 || char === 44) {
+			accept.type = acceptHeader.slice(startIndex, ignoreTrailingWhitespace(acceptHeader, i));
+			i++;
+			if (char === 44) return [i, accept.type ? accept : void 0];
+			if (!accept.type) return [skipInvalidAcceptValue(acceptHeader, i), void 0];
+			break;
+		}
+		i++;
+	}
+	if (!accept.type) {
+		accept.type = acceptHeader.slice(startIndex, ignoreTrailingWhitespace(acceptHeader, acceptHeader.length));
+		return [acceptHeader.length, accept.type ? accept : void 0];
+	}
+	let param;
+	let value;
+	let hasNext;
+	while (i < acceptHeader.length) {
+		[i, param, value, hasNext] = getNextParam(acceptHeader, i);
+		if (param && value) accept.params[param] = value;
+		if (!hasNext) break;
+	}
+	return [i, accept];
+};
+const parseAccept = (acceptHeader) => {
+	if (!acceptHeader) return [];
+	const values = [];
+	let i = 0;
+	let accept;
+	let requiresSort = false;
+	let lastAccept;
+	while (i < acceptHeader.length) {
+		[i, accept] = getNextAcceptValue(acceptHeader, i);
+		if (accept) {
+			accept.q = parseQuality(accept.params.q ?? accept.params.Q);
+			values.push(accept);
+			if (lastAccept && lastAccept.q < accept.q) requiresSort = true;
+			lastAccept = accept;
+		}
+	}
+	if (requiresSort) values.sort((a, b) => b.q - a.q);
+	return values;
+};
+const parseQuality = (qVal) => {
+	if (qVal === void 0) return 1;
+	if (qVal === "") return 1;
+	if (qVal === "NaN") return 0;
+	const num = Number(qVal);
+	if (Number.isNaN(num)) return 1;
+	if (num < 0) return 0;
+	if (num > 1) return 1;
+	return num;
+};
+//#endregion
+export { parseAccept as t };

package/lib/{accepts-XBuZPVRI.js → accepts-Btq83xPd.js}

@@ -1,4 +1,4 @@
-import { parseAccept } from "./utils/accept.js";
+import { t as parseAccept } from "./accept-CNNHu4Cf.js";
 //#region ../../plugins/acryl-router/src/core/helper/accepts/accepts.ts
 const matchType = (acceptType, supportedType) => {
 	const accept = acceptType.toLowerCase();

package/lib/accepts.js

@@ -1,2 +1,2 @@
-import { t as accepts } from "./accepts-XBuZPVRI.js";
+import { t as accepts } from "./accepts-Btq83xPd.js";
 export { accepts };

package/lib/acryl-base.js

@@ -1,332 +1,2 @@
-import { t as compose } from "./compose-BuW2B6PZ.js";
-import { getPath, getPathNoStrict, mergePath } from "./utils/url.js";
-import { t as Context } from "./context-DDO0cfuP.js";
-import { METHODS } from "./router.js";
-import { COMPOSED_HANDLER } from "./utils/constants.js";
-//#region ../../plugins/acryl-router/src/core/app-base.ts
-/**
-* @module
-* This module is the base module for the Acryl object.
-*/
-const notFoundHandler = (c) => {
-	return c.text("404 Not Found", 404);
-};
-const errorHandler = (err, c) => {
-	if ("getResponse" in err) {
-		const res = err.getResponse();
-		return c.newResponse(res.body, res);
-	}
-	console.error(err);
-	return c.text("Internal Server Error", 500);
-};
-var Acryl = class Acryl {
-	get;
-	post;
-	put;
-	delete;
-	options;
-	patch;
-	query;
-	all;
-	on;
-	use;
-	router;
-	getPath;
-	_basePath = "/";
-	#path = "/";
-	routes = [];
-	constructor(options = {}) {
-		[...METHODS, "all"].forEach((method) => {
-			this[method] = (args1, ...args) => {
-				const methodName = method.toUpperCase();
-				if (typeof args1 === "string") this.#path = args1;
-				else this.#addRoute(methodName, this.#path, args1);
-				args.forEach((handler) => {
-					this.#addRoute(methodName, this.#path, handler);
-				});
-				return this;
-			};
-		});
-		this.on = (method, path, ...handlers) => {
-			for (const p of [path].flat()) {
-				this.#path = p;
-				for (const m of [method].flat()) {
-					const methodName = m.toUpperCase();
-					for (const handler of handlers) this.#addRoute(methodName, this.#path, handler);
-				}
-			}
-			return this;
-		};
-		this.use = (arg1, ...handlers) => {
-			if (typeof arg1 === "string") this.#path = arg1;
-			else {
-				this.#path = "*";
-				handlers.unshift(arg1);
-			}
-			handlers.forEach((handler) => {
-				this.#addRoute("ALL", this.#path, handler);
-			});
-			return this;
-		};
-		const { strict, ...optionsWithoutStrict } = options;
-		Object.assign(this, optionsWithoutStrict);
-		this.getPath = strict ?? true ? options.getPath ?? getPath : getPathNoStrict;
-	}
-	#clone() {
-		const clone = new Acryl({
-			router: this.router,
-			getPath: this.getPath
-		});
-		clone.errorHandler = this.errorHandler;
-		clone.#notFoundHandler = this.#notFoundHandler;
-		clone.routes = this.routes;
-		return clone;
-	}
-	#notFoundHandler = notFoundHandler;
-	errorHandler = errorHandler;
-	/**
-	* `.route()` allows grouping other Acryl instance in routes.
-	*
-	*
-	* @param {string} path - base Path
-	* @param {Acryl} app - other Acryl instance
-	* @returns {Acryl} routed Acryl instance
-	*
-	* @example
-	* ```ts
-	* const app = new Acryl()
-	* const app2 = new Acryl()
-	*
-	* app2.get("/user", (c) => c.text("user"))
-	* app.route("/api", app2) // GET /api/user
-	* ```
-	*/
-	route(path, app) {
-		const subApp = this.basePath(path);
-		app.routes.map((r) => {
-			let handler;
-			if (app.errorHandler === errorHandler) handler = r.handler;
-			else {
-				handler = async (c, next) => (await compose([], app.errorHandler)(c, () => r.handler(c, next))).res;
-				handler[COMPOSED_HANDLER] = r.handler;
-			}
-			subApp.#addRoute(r.method, r.path, handler, r.basePath);
-		});
-		return this;
-	}
-	/**
-	* `.basePath()` allows base paths to be specified.
-	*
-	*
-	* @param {string} path - base Path
-	* @returns {Acryl} changed Acryl instance
-	*
-	* @example
-	* ```ts
-	* const api = new Acryl().basePath('/api')
-	* ```
-	*/
-	basePath(path) {
-		const subApp = this.#clone();
-		subApp._basePath = mergePath(this._basePath, path);
-		return subApp;
-	}
-	/**
-	* `.onError()` handles an error and returns a customized Response.
-	*
-	*
-	* @param {ErrorHandler} handler - request Handler for error
-	* @returns {Acryl} changed Acryl instance
-	*
-	* @example
-	* ```ts
-	* app.onError((err, c) => {
-	*   console.error(`${err}`)
-	*   return c.text('Custom Error Message', 500)
-	* })
-	* ```
-	*/
-	onError = (handler) => {
-		this.errorHandler = handler;
-		return this;
-	};
-	/**
-	* `.notFound()` allows you to customize a Not Found Response.
-	*
-	*
-	* @param {NotFoundHandler} handler - request handler for not-found
-	* @returns {Acryl} changed Acryl instance
-	*
-	* @example
-	* ```ts
-	* app.notFound((c) => {
-	*   return c.text('Custom 404 Message', 404)
-	* })
-	* ```
-	*/
-	notFound = (handler) => {
-		this.#notFoundHandler = handler;
-		return this;
-	};
-	/**
-	* `.mount()` allows you to mount applications built with other frameworks into your Acryl application.
-	*
-	* @deprecated Use `mount()` from `acryl-router/mount` instead. `.mount()` will be removed in v5.
-	*
-	*
-	* @param {string} path - base Path
-	* @param {Function} applicationHandler - other Request Handler
-	* @param {MountOptions} [options] - options of `.mount()`
-	* @returns {Acryl} mounted Acryl instance
-	*
-	* @example
-	* ```ts
-	* import { Router as IttyRouter } from 'itty-router'
-	* import { Acryl } from 'acrylblends'
-	* // 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.mount('/itty-router', ittyRouter.handle)
-	* ```
-	*
-	* @example
-	* ```ts
-	* const app = new Acryl()
-	* // Send the request to another application without modification.
-	* app.mount('/app', anotherApp, {
-	*   replaceRequest: (req) => req,
-	* })
-	* ```
-	*/
-	mount(path, 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];
-		} : (c) => {
-			let executionContext = void 0;
-			try {
-				executionContext = c.executionCtx;
-			} catch {}
-			return [c.env, executionContext];
-		};
-		replaceRequest ||= (() => {
-			const mergedPath = mergePath(this._basePath, path);
-			const pathPrefixLength = mergedPath === "/" ? 0 : mergedPath.length;
-			return (request) => {
-				const url = new URL(request.url);
-				url.pathname = this.getPath(request).slice(pathPrefixLength) || "/";
-				return new Request(url, request);
-			};
-		})();
-		const handler = async (c, next) => {
-			const res = await applicationHandler(replaceRequest(c.req.raw), ...getOptions(c));
-			if (res) return res;
-			await next();
-		};
-		this.#addRoute("ALL", mergePath(path, "*"), handler);
-		return this;
-	}
-	#addRoute(method, path, handler, baseRoutePath) {
-		path = mergePath(this._basePath, path);
-		const r = {
-			basePath: baseRoutePath !== void 0 ? mergePath(this._basePath, baseRoutePath) : this._basePath,
-			path,
-			method,
-			handler
-		};
-		this.router.add(method, path, [handler, r]);
-		this.routes.push(r);
-	}
-	#handleError(err, c) {
-		if (err instanceof Error) return this.errorHandler(err, c);
-		throw err;
-	}
-	#dispatch(request, executionCtx, env, method) {
-		if (method === "HEAD") return (async () => new Response(null, await this.#dispatch(request, executionCtx, env, "GET")))();
-		const path = this.getPath(request, { env });
-		const matchResult = this.router.match(method, path);
-		const c = new Context(request, {
-			path,
-			matchResult,
-			env,
-			executionCtx,
-			notFoundHandler: this.#notFoundHandler
-		});
-		if (matchResult[0].length === 1) {
-			let res;
-			try {
-				res = matchResult[0][0][0][0](c, async () => {
-					c.res = await this.#notFoundHandler(c);
-				});
-			} catch (err) {
-				return this.#handleError(err, c);
-			}
-			return res instanceof Promise ? res.then((resolved) => resolved || (c.finalized ? c.res : this.#notFoundHandler(c))).catch((err) => this.#handleError(err, c)) : res ?? this.#notFoundHandler(c);
-		}
-		const composed = compose(matchResult[0], this.errorHandler, this.#notFoundHandler);
-		return (async () => {
-			try {
-				const context = await composed(c);
-				if (!context.finalized) throw new Error("Context is not finalized. Did you forget to return a Response object or `await next()`?");
-				return context.res;
-			} catch (err) {
-				return this.#handleError(err, c);
-			}
-		})();
-	}
-	/**
-	* `.fetch()` will be entry point of your app.
-	*
-	*
-	* @param {Request} request - request Object of request
-	* @param {Env} env - env Object
-	* @param {ExecutionContext} executionCtx - context of execution
-	* @returns {Response | Promise<Response>} response of request
-	*
-	*/
-	fetch = (request, ...rest) => {
-		return this.#dispatch(request, rest[1], rest[0], request.method);
-	};
-	/**
-	* `.request()` is a useful method for testing.
-	* You can pass a URL or pathname to send a GET request.
-	* app will return a Response object.
-	* ```ts
-	* test('GET /hello is ok', async () => {
-	*   const res = await app.request('/hello')
-	*   expect(res.status).toBe(200)
-	* })
-	* ```
-	*/
-	request = (input, requestInit, Env, executionCtx) => {
-		if (input instanceof Request) return this.fetch(requestInit ? new Request(input, requestInit) : input, Env, executionCtx);
-		input = input.toString();
-		return this.fetch(new Request(/^https?:\/\//.test(input) ? input : `http://localhost${mergePath("/", input)}`, requestInit), Env, executionCtx);
-	};
-	/**
-	* `.fire()` automatically adds a global fetch event listener.
-	* This can be useful for environments that adhere to the Service Worker API, such as non-ES module Cloudflare Workers.
-	* @deprecated
-	* ACRYL ships no service-worker adapter: mount the app with `ctx.router.route(path, app)` and serve it through an ACRYL adapter instead.
-	* @see https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API
-	* @see https://developers.cloudflare.com/workers/reference/migrate-to-module-workers/
-	*/
-	fire = () => {
-		addEventListener("fetch", (event) => {
-			event.respondWith(this.#dispatch(event.request, event, void 0, event.request.method));
-		});
-	};
-};
-//#endregion
+import { t as Acryl } from "./app-base-CpRMZL4v.js";
 export { Acryl as AcrylBase };

package/lib/adapter-CaZ6FZUU.js

@@ -0,0 +1,37 @@
+//#region ../../plugins/acryl-router/src/core/helper/adapter/index.ts
+const env = (c, runtime) => {
+	const globalEnv = globalThis?.process?.env;
+	runtime ??= getRuntimeKey();
+	return {
+		bun: () => globalEnv,
+		node: () => globalEnv,
+		"edge-light": () => globalEnv,
+		deno: () => {
+			return Deno.env.toObject();
+		},
+		workerd: () => c.env,
+		fastly: () => ({}),
+		other: () => ({})
+	}[runtime]();
+};
+const knownUserAgents = {
+	deno: "Deno",
+	bun: "Bun",
+	workerd: "Cloudflare-Workers",
+	node: "Node.js"
+};
+const getRuntimeKey = () => {
+	const global = globalThis;
+	if (typeof navigator !== "undefined" && typeof navigator.userAgent === "string") {
+		for (const [runtimeKey, userAgent] of Object.entries(knownUserAgents)) if (checkUserAgentEquals(userAgent)) return runtimeKey;
+	}
+	if (typeof global?.EdgeRuntime === "string") return "edge-light";
+	if (global?.fastly !== void 0) return "fastly";
+	if (global?.process?.release?.name === "node") return "node";
+	return "other";
+};
+const checkUserAgentEquals = (platform) => {
+	return navigator.userAgent.startsWith(platform);
+};
+//#endregion
+export { knownUserAgents as i, env as n, getRuntimeKey as r, checkUserAgentEquals as t };

package/lib/adapter.js

@@ -1,37 +1,2 @@
-//#region ../../plugins/acryl-router/src/core/helper/adapter/index.ts
-const env = (c, runtime) => {
-	const globalEnv = globalThis?.process?.env;
-	runtime ??= getRuntimeKey();
-	return {
-		bun: () => globalEnv,
-		node: () => globalEnv,
-		"edge-light": () => globalEnv,
-		deno: () => {
-			return Deno.env.toObject();
-		},
-		workerd: () => c.env,
-		fastly: () => ({}),
-		other: () => ({})
-	}[runtime]();
-};
-const knownUserAgents = {
-	deno: "Deno",
-	bun: "Bun",
-	workerd: "Cloudflare-Workers",
-	node: "Node.js"
-};
-const getRuntimeKey = () => {
-	const global = globalThis;
-	if (typeof navigator !== "undefined" && typeof navigator.userAgent === "string") {
-		for (const [runtimeKey, userAgent] of Object.entries(knownUserAgents)) if (checkUserAgentEquals(userAgent)) return runtimeKey;
-	}
-	if (typeof global?.EdgeRuntime === "string") return "edge-light";
-	if (global?.fastly !== void 0) return "fastly";
-	if (global?.process?.release?.name === "node") return "node";
-	return "other";
-};
-const checkUserAgentEquals = (platform) => {
-	return navigator.userAgent.startsWith(platform);
-};
-//#endregion
+import { i as knownUserAgents, n as env, r as getRuntimeKey, t as checkUserAgentEquals } from "./adapter-CaZ6FZUU.js";
 export { checkUserAgentEquals, env, getRuntimeKey, knownUserAgents };

package/lib/{app-BM0rTCp7.js → app-CQcGWjrk.js}

@@ -1,7 +1,7 @@
-import { AcrylBase as Acryl$1 } from "./acryl-base.js";
-import { i as RegExpRouter } from "./reg-exp-router-DC1R3qoY.js";
-import { t as SmartRouter } from "./smart-router-C5CZ5XSM.js";
-import { t as TrieRouter } from "./trie-router-CfFbapzL.js";
+import { t as Acryl$1 } from "./app-base-CpRMZL4v.js";
+import { i as RegExpRouter } from "./reg-exp-router-C_WV84eV.js";
+import { t as SmartRouter } from "./smart-router-BjxkDQCE.js";
+import { t as TrieRouter } from "./trie-router-JydLKUa2.js";
 //#region ../../plugins/acryl-router/src/core/app.ts
 /**
 * The Acryl class extends the functionality of the AcrylBase class.