acrylblends 0.4.0 → 0.5.0

package/lib/request.js

@@ -0,0 +1,323 @@
+import { HTTPException } from "./http-exception.js";
+import { t as GET_MATCH_RESULT } from "./constants-Dy7ZvN1H.js";
+import { parseBody } from "./utils/body.js";
+import { getQueryParam, getQueryParams, tryDecodeURIComponent } from "./utils/url.js";
+//#region ../../plugins/acryl-router/src/core/request.ts
+var AcrylRequest = class {
+	/**
+	* `.raw` can get the raw Request object.
+	*
+	*
+	* @example
+	* ```ts
+	* // For Cloudflare Workers
+	* app.post('/', async (c) => {
+	*   const metadata = c.req.raw.cf?.hostMetadata?
+	*   ...
+	* })
+	* ```
+	*/
+	raw;
+	#validatedData;
+	#matchResult;
+	routeIndex = 0;
+	/**
+	* `.path` can get the pathname of the request.
+	*
+	*
+	* @example
+	* ```ts
+	* app.get('/about/me', (c) => {
+	*   const pathname = c.req.path // `/about/me`
+	* })
+	* ```
+	*/
+	path;
+	bodyCache = {};
+	constructor(request, path = "/", matchResult = [[]]) {
+		this.raw = request;
+		this.path = path;
+		this.#matchResult = matchResult;
+	}
+	param(key) {
+		return key ? this.#getDecodedParam(key) : this.#getAllDecodedParams();
+	}
+	#getDecodedParam(key) {
+		const paramKey = this.#matchResult[0][this.routeIndex]?.[1][key];
+		const param = this.#getParamValue(paramKey);
+		return param && tryDecodeURIComponent(param);
+	}
+	#getAllDecodedParams() {
+		const decoded = {};
+		const keys = Object.keys(this.#matchResult[0][this.routeIndex]?.[1] ?? {});
+		for (const key of keys) {
+			const value = this.#getParamValue(this.#matchResult[0][this.routeIndex][1][key]);
+			if (value !== void 0) decoded[key] = tryDecodeURIComponent(value);
+		}
+		return decoded;
+	}
+	#getParamValue(paramKey) {
+		return this.#matchResult[1] ? this.#matchResult[1][paramKey] : paramKey;
+	}
+	query(key) {
+		return getQueryParam(this.url, key);
+	}
+	queries(key) {
+		return getQueryParams(this.url, key);
+	}
+	header(name) {
+		if (name) return this.raw.headers.get(name) ?? void 0;
+		const headerData = Object.create(null);
+		this.raw.headers.forEach((value, key) => {
+			headerData[key] = value;
+		});
+		return headerData;
+	}
+	async parseBody(options) {
+		return parseBody(this, options);
+	}
+	#cachedBody = (key) => {
+		const { bodyCache, raw } = this;
+		const cachedBody = bodyCache[key];
+		if (cachedBody) return cachedBody;
+		for (const anyCachedKey in bodyCache) return bodyCache[anyCachedKey].then((body) => {
+			if (anyCachedKey === "json") body = JSON.stringify(body);
+			const contentType = anyCachedKey === "formData" ? void 0 : raw.headers.get("content-type");
+			return new Response(body, { headers: contentType ? { "Content-Type": contentType } : void 0 })[key]();
+		});
+		return bodyCache[key] = raw[key]();
+	};
+	/**
+	* `.json()` can parse Request body of type `application/json`
+	*
+	*
+	* @example
+	* ```ts
+	* app.post('/entry', async (c) => {
+	*   const body = await c.req.json()
+	* })
+	* ```
+	*/
+	json() {
+		return this.#cachedBody("text").then((text) => JSON.parse(text));
+	}
+	/**
+	* `.text()` can parse Request body of type `text/plain`
+	*
+	*
+	* @example
+	* ```ts
+	* app.post('/entry', async (c) => {
+	*   const body = await c.req.text()
+	* })
+	* ```
+	*/
+	text() {
+		return this.#cachedBody("text");
+	}
+	/**
+	* `.arrayBuffer()` parse Request body as an `ArrayBuffer`
+	*
+	*
+	* @example
+	* ```ts
+	* app.post('/entry', async (c) => {
+	*   const body = await c.req.arrayBuffer()
+	* })
+	* ```
+	*/
+	arrayBuffer() {
+		return this.#cachedBody("arrayBuffer");
+	}
+	/**
+	* `.bytes()` parses the request body as a `Uint8Array`.
+	*
+	*
+	* @example
+	* ```ts
+	* app.post('/entry', async (c) => {
+	*   const body = await c.req.bytes()
+	* })
+	* ```
+	*/
+	bytes() {
+		return this.#cachedBody("arrayBuffer").then((buffer) => new Uint8Array(buffer));
+	}
+	/**
+	* Parses the request body as a `Blob`.
+	* @example
+	* ```ts
+	* app.post('/entry', async (c) => {
+	*   const body = await c.req.blob();
+	* });
+	* ```
+	*/
+	blob() {
+		return this.#cachedBody("blob");
+	}
+	/**
+	* Parses the request body as `FormData`.
+	* @example
+	* ```ts
+	* app.post('/entry', async (c) => {
+	*   const body = await c.req.formData();
+	* });
+	* ```
+	*/
+	formData() {
+		return this.#cachedBody("formData");
+	}
+	/**
+	* Adds validated data to the request.
+	*
+	* @param target - The target of the validation.
+	* @param data - The validated data to add.
+	*/
+	addValidatedData(target, data) {
+		(this.#validatedData ??= {})[target] = data;
+	}
+	valid(target) {
+		return this.#validatedData?.[target];
+	}
+	/**
+	* `.url` can get the request url strings.
+	*
+	*
+	* @example
+	* ```ts
+	* app.get('/about/me', (c) => {
+	*   const url = c.req.url // `http://localhost:8787/about/me`
+	*   ...
+	* })
+	* ```
+	*/
+	get url() {
+		return this.raw.url;
+	}
+	/**
+	* `.method` can get the method name of the request.
+	*
+	*
+	* @example
+	* ```ts
+	* app.get('/about/me', (c) => {
+	*   const method = c.req.method // `GET`
+	* })
+	* ```
+	*/
+	get method() {
+		return this.raw.method;
+	}
+	get [GET_MATCH_RESULT]() {
+		return this.#matchResult;
+	}
+	/**
+	* `.matchedRoutes` can return a matched route in the handler
+	*
+	* @deprecated
+	*
+	* Use matchedRoutes helper defined in "acryl-router/route" instead.
+	*
+	*
+	* @example
+	* ```ts
+	* app.use('*', async function logger(c, next) {
+	*   await next()
+	*   c.req.matchedRoutes.forEach(({ handler, method, path }, i) => {
+	*     const name = handler.name || (handler.length < 2 ? '[handler]' : '[middleware]')
+	*     console.log(
+	*       method,
+	*       ' ',
+	*       path,
+	*       ' '.repeat(Math.max(10 - path.length, 0)),
+	*       name,
+	*       i === c.req.routeIndex ? '<- respond from here' : ''
+	*     )
+	*   })
+	* })
+	* ```
+	*/
+	get matchedRoutes() {
+		return this.#matchResult[0].map(([[, route]]) => route);
+	}
+	/**
+	* `.routePath` can retrieve the path registered within the handler
+	*
+	* @deprecated
+	*
+	* Use routePath helper defined in "acryl-router/route" instead.
+	*
+	*
+	* @example
+	* ```ts
+	* app.get('/posts/:id', (c) => {
+	*   return c.json({ path: c.req.routePath })
+	* })
+	* ```
+	*/
+	get routePath() {
+		return this.#matchResult[0].map(([[, route]]) => route)[this.routeIndex].path;
+	}
+};
+/**
+* Clones a AcrylRequest's underlying raw Request object.
+*
+* This utility handles both consumed and unconsumed request bodies:
+* - If the request body hasn't been consumed, it uses the native `clone()` method
+* - If the request body has been consumed, it reconstructs a new Request using cached body data
+*
+* This is particularly useful when you need to:
+* - Process the same request body multiple times
+* - Pass requests to external services after validation
+*
+* @param req - The AcrylRequest object to clone
+* @returns A Promise that resolves to a new Request object with the same properties
+* @throws {HTTPException} If the request body was consumed directly via `req.raw`
+*   without using AcrylRequest methods (e.g., `req.json()`, `req.text()`), making it
+*   impossible to reconstruct the body from cache
+*
+* @example
+* ```ts
+* // Clone after consuming the body (e.g., after validation)
+* app.post('/forward',
+*   validator('json', (data) => data),
+*   async (c) => {
+*     const validated = c.req.valid('json')
+*     // Body has been consumed, but cloneRawRequest still works
+*     const clonedReq = await cloneRawRequest(c.req)
+*     return fetch('http://backend-service.com', clonedReq)
+*   }
+* )
+* ```
+*/
+const cloneRawRequest = async (req) => {
+	if (!req.raw.bodyUsed) return req.raw.clone();
+	const cacheKey = Object.keys(req.bodyCache)[0];
+	if (!cacheKey) throw new HTTPException(500, { message: "Cannot clone request: body was already consumed and not cached. Please use AcrylRequest methods (e.g., req.json(), req.text()) instead of consuming req.raw directly." });
+	let body = await req[cacheKey]();
+	const headers = req.header();
+	if (cacheKey === "json") {
+		body = JSON.stringify(body);
+		delete headers["content-length"];
+	} else if (body instanceof FormData) {
+		delete headers["content-type"];
+		delete headers["content-length"];
+	}
+	const requestInit = {
+		body,
+		cache: req.raw.cache,
+		credentials: req.raw.credentials,
+		headers,
+		integrity: req.raw.integrity,
+		keepalive: req.raw.keepalive,
+		method: req.method,
+		mode: req.raw.mode,
+		redirect: req.raw.redirect,
+		referrer: req.raw.referrer,
+		referrerPolicy: req.raw.referrerPolicy,
+		signal: req.raw.signal
+	};
+	return new Request(req.url, requestInit);
+};
+//#endregion
+export { AcrylRequest, cloneRawRequest };

package/lib/route.d.ts

@@ -0,0 +1,78 @@
+import { q as RouterRoute, t as Context } from "./context-Bm7rI-oK.js";
+
+//#region ../../plugins/acryl-router/src/core/helper/route/index.d.ts
+/**
+ * Get matched routes in the handler
+ *
+ * @param {Context} c - The context object
+ * @returns An array of matched routes
+ *
+ * @example
+ * ```ts
+ * import { matchedRoutes } from 'acrylblends/route'
+ *
+ * app.use('*', async function logger(c, next) {
+ *   await next()
+ *   matchedRoutes(c).forEach(({ handler, method, path }, i) => {
+ *     const name = handler.name || (handler.length < 2 ? '[handler]' : '[middleware]')
+ *     console.log(
+ *       method,
+ *       ' ',
+ *       path,
+ *       ' '.repeat(Math.max(10 - path.length, 0)),
+ *       name,
+ *       i === c.req.routeIndex ? '<- respond from here' : ''
+ *     )
+ *   })
+ * })
+ * ```
+ */
+declare const matchedRoutes: (c: Context) => RouterRoute[];
+/**
+ * Get the route path registered within the handler
+ *
+ * @param {Context} c - The context object
+ * @param {number} index - The index of the route from which to retrieve the path, similar to Array.prototype.at(), where a negative number is the index counted from the end of the matching route. Defaults to the current route index.
+ * @returns The route path registered within the handler
+ *
+ * @example
+ * ```ts
+ * import { routePath } from 'acrylblends/route'
+ *
+ * app.use('*', (c, next) => {
+ *   console.log(routePath(c)) // '*'
+ *   console.log(routePath(c, -1)) // '/posts/:id'
+ *   return next()
+ * })
+ *
+ * app.get('/posts/:id', (c) => {
+ *   return c.text(routePath(c)) // '/posts/:id'
+ * })
+ * ```
+ */
+declare const routePath: (c: Context, index?: number) => string;
+/**
+ * Get the basePath of the as-is route specified by routing.
+ *
+ * @param {Context} c - The context object
+ * @param {number} index - The index of the route from which to retrieve the path, similar to Array.prototype.at(), where a negative number is the index counted from the end of the matching route. Defaults to the current route index.
+ * @returns The basePath of the as-is route specified by routing.
+ *
+ * @example
+ * ```ts
+ * import { baseRoutePath } from 'acrylblends/route'
+ *
+ * const app = new Acryl()
+ *
+ * const subApp = new Acryl()
+ * subApp.get('/posts/:id', (c) => {
+ *   return c.text(baseRoutePath(c)) // '/:sub'
+ * })
+ *
+ * app.route('/:sub', subApp)
+ * ```
+ */
+declare const baseRoutePath: (c: Context, index?: number) => string;
+declare const basePath: (c: Context, index?: number) => string;
+//#endregion
+export { basePath, baseRoutePath, matchedRoutes, routePath };

package/lib/route.js

@@ -0,0 +1,126 @@
+import { t as GET_MATCH_RESULT } from "./constants-Dy7ZvN1H.js";
+import { getPattern, splitRoutingPath } from "./utils/url.js";
+//#region ../../plugins/acryl-router/src/core/helper/route/index.ts
+/**
+* Get matched routes in the handler
+*
+* @param {Context} c - The context object
+* @returns An array of matched routes
+*
+* @example
+* ```ts
+* import { matchedRoutes } from 'acrylblends/route'
+*
+* app.use('*', async function logger(c, next) {
+*   await next()
+*   matchedRoutes(c).forEach(({ handler, method, path }, i) => {
+*     const name = handler.name || (handler.length < 2 ? '[handler]' : '[middleware]')
+*     console.log(
+*       method,
+*       ' ',
+*       path,
+*       ' '.repeat(Math.max(10 - path.length, 0)),
+*       name,
+*       i === c.req.routeIndex ? '<- respond from here' : ''
+*     )
+*   })
+* })
+* ```
+*/
+const matchedRoutes = (c) => c.req[GET_MATCH_RESULT][0].map(([[, route]]) => route);
+/**
+* Get the route path registered within the handler
+*
+* @param {Context} c - The context object
+* @param {number} index - The index of the route from which to retrieve the path, similar to Array.prototype.at(), where a negative number is the index counted from the end of the matching route. Defaults to the current route index.
+* @returns The route path registered within the handler
+*
+* @example
+* ```ts
+* import { routePath } from 'acrylblends/route'
+*
+* app.use('*', (c, next) => {
+*   console.log(routePath(c)) // '*'
+*   console.log(routePath(c, -1)) // '/posts/:id'
+*   return next()
+* })
+*
+* app.get('/posts/:id', (c) => {
+*   return c.text(routePath(c)) // '/posts/:id'
+* })
+* ```
+*/
+const routePath = (c, index) => matchedRoutes(c).at(index ?? c.req.routeIndex)?.path ?? "";
+/**
+* Get the basePath of the as-is route specified by routing.
+*
+* @param {Context} c - The context object
+* @param {number} index - The index of the route from which to retrieve the path, similar to Array.prototype.at(), where a negative number is the index counted from the end of the matching route. Defaults to the current route index.
+* @returns The basePath of the as-is route specified by routing.
+*
+* @example
+* ```ts
+* import { baseRoutePath } from 'acrylblends/route'
+*
+* const app = new Acryl()
+*
+* const subApp = new Acryl()
+* subApp.get('/posts/:id', (c) => {
+*   return c.text(baseRoutePath(c)) // '/:sub'
+* })
+*
+* app.route('/:sub', subApp)
+* ```
+*/
+const baseRoutePath = (c, index) => matchedRoutes(c).at(index ?? c.req.routeIndex)?.basePath ?? "";
+/**
+* Get the basePath with embedded parameters
+*
+* @param {Context} c - The context object
+* @param {number} index - The index of the route from which to retrieve the path, similar to Array.prototype.at(), where a negative number is the index counted from the end of the matching route. Defaults to the current route index.
+* @returns The basePath with embedded parameters.
+*
+* @example
+* ```ts
+* import { basePath } from 'acrylblends/route'
+*
+* const app = new Acryl()
+*
+* const subApp = new Acryl()
+* subApp.get('/posts/:id', (c) => {
+*   return c.text(basePath(c)) // '/requested-sub-app-path'
+* })
+*
+* app.route('/:sub', subApp)
+* ```
+*/
+const basePathCacheMap = /* @__PURE__ */ new WeakMap();
+const basePath = (c, index) => {
+	index ??= c.req.routeIndex;
+	const cache = basePathCacheMap.get(c) || [];
+	if (typeof cache[index] === "string") return cache[index];
+	let result;
+	const rp = baseRoutePath(c, index);
+	if (!/[:*]/.test(rp)) result = rp;
+	else {
+		const paths = splitRoutingPath(rp);
+		const reqPath = c.req.path;
+		let basePathLength = 0;
+		for (let i = 0, len = paths.length; i < len; i++) {
+			const pattern = getPattern(paths[i], paths[i + 1]);
+			if (pattern) {
+				const re = pattern[2] === true || pattern === "*" ? /[^\/]+/ : pattern[2];
+				const restPath = reqPath.substring(basePathLength + 1);
+				const segment = restPath.split("/", 1)[0];
+				basePathLength += (restPath.match(re)?.[0] ?? (re.test(segment) ? segment : "")).length;
+			} else basePathLength += paths[i].length;
+			basePathLength += 1;
+		}
+		result = reqPath.substring(0, basePathLength);
+	}
+	cache[index] = result;
+	basePathCacheMap.set(c, cache);
+	return result;
+};
+//#endregion
+export { basePath, baseRoutePath, matchedRoutes, routePath };

package/lib/router/linear-router.d.ts

@@ -0,0 +1,11 @@
+import { c as Result, l as Router } from "../router-CvUxUTOq.js";
+
+//#region ../../plugins/acryl-router/src/core/router/linear-router/router.d.ts
+declare class LinearRouter<T> implements Router<T> {
+  #private;
+  name: string;
+  add(method: string, path: string, handler: T): void;
+  match(method: string, path: string): Result<T>;
+}
+//#endregion
+export { LinearRouter };

package/lib/router/linear-router.js

@@ -0,0 +1,96 @@
+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
+export { LinearRouter };

package/lib/router/pattern-router.d.ts

@@ -0,0 +1,11 @@
+import { c as Result, l as Router } from "../router-CvUxUTOq.js";
+
+//#region ../../plugins/acryl-router/src/core/router/pattern-router/router.d.ts
+declare class PatternRouter<T> implements Router<T> {
+  #private;
+  name: string;
+  add(method: string, path: string, handler: T): void;
+  match(method: string, path: string): Result<T>;
+}
+//#endregion
+export { PatternRouter };

package/lib/router/pattern-router.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 };