acrylblends 0.6.1 → 0.6.3

package/lib/basic-auth.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-DVQBjuns.js";
 
 //#region ../../plugins/acryl-router/src/core/middleware/basic-auth/index.d.ts
 type MessageFunction = (c: Context) => string | object | Promise<string | object>;

package/lib/bearer-auth.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-DVQBjuns.js";
 
 //#region ../../plugins/acryl-router/src/core/middleware/bearer-auth/index.d.ts
 type MessageFunction = (c: Context) => string | object | Promise<string | object>;

package/lib/body-limit.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-DVQBjuns.js";
 
 //#region ../../plugins/acryl-router/src/core/middleware/body-limit/index.d.ts
 type OnError = (c: Context) => Response | Promise<Response>;

package/lib/cache.d.ts

@@ -0,0 +1,43 @@
+import { I as MiddlewareHandler, t as Context } from "./context-DVQBjuns.js";
+import { c as StatusCode } from "./http-status-DaAwGAFL.js";
+
+//#region ../../plugins/acryl-router/src/core/middleware/cache/index.d.ts
+/**
+ * Cache Middleware for Acryl.
+ *
+ *
+ * @param {Object} options - The options for the cache middleware.
+ * @param {string | Function} options.cacheName - The name of the cache. Can be used to store multiple caches with different identifiers.
+ * @param {boolean} [options.wait=false] - A boolean indicating if Acryl should wait for the Promise of the `cache.put` function to resolve before continuing with the request. Required to be true for the Deno environment.
+ * @param {string} [options.cacheControl] - A string of directives for the `Cache-Control` header.
+ * @param {string | string[]} [options.vary] - Adds the configured request headers to the cache key variants and sets the `Vary` header in the response. If the original response header already contains a `Vary` header, the values are merged, removing any duplicates.
+ * @param {Function} [options.keyGenerator] - Generates keys for every request in the `cacheName` store. This can be used to cache data based on request parameters or context parameters. QUERY keys additionally include a digest of the request content and its representation metadata.
+ * @param {number} [options.maxQueryBodySize=65536] - The maximum QUERY request body size in bytes that can be cached. Larger QUERY requests bypass the cache.
+ * @param {number[]} [options.cacheableStatusCodes=[200]] - An array of status codes that can be cached.
+ * @param {Function | false} [options.onCacheNotAvailable] - A callback invoked with the reason when `globalThis.caches` is not available or QUERY caching cannot use Web Crypto. By default, the reason is logged to the console. Set to `false` to suppress the log, or provide a custom function.
+ * @returns {MiddlewareHandler} The middleware handler function.
+ * @throws {Error} If the `vary` option includes "*".
+ *
+ * @example
+ * ```ts
+ * app.use(
+ *   '*',
+ *   cache({
+ *     cacheName: 'my-app',
+ *     cacheControl: 'max-age=3600',
+ *   })
+ * )
+ * ```
+ */
+declare const cache: (options: {
+  cacheName: string | ((c: Context) => Promise<string> | string);
+  wait?: boolean;
+  cacheControl?: string;
+  vary?: string | string[];
+  keyGenerator?: (c: Context) => Promise<string> | string;
+  maxQueryBodySize?: number;
+  cacheableStatusCodes?: StatusCode[];
+  onCacheNotAvailable?: ((reason: string) => void) | false;
+}) => MiddlewareHandler;
+//#endregion
+export { cache };

package/lib/cache.js

@@ -0,0 +1,169 @@
+import { sha256 } from "./utils/crypto.js";
+import { cloneRawRequest } from "./request.js";
+//#region ../../plugins/acryl-router/src/core/middleware/cache/index.ts
+/**
+* status codes that can be cached by default.
+*/
+const defaultCacheableStatusCodes = [200];
+const defaultMaxQueryBodySize = 64 * 1024;
+const cacheKeyPath = "/.acryl-router/cache";
+const cacheKeyParameter = "__hono_cache_key";
+const cacheMethodKeyParameter = "__hono_cache_method";
+const queryDigestKeyParameter = "__hono_query_digest";
+const cacheVaryKeyParameter = "__hono_cache_vary";
+const queryRepresentationMetadataHeaders = [
+	"content-type",
+	"content-encoding",
+	"content-language",
+	"content-location"
+];
+const shouldSkipCacheControl = (cacheControl) => !!cacheControl && /(?:^|,\s*)(?:private|no-(?:store|cache))(?:\s*(?:=|,|$))/i.test(cacheControl);
+const parseVaryDirectives = (vary) => {
+	if (vary == null) return [];
+	return (Array.isArray(vary) ? vary : vary.split(",")).map((directive) => directive.trim().toLowerCase()).filter(Boolean);
+};
+const createCacheKey = (key, requestUrl, request, varyHeaders) => {
+	const url = new URL(cacheKeyPath, requestUrl);
+	url.searchParams.append(cacheKeyParameter, key);
+	url.searchParams.append(cacheMethodKeyParameter, request.method);
+	if (request.method === "QUERY") url.searchParams.append(queryDigestKeyParameter, request.digest);
+	for (const header of varyHeaders) url.searchParams.append(cacheVaryKeyParameter, JSON.stringify(header));
+	return url.href;
+};
+const shouldSkipCache = (res, optionsVaryDirectives, responseVary) => responseVary.length && (!optionsVaryDirectives || responseVary.some((name) => !optionsVaryDirectives.has(name))) || shouldSkipCacheControl(res.headers.get("Cache-Control")) || res.headers.has("Set-Cookie");
+const reportCacheNotAvailable = (onCacheNotAvailable, reason) => {
+	if (onCacheNotAvailable === false) {} else if (onCacheNotAvailable) onCacheNotAvailable(reason);
+	else console.log(reason);
+};
+const createQueryDigest = async (c, maxQueryBodySize) => {
+	if (!globalThis.crypto?.subtle) return;
+	if (c.req.raw.bodyUsed && Object.keys(c.req.bodyCache)[0] === "formData") return;
+	try {
+		const requestHeaders = c.req.raw.headers;
+		const metadata = new TextEncoder().encode(JSON.stringify(queryRepresentationMetadataHeaders.map((header) => [header, requestHeaders.get(header)])));
+		const body = (await cloneRawRequest(c.req)).body;
+		const chunks = [];
+		let bodySize = 0;
+		if (body) {
+			const reader = body.getReader();
+			for (;;) {
+				const { done, value } = await reader.read();
+				if (done) break;
+				bodySize += value.byteLength;
+				if (bodySize > maxQueryBodySize) {
+					reader.cancel().catch(() => {});
+					return;
+				}
+				chunks.push(value);
+			}
+		}
+		const data = new Uint8Array(metadata.byteLength + bodySize);
+		data.set(metadata);
+		let offset = metadata.byteLength;
+		for (const chunk of chunks) {
+			data.set(chunk, offset);
+			offset += chunk.byteLength;
+		}
+		return await sha256(data) ?? void 0;
+	} catch {
+		return;
+	}
+};
+/**
+* Cache Middleware for Acryl.
+*
+*
+* @param {Object} options - The options for the cache middleware.
+* @param {string | Function} options.cacheName - The name of the cache. Can be used to store multiple caches with different identifiers.
+* @param {boolean} [options.wait=false] - A boolean indicating if Acryl should wait for the Promise of the `cache.put` function to resolve before continuing with the request. Required to be true for the Deno environment.
+* @param {string} [options.cacheControl] - A string of directives for the `Cache-Control` header.
+* @param {string | string[]} [options.vary] - Adds the configured request headers to the cache key variants and sets the `Vary` header in the response. If the original response header already contains a `Vary` header, the values are merged, removing any duplicates.
+* @param {Function} [options.keyGenerator] - Generates keys for every request in the `cacheName` store. This can be used to cache data based on request parameters or context parameters. QUERY keys additionally include a digest of the request content and its representation metadata.
+* @param {number} [options.maxQueryBodySize=65536] - The maximum QUERY request body size in bytes that can be cached. Larger QUERY requests bypass the cache.
+* @param {number[]} [options.cacheableStatusCodes=[200]] - An array of status codes that can be cached.
+* @param {Function | false} [options.onCacheNotAvailable] - A callback invoked with the reason when `globalThis.caches` is not available or QUERY caching cannot use Web Crypto. By default, the reason is logged to the console. Set to `false` to suppress the log, or provide a custom function.
+* @returns {MiddlewareHandler} The middleware handler function.
+* @throws {Error} If the `vary` option includes "*".
+*
+* @example
+* ```ts
+* app.use(
+*   '*',
+*   cache({
+*     cacheName: 'my-app',
+*     cacheControl: 'max-age=3600',
+*   })
+* )
+* ```
+*/
+const cache = (options) => {
+	if (!globalThis.caches) {
+		reportCacheNotAvailable(options.onCacheNotAvailable, "Cache Middleware is not enabled because caches is not defined.");
+		return async (_c, next) => await next();
+	}
+	if (!globalThis.crypto?.subtle) reportCacheNotAvailable(options.onCacheNotAvailable, "Cache Middleware cannot cache QUERY requests because Web Crypto is not available.");
+	if (options.wait === void 0) options.wait = false;
+	const cacheControlDirectives = options.cacheControl?.split(",").map((directive) => directive.toLowerCase());
+	const optionsVaryList = parseVaryDirectives(options.vary);
+	const varyDirectives = optionsVaryList.length ? new Set(optionsVaryList) : void 0;
+	if (varyDirectives?.has("*")) throw new Error("Middleware vary configuration cannot include \"*\", as it disallows effective caching.");
+	const cacheableStatusCodes = new Set(options.cacheableStatusCodes ?? defaultCacheableStatusCodes);
+	const maxQueryBodySize = options.maxQueryBodySize ?? defaultMaxQueryBodySize;
+	const addHeader = (c, responseVary) => {
+		if (cacheControlDirectives) {
+			const existingDirectives = c.res.headers.get("Cache-Control")?.split(",").map((d) => d.trim().split("=", 1)[0].toLowerCase()) ?? [];
+			for (const directive of cacheControlDirectives) {
+				let [name, value] = directive.trim().split("=", 2);
+				name = name.toLowerCase();
+				if (!existingDirectives.includes(name)) c.header("Cache-Control", `${name}${value ? `=${value}` : ""}`, { append: true });
+			}
+		}
+		if (varyDirectives) if (responseVary.length === 0) c.header("Vary", Array.from(varyDirectives).join(", "));
+		else {
+			const merged = new Set(varyDirectives);
+			for (const directive of responseVary) merged.add(directive);
+			if (merged.has("*")) c.header("Vary", "*");
+			else c.header("Vary", Array.from(merged).join(", "));
+		}
+	};
+	return async function cache(c, next) {
+		if (c.req.method !== "GET" && c.req.method !== "QUERY" || c.req.raw.headers.has("Authorization")) {
+			await next();
+			return;
+		}
+		let cacheKeyRequest = { method: "GET" };
+		if (c.req.method === "QUERY") {
+			const digest = await createQueryDigest(c, maxQueryBodySize);
+			if (digest === void 0) {
+				await next();
+				return;
+			}
+			cacheKeyRequest = {
+				method: "QUERY",
+				digest
+			};
+		}
+		let key = c.req.url;
+		if (options.keyGenerator) key = await options.keyGenerator(c);
+		const varyHeaders = [];
+		if (varyDirectives) for (const directive of varyDirectives) {
+			const value = c.req.raw.headers.get(directive) ?? "";
+			varyHeaders.push([directive, value]);
+		}
+		key = createCacheKey(key, c.req.url, cacheKeyRequest, varyHeaders);
+		const cacheName = typeof options.cacheName === "function" ? await options.cacheName(c) : options.cacheName;
+		const cache = await caches.open(cacheName);
+		const response = await cache.match(key);
+		if (response) return new Response(response.body, response);
+		await next();
+		if (!cacheableStatusCodes.has(c.res.status)) return;
+		const responseVary = parseVaryDirectives(c.res.headers.get("Vary"));
+		addHeader(c, responseVary);
+		if (shouldSkipCache(c.res, varyDirectives, responseVary)) return;
+		const res = c.res.clone();
+		if (options.wait) await cache.put(key, res);
+		else c.executionCtx.waitUntil(cache.put(key, res));
+	};
+};
+//#endregion
+export { cache };

package/lib/client.d.ts

@@ -1,3 +1,3 @@
-import { a as ClientResponse, c as InferRequestType, i as ClientRequestOptions, l as InferResponseType, o as Fetch, r as ClientRequest, t as ApplyGlobalResponse, u as PickResponseByStatusCode } from "./types-CHesD1KG.js";
-import { n as DetailedError, r as hc, t as parseResponse } from "./index-oOClm_Xk.js";
+import { a as ClientResponse, c as InferRequestType, i as ClientRequestOptions, l as InferResponseType, o as Fetch, r as ClientRequest, t as ApplyGlobalResponse, u as PickResponseByStatusCode } from "./types-CQiGmsWW.js";
+import { n as DetailedError, r as hc, t as parseResponse } from "./index-CUTfU69R.js";
 export { type ApplyGlobalResponse, type ClientRequest, type ClientRequestOptions, type ClientResponse, DetailedError, type Fetch, type InferRequestType, type InferResponseType, type PickResponseByStatusCode, hc, parseResponse };

package/lib/combine.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-DVQBjuns.js";
 
 //#region ../../plugins/acryl-router/src/core/middleware/combine/index.d.ts
 type Condition = (c: Context) => boolean;

package/lib/common-D8Z4JRCw.d.ts

@@ -0,0 +1,46 @@
+//#region ../../plugins/acryl-router/src/core/helper/css/common.d.ts
+declare const SELECTOR: unique symbol;
+declare const CLASS_NAME: unique symbol;
+declare const STYLE_STRING: unique symbol;
+declare const SELECTORS: unique symbol;
+declare const EXTERNAL_CLASS_NAMES: unique symbol;
+declare const CSS_ESCAPED: unique symbol;
+interface CssClassName {
+  [SELECTOR]: string;
+  [CLASS_NAME]: string;
+  [STYLE_STRING]: string;
+  [SELECTORS]: CssClassName[];
+  [EXTERNAL_CLASS_NAMES]: string[];
+}
+interface CssEscapedString {
+  [CSS_ESCAPED]: string;
+}
+/**
+ * @experimental
+ * `rawCssString` is an experimental feature.
+ * The API might be changed.
+ */
+declare const rawCssString: (value: string) => CssEscapedString;
+type CssVariableBasicType = CssClassName | CssEscapedString | string | number | boolean | null | undefined;
+type CssVariableAsyncType = Promise<CssVariableBasicType>;
+type CssVariableArrayType = (CssVariableBasicType | CssVariableAsyncType)[];
+type CssVariableType = CssVariableBasicType | CssVariableAsyncType | CssVariableArrayType;
+/**
+ * A function that customizes generated CSS class names.
+ *
+ * @param hash - The default hash-based class name (e.g. `css-1234567890`)
+ * @param label - The comment label extracted from the CSS template, may be empty.
+ *   Whitespace is trimmed and inner spaces are replaced with hyphens.
+ * @param styleString - The minified CSS style string
+ * @returns The custom class name to use. Must be a safe CSS identifier;
+ *   otherwise, the default hash is used as a fallback.
+ */
+type ClassNameSlug = (hash: string, label: string, styleString: string) => string;
+/**
+ * A callback function called when an invalid slug is returned from ClassNameSlug.
+ *
+ * @param slug - The invalid slug
+ */
+type OnInvalidSlug = (slug: string) => void;
+//#endregion
+export { rawCssString as a, OnInvalidSlug as i, CssClassName as n, CssVariableType as r, ClassNameSlug as t };

package/lib/components-Ce5FRyHU.js

@@ -0,0 +1,268 @@
+import { C as captureRenderContext, E as useContext, d as renderUntrustedObject, i as isUntrustedObject, n as JSXNode, o as jsx, t as Fragment, u as renderChildren, w as createContext } from "./base-ddiVmiE7.js";
+import { HtmlEscapedCallbackPhase, raw, resolveCallback } from "./utils/html.js";
+import { a as DOM_STASH, i as DOM_RENDERER } from "./constants-BR9jM9BC.js";
+import { x as buildDataStack } from "./hooks-Bq5q9IMl.js";
+import { n as Suspense$1, t as ErrorBoundary$1 } from "./components-DYZdxJIJ.js";
+//#region ../../plugins/acryl-router/src/core/jsx/streaming.ts
+/**
+* @module
+* This module enables JSX to supports streaming Response.
+*/
+/**
+* Used to specify nonce for scripts generated by `Suspense` and `ErrorBoundary`.
+*
+* @example
+* ```tsx
+* <StreamingContext.Provider value={{ scriptNonce: 'test-nonce' }}>
+*   <Suspense fallback={<p>Loading...</p>}>
+*     <Content />
+*   </Suspense>
+* </StreamingContext.Provider>
+* ```
+*/
+const StreamingContext = createContext(null);
+let suspenseCounter = 0;
+const serializeBoundaryChild = (child) => typeof child === "string" || Array.isArray(child) ? renderChildren([child]) : child == null || typeof child === "boolean" ? "" : isUntrustedObject(child) ? renderUntrustedObject(child) : child.toString();
+/**
+* @experimental
+* `Suspense` is an experimental feature.
+* The API might be changed.
+*/
+const Suspense = async ({ children, fallback }) => {
+	if (!Array.isArray(children)) children = [children];
+	const nonce = useContext(StreamingContext)?.scriptNonce;
+	let resArray = [];
+	const stackNode = { [DOM_STASH]: [0, []] };
+	const popNodeStack = () => {
+		buildDataStack.pop();
+	};
+	try {
+		stackNode[DOM_STASH][0] = 0;
+		buildDataStack.push([[], stackNode]);
+		resArray = children.map(serializeBoundaryChild);
+	} catch (e) {
+		if (e instanceof Promise) {
+			const resume = captureRenderContext();
+			resArray = [e.then(() => resume(() => {
+				stackNode[DOM_STASH][0] = 0;
+				buildDataStack.push([[], stackNode]);
+				return childrenToString(children).finally(popNodeStack);
+			}))];
+		} else throw e;
+	} finally {
+		popNodeStack();
+	}
+	if (resArray.some((res) => res instanceof Promise)) {
+		const index = suspenseCounter++;
+		const fallbackStr = await (typeof fallback === "string" || Array.isArray(fallback) ? renderChildren([fallback]) : isUntrustedObject(fallback) ? renderUntrustedObject(fallback) : fallback.toString());
+		return raw(`<template id="H:${index}"></template>${fallbackStr}<!--/$-->`, [...fallbackStr.callbacks || [], ({ phase, buffer, context }) => {
+			if (phase === HtmlEscapedCallbackPhase.BeforeStream) return;
+			return Promise.all(resArray).then(async (htmlArray) => {
+				htmlArray = htmlArray.flat();
+				const content = htmlArray.join("");
+				if (buffer) buffer[0] = buffer[0].replace(new RegExp(`<template id="H:${index}"></template>.*?<!--/\\$-->`, "s"), () => content);
+				let html = buffer ? "" : `<template data-acryl-target="H:${index}">${content}</template><script${nonce ? ` nonce="${nonce}"` : ""}>
+((d,c,n) => {
+c=d.currentScript.previousSibling
+d=d.getElementById('H:${index}')
+if(!d)return
+do{n=d.nextSibling;n.remove()}while(n.nodeType!=8||n.nodeValue!='/$')
+d.replaceWith(c.content)
+})(document)
+<\/script>`;
+				const callbacks = htmlArray.map((html) => html.callbacks || []).flat();
+				if (!callbacks.length) return html;
+				if (phase === HtmlEscapedCallbackPhase.Stream) html = await resolveCallback(html, HtmlEscapedCallbackPhase.BeforeStream, true, context);
+				return raw(html, callbacks);
+			});
+		}]);
+	} else return raw(resArray.join(""));
+};
+Suspense[DOM_RENDERER] = Suspense$1;
+const textEncoder = new TextEncoder();
+/**
+* @experimental
+* `renderToReadableStream()` is an experimental feature.
+* The API might be changed.
+*/
+const renderToReadableStream = (content, onError = console.trace) => {
+	let cancelled = false;
+	return new ReadableStream({
+		async start(controller) {
+			try {
+				if (content instanceof JSXNode) content = content.toString();
+				const context = typeof content === "object" ? content : {};
+				const resolved = await resolveCallback(content, HtmlEscapedCallbackPhase.BeforeStream, true, context);
+				if (!cancelled) controller.enqueue(textEncoder.encode(resolved));
+				let resolvedCount = 0;
+				const callbacks = [];
+				const then = (promise) => {
+					callbacks.push(promise.catch((err) => {
+						console.log(err);
+						onError(err);
+						return "";
+					}).then(async (res) => {
+						res = await resolveCallback(res, HtmlEscapedCallbackPhase.BeforeStream, true, context);
+						res.callbacks?.map((c) => c({
+							phase: HtmlEscapedCallbackPhase.Stream,
+							context
+						})).filter(Boolean).forEach(then);
+						resolvedCount++;
+						if (!cancelled) controller.enqueue(textEncoder.encode(res));
+					}));
+				};
+				resolved.callbacks?.map((c) => c({
+					phase: HtmlEscapedCallbackPhase.Stream,
+					context
+				})).filter(Boolean).forEach(then);
+				while (resolvedCount !== callbacks.length) await Promise.all(callbacks);
+			} catch (e) {
+				onError(e);
+			}
+			if (!cancelled) controller.close();
+		},
+		cancel() {
+			cancelled = true;
+		}
+	});
+};
+//#endregion
+//#region ../../plugins/acryl-router/src/core/jsx/components.ts
+let errorBoundaryCounter = 0;
+const childrenToString = async (children) => {
+	try {
+		return children.flat().map(resolveChildEarly);
+	} catch (e) {
+		if (e instanceof Promise) {
+			const resume = captureRenderContext();
+			await e;
+			return resume(() => childrenToString(children));
+		} else throw e;
+	}
+};
+const resolveChildEarly = (child) => {
+	if (child == null || typeof child === "boolean") return "";
+	else if (typeof child === "string" || Array.isArray(child)) return renderChildren([child]);
+	else if (isUntrustedObject(child)) return renderUntrustedObject(child);
+	else {
+		const str = child.toString();
+		return str instanceof Promise ? str : raw(str);
+	}
+};
+/**
+* @experimental
+* `ErrorBoundary` is an experimental feature.
+* The API might be changed.
+*/
+const ErrorBoundary = async ({ children, fallback, fallbackRender, onError }) => {
+	if (!children) return raw("");
+	if (!Array.isArray(children)) children = [children];
+	const nonce = useContext(StreamingContext)?.scriptNonce;
+	let resume;
+	const getResume = () => resume ||= captureRenderContext();
+	let fallbackStrPromise;
+	const resolveFallbackStr = () => fallbackStrPromise ||= (async () => {
+		const awaitedFallback = await fallback;
+		if (awaitedFallback === null || awaitedFallback === void 0) return;
+		if (typeof awaitedFallback === "string" || Array.isArray(awaitedFallback)) return getResume()(() => renderChildren([awaitedFallback]));
+		if (isUntrustedObject(awaitedFallback)) return getResume()(() => renderUntrustedObject(awaitedFallback));
+		const fallbackResult = await getResume()(() => awaitedFallback.toString());
+		return raw(fallbackResult, fallbackResult.callbacks || awaitedFallback.callbacks);
+	})();
+	const renderFallback = async (error) => {
+		const fallbackStr = await resolveFallbackStr();
+		return getResume()(async () => {
+			onError?.(error);
+			const fallbackRes = fallbackStr !== void 0 ? fallbackStr : fallbackRender && jsx(Fragment, {}, fallbackRender(error)) || "";
+			const fallbackResString = await Fragment({ children: fallbackRes }).toString();
+			return raw(fallbackResString, fallbackResString.callbacks || fallbackRes.callbacks);
+		});
+	};
+	let resArray = [];
+	try {
+		resArray = children.map(resolveChildEarly);
+	} catch (e) {
+		const resume = getResume();
+		if (e instanceof Promise) resArray = [e.then(() => resume(() => childrenToString(children))).catch((e) => renderFallback(e))];
+		else resArray = [await renderFallback(e)];
+	}
+	if (resArray.some((res) => res instanceof Promise)) {
+		getResume();
+		const index = errorBoundaryCounter++;
+		const replaceRe = RegExp(`(<template id="E:${index}"></template>)(.*?)(<!--E:${index}-->)`, "s");
+		let caught = false;
+		const catchCallback = async ({ error, buffer }) => {
+			if (caught) return "";
+			caught = true;
+			const fallbackResString = await renderFallback(error);
+			const fallbackCallbacks = fallbackResString.callbacks;
+			if (buffer) {
+				buffer[0] = buffer[0].replace(replaceRe, () => fallbackResString);
+				return fallbackCallbacks?.length ? raw("", fallbackCallbacks) : "";
+			}
+			return raw(`<template data-acryl-target="E:${index}">${fallbackResString}</template><script>
+((d,c,n) => {
+c=d.currentScript.previousSibling
+d=d.getElementById('E:${index}')
+if(!d)return
+do{n=d.nextSibling;n.remove()}while(n.nodeType!=8||n.nodeValue!='E:${index}')
+d.replaceWith(c.content)
+})(document)
+<\/script>`, fallbackCallbacks);
+		};
+		let error;
+		const promiseAll = Promise.all(resArray).catch((e) => error = e);
+		return raw(`<template id="E:${index}"></template><!--E:${index}-->`, [({ phase, buffer, context }) => {
+			if (phase === HtmlEscapedCallbackPhase.BeforeStream) return;
+			return promiseAll.then(async (htmlArray) => {
+				if (error) throw error;
+				htmlArray = htmlArray.flat();
+				const content = htmlArray.join("");
+				let html = buffer ? "" : `<template data-acryl-target="E:${index}">${content}</template><script${nonce ? ` nonce="${nonce}"` : ""}>
+((d,c) => {
+c=d.currentScript.previousSibling
+d=d.getElementById('E:${index}')
+if(!d)return
+d.parentElement.insertBefore(c.content,d.nextSibling)
+})(document)
+<\/script>`;
+				if (htmlArray.every((html) => !html.callbacks?.length)) {
+					if (buffer) buffer[0] = buffer[0].replace(replaceRe, () => content);
+					return html;
+				}
+				if (buffer) buffer[0] = buffer[0].replace(replaceRe, (_all, pre, _, post) => `${pre}${content}${post}`);
+				const callbacks = htmlArray.map((html) => html.callbacks || []).flat();
+				if (phase === HtmlEscapedCallbackPhase.Stream) html = await resolveCallback(html, HtmlEscapedCallbackPhase.BeforeStream, true, context);
+				let resolvedCount = 0;
+				const promises = callbacks.map((c) => (...args) => c(...args)?.then((content) => {
+					resolvedCount++;
+					if (buffer) {
+						if (resolvedCount === callbacks.length) buffer[0] = buffer[0].replace(replaceRe, (_all, _pre, content) => content);
+						buffer[0] += content;
+						return raw("", content.callbacks);
+					}
+					return raw(content + (resolvedCount !== callbacks.length ? "" : `<script>
+((d,c,n) => {
+d=d.getElementById('E:${index}')
+if(!d)return
+n=d.nextSibling
+while(n.nodeType!=8||n.nodeValue!='E:${index}'){n=n.nextSibling}
+n.remove()
+d.remove()
+})(document)
+<\/script>`), content.callbacks);
+				}).catch((error) => catchCallback({
+					error,
+					buffer
+				})));
+				return raw(html, promises);
+			}).catch((error) => catchCallback({
+				error,
+				buffer
+			}));
+		}]);
+	} else return Fragment({ children: resArray });
+};
+ErrorBoundary[DOM_RENDERER] = ErrorBoundary$1;
+//#endregion
+export { renderToReadableStream as i, StreamingContext as n, Suspense as r, ErrorBoundary as t };

package/lib/components-DYZdxJIJ.js

@@ -0,0 +1,24 @@
+import { t as DOM_ERROR_HANDLER } from "./constants-BR9jM9BC.js";
+import { t as Fragment } from "./jsx-dev-runtime-kAhR_4C7.js";
+import "./jsx/dom/jsx-runtime.js";
+//#region ../../plugins/acryl-router/src/core/jsx/dom/components.ts
+const ErrorBoundary = (({ children, fallback, fallbackRender, onError }) => {
+	const res = Fragment({ children });
+	res[DOM_ERROR_HANDLER] = (err) => {
+		if (err instanceof Promise) throw err;
+		onError?.(err);
+		return fallbackRender?.(err) || fallback;
+	};
+	return res;
+});
+const Suspense = (({ children, fallback }) => {
+	const res = Fragment({ children });
+	res[DOM_ERROR_HANDLER] = (err, retry) => {
+		if (!(err instanceof Promise)) throw err;
+		err.finally(retry);
+		return fallback;
+	};
+	return res;
+});
+//#endregion
+export { Suspense as n, ErrorBoundary as t };

package/lib/compress.d.ts

@@ -1,4 +1,4 @@
-import { I as MiddlewareHandler } from "./context-Bm7rI-oK.js";
+import { I as MiddlewareHandler } from "./context-DVQBjuns.js";
 import { COMPRESSIBLE_CONTENT_TYPE_REGEX } from "./utils/compress.js";
 
 //#region ../../plugins/acryl-router/src/core/middleware/compress/index.d.ts

package/lib/conninfo.d.ts

@@ -1,5 +1,5 @@
-import { t as Context } from "./context-Bm7rI-oK.js";
-import { i as NetAddrInfo, n as ConnInfo, r as GetConnInfo, t as AddressType } from "./types-CDO6I3B0.js";
+import { t as Context } from "./context-DVQBjuns.js";
+import { i as NetAddrInfo, n as ConnInfo, r as GetConnInfo, t as AddressType } from "./types-nEL8VPDC.js";
 
 //#region ../../plugins/acryl-router/src/connection.d.ts
 /** An in-process caller (the terminal UI, a test) passes nothing, so a handler that needs a trusted peer must refuse an empty one. */

package/lib/constants-BR9jM9BC.js

@@ -0,0 +1,9 @@
+//#region ../../plugins/acryl-router/src/core/jsx/constants.ts
+const DOM_RENDERER = Symbol("RENDERER");
+const DOM_ERROR_HANDLER = Symbol("ERROR_HANDLER");
+const DOM_STASH = Symbol("STASH");
+const DOM_INTERNAL_TAG = Symbol("INTERNAL");
+const DOM_MEMO = Symbol("MEMO");
+const PERMALINK = Symbol("PERMALINK");
+//#endregion
+export { DOM_STASH as a, DOM_RENDERER as i, DOM_INTERNAL_TAG as n, PERMALINK as o, DOM_MEMO as r, DOM_ERROR_HANDLER as t };

package/lib/{context-Bm7rI-oK.d.ts → context-DVQBjuns.d.ts}

@@ -1,7 +1,7 @@
 import { c as Result, l as Router } from "./router-CvUxUTOq.js";
 import { i as ResponseHeader, n as CustomHeader, r as RequestHeader } from "./headers-tu2YYN8T.js";
 import { c as StatusCode, n as ContentfulStatusCode, o as RedirectStatusCode } from "./http-status-DaAwGAFL.js";
-import { S as Simplify, T as UnionToIntersection, b as RemoveBlankRecord, c as IfAnyThenEmptyObject, d as IsAny, g as JSONValue, m as JSONParsed, u as InvalidJSONValue } from "./types-CwrQjlaM.js";
+import { D as UnionToIntersection, S as RemoveBlankRecord, f as InvalidJSONValue, g as JSONParsed, p as IsAny, u as IfAnyThenEmptyObject, v as JSONValue, w as Simplify } from "./types-Lqx5BxQF.js";
 import { t as BaseMime } from "./mime-BQOYHl-l.js";
 
 //#region ../../plugins/acryl-router/src/core/request/constants.d.ts