@yorozu/utils 0.3.0 → 0.3.1

package/index.js

@@ -114,7 +114,7 @@ var typed_exports = /* @__PURE__ */ __exportAll({
 });
 //#endregion
 //#region src/arrays/u8/misc.ts
-var empty = new Uint8Array(0);
+var empty$1 = new Uint8Array(0);
 function clone(buf) {
 	return new Uint8Array(buf);
 }
@@ -126,36 +126,36 @@ function readNthBit(byte, bit) {
 var BufferPool = class {
 	size;
 	maxAllocSize;
-	#pool;
-	#offset = 0;
+	_pool;
+	_offset = 0;
 	constructor(size = 16 * 1024) {
 		this.size = size;
 		this.maxAllocSize = size >>> 1;
-		this.#reallocate();
+		this._reallocate();
 	}
-	get #remaining() {
-		return this.size - this.#offset;
+	get _remaining() {
+		return this.size - this._offset;
 	}
 	allocate(size) {
 		if (!Number.isInteger(size) || size < 0) throw new RangeError(`Invalid allocation size: ${size}.`);
-		if (size === 0) return empty;
+		if (size === 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);
+		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();
+		this._reallocate();
 	}
-	#reallocate() {
-		this.#pool = new ArrayBuffer(this.size);
-		this.#offset = 0;
+	_reallocate() {
+		this._pool = new ArrayBuffer(this.size);
+		this._offset = 0;
 	}
-	#align() {
-		let misalignment = this.#offset & 7;
-		if (misalignment !== 0) this.#offset += 8 - misalignment;
+	_align() {
+		let misalignment = this._offset & 7;
+		if (misalignment !== 0) this._offset += 8 - misalignment;
 	}
 };
 var defaultPool = new BufferPool(16 * 1024);
@@ -292,7 +292,7 @@ var u8_exports = /* @__PURE__ */ __exportAll({
 	concat: () => concat,
 	concat2: () => concat2,
 	concat3: () => concat3,
-	empty: () => empty,
+	empty: () => empty$1,
 	readNthBit: () => readNthBit,
 	reverse: () => reverse,
 	setDefaultPool: () => setDefaultPool,
@@ -769,51 +769,51 @@ 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();
+	_handler;
+	_interval;
+	_timer;
+	_onError = noop;
+	_stopped = true;
+	_generation = 0;
+	_abortController = new AbortController();
 	constructor(handler, interval) {
-		this.#handler = handler;
-		this.#interval = interval;
+		this._handler = handler;
+		this._interval = interval;
 	}
-	start(after = this.#interval) {
+	start(after = this._interval) {
 		this.stop();
-		this.#stopped = false;
-		let generation = this.#generation;
-		this.#timer = setTimeoutWrap(() => this.#onTimeout(generation), after);
+		this._stopped = false;
+		let generation = this._generation;
+		this._timer = setTimeoutWrap(() => this._onTimeout(generation), after);
 	}
 	startNow() {
 		this.stop();
-		this.#stopped = false;
-		this.#onTimeout(this.#generation);
+		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._generation++;
+		this._abortController.abort();
+		this._abortController = new AbortController();
+		if (this._timer != null) {
+			clearTimeoutWrap(this._timer);
+			this._timer = void 0;
 		}
-		this.#stopped = true;
+		this._stopped = true;
 	}
 	onError(handler) {
-		this.#onError = handler;
+		this._onError = handler;
 	}
-	#onTimeout = (generation) => {
-		this.#timer = void 0;
+	_onTimeout = (generation) => {
+		this._timer = void 0;
 		(async () => {
 			try {
-				await this.#handler(this.#abortController.signal);
+				await this._handler(this._abortController.signal);
 			} catch (err) {
-				this.#onError(err);
+				this._onError(err);
 			}
-			if (this.#stopped || generation !== this.#generation) return;
-			this.#timer = setTimeoutWrap(() => this.#onTimeout(generation), this.#interval);
+			if (this._stopped || generation !== this._generation) return;
+			this._timer = setTimeoutWrap(() => this._onTimeout(generation), this._interval);
 		})();
 	};
 };
@@ -829,55 +829,55 @@ function maybeWrapIterator(iter) {
 //#region src/structures/custom-map.ts
 var CustomMap = class {
 	clear;
-	#map;
-	#mapperTo;
-	#mapperFrom;
+	_map;
+	_mapperTo;
+	_mapperFrom;
 	constructor(externalToInternal, internalToExternal) {
-		this.#mapperTo = externalToInternal;
-		this.#mapperFrom = internalToExternal;
-		this.clear = (this.#map = /* @__PURE__ */ new Map()).clear.bind(this.#map);
+		this._mapperTo = externalToInternal;
+		this._mapperFrom = internalToExternal;
+		this.clear = (this._map = /* @__PURE__ */ new Map()).clear.bind(this._map);
 	}
 	get size() {
-		return this.#map.size;
+		return this._map.size;
 	}
 	get [Symbol.toStringTag]() {
-		return this.#map[Symbol.toStringTag];
+		return this._map[Symbol.toStringTag];
 	}
 	getInternalMap() {
-		return this.#map;
+		return this._map;
 	}
 	delete(key) {
-		return this.#map.delete(this.#mapperTo(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);
+		return this._map.forEach((value, key) => {
+			cb.call(thisArg, value, this._mapperFrom(key), this);
 		});
 	}
 	get(key) {
-		return this.#map.get(this.#mapperTo(key));
+		return this._map.get(this._mapperTo(key));
 	}
 	has(key) {
-		return this.#map.has(this.#mapperTo(key));
+		return this._map.has(this._mapperTo(key));
 	}
 	set(key, value) {
-		this.#map.set(this.#mapperTo(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);
+		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);
+		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();
+		let inner = this._map.entries();
 		const iterator = {
 			[Symbol.iterator]: () => iterator,
 			next: () => {
@@ -888,14 +888,14 @@ var CustomMap = class {
 				};
 				return {
 					done,
-					value: [this.#mapperFrom(value[0]), value[1]]
+					value: [this._mapperFrom(value[0]), value[1]]
 				};
 			}
 		};
 		return maybeWrapIterator(iterator);
 	}
 	keys() {
-		let inner = this.#map.keys();
+		let inner = this._map.keys();
 		const iterator = {
 			[Symbol.iterator]: () => iterator,
 			next: () => {
@@ -906,14 +906,14 @@ var CustomMap = class {
 				};
 				return {
 					done,
-					value: this.#mapperFrom(value)
+					value: this._mapperFrom(value)
 				};
 			}
 		};
 		return maybeWrapIterator(iterator);
 	}
 	values() {
-		let inner = this.#map.values();
+		let inner = this._map.values();
 		const iterator = {
 			[Symbol.iterator]: () => iterator,
 			next: () => {
@@ -938,39 +938,39 @@ var CustomMap = class {
 //#region src/structures/custom-set.ts
 var CustomSet = class CustomSet {
 	clear;
-	#set;
-	#mapperTo;
-	#mapperFrom;
+	_set;
+	_mapperTo;
+	_mapperFrom;
 	constructor(externalToInternal, internalToExternal) {
-		this.#mapperTo = externalToInternal;
-		this.#mapperFrom = internalToExternal;
-		let set = this.#set = /* @__PURE__ */ new Set();
+		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;
+		return this._set.size;
 	}
 	get [Symbol.toStringTag]() {
-		return this.#set[Symbol.toStringTag];
+		return this._set[Symbol.toStringTag];
 	}
 	add(value) {
-		this.#set.add(this.#mapperTo(value));
+		this._set.add(this._mapperTo(value));
 		return this;
 	}
 	delete(value) {
-		return this.#set.delete(this.#mapperTo(value));
+		return this._set.delete(this._mapperTo(value));
 	}
 	forEach(cb, thisArg) {
-		this.#set.forEach((value) => {
-			let mapped = this.#mapperFrom(value);
+		this._set.forEach((value) => {
+			let mapped = this._mapperFrom(value);
 			cb.call(thisArg, mapped, mapped, this);
 		});
 	}
 	has(value) {
-		return this.#set.has(this.#mapperTo(value));
+		return this._set.has(this._mapperTo(value));
 	}
 	entries() {
-		let inner = this.#set.entries();
+		let inner = this._set.entries();
 		const iterator = {
 			[Symbol.iterator]: () => iterator,
 			next: () => {
@@ -979,7 +979,7 @@ var CustomSet = class CustomSet {
 					done,
 					value
 				};
-				let mapped = this.#mapperFrom(value[0]);
+				let mapped = this._mapperFrom(value[0]);
 				return {
 					done,
 					value: [mapped, mapped]
@@ -989,7 +989,7 @@ var CustomSet = class CustomSet {
 		return maybeWrapIterator(iterator);
 	}
 	keys() {
-		let inner = this.#set.keys();
+		let inner = this._set.keys();
 		const iterator = {
 			[Symbol.iterator]: () => iterator,
 			next: () => {
@@ -1000,7 +1000,7 @@ var CustomSet = class CustomSet {
 				};
 				return {
 					done,
-					value: this.#mapperFrom(value)
+					value: this._mapperFrom(value)
 				};
 			}
 		};
@@ -1010,31 +1010,31 @@ var CustomSet = class CustomSet {
 		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)));
+		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);
+		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);
+		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);
+		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) => {
@@ -1043,7 +1043,7 @@ var CustomSet = class CustomSet {
 		return newSet;
 	}
 	isSubsetOf(other) {
-		for (let v of this.#set) if (!other.has(this.#mapperFrom(v))) return false;
+		for (let v of this._set) if (!other.has(this._mapperFrom(v))) return false;
 		return true;
 	}
 	isSupersetOf(other) {
@@ -1058,7 +1058,7 @@ var CustomSet = class CustomSet {
 		return this.keys();
 	}
 	getInternalSet() {
-		return this.#set;
+		return this._set;
 	}
 };
 //#endregion
@@ -1077,7 +1077,7 @@ var Deque = class {
 	_size = 0;
 	constructor(array, options = {}) {
 		this._capacity = options.capacity;
-		if (array) this.#fromArray(array);
+		if (array) this._fromArray(array);
 		else this._list = new Array(4);
 	}
 	get length() {
@@ -1101,7 +1101,7 @@ var Deque = class {
 		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();
+		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++;
@@ -1109,7 +1109,7 @@ var Deque = class {
 		return this._size;
 	}
 	pushBack(item) {
-		if (this._size === this._list.length) this.#growArray();
+		if (this._size === this._list.length) this._growArray();
 		this._list[this._tail] = item;
 		this._tail = this._tail + 1 & this._capacityMask;
 		this._size++;
@@ -1122,7 +1122,7 @@ var Deque = class {
 		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();
+		if (this._size <= this._list.length / 4 && this._list.length > 4) this._shrinkArray();
 		return item;
 	}
 	popBack() {
@@ -1131,7 +1131,7 @@ var Deque = class {
 		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();
+		if (this._size <= this._list.length / 4 && this._list.length > 4) this._shrinkArray();
 		return item;
 	}
 	removeOne(idx) {
@@ -1140,7 +1140,7 @@ var Deque = class {
 		if (idx < 0) idx += len;
 		let realIdx = this._head + idx & this._capacityMask;
 		let item = this._list[realIdx];
-		this.#remove(realIdx);
+		this._remove(realIdx);
 		return item;
 	}
 	removeBy(predicate) {
@@ -1148,7 +1148,7 @@ var Deque = class {
 			let i = this._head + pos & this._capacityMask;
 			let item = this._list[i];
 			if (item !== void 0 && predicate(item)) {
-				this.#remove(i);
+				this._remove(i);
 				return;
 			}
 		}
@@ -1196,7 +1196,7 @@ var Deque = class {
 			};
 		} };
 	}
-	#fromArray(array) {
+	_fromArray(array) {
 		let start = 0;
 		let length = array.length;
 		if (this._capacity !== void 0 && length > this._capacity) {
@@ -1211,7 +1211,7 @@ var Deque = class {
 		this._size = length;
 		for (let i = 0; i < length; i++) this._list[i] = array[start + i];
 	}
-	#growArray() {
+	_growArray() {
 		let oldMask = this._capacityMask;
 		let oldList = this._list;
 		let oldHead = this._head;
@@ -1223,7 +1223,7 @@ var Deque = class {
 		this._tail = size;
 		this._capacityMask = newList.length - 1;
 	}
-	#shrinkArray() {
+	_shrinkArray() {
 		if (this._list.length <= 4) return;
 		let oldMask = this._capacityMask;
 		let oldList = this._list;
@@ -1236,7 +1236,7 @@ var Deque = class {
 		this._tail = size;
 		this._capacityMask = newList.length - 1;
 	}
-	#remove(idx) {
+	_remove(idx) {
 		let mask = this._capacityMask;
 		let len = this._list.length;
 		let distFromHead = idx - this._head & mask;
@@ -1261,92 +1261,92 @@ var Deque = class {
 			this._tail = last;
 		}
 		this._size--;
-		if (this._size <= this._list.length / 4 && this._list.length > 4) this.#shrinkArray();
+		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;
+	_capacity;
+	_map;
 	constructor(capacity, MapImpl = Map) {
-		this.#capacity = capacity;
-		this.#map = new MapImpl();
+		this._capacity = capacity;
+		this._map = new MapImpl();
 	}
 	get size() {
-		return this.#map.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);
+		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);
+		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);
+		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);
+		this._map.delete(key);
 	}
 	clear() {
-		this.#map.clear();
+		this._map.clear();
 	}
 	*[Symbol.iterator]() {
-		yield* this.#map;
+		yield* this._map;
 	}
 	entries() {
-		return this.#map.entries();
+		return this._map.entries();
 	}
 	keys() {
-		return this.#map.keys();
+		return this._map.keys();
 	}
 	values() {
-		return this.#map.values();
+		return this._map.values();
 	}
 };
 //#endregion
 //#region src/structures/lru-set.ts
 var LruSet = class {
-	#capacity;
-	#set;
+	_capacity;
+	_set;
 	constructor(capacity, SetImpl = Set) {
-		this.#capacity = capacity;
-		this.#set = new SetImpl();
+		this._capacity = capacity;
+		this._set = new SetImpl();
 	}
 	get size() {
-		return this.#set.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);
+		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);
+		return this._set.has(value);
 	}
 	delete(value) {
-		return this.#set.delete(value);
+		return this._set.delete(value);
 	}
 	clear() {
-		this.#set.clear();
+		this._set.clear();
 	}
 	*[Symbol.iterator]() {
-		yield* this.#set;
+		yield* this._set;
 	}
 	toArray() {
-		return Array.from(this.#set);
+		return Array.from(this._set);
 	}
 };
 //#endregion
@@ -1394,13 +1394,13 @@ var Deferred = class {
 var DeferredTracked = class {
 	promise;
 	status;
-	#resolve;
-	#reject;
+	_resolve;
+	_reject;
 	constructor() {
 		this.status = { type: "pending" };
 		this.promise = new Promise((resolve, reject) => {
-			this.#resolve = resolve;
-			this.#reject = reject;
+			this._resolve = resolve;
+			this._reject = reject;
 		});
 	}
 	get result() {
@@ -1415,7 +1415,7 @@ var DeferredTracked = class {
 			type: "fulfilled",
 			value
 		};
-		this.#resolve(value);
+		this._resolve(value);
 	}
 	reject(reason) {
 		if (this.status.type !== "pending") return;
@@ -1423,7 +1423,7 @@ var DeferredTracked = class {
 			type: "rejected",
 			reason
 		};
-		this.#reject(reason);
+		this._reject(reason);
 	}
 };
 //#endregion
@@ -1431,9 +1431,9 @@ var DeferredTracked = class {
 var AsyncQueue = class {
 	queue;
 	maxSize;
-	#consumerWaiters = new Deque();
-	#producerWaiters = new Deque();
-	#ended = false;
+	_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;
@@ -1452,13 +1452,13 @@ var AsyncQueue = class {
 		return this.maxSize !== void 0 ? this.maxSize - this.queue.length : Infinity;
 	}
 	get ended() {
-		return this.#ended;
+		return this._ended;
 	}
 	async enqueue(item) {
-		if (this.#ended) throw new Error("Cannot enqueue after .end() has been called");
+		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);
+			if (this._consumerWaiters.length > 0) {
+				this._consumerWaiters.popFront().resolve(item);
 				return;
 			}
 			if (!this.isFull) {
@@ -1466,28 +1466,28 @@ var AsyncQueue = class {
 				return;
 			}
 			let waiter = new Deferred();
-			this.#producerWaiters.pushBack(waiter);
+			this._producerWaiters.pushBack(waiter);
 			await waiter.promise;
-			if (this.#ended) throw new Error("Queue was ended while waiting to enqueue.");
+			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);
+		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();
+		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();
+		for (let waiter of this._producerWaiters) waiter.reject(err);
+		this._producerWaiters.clear();
 	}
 	peek() {
 		return this.queue.peekFront();
@@ -1495,18 +1495,18 @@ var AsyncQueue = class {
 	next() {
 		if (this.queue.length === 0) return void 0;
 		let item = this.queue.popFront();
-		this.#wakeProducerIfNeeded();
+		this._wakeProducerIfNeeded();
 		return item;
 	}
 	async nextOrWait() {
 		if (this.queue.length > 0) {
 			let item = this.queue.popFront();
-			this.#wakeProducerIfNeeded();
+			this._wakeProducerIfNeeded();
 			return item;
 		}
-		if (this.#ended) return;
+		if (this._ended) return;
 		let waiter = new Deferred();
-		this.#consumerWaiters.pushBack(waiter);
+		this._consumerWaiters.pushBack(waiter);
 		return waiter.promise;
 	}
 	[Symbol.asyncIterator]() {
@@ -1526,33 +1526,33 @@ var AsyncQueue = class {
 		};
 		return iterator;
 	}
-	#wakeProducerIfNeeded() {
-		if (this.#producerWaiters.length > 0 && !this.isFull) this.#producerWaiters.popFront().resolve();
+	_wakeProducerIfNeeded() {
+		if (this._producerWaiters.length > 0 && !this.isFull) this._producerWaiters.popFront().resolve();
 	}
 };
 //#endregion
 //#region src/async/emitter.ts
 var Emitter = class {
-	#listeners = [];
-	#emit = noop;
+	_listeners = [];
+	_emit = noop;
 	get length() {
-		return this.#listeners.length;
+		return this._listeners.length;
 	}
 	add(listener) {
-		this.#listeners.push(listener);
-		this.#updateEmit();
+		this._listeners.push(listener);
+		this._updateEmit();
 	}
 	forwardTo(emitter) {
 		this.add(emitter.emit.bind(emitter));
 	}
 	remove(listener) {
-		let idx = this.#listeners.indexOf(listener);
+		let idx = this._listeners.indexOf(listener);
 		if (idx === -1) return;
-		this.#listeners.splice(idx, 1);
-		this.#updateEmit();
+		this._listeners.splice(idx, 1);
+		this._updateEmit();
 	}
 	emit(value) {
-		this.#emit(value);
+		this._emit(value);
 	}
 	once(listener) {
 		const once = (value) => {
@@ -1562,14 +1562,14 @@ var Emitter = class {
 		this.add(once);
 	}
 	listeners() {
-		return this.#listeners;
+		return this._listeners;
 	}
 	clear() {
-		this.#listeners.length = 0;
-		this.#emit = noop;
+		this._listeners.length = 0;
+		this._emit = noop;
 	}
-	#emitFew = (value) => {
-		let listeners = this.#listeners.slice();
+	_emitFew = (value) => {
+		let listeners = this._listeners.slice();
 		let len = listeners.length;
 		listeners[0](value);
 		len > 1 && listeners[1](value);
@@ -1577,29 +1577,29 @@ var Emitter = class {
 		len > 3 && listeners[3](value);
 		len > 4 && listeners[4](value);
 	};
-	#emitAll = (value) => {
-		let listeners = this.#listeners.slice();
+	_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;
+	_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;
+	_abort;
+	_ctx;
+	_updating;
+	_timeout;
+	_destroyed = false;
 	constructor(options) {
 		this.options = options;
-		this.#ctx = {
+		this._ctx = {
 			current: null,
 			currentFetchedAt: 0,
 			currentExpiresAt: 0,
@@ -1608,102 +1608,102 @@ var AsyncResource = class {
 		};
 	}
 	get isStale() {
-		return this.#ctx.current === null || this.#ctx.currentExpiresAt <= performance.now();
+		return this._ctx.current === null || this._ctx.currentExpiresAt <= performance.now();
 	}
 	setData(data, expiresIn) {
-		if (this.#destroyed) return;
+		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);
+		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._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;
+		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();
+		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);
+			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;
+				this._updating?.resolve();
+				this._updating = void 0;
+				this._ctx.abort = null;
 				return;
 			}
-			if (this.options.onError) this.options.onError(err, this.#ctx);
+			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;
+			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);
+		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) {
+		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;
+			if (!validator || validator(this._ctx)) {
+				this._ctx.isBackground = true;
 				this.update(true).catch(noop);
-				return this.#ctx.current;
+				return this._ctx.current;
 			}
 		}
-		this.#ctx.isBackground = false;
+		this._ctx.isBackground = false;
 		await this.update();
-		return this.#ctx.current;
+		return this._ctx.current;
 	}
 	getCached() {
-		return this.#ctx.current;
+		return this._ctx.current;
 	}
 	destroy() {
-		if (this.#destroyed) return;
-		this.#destroyed = true;
-		this.#clearTimer();
-		this.#abort?.abort();
+		if (this._destroyed) return;
+		this._destroyed = true;
+		this._clearTimer();
+		this._abort?.abort();
 		this.onUpdated.clear();
-		this.#updating?.resolve();
-		this.#updating = void 0;
+		this._updating?.resolve();
+		this._updating = void 0;
 	}
-	#clearTimer() {
-		if (this.#timeout) {
-			clearTimeoutWrap(this.#timeout);
-			this.#timeout = void 0;
+	_clearTimer() {
+		if (this._timeout) {
+			clearTimeoutWrap(this._timeout);
+			this._timeout = void 0;
 		}
 	}
 };
 //#endregion
 //#region src/async/condition-variable.ts
 var ConditionVariable = class {
-	#resolvers = [];
+	_resolvers = [];
 	wait() {
 		return new Promise((resolve) => {
-			this.#resolvers.push(resolve);
+			this._resolvers.push(resolve);
 		});
 	}
 	notify() {
-		let resolvers = this.#resolvers;
-		this.#resolvers = [];
+		let resolvers = this._resolvers;
+		this._resolvers = [];
 		for (let resolve of resolvers) resolve();
 	}
 };
@@ -1816,4 +1816,1339 @@ function throwUnreachable() {
 	throw new Error("Unreachable");
 }
 //#endregion
-export { AggregateError, AsyncInterval, AsyncLock, AsyncQueue, AsyncResource, ConditionVariable, CustomMap, CustomSet, Deferred, DeferredTracked, Deque, Emitter, LruMap, LruSet, NotImplementedError, abs, asNonNull, assert, assertEndsWith, assertEndsWith as assertsEndsWith, assertHashKey, assertMatches, assertNotNull, assertStartsWith, asyncPool, base64_exports as base64, bitLength, clearUndefinedInPlace, composeMiddlewares, deepMerge, enumerate, euclideanGcd, fromBytes, hex_exports as hex, isBigInt, isBoolean, isFalsy, isFunction, isNotNull, isNotUndefined, isNumber, isObject, isString, isSymbol, isTruthy, max, max2, min, min2, modInv, modPowBinary, noop, objectEntries, objectKeys, parallelMap, sleep, splitOnce, throwNotImplemented, throwUnreachable, timers_exports as timers, toBytes, twoMultiplicity, typed_exports as typed, u8_exports as u8, unknownToError, unsafeCastType, utf8_exports as utf8 };
+//#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 };