acrylblends 0.4.1 → 0.5.1

package/lib/utils/buffer.d.ts

@@ -0,0 +1,19 @@
+//#region ../../plugins/acryl-router/src/core/utils/buffer.d.ts
+/**
+ * @module
+ * Buffer utility.
+ */
+declare const equal: (a: ArrayBuffer, b: ArrayBuffer) => boolean;
+type StringHashFunction = (input: string) => string | null | Promise<string | null>;
+type TimingSafeEqual = {
+  (a: string, b: string, hashFunction?: StringHashFunction): Promise<boolean>;
+  /**
+   * @deprecated object and boolean signatures that take boolean as first and second arguments, and functions with signatures that take non-string arguments have been deprecated
+   */
+  (a: string | object | boolean, b: string | object | boolean, hashFunction?: Function): Promise<boolean>;
+};
+declare const timingSafeEqual: TimingSafeEqual;
+declare const bufferToString: (buffer: ArrayBuffer) => string;
+declare const bufferToFormData: (arrayBuffer: ArrayBuffer, contentType: string) => Promise<FormData>;
+//#endregion
+export { bufferToFormData, bufferToString, equal, timingSafeEqual };

package/lib/utils/buffer.js

@@ -0,0 +1,51 @@
+import { sha256 } from "./crypto.js";
+//#region ../../plugins/acryl-router/src/core/utils/buffer.ts
+/**
+* @module
+* Buffer utility.
+*/
+const equal = (a, b) => {
+	if (a === b) return true;
+	if (a.byteLength !== b.byteLength) return false;
+	const va = new DataView(a);
+	const vb = new DataView(b);
+	let i = va.byteLength;
+	while (i--) if (va.getUint8(i) !== vb.getUint8(i)) return false;
+	return true;
+};
+const constantTimeEqualString = (a, b) => {
+	const aLen = a.length;
+	const bLen = b.length;
+	const maxLen = Math.max(aLen, bLen);
+	let out = aLen ^ bLen;
+	for (let i = 0; i < maxLen; i++) {
+		const aChar = i < aLen ? a.charCodeAt(i) : 0;
+		const bChar = i < bLen ? b.charCodeAt(i) : 0;
+		out |= aChar ^ bChar;
+	}
+	return out === 0;
+};
+const timingSafeEqualString = async (a, b, hashFunction) => {
+	if (!hashFunction) hashFunction = sha256;
+	const [sa, sb] = await Promise.all([hashFunction(a), hashFunction(b)]);
+	if (sa == null || sb == null || typeof sa !== "string" || typeof sb !== "string") return false;
+	const hashEqual = constantTimeEqualString(sa, sb);
+	const originalEqual = constantTimeEqualString(a, b);
+	return hashEqual && originalEqual;
+};
+const timingSafeEqual = async (a, b, hashFunction) => {
+	if (typeof a === "string" && typeof b === "string") return timingSafeEqualString(a, b, hashFunction);
+	if (!hashFunction) hashFunction = sha256;
+	const [sa, sb] = await Promise.all([hashFunction(a), hashFunction(b)]);
+	if (!sa || !sb || typeof sa !== "string" || typeof sb !== "string") return false;
+	return timingSafeEqualString(sa, sb);
+};
+const bufferToString = (buffer) => {
+	if (buffer instanceof ArrayBuffer) return new TextDecoder("utf-8").decode(buffer);
+	return buffer;
+};
+const bufferToFormData = (arrayBuffer, contentType) => {
+	return new Response(arrayBuffer, { headers: { "Content-Type": contentType.replace(/^[^;]+/, (mediaType) => mediaType.toLowerCase()) } }).formData();
+};
+//#endregion
+export { bufferToFormData, bufferToString, equal, timingSafeEqual };

package/lib/utils/color.d.ts

@@ -0,0 +1,24 @@
+//#region ../../plugins/acryl-router/src/core/utils/color.d.ts
+/**
+ * @module
+ * Color utility.
+ */
+/**
+ * Get whether color change on terminal is enabled or disabled.
+ * If `NO_COLOR` environment variable is set, this function returns `false`.
+ * Unlike getColorEnabledAsync(), this cannot check Cloudflare environment variables.
+ * @see {@link https://no-color.org/}
+ *
+ * @returns {boolean}
+ */
+declare function getColorEnabled(): boolean;
+/**
+ * Get whether color change on terminal is enabled or disabled.
+ * If `NO_COLOR` environment variable is set, this function returns `false`.
+ * @see {@link https://no-color.org/}
+ *
+ * @returns {boolean}
+ */
+declare function getColorEnabledAsync(): Promise<boolean>;
+//#endregion
+export { getColorEnabled, getColorEnabledAsync };

package/lib/utils/color.js

@@ -0,0 +1,37 @@
+//#region ../../plugins/acryl-router/src/core/utils/color.ts
+/**
+* @module
+* Color utility.
+*/
+/**
+* Get whether color change on terminal is enabled or disabled.
+* If `NO_COLOR` environment variable is set, this function returns `false`.
+* Unlike getColorEnabledAsync(), this cannot check Cloudflare environment variables.
+* @see {@link https://no-color.org/}
+*
+* @returns {boolean}
+*/
+function getColorEnabled() {
+	const { process, Deno } = globalThis;
+	return !(typeof Deno?.noColor === "boolean" ? Deno.noColor : process !== void 0 ? "NO_COLOR" in process?.env : false);
+}
+/**
+* Get whether color change on terminal is enabled or disabled.
+* If `NO_COLOR` environment variable is set, this function returns `false`.
+* @see {@link https://no-color.org/}
+*
+* @returns {boolean}
+*/
+async function getColorEnabledAsync() {
+	const { navigator } = globalThis;
+	const cfWorkers = "cloudflare:workers";
+	return !(navigator !== void 0 && navigator.userAgent === "Cloudflare-Workers" ? await (async () => {
+		try {
+			return "NO_COLOR" in ((await import(cfWorkers)).env ?? {});
+		} catch {
+			return false;
+		}
+	})() : !getColorEnabled());
+}
+//#endregion
+export { getColorEnabled, getColorEnabledAsync };

package/lib/utils/compress.d.ts

@@ -0,0 +1,11 @@
+//#region ../../plugins/acryl-router/src/core/utils/compress.d.ts
+/**
+ * @module
+ * Constants for compression.
+ */
+/**
+ * Match for compressible content type.
+ */
+declare const COMPRESSIBLE_CONTENT_TYPE_REGEX: RegExp;
+//#endregion
+export { COMPRESSIBLE_CONTENT_TYPE_REGEX };

package/lib/utils/compress.js

@@ -0,0 +1,11 @@
+//#region ../../plugins/acryl-router/src/core/utils/compress.ts
+/**
+* @module
+* Constants for compression.
+*/
+/**
+* Match for compressible content type.
+*/
+const COMPRESSIBLE_CONTENT_TYPE_REGEX = /^\s*(?:text\/(?!event-stream(?:[;\s]|$))[^;\s]+|application\/(?:javascript|json|xml|xml-dtd|ecmascript|dart|msgpack|postscript|rtf|tar|toml|vnd\.dart|vnd\.ms-fontobject|vnd\.ms-opentype|vnd\.msgpack|wasm|x-httpd-php|x-javascript|x-msgpack|x-ns-proxy-autoconfig|x-sh|x-tar|x-virtualbox-hdd|x-virtualbox-ova|x-virtualbox-ovf|x-virtualbox-vbox|x-virtualbox-vdi|x-virtualbox-vhd|x-virtualbox-vmdk|x-www-form-urlencoded)|font\/(?:otf|ttf)|image\/(?:bmp|vnd\.adobe\.photoshop|vnd\.microsoft\.icon|vnd\.ms-dds|x-icon|x-ms-bmp)|message\/rfc822|model\/gltf-binary|x-shader\/x-fragment|x-shader\/x-vertex|[^;\s]+?\+(?:json|text|xml|yaml|msgpack))(?:[;\s]|$)/i;
+//#endregion
+export { COMPRESSIBLE_CONTENT_TYPE_REGEX };

package/lib/utils/concurrent.d.ts

@@ -0,0 +1,17 @@
+//#region ../../plugins/acryl-router/src/core/utils/concurrent.d.ts
+/**
+ * @module
+ * Concurrent utility.
+ */
+interface Pool {
+  run<T>(fn: () => T): Promise<T>;
+}
+declare const createPool: ({
+  concurrency,
+  interval
+}?: {
+  concurrency?: number;
+  interval?: number;
+}) => Pool;
+//#endregion
+export { Pool, createPool };

package/lib/utils/concurrent.js

@@ -0,0 +1,30 @@
+//#region ../../plugins/acryl-router/src/core/utils/concurrent.ts
+/**
+* @module
+* Concurrent utility.
+*/
+const DEFAULT_CONCURRENCY = 1024;
+const createPool = ({ concurrency, interval } = {}) => {
+	concurrency ||= DEFAULT_CONCURRENCY;
+	if (concurrency === Infinity) return { run: async (fn) => fn() };
+	const pool = /* @__PURE__ */ new Set();
+	const run = async (fn, promise, resolve) => {
+		if (pool.size >= concurrency) {
+			promise ||= new Promise((r) => resolve = r);
+			setTimeout(() => run(fn, promise, resolve));
+			return promise;
+		}
+		const marker = {};
+		pool.add(marker);
+		const result = await fn();
+		if (interval) setTimeout(() => pool.delete(marker), interval);
+		else pool.delete(marker);
+		if (resolve) {
+			resolve(result);
+			return promise;
+		} else return result;
+	};
+	return { run };
+};
+//#endregion
+export { createPool };

package/lib/utils/constants.d.ts

@@ -0,0 +1,7 @@
+//#region ../../plugins/acryl-router/src/core/utils/constants.d.ts
+/**
+ * Constant used to mark a composed handler.
+ */
+declare const COMPOSED_HANDLER = "__COMPOSED_HANDLER";
+//#endregion
+export { COMPOSED_HANDLER };

package/lib/utils/constants.js

@@ -0,0 +1,7 @@
+//#region ../../plugins/acryl-router/src/core/utils/constants.ts
+/**
+* Constant used to mark a composed handler.
+*/
+const COMPOSED_HANDLER = "__COMPOSED_HANDLER";
+//#endregion
+export { COMPOSED_HANDLER };

package/lib/utils/cookie.d.ts

@@ -0,0 +1,2 @@
+import { a as SignedCookie, c as serialize, i as CookiePrefixOptions, l as serializeSigned, n as CookieConstraint, o as parse, r as CookieOptions, s as parseSigned, t as Cookie } from "../cookie-ClMaKDQf.js";
+export { Cookie, CookieConstraint, CookieOptions, CookiePrefixOptions, SignedCookie, parse, parseSigned, serialize, serializeSigned };

package/lib/utils/cookie.js

@@ -0,0 +1,125 @@
+import { tryDecodeURIComponent } from "./url.js";
+//#region ../../plugins/acryl-router/src/core/utils/cookie.ts
+/**
+* @module
+* Cookie utility.
+*/
+const algorithm = {
+	name: "HMAC",
+	hash: "SHA-256"
+};
+const getCryptoKey = async (secret) => {
+	const secretBuf = typeof secret === "string" ? new TextEncoder().encode(secret) : secret;
+	return await crypto.subtle.importKey("raw", secretBuf, algorithm, false, ["sign", "verify"]);
+};
+const makeSignature = async (value, secret) => {
+	const key = await getCryptoKey(secret);
+	const signature = await crypto.subtle.sign(algorithm.name, key, new TextEncoder().encode(value));
+	return btoa(String.fromCharCode(...new Uint8Array(signature)));
+};
+const verifySignature = async (base64Signature, value, secret) => {
+	try {
+		const signatureBinStr = atob(base64Signature);
+		const signature = new Uint8Array(signatureBinStr.length);
+		for (let i = 0, len = signatureBinStr.length; i < len; i++) signature[i] = signatureBinStr.charCodeAt(i);
+		return await crypto.subtle.verify(algorithm, secret, signature, new TextEncoder().encode(value));
+	} catch {
+		return false;
+	}
+};
+const validCookieNameRegEx = /^[\w!#$%&'*.^`|~+-]+$/;
+const relaxedCookieNameRegEx = /^[!#-:<>-[\]-~]+$/;
+const validCookieValueRegEx = /^[ !#-:<-[\]-~]*$/;
+const trimCookieWhitespace = (value) => {
+	let start = 0;
+	let end = value.length;
+	while (start < end) {
+		const charCode = value.charCodeAt(start);
+		if (charCode !== 32 && charCode !== 9) break;
+		start++;
+	}
+	while (end > start) {
+		const charCode = value.charCodeAt(end - 1);
+		if (charCode !== 32 && charCode !== 9) break;
+		end--;
+	}
+	return start === 0 && end === value.length ? value : value.slice(start, end);
+};
+const parse = (cookie, name) => {
+	if (name && cookie.indexOf(name) === -1) return {};
+	const pairs = cookie.split(";");
+	const parsedCookie = Object.create(null);
+	for (const pairStr of pairs) {
+		const valueStartPos = pairStr.indexOf("=");
+		if (valueStartPos === -1) continue;
+		const cookieName = trimCookieWhitespace(pairStr.substring(0, valueStartPos));
+		if (name && name !== cookieName || !relaxedCookieNameRegEx.test(cookieName) || cookieName in parsedCookie) continue;
+		let cookieValue = trimCookieWhitespace(pairStr.substring(valueStartPos + 1));
+		if (cookieValue.startsWith("\"") && cookieValue.endsWith("\"")) cookieValue = cookieValue.slice(1, -1);
+		if (validCookieValueRegEx.test(cookieValue)) {
+			parsedCookie[cookieName] = tryDecodeURIComponent(cookieValue);
+			if (name) break;
+		}
+	}
+	return parsedCookie;
+};
+const parseSigned = async (cookie, secret, name) => {
+	const parsedCookie = Object.create(null);
+	const secretKey = await getCryptoKey(secret);
+	for (const [key, value] of Object.entries(parse(cookie, name))) {
+		const signatureStartPos = value.lastIndexOf(".");
+		if (signatureStartPos < 0) continue;
+		const signedValue = value.substring(0, signatureStartPos);
+		const signature = value.substring(signatureStartPos + 1);
+		if (signature.length !== 44 || !signature.endsWith("=")) continue;
+		parsedCookie[key] = await verifySignature(signature, signedValue, secretKey) ? signedValue : false;
+	}
+	return parsedCookie;
+};
+const _serialize = (name, value, opt = {}) => {
+	if (!validCookieNameRegEx.test(name)) throw new Error("Invalid cookie name");
+	let cookie = `${name}=${value}`;
+	if (name.startsWith("__Secure-") && !opt.secure) throw new Error("__Secure- Cookie must have Secure attributes");
+	if (name.startsWith("__Host-")) {
+		if (!opt.secure) throw new Error("__Host- Cookie must have Secure attributes");
+		if (opt.path !== "/") throw new Error("__Host- Cookie must have Path attributes with \"/\"");
+		if (opt.domain) throw new Error("__Host- Cookie must not have Domain attributes");
+	}
+	for (const key of [
+		"domain",
+		"path",
+		"sameSite",
+		"priority"
+	]) if (opt[key] && /[;\r\n]/.test(opt[key])) throw new Error(`${key} must not contain ";", "\\r", or "\\n"`);
+	if (opt && typeof opt.maxAge === "number" && opt.maxAge >= 0) {
+		if (opt.maxAge > 3456e4) throw new Error("Cookies Max-Age SHOULD NOT be greater than 400 days (34560000 seconds) in duration.");
+		cookie += `; Max-Age=${opt.maxAge | 0}`;
+	}
+	if (opt.domain && opt.prefix !== "host") cookie += `; Domain=${opt.domain}`;
+	if (opt.path) cookie += `; Path=${opt.path}`;
+	if (opt.expires) {
+		if (opt.expires.getTime() - Date.now() > 3456e7) throw new Error("Cookies Expires SHOULD NOT be greater than 400 days (34560000 seconds) in the future.");
+		cookie += `; Expires=${opt.expires.toUTCString()}`;
+	}
+	if (opt.httpOnly) cookie += "; HttpOnly";
+	if (opt.secure) cookie += "; Secure";
+	if (opt.sameSite) cookie += `; SameSite=${opt.sameSite.charAt(0).toUpperCase() + opt.sameSite.slice(1)}`;
+	if (opt.priority) cookie += `; Priority=${opt.priority.charAt(0).toUpperCase() + opt.priority.slice(1)}`;
+	if (opt.partitioned) {
+		if (!opt.secure) throw new Error("Partitioned Cookie must have Secure attributes");
+		cookie += "; Partitioned";
+	}
+	return cookie;
+};
+const serialize = (name, value, opt) => {
+	value = encodeURIComponent(value);
+	return _serialize(name, value, opt);
+};
+const serializeSigned = async (name, value, secret, opt = {}) => {
+	const signature = await makeSignature(value, secret);
+	value = `${value}.${signature}`;
+	value = encodeURIComponent(value);
+	return _serialize(name, value, opt);
+};
+//#endregion
+export { parse, parseSigned, serialize, serializeSigned };

package/lib/utils/crypto.d.ts

@@ -0,0 +1,14 @@
+import { g as JSONValue } from "../types-CwrQjlaM.js";
+
+//#region ../../plugins/acryl-router/src/core/utils/crypto.d.ts
+type Algorithm = {
+  name: string;
+  alias: string;
+};
+type Data = string | boolean | number | JSONValue | ArrayBufferView | ArrayBuffer;
+declare const sha256: (data: Data) => Promise<string | null>;
+declare const sha1: (data: Data) => Promise<string | null>;
+declare const md5: (data: Data) => Promise<string | null>;
+declare const createHash: (data: Data, algorithm: Algorithm) => Promise<string | null>;
+//#endregion
+export { createHash, md5, sha1, sha256 };

package/lib/utils/crypto.js

@@ -0,0 +1,34 @@
+//#region ../../plugins/acryl-router/src/core/utils/crypto.ts
+const sha256 = async (data) => {
+	return await createHash(data, {
+		name: "SHA-256",
+		alias: "sha256"
+	});
+};
+const sha1 = async (data) => {
+	return await createHash(data, {
+		name: "SHA-1",
+		alias: "sha1"
+	});
+};
+const md5 = async (data) => {
+	return await createHash(data, {
+		name: "MD5",
+		alias: "md5"
+	});
+};
+const createHash = async (data, algorithm) => {
+	let sourceBuffer;
+	if (ArrayBuffer.isView(data) || data instanceof ArrayBuffer) sourceBuffer = data;
+	else {
+		if (typeof data === "object") data = JSON.stringify(data);
+		sourceBuffer = new TextEncoder().encode(String(data));
+	}
+	if (crypto && crypto.subtle) {
+		const buffer = await crypto.subtle.digest({ name: algorithm.name }, sourceBuffer);
+		return Array.prototype.map.call(new Uint8Array(buffer), (x) => ("00" + x.toString(16)).slice(-2)).join("");
+	}
+	return null;
+};
+//#endregion
+export { createHash, md5, sha1, sha256 };

package/lib/utils/encode.d.ts

@@ -0,0 +1,11 @@
+//#region ../../plugins/acryl-router/src/core/utils/encode.d.ts
+/**
+ * @module
+ * Encode utility.
+ */
+declare const decodeBase64Url: (str: string) => Uint8Array<ArrayBuffer>;
+declare const encodeBase64Url: (buf: ArrayBufferLike) => string;
+declare const encodeBase64: (buf: ArrayBufferLike) => string;
+declare const decodeBase64: (str: string) => Uint8Array<ArrayBuffer>;
+//#endregion
+export { decodeBase64, decodeBase64Url, encodeBase64, encodeBase64Url };

package/lib/utils/encode.js

@@ -0,0 +1,33 @@
+//#region ../../plugins/acryl-router/src/core/utils/encode.ts
+/**
+* @module
+* Encode utility.
+*/
+const decodeBase64Url = (str) => {
+	return decodeBase64(str.replace(/_|-/g, (m) => ({
+		_: "/",
+		"-": "+"
+	})[m] ?? m));
+};
+const encodeBase64Url = (buf) => encodeBase64(buf).replace(/\/|\+/g, (m) => ({
+	"/": "_",
+	"+": "-"
+})[m] ?? m);
+const encodeBase64 = (buf) => {
+	let binary = "";
+	const bytes = new Uint8Array(buf);
+	for (let i = 0, len = bytes.length; i < len; i++) binary += String.fromCharCode(bytes[i]);
+	return btoa(binary);
+};
+const decodeBase64 = (str) => {
+	const binary = atob(str);
+	const bytes = new Uint8Array(new ArrayBuffer(binary.length));
+	const half = binary.length / 2;
+	for (let i = 0, j = binary.length - 1; i <= half; i++, j--) {
+		bytes[i] = binary.charCodeAt(i);
+		bytes[j] = binary.charCodeAt(j);
+	}
+	return bytes;
+};
+//#endregion
+export { decodeBase64, decodeBase64Url, encodeBase64, encodeBase64Url };

package/lib/utils/filepath.d.ts

@@ -0,0 +1,14 @@
+//#region ../../plugins/acryl-router/src/core/utils/filepath.d.ts
+/**
+ * @module
+ * FilePath utility.
+ */
+type FilePathOptions = {
+  filename: string;
+  root?: string;
+  defaultDocument?: string;
+};
+declare const getFilePath: (options: FilePathOptions) => string | undefined;
+declare const getFilePathWithoutDefaultDocument: (options: Omit<FilePathOptions, "defaultDocument">) => string | undefined;
+//#endregion
+export { getFilePath, getFilePathWithoutDefaultDocument };

package/lib/utils/filepath.js

@@ -0,0 +1,25 @@
+//#region ../../plugins/acryl-router/src/core/utils/filepath.ts
+const getFilePath = (options) => {
+	let filename = options.filename;
+	const defaultDocument = options.defaultDocument || "index.html";
+	if (filename.endsWith("/")) filename = filename.concat(defaultDocument);
+	else if (!filename.match(/\.[a-zA-Z0-9_-]+$/)) filename = filename.concat("/" + defaultDocument);
+	return getFilePathWithoutDefaultDocument({
+		root: options.root,
+		filename
+	});
+};
+const getFilePathWithoutDefaultDocument = (options) => {
+	let root = options.root || "";
+	let filename = options.filename;
+	if (/(?:^|[\/\\])\.\.(?:$|[\/\\])/.test(filename)) return;
+	filename = filename.replace(/^\.?[\/\\]/, "");
+	filename = filename.replace(/\\/g, "/");
+	root = root.replace(/\/$/, "");
+	let path = root ? root + "/" + filename : filename;
+	path = path.replace(/^\.?\//, "");
+	if (root[0] !== "/" && path[0] === "/") return;
+	return path;
+};
+//#endregion
+export { getFilePath, getFilePathWithoutDefaultDocument };

package/lib/utils/handler.d.ts

@@ -0,0 +1,9 @@
+//#region ../../plugins/acryl-router/src/core/utils/handler.d.ts
+/**
+ * @module
+ * Handler utility.
+ */
+declare const isMiddleware: (handler: Function) => boolean;
+declare const findTargetHandler: (handler: Function) => Function;
+//#endregion
+export { findTargetHandler, isMiddleware };

package/lib/utils/handler.js

@@ -0,0 +1,12 @@
+import { COMPOSED_HANDLER } from "./constants.js";
+//#region ../../plugins/acryl-router/src/core/utils/handler.ts
+/**
+* @module
+* Handler utility.
+*/
+const isMiddleware = (handler) => handler.length > 1;
+const findTargetHandler = (handler) => {
+	return handler["__COMPOSED_HANDLER"] ? findTargetHandler(handler[COMPOSED_HANDLER]) : handler;
+};
+//#endregion
+export { findTargetHandler, isMiddleware };

package/lib/utils/headers.d.ts

@@ -0,0 +1,2 @@
+import { i as ResponseHeader, n as CustomHeader, r as RequestHeader, t as AcceptHeader } from "../headers-tu2YYN8T.js";
+export { AcceptHeader, CustomHeader, RequestHeader, ResponseHeader };

package/lib/utils/headers.js

@@ -0,0 +1 @@
+export {};

package/lib/utils/html.d.ts

@@ -0,0 +1,46 @@
+//#region ../../plugins/acryl-router/src/core/utils/html.d.ts
+/**
+ * @module
+ * HTML utility.
+ */
+declare const HtmlEscapedCallbackPhase: {
+  readonly Stringify: 1;
+  readonly BeforeStream: 2;
+  readonly Stream: 3;
+};
+type HtmlEscapedCallbackOpts = {
+  buffer?: [string];
+  phase: (typeof HtmlEscapedCallbackPhase)[keyof typeof HtmlEscapedCallbackPhase];
+  context: Readonly<object>;
+};
+type HtmlEscapedCallback = (opts: HtmlEscapedCallbackOpts) => Promise<string> | undefined;
+type HtmlEscaped = {
+  isEscaped: true;
+  callbacks?: HtmlEscapedCallback[];
+};
+type HtmlEscapedString = string & HtmlEscaped;
+/**
+ * StringBuffer contains string and Promise<string> alternately
+ * The length of the array will be odd, the odd numbered element will be a string,
+ * and the even numbered element will be a Promise<string>.
+ * When concatenating into a single string, it must be processed from the tail.
+ * @example
+ * [
+ *   'framework.',
+ *   Promise.resolve('ultra fast'),
+ *   'a ',
+ *   Promise.resolve('is '),
+ *   'Acryl',
+ * ]
+ */
+type StringBuffer = (string | Promise<string>)[];
+type StringBufferWithCallbacks = StringBuffer & {
+  callbacks: HtmlEscapedCallback[];
+};
+declare const raw: (value: unknown, callbacks?: HtmlEscapedCallback[]) => HtmlEscapedString;
+declare const stringBufferToString: (buffer: StringBuffer, callbacks: HtmlEscapedCallback[] | undefined) => Promise<HtmlEscapedString>;
+declare const escapeToBuffer: (str: string, buffer: StringBuffer) => void;
+declare const resolveCallbackSync: (str: string | HtmlEscapedString) => string;
+declare const resolveCallback: (str: string | HtmlEscapedString | Promise<string>, phase: (typeof HtmlEscapedCallbackPhase)[keyof typeof HtmlEscapedCallbackPhase], preserveCallbacks: boolean, context: object, buffer?: [string]) => Promise<string>;
+//#endregion
+export { HtmlEscaped, HtmlEscapedCallback, HtmlEscapedCallbackPhase, HtmlEscapedString, StringBuffer, StringBufferWithCallbacks, escapeToBuffer, raw, resolveCallback, resolveCallbackSync, stringBufferToString };