@yorozu/utils 0.1.4 → 0.3.1

package/index.js

@@ -0,0 +1,3154 @@
+//#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$1 = 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$1;
+		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$1,
+	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
+//#region src/compress/checksum.ts
+var crcTable = new Int32Array(256);
+for (let i = 0; i < 256; i++) {
+	let c = i;
+	for (let k = 0; k < 8; k++) c = (c & 1 ? -306674912 : 0) ^ c >>> 1;
+	crcTable[i] = c;
+}
+var Crc32 = class {
+	_c;
+	constructor(seed = 0) {
+		this._c = ~seed;
+	}
+	update(data) {
+		let c = this._c;
+		for (let i = 0; i < data.length; i++) c = crcTable[c & 255 ^ data[i]] ^ c >>> 8;
+		this._c = c;
+		return this;
+	}
+	digest() {
+		return ~this._c >>> 0;
+	}
+};
+function crc32(data, seed = 0) {
+	return new Crc32(seed).update(data).digest();
+}
+var Adler32 = class {
+	_a;
+	_b;
+	constructor(seed = 1) {
+		this._a = seed & 65535;
+		this._b = seed >>> 16 & 65535;
+	}
+	update(data) {
+		let a = this._a;
+		let b = this._b;
+		let i = 0;
+		let n = data.length;
+		while (i < n) {
+			let end = Math.min(i + 2654, n);
+			for (; i < end; i++) {
+				a += data[i];
+				b += a;
+			}
+			a %= 65521;
+			b %= 65521;
+		}
+		this._a = a;
+		this._b = b;
+		return this;
+	}
+	digest() {
+		return (this._b << 16 | this._a) >>> 0;
+	}
+};
+function adler32(data, seed = 1) {
+	return new Adler32(seed).update(data).digest();
+}
+//#endregion
+//#region src/compress/bits.ts
+function readBits(data, bitPos, mask) {
+	let offset = bitPos / 8 | 0;
+	return (data[offset] | data[offset + 1] << 8) >> (bitPos & 7) & mask;
+}
+function readBits16(data, bitPos) {
+	let offset = bitPos / 8 | 0;
+	return (data[offset] | data[offset + 1] << 8 | data[offset + 2] << 16) >> (bitPos & 7);
+}
+function writeBits(data, bitPos, value) {
+	value <<= bitPos & 7;
+	let offset = bitPos / 8 | 0;
+	data[offset] |= value;
+	data[offset + 1] |= value >> 8;
+}
+function writeBits16(data, bitPos, value) {
+	value <<= bitPos & 7;
+	let offset = bitPos / 8 | 0;
+	data[offset] |= value;
+	data[offset + 1] |= value >> 8;
+	data[offset + 2] |= value >> 16;
+}
+function byteCeil(bitPos) {
+	return (bitPos + 7) / 8 | 0;
+}
+//#endregion
+//#region src/compress/errors.ts
+var FlateError = class extends Error {
+	constructor(message, options) {
+		super(message, options);
+		this.name = new.target.name;
+	}
+};
+var UnexpectedEofError = class extends FlateError {
+	constructor(options) {
+		super("Unexpected end of DEFLATE stream.", options);
+	}
+};
+var InvalidBlockTypeError = class extends FlateError {
+	constructor(options) {
+		super("Invalid DEFLATE block type.", options);
+	}
+};
+var InvalidLengthLiteralError = class extends FlateError {
+	constructor(options) {
+		super("Invalid DEFLATE length or literal symbol.", options);
+	}
+};
+var InvalidDistanceError = class extends FlateError {
+	constructor(options) {
+		super("Invalid DEFLATE distance.", options);
+	}
+};
+var InvalidHeaderError = class extends FlateError {
+	constructor(message = "Invalid compressed stream header.", options) {
+		super(message, options);
+	}
+};
+var StreamFinishedError = class extends FlateError {
+	constructor(options) {
+		super("Stream already finished.", options);
+	}
+};
+var ChecksumMismatchError = class extends FlateError {
+	constructor(options) {
+		super("Checksum mismatch.", options);
+	}
+};
+//#endregion
+//#region src/compress/tables.ts
+var fixedLengthExtraBits = new Uint8Array([
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	1,
+	1,
+	1,
+	1,
+	2,
+	2,
+	2,
+	2,
+	3,
+	3,
+	3,
+	3,
+	4,
+	4,
+	4,
+	4,
+	5,
+	5,
+	5,
+	5,
+	0,
+	0,
+	0
+]);
+var fixedDistanceExtraBits = new Uint8Array([
+	0,
+	0,
+	0,
+	0,
+	1,
+	1,
+	2,
+	2,
+	3,
+	3,
+	4,
+	4,
+	5,
+	5,
+	6,
+	6,
+	7,
+	7,
+	8,
+	8,
+	9,
+	9,
+	10,
+	10,
+	11,
+	11,
+	12,
+	12,
+	13,
+	13,
+	0,
+	0
+]);
+var codeLengthOrder = new Uint8Array([
+	16,
+	17,
+	18,
+	0,
+	8,
+	7,
+	9,
+	6,
+	10,
+	5,
+	11,
+	4,
+	12,
+	3,
+	13,
+	2,
+	14,
+	1,
+	15
+]);
+function basesFromExtra(extraBits, start) {
+	let bases = new Uint16Array(31);
+	for (let i = 0; i < 31; i++) {
+		start += 1 << (i === 0 ? 0 : extraBits[i - 1]);
+		bases[i] = start;
+	}
+	let reverse = new Int32Array(bases[30]);
+	for (let i = 1; i < 30; i++) for (let value = bases[i]; value < bases[i + 1]; value++) reverse[value] = value - bases[i] << 5 | i;
+	return {
+		bases,
+		reverse
+	};
+}
+var lengthTables = basesFromExtra(fixedLengthExtraBits, 2);
+lengthTables.bases[28] = 258;
+lengthTables.reverse[258] = 28;
+var lengthBase = lengthTables.bases;
+var lengthReverse = lengthTables.reverse;
+var distanceTables = basesFromExtra(fixedDistanceExtraBits, 0);
+var distanceBase = distanceTables.bases;
+var distanceReverse = distanceTables.reverse;
+var reverseBits15 = new Uint16Array(32768);
+for (let i = 0; i < 32768; i++) {
+	let x = (i & 43690) >> 1 | (i & 21845) << 1;
+	x = (x & 52428) >> 2 | (x & 13107) << 2;
+	x = (x & 61680) >> 4 | (x & 3855) << 4;
+	reverseBits15[i] = ((x & 65280) >> 8 | (x & 255) << 8) >> 1;
+}
+var fixedLiteralLengths = new Uint8Array(288);
+for (let i = 0; i < 144; i++) fixedLiteralLengths[i] = 8;
+for (let i = 144; i < 256; i++) fixedLiteralLengths[i] = 9;
+for (let i = 256; i < 280; i++) fixedLiteralLengths[i] = 7;
+for (let i = 280; i < 288; i++) fixedLiteralLengths[i] = 8;
+var fixedDistanceLengths = new Uint8Array(32);
+fixedDistanceLengths.fill(5);
+//#endregion
+//#region src/compress/huffman.ts
+function buildEncodeMap(lengths, maxBits) {
+	return buildCodeMap(lengths, maxBits, false);
+}
+function buildDecodeMap(lengths, maxBits) {
+	return buildCodeMap(lengths, maxBits, true);
+}
+function buildCodeMap(lengths, maxBits, decode) {
+	let count = new Uint16Array(maxBits);
+	for (let i = 0; i < lengths.length; i++) if (lengths[i]) count[lengths[i] - 1]++;
+	let nextCode = new Uint16Array(maxBits);
+	for (let i = 1; i < maxBits; i++) nextCode[i] = nextCode[i - 1] + count[i - 1] << 1;
+	if (decode) {
+		let map = new Uint16Array(1 << maxBits);
+		let drop = 15 - maxBits;
+		for (let symbol = 0; symbol < lengths.length; symbol++) {
+			let bits = lengths[symbol];
+			if (!bits) continue;
+			let packed = symbol << 4 | bits;
+			let pad = maxBits - bits;
+			let value = nextCode[bits - 1]++ << pad;
+			let last = value | (1 << pad) - 1;
+			for (; value <= last; value++) map[reverseBits15[value] >> drop] = packed;
+		}
+		return map;
+	}
+	let map = new Uint16Array(lengths.length);
+	for (let symbol = 0; symbol < lengths.length; symbol++) {
+		let bits = lengths[symbol];
+		if (bits) map[symbol] = reverseBits15[nextCode[bits - 1]++] >> 15 - bits;
+	}
+	return map;
+}
+function buildLengthLimitedTree(freqs, maxBits) {
+	let nodes = [];
+	for (let i = 0; i < freqs.length; i++) if (freqs[i]) nodes.push({
+		symbol: i,
+		freq: freqs[i]
+	});
+	let n = nodes.length;
+	let leaves = nodes.slice();
+	if (!n) return {
+		lengths: new Uint8Array(0),
+		maxBits: 0
+	};
+	if (n === 1) {
+		let lengths = new Uint8Array(nodes[0].symbol + 1);
+		lengths[nodes[0].symbol] = 1;
+		return {
+			lengths,
+			maxBits: 1
+		};
+	}
+	nodes.sort((a, b) => a.freq - b.freq);
+	nodes.push({
+		symbol: -1,
+		freq: 25001
+	});
+	let left = nodes[0];
+	let right = nodes[1];
+	let lookbehind = 0;
+	let write = 1;
+	let lookahead = 2;
+	nodes[0] = {
+		symbol: -1,
+		freq: left.freq + right.freq,
+		left,
+		right
+	};
+	while (write !== n - 1) {
+		left = nodes[nodes[lookbehind].freq < nodes[lookahead].freq ? lookbehind++ : lookahead++];
+		right = nodes[lookbehind !== write && nodes[lookbehind].freq < nodes[lookahead].freq ? lookbehind++ : lookahead++];
+		nodes[write++] = {
+			symbol: -1,
+			freq: left.freq + right.freq,
+			left,
+			right
+		};
+	}
+	let maxSymbol = leaves[0].symbol;
+	for (let i = 1; i < n; i++) if (leaves[i].symbol > maxSymbol) maxSymbol = leaves[i].symbol;
+	let bitLengths = new Uint16Array(maxSymbol + 1);
+	let treeBits = assignLengths(nodes[write - 1], bitLengths, 0);
+	if (treeBits > maxBits) {
+		let debt = 0;
+		let overflow = treeBits - maxBits;
+		let cost = 1 << overflow;
+		leaves.sort((a, b) => bitLengths[b.symbol] - bitLengths[a.symbol] || a.freq - b.freq);
+		let i = 0;
+		for (; i < n; i++) {
+			let symbol = leaves[i].symbol;
+			if (bitLengths[symbol] > maxBits) {
+				debt += cost - (1 << treeBits - bitLengths[symbol]);
+				bitLengths[symbol] = maxBits;
+			} else break;
+		}
+		debt >>= overflow;
+		while (debt > 0) {
+			let symbol = leaves[i].symbol;
+			if (bitLengths[symbol] < maxBits) debt -= 1 << maxBits - bitLengths[symbol]++ - 1;
+			else i++;
+		}
+		for (; i >= 0 && debt; i--) {
+			let symbol = leaves[i].symbol;
+			if (bitLengths[symbol] === maxBits) {
+				bitLengths[symbol]--;
+				debt++;
+			}
+		}
+		treeBits = maxBits;
+	}
+	return {
+		lengths: new Uint8Array(bitLengths),
+		maxBits: treeBits
+	};
+}
+function assignLengths(node, lengths, depth) {
+	if (node.symbol === -1) return Math.max(assignLengths(node.left, lengths, depth + 1), assignLengths(node.right, lengths, depth + 1));
+	lengths[node.symbol] = depth;
+	return depth;
+}
+//#endregion
+//#region src/compress/deflate.ts
+var levelOptions = new Int32Array([
+	65540,
+	131080,
+	131088,
+	131104,
+	262176,
+	1048704,
+	1048832,
+	2114560,
+	2117632
+]);
+var empty = empty$1;
+var fixedLiteralEncode = /* @__PURE__ */ buildEncodeMap(fixedLiteralLengths, 9);
+var fixedDistanceEncode = /* @__PURE__ */ buildEncodeMap(fixedDistanceLengths, 5);
+function copySlice$1(buffer, start, end) {
+	if (start < 0) start = 0;
+	if (end == null || end > buffer.length) end = buffer.length;
+	return new Uint8Array(buffer.subarray(start, end));
+}
+function encodedSize(freqs, lengths) {
+	let bits = 0;
+	for (let i = 0; i < lengths.length; i++) bits += freqs[i] * lengths[i];
+	return bits;
+}
+function runLengthCodeLengths(lengths) {
+	let end = lengths.length;
+	while (end && !lengths[--end]);
+	let packed = new Uint16Array(++end);
+	let count = 0;
+	let value = lengths[0];
+	let run = 1;
+	let write = (code) => {
+		packed[count++] = code;
+	};
+	for (let i = 1; i <= end; i++) if (lengths[i] === value && i !== end) run++;
+	else {
+		if (!value && run > 2) {
+			for (; run > 138; run -= 138) write(32754);
+			if (run > 2) {
+				write(run > 10 ? run - 11 << 5 | 28690 : run - 3 << 5 | 12305);
+				run = 0;
+			}
+		} else if (run > 3) {
+			write(value);
+			run--;
+			for (; run > 6; run -= 6) write(8304);
+			if (run > 2) {
+				write(run - 3 << 5 | 8208);
+				run = 0;
+			}
+		}
+		while (run--) write(value);
+		run = 1;
+		value = lengths[i];
+	}
+	return {
+		codes: packed.subarray(0, count),
+		used: end
+	};
+}
+function writeStoredBlock(out, bitPos, data) {
+	let length = data.length;
+	let offset = byteCeil(bitPos + 2);
+	out[offset] = length & 255;
+	out[offset + 1] = length >> 8;
+	out[offset + 2] = out[offset] ^ 255;
+	out[offset + 3] = out[offset + 1] ^ 255;
+	out.set(data, offset + 4);
+	return (offset + 4 + length) * 8;
+}
+function writeBlock(data, out, final, symbols, literalFreq, distanceFreq, extraBits, symbolCount, blockStart, blockLength, bitPos) {
+	writeBits(out, bitPos++, final);
+	literalFreq[256]++;
+	let literalTree = buildLengthLimitedTree(literalFreq, 15);
+	let distanceTree = buildLengthLimitedTree(distanceFreq, 15);
+	let literalRuns = runLengthCodeLengths(literalTree.lengths);
+	let distanceRuns = runLengthCodeLengths(distanceTree.lengths);
+	let codeLengthFreq = new Uint16Array(19);
+	for (let i = 0; i < literalRuns.codes.length; i++) codeLengthFreq[literalRuns.codes[i] & 31]++;
+	for (let i = 0; i < distanceRuns.codes.length; i++) codeLengthFreq[distanceRuns.codes[i] & 31]++;
+	let codeLengthTree = buildLengthLimitedTree(codeLengthFreq, 7);
+	let codeLengthCount = 19;
+	while (codeLengthCount > 4 && !codeLengthTree.lengths[codeLengthOrder[codeLengthCount - 1]]) codeLengthCount--;
+	let storedBits = blockLength + 5 << 3;
+	let fixedBits = encodedSize(literalFreq, fixedLiteralLengths) + encodedSize(distanceFreq, fixedDistanceLengths) + extraBits;
+	let dynamicBits = encodedSize(literalFreq, literalTree.lengths) + encodedSize(distanceFreq, distanceTree.lengths) + extraBits + 14 + 3 * codeLengthCount + encodedSize(codeLengthFreq, codeLengthTree.lengths) + 2 * codeLengthFreq[16] + 3 * codeLengthFreq[17] + 7 * codeLengthFreq[18];
+	if (blockStart >= 0 && storedBits <= fixedBits && storedBits <= dynamicBits) return writeStoredBlock(out, bitPos, data.subarray(blockStart, blockStart + blockLength));
+	let literalMap;
+	let literalLengths;
+	let distanceMap;
+	let distanceLengths;
+	writeBits(out, bitPos, 1 + (dynamicBits < fixedBits ? 1 : 0));
+	bitPos += 2;
+	if (dynamicBits < fixedBits) {
+		literalMap = buildEncodeMap(literalTree.lengths, literalTree.maxBits);
+		literalLengths = literalTree.lengths;
+		distanceMap = buildEncodeMap(distanceTree.lengths, distanceTree.maxBits);
+		distanceLengths = distanceTree.lengths;
+		let codeLengthMap = buildEncodeMap(codeLengthTree.lengths, codeLengthTree.maxBits);
+		writeBits(out, bitPos, literalRuns.used - 257);
+		writeBits(out, bitPos + 5, distanceRuns.used - 1);
+		writeBits(out, bitPos + 10, codeLengthCount - 4);
+		bitPos += 14;
+		for (let i = 0; i < codeLengthCount; i++) writeBits(out, bitPos + 3 * i, codeLengthTree.lengths[codeLengthOrder[i]]);
+		bitPos += 3 * codeLengthCount;
+		let runs = [literalRuns.codes, distanceRuns.codes];
+		for (let set = 0; set < 2; set++) {
+			let codes = runs[set];
+			for (let i = 0; i < codes.length; i++) {
+				let symbol = codes[i] & 31;
+				writeBits(out, bitPos, codeLengthMap[symbol]);
+				bitPos += codeLengthTree.lengths[symbol];
+				if (symbol > 15) {
+					writeBits(out, bitPos, codes[i] >> 5 & 127);
+					bitPos += codes[i] >> 12;
+				}
+			}
+		}
+	} else {
+		literalMap = fixedLiteralEncode;
+		literalLengths = fixedLiteralLengths;
+		distanceMap = fixedDistanceEncode;
+		distanceLengths = fixedDistanceLengths;
+	}
+	for (let i = 0; i < symbolCount; i++) {
+		let symbol = symbols[i];
+		if (symbol > 255) {
+			let lengthIndex = symbol >> 18 & 31;
+			writeBits16(out, bitPos, literalMap[lengthIndex + 257]);
+			bitPos += literalLengths[lengthIndex + 257];
+			if (lengthIndex > 7) {
+				writeBits(out, bitPos, symbol >> 23 & 31);
+				bitPos += fixedLengthExtraBits[lengthIndex];
+			}
+			let distanceIndex = symbol & 31;
+			writeBits16(out, bitPos, distanceMap[distanceIndex]);
+			bitPos += distanceLengths[distanceIndex];
+			if (distanceIndex > 3) {
+				writeBits16(out, bitPos, symbol >> 5 & 8191);
+				bitPos += fixedDistanceExtraBits[distanceIndex];
+			}
+		} else {
+			writeBits16(out, bitPos, literalMap[symbol]);
+			bitPos += literalLengths[symbol];
+		}
+	}
+	writeBits16(out, bitPos, literalMap[256]);
+	return bitPos + literalLengths[256];
+}
+function deflateRaw(data, level, hashBits, pre, post, state) {
+	let size = state.end || data.length;
+	let out = new Uint8Array(pre + size + 5 * (1 + Math.ceil(size / 7e3)) + post);
+	let dest = out.subarray(pre, out.length - post);
+	let last = state.last;
+	let pos = (state.remainder || 0) & 7;
+	if (level) {
+		if (pos) dest[0] = state.remainder >> 3;
+		let opt = levelOptions[level - 1];
+		let nice = opt >> 13;
+		let chain = opt & 8191;
+		let mask = (1 << hashBits) - 1;
+		let prev = state.prev || new Uint16Array(32768);
+		let head = state.head || new Uint16Array(mask + 1);
+		let shift1 = Math.ceil(hashBits / 3);
+		let shift2 = 2 * shift1;
+		let hashAt = (i) => (data[i] ^ data[i + 1] << shift1 ^ data[i + 2] << shift2) & mask;
+		let symbols = new Int32Array(25e3);
+		let literalFreq = new Uint16Array(288);
+		let distanceFreq = new Uint16Array(32);
+		let matches = 0;
+		let extraBits = 0;
+		let i = state.index || 0;
+		let symbolCount = 0;
+		let wait = state.wait || 0;
+		let blockStart = 0;
+		for (; i + 2 < size; i++) {
+			let hv = hashAt(i);
+			let imod = i & 32767;
+			let previous = head[hv];
+			prev[imod] = previous;
+			head[hv] = imod;
+			if (wait <= i) {
+				let remaining = size - i;
+				if ((matches > 7e3 || symbolCount > 24576) && (remaining > 423 || !last)) {
+					pos = writeBlock(data, dest, 0, symbols, literalFreq, distanceFreq, extraBits, symbolCount, blockStart, i - blockStart, pos);
+					symbolCount = matches = extraBits = 0;
+					blockStart = i;
+					literalFreq.fill(0);
+					distanceFreq.fill(0);
+				}
+				let bestLen = 2;
+				let bestDist = 0;
+				let tries = chain;
+				let dist = imod - previous & 32767;
+				if (remaining > 2 && hv === hashAt(i - dist)) {
+					let niceLen = Math.min(nice, remaining) - 1;
+					let maxDist = Math.min(32767, i);
+					let maxLen = Math.min(258, remaining);
+					while (dist <= maxDist && --tries && imod !== previous) {
+						if (data[i + bestLen] === data[i + bestLen - dist]) {
+							let len = 0;
+							for (; len < maxLen && data[i + len] === data[i + len - dist]; len++);
+							if (len > bestLen) {
+								bestLen = len;
+								bestDist = dist;
+								if (len > niceLen) break;
+								let search = Math.min(dist, len - 2);
+								let rarest = 0;
+								for (let j = 0; j < search; j++) {
+									let ti = i - dist + j & 32767;
+									let candidate = ti - prev[ti] & 32767;
+									if (candidate > rarest) {
+										rarest = candidate;
+										previous = ti;
+									}
+								}
+							}
+						}
+						imod = previous;
+						previous = prev[imod];
+						dist += imod - previous & 32767;
+					}
+				}
+				if (bestDist) {
+					symbols[symbolCount++] = 268435456 | lengthReverse[bestLen] << 18 | distanceReverse[bestDist];
+					let lengthIndex = lengthReverse[bestLen] & 31;
+					let distanceIndex = distanceReverse[bestDist] & 31;
+					extraBits += fixedLengthExtraBits[lengthIndex] + fixedDistanceExtraBits[distanceIndex];
+					literalFreq[257 + lengthIndex]++;
+					distanceFreq[distanceIndex]++;
+					wait = i + bestLen;
+					matches++;
+				} else {
+					symbols[symbolCount++] = data[i];
+					literalFreq[data[i]]++;
+				}
+			}
+		}
+		for (i = Math.max(i, wait); i < size; i++) {
+			symbols[symbolCount++] = data[i];
+			literalFreq[data[i]]++;
+		}
+		pos = writeBlock(data, dest, last, symbols, literalFreq, distanceFreq, extraBits, symbolCount, blockStart, i - blockStart, pos);
+		if (!last) {
+			state.remainder = pos & 7 | dest[pos / 8 | 0] << 3;
+			pos -= 7;
+			state.head = head;
+			state.prev = prev;
+			state.index = i;
+			state.wait = wait;
+		}
+	} else {
+		for (let i = state.wait || 0; i < size + last; i += 65535) {
+			let end = i + 65535;
+			if (end >= size) {
+				dest[pos / 8 | 0] = last;
+				end = size;
+			}
+			pos = writeStoredBlock(dest, pos + 1, data.subarray(i, end));
+		}
+		state.index = size;
+	}
+	return copySlice$1(out, 0, pre + byteCeil(pos) + post);
+}
+function defaultHashBits(length, last) {
+	if (!last) return 20;
+	return Math.ceil(Math.max(8, Math.min(13, Math.log(Math.max(length, 1)))) * 1.5);
+}
+function deflateWithOptions(data, options, pre, post, state) {
+	if (!state) {
+		state = { last: 1 };
+		if (options.dictionary) {
+			let dict = options.dictionary.subarray(-32768);
+			let prefixed = new Uint8Array(dict.length + data.length);
+			prefixed.set(dict);
+			prefixed.set(data, dict.length);
+			data = prefixed;
+			state.wait = dict.length;
+		}
+	}
+	let level = options.level == null ? 6 : options.level;
+	let hashBits = options.mem == null ? defaultHashBits(data.length, state.last) : 12 + options.mem;
+	return deflateRaw(data, level, hashBits, pre, post, state);
+}
+function compress$2(data, options = {}) {
+	return deflateWithOptions(data, options, 0, 0);
+}
+var Compressor$2 = class {
+	_options;
+	_state;
+	_buffer;
+	_done = false;
+	constructor(options = {}) {
+		this._options = options;
+		this._state = {
+			last: 0,
+			index: 32768,
+			wait: 32768,
+			end: 32768
+		};
+		this._buffer = new Uint8Array(98304);
+		if (options.dictionary) {
+			let dict = options.dictionary.subarray(-32768);
+			this._buffer.set(dict, 32768 - dict.length);
+			this._state.index = 32768 - dict.length;
+		}
+	}
+	_emit(final) {
+		return deflateWithOptions(this._buffer, this._options, 0, 0, this._state);
+	}
+	push(chunk, final) {
+		if (this._done) throw new StreamFinishedError();
+		let endLen = chunk.length + this._state.end;
+		if (endLen > this._buffer.length) {
+			if (endLen > 2 * this._buffer.length - 32768) {
+				let next = new Uint8Array(endLen & -32768);
+				next.set(this._buffer.subarray(0, this._state.end));
+				this._buffer = next;
+			}
+			let split = this._buffer.length - this._state.end;
+			this._buffer.set(chunk.subarray(0, split), this._state.end);
+			this._state.end = this._buffer.length;
+			let first = this._emit(false);
+			this._buffer.set(this._buffer.subarray(-32768));
+			this._buffer.set(chunk.subarray(split), 32768);
+			this._state.end = chunk.length - split + 32768;
+			this._state.index = 32766;
+			this._state.wait = 32768;
+			this._state.last = final ? 1 : 0;
+			let rest = new Uint8Array(0);
+			if (this._state.end > this._state.wait + 8191 || final) {
+				rest = this._emit(!!final);
+				this._state.wait = this._state.index;
+				this._state.index -= 2;
+			}
+			if (final) {
+				this._done = true;
+				this._buffer = empty;
+				this._state = { last: 1 };
+			}
+			if (!rest.length) return first;
+			let joined = new Uint8Array(first.length + rest.length);
+			joined.set(first);
+			joined.set(rest, first.length);
+			return joined;
+		}
+		this._buffer.set(chunk, this._state.end);
+		this._state.end += chunk.length;
+		this._state.last = final ? 1 : 0;
+		let out = empty$1;
+		if (this._state.end > this._state.wait + 8191 || final) {
+			out = this._emit(!!final);
+			this._state.wait = this._state.index;
+			this._state.index -= 2;
+		}
+		if (final) {
+			this._done = true;
+			this._buffer = empty;
+			this._state = { last: 1 };
+		}
+		return out;
+	}
+	flush(sync) {
+		if (this._done) throw new StreamFinishedError();
+		let out = this._emit(false);
+		this._state.wait = this._state.index;
+		this._state.index -= 2;
+		if (!sync) return out;
+		let block = new Uint8Array(6);
+		block[0] = this._state.remainder >> 3;
+		let end = writeStoredBlock(block, this._state.remainder, empty);
+		this._state.remainder = 0;
+		let trailer = block.subarray(0, end >> 3);
+		if (!out.length) return new Uint8Array(trailer);
+		let joined = new Uint8Array(out.length + trailer.length);
+		joined.set(out);
+		joined.set(trailer, out.length);
+		return joined;
+	}
+};
+//#endregion
+//#region src/compress/inflate.ts
+var fixedLengthMap = /* @__PURE__ */ buildDecodeMap(fixedLiteralLengths, 9);
+var fixedDistanceMap = /* @__PURE__ */ buildDecodeMap(fixedDistanceLengths, 5);
+function copySlice(buffer, start, end) {
+	if (start < 0) start = 0;
+	if (end == null || end > buffer.length) end = buffer.length;
+	return new Uint8Array(buffer.subarray(start, end));
+}
+function maxValue(values) {
+	let max = values[0];
+	for (let i = 1; i < values.length; i++) if (values[i] > max) max = values[i];
+	return max;
+}
+function inflateRaw(data, state, buf, dictionary) {
+	let sourceLength = data.length;
+	let dictLength = dictionary ? dictionary.length : 0;
+	if (!sourceLength || state.final && !state.lengthMap) return buf || empty$1;
+	let noBuf = !buf;
+	let resize = noBuf || state.mode !== 2;
+	let throwOnEof = state.mode !== 0;
+	if (noBuf) buf = new Uint8Array(sourceLength * 3);
+	let ensure = (need) => {
+		if (need <= buf.length) return;
+		let next = new Uint8Array(Math.max(buf.length * 2, need));
+		next.set(buf);
+		buf = next;
+	};
+	let final = state.final || 0;
+	let pos = state.bitPos || 0;
+	let written = state.outputLength || 0;
+	let lengthMap = state.lengthMap;
+	let distanceMap = state.distanceMap;
+	let lengthBits = state.lengthBits;
+	let distanceBits = state.distanceBits;
+	let totalBits = sourceLength * 8;
+	do {
+		if (!lengthMap) {
+			final = readBits(data, pos, 1);
+			let type = readBits(data, pos + 1, 3);
+			pos += 3;
+			if (!type) {
+				let start = byteCeil(pos) + 4;
+				let length = data[start - 4] | data[start - 3] << 8;
+				let end = start + length;
+				if (end > sourceLength) {
+					if (throwOnEof) throw new UnexpectedEofError();
+					break;
+				}
+				if (resize) ensure(written + length);
+				let room = buf.length - written;
+				if (room > 0) buf.set(data.subarray(start, start + Math.min(length, room)), written);
+				state.outputLength = written += length;
+				state.bitPos = pos = end * 8;
+				state.final = final;
+				continue;
+			} else if (type === 1) {
+				lengthMap = fixedLengthMap;
+				distanceMap = fixedDistanceMap;
+				lengthBits = 9;
+				distanceBits = 5;
+			} else if (type === 2) {
+				let literalCount = readBits(data, pos, 31) + 257;
+				let distanceCount = readBits(data, pos + 5, 31) + 1;
+				let codeLengthCount = readBits(data, pos + 10, 15) + 4;
+				let totalCodes = literalCount + distanceCount;
+				pos += 14;
+				let lengths = new Uint8Array(totalCodes);
+				let codeLengthTree = new Uint8Array(19);
+				for (let i = 0; i < codeLengthCount; i++) codeLengthTree[codeLengthOrder[i]] = readBits(data, pos + i * 3, 7);
+				pos += codeLengthCount * 3;
+				let codeLengthBits = maxValue(codeLengthTree);
+				let codeLengthMask = (1 << codeLengthBits) - 1;
+				let codeLengthMap = buildDecodeMap(codeLengthTree, codeLengthBits);
+				for (let i = 0; i < totalCodes;) {
+					let entry = codeLengthMap[readBits(data, pos, codeLengthMask)];
+					pos += entry & 15;
+					let symbol = entry >> 4;
+					if (symbol < 16) lengths[i++] = symbol;
+					else {
+						let fill = 0;
+						let count = 0;
+						if (symbol === 16) {
+							count = 3 + readBits(data, pos, 3);
+							pos += 2;
+							fill = lengths[i - 1];
+						} else if (symbol === 17) {
+							count = 3 + readBits(data, pos, 7);
+							pos += 3;
+						} else if (symbol === 18) {
+							count = 11 + readBits(data, pos, 127);
+							pos += 7;
+						}
+						while (count--) lengths[i++] = fill;
+					}
+				}
+				let literalLengths = lengths.subarray(0, literalCount);
+				let distanceLengths = lengths.subarray(literalCount);
+				lengthBits = maxValue(literalLengths);
+				distanceBits = maxValue(distanceLengths);
+				lengthMap = buildDecodeMap(literalLengths, lengthBits);
+				distanceMap = buildDecodeMap(distanceLengths, distanceBits);
+			} else throw new InvalidBlockTypeError();
+			if (pos > totalBits) {
+				if (throwOnEof) throw new UnexpectedEofError();
+				break;
+			}
+		}
+		if (resize) ensure(written + 131072);
+		let lengthMask = (1 << lengthBits) - 1;
+		let distanceMask = (1 << distanceBits) - 1;
+		let lastPos = pos;
+		for (;; lastPos = pos) {
+			let entry = lengthMap[readBits16(data, pos) & lengthMask];
+			let symbol = entry >> 4;
+			pos += entry & 15;
+			if (pos > totalBits) {
+				if (throwOnEof) throw new UnexpectedEofError();
+				break;
+			}
+			if (!entry) throw new InvalidLengthLiteralError();
+			if (symbol < 256) {
+				if (written < buf.length) buf[written] = symbol;
+				written++;
+			} else if (symbol === 256) {
+				lastPos = pos;
+				lengthMap = void 0;
+				break;
+			} else {
+				let add = symbol - 254;
+				if (symbol > 264) {
+					let index = symbol - 257;
+					let extra = fixedLengthExtraBits[index];
+					add = readBits(data, pos, (1 << extra) - 1) + lengthBase[index];
+					pos += extra;
+				}
+				let distEntry = distanceMap[readBits16(data, pos) & distanceMask];
+				let distSymbol = distEntry >> 4;
+				if (!distEntry) throw new InvalidDistanceError();
+				pos += distEntry & 15;
+				let distance = distanceBase[distSymbol];
+				if (distSymbol > 3) {
+					let extra = fixedDistanceExtraBits[distSymbol];
+					distance += readBits16(data, pos) & (1 << extra) - 1;
+					pos += extra;
+				}
+				if (pos > totalBits) {
+					if (throwOnEof) throw new UnexpectedEofError();
+					break;
+				}
+				if (resize) ensure(written + 131072);
+				let end = written + add;
+				if (written < distance) {
+					let shift = dictLength - distance;
+					let dictEnd = Math.min(distance, end);
+					if (shift + written < 0) throw new InvalidDistanceError();
+					for (; written < dictEnd; written++) if (written < buf.length) buf[written] = dictionary[shift + written];
+				}
+				for (; written < end; written++) if (written < buf.length) buf[written] = buf[written - distance];
+			}
+		}
+		state.lengthMap = lengthMap;
+		state.bitPos = lastPos;
+		state.outputLength = written;
+		state.final = final;
+		if (lengthMap) {
+			final = 1;
+			state.lengthBits = lengthBits;
+			state.distanceMap = distanceMap;
+			state.distanceBits = distanceBits;
+		}
+	} while (!final);
+	let length = Math.min(written, buf.length);
+	if (length === buf.length) return buf;
+	return noBuf ? copySlice(buf, 0, length) : buf.subarray(0, length);
+}
+function decompress$3(data, options) {
+	return inflateRaw(data, { mode: 2 }, options?.out, options?.dictionary);
+}
+var Decompressor$2 = class {
+	_state;
+	_window;
+	_pending;
+	_done = false;
+	constructor(options) {
+		let dict = options?.dictionary?.subarray(-32768);
+		this._state = {
+			mode: 0,
+			outputLength: dict ? dict.length : 0
+		};
+		this._window = new Uint8Array(32768);
+		this._pending = empty$1;
+		if (dict) this._window.set(dict);
+	}
+	push(chunk, final) {
+		if (this._done) throw new StreamFinishedError();
+		if (!this._pending.length) this._pending = chunk;
+		else if (chunk.length) {
+			let next = new Uint8Array(this._pending.length + chunk.length);
+			next.set(this._pending);
+			next.set(chunk, this._pending.length);
+			this._pending = next;
+		}
+		this._done = !!final;
+		this._state.mode = this._done ? 1 : 0;
+		let start = this._state.outputLength || 0;
+		let out = inflateRaw(this._pending, this._state, this._window);
+		let produced = copySlice(out, start, this._state.outputLength);
+		this._window = copySlice(out, (this._state.outputLength || 0) - 32768);
+		this._state.outputLength = this._window.length;
+		this._pending = copySlice(this._pending, (this._state.bitPos || 0) / 8 | 0);
+		this._state.bitPos = (this._state.bitPos || 0) & 7;
+		return produced.length ? produced : empty$1;
+	}
+};
+//#endregion
+//#region src/compress/gzip.ts
+function writeU32LE(buf, offset, value) {
+	buf[offset] = value;
+	buf[offset + 1] = value >>> 8;
+	buf[offset + 2] = value >>> 16;
+	buf[offset + 3] = value >>> 24;
+}
+function readU32LE(buf, offset) {
+	return (buf[offset] | buf[offset + 1] << 8 | buf[offset + 2] << 16 | buf[offset + 3] << 24) >>> 0;
+}
+function gzipHeaderSize(options) {
+	return 10 + (options.filename ? options.filename.length + 1 : 0);
+}
+function writeGzipHeader(out, options) {
+	out[0] = 31;
+	out[1] = 139;
+	out[2] = 8;
+	let level = options.level ?? 6;
+	out[8] = level < 2 ? 4 : level === 9 ? 2 : 0;
+	out[9] = 3;
+	if (options.mtime !== 0) writeU32LE(out, 4, Math.floor((options.mtime != null ? new Date(options.mtime).getTime() : Date.now()) / 1e3) >>> 0);
+	if (options.filename) {
+		out[3] = 8;
+		for (let i = 0; i < options.filename.length; i++) out[10 + i] = options.filename.charCodeAt(i);
+		out[10 + options.filename.length] = 0;
+	}
+}
+function gzipHeaderLength(data) {
+	if (data.length < 10) throw new UnexpectedEofError();
+	if (data[0] !== 31 || data[1] !== 139 || data[2] !== 8) throw new InvalidHeaderError("Invalid gzip header.");
+	let flags = data[3];
+	let offset = 10;
+	if (flags & 4) {
+		if (offset + 2 > data.length) throw new UnexpectedEofError();
+		offset += (data[offset] | data[offset + 1] << 8) + 2;
+	}
+	let strings = (flags >> 3 & 1) + (flags >> 4 & 1);
+	while (strings) {
+		if (offset >= data.length) throw new UnexpectedEofError();
+		if (!data[offset++]) strings--;
+	}
+	if (flags & 2) offset += 2;
+	if (offset > data.length) throw new UnexpectedEofError();
+	return offset;
+}
+function concatParts(parts) {
+	if (parts.length === 0) return empty$1;
+	if (parts.length === 1) return parts[0];
+	let out = new Uint8Array(parts.reduce((n, p) => n + p.length, 0));
+	let offset = 0;
+	for (let part of parts) {
+		out.set(part, offset);
+		offset += part.length;
+	}
+	return out;
+}
+function verifyFooter(footer, data, check) {
+	if (!check) return;
+	if (readU32LE(footer, 0) !== crc32(data) || readU32LE(footer, 4) !== data.length >>> 0) throw new ChecksumMismatchError();
+}
+function compress$1(data, options = {}) {
+	let out = deflateWithOptions(data, options, gzipHeaderSize(options), 8);
+	writeGzipHeader(out, options);
+	writeU32LE(out, out.length - 8, crc32(data));
+	writeU32LE(out, out.length - 4, data.length >>> 0);
+	return out;
+}
+function decompress$2(data, options) {
+	let parts = [];
+	let offset = 0;
+	while (offset < data.length) {
+		let header = gzipHeaderLength(data.subarray(offset));
+		offset += header;
+		let state = { mode: 2 };
+		let payload = inflateRaw(data.subarray(offset), state);
+		parts.push(payload);
+		offset += byteCeil(state.bitPos || 0);
+		if (offset + 8 > data.length) throw new UnexpectedEofError();
+		verifyFooter(data.subarray(offset, offset + 8), payload, options?.check !== false);
+		offset += 8;
+	}
+	return concatParts(parts);
+}
+var Compressor$1 = class {
+	_inner;
+	_options;
+	_crc = new Crc32();
+	_length = 0;
+	_header = false;
+	_done = false;
+	constructor(options = {}) {
+		this._options = options;
+		this._inner = new Compressor$2(options);
+	}
+	_wrap(raw, final) {
+		let header = 0;
+		if (!this._header) {
+			header = gzipHeaderSize(this._options);
+			this._header = true;
+		}
+		let footer = final ? 8 : 0;
+		if (!header && !footer) return raw;
+		let out = new Uint8Array(header + raw.length + footer);
+		if (header) writeGzipHeader(out, this._options);
+		out.set(raw, header);
+		if (footer) {
+			writeU32LE(out, header + raw.length, this._crc.digest());
+			writeU32LE(out, header + raw.length + 4, this._length >>> 0);
+		}
+		return out;
+	}
+	push(chunk, final) {
+		if (this._done) throw new StreamFinishedError();
+		this._crc.update(chunk);
+		this._length += chunk.length;
+		this._done = !!final;
+		return this._wrap(this._inner.push(chunk, final), !!final);
+	}
+	flush(sync) {
+		if (this._done) throw new StreamFinishedError();
+		return this._wrap(this._inner.flush(sync), false);
+	}
+};
+var Decompressor$1 = class {
+	_pending = empty$1;
+	_needHeader = true;
+	_state = { mode: 0 };
+	_window = new Uint8Array(32768);
+	_crc = new Crc32();
+	_length = 0;
+	_check;
+	_done = false;
+	constructor(options) {
+		this._check = options?.check !== false;
+	}
+	push(chunk, final) {
+		if (this._done) throw new StreamFinishedError();
+		if (!this._pending.length) this._pending = chunk;
+		else if (chunk.length) {
+			let next = new Uint8Array(this._pending.length + chunk.length);
+			next.set(this._pending);
+			next.set(chunk, this._pending.length);
+			this._pending = next;
+		}
+		let parts = [];
+		for (;;) {
+			if (this._needHeader) {
+				if (!this._pending.length) break;
+				if (this._pending.length < 10 && !final) break;
+				let header = gzipHeaderLength(this._pending);
+				this._pending = this._pending.subarray(header);
+				this._needHeader = false;
+				this._state = { mode: 0 };
+				this._window = new Uint8Array(32768);
+				this._crc = new Crc32();
+				this._length = 0;
+			}
+			this._state.mode = 0;
+			let start = this._state.outputLength || 0;
+			let out = inflateRaw(this._pending, this._state, this._window);
+			let produced = out.subarray(start, Math.min(this._state.outputLength || 0, out.length));
+			if (produced.length) {
+				this._crc.update(produced);
+				this._length += produced.length;
+				parts.push(new Uint8Array(produced));
+			}
+			if (this._state.final && !this._state.lengthMap) {
+				this._pending = this._pending.subarray(byteCeil(this._state.bitPos || 0));
+				this._state.bitPos = 0;
+			} else {
+				this._pending = this._pending.subarray((this._state.bitPos || 0) / 8 | 0);
+				this._state.bitPos = (this._state.bitPos || 0) & 7;
+			}
+			this._window = new Uint8Array(out.subarray(Math.max(0, (this._state.outputLength || 0) - 32768)));
+			this._state.outputLength = this._window.length;
+			if (this._state.final && !this._state.lengthMap) {
+				if (this._pending.length < 8) {
+					if (!final) break;
+					throw new UnexpectedEofError();
+				}
+				if (this._check) {
+					if (readU32LE(this._pending, 0) !== this._crc.digest() || readU32LE(this._pending, 4) !== this._length >>> 0) throw new ChecksumMismatchError();
+				}
+				this._pending = this._pending.subarray(8);
+				this._needHeader = true;
+				continue;
+			}
+			break;
+		}
+		if (final) this._done = true;
+		return concatParts(parts);
+	}
+};
+//#endregion
+//#region src/compress/zlib.ts
+function writeU32BE(buf, offset, value) {
+	buf[offset] = value >>> 24;
+	buf[offset + 1] = value >>> 16;
+	buf[offset + 2] = value >>> 8;
+	buf[offset + 3] = value;
+}
+function readU32BE(buf, offset) {
+	return (buf[offset] << 24 | buf[offset + 1] << 16 | buf[offset + 2] << 8 | buf[offset + 3]) >>> 0;
+}
+function zlibHeaderSize(options) {
+	return options.dictionary ? 6 : 2;
+}
+function writeZlibHeader(out, options) {
+	let level = options.level ?? 6;
+	let flevel = level === 0 ? 0 : level < 6 ? 1 : level === 9 ? 3 : 2;
+	out[0] = 120;
+	out[1] = flevel << 6 | (options.dictionary ? 32 : 0);
+	out[1] += 31 - (out[0] << 8 | out[1]) % 31;
+	if (options.dictionary) writeU32BE(out, 2, adler32(options.dictionary));
+}
+function zlibHeaderLength(data, dictionary) {
+	if (data.length < 2) throw new UnexpectedEofError();
+	if ((data[0] & 15) !== 8 || data[0] >> 4 > 7 || (data[0] << 8 | data[1]) % 31 !== 0) throw new InvalidHeaderError("Invalid zlib header.");
+	let hasDict = data[1] >> 5 & 1;
+	if (hasDict && !dictionary) throw new InvalidHeaderError("zlib stream requires a dictionary.");
+	if (!hasDict && dictionary) throw new InvalidHeaderError("zlib stream has no dictionary.");
+	let size = hasDict ? 6 : 2;
+	if (data.length < size) throw new UnexpectedEofError();
+	return size;
+}
+function compress(data, options = {}) {
+	let out = deflateWithOptions(data, options, zlibHeaderSize(options), 4);
+	writeZlibHeader(out, options);
+	writeU32BE(out, out.length - 4, adler32(data));
+	return out;
+}
+function decompress$1(data, options) {
+	let header = zlibHeaderLength(data, options?.dictionary);
+	let state = { mode: 2 };
+	let payload = inflateRaw(data.subarray(header), state, options?.out, options?.dictionary);
+	let trailer = header + byteCeil(state.bitPos || 0);
+	if (options?.check !== false) {
+		if (trailer + 4 > data.length) throw new UnexpectedEofError();
+		if (readU32BE(data, trailer) !== adler32(payload)) throw new ChecksumMismatchError();
+	}
+	return payload;
+}
+var Compressor = class {
+	_inner;
+	_options;
+	_sum = new Adler32();
+	_header = false;
+	_done = false;
+	constructor(options = {}) {
+		this._options = options;
+		this._inner = new Compressor$2(options);
+	}
+	_wrap(raw, final) {
+		let header = 0;
+		if (!this._header) {
+			header = zlibHeaderSize(this._options);
+			this._header = true;
+		}
+		let footer = final ? 4 : 0;
+		if (!header && !footer) return raw;
+		let out = new Uint8Array(header + raw.length + footer);
+		if (header) writeZlibHeader(out, this._options);
+		out.set(raw, header);
+		if (footer) writeU32BE(out, header + raw.length, this._sum.digest());
+		return out;
+	}
+	push(chunk, final) {
+		if (this._done) throw new StreamFinishedError();
+		this._sum.update(chunk);
+		this._done = !!final;
+		return this._wrap(this._inner.push(chunk, final), !!final);
+	}
+	flush(sync) {
+		if (this._done) throw new StreamFinishedError();
+		return this._wrap(this._inner.flush(sync), false);
+	}
+};
+var Decompressor = class {
+	_pending = empty$1;
+	_header = false;
+	_state = { mode: 0 };
+	_window = new Uint8Array(32768);
+	_sum = new Adler32();
+	_dictionary;
+	_check;
+	_done = false;
+	constructor(options) {
+		this._dictionary = options?.dictionary;
+		this._check = options?.check !== false;
+		if (options?.dictionary) this._window.set(options.dictionary.subarray(-32768), 32768 - Math.min(32768, options.dictionary.length));
+	}
+	push(chunk, final) {
+		if (this._done) throw new StreamFinishedError();
+		if (!this._pending.length) this._pending = chunk;
+		else if (chunk.length) {
+			let next = new Uint8Array(this._pending.length + chunk.length);
+			next.set(this._pending);
+			next.set(chunk, this._pending.length);
+			this._pending = next;
+		}
+		if (!this._header) {
+			if (this._pending.length < 2 && !final) return empty$1;
+			let size = zlibHeaderLength(this._pending, this._dictionary);
+			if (this._dictionary) {
+				this._state.outputLength = Math.min(32768, this._dictionary.length);
+				this._window = new Uint8Array(32768);
+				this._window.set(this._dictionary.subarray(-32768));
+			}
+			this._pending = this._pending.subarray(size);
+			this._header = true;
+		}
+		this._state.mode = final ? 1 : 0;
+		let start = this._state.outputLength || 0;
+		let out = inflateRaw(this._pending, this._state, this._window, this._header && !start ? this._dictionary : void 0);
+		let produced = new Uint8Array(out.subarray(start, Math.min(this._state.outputLength || 0, out.length)));
+		if (produced.length) this._sum.update(produced);
+		if (this._state.final && !this._state.lengthMap) {
+			this._pending = this._pending.subarray(byteCeil(this._state.bitPos || 0));
+			this._state.bitPos = 0;
+		} else {
+			this._pending = this._pending.subarray((this._state.bitPos || 0) / 8 | 0);
+			this._state.bitPos = (this._state.bitPos || 0) & 7;
+		}
+		this._window = new Uint8Array(out.subarray(Math.max(0, (this._state.outputLength || 0) - 32768)));
+		this._state.outputLength = this._window.length;
+		if (final) {
+			this._done = true;
+			if (this._check && this._state.final) {
+				if (this._pending.length < 4) throw new UnexpectedEofError();
+				if (readU32BE(this._pending, 0) !== this._sum.digest()) throw new ChecksumMismatchError();
+			}
+		}
+		return produced.length ? produced : empty$1;
+	}
+};
+//#endregion
+//#region src/compress/compress.ts
+var compress_exports = /* @__PURE__ */ __exportAll({
+	Deflate: () => Compressor$2,
+	Gzip: () => Compressor$1,
+	Zlib: () => Compressor,
+	deflate: () => compress$2,
+	gzip: () => compress$1,
+	zlib: () => compress
+});
+//#endregion
+//#region src/compress/detect.ts
+function decompress(data, options) {
+	if (data.length >= 2 && data[0] === 31 && data[1] === 139) return decompress$2(data, options);
+	if (data.length >= 2 && (data[0] & 15) === 8 && data[0] >> 4 <= 7 && (data[0] << 8 | data[1]) % 31 === 0) return decompress$1(data, options);
+	return decompress$3(data, options);
+}
+//#endregion
+//#region src/compress/decompress.ts
+var decompress_exports = /* @__PURE__ */ __exportAll({
+	Deflate: () => Decompressor$2,
+	Gzip: () => Decompressor$1,
+	Zlib: () => Decompressor,
+	auto: () => decompress,
+	deflate: () => decompress$3,
+	gzip: () => decompress$2,
+	zlib: () => decompress$1
+});
+//#endregion
+export { Adler32, AggregateError, AsyncInterval, AsyncLock, AsyncQueue, AsyncResource, ChecksumMismatchError, ConditionVariable, Crc32, CustomMap, CustomSet, Deferred, DeferredTracked, Deque, Emitter, FlateError, InvalidBlockTypeError, InvalidDistanceError, InvalidHeaderError, InvalidLengthLiteralError, LruMap, LruSet, NotImplementedError, StreamFinishedError, UnexpectedEofError, abs, adler32, asNonNull, assert, assertEndsWith, assertEndsWith as assertsEndsWith, assertHashKey, assertMatches, assertNotNull, assertStartsWith, asyncPool, base64_exports as base64, bitLength, clearUndefinedInPlace, composeMiddlewares, compress_exports as compress, crc32, decompress_exports as decompress, 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 };