@yorozu/utils 0.1.1 → 0.3.0

package/index.js

@@ -0,0 +1,1819 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region src/arrays/typed/compare.ts
+function compare(a, b) {
+	if (a.length < b.length) return -1;
+	if (a.length > b.length) return 1;
+	for (let i = 0; i < a.length; i++) {
+		if (a[i] < b[i]) return -1;
+		if (a[i] > b[i]) return 1;
+	}
+	return 0;
+}
+function equal(a, b) {
+	return compare(a, b) === 0;
+}
+//#endregion
+//#region src/arrays/typed/find.ts
+function indexOf(haystack, needle, start = 0) {
+	let length = haystack.length;
+	if (start < 0) {
+		start += length;
+		if (start < 0) start = 0;
+	}
+	for (let i = start; i < length; i++) if (haystack[i] === needle) return i;
+	return -1;
+}
+function lastIndexOf(haystack, needle, start = haystack.length - 1) {
+	let length = haystack.length;
+	if (start < 0) {
+		start += length;
+		if (start < 0) return -1;
+	} else if (start >= length) start = length - 1;
+	for (let i = start; i >= 0; i--) if (haystack[i] === needle) return i;
+	return -1;
+}
+function indexOfArray(haystack, needle, start = 0) {
+	if (needle.length === 0) return start;
+	if (needle.length === 1) return indexOf(haystack, needle[0], start);
+	let max = haystack.length - needle.length;
+	for (let i = start; i <= max; i++) if (haystack[i] === needle[0]) {
+		let j = 1;
+		for (; j < needle.length; j++) if (haystack[i + j] !== needle[j]) break;
+		if (j === needle.length) return i;
+	}
+	return -1;
+}
+function lastIndexOfArray(haystack, needle, start = haystack.length - 1) {
+	if (needle.length === 0) return start;
+	if (needle.length === 1) return lastIndexOf(haystack, needle[0], start);
+	let maxStart = haystack.length - needle.length;
+	let effectiveStart = start > maxStart ? maxStart : start;
+	for (let i = effectiveStart; i >= 0; i--) {
+		let j = 0;
+		for (; j < needle.length; j++) if (haystack[i + j] !== needle[j]) break;
+		if (j === needle.length) return i;
+	}
+	return -1;
+}
+function includes(haystack, needle) {
+	for (let i = 0; i < haystack.length; i++) {
+		let value = haystack[i];
+		if (value === needle || Number.isNaN(value) && Number.isNaN(needle)) return true;
+	}
+	return false;
+}
+function includesArray(haystack, needle) {
+	return indexOfArray(haystack, needle) !== -1;
+}
+//#endregion
+//#region src/arrays/typed/misc.ts
+function toDataView(buf) {
+	return new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+}
+function view(ctor, buf) {
+	let byteLength = buf.byteLength;
+	let bytesPerElement = ctor.BYTES_PER_ELEMENT;
+	if (byteLength % bytesPerElement !== 0) throw new RangeError(`byteLength (${byteLength}) is not a multiple of ${bytesPerElement} for ${ctor.name}`);
+	let length = byteLength / bytesPerElement;
+	return new ctor(buf.buffer, buf.byteOffset, length);
+}
+function getPlatformByteOrder() {
+	if (getPlatformByteOrder._cachedByteOrder === null) {
+		let buffer = /* @__PURE__ */ new ArrayBuffer(2);
+		new DataView(buffer).setUint16(0, 4660, true);
+		getPlatformByteOrder._cachedByteOrder = new Uint16Array(buffer)[0] === 4660;
+	}
+	return getPlatformByteOrder._cachedByteOrder ? "little" : "big";
+}
+getPlatformByteOrder._cachedByteOrder = null;
+//#endregion
+//#region src/arrays/typed/index.ts
+var typed_exports = /* @__PURE__ */ __exportAll({
+	compare: () => compare,
+	equal: () => equal,
+	getPlatformByteOrder: () => getPlatformByteOrder,
+	includes: () => includes,
+	includesArray: () => includesArray,
+	indexOf: () => indexOf,
+	indexOfArray: () => indexOfArray,
+	lastIndexOf: () => lastIndexOf,
+	lastIndexOfArray: () => lastIndexOfArray,
+	toDataView: () => toDataView,
+	view: () => view
+});
+//#endregion
+//#region src/arrays/u8/misc.ts
+var empty = new Uint8Array(0);
+function clone(buf) {
+	return new Uint8Array(buf);
+}
+function readNthBit(byte, bit) {
+	return (byte & 1 << bit) >> bit;
+}
+//#endregion
+//#region src/arrays/u8/pool.ts
+var BufferPool = class {
+	size;
+	maxAllocSize;
+	#pool;
+	#offset = 0;
+	constructor(size = 16 * 1024) {
+		this.size = size;
+		this.maxAllocSize = size >>> 1;
+		this.#reallocate();
+	}
+	get #remaining() {
+		return this.size - this.#offset;
+	}
+	allocate(size) {
+		if (!Number.isInteger(size) || size < 0) throw new RangeError(`Invalid allocation size: ${size}.`);
+		if (size === 0) return empty;
+		if (size > this.maxAllocSize) return new Uint8Array(size);
+		if (size > this.#remaining) this.#reallocate();
+		let start = this.#offset;
+		this.#offset += size;
+		this.#align();
+		return new Uint8Array(this.#pool, start, size);
+	}
+	reset() {
+		this.#reallocate();
+	}
+	#reallocate() {
+		this.#pool = new ArrayBuffer(this.size);
+		this.#offset = 0;
+	}
+	#align() {
+		let misalignment = this.#offset & 7;
+		if (misalignment !== 0) this.#offset += 8 - misalignment;
+	}
+};
+var defaultPool = new BufferPool(16 * 1024);
+function setDefaultPool(size) {
+	defaultPool = new BufferPool(size);
+}
+function allocate(size) {
+	return defaultPool.allocate(size);
+}
+function allocateWith(init) {
+	let buf = allocate(init.length);
+	buf.set(init);
+	return buf;
+}
+//#endregion
+//#region src/arrays/u8/concat.ts
+function concat(bufs) {
+	if (bufs.length === 0) return allocate(0);
+	if (bufs.length === 1) return bufs[0];
+	if (typeof Buffer !== "undefined") {
+		let buf = Buffer.concat(bufs);
+		return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+	}
+	let length = 0;
+	for (let i = 0; i < bufs.length; i++) length += bufs[i].length;
+	let ret = allocate(length);
+	let offset = 0;
+	for (let i = 0; i < bufs.length; i++) {
+		ret.set(bufs[i], offset);
+		offset += bufs[i].length;
+	}
+	return ret;
+}
+function concat2(a, b) {
+	let ret = allocate(a.length + b.length);
+	ret.set(a);
+	ret.set(b, a.length);
+	return ret;
+}
+function concat3(a, b, c) {
+	let ret = allocate(a.length + b.length + c.length);
+	ret.set(a);
+	ret.set(b, a.length);
+	ret.set(c, a.length + b.length);
+	return ret;
+}
+//#endregion
+//#region src/arrays/u8/reverse.ts
+function reverse(buffer) {
+	if (buffer.length < 2) return;
+	let left = 0;
+	let right = buffer.length - 1;
+	while (left < right) {
+		let tmp = buffer[left];
+		buffer[left] = buffer[right];
+		buffer[right] = tmp;
+		left++;
+		right--;
+	}
+}
+function toReversed(buffer) {
+	let len = buffer.length;
+	if (len === 0) return allocate(0);
+	if (len === 1) {
+		let result = allocate(1);
+		result[0] = buffer[0];
+		return result;
+	}
+	let result = allocate(len);
+	let last = len - 1;
+	for (let i = 0; i < len; i++) result[i] = buffer[last - i];
+	return result;
+}
+//#endregion
+//#region src/arrays/u8/swap.ts
+function swap16(buf) {
+	if (buf.length % 2 !== 0) throw new RangeError(`Buffer length must be a multiple of 2`);
+	for (let i = 0; i < buf.length; i += 2) {
+		let tmp = buf[i];
+		buf[i] = buf[i + 1];
+		buf[i + 1] = tmp;
+	}
+}
+function swap32(buf) {
+	if (buf.length % 4 !== 0) throw new RangeError(`Buffer length must be a multiple of 4`);
+	for (let i = 0; i < buf.length; i += 4) {
+		let tmp = buf[i];
+		buf[i] = buf[i + 3];
+		buf[i + 3] = tmp;
+		tmp = buf[i + 1];
+		buf[i + 1] = buf[i + 2];
+		buf[i + 2] = tmp;
+	}
+}
+function swap64(buf) {
+	if (buf.length % 8 !== 0) throw new RangeError(`Buffer length must be a multiple of 8`);
+	for (let i = 0; i < buf.length; i += 8) {
+		let tmp = buf[i];
+		buf[i] = buf[i + 7];
+		buf[i + 7] = tmp;
+		tmp = buf[i + 1];
+		buf[i + 1] = buf[i + 6];
+		buf[i + 6] = tmp;
+		tmp = buf[i + 2];
+		buf[i + 2] = buf[i + 5];
+		buf[i + 5] = tmp;
+		tmp = buf[i + 3];
+		buf[i + 3] = buf[i + 4];
+		buf[i + 4] = tmp;
+	}
+}
+function swapNibbles(buf) {
+	for (let i = 0; i < buf.length; i++) buf[i] = (buf[i] & 240) >> 4 | (buf[i] & 15) << 4;
+}
+//#endregion
+//#region src/arrays/u8/xor.ts
+function xor(data, key) {
+	if (key.length < data.length) throw new RangeError(`Key must be at least as long as data (key=${key.length}, data=${data.length})`);
+	let ret = allocate(data.length);
+	for (let i = 0; i < data.length; i++) ret[i] = data[i] ^ key[i];
+	return ret;
+}
+function xorInPlace(data, key) {
+	if (key.length < data.length) throw new RangeError(`Key must be at least as long as data (key=${key.length}, data=${data.length})`);
+	for (let i = 0; i < data.length; i++) data[i] ^= key[i];
+}
+//#endregion
+//#region src/arrays/u8/index.ts
+var u8_exports = /* @__PURE__ */ __exportAll({
+	BufferPool: () => BufferPool,
+	allocate: () => allocate,
+	allocateWith: () => allocateWith,
+	clone: () => clone,
+	concat: () => concat,
+	concat2: () => concat2,
+	concat3: () => concat3,
+	empty: () => empty,
+	readNthBit: () => readNthBit,
+	reverse: () => reverse,
+	setDefaultPool: () => setDefaultPool,
+	swap16: () => swap16,
+	swap32: () => swap32,
+	swap64: () => swap64,
+	swapNibbles: () => swapNibbles,
+	toReversed: () => toReversed,
+	xor: () => xor,
+	xorInPlace: () => xorInPlace
+});
+//#endregion
+//#region src/bigint/math.ts
+function bitLength(n) {
+	if (n === 0n) return 0;
+	if (n < 0n) n = -n;
+	let hex = n.toString(16);
+	let len = hex.length;
+	let leadingDigit = parseInt(hex[0], 16);
+	return (len - 1) * 4 + (32 - Math.clz32(leadingDigit));
+}
+function twoMultiplicity(n) {
+	if (n === 0n) return 0n;
+	let m = 0n;
+	let pow = 1n;
+	while (true) {
+		if ((n & pow) !== 0n) return m;
+		m += 1n;
+		pow <<= 1n;
+	}
+}
+function min2(a, b) {
+	return a < b ? a : b;
+}
+function min(...args) {
+	let m = args[0];
+	for (let i = 1; i < args.length; i++) if (args[i] < m) m = args[i];
+	return m;
+}
+function max2(a, b) {
+	return a > b ? a : b;
+}
+function max(...args) {
+	let m = args[0];
+	for (let i = 1; i < args.length; i++) if (args[i] > m) m = args[i];
+	return m;
+}
+function abs(a) {
+	return a < 0n ? -a : a;
+}
+function euclideanGcd(a, b) {
+	while (b !== 0n) {
+		let t = b;
+		b = a % b;
+		a = t;
+	}
+	return a < 0n ? -a : a;
+}
+function modPowBinary(base, exp, mod) {
+	if (exp < 0n) throw new RangeError("Negative exponent is not supported.");
+	if (mod === 1n) return 0n;
+	base %= mod;
+	if (base < 0n) base += mod;
+	let result = 1n;
+	while (exp > 0n) {
+		if (exp % 2n === 1n) result = result * base % mod;
+		exp >>= 1n;
+		base = base ** 2n % mod;
+	}
+	return result;
+}
+function modInv(a, n) {
+	let [g, x] = eGcd(toZn(a, n), n);
+	if (g !== 1n) throw new RangeError(`${a.toString()} does not have inverse modulo ${n.toString()}`);
+	else return toZn(x, n);
+}
+function eGcd(a, b) {
+	let x = 0n;
+	let y = 1n;
+	let u = 1n;
+	let v = 0n;
+	while (a !== 0n) {
+		let q = b / a;
+		let r = b % a;
+		let m = x - u * q;
+		let n = y - v * q;
+		b = a;
+		a = r;
+		x = u;
+		y = v;
+		u = m;
+		v = n;
+	}
+	return [
+		b,
+		x,
+		y
+	];
+}
+function toZn(a, n) {
+	if (typeof a === "number") a = BigInt(a);
+	if (typeof n === "number") n = BigInt(n);
+	if (n <= 0n) throw new RangeError("n must be greater than 0.");
+	let aZn = a % n;
+	return aZn < 0n ? aZn + n : aZn;
+}
+//#endregion
+//#region src/bigint/bytes.ts
+function toBytes(value, length = 0, le = false) {
+	let bits = bitLength(value < 0n ? ~value : value) + (value < 0n ? 1 : 0);
+	let bytes = Math.ceil(bits / 8);
+	if (length !== 0 && bytes > length) throw new RangeError(`Value out of bounds: ${bytes.toString()}, ${length.toString()}.`);
+	if (length === 0) length = bytes;
+	let buf = new ArrayBuffer(length);
+	let arr = new Uint8Array(buf);
+	let unaligned = length % 8;
+	let dv = new DataView(buf, 0, length - unaligned);
+	for (let i = 0; i < dv.byteLength; i += 8) {
+		dv.setBigUint64(i, value & 18446744073709551615n, true);
+		value >>= 64n;
+	}
+	if (unaligned > 0) for (let i = length - unaligned; i < length; i++) {
+		arr[i] = Number(value & 255n);
+		value >>= 8n;
+	}
+	if (!le) arr.reverse();
+	return arr;
+}
+function fromBytes(buffer, le = false) {
+	if (le) buffer = toReversed(buffer);
+	let unaligned = buffer.length % 8;
+	let dv = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength - unaligned);
+	let res = 0n;
+	for (let i = 0; i < dv.byteLength; i += 8) res = res << 64n | BigInt(dv.getBigUint64(i, false));
+	if (unaligned > 0) for (let i = buffer.length - unaligned; i < buffer.length; i++) res = res << 8n | BigInt(buffer[i]);
+	return res;
+}
+//#endregion
+//#region src/encoding/utf8.ts
+var utf8_exports = /* @__PURE__ */ __exportAll({
+	decoder: () => decoder,
+	encodedLength: () => encodedLength$2,
+	encoder: () => encoder
+});
+var encoder = new TextEncoder();
+var decoder = new TextDecoder();
+function encodedLength$2(data) {
+	if (typeof Buffer !== "undefined") return Buffer.byteLength(data, "utf8");
+	let length = data.length;
+	for (let i = length - 1; i >= 0; i--) {
+		let code = data.charCodeAt(i);
+		if (code > 127 && code <= 2047) length++;
+		else if (code > 2047 && code <= 65535) length += 2;
+		if (code >= 56320 && code <= 57343 && i > 0) {
+			let prev = data.charCodeAt(i - 1);
+			if (prev >= 55296 && prev <= 56319) i--;
+		}
+	}
+	return length;
+}
+//#endregion
+//#region src/encoding/base64.ts
+var base64_exports = /* @__PURE__ */ __exportAll({
+	decode: () => decode$1,
+	decodedLength: () => decodedLength$1,
+	encode: () => encode$1,
+	encodeLookup: () => encodeLookup,
+	encodedLength: () => encodedLength$1,
+	lookup: () => lookup
+});
+var alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var lookup = /* @__PURE__ */ new Map();
+var encodeLookup = /* @__PURE__ */ new Map();
+for (let i = 0; i < 64; i++) {
+	const charCode = alphabet.charCodeAt(i);
+	lookup.set(charCode, i);
+	encodeLookup.set(i, charCode);
+}
+lookup.set("=".charCodeAt(0), 0);
+lookup.set("-".charCodeAt(0), 62);
+lookup.set("_".charCodeAt(0), 63);
+var HasToBase64 = typeof Uint8Array.prototype.toBase64 === "function";
+function decode$1(data, url = false) {
+	if (typeof Uint8Array.fromBase64 === "function") return Uint8Array.fromBase64(data, { alphabet: url ? "base64url" : "base64" });
+	data = data.replace(/=+$/g, "");
+	let n = data.length;
+	let rem = n % 4;
+	let k = rem && rem - 1;
+	let m = (n >> 2) * 3 + k;
+	let encoded = allocate(n + 3);
+	encoder.encodeInto(`${data}===`, encoded);
+	for (let i = 0, j = 0; i < n; i += 4, j += 3) {
+		let a = lookup.get(encoded[i]);
+		let b = lookup.get(encoded[i + 1]);
+		let c = lookup.get(encoded[i + 2]);
+		let d = lookup.get(encoded[i + 3]);
+		if (a === void 0 || b === void 0 || c === void 0 || d === void 0) throw new TypeError("Invalid base64 string.", { cause: { data } });
+		let x = (a << 18) + (b << 12) + (c << 6) + d;
+		encoded[j] = x >> 16;
+		encoded[j + 1] = x >> 8 & 255;
+		encoded[j + 2] = x & 255;
+	}
+	return new Uint8Array(encoded.buffer, encoded.byteOffset, m);
+}
+var ToBase64Options = {
+	alphabet: "base64",
+	omitPadding: false
+};
+var ToBase64UrlOptions = {
+	alphabet: "base64url",
+	omitPadding: true
+};
+function encode$1(bytes, url = false) {
+	if (typeof Buffer !== "undefined") return Buffer.from(bytes).toString(url ? "base64url" : "base64");
+	if (HasToBase64) return bytes.toBase64(url ? ToBase64UrlOptions : ToBase64Options);
+	let m = bytes.length;
+	let k = m % 3;
+	let n = Math.floor(m / 3) * 4 + (k && k + 1);
+	let encoded = allocate(Math.ceil(m / 3) * 4);
+	for (let i = 0, j = 0; j < m; i += 4, j += 3) {
+		let y = (bytes[j] << 16) + (bytes[j + 1] << 8) + (bytes[j + 2] | 0);
+		encoded[i] = encodeLookup.get(y >> 18);
+		encoded[i + 1] = encodeLookup.get(y >> 12 & 63);
+		encoded[i + 2] = encodeLookup.get(y >> 6 & 63);
+		encoded[i + 3] = encodeLookup.get(y & 63);
+	}
+	let base64 = decoder.decode(new Uint8Array(encoded.buffer, encoded.byteOffset, n));
+	if (url) base64 = base64.replace(/\+/g, "-").replace(/\//g, "_");
+	else {
+		if (k === 1) base64 += "==";
+		if (k === 2) base64 += "=";
+	}
+	return base64;
+}
+function encodedLength$1(n) {
+	return Math.ceil(n / 3) * 4;
+}
+function decodedLength$1(n) {
+	let rem = n % 4;
+	return (n >> 2) * 3 + (rem && rem - 1);
+}
+//#endregion
+//#region src/encoding/hex.ts
+var hex_exports = /* @__PURE__ */ __exportAll({
+	decode: () => decode,
+	decodedLength: () => decodedLength,
+	encode: () => encode,
+	encodedLength: () => encodedLength
+});
+var hexSliceLookupTable = (function() {
+	const alphabet = "0123456789abcdef";
+	const table = Array.from({ length: 256 });
+	for (let i = 0; i < 16; ++i) {
+		const i16 = i * 16;
+		for (let j = 0; j < 16; ++j) table[i16 + j] = alphabet[i] + alphabet[j];
+	}
+	return table;
+})();
+var hexCharValueTable = {
+	0: 0,
+	1: 1,
+	2: 2,
+	3: 3,
+	4: 4,
+	5: 5,
+	6: 6,
+	7: 7,
+	8: 8,
+	9: 9,
+	a: 10,
+	b: 11,
+	c: 12,
+	d: 13,
+	e: 14,
+	f: 15,
+	A: 10,
+	B: 11,
+	C: 12,
+	D: 13,
+	E: 14,
+	F: 15
+};
+var HasToHex = typeof Uint8Array.prototype.toHex === "function";
+function encode(buf) {
+	if (typeof Buffer !== "undefined") return Buffer.from(buf).toString("hex");
+	if (HasToHex) return buf.toHex();
+	let out = "";
+	for (let i = 0; i < buf.byteLength; ++i) out += hexSliceLookupTable[buf[i]];
+	return out;
+}
+function decode(data) {
+	if (typeof Uint8Array.fromHex === "function") return Uint8Array.fromHex(data);
+	if (data.length % 2 !== 0) throw new TypeError("Invalid hex string.", { cause: { data } });
+	let buf = allocate(data.length / 2);
+	for (let i = 0; i < buf.length; ++i) {
+		let a = hexCharValueTable[data[i * 2]];
+		let b = hexCharValueTable[data[i * 2 + 1]];
+		if (a === void 0 || b === void 0) throw new TypeError("Invalid hex string.", { cause: { data } });
+		buf[i] = a << 4 | b;
+	}
+	return buf;
+}
+function encodedLength(n) {
+	return n * 2;
+}
+function decodedLength(n) {
+	return Math.ceil(n / 2);
+}
+//#endregion
+//#region src/iterate/enumerate.ts
+function enumerate(iterable) {
+	const iterator = iterable[Symbol.iterator]();
+	let idx = 0;
+	return {
+		[Symbol.iterator]() {
+			return this;
+		},
+		next() {
+			let res = iterator.next();
+			if (res.done) return res;
+			return {
+				done: false,
+				value: [idx++, res.value]
+			};
+		}
+	};
+}
+//#endregion
+//#region src/misc/assert.ts
+function assert(condition, message) {
+	if (!condition) throw new Error(typeof message === "string" ? message : "Assertion failed.", { cause: message });
+}
+function assertHashKey(obj, key) {
+	if (!(key in obj)) throw new Error(`Key ${JSON.stringify(key)} not found in object.`, { cause: {
+		obj,
+		key
+	} });
+}
+function unsafeCastType(value) {}
+function assertNotNull(value) {
+	if (value == null) throw new Error(`Value is ${value}.`);
+}
+function asNonNull(value) {
+	assertNotNull(value);
+	return value;
+}
+function assertMatches(str, regex) {
+	let match = str.match(regex);
+	if (!match) throw new Error(`${JSON.stringify(str)} does not match ${regex}.`, { cause: {
+		str,
+		regex
+	} });
+	return match;
+}
+//#endregion
+//#region src/misc/composer.ts
+function composeMiddlewares(middlewares, final) {
+	middlewares = middlewares.slice();
+	if (final == null) return function(context, next) {
+		function dispatch(i, ctx) {
+			if (i > middlewares.length) throw new Error("next() called after end");
+			return (middlewares[i] ?? next)(ctx, dispatch.bind(null, i + 1));
+		}
+		return dispatch(0, context);
+	};
+	middlewares.push(final);
+	function dispatch(i, ctx) {
+		let fn = middlewares[i];
+		return fn(ctx, boundDispatches[i + 1]);
+	}
+	let boundDispatches = [];
+	for (let i = 0; i < middlewares.length; i++) boundDispatches.push(dispatch.bind(null, i));
+	return function(context) {
+		return boundDispatches[0](context);
+	};
+}
+//#endregion
+//#region src/misc/guards.ts
+var isNotUndefined = (val) => val !== void 0;
+var isNotNull = (val) => val !== null;
+var isBoolean = (val) => typeof val === "boolean";
+var isTruthy = (val) => Boolean(val);
+var isFalsy = (val) => !val;
+var isFunction = (val) => typeof val === "function";
+var isNumber = (val) => typeof val === "number";
+var isString = (val) => typeof val === "string";
+var isSymbol = (val) => typeof val === "symbol";
+var isBigInt = (val) => typeof val === "bigint";
+var isObject = (val) => typeof val === "object" && val !== null;
+//#endregion
+//#region src/misc/noop.ts
+function noop() {}
+//#endregion
+//#region src/misc/objects.ts
+function objectKeys(obj) {
+	return Object.keys(obj);
+}
+function objectEntries(obj) {
+	return Object.entries(obj);
+}
+function clearUndefinedInPlace(obj) {
+	for (const key in obj) {
+		if (!Object.hasOwn(obj, key)) continue;
+		if (obj[key] === void 0) delete obj[key];
+	}
+}
+function deepMerge(into, from, options = {}) {
+	if (!Array.isArray(from)) from = [from];
+	if (from.length === 0) return into;
+	const { undefined: undefinedStrategy = "ignore", properties: propertiesStrategy = "replace", arrays: arraysStrategy = "replace", objects: objectsStrategy = "merge" } = options;
+	for (let i = 0; i < from.length; i++) {
+		const source = from[i];
+		for (const key in source) {
+			if (!Object.hasOwn(source, key)) continue;
+			const value = source[key];
+			const existing = into[key];
+			if (value === void 0) {
+				if (undefinedStrategy === "replace") into[key] = void 0;
+				continue;
+			}
+			if (Array.isArray(value)) {
+				if (arraysStrategy === "merge" && Array.isArray(existing)) existing.push(...value);
+				else if (arraysStrategy === "ignore" && existing !== void 0) {} else into[key] = [...value];
+				continue;
+			}
+			if (typeof value === "object" && value !== null) {
+				if (value instanceof Date || value instanceof Map || value instanceof Set || value instanceof RegExp) {
+					if (propertiesStrategy === "ignore" && existing !== void 0) {} else into[key] = value;
+					continue;
+				}
+				if (objectsStrategy === "merge" && typeof existing === "object" && existing !== null) into[key] = deepMerge(existing, value, options);
+				else if (objectsStrategy === "ignore" && existing !== void 0) {} else into[key] = { ...value };
+				continue;
+			}
+			if (propertiesStrategy === "ignore" && existing !== void 0) {} else into[key] = value;
+		}
+	}
+	return into;
+}
+//#endregion
+//#region src/misc/string.ts
+function splitOnce(str, separator) {
+	let idx = str.indexOf(separator);
+	if (idx === -1) throw new RangeError(`Separator not found: ${separator}.`, { cause: {
+		str,
+		separator
+	} });
+	return [str.slice(0, idx), str.slice(idx + separator.length)];
+}
+function assertStartsWith(str, prefix) {
+	if (!str.startsWith(prefix)) throw new TypeError(`String does not starts with ${prefix}.`, { cause: {
+		str,
+		prefix
+	} });
+}
+function assertEndsWith(str, suffix) {
+	if (!str.endsWith(suffix)) throw new TypeError(`String does not ends with ${suffix}.`, { cause: {
+		str,
+		suffix
+	} });
+}
+//#endregion
+//#region src/async/timers.ts
+var timers_exports = /* @__PURE__ */ __exportAll({
+	clearInterval: () => clearIntervalWrap,
+	clearTimeout: () => clearTimeoutWrap,
+	setInterval: () => setIntervalWrap,
+	setTimeout: () => setTimeoutWrap
+});
+var setTimeoutWrap = ((...args) => setTimeout(...args));
+var setIntervalWrap = ((...args) => setInterval(...args));
+var clearTimeoutWrap = ((...args) => clearTimeout(...args));
+var clearIntervalWrap = ((...args) => clearInterval(...args));
+//#endregion
+//#region src/async/async-interval.ts
+var AsyncInterval = class {
+	#handler;
+	#interval;
+	#timer;
+	#onError = noop;
+	#stopped = true;
+	#generation = 0;
+	#abortController = new AbortController();
+	constructor(handler, interval) {
+		this.#handler = handler;
+		this.#interval = interval;
+	}
+	start(after = this.#interval) {
+		this.stop();
+		this.#stopped = false;
+		let generation = this.#generation;
+		this.#timer = setTimeoutWrap(() => this.#onTimeout(generation), after);
+	}
+	startNow() {
+		this.stop();
+		this.#stopped = false;
+		this.#onTimeout(this.#generation);
+	}
+	stop() {
+		this.#generation++;
+		this.#abortController.abort();
+		this.#abortController = new AbortController();
+		if (this.#timer != null) {
+			clearTimeoutWrap(this.#timer);
+			this.#timer = void 0;
+		}
+		this.#stopped = true;
+	}
+	onError(handler) {
+		this.#onError = handler;
+	}
+	#onTimeout = (generation) => {
+		this.#timer = void 0;
+		(async () => {
+			try {
+				await this.#handler(this.#abortController.signal);
+			} catch (err) {
+				this.#onError(err);
+			}
+			if (this.#stopped || generation !== this.#generation) return;
+			this.#timer = setTimeoutWrap(() => this.#onTimeout(generation), this.#interval);
+		})();
+	};
+};
+//#endregion
+//#region src/structures/_iterator.ts
+var _hasIteratorFrom = null;
+function maybeWrapIterator(iter) {
+	if (_hasIteratorFrom === null) _hasIteratorFrom = typeof globalThis.Iterator !== "undefined" && "from" in globalThis.Iterator;
+	if (_hasIteratorFrom) return globalThis.Iterator.from(iter);
+	return iter;
+}
+//#endregion
+//#region src/structures/custom-map.ts
+var CustomMap = class {
+	clear;
+	#map;
+	#mapperTo;
+	#mapperFrom;
+	constructor(externalToInternal, internalToExternal) {
+		this.#mapperTo = externalToInternal;
+		this.#mapperFrom = internalToExternal;
+		this.clear = (this.#map = /* @__PURE__ */ new Map()).clear.bind(this.#map);
+	}
+	get size() {
+		return this.#map.size;
+	}
+	get [Symbol.toStringTag]() {
+		return this.#map[Symbol.toStringTag];
+	}
+	getInternalMap() {
+		return this.#map;
+	}
+	delete(key) {
+		return this.#map.delete(this.#mapperTo(key));
+	}
+	forEach(cb, thisArg) {
+		return this.#map.forEach((value, key) => {
+			cb.call(thisArg, value, this.#mapperFrom(key), this);
+		});
+	}
+	get(key) {
+		return this.#map.get(this.#mapperTo(key));
+	}
+	has(key) {
+		return this.#map.has(this.#mapperTo(key));
+	}
+	set(key, value) {
+		this.#map.set(this.#mapperTo(key), value);
+		return this;
+	}
+	getOrInsert(key, value) {
+		if (this.#map.getOrInsert) return this.#map.getOrInsert(this.#mapperTo(key), value);
+		let k = this.#mapperTo(key);
+		if (!this.#map.has(k)) this.#map.set(k, value);
+		return this.#map.get(k);
+	}
+	getOrInsertComputed(key, callback) {
+		if (this.#map.getOrInsertComputed) return this.#map.getOrInsertComputed(this.#mapperTo(key), (k) => callback(this.#mapperFrom(k)));
+		let k = this.#mapperTo(key);
+		if (!this.#map.has(k)) this.#map.set(k, callback(key));
+		return this.#map.get(k);
+	}
+	entries() {
+		let inner = this.#map.entries();
+		const iterator = {
+			[Symbol.iterator]: () => iterator,
+			next: () => {
+				let { done, value } = inner.next();
+				if (done) return {
+					done,
+					value
+				};
+				return {
+					done,
+					value: [this.#mapperFrom(value[0]), value[1]]
+				};
+			}
+		};
+		return maybeWrapIterator(iterator);
+	}
+	keys() {
+		let inner = this.#map.keys();
+		const iterator = {
+			[Symbol.iterator]: () => iterator,
+			next: () => {
+				let { done, value } = inner.next();
+				if (done) return {
+					done,
+					value
+				};
+				return {
+					done,
+					value: this.#mapperFrom(value)
+				};
+			}
+		};
+		return maybeWrapIterator(iterator);
+	}
+	values() {
+		let inner = this.#map.values();
+		const iterator = {
+			[Symbol.iterator]: () => iterator,
+			next: () => {
+				let { done, value } = inner.next();
+				if (done) return {
+					done,
+					value
+				};
+				return {
+					done,
+					value
+				};
+			}
+		};
+		return maybeWrapIterator(iterator);
+	}
+	[Symbol.iterator]() {
+		return this.entries();
+	}
+};
+//#endregion
+//#region src/structures/custom-set.ts
+var CustomSet = class CustomSet {
+	clear;
+	#set;
+	#mapperTo;
+	#mapperFrom;
+	constructor(externalToInternal, internalToExternal) {
+		this.#mapperTo = externalToInternal;
+		this.#mapperFrom = internalToExternal;
+		let set = this.#set = /* @__PURE__ */ new Set();
+		this.clear = set.clear.bind(set);
+	}
+	get size() {
+		return this.#set.size;
+	}
+	get [Symbol.toStringTag]() {
+		return this.#set[Symbol.toStringTag];
+	}
+	add(value) {
+		this.#set.add(this.#mapperTo(value));
+		return this;
+	}
+	delete(value) {
+		return this.#set.delete(this.#mapperTo(value));
+	}
+	forEach(cb, thisArg) {
+		this.#set.forEach((value) => {
+			let mapped = this.#mapperFrom(value);
+			cb.call(thisArg, mapped, mapped, this);
+		});
+	}
+	has(value) {
+		return this.#set.has(this.#mapperTo(value));
+	}
+	entries() {
+		let inner = this.#set.entries();
+		const iterator = {
+			[Symbol.iterator]: () => iterator,
+			next: () => {
+				let { done, value } = inner.next();
+				if (done) return {
+					done,
+					value
+				};
+				let mapped = this.#mapperFrom(value[0]);
+				return {
+					done,
+					value: [mapped, mapped]
+				};
+			}
+		};
+		return maybeWrapIterator(iterator);
+	}
+	keys() {
+		let inner = this.#set.keys();
+		const iterator = {
+			[Symbol.iterator]: () => iterator,
+			next: () => {
+				let { done, value } = inner.next();
+				if (done) return {
+					done,
+					value
+				};
+				return {
+					done,
+					value: this.#mapperFrom(value)
+				};
+			}
+		};
+		return maybeWrapIterator(iterator);
+	}
+	values() {
+		return this.keys();
+	}
+	union(other) {
+		let newSet = new CustomSet((k) => this.#mapperTo(k), (k) => this.#mapperFrom(k));
+		this.#set.forEach((v) => newSet.add(this.#mapperFrom(v)));
+		other.forEach((v) => newSet.add(v));
+		return newSet;
+	}
+	intersection(other) {
+		let newSet = new CustomSet((k) => this.#mapperTo(k), (k) => this.#mapperFrom(k));
+		this.#set.forEach((v) => {
+			let ext = this.#mapperFrom(v);
+			if (other.has(ext)) newSet.add(ext);
+		});
+		return newSet;
+	}
+	difference(other) {
+		let newSet = new CustomSet(this.#mapperTo, this.#mapperFrom);
+		this.#set.forEach((v) => {
+			let ext = this.#mapperFrom(v);
+			if (!other.has(ext)) newSet.add(ext);
+		});
+		return newSet;
+	}
+	symmetricDifference(other) {
+		let newSet = new CustomSet((k) => this.#mapperTo(k), (k) => this.#mapperFrom(k));
+		this.#set.forEach((v) => {
+			let ext = this.#mapperFrom(v);
+			if (!other.has(ext)) newSet.add(ext);
+		});
+		other.forEach((v) => {
+			if (!this.has(v)) newSet.add(v);
+		});
+		return newSet;
+	}
+	isSubsetOf(other) {
+		for (let v of this.#set) if (!other.has(this.#mapperFrom(v))) return false;
+		return true;
+	}
+	isSupersetOf(other) {
+		for (let v of other) if (!this.has(v)) return false;
+		return true;
+	}
+	isDisjointFrom(other) {
+		for (let v of other) if (this.has(v)) return false;
+		return true;
+	}
+	[Symbol.iterator]() {
+		return this.keys();
+	}
+	getInternalSet() {
+		return this.#set;
+	}
+};
+//#endregion
+//#region src/structures/deque.ts
+var Log2 = Math.log(2);
+function _nextPowerOf2(n) {
+	if (n <= 4) return 4;
+	return 1 << Math.ceil(Math.log(n) / Log2);
+}
+var Deque = class {
+	_list;
+	_head = 0;
+	_tail = 0;
+	_capacityMask = 3;
+	_capacity;
+	_size = 0;
+	constructor(array, options = {}) {
+		this._capacity = options.capacity;
+		if (array) this.#fromArray(array);
+		else this._list = new Array(4);
+	}
+	get length() {
+		return this._size;
+	}
+	isEmpty() {
+		return this._size === 0;
+	}
+	at(index) {
+		let i = index;
+		if (i !== (i | 0)) return void 0;
+		let len = this._size;
+		if (i >= len || i < -len) return void 0;
+		if (i < 0) i += len;
+		return this._list[this._head + i & this._capacityMask];
+	}
+	peekFront() {
+		return this.isEmpty() ? void 0 : this._list[this._head];
+	}
+	peekBack() {
+		return this.isEmpty() ? void 0 : this._list[this._tail - 1 + this._list.length & this._capacityMask];
+	}
+	pushFront(item) {
+		if (this._size === this._list.length) this.#growArray();
+		this._head = this._head - 1 + this._list.length & this._capacityMask;
+		this._list[this._head] = item;
+		this._size++;
+		if (this._capacity !== void 0 && this._size > this._capacity) this.popBack();
+		return this._size;
+	}
+	pushBack(item) {
+		if (this._size === this._list.length) this.#growArray();
+		this._list[this._tail] = item;
+		this._tail = this._tail + 1 & this._capacityMask;
+		this._size++;
+		if (this._capacity !== void 0 && this._size > this._capacity) this.popFront();
+		return this._size;
+	}
+	popFront() {
+		if (this.isEmpty()) return void 0;
+		let item = this._list[this._head];
+		this._list[this._head] = void 0;
+		this._head = this._head + 1 & this._capacityMask;
+		this._size--;
+		if (this._size <= this._list.length / 4 && this._list.length > 4) this.#shrinkArray();
+		return item;
+	}
+	popBack() {
+		if (this.isEmpty()) return void 0;
+		this._tail = this._tail - 1 + this._list.length & this._capacityMask;
+		let item = this._list[this._tail];
+		this._list[this._tail] = void 0;
+		this._size--;
+		if (this._size <= this._list.length / 4 && this._list.length > 4) this.#shrinkArray();
+		return item;
+	}
+	removeOne(idx) {
+		let len = this._size;
+		if (idx >= len || idx < -len) return void 0;
+		if (idx < 0) idx += len;
+		let realIdx = this._head + idx & this._capacityMask;
+		let item = this._list[realIdx];
+		this.#remove(realIdx);
+		return item;
+	}
+	removeBy(predicate) {
+		for (let pos = 0; pos < this._size; pos++) {
+			let i = this._head + pos & this._capacityMask;
+			let item = this._list[i];
+			if (item !== void 0 && predicate(item)) {
+				this.#remove(i);
+				return;
+			}
+		}
+	}
+	clear() {
+		this._list = new Array(this._list.length);
+		this._head = 0;
+		this._tail = 0;
+		this._size = 0;
+	}
+	indexOf(item) {
+		for (let pos = 0; pos < this._size; pos++) if (this._list[this._head + pos & this._capacityMask] === item) return pos;
+		return -1;
+	}
+	findIndex(predicate) {
+		for (let pos = 0; pos < this._size; pos++) if (predicate(this._list[this._head + pos & this._capacityMask])) return pos;
+		return -1;
+	}
+	find(predicate) {
+		for (let pos = 0; pos < this._size; pos++) {
+			let item = this._list[this._head + pos & this._capacityMask];
+			if (item !== void 0 && predicate(item)) return item;
+		}
+	}
+	includes(item) {
+		return this.indexOf(item) !== -1;
+	}
+	toArray() {
+		let arr = new Array(this._size);
+		for (let k = 0; k < this._size; k++) arr[k] = this._list[this._head + k & this._capacityMask];
+		return arr;
+	}
+	[Symbol.iterator]() {
+		let pos = 0;
+		return { next: () => {
+			if (pos >= this._size) return {
+				done: true,
+				value: void 0
+			};
+			let value = this._list[this._head + pos & this._capacityMask];
+			pos++;
+			return {
+				done: false,
+				value
+			};
+		} };
+	}
+	#fromArray(array) {
+		let start = 0;
+		let length = array.length;
+		if (this._capacity !== void 0 && length > this._capacity) {
+			start = length - this._capacity;
+			length = this._capacity;
+		}
+		let capacity = _nextPowerOf2(length);
+		this._list = new Array(capacity);
+		this._capacityMask = capacity - 1;
+		this._head = 0;
+		this._tail = length & this._capacityMask;
+		this._size = length;
+		for (let i = 0; i < length; i++) this._list[i] = array[start + i];
+	}
+	#growArray() {
+		let oldMask = this._capacityMask;
+		let oldList = this._list;
+		let oldHead = this._head;
+		let size = this._size;
+		let newList = new Array(oldList.length << 1);
+		for (let i = 0; i < size; i++) newList[i] = oldList[oldHead + i & oldMask];
+		this._list = newList;
+		this._head = 0;
+		this._tail = size;
+		this._capacityMask = newList.length - 1;
+	}
+	#shrinkArray() {
+		if (this._list.length <= 4) return;
+		let oldMask = this._capacityMask;
+		let oldList = this._list;
+		let oldHead = this._head;
+		let size = this._size;
+		let newList = new Array(oldList.length >>> 1);
+		for (let i = 0; i < size; i++) newList[i] = oldList[oldHead + i & oldMask];
+		this._list = newList;
+		this._head = 0;
+		this._tail = size;
+		this._capacityMask = newList.length - 1;
+	}
+	#remove(idx) {
+		let mask = this._capacityMask;
+		let len = this._list.length;
+		let distFromHead = idx - this._head & mask;
+		if (distFromHead < this._size - distFromHead) {
+			let i = idx;
+			while (i !== this._head) {
+				let prev = i - 1 + len & mask;
+				this._list[i] = this._list[prev];
+				i = prev;
+			}
+			this._list[this._head] = void 0;
+			this._head = this._head + 1 & mask;
+		} else {
+			let i = idx;
+			let last = this._tail - 1 + len & mask;
+			while (i !== last) {
+				let next = i + 1 & mask;
+				this._list[i] = this._list[next];
+				i = next;
+			}
+			this._list[last] = void 0;
+			this._tail = last;
+		}
+		this._size--;
+		if (this._size <= this._list.length / 4 && this._list.length > 4) this.#shrinkArray();
+	}
+};
+//#endregion
+//#region src/structures/lru-map.ts
+var LruMap = class {
+	#capacity;
+	#map;
+	constructor(capacity, MapImpl = Map) {
+		this.#capacity = capacity;
+		this.#map = new MapImpl();
+	}
+	get size() {
+		return this.#map.size;
+	}
+	get(key) {
+		if (!this.#map.has(key)) return void 0;
+		let value = this.#map.get(key);
+		this.#map.delete(key);
+		this.#map.set(key, value);
+		return value;
+	}
+	has(key) {
+		return this.#map.has(key);
+	}
+	set(key, value) {
+		if (this.#map.has(key)) this.#map.delete(key);
+		this.#map.set(key, value);
+		if (this.#map.size > this.#capacity) {
+			let oldest = this.#map.keys().next();
+			if (!oldest.done) this.#map.delete(oldest.value);
+		}
+	}
+	delete(key) {
+		this.#map.delete(key);
+	}
+	clear() {
+		this.#map.clear();
+	}
+	*[Symbol.iterator]() {
+		yield* this.#map;
+	}
+	entries() {
+		return this.#map.entries();
+	}
+	keys() {
+		return this.#map.keys();
+	}
+	values() {
+		return this.#map.values();
+	}
+};
+//#endregion
+//#region src/structures/lru-set.ts
+var LruSet = class {
+	#capacity;
+	#set;
+	constructor(capacity, SetImpl = Set) {
+		this.#capacity = capacity;
+		this.#set = new SetImpl();
+	}
+	get size() {
+		return this.#set.size;
+	}
+	add(value) {
+		if (this.#set.has(value)) this.#set.delete(value);
+		this.#set.add(value);
+		if (this.#set.size > this.#capacity) {
+			let oldest = this.#set.keys().next();
+			if (!oldest.done) this.#set.delete(oldest.value);
+		}
+	}
+	has(value) {
+		return this.#set.has(value);
+	}
+	delete(value) {
+		return this.#set.delete(value);
+	}
+	clear() {
+		this.#set.clear();
+	}
+	*[Symbol.iterator]() {
+		yield* this.#set;
+	}
+	toArray() {
+		return Array.from(this.#set);
+	}
+};
+//#endregion
+//#region src/async/async-lock.ts
+var AsyncLock = class {
+	_queue = new Deque();
+	async acquire() {
+		let info;
+		while (info = this._queue.peekFront()) await info[0];
+		let unlock;
+		const promise = new Promise((resolve) => {
+			unlock = resolve;
+		});
+		this._queue.pushBack([promise, unlock]);
+	}
+	release() {
+		const front = this._queue.popFront();
+		if (!front) throw new Error("Nothing to release.", { cause: this._queue });
+		front[1]();
+	}
+	with(func) {
+		return (async () => {
+			await this.acquire();
+			try {
+				return await func();
+			} finally {
+				this.release();
+			}
+		})();
+	}
+};
+//#endregion
+//#region src/async/deferred.ts
+var Deferred = class {
+	resolve;
+	reject;
+	promise;
+	constructor() {
+		this.promise = new Promise((resolve, reject) => {
+			this.resolve = resolve;
+			this.reject = reject;
+		});
+	}
+};
+var DeferredTracked = class {
+	promise;
+	status;
+	#resolve;
+	#reject;
+	constructor() {
+		this.status = { type: "pending" };
+		this.promise = new Promise((resolve, reject) => {
+			this.#resolve = resolve;
+			this.#reject = reject;
+		});
+	}
+	get result() {
+		if (this.status.type === "fulfilled") return this.status.value;
+	}
+	get error() {
+		if (this.status.type === "rejected") return this.status.reason;
+	}
+	resolve(value) {
+		if (this.status.type !== "pending") return;
+		this.status = {
+			type: "fulfilled",
+			value
+		};
+		this.#resolve(value);
+	}
+	reject(reason) {
+		if (this.status.type !== "pending") return;
+		this.status = {
+			type: "rejected",
+			reason
+		};
+		this.#reject(reason);
+	}
+};
+//#endregion
+//#region src/async/async-queue.ts
+var AsyncQueue = class {
+	queue;
+	maxSize;
+	#consumerWaiters = new Deque();
+	#producerWaiters = new Deque();
+	#ended = false;
+	constructor(from, maxSize) {
+		if (maxSize !== void 0 && maxSize < 1) throw new Error("maxSize must be at least 1");
+		this.maxSize = maxSize;
+		if (from) if (from instanceof Deque) this.queue = from;
+		else this.queue = new Deque(from);
+		else this.queue = new Deque();
+		if (maxSize !== void 0 && this.queue.length > maxSize) throw new Error("Initial queue length exceeds maxSize");
+	}
+	get length() {
+		return this.queue.length;
+	}
+	get isFull() {
+		return this.maxSize !== void 0 && this.queue.length >= this.maxSize;
+	}
+	get remainingCapacity() {
+		return this.maxSize !== void 0 ? this.maxSize - this.queue.length : Infinity;
+	}
+	get ended() {
+		return this.#ended;
+	}
+	async enqueue(item) {
+		if (this.#ended) throw new Error("Cannot enqueue after .end() has been called");
+		while (true) {
+			if (this.#consumerWaiters.length > 0) {
+				this.#consumerWaiters.popFront().resolve(item);
+				return;
+			}
+			if (!this.isFull) {
+				this.queue.pushBack(item);
+				return;
+			}
+			let waiter = new Deferred();
+			this.#producerWaiters.pushBack(waiter);
+			await waiter.promise;
+			if (this.#ended) throw new Error("Queue was ended while waiting to enqueue.");
+		}
+	}
+	tryEnqueue(item) {
+		if (this.#ended || this.isFull) return false;
+		if (this.#consumerWaiters.length > 0) {
+			this.#consumerWaiters.popFront().resolve(item);
+			return true;
+		}
+		this.queue.pushBack(item);
+		return true;
+	}
+	end() {
+		if (this.#ended) throw new Error(".end() has already been called.");
+		this.#ended = true;
+		for (let waiter of this.#consumerWaiters) waiter.resolve(void 0);
+		this.#consumerWaiters.clear();
+		let err = /* @__PURE__ */ new Error("Queue has been ended.");
+		for (let waiter of this.#producerWaiters) waiter.reject(err);
+		this.#producerWaiters.clear();
+	}
+	peek() {
+		return this.queue.peekFront();
+	}
+	next() {
+		if (this.queue.length === 0) return void 0;
+		let item = this.queue.popFront();
+		this.#wakeProducerIfNeeded();
+		return item;
+	}
+	async nextOrWait() {
+		if (this.queue.length > 0) {
+			let item = this.queue.popFront();
+			this.#wakeProducerIfNeeded();
+			return item;
+		}
+		if (this.#ended) return;
+		let waiter = new Deferred();
+		this.#consumerWaiters.pushBack(waiter);
+		return waiter.promise;
+	}
+	[Symbol.asyncIterator]() {
+		let iterator = {
+			[Symbol.asyncIterator]: () => iterator,
+			next: async () => {
+				let item = await this.nextOrWait();
+				if (item === void 0) return {
+					done: true,
+					value: void 0
+				};
+				return {
+					value: item,
+					done: false
+				};
+			}
+		};
+		return iterator;
+	}
+	#wakeProducerIfNeeded() {
+		if (this.#producerWaiters.length > 0 && !this.isFull) this.#producerWaiters.popFront().resolve();
+	}
+};
+//#endregion
+//#region src/async/emitter.ts
+var Emitter = class {
+	#listeners = [];
+	#emit = noop;
+	get length() {
+		return this.#listeners.length;
+	}
+	add(listener) {
+		this.#listeners.push(listener);
+		this.#updateEmit();
+	}
+	forwardTo(emitter) {
+		this.add(emitter.emit.bind(emitter));
+	}
+	remove(listener) {
+		let idx = this.#listeners.indexOf(listener);
+		if (idx === -1) return;
+		this.#listeners.splice(idx, 1);
+		this.#updateEmit();
+	}
+	emit(value) {
+		this.#emit(value);
+	}
+	once(listener) {
+		const once = (value) => {
+			this.remove(once);
+			listener(value);
+		};
+		this.add(once);
+	}
+	listeners() {
+		return this.#listeners;
+	}
+	clear() {
+		this.#listeners.length = 0;
+		this.#emit = noop;
+	}
+	#emitFew = (value) => {
+		let listeners = this.#listeners.slice();
+		let len = listeners.length;
+		listeners[0](value);
+		len > 1 && listeners[1](value);
+		len > 2 && listeners[2](value);
+		len > 3 && listeners[3](value);
+		len > 4 && listeners[4](value);
+	};
+	#emitAll = (value) => {
+		let listeners = this.#listeners.slice();
+		for (let i = 0; i < listeners.length; i++) listeners[i](value);
+	};
+	#updateEmit = () => {
+		let len = this.#listeners.length;
+		if (len === 0) this.#emit = noop;
+		else if (len <= 5) this.#emit = this.#emitFew;
+		else this.#emit = this.#emitAll;
+	};
+};
+//#endregion
+//#region src/async/async-resource.ts
+var AsyncResource = class {
+	onUpdated = new Emitter();
+	#abort;
+	#ctx;
+	#updating;
+	#timeout;
+	#destroyed = false;
+	constructor(options) {
+		this.options = options;
+		this.#ctx = {
+			current: null,
+			currentFetchedAt: 0,
+			currentExpiresAt: 0,
+			isBackground: false,
+			abort: null
+		};
+	}
+	get isStale() {
+		return this.#ctx.current === null || this.#ctx.currentExpiresAt <= performance.now();
+	}
+	setData(data, expiresIn) {
+		if (this.#destroyed) return;
+		let now = performance.now();
+		this.#ctx.current = data;
+		this.#ctx.currentExpiresAt = now + expiresIn;
+		this.#ctx.currentFetchedAt = now;
+		this.onUpdated.emit(this.#ctx);
+		if (this.options.autoReload) {
+			this.#clearTimer();
+			this.#timeout = setTimeoutWrap(() => {
+				if (this.#destroyed) return;
+				this.#ctx.isBackground = true;
+				this.update(true).catch(noop);
+			}, expiresIn + (this.options.autoReloadAfter ?? this.options.authReloadAfter ?? 0));
+		}
+	}
+	async update(force = false) {
+		if (this.#destroyed) return;
+		if (this.#updating) {
+			await this.#updating.promise;
+			return;
+		}
+		if (!force && !this.isStale) return;
+		this.#abort?.abort();
+		this.#abort = new AbortController();
+		this.#ctx.abort = this.#abort.signal;
+		this.#updating = new Deferred();
+		let result;
+		try {
+			result = await this.options.fetcher(this.#ctx);
+		} catch (err) {
+			if (err instanceof Error && err.name === "AbortError") {
+				this.#updating?.resolve();
+				this.#updating = void 0;
+				this.#ctx.abort = null;
+				return;
+			}
+			if (this.options.onError) this.options.onError(err, this.#ctx);
+			else console.error(err);
+			this.#updating?.resolve();
+			this.#updating = void 0;
+			this.#ctx.abort = null;
+			return;
+		}
+		this.#updating?.resolve();
+		this.#updating = void 0;
+		this.#ctx.abort = null;
+		if (!this.#destroyed) this.setData(result.data, result.expiresIn);
+	}
+	async get() {
+		if (this.#destroyed) return null;
+		if (this.options.swr === true && this.#ctx.current !== null) {
+			let validator = this.options.swrValidator;
+			if (!validator || validator(this.#ctx)) {
+				this.#ctx.isBackground = true;
+				this.update(true).catch(noop);
+				return this.#ctx.current;
+			}
+		}
+		this.#ctx.isBackground = false;
+		await this.update();
+		return this.#ctx.current;
+	}
+	getCached() {
+		return this.#ctx.current;
+	}
+	destroy() {
+		if (this.#destroyed) return;
+		this.#destroyed = true;
+		this.#clearTimer();
+		this.#abort?.abort();
+		this.onUpdated.clear();
+		this.#updating?.resolve();
+		this.#updating = void 0;
+	}
+	#clearTimer() {
+		if (this.#timeout) {
+			clearTimeoutWrap(this.#timeout);
+			this.#timeout = void 0;
+		}
+	}
+};
+//#endregion
+//#region src/async/condition-variable.ts
+var ConditionVariable = class {
+	#resolvers = [];
+	wait() {
+		return new Promise((resolve) => {
+			this.#resolvers.push(resolve);
+		});
+	}
+	notify() {
+		let resolvers = this.#resolvers;
+		this.#resolvers = [];
+		for (let resolve of resolvers) resolve();
+	}
+};
+//#endregion
+//#region src/async/pool.ts
+var ErrorInfo = class {
+	constructor(item, index, error) {
+		this.item = item;
+		this.index = index;
+		this.error = error;
+	}
+};
+var AggregateError = class extends Error {
+	constructor(errors) {
+		super(`AggregateError: ${errors.length} errors`);
+		this.errors = errors;
+	}
+};
+async function asyncPool(iterable, executor, options = {}) {
+	let { limit = 16, signal, onErrorStrategy } = options;
+	if (limit <= 0) throw new RangeError(`Pool limit must be a positive integer.`);
+	if (signal?.aborted) throw signal.reason;
+	let iterator = iterable[Symbol.asyncIterator]?.() ?? iterable[Symbol.iterator]?.();
+	if (!iterator) throw new TypeError(`iterable must be iterable`);
+	let idx = 0;
+	let errors = [];
+	let abortController = new AbortController();
+	let abortSignal = signal ? AbortSignal.any([signal, abortController.signal]) : abortController.signal;
+	async function worker() {
+		while (true) {
+			if (abortSignal.aborted) return;
+			let result;
+			try {
+				result = await iterator.next();
+			} catch (e) {
+				abortController.abort(e);
+				return;
+			}
+			if (result.done) return;
+			if (abortSignal.aborted) return;
+			let item = result.value;
+			let thisIdx = idx++;
+			try {
+				await executor(item, thisIdx);
+			} catch (err) {
+				let action = onErrorStrategy?.(item, thisIdx, err) ?? "throw";
+				if (action instanceof Promise) action = await action;
+				if (action === "ignore") continue;
+				if (action === "collect") {
+					errors.push(new ErrorInfo(item, thisIdx, err));
+					continue;
+				}
+				abortController.abort(err);
+				return;
+			}
+		}
+	}
+	await Promise.all(Array.from({ length: limit }, worker));
+	if (abortSignal.aborted) throw abortSignal.reason;
+	if (errors.length > 0) throw new AggregateError(errors);
+}
+async function parallelMap(iterable, executor, options = {}) {
+	let result = [];
+	if (Array.isArray(iterable)) result.length = iterable.length;
+	await asyncPool(iterable, async (item, index) => {
+		result[index] = await executor(item, index);
+	}, options);
+	return result;
+}
+//#endregion
+//#region src/async/sleep.ts
+function sleep(ms, signal) {
+	if (ms < 0) throw new RangeError("sleep: ms must be a non-negative number");
+	return new Promise((resolve, reject) => {
+		if (signal?.aborted) {
+			reject(signal.reason ?? new DOMException("The operation was aborted.", "AbortError"));
+			return;
+		}
+		let onAbort = () => {
+			clearTimeout(timeoutId);
+			reject(signal.reason ?? new DOMException("The operation was aborted.", "AbortError"));
+		};
+		let timeoutId = setTimeout(() => {
+			signal?.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		signal?.addEventListener("abort", onAbort, { once: true });
+	});
+}
+//#endregion
+//#region src/types/error.ts
+function unknownToError(err) {
+	if (err instanceof Error) return err;
+	if (typeof err === "string") return new Error(err);
+	let error = "";
+	try {
+		error = JSON.stringify(err);
+	} catch (_) {}
+	return new Error(error, { cause: err });
+}
+var NotImplementedError = class extends Error {
+	constructor(message, options = {}) {
+		super(`Not implemented${message != null ? `: ${message}` : ""}`, options);
+	}
+};
+function throwNotImplemented(message, options) {
+	throw new NotImplementedError(message, options);
+}
+function throwUnreachable() {
+	throw new Error("Unreachable");
+}
+//#endregion
+export { AggregateError, AsyncInterval, AsyncLock, AsyncQueue, AsyncResource, ConditionVariable, CustomMap, CustomSet, Deferred, DeferredTracked, Deque, Emitter, LruMap, LruSet, NotImplementedError, abs, asNonNull, assert, assertEndsWith, assertEndsWith as assertsEndsWith, assertHashKey, assertMatches, assertNotNull, assertStartsWith, asyncPool, base64_exports as base64, bitLength, clearUndefinedInPlace, composeMiddlewares, deepMerge, enumerate, euclideanGcd, fromBytes, hex_exports as hex, isBigInt, isBoolean, isFalsy, isFunction, isNotNull, isNotUndefined, isNumber, isObject, isString, isSymbol, isTruthy, max, max2, min, min2, modInv, modPowBinary, noop, objectEntries, objectKeys, parallelMap, sleep, splitOnce, throwNotImplemented, throwUnreachable, timers_exports as timers, toBytes, twoMultiplicity, typed_exports as typed, u8_exports as u8, unknownToError, unsafeCastType, utf8_exports as utf8 };