acrylblends 0.4.1 → 0.5.0

package/lib/utils/html.js

@@ -0,0 +1,103 @@
+//#region ../../plugins/acryl-router/src/core/utils/html.ts
+/**
+* @module
+* HTML utility.
+*/
+const HtmlEscapedCallbackPhase = {
+	Stringify: 1,
+	BeforeStream: 2,
+	Stream: 3
+};
+const raw = (value, callbacks) => {
+	const escapedString = new String(value);
+	escapedString.isEscaped = true;
+	escapedString.callbacks = callbacks;
+	return escapedString;
+};
+const escapeRe = /[&<>'"]/;
+const stringBufferToString = async (buffer, callbacks) => {
+	let str = "";
+	callbacks ||= [];
+	const resolvedBuffer = await Promise.all(buffer);
+	for (let i = resolvedBuffer.length - 1;; i--) {
+		str += resolvedBuffer[i];
+		i--;
+		if (i < 0) break;
+		let r = resolvedBuffer[i];
+		if (typeof r === "object") callbacks.push(...r.callbacks || []);
+		const isEscaped = r.isEscaped;
+		r = await (typeof r === "object" ? r.toString() : r);
+		if (typeof r === "object") callbacks.push(...r.callbacks || []);
+		if (r.isEscaped ?? isEscaped) str += r;
+		else {
+			const buf = [str];
+			escapeToBuffer(r, buf);
+			str = buf[0];
+		}
+	}
+	return raw(str, callbacks);
+};
+const escapeToBuffer = (str, buffer) => {
+	const match = str.search(escapeRe);
+	if (match === -1) {
+		buffer[0] += str;
+		return;
+	}
+	let escape;
+	let index;
+	let lastIndex = 0;
+	for (index = match; index < str.length; index++) {
+		switch (str.charCodeAt(index)) {
+			case 34:
+				escape = "&quot;";
+				break;
+			case 39:
+				escape = "&#39;";
+				break;
+			case 38:
+				escape = "&amp;";
+				break;
+			case 60:
+				escape = "&lt;";
+				break;
+			case 62:
+				escape = "&gt;";
+				break;
+			default: continue;
+		}
+		buffer[0] += str.substring(lastIndex, index) + escape;
+		lastIndex = index + 1;
+	}
+	buffer[0] += str.substring(lastIndex, index);
+};
+const resolveCallbackSync = (str) => {
+	const callbacks = str.callbacks;
+	if (!callbacks?.length) return str;
+	const buffer = [str];
+	const context = {};
+	callbacks.forEach((c) => c({
+		phase: HtmlEscapedCallbackPhase.Stringify,
+		buffer,
+		context
+	}));
+	return buffer[0];
+};
+const resolveCallback = async (str, phase, preserveCallbacks, context, buffer) => {
+	if (typeof str === "object" && !(str instanceof String)) {
+		if (!(str instanceof Promise)) str = str.toString();
+		if (str instanceof Promise) str = await str;
+	}
+	const callbacks = str.callbacks;
+	if (!callbacks?.length) return Promise.resolve(str);
+	if (buffer) buffer[0] += str;
+	else buffer = [str];
+	const resStr = Promise.all(callbacks.map((c) => c({
+		phase,
+		buffer,
+		context
+	}))).then((res) => Promise.all(res.filter(Boolean).map((str) => resolveCallback(str, phase, false, context, buffer))).then(() => buffer[0]));
+	if (preserveCallbacks) return raw(await resStr, callbacks);
+	else return resStr;
+};
+//#endregion
+export { HtmlEscapedCallbackPhase, escapeToBuffer, raw, resolveCallback, resolveCallbackSync, stringBufferToString };

package/lib/utils/http-status.d.ts

@@ -0,0 +1,2 @@
+import { a as InfoStatusCode, c as StatusCode, d as UnofficialStatusCode, i as DeprecatedStatusCode, l as SuccessStatusCode, n as ContentfulStatusCode, o as RedirectStatusCode, r as ContentlessStatusCode, s as ServerErrorStatusCode, t as ClientErrorStatusCode, u as UnOfficalStatusCode } from "../http-status-DaAwGAFL.js";
+export { ClientErrorStatusCode, ContentfulStatusCode, ContentlessStatusCode, DeprecatedStatusCode, InfoStatusCode, RedirectStatusCode, ServerErrorStatusCode, StatusCode, SuccessStatusCode, UnOfficalStatusCode, UnofficialStatusCode };

package/lib/utils/http-status.js

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

package/lib/utils/ipaddr.d.ts

@@ -0,0 +1,56 @@
+import { t as AddressType } from "../types-CDO6I3B0.js";
+
+//#region ../../plugins/acryl-router/src/core/utils/ipaddr.d.ts
+/**
+ * Expand IPv6 Address
+ * @param ipV6 Shorten IPv6 Address
+ * @return expanded IPv6 Address
+ */
+declare const expandIPv6: (ipV6: string) => string;
+declare const INVALID_IP_ADDRESS_ERROR_CODE = "ERR_INVALID_IP_ADDRESS";
+type InvalidIPAddressError = TypeError & {
+  code: typeof INVALID_IP_ADDRESS_ERROR_CODE;
+};
+/**
+ * Distinct Remote Addr
+ * @param remoteAddr Remote Addr
+ */
+declare const distinctRemoteAddr: (remoteAddr: string) => AddressType;
+/**
+ * Convert IPv4 to Uint8Array
+ * @param ipv4 IPv4 Address
+ * @returns BigInt
+ */
+declare const convertIPv4ToBinary: (ipv4: string) => bigint;
+/**
+ * Convert IPv6 to Uint8Array
+ * @param ipv6 IPv6 Address
+ * @returns BigInt
+ */
+declare const convertIPv6ToBinary: (ipv6: string) => bigint;
+/**
+ * Convert a binary representation of an IPv4 address to a string.
+ * @param ipV4 binary IPv4 Address
+ * @return IPv4 Address in string
+ */
+declare const convertIPv4BinaryToString: (ipV4: bigint) => string;
+/**
+ * Check if a binary IPv6 address is an IPv4-mapped IPv6 address (::ffff:x.x.x.x)
+ * @param ipv6binary binary IPv6 Address
+ * @return true if the address is an IPv4-mapped IPv6 address
+ */
+declare const isIPv4MappedIPv6: (ipv6binary: bigint) => boolean;
+/**
+ * Extract the IPv4 portion from an IPv4-mapped IPv6 address
+ * @param ipv6binary binary IPv4-mapped IPv6 Address
+ * @return binary IPv4 Address
+ */
+declare const convertIPv4MappedIPv6ToIPv4: (ipv6binary: bigint) => bigint;
+/**
+ * Convert a binary representation of an IPv6 address to a string.
+ * @param ipV6 binary IPv6 Address
+ * @return normalized IPv6 Address in string
+ */
+declare const convertIPv6BinaryToString: (ipV6: bigint) => string;
+//#endregion
+export { INVALID_IP_ADDRESS_ERROR_CODE, InvalidIPAddressError, convertIPv4BinaryToString, convertIPv4MappedIPv6ToIPv4, convertIPv4ToBinary, convertIPv6BinaryToString, convertIPv6ToBinary, distinctRemoteAddr, expandIPv6, isIPv4MappedIPv6 };

package/lib/utils/ipaddr.js

@@ -0,0 +1,238 @@
+//#region ../../plugins/acryl-router/src/core/utils/ipaddr.ts
+/**
+* Expand IPv6 Address
+* @param ipV6 Shorten IPv6 Address
+* @return expanded IPv6 Address
+*/
+const expandIPv6 = (ipV6) => {
+	const sections = ipV6.split(":");
+	const lastSection = sections.at(-1);
+	if (IPV4_REGEX.test(lastSection)) {
+		const octets = lastSection.split(".").map(Number);
+		sections.splice(-1, 1, (octets[0] << 8 | octets[1]).toString(16), (octets[2] << 8 | octets[3]).toString(16));
+	}
+	for (let i = 0; i < sections.length; i++) {
+		const node = sections[i];
+		if (node !== "") sections[i] = node.padStart(4, "0");
+		else {
+			while (sections[i + 1] === "") sections.splice(i + 1, 1);
+			sections[i] = new Array(8 - sections.length + 1).fill("0000").join(":");
+		}
+	}
+	return sections.join(":");
+};
+const IPV4_OCTET_PART = "(?:25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])";
+const IPV4_REGEX = new RegExp(`^(?:${IPV4_OCTET_PART}\\.){3}${IPV4_OCTET_PART}$`);
+const INVALID_IP_ADDRESS_ERROR_CODE = "ERR_INVALID_IP_ADDRESS";
+const CHAR_CODE_0 = 48;
+const CHAR_CODE_9 = 57;
+const CHAR_CODE_A = 65;
+const CHAR_CODE_F = 70;
+const CHAR_CODE_a = 97;
+const CHAR_CODE_f = 102;
+const CHAR_CODE_DOT = 46;
+const CHAR_CODE_COLON = 58;
+const CHAR_CODE_PERCENT = 37;
+/**
+* Distinct Remote Addr
+* @param remoteAddr Remote Addr
+*/
+const distinctRemoteAddr = (remoteAddr) => {
+	if (IPV4_REGEX.test(remoteAddr)) return "IPv4";
+	if (remoteAddr.includes(":")) return "IPv6";
+};
+const createInvalidIPAddressError = (message) => {
+	const error = new TypeError(message);
+	error.code = INVALID_IP_ADDRESS_ERROR_CODE;
+	return error;
+};
+const throwInvalidIPv4Address = (ipv4) => {
+	throw createInvalidIPAddressError(`Invalid IPv4 address: ${ipv4}`);
+};
+const throwInvalidIPv6Address = (ipv6) => {
+	throw createInvalidIPAddressError(`Invalid IPv6 address: ${ipv6}`);
+};
+const parseIPv4ToBinary = (ipv4, start, end, onInvalid) => {
+	let result = 0n;
+	let octets = 0;
+	let octet = 0;
+	let digits = 0;
+	let firstDigit = 0;
+	for (let i = start; i <= end; i++) {
+		const code = i < end ? ipv4.charCodeAt(i) : CHAR_CODE_DOT;
+		if (code >= CHAR_CODE_0 && code <= CHAR_CODE_9) {
+			if (digits === 0) firstDigit = code;
+			else if (firstDigit === CHAR_CODE_0) onInvalid();
+			octet = octet * 10 + code - CHAR_CODE_0;
+			if (octet > 255) onInvalid();
+			digits++;
+			continue;
+		}
+		if (code !== CHAR_CODE_DOT || digits === 0 || octets === 4) onInvalid();
+		result = (result << 8n) + BigInt(octet);
+		octets++;
+		octet = 0;
+		digits = 0;
+	}
+	if (octets !== 4) onInvalid();
+	return result;
+};
+const parseIPv6HexCode = (code) => {
+	if (code >= CHAR_CODE_0 && code <= CHAR_CODE_9) return code - CHAR_CODE_0;
+	if (code >= CHAR_CODE_A && code <= CHAR_CODE_F) return code - CHAR_CODE_A + 10;
+	if (code >= CHAR_CODE_a && code <= CHAR_CODE_f) return code - CHAR_CODE_a + 10;
+	return -1;
+};
+const isIPv6LinkLocal = (ipv6binary) => ipv6binary >> 118n === 1018n;
+/**
+* Convert IPv4 to Uint8Array
+* @param ipv4 IPv4 Address
+* @returns BigInt
+*/
+const convertIPv4ToBinary = (ipv4) => {
+	return parseIPv4ToBinary(ipv4, 0, ipv4.length, () => throwInvalidIPv4Address(ipv4));
+};
+/**
+* Convert IPv6 to Uint8Array
+* @param ipv6 IPv6 Address
+* @returns BigInt
+*/
+const convertIPv6ToBinary = (ipv6) => {
+	const length = ipv6.length;
+	const sections = [];
+	let hasZoneId = false;
+	let compressAt = -1;
+	let index = 0;
+	if (length === 0) throwInvalidIPv6Address(ipv6);
+	while (index < length) {
+		if (sections.length > 8) throwInvalidIPv6Address(ipv6);
+		let code = ipv6.charCodeAt(index);
+		if (code === CHAR_CODE_PERCENT) {
+			if (index + 1 === length) throwInvalidIPv6Address(ipv6);
+			hasZoneId = true;
+			break;
+		}
+		if (code === CHAR_CODE_COLON) {
+			if (index + 1 < length && ipv6.charCodeAt(index + 1) === CHAR_CODE_COLON) {
+				if (compressAt !== -1) throwInvalidIPv6Address(ipv6);
+				compressAt = sections.length;
+				index += 2;
+				continue;
+			}
+			throwInvalidIPv6Address(ipv6);
+		}
+		let value = 0;
+		let digits = 0;
+		const sectionStart = index;
+		while (index < length) {
+			code = ipv6.charCodeAt(index);
+			const hex = parseIPv6HexCode(code);
+			if (hex === -1) break;
+			if (digits === 4) throwInvalidIPv6Address(ipv6);
+			value = value << 4 | hex;
+			digits++;
+			index++;
+		}
+		if (index < length && ipv6.charCodeAt(index) === CHAR_CODE_DOT) {
+			let ipv4End = length;
+			for (let i = index; i < length; i++) if (ipv6.charCodeAt(i) === CHAR_CODE_PERCENT) {
+				if (i + 1 === length) throwInvalidIPv6Address(ipv6);
+				hasZoneId = true;
+				ipv4End = i;
+				break;
+			}
+			const ipv4 = parseIPv4ToBinary(ipv6, sectionStart, ipv4End, () => throwInvalidIPv6Address(ipv6));
+			sections.push(Number(ipv4 >> 16n & 65535n), Number(ipv4 & 65535n));
+			index = length;
+			break;
+		}
+		if (digits === 0) throwInvalidIPv6Address(ipv6);
+		sections.push(value);
+		if (index === length) break;
+		code = ipv6.charCodeAt(index);
+		if (code === CHAR_CODE_PERCENT) {
+			if (index + 1 === length) throwInvalidIPv6Address(ipv6);
+			hasZoneId = true;
+			break;
+		}
+		if (code !== CHAR_CODE_COLON) throwInvalidIPv6Address(ipv6);
+		if (index + 1 < length && ipv6.charCodeAt(index + 1) === CHAR_CODE_COLON) {
+			if (compressAt !== -1) throwInvalidIPv6Address(ipv6);
+			compressAt = sections.length;
+			index += 2;
+			continue;
+		}
+		index++;
+		if (index === length) throwInvalidIPv6Address(ipv6);
+	}
+	if (compressAt === -1 ? sections.length !== 8 : sections.length >= 8) throwInvalidIPv6Address(ipv6);
+	let result = 0n;
+	const zeros = compressAt === -1 ? 0 : 8 - sections.length;
+	const firstSectionEnd = compressAt === -1 ? sections.length : compressAt;
+	for (let i = 0; i < firstSectionEnd; i++) {
+		result <<= 16n;
+		result += BigInt(sections[i]);
+	}
+	for (let i = 0; i < zeros; i++) result <<= 16n;
+	for (let i = firstSectionEnd; i < sections.length; i++) {
+		result <<= 16n;
+		result += BigInt(sections[i]);
+	}
+	if (hasZoneId && !isIPv6LinkLocal(result)) throwInvalidIPv6Address(ipv6);
+	return result;
+};
+/**
+* Convert a binary representation of an IPv4 address to a string.
+* @param ipV4 binary IPv4 Address
+* @return IPv4 Address in string
+*/
+const convertIPv4BinaryToString = (ipV4) => {
+	const sections = [];
+	for (let i = 0; i < 4; i++) sections.push(ipV4 >> BigInt(8 * (3 - i)) & 255n);
+	return sections.join(".");
+};
+/**
+* Check if a binary IPv6 address is an IPv4-mapped IPv6 address (::ffff:x.x.x.x)
+* @param ipv6binary binary IPv6 Address
+* @return true if the address is an IPv4-mapped IPv6 address
+*/
+const isIPv4MappedIPv6 = (ipv6binary) => ipv6binary >> 32n === 65535n;
+/**
+* Extract the IPv4 portion from an IPv4-mapped IPv6 address
+* @param ipv6binary binary IPv4-mapped IPv6 Address
+* @return binary IPv4 Address
+*/
+const convertIPv4MappedIPv6ToIPv4 = (ipv6binary) => ipv6binary & 4294967295n;
+/**
+* Convert a binary representation of an IPv6 address to a string.
+* @param ipV6 binary IPv6 Address
+* @return normalized IPv6 Address in string
+*/
+const convertIPv6BinaryToString = (ipV6) => {
+	if (ipV6 === 0n) return "::";
+	if (isIPv4MappedIPv6(ipV6)) return `::ffff:${convertIPv4BinaryToString(convertIPv4MappedIPv6ToIPv4(ipV6))}`;
+	const sections = [];
+	for (let i = 0; i < 8; i++) sections.push((ipV6 >> BigInt(16 * (7 - i)) & 65535n).toString(16));
+	let currentZeroStart = -1;
+	let maxZeroStart = -1;
+	let maxZeroEnd = -1;
+	for (let i = 0; i < 8; i++) if (sections[i] === "0") {
+		if (currentZeroStart === -1) currentZeroStart = i;
+	} else if (currentZeroStart > -1) {
+		if (i - currentZeroStart > maxZeroEnd - maxZeroStart) {
+			maxZeroStart = currentZeroStart;
+			maxZeroEnd = i;
+		}
+		currentZeroStart = -1;
+	}
+	if (currentZeroStart > -1) {
+		if (8 - currentZeroStart > maxZeroEnd - maxZeroStart) {
+			maxZeroStart = currentZeroStart;
+			maxZeroEnd = 8;
+		}
+	}
+	if (maxZeroStart !== -1 && maxZeroEnd - maxZeroStart > 1) sections.splice(maxZeroStart, maxZeroEnd - maxZeroStart, ":");
+	return sections.join(":").replace(/:{2,}/g, "::");
+};
+//#endregion
+export { INVALID_IP_ADDRESS_ERROR_CODE, convertIPv4BinaryToString, convertIPv4MappedIPv6ToIPv4, convertIPv4ToBinary, convertIPv6BinaryToString, convertIPv6ToBinary, distinctRemoteAddr, expandIPv6, isIPv4MappedIPv6 };

package/lib/utils/jwt.d.ts

@@ -0,0 +1,24 @@
+import { a as SignatureKey, c as SignatureAlgorithm, i as AcrylJsonWebKey, n as VerifyOptions, r as VerifyOptionsWithAlg, s as AsymmetricAlgorithm, t as TokenHeader } from "../jwt-Dg493Tai.js";
+import { t as JWTPayload } from "../types-DR95J00T.js";
+
+//#region ../../plugins/acryl-router/src/core/utils/jwt/index.d.ts
+/**
+ * @module
+ * JWT utility.
+ */
+declare const Jwt: {
+  sign: (payload: JWTPayload, privateKey: SignatureKey, alg?: SignatureAlgorithm) => Promise<string>;
+  verify: (token: string, publicKey: SignatureKey, algOrOptions: SignatureAlgorithm | VerifyOptionsWithAlg) => Promise<JWTPayload>;
+  decode: (token: string) => {
+    header: TokenHeader;
+    payload: JWTPayload;
+  };
+  verifyWithJwks: (token: string, options: {
+    keys?: AcrylJsonWebKey[];
+    jwks_uri?: string;
+    verification?: VerifyOptions;
+    allowedAlgorithms: readonly AsymmetricAlgorithm[];
+  }, init?: RequestInit) => Promise<JWTPayload>;
+};
+//#endregion
+export { Jwt };

package/lib/utils/jwt.js

@@ -0,0 +1,2 @@
+import { t as Jwt } from "../jwt-BGJBw5AF.js";
+export { Jwt };

package/lib/utils/mime.d.ts

@@ -0,0 +1,2 @@
+import { i as getMimeType, n as baseMimes, r as getExtension, t as BaseMime } from "../mime-BQOYHl-l.js";
+export { BaseMime, getExtension, getMimeType, baseMimes as mimes };

package/lib/utils/mime.js

@@ -0,0 +1,77 @@
+//#region ../../plugins/acryl-router/src/core/utils/mime.ts
+/**
+* @module
+* MIME utility.
+*/
+const getMimeType = (filename, mimes = baseMimes) => {
+	const match = filename.match(/\.([a-zA-Z0-9]+?)$/);
+	if (!match) return;
+	return mimes[match[1].toLowerCase()];
+};
+const getExtension = (mimeType) => {
+	const baseType = mimeType.split(";", 1)[0].trim();
+	for (const ext in baseMimes) {
+		const stored = baseMimes[ext];
+		if (stored === mimeType || stored.split(";", 1)[0].trim() === baseType) return ext;
+	}
+};
+const baseMimes = {
+	aac: "audio/aac",
+	avi: "video/x-msvideo",
+	avif: "image/avif",
+	av1: "video/av1",
+	bin: "application/octet-stream",
+	bmp: "image/bmp",
+	css: "text/css; charset=utf-8",
+	csv: "text/csv; charset=utf-8",
+	eot: "application/vnd.ms-fontobject",
+	epub: "application/epub+zip",
+	gif: "image/gif",
+	gz: "application/gzip",
+	htm: "text/html; charset=utf-8",
+	html: "text/html; charset=utf-8",
+	ico: "image/x-icon",
+	ics: "text/calendar; charset=utf-8",
+	jpeg: "image/jpeg",
+	jpg: "image/jpeg",
+	js: "text/javascript; charset=utf-8",
+	json: "application/json",
+	jsonld: "application/ld+json",
+	map: "application/json",
+	mid: "audio/x-midi",
+	midi: "audio/x-midi",
+	mjs: "text/javascript; charset=utf-8",
+	mp3: "audio/mpeg",
+	mp4: "video/mp4",
+	mpeg: "video/mpeg",
+	oga: "audio/ogg",
+	ogv: "video/ogg",
+	ogx: "application/ogg",
+	opus: "audio/opus",
+	otf: "font/otf",
+	pdf: "application/pdf",
+	png: "image/png",
+	rtf: "application/rtf",
+	svg: "image/svg+xml; charset=utf-8",
+	tif: "image/tiff",
+	tiff: "image/tiff",
+	ts: "video/mp2t",
+	ttf: "font/ttf",
+	txt: "text/plain; charset=utf-8",
+	wasm: "application/wasm",
+	webm: "video/webm",
+	weba: "audio/webm",
+	webmanifest: "application/manifest+json",
+	webp: "image/webp",
+	woff: "font/woff",
+	woff2: "font/woff2",
+	xhtml: "application/xhtml+xml; charset=utf-8",
+	xml: "application/xml; charset=utf-8",
+	zip: "application/zip",
+	"3gp": "video/3gpp",
+	"3g2": "video/3gpp2",
+	gltf: "model/gltf+json",
+	glb: "model/gltf-binary"
+};
+//#endregion
+export { getExtension, getMimeType, baseMimes as mimes };

package/lib/utils/stream.d.ts

@@ -0,0 +1,2 @@
+import { t as StreamingApi } from "../stream-CPdqZ0Fp.js";
+export { StreamingApi };

package/lib/utils/stream.js

@@ -0,0 +1,88 @@
+//#region ../../plugins/acryl-router/src/core/utils/stream.ts
+/**
+* @module
+* Stream utility.
+*/
+var StreamingApi = class {
+	writer;
+	encoder;
+	writable;
+	abortSubscribers = [];
+	responseReadable;
+	/**
+	* Whether the stream has been aborted.
+	*/
+	aborted = false;
+	/**
+	* Whether the stream has been closed normally.
+	*/
+	closed = false;
+	constructor(writable, _readable) {
+		this.writable = writable;
+		this.writer = writable.getWriter();
+		this.encoder = new TextEncoder();
+		const reader = _readable.getReader();
+		this.abortSubscribers.push(async () => {
+			await reader.cancel();
+		});
+		this.responseReadable = new ReadableStream({
+			async pull(controller) {
+				const { done, value } = await reader.read();
+				done ? controller.close() : controller.enqueue(value);
+			},
+			cancel: () => {
+				if (!this.closed) this.abort();
+			}
+		});
+	}
+	async write(input) {
+		try {
+			if (typeof input === "string") input = this.encoder.encode(input);
+			await this.writer.write(input);
+		} catch {}
+		return this;
+	}
+	async writeln(input) {
+		await this.write(input + "\n");
+		return this;
+	}
+	sleep(ms) {
+		return new Promise((res) => setTimeout(res, ms));
+	}
+	async close() {
+		this.closed = true;
+		try {
+			await this.writer.close();
+		} catch {}
+	}
+	async pipe(body) {
+		this.writer.releaseLock();
+		try {
+			await body.pipeTo(this.writable, {
+				preventClose: true,
+				preventAbort: true
+			});
+		} finally {
+			this.writer = this.writable.getWriter();
+		}
+	}
+	onAbort(listener) {
+		this.abortSubscribers.push(listener);
+	}
+	/**
+	* Abort the stream.
+	* You can call this method when stream is aborted by external event.
+	*/
+	abort() {
+		if (!this.aborted) {
+			this.aborted = true;
+			this.abortSubscribers.forEach((subscriber) => {
+				try {
+					Promise.resolve(subscriber()).catch(() => {});
+				} catch {}
+			});
+		}
+	}
+};
+//#endregion
+export { StreamingApi };

package/lib/utils/types.d.ts

@@ -0,0 +1,2 @@
+import { C as SimplifyDeepArray, S as Simplify, T as UnionToIntersection, _ as JsonWebKey, a as Equal, b as RemoveBlankRecord, c as IfAnyThenEmptyObject, d as IsAny, f as JSONArray, g as JSONValue, h as JSONPrimitive, i as CryptoKey, l as InterfaceToType, m as JSONParsed, n as BufferSource, o as Expect, p as JSONObject, r as CloseEvent, s as HasRequiredKeys, t as BinaryType, u as InvalidJSONValue, v as MessageEvent, w as StringLiteralUnion, x as RequiredKeysOf, y as NotEqual } from "../types-CwrQjlaM.js";
+export { BinaryType, BufferSource, CloseEvent, CryptoKey, Equal, Expect, HasRequiredKeys, IfAnyThenEmptyObject, InterfaceToType, InvalidJSONValue, IsAny, JSONArray, JSONObject, JSONParsed, JSONPrimitive, JSONValue, JsonWebKey, MessageEvent, NotEqual, RemoveBlankRecord, RequiredKeysOf, Simplify, SimplifyDeepArray, StringLiteralUnion, UnionToIntersection };

package/lib/utils/types.js

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

package/lib/utils/url.d.ts

@@ -0,0 +1,46 @@
+//#region ../../plugins/acryl-router/src/core/utils/url.d.ts
+/**
+ * @module
+ * URL utility.
+ */
+type Pattern = readonly [string, string, RegExp | true] | '*';
+declare const splitPath: (path: string) => string[];
+declare const splitRoutingPath: (routePath: string) => string[];
+declare const getPattern: (label: string, next?: string) => Pattern | null;
+type Decoder = (str: string) => string;
+declare const tryDecode: (str: string, decoder: Decoder) => string;
+/**
+ * Try to apply decodeURI() to given string.
+ * If it fails, skip invalid percent encoding or invalid UTF-8 sequences, and apply decodeURI() to the rest as much as possible.
+ * @param str The string to decode.
+ * @returns The decoded string that sometimes contains undecodable percent encoding.
+ * @example
+ * tryDecodeURI('Hello%20World') // 'Hello World'
+ * tryDecodeURI('Hello%20World/%A4%A2') // 'Hello World/%A4%A2'
+ */
+declare const tryDecodeURI: (str: string) => string;
+declare const getPath: (request: Request) => string;
+/**
+ * @deprecated
+ * Use the `URL` API instead.
+ */
+declare const getQueryStrings: (url: string) => string;
+declare const getPathNoStrict: (request: Request) => string;
+/**
+ * Merge paths.
+ * @param {string[]} ...paths - The paths to merge.
+ * @returns {string} The merged path.
+ * @example
+ * mergePath('/api', '/users') // '/api/users'
+ * mergePath('/api/', '/users') // '/api/users'
+ * mergePath('/api', '/') // '/api'
+ * mergePath('/api/', '/') // '/api/'
+ */
+declare const mergePath: (...paths: string[]) => string;
+declare const checkOptionalParameter: (path: string) => string[] | null;
+declare const tryDecodeURIComponent: (str: string) => string;
+declare const getQueryParam: (url: string, key?: string) => string | undefined | Record<string, string>;
+declare const getQueryParams: (url: string, key?: string) => string[] | undefined | Record<string, string[]>;
+declare const decodeURIComponent_: typeof decodeURIComponent;
+//#endregion
+export { Pattern, checkOptionalParameter, decodeURIComponent_, getPath, getPathNoStrict, getPattern, getQueryParam, getQueryParams, getQueryStrings, mergePath, splitPath, splitRoutingPath, tryDecode, tryDecodeURI, tryDecodeURIComponent };