brotli-lib 0.0.1

package/dist/index.js

@@ -0,0 +1,4556 @@
+//#region src/decode/streams.ts
+var BrotliInput = class {
+	constructor(buffer) {
+		this.buffer = buffer;
+		this.pos = 0;
+	}
+	read(buf, i, count) {
+		const available = this.buffer.length - this.pos;
+		if (count > available) count = available;
+		buf.set(this.buffer.subarray(this.pos, this.pos + count), i);
+		this.pos += count;
+		return count;
+	}
+};
+
+//#endregion
+//#region src/decode/bit-reader.ts
+const BROTLI_READ_SIZE = 4096;
+const BROTLI_BYTE_BUFFER_SIZE = BROTLI_READ_SIZE + 64;
+const BROTLI_SHORT_BUFFER_SIZE = BROTLI_BYTE_BUFFER_SIZE >> 1;
+const BROTLI_IBUF_MASK = 2 * BROTLI_READ_SIZE - 1;
+const kBitMask = new Uint32Array([
+	0,
+	1,
+	3,
+	7,
+	15,
+	31,
+	63,
+	127,
+	255,
+	511,
+	1023,
+	2047,
+	4095,
+	8191,
+	16383,
+	32767,
+	65535,
+	131071,
+	262143,
+	524287,
+	1048575,
+	2097151,
+	4194303,
+	8388607,
+	16777215
+]);
+var BrotliBitReader = class {
+	static {
+		this.READ_SIZE = BROTLI_READ_SIZE;
+	}
+	static {
+		this.IBUF_MASK = BROTLI_IBUF_MASK;
+	}
+	constructor(input) {
+		this.accumulator32_ = 0;
+		this.bit_offset_ = 0;
+		this.half_offset_ = 0;
+		this.tail_bytes_ = 0;
+		this.end_of_stream_reached_ = 0;
+		this.input_ = input;
+		this.byte_buffer_ = new Uint8Array(BROTLI_BYTE_BUFFER_SIZE);
+		this.short_buffer_ = new Int16Array(BROTLI_SHORT_BUFFER_SIZE);
+		this.reset();
+	}
+	reset() {
+		this.accumulator32_ = 0;
+		this.bit_offset_ = 32;
+		this.half_offset_ = 2048;
+		this.tail_bytes_ = 0;
+		this.end_of_stream_reached_ = 0;
+		this.prepare();
+		return this.bit_offset_ < 32;
+	}
+	readMoreInput() {
+		if (this.end_of_stream_reached_ !== 0) {
+			if (this.halfAvailable() >= -2) return;
+			throw new Error("Unexpected end of input");
+		}
+		const read_offset = this.half_offset_ << 1;
+		let bytes_in_buffer = BROTLI_READ_SIZE - read_offset;
+		this.byte_buffer_.copyWithin(0, read_offset, BROTLI_READ_SIZE);
+		this.half_offset_ = 0;
+		while (bytes_in_buffer < BROTLI_READ_SIZE) {
+			const space_left = BROTLI_READ_SIZE - bytes_in_buffer;
+			const len = this.input_.read(this.byte_buffer_, bytes_in_buffer, space_left);
+			if (len < 0) throw new Error("Unexpected end of input");
+			if (len <= 0) {
+				this.end_of_stream_reached_ = 1;
+				this.tail_bytes_ = bytes_in_buffer;
+				bytes_in_buffer += 1;
+				break;
+			}
+			bytes_in_buffer += len;
+		}
+		this.bytesToNibbles(bytes_in_buffer);
+	}
+	bytesToNibbles(bytes_in_buffer) {
+		const short_buffer = this.short_buffer_;
+		const byte_buffer = this.byte_buffer_;
+		const len = bytes_in_buffer + 1 >> 1;
+		for (let i = 0; i < len; ++i) short_buffer[i] = byte_buffer[i * 2] & 255 | (byte_buffer[i * 2 + 1] & 255) << 8;
+	}
+	readInput(buf, offset, length) {
+		return this.input_.read(buf, offset, length);
+	}
+	checkHealth(end_of_stream) {
+		if (this.end_of_stream_reached_ === 0) return;
+		const byte_offset = (this.half_offset_ << 1) + (this.bit_offset_ + 7 >> 3) - 4;
+		if (byte_offset > this.tail_bytes_) throw new Error("Unexpected end of input");
+		if (end_of_stream !== 0 && byte_offset !== this.tail_bytes_) throw new Error("Unexpected end of input");
+	}
+	prepare() {
+		if (this.half_offset_ > 2030) this.readMoreInput();
+		this.checkHealth(0);
+		this.accumulator32_ = this.short_buffer_[this.half_offset_++] << 16 | this.accumulator32_ >>> 16;
+		this.bit_offset_ -= 16;
+		this.accumulator32_ = this.short_buffer_[this.half_offset_++] << 16 | this.accumulator32_ >>> 16;
+		this.bit_offset_ -= 16;
+	}
+	reload16() {
+		if (this.half_offset_ > 2030) this.readMoreInput();
+		this.checkHealth(0);
+		this.accumulator32_ = this.short_buffer_[this.half_offset_++] << 16 | this.accumulator32_ >>> 16;
+		this.bit_offset_ -= 16;
+	}
+	readFewBits(n_bits) {
+		const val = this.accumulator32_ >>> this.bit_offset_ & kBitMask[n_bits];
+		this.bit_offset_ += n_bits;
+		return val;
+	}
+	readManyBits(n_bits) {
+		const low = this.readFewBits(16);
+		this.reload16();
+		return low | this.readFewBits(n_bits - 16) << 16;
+	}
+	peekBits(n_bits) {
+		if (this.bit_offset_ >= 16) this.reload16();
+		return this.accumulator32_ >>> this.bit_offset_ & kBitMask[n_bits];
+	}
+	skipBits(n_bits) {
+		this.bit_offset_ += n_bits;
+	}
+	alignToByte() {
+		const padding = 32 - this.bit_offset_ & 7;
+		if (padding === 0) return 0;
+		return this.readBits(padding);
+	}
+	copyRawBytes(dst, offset, length) {
+		let pos = offset;
+		let len = length;
+		if ((this.bit_offset_ & 7) !== 0) throw new Error("Invalid alignment for raw copy");
+		while (this.bit_offset_ !== 32 && len !== 0) {
+			dst[pos++] = this.accumulator32_ >>> this.bit_offset_;
+			this.bit_offset_ += 8;
+			len--;
+		}
+		if (len === 0) return;
+		const copy_nibbles = Math.min(this.halfAvailable(), len >> 1);
+		if (copy_nibbles > 0) {
+			const read_offset = this.half_offset_ << 1;
+			const delta = copy_nibbles << 1;
+			dst.set(this.byte_buffer_.subarray(read_offset, read_offset + delta), pos);
+			pos += delta;
+			len -= delta;
+			this.half_offset_ += copy_nibbles;
+		}
+		if (len === 0) return;
+		if (this.halfAvailable() > 0) {
+			if (this.bit_offset_ >= 16) {
+				this.accumulator32_ = this.short_buffer_[this.half_offset_++] << 16 | this.accumulator32_ >>> 16;
+				this.bit_offset_ -= 16;
+			}
+			while (len !== 0) {
+				dst[pos++] = this.accumulator32_ >>> this.bit_offset_;
+				this.bit_offset_ += 8;
+				len--;
+			}
+			this.checkHealth(0);
+			return;
+		}
+		while (len > 0) {
+			const chunk_len = this.readInput(dst, pos, len);
+			if (chunk_len <= 0) throw new Error("Unexpected end of input");
+			pos += chunk_len;
+			len -= chunk_len;
+		}
+	}
+	halfAvailable() {
+		let limit = 2048;
+		if (this.end_of_stream_reached_ !== 0) limit = this.tail_bytes_ + 1 >> 1;
+		return limit - this.half_offset_;
+	}
+	readBits(n_bits) {
+		if (this.bit_offset_ >= 16) this.reload16();
+		if (n_bits <= 16) return this.readFewBits(n_bits);
+		return this.readManyBits(n_bits);
+	}
+};
+
+//#endregion
+//#region src/decode/dictionary-bin.ts
+const compressedDictionary = "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";
+
+//#endregion
+//#region src/decode/dictionary.ts
+let _decoder = null;
+function setDecoder(decoder) {
+	_decoder = decoder;
+}
+const offsetsByLength = new Uint32Array([
+	0,
+	0,
+	0,
+	0,
+	0,
+	4096,
+	9216,
+	21504,
+	35840,
+	44032,
+	53248,
+	63488,
+	74752,
+	87040,
+	93696,
+	100864,
+	104704,
+	106752,
+	108928,
+	113536,
+	115968,
+	118528,
+	119872,
+	121280,
+	122016
+]);
+const sizeBitsByLength = new Uint8Array([
+	0,
+	0,
+	0,
+	0,
+	10,
+	10,
+	11,
+	11,
+	10,
+	10,
+	10,
+	10,
+	10,
+	9,
+	9,
+	8,
+	7,
+	7,
+	8,
+	7,
+	7,
+	6,
+	6,
+	5,
+	5
+]);
+
+//#endregion
+//#region src/decode/engine.ts
+const MAX_HUFFMAN_TABLE_SIZE = Int32Array.from([
+	256,
+	402,
+	436,
+	468,
+	500,
+	534,
+	566,
+	598,
+	630,
+	662,
+	694,
+	726,
+	758,
+	790,
+	822,
+	854,
+	886,
+	920,
+	952,
+	984,
+	1016,
+	1048,
+	1080
+]);
+const CODE_LENGTH_CODE_ORDER = Int32Array.from([
+	1,
+	2,
+	3,
+	4,
+	0,
+	5,
+	17,
+	6,
+	16,
+	7,
+	8,
+	9,
+	10,
+	11,
+	12,
+	13,
+	14,
+	15
+]);
+const DISTANCE_SHORT_CODE_INDEX_OFFSET = Int32Array.from([
+	0,
+	3,
+	2,
+	1,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3
+]);
+const DISTANCE_SHORT_CODE_VALUE_OFFSET = Int32Array.from([
+	0,
+	0,
+	0,
+	0,
+	-1,
+	1,
+	-2,
+	2,
+	-3,
+	3,
+	-1,
+	1,
+	-2,
+	2,
+	-3,
+	3
+]);
+const FIXED_TABLE = Int32Array.from([
+	131072,
+	131076,
+	131075,
+	196610,
+	131072,
+	131076,
+	131075,
+	262145,
+	131072,
+	131076,
+	131075,
+	196610,
+	131072,
+	131076,
+	131075,
+	262149
+]);
+const BLOCK_LENGTH_OFFSET = Int32Array.from([
+	1,
+	5,
+	9,
+	13,
+	17,
+	25,
+	33,
+	41,
+	49,
+	65,
+	81,
+	97,
+	113,
+	145,
+	177,
+	209,
+	241,
+	305,
+	369,
+	497,
+	753,
+	1265,
+	2289,
+	4337,
+	8433,
+	16625
+]);
+const BLOCK_LENGTH_N_BITS = Int32Array.from([
+	2,
+	2,
+	2,
+	2,
+	3,
+	3,
+	3,
+	3,
+	4,
+	4,
+	4,
+	4,
+	5,
+	5,
+	5,
+	5,
+	6,
+	6,
+	7,
+	8,
+	9,
+	10,
+	11,
+	12,
+	13,
+	24
+]);
+const INSERT_LENGTH_N_BITS = Int16Array.from([
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	1,
+	1,
+	2,
+	2,
+	3,
+	3,
+	4,
+	4,
+	5,
+	5,
+	6,
+	7,
+	8,
+	9,
+	10,
+	12,
+	14,
+	24
+]);
+const COPY_LENGTH_N_BITS = Int16Array.from([
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	1,
+	1,
+	2,
+	2,
+	3,
+	3,
+	4,
+	4,
+	5,
+	5,
+	6,
+	7,
+	8,
+	9,
+	10,
+	24
+]);
+const CMD_LOOKUP = new Int16Array(2816);
+unpackCommandLookupTable(CMD_LOOKUP);
+const IS_LITTLE_ENDIAN = new Uint16Array(new Uint8Array([1, 0]).buffer)[0] === 1;
+function log2floor(i) {
+	let result = -1;
+	let step = 16;
+	let v = i;
+	while (step > 0) {
+		let next = v >> step;
+		if (next !== 0) {
+			result += step;
+			v = next;
+		}
+		step = step >> 1;
+	}
+	return result + v;
+}
+function calculateDistanceAlphabetSize$1(npostfix, ndirect, maxndistbits) {
+	return 16 + ndirect + 2 * (maxndistbits << npostfix);
+}
+function calculateDistanceAlphabetLimit(s, maxDistance, npostfix, ndirect) {
+	if (maxDistance < ndirect + (2 << npostfix)) return makeError(s, -23);
+	const offset = (maxDistance - ndirect >> npostfix) + 4;
+	const ndistbits = log2floor(offset) - 1;
+	return ((ndistbits - 1 << 1 | offset >> ndistbits & 1) - 1 << npostfix) + (1 << npostfix) + ndirect + 16;
+}
+function unpackCommandLookupTable(cmdLookup) {
+	const insertLengthOffsets = new Int32Array(24);
+	const copyLengthOffsets = new Int32Array(24);
+	copyLengthOffsets[0] = 2;
+	for (let i = 0; i < 23; ++i) {
+		insertLengthOffsets[i + 1] = insertLengthOffsets[i] + (1 << INSERT_LENGTH_N_BITS[i]);
+		copyLengthOffsets[i + 1] = copyLengthOffsets[i] + (1 << COPY_LENGTH_N_BITS[i]);
+	}
+	for (let cmdCode = 0; cmdCode < 704; ++cmdCode) {
+		let rangeIdx = cmdCode >> 6;
+		let distanceContextOffset = -4;
+		if (rangeIdx >= 2) {
+			rangeIdx -= 2;
+			distanceContextOffset = 0;
+		}
+		const insertCode = (170064 >> rangeIdx * 2 & 3) << 3 | cmdCode >> 3 & 7;
+		const copyCode = (156228 >> rangeIdx * 2 & 3) << 3 | cmdCode & 7;
+		const copyLengthOffset = copyLengthOffsets[copyCode];
+		const distanceContext = distanceContextOffset + Math.min(copyLengthOffset, 5) - 2;
+		const index = cmdCode * 4;
+		cmdLookup[index] = INSERT_LENGTH_N_BITS[insertCode] | COPY_LENGTH_N_BITS[copyCode] << 8;
+		cmdLookup[index + 1] = insertLengthOffsets[insertCode];
+		cmdLookup[index + 2] = copyLengthOffsets[copyCode];
+		cmdLookup[index + 3] = distanceContext;
+	}
+}
+function decodeWindowBits$1(s) {
+	const largeWindowEnabled = s.isLargeWindow;
+	s.isLargeWindow = 0;
+	if (s.bitOffset >= 16) {
+		s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
+		s.bitOffset -= 16;
+	}
+	if (readFewBits(s, 1) === 0) return 16;
+	let n = readFewBits(s, 3);
+	if (n !== 0) return 17 + n;
+	n = readFewBits(s, 3);
+	if (n !== 0) {
+		if (n === 1) {
+			if (largeWindowEnabled === 0) return -1;
+			s.isLargeWindow = 1;
+			if (readFewBits(s, 1) === 1) return -1;
+			n = readFewBits(s, 6);
+			if (n < 10 || n > 30) return -1;
+			return n;
+		}
+		return 8 + n;
+	}
+	return 17;
+}
+function attachDictionaryChunk(s, data) {
+	if (s.runningState !== 1) return makeError(s, -24);
+	if (s.cdNumChunks === 0) {
+		s.cdChunks = new Array(16);
+		s.cdChunkOffsets = new Int32Array(16);
+		s.cdBlockBits = -1;
+	}
+	if (s.cdNumChunks === 15) return makeError(s, -27);
+	s.cdChunks[s.cdNumChunks] = data;
+	s.cdNumChunks++;
+	s.cdTotalSize += data.length;
+	s.cdChunkOffsets[s.cdNumChunks] = s.cdTotalSize;
+	return 0;
+}
+function initState(s) {
+	if (s.runningState !== 0) return makeError(s, -26);
+	s.blockTrees = new Int32Array(3091);
+	s.blockTrees[0] = 7;
+	s.distRbIdx = 3;
+	let result = calculateDistanceAlphabetLimit(s, 2147483644, 3, 120);
+	if (result < 0) return result;
+	const maxDistanceAlphabetLimit = result;
+	s.distExtraBits = new Int8Array(maxDistanceAlphabetLimit);
+	s.distOffset = new Int32Array(maxDistanceAlphabetLimit);
+	result = initBitReader(s);
+	if (result < 0) return result;
+	s.runningState = 1;
+	return 0;
+}
+function close(s) {
+	if (s.runningState === 0) return makeError(s, -25);
+	if (s.runningState > 0) s.runningState = 11;
+	return 0;
+}
+function decodeVarLenUnsignedByte(s) {
+	if (s.bitOffset >= 16) {
+		s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
+		s.bitOffset -= 16;
+	}
+	if (readFewBits(s, 1) !== 0) {
+		const n = readFewBits(s, 3);
+		if (n === 0) return 1;
+		return readFewBits(s, n) + (1 << n);
+	}
+	return 0;
+}
+function decodeMetaBlockLength$1(s) {
+	if (s.bitOffset >= 16) {
+		s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
+		s.bitOffset -= 16;
+	}
+	s.inputEnd = readFewBits(s, 1);
+	s.metaBlockLength = 0;
+	s.isUncompressed = 0;
+	s.isMetadata = 0;
+	if (s.inputEnd !== 0 && readFewBits(s, 1) !== 0) return 0;
+	const sizeNibbles = readFewBits(s, 2) + 4;
+	if (sizeNibbles === 7) {
+		s.isMetadata = 1;
+		if (readFewBits(s, 1) !== 0) return makeError(s, -6);
+		const sizeBytes = readFewBits(s, 2);
+		if (sizeBytes === 0) return 0;
+		for (let i = 0; i < sizeBytes; ++i) {
+			if (s.bitOffset >= 16) {
+				s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
+				s.bitOffset -= 16;
+			}
+			const bits = readFewBits(s, 8);
+			if (bits === 0 && i + 1 === sizeBytes && sizeBytes > 1) return makeError(s, -8);
+			s.metaBlockLength += bits << i * 8;
+		}
+	} else for (let i = 0; i < sizeNibbles; ++i) {
+		if (s.bitOffset >= 16) {
+			s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
+			s.bitOffset -= 16;
+		}
+		const bits = readFewBits(s, 4);
+		if (bits === 0 && i + 1 === sizeNibbles && sizeNibbles > 4) return makeError(s, -8);
+		s.metaBlockLength += bits << i * 4;
+	}
+	s.metaBlockLength++;
+	if (s.inputEnd === 0) s.isUncompressed = readFewBits(s, 1);
+	return 0;
+}
+function readSymbol(tableGroup, tableIdx, s) {
+	let offset = tableGroup[tableIdx];
+	const v = s.accumulator32 >>> s.bitOffset;
+	offset += v & 255;
+	const e0 = tableGroup[offset];
+	const bits = e0 >> 16;
+	const sym = e0 & 65535;
+	if (bits <= 8) {
+		s.bitOffset += bits;
+		return sym;
+	}
+	offset += sym;
+	const mask = (1 << bits) - 1;
+	offset += (v & mask) >>> 8;
+	const e1 = tableGroup[offset];
+	s.bitOffset += (e1 >> 16) + 8;
+	return e1 & 65535;
+}
+function readBlockLength(tableGroup, tableIdx, s) {
+	if (s.bitOffset >= 16) {
+		s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
+		s.bitOffset -= 16;
+	}
+	const code = readSymbol(tableGroup, tableIdx, s);
+	const n = BLOCK_LENGTH_N_BITS[code];
+	if (s.bitOffset >= 16) {
+		s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
+		s.bitOffset -= 16;
+	}
+	return BLOCK_LENGTH_OFFSET[code] + (n <= 16 ? readFewBits(s, n) : readManyBits(s, n));
+}
+function moveToFront(v, index) {
+	let i = index;
+	const value = v[i];
+	while (i > 0) {
+		v[i] = v[i - 1];
+		i--;
+	}
+	v[0] = value;
+}
+function inverseMoveToFrontTransform(v, vLen) {
+	const mtf = new Int32Array(256);
+	for (let i = 0; i < 256; ++i) mtf[i] = i;
+	for (let i = 0; i < vLen; ++i) {
+		const index = v[i] & 255;
+		v[i] = mtf[index];
+		if (index !== 0) moveToFront(mtf, index);
+	}
+}
+function readHuffmanCodeLengths(codeLengthCodeLengths, numSymbols, codeLengths, s) {
+	let symbol = 0;
+	let prevCodeLen = 8;
+	let repeat = 0;
+	let repeatCodeLen = 0;
+	let space = 32768;
+	const table = new Int32Array(33);
+	buildHuffmanTable(table, table.length - 1, 5, codeLengthCodeLengths, 18);
+	while (symbol < numSymbols && space > 0) {
+		if (s.halfOffset > 2030) {
+			const result = readMoreInput(s);
+			if (result < 0) return result;
+		}
+		if (s.bitOffset >= 16) {
+			s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
+			s.bitOffset -= 16;
+		}
+		const p = s.accumulator32 >>> s.bitOffset & 31;
+		s.bitOffset += table[p] >> 16;
+		const codeLen = table[p] & 65535;
+		if (codeLen < 16) {
+			repeat = 0;
+			codeLengths[symbol++] = codeLen;
+			if (codeLen !== 0) {
+				prevCodeLen = codeLen;
+				space -= 32768 >> codeLen;
+			}
+		} else {
+			const extraBits = codeLen - 14;
+			let newLen = 0;
+			if (codeLen === 16) newLen = prevCodeLen;
+			if (repeatCodeLen !== newLen) {
+				repeat = 0;
+				repeatCodeLen = newLen;
+			}
+			const oldRepeat = repeat;
+			if (repeat > 0) {
+				repeat -= 2;
+				repeat = repeat << extraBits;
+			}
+			if (s.bitOffset >= 16) {
+				s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
+				s.bitOffset -= 16;
+			}
+			repeat += readFewBits(s, extraBits) + 3;
+			const repeatDelta = repeat - oldRepeat;
+			if (symbol + repeatDelta > numSymbols) return makeError(s, -2);
+			for (let i = 0; i < repeatDelta; ++i) codeLengths[symbol++] = repeatCodeLen;
+			if (repeatCodeLen !== 0) space -= repeatDelta << 15 - repeatCodeLen;
+		}
+	}
+	if (space !== 0) return makeError(s, -18);
+	codeLengths.fill(0, symbol, numSymbols);
+	return 0;
+}
+function checkDupes(s, symbols, length) {
+	for (let i = 0; i < length - 1; ++i) for (let j = i + 1; j < length; ++j) if (symbols[i] === symbols[j]) return makeError(s, -7);
+	return 0;
+}
+function readSimpleHuffmanCode(alphabetSizeMax, alphabetSizeLimit, tableGroup, tableIdx, s) {
+	const codeLengths = new Int32Array(alphabetSizeLimit);
+	const symbols = new Int32Array(4);
+	const maxBits = 1 + log2floor(alphabetSizeMax - 1);
+	const numSymbols = readFewBits(s, 2) + 1;
+	for (let i = 0; i < numSymbols; ++i) {
+		if (s.bitOffset >= 16) {
+			s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
+			s.bitOffset -= 16;
+		}
+		const symbol = readFewBits(s, maxBits);
+		if (symbol >= alphabetSizeLimit) return makeError(s, -15);
+		symbols[i] = symbol;
+	}
+	const result = checkDupes(s, symbols, numSymbols);
+	if (result < 0) return result;
+	let histogramId = numSymbols;
+	if (numSymbols === 4) histogramId += readFewBits(s, 1);
+	switch (histogramId) {
+		case 1:
+			codeLengths[symbols[0]] = 1;
+			break;
+		case 2:
+			codeLengths[symbols[0]] = 1;
+			codeLengths[symbols[1]] = 1;
+			break;
+		case 3:
+			codeLengths[symbols[0]] = 1;
+			codeLengths[symbols[1]] = 2;
+			codeLengths[symbols[2]] = 2;
+			break;
+		case 4:
+			codeLengths[symbols[0]] = 2;
+			codeLengths[symbols[1]] = 2;
+			codeLengths[symbols[2]] = 2;
+			codeLengths[symbols[3]] = 2;
+			break;
+		case 5:
+			codeLengths[symbols[0]] = 1;
+			codeLengths[symbols[1]] = 2;
+			codeLengths[symbols[2]] = 3;
+			codeLengths[symbols[3]] = 3;
+			break;
+		default: break;
+	}
+	return buildHuffmanTable(tableGroup, tableIdx, 8, codeLengths, alphabetSizeLimit);
+}
+function readComplexHuffmanCode(alphabetSizeLimit, skip, tableGroup, tableIdx, s) {
+	const codeLengths = new Int32Array(alphabetSizeLimit);
+	const codeLengthCodeLengths = new Int32Array(18);
+	let space = 32;
+	let numCodes = 0;
+	for (let i = skip; i < 18; ++i) {
+		const codeLenIdx = CODE_LENGTH_CODE_ORDER[i];
+		if (s.bitOffset >= 16) {
+			s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
+			s.bitOffset -= 16;
+		}
+		const p = s.accumulator32 >>> s.bitOffset & 15;
+		s.bitOffset += FIXED_TABLE[p] >> 16;
+		const v = FIXED_TABLE[p] & 65535;
+		codeLengthCodeLengths[codeLenIdx] = v;
+		if (v !== 0) {
+			space -= 32 >> v;
+			numCodes++;
+			if (space <= 0) break;
+		}
+	}
+	if (space !== 0 && numCodes !== 1) return makeError(s, -4);
+	const result = readHuffmanCodeLengths(codeLengthCodeLengths, alphabetSizeLimit, codeLengths, s);
+	if (result < 0) return result;
+	return buildHuffmanTable(tableGroup, tableIdx, 8, codeLengths, alphabetSizeLimit);
+}
+function readHuffmanCode(alphabetSizeMax, alphabetSizeLimit, tableGroup, tableIdx, s) {
+	if (s.halfOffset > 2030) {
+		const result = readMoreInput(s);
+		if (result < 0) return result;
+	}
+	if (s.bitOffset >= 16) {
+		s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
+		s.bitOffset -= 16;
+	}
+	const simpleCodeOrSkip = readFewBits(s, 2);
+	if (simpleCodeOrSkip === 1) return readSimpleHuffmanCode(alphabetSizeMax, alphabetSizeLimit, tableGroup, tableIdx, s);
+	return readComplexHuffmanCode(alphabetSizeLimit, simpleCodeOrSkip, tableGroup, tableIdx, s);
+}
+function decodeContextMap(contextMapSize, contextMap, s) {
+	let result;
+	if (s.halfOffset > 2030) {
+		result = readMoreInput(s);
+		if (result < 0) return result;
+	}
+	const numTrees = decodeVarLenUnsignedByte(s) + 1;
+	if (numTrees === 1) {
+		contextMap.fill(0, 0, contextMapSize);
+		return numTrees;
+	}
+	if (s.bitOffset >= 16) {
+		s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
+		s.bitOffset -= 16;
+	}
+	const useRleForZeros = readFewBits(s, 1);
+	let maxRunLengthPrefix = 0;
+	if (useRleForZeros !== 0) maxRunLengthPrefix = readFewBits(s, 4) + 1;
+	const alphabetSize = numTrees + maxRunLengthPrefix;
+	const tableSize = MAX_HUFFMAN_TABLE_SIZE[alphabetSize + 31 >> 5];
+	const table = new Int32Array(tableSize + 1);
+	const tableIdx = table.length - 1;
+	result = readHuffmanCode(alphabetSize, alphabetSize, table, tableIdx, s);
+	if (result < 0) return result;
+	let i = 0;
+	while (i < contextMapSize) {
+		if (s.halfOffset > 2030) {
+			result = readMoreInput(s);
+			if (result < 0) return result;
+		}
+		if (s.bitOffset >= 16) {
+			s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
+			s.bitOffset -= 16;
+		}
+		const code = readSymbol(table, tableIdx, s);
+		if (code === 0) {
+			contextMap[i] = 0;
+			i++;
+		} else if (code <= maxRunLengthPrefix) {
+			if (s.bitOffset >= 16) {
+				s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
+				s.bitOffset -= 16;
+			}
+			let reps = (1 << code) + readFewBits(s, code);
+			while (reps !== 0) {
+				if (i >= contextMapSize) return makeError(s, -3);
+				contextMap[i] = 0;
+				i++;
+				reps--;
+			}
+		} else {
+			contextMap[i] = code - maxRunLengthPrefix;
+			i++;
+		}
+	}
+	if (s.bitOffset >= 16) {
+		s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
+		s.bitOffset -= 16;
+	}
+	if (readFewBits(s, 1) === 1) inverseMoveToFrontTransform(contextMap, contextMapSize);
+	return numTrees;
+}
+function decodeBlockTypeAndLength(s, treeType, numBlockTypes) {
+	const ringBuffers = s.rings;
+	const offset = 4 + treeType * 2;
+	if (s.bitOffset >= 16) {
+		s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
+		s.bitOffset -= 16;
+	}
+	let blockType = readSymbol(s.blockTrees, 2 * treeType, s);
+	const result = readBlockLength(s.blockTrees, 2 * treeType + 1, s);
+	if (blockType === 1) blockType = ringBuffers[offset + 1] + 1;
+	else if (blockType === 0) blockType = ringBuffers[offset];
+	else blockType -= 2;
+	if (blockType >= numBlockTypes) blockType -= numBlockTypes;
+	ringBuffers[offset] = ringBuffers[offset + 1];
+	ringBuffers[offset + 1] = blockType;
+	return result;
+}
+function decodeLiteralBlockSwitch(s) {
+	s.literalBlockLength = decodeBlockTypeAndLength(s, 0, s.numLiteralBlockTypes);
+	const literalBlockType = s.rings[5];
+	s.contextMapSlice = literalBlockType << 6;
+	s.literalTreeIdx = s.contextMap[s.contextMapSlice] & 255;
+	s.contextLookupOffset1 = s.contextModes[literalBlockType] << 9;
+	s.contextLookupOffset2 = s.contextLookupOffset1 + 256;
+}
+function decodeCommandBlockSwitch(s) {
+	s.commandBlockLength = decodeBlockTypeAndLength(s, 1, s.numCommandBlockTypes);
+	s.commandTreeIdx = s.rings[7];
+}
+function decodeDistanceBlockSwitch(s) {
+	s.distanceBlockLength = decodeBlockTypeAndLength(s, 2, s.numDistanceBlockTypes);
+	s.distContextMapSlice = s.rings[9] << 2;
+}
+function maybeReallocateRingBuffer(s) {
+	let newSize = s.maxRingBufferSize;
+	if (newSize > s.expectedTotalSize) {
+		const minimalNewSize = s.expectedTotalSize;
+		while (newSize >> 1 > minimalNewSize) newSize = newSize >> 1;
+		if (s.inputEnd === 0 && newSize < 16384 && s.maxRingBufferSize >= 16384) newSize = 16384;
+	}
+	if (newSize <= s.ringBufferSize) return;
+	const ringBufferSizeWithSlack = newSize + 37;
+	const newBuffer = new Uint8Array(ringBufferSizeWithSlack);
+	const oldBuffer = s.ringBuffer;
+	if (oldBuffer.length !== 0) newBuffer.set(oldBuffer.subarray(0, s.ringBufferSize), 0);
+	s.ringBuffer = newBuffer;
+	s.ringBufferSize = newSize;
+}
+function readNextMetablockHeader(s) {
+	if (s.inputEnd !== 0) {
+		s.nextRunningState = 10;
+		s.runningState = 12;
+		return 0;
+	}
+	s.literalTreeGroup = new Int32Array(0);
+	s.commandTreeGroup = new Int32Array(0);
+	s.distanceTreeGroup = new Int32Array(0);
+	let result;
+	if (s.halfOffset > 2030) {
+		result = readMoreInput(s);
+		if (result < 0) return result;
+	}
+	result = decodeMetaBlockLength$1(s);
+	if (result < 0) return result;
+	if (s.metaBlockLength === 0 && s.isMetadata === 0) return 0;
+	if (s.isUncompressed !== 0 || s.isMetadata !== 0) {
+		result = jumpToByteBoundary(s);
+		if (result < 0) return result;
+		if (s.isMetadata === 0) s.runningState = 6;
+		else s.runningState = 5;
+	} else s.runningState = 3;
+	if (s.isMetadata !== 0) return 0;
+	s.expectedTotalSize += s.metaBlockLength;
+	if (s.expectedTotalSize > 1 << 30) s.expectedTotalSize = 1 << 30;
+	if (s.ringBufferSize < s.maxRingBufferSize) maybeReallocateRingBuffer(s);
+	return 0;
+}
+function readMetablockPartition(s, treeType, numBlockTypes) {
+	let offset = s.blockTrees[2 * treeType];
+	if (numBlockTypes <= 1) {
+		s.blockTrees[2 * treeType + 1] = offset;
+		s.blockTrees[2 * treeType + 2] = offset;
+		return 1 << 28;
+	}
+	const blockTypeAlphabetSize = numBlockTypes + 2;
+	let result = readHuffmanCode(blockTypeAlphabetSize, blockTypeAlphabetSize, s.blockTrees, 2 * treeType, s);
+	if (result < 0) return result;
+	offset += result;
+	s.blockTrees[2 * treeType + 1] = offset;
+	const blockLengthAlphabetSize = 26;
+	result = readHuffmanCode(blockLengthAlphabetSize, blockLengthAlphabetSize, s.blockTrees, 2 * treeType + 1, s);
+	if (result < 0) return result;
+	offset += result;
+	s.blockTrees[2 * treeType + 2] = offset;
+	return readBlockLength(s.blockTrees, 2 * treeType + 1, s);
+}
+function calculateDistanceLut(s, alphabetSizeLimit) {
+	const distExtraBits = s.distExtraBits;
+	const distOffset = s.distOffset;
+	const npostfix = s.distancePostfixBits;
+	const ndirect = s.numDirectDistanceCodes;
+	const postfix = 1 << npostfix;
+	let bits = 1;
+	let half = 0;
+	let i = 16;
+	for (let j = 0; j < ndirect; ++j) {
+		distExtraBits[i] = 0;
+		distOffset[i] = j + 1;
+		++i;
+	}
+	while (i < alphabetSizeLimit) {
+		const base = ndirect + ((2 + half << bits) - 4 << npostfix) + 1;
+		for (let j = 0; j < postfix; ++j) {
+			distExtraBits[i] = bits;
+			distOffset[i] = base + j;
+			++i;
+		}
+		bits = bits + half;
+		half = half ^ 1;
+	}
+}
+function readMetablockHuffmanCodesAndContextMaps(s) {
+	s.numLiteralBlockTypes = decodeVarLenUnsignedByte(s) + 1;
+	let result = readMetablockPartition(s, 0, s.numLiteralBlockTypes);
+	if (result < 0) return result;
+	s.literalBlockLength = result;
+	s.numCommandBlockTypes = decodeVarLenUnsignedByte(s) + 1;
+	result = readMetablockPartition(s, 1, s.numCommandBlockTypes);
+	if (result < 0) return result;
+	s.commandBlockLength = result;
+	s.numDistanceBlockTypes = decodeVarLenUnsignedByte(s) + 1;
+	result = readMetablockPartition(s, 2, s.numDistanceBlockTypes);
+	if (result < 0) return result;
+	s.distanceBlockLength = result;
+	if (s.halfOffset > 2030) {
+		result = readMoreInput(s);
+		if (result < 0) return result;
+	}
+	if (s.bitOffset >= 16) {
+		s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
+		s.bitOffset -= 16;
+	}
+	s.distancePostfixBits = readFewBits(s, 2);
+	s.numDirectDistanceCodes = readFewBits(s, 4) << s.distancePostfixBits;
+	s.contextModes = new Int8Array(s.numLiteralBlockTypes);
+	let i = 0;
+	while (i < s.numLiteralBlockTypes) {
+		const limit = Math.min(i + 96, s.numLiteralBlockTypes);
+		while (i < limit) {
+			if (s.bitOffset >= 16) {
+				s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
+				s.bitOffset -= 16;
+			}
+			s.contextModes[i] = readFewBits(s, 2);
+			i++;
+		}
+		if (s.halfOffset > 2030) {
+			result = readMoreInput(s);
+			if (result < 0) return result;
+		}
+	}
+	const contextMapLength = s.numLiteralBlockTypes << 6;
+	s.contextMap = new Int8Array(contextMapLength);
+	result = decodeContextMap(contextMapLength, s.contextMap, s);
+	if (result < 0) return result;
+	const numLiteralTrees = result;
+	s.trivialLiteralContext = 1;
+	for (let j = 0; j < contextMapLength; ++j) if (s.contextMap[j] !== j >> 6) {
+		s.trivialLiteralContext = 0;
+		break;
+	}
+	s.distContextMap = new Int8Array(s.numDistanceBlockTypes << 2);
+	result = decodeContextMap(s.numDistanceBlockTypes << 2, s.distContextMap, s);
+	if (result < 0) return result;
+	const numDistTrees = result;
+	s.literalTreeGroup = new Int32Array(huffmanTreeGroupAllocSize(256, numLiteralTrees));
+	result = decodeHuffmanTreeGroup(256, 256, numLiteralTrees, s, s.literalTreeGroup);
+	if (result < 0) return result;
+	s.commandTreeGroup = new Int32Array(huffmanTreeGroupAllocSize(704, s.numCommandBlockTypes));
+	result = decodeHuffmanTreeGroup(704, 704, s.numCommandBlockTypes, s, s.commandTreeGroup);
+	if (result < 0) return result;
+	let distanceAlphabetSizeMax = calculateDistanceAlphabetSize$1(s.distancePostfixBits, s.numDirectDistanceCodes, 24);
+	let distanceAlphabetSizeLimit = distanceAlphabetSizeMax;
+	if (s.isLargeWindow === 1) {
+		distanceAlphabetSizeMax = calculateDistanceAlphabetSize$1(s.distancePostfixBits, s.numDirectDistanceCodes, 62);
+		result = calculateDistanceAlphabetLimit(s, 2147483644, s.distancePostfixBits, s.numDirectDistanceCodes);
+		if (result < 0) return result;
+		distanceAlphabetSizeLimit = result;
+	}
+	s.distanceTreeGroup = new Int32Array(huffmanTreeGroupAllocSize(distanceAlphabetSizeLimit, numDistTrees));
+	result = decodeHuffmanTreeGroup(distanceAlphabetSizeMax, distanceAlphabetSizeLimit, numDistTrees, s, s.distanceTreeGroup);
+	if (result < 0) return result;
+	calculateDistanceLut(s, distanceAlphabetSizeLimit);
+	s.contextMapSlice = 0;
+	s.distContextMapSlice = 0;
+	s.contextLookupOffset1 = s.contextModes[0] * 512;
+	s.contextLookupOffset2 = s.contextLookupOffset1 + 256;
+	s.literalTreeIdx = 0;
+	s.commandTreeIdx = 0;
+	s.rings[4] = 1;
+	s.rings[5] = 0;
+	s.rings[6] = 1;
+	s.rings[7] = 0;
+	s.rings[8] = 1;
+	s.rings[9] = 0;
+	return 0;
+}
+function copyUncompressedData(s) {
+	const ringBuffer = s.ringBuffer;
+	let result;
+	if (s.metaBlockLength <= 0) {
+		result = reload(s);
+		if (result < 0) return result;
+		s.runningState = 2;
+		return 0;
+	}
+	const chunkLength = Math.min(s.ringBufferSize - s.pos, s.metaBlockLength);
+	result = copyRawBytes(s, ringBuffer, s.pos, chunkLength);
+	if (result < 0) return result;
+	s.metaBlockLength -= chunkLength;
+	s.pos += chunkLength;
+	if (s.pos === s.ringBufferSize) {
+		s.nextRunningState = 6;
+		s.runningState = 12;
+		return 0;
+	}
+	result = reload(s);
+	if (result < 0) return result;
+	s.runningState = 2;
+	return 0;
+}
+function writeRingBuffer(s) {
+	const toWrite = Math.min(s.outputLength - s.outputUsed, s.ringBufferBytesReady - s.ringBufferBytesWritten);
+	if (toWrite !== 0) {
+		s.output.set(s.ringBuffer.subarray(s.ringBufferBytesWritten, s.ringBufferBytesWritten + toWrite), s.outputOffset + s.outputUsed);
+		s.outputUsed += toWrite;
+		s.ringBufferBytesWritten += toWrite;
+	}
+	if (s.outputUsed < s.outputLength) return 0;
+	return 2;
+}
+function huffmanTreeGroupAllocSize(alphabetSizeLimit, n) {
+	return n + n * MAX_HUFFMAN_TABLE_SIZE[alphabetSizeLimit + 31 >> 5];
+}
+function decodeHuffmanTreeGroup(alphabetSizeMax, alphabetSizeLimit, n, s, group) {
+	let next = n;
+	for (let i = 0; i < n; ++i) {
+		group[i] = next;
+		const result = readHuffmanCode(alphabetSizeMax, alphabetSizeLimit, group, i, s);
+		if (result < 0) return result;
+		next += result;
+	}
+	return 0;
+}
+function calculateFence(s) {
+	let result = s.ringBufferSize;
+	if (s.isEager !== 0) result = Math.min(result, s.ringBufferBytesWritten + s.outputLength - s.outputUsed);
+	return result;
+}
+function doUseDictionary(s, fence) {
+	if (s.distance > 2147483644) return makeError(s, -9);
+	const address = s.distance - s.maxDistance - 1 - s.cdTotalSize;
+	if (address < 0) {
+		const result = initializeCompoundDictionaryCopy(s, -address - 1, s.copyLength);
+		if (result < 0) return result;
+		s.runningState = 14;
+	} else {
+		ensureDictionary();
+		const dictionaryData = data;
+		const wordLength = s.copyLength;
+		if (wordLength > 31) return makeError(s, -9);
+		const shift = sizeBits[wordLength];
+		if (shift === 0) return makeError(s, -9);
+		let offset = offsets[wordLength];
+		const wordIdx = address & (1 << shift) - 1;
+		const transformIdx = address >> shift;
+		offset += wordIdx * wordLength;
+		const transforms = RFC_TRANSFORMS;
+		if (transformIdx >= transforms.numTransforms) return makeError(s, -9);
+		const len = transformDictionaryWord(s.ringBuffer, s.pos, dictionaryData, offset, wordLength, transforms, transformIdx);
+		s.pos += len;
+		s.metaBlockLength -= len;
+		if (s.pos >= fence) {
+			s.nextRunningState = 4;
+			s.runningState = 12;
+			return 0;
+		}
+		s.runningState = 4;
+	}
+	return 0;
+}
+function initializeCompoundDictionary(s) {
+	s.cdBlockMap = new Int8Array(256);
+	let blockBits = 8;
+	while (s.cdTotalSize - 1 >> blockBits !== 0) blockBits++;
+	blockBits -= 8;
+	s.cdBlockBits = blockBits;
+	let cursor = 0;
+	let index = 0;
+	while (cursor < s.cdTotalSize) {
+		while (s.cdChunkOffsets[index + 1] < cursor) index++;
+		s.cdBlockMap[cursor >> blockBits] = index;
+		cursor += 1 << blockBits;
+	}
+}
+function initializeCompoundDictionaryCopy(s, address, length) {
+	if (s.cdBlockBits === -1) initializeCompoundDictionary(s);
+	let index = s.cdBlockMap[address >> s.cdBlockBits];
+	while (address >= s.cdChunkOffsets[index + 1]) index++;
+	if (s.cdTotalSize > address + length) return makeError(s, -9);
+	s.distRbIdx = s.distRbIdx + 1 & 3;
+	s.rings[s.distRbIdx] = s.distance;
+	s.metaBlockLength -= length;
+	s.cdBrIndex = index;
+	s.cdBrOffset = address - s.cdChunkOffsets[index];
+	s.cdBrLength = length;
+	s.cdBrCopied = 0;
+	return 0;
+}
+function copyFromCompoundDictionary(s, fence) {
+	let pos = s.pos;
+	const origPos = pos;
+	while (s.cdBrLength !== s.cdBrCopied) {
+		const space = fence - pos;
+		const remChunkLength = s.cdChunkOffsets[s.cdBrIndex + 1] - s.cdChunkOffsets[s.cdBrIndex] - s.cdBrOffset;
+		let length = s.cdBrLength - s.cdBrCopied;
+		if (length > remChunkLength) length = remChunkLength;
+		if (length > space) length = space;
+		s.ringBuffer.set(s.cdChunks[s.cdBrIndex].subarray(s.cdBrOffset, s.cdBrOffset + length), pos);
+		pos += length;
+		s.cdBrOffset += length;
+		s.cdBrCopied += length;
+		if (length === remChunkLength) {
+			s.cdBrIndex++;
+			s.cdBrOffset = 0;
+		}
+		if (pos >= fence) break;
+	}
+	return pos - origPos;
+}
+function decompress(s) {
+	let result;
+	if (s.runningState === 0) return makeError(s, -25);
+	if (s.runningState < 0) return makeError(s, -28);
+	if (s.runningState === 11) return makeError(s, -22);
+	if (s.runningState === 1) {
+		const windowBits = decodeWindowBits$1(s);
+		if (windowBits === -1) return makeError(s, -11);
+		s.maxRingBufferSize = 1 << windowBits;
+		s.maxBackwardDistance = s.maxRingBufferSize - 16;
+		s.runningState = 2;
+	}
+	let fence = calculateFence(s);
+	let ringBufferMask = s.ringBufferSize - 1;
+	let ringBuffer = s.ringBuffer;
+	while (s.runningState !== 10) switch (s.runningState) {
+		case 2:
+			if (s.metaBlockLength < 0) return makeError(s, -10);
+			result = readNextMetablockHeader(s);
+			if (result < 0) return result;
+			fence = calculateFence(s);
+			ringBufferMask = s.ringBufferSize - 1;
+			ringBuffer = s.ringBuffer;
+			continue;
+		case 3:
+			result = readMetablockHuffmanCodesAndContextMaps(s);
+			if (result < 0) return result;
+			s.runningState = 4;
+			continue;
+		case 4:
+			if (s.metaBlockLength <= 0) {
+				s.runningState = 2;
+				continue;
+			}
+			if (s.halfOffset > 2030) {
+				result = readMoreInput(s);
+				if (result < 0) return result;
+			}
+			if (s.commandBlockLength === 0) decodeCommandBlockSwitch(s);
+			s.commandBlockLength--;
+			if (s.bitOffset >= 16) {
+				s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
+				s.bitOffset -= 16;
+			}
+			const cmdCode = readSymbol(s.commandTreeGroup, s.commandTreeIdx, s) << 2;
+			const insertAndCopyExtraBits = CMD_LOOKUP[cmdCode];
+			const insertLengthOffset = CMD_LOOKUP[cmdCode + 1];
+			const copyLengthOffset = CMD_LOOKUP[cmdCode + 2];
+			s.distanceCode = CMD_LOOKUP[cmdCode + 3];
+			if (s.bitOffset >= 16) {
+				s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
+				s.bitOffset -= 16;
+			}
+			const insertLengthExtraBits = insertAndCopyExtraBits & 255;
+			s.insertLength = insertLengthOffset + (insertLengthExtraBits <= 16 ? readFewBits(s, insertLengthExtraBits) : readManyBits(s, insertLengthExtraBits));
+			if (s.bitOffset >= 16) {
+				s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
+				s.bitOffset -= 16;
+			}
+			const copyLengthExtraBits = insertAndCopyExtraBits >> 8;
+			s.copyLength = copyLengthOffset + (copyLengthExtraBits <= 16 ? readFewBits(s, copyLengthExtraBits) : readManyBits(s, copyLengthExtraBits));
+			s.j = 0;
+			s.runningState = 7;
+			continue;
+		case 7:
+			if (s.trivialLiteralContext !== 0) while (s.j < s.insertLength) {
+				if (s.halfOffset > 2030) {
+					result = readMoreInput(s);
+					if (result < 0) return result;
+				}
+				if (s.literalBlockLength === 0) decodeLiteralBlockSwitch(s);
+				s.literalBlockLength--;
+				if (s.bitOffset >= 16) {
+					s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
+					s.bitOffset -= 16;
+				}
+				ringBuffer[s.pos] = readSymbol(s.literalTreeGroup, s.literalTreeIdx, s);
+				s.pos++;
+				s.j++;
+				if (s.pos >= fence) {
+					s.nextRunningState = 7;
+					s.runningState = 12;
+					break;
+				}
+			}
+			else {
+				let prevByte1 = ringBuffer[s.pos - 1 & ringBufferMask];
+				let prevByte2 = ringBuffer[s.pos - 2 & ringBufferMask];
+				while (s.j < s.insertLength) {
+					if (s.halfOffset > 2030) {
+						result = readMoreInput(s);
+						if (result < 0) return result;
+					}
+					if (s.literalBlockLength === 0) decodeLiteralBlockSwitch(s);
+					const literalContext = LOOKUP[s.contextLookupOffset1 + prevByte1] | LOOKUP[s.contextLookupOffset2 + prevByte2];
+					const literalTreeIdx = s.contextMap[s.contextMapSlice + literalContext] & 255;
+					s.literalBlockLength--;
+					prevByte2 = prevByte1;
+					if (s.bitOffset >= 16) {
+						s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
+						s.bitOffset -= 16;
+					}
+					prevByte1 = readSymbol(s.literalTreeGroup, literalTreeIdx, s);
+					ringBuffer[s.pos] = prevByte1;
+					s.pos++;
+					s.j++;
+					if (s.pos >= fence) {
+						s.nextRunningState = 7;
+						s.runningState = 12;
+						break;
+					}
+				}
+			}
+			if (s.runningState !== 7) continue;
+			s.metaBlockLength -= s.insertLength;
+			if (s.metaBlockLength <= 0) {
+				s.runningState = 4;
+				continue;
+			}
+			let distanceCode = s.distanceCode;
+			if (distanceCode < 0) s.distance = s.rings[s.distRbIdx];
+			else {
+				if (s.halfOffset > 2030) {
+					result = readMoreInput(s);
+					if (result < 0) return result;
+				}
+				if (s.distanceBlockLength === 0) decodeDistanceBlockSwitch(s);
+				s.distanceBlockLength--;
+				if (s.bitOffset >= 16) {
+					s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
+					s.bitOffset -= 16;
+				}
+				const distTreeIdx = s.distContextMap[s.distContextMapSlice + distanceCode] & 255;
+				distanceCode = readSymbol(s.distanceTreeGroup, distTreeIdx, s);
+				if (distanceCode < 16) {
+					const index = s.distRbIdx + DISTANCE_SHORT_CODE_INDEX_OFFSET[distanceCode] & 3;
+					s.distance = s.rings[index] + DISTANCE_SHORT_CODE_VALUE_OFFSET[distanceCode];
+					if (s.distance < 0) return makeError(s, -12);
+				} else {
+					const extraBits = s.distExtraBits[distanceCode];
+					let bits;
+					if (s.bitOffset + extraBits <= 32) bits = readFewBits(s, extraBits);
+					else {
+						if (s.bitOffset >= 16) {
+							s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
+							s.bitOffset -= 16;
+						}
+						bits = extraBits <= 16 ? readFewBits(s, extraBits) : readManyBits(s, extraBits);
+					}
+					s.distance = s.distOffset[distanceCode] + (bits << s.distancePostfixBits);
+				}
+			}
+			if (s.maxDistance !== s.maxBackwardDistance && s.pos < s.maxBackwardDistance) s.maxDistance = s.pos;
+			else s.maxDistance = s.maxBackwardDistance;
+			if (s.distance > s.maxDistance) {
+				s.runningState = 9;
+				continue;
+			}
+			if (distanceCode > 0) {
+				s.distRbIdx = s.distRbIdx + 1 & 3;
+				s.rings[s.distRbIdx] = s.distance;
+			}
+			if (s.copyLength > s.metaBlockLength) return makeError(s, -9);
+			s.j = 0;
+			s.runningState = 8;
+			continue;
+		case 8:
+			let src = s.pos - s.distance & ringBufferMask;
+			let dst = s.pos;
+			const copyLength = s.copyLength - s.j;
+			const srcEnd = src + copyLength;
+			const dstEnd = dst + copyLength;
+			if (srcEnd < ringBufferMask && dstEnd < ringBufferMask) {
+				if (s.distance === 4 && copyLength >= 8) {
+					ringBuffer[dst] = ringBuffer[src];
+					ringBuffer[dst + 1] = ringBuffer[src + 1];
+					ringBuffer[dst + 2] = ringBuffer[src + 2];
+					ringBuffer[dst + 3] = ringBuffer[src + 3];
+					let written = 4;
+					while (written < copyLength) {
+						const chunk = Math.min(written, copyLength - written);
+						ringBuffer.copyWithin(dst + written, dst, dst + chunk);
+						written += chunk;
+					}
+				} else if (copyLength < 12 || srcEnd > dst && dstEnd > src) {
+					const numQuads = copyLength + 3 >> 2;
+					for (let k = 0; k < numQuads; ++k) {
+						ringBuffer[dst++] = ringBuffer[src++];
+						ringBuffer[dst++] = ringBuffer[src++];
+						ringBuffer[dst++] = ringBuffer[src++];
+						ringBuffer[dst++] = ringBuffer[src++];
+					}
+				} else ringBuffer.copyWithin(dst, src, srcEnd);
+				s.j += copyLength;
+				s.metaBlockLength -= copyLength;
+				s.pos += copyLength;
+			} else while (s.j < s.copyLength) {
+				ringBuffer[s.pos] = ringBuffer[s.pos - s.distance & ringBufferMask];
+				s.metaBlockLength--;
+				s.pos++;
+				s.j++;
+				if (s.pos >= fence) {
+					s.nextRunningState = 8;
+					s.runningState = 12;
+					break;
+				}
+			}
+			if (s.runningState === 8) s.runningState = 4;
+			continue;
+		case 9:
+			result = doUseDictionary(s, fence);
+			if (result < 0) return result;
+			continue;
+		case 14:
+			s.pos += copyFromCompoundDictionary(s, fence);
+			if (s.pos >= fence) {
+				s.nextRunningState = 14;
+				s.runningState = 12;
+				return 2;
+			}
+			s.runningState = 4;
+			continue;
+		case 5:
+			while (s.metaBlockLength > 0) {
+				if (s.halfOffset > 2030) {
+					result = readMoreInput(s);
+					if (result < 0) return result;
+				}
+				if (s.bitOffset >= 16) {
+					s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
+					s.bitOffset -= 16;
+				}
+				readFewBits(s, 8);
+				s.metaBlockLength--;
+			}
+			s.runningState = 2;
+			continue;
+		case 6:
+			result = copyUncompressedData(s);
+			if (result < 0) return result;
+			continue;
+		case 12:
+			s.ringBufferBytesReady = Math.min(s.pos, s.ringBufferSize);
+			s.runningState = 13;
+			continue;
+		case 13:
+			result = writeRingBuffer(s);
+			if (result !== 0) return result;
+			if (s.pos >= s.maxBackwardDistance) s.maxDistance = s.maxBackwardDistance;
+			if (s.pos >= s.ringBufferSize) {
+				if (s.pos > s.ringBufferSize) ringBuffer.copyWithin(0, s.ringBufferSize, s.pos);
+				s.pos = s.pos & ringBufferMask;
+				s.ringBufferBytesWritten = 0;
+			}
+			s.runningState = s.nextRunningState;
+			continue;
+		default: return makeError(s, -28);
+	}
+	if (s.runningState !== 10) return makeError(s, -29);
+	if (s.metaBlockLength < 0) return makeError(s, -10);
+	result = jumpToByteBoundary(s);
+	if (result !== 0) return result;
+	result = checkHealth(s, 1);
+	if (result !== 0) return result;
+	return 1;
+}
+var Transforms = class {
+	constructor(numTransforms, prefixSuffixLen, prefixSuffixCount) {
+		this.numTransforms = 0;
+		this.triplets = new Int32Array(0);
+		this.prefixSuffixStorage = new Int8Array(0);
+		this.prefixSuffixHeads = new Int32Array(0);
+		this.params = new Int16Array(0);
+		this.numTransforms = numTransforms;
+		this.triplets = new Int32Array(numTransforms * 3);
+		this.params = new Int16Array(numTransforms);
+		this.prefixSuffixStorage = new Int8Array(prefixSuffixLen);
+		this.prefixSuffixHeads = new Int32Array(prefixSuffixCount + 1);
+	}
+};
+const RFC_TRANSFORMS = new Transforms(121, 167, 50);
+function unpackTransforms(prefixSuffix, prefixSuffixHeads, transforms, prefixSuffixSrc, transformsSrc) {
+	const prefixSuffixBytes = toUtf8Runes(prefixSuffixSrc);
+	const n = prefixSuffixBytes.length;
+	let index = 1;
+	let j = 0;
+	for (let i = 0; i < n; ++i) {
+		const c = prefixSuffixBytes[i];
+		if (c === 35) prefixSuffixHeads[index++] = j;
+		else prefixSuffix[j++] = c;
+	}
+	for (let i = 0; i < 363; ++i) transforms[i] = transformsSrc.charCodeAt(i) - 32;
+}
+unpackTransforms(RFC_TRANSFORMS.prefixSuffixStorage, RFC_TRANSFORMS.prefixSuffixHeads, RFC_TRANSFORMS.triplets, "# #s #, #e #.# the #.com/#Â\xA0# of # and # in # to #\"#\">#\n#]# for # a # that #. # with #'# from # by #. The # on # as # is #ing #\n	#:#ed #(# at #ly #=\"# of the #. This #,# not #er #al #='#ful #ive #less #est #ize #ous #", "     !! ! ,  *!  &!  \" !  ) *   * -  ! # !  #!*!  +  ,$ !  -  %  .  / #   0  1 .  \"   2  3!*   4%  ! # /   5  6  7  8 0  1 &   $   9 +   :  ;  < '  !=  >  ?! 4  @ 4  2  &   A *# (   B  C& ) %  ) !*# *-% A +! *.  D! %'  & E *6  F  G% ! *A *%  H! D  I!+!  J!+   K +- *4! A  L!*4  M  N +6  O!*% +.! K *G  P +%(  ! G *D +D  Q +# *K!*G!+D!+# +G +A +4!+% +K!+4!*D!+K!*K");
+function transformDictionaryWord(dst, dstOffset, src, srcOffset, wordLen, transforms, transformIndex) {
+	let offset = dstOffset;
+	const triplets = transforms.triplets;
+	const prefixSuffixStorage = transforms.prefixSuffixStorage;
+	const prefixSuffixHeads = transforms.prefixSuffixHeads;
+	const transformOffset = 3 * transformIndex;
+	const prefixIdx = triplets[transformOffset];
+	const transformType = triplets[transformOffset + 1];
+	const suffixIdx = triplets[transformOffset + 2];
+	let prefix = prefixSuffixHeads[prefixIdx];
+	const prefixEnd = prefixSuffixHeads[prefixIdx + 1];
+	let suffix = prefixSuffixHeads[suffixIdx];
+	const suffixEnd = prefixSuffixHeads[suffixIdx + 1];
+	let omitFirst = transformType - 11;
+	let omitLast = transformType;
+	if (omitFirst < 1 || omitFirst > 9) omitFirst = 0;
+	if (omitLast < 1 || omitLast > 9) omitLast = 0;
+	while (prefix !== prefixEnd) dst[offset++] = prefixSuffixStorage[prefix++];
+	let len = wordLen;
+	if (omitFirst > len) omitFirst = len;
+	let dictOffset = srcOffset + omitFirst;
+	len -= omitFirst;
+	len -= omitLast;
+	let i = len;
+	while (i > 0) {
+		dst[offset++] = src[dictOffset++];
+		i--;
+	}
+	if (transformType === 10 || transformType === 11) {
+		let uppercaseOffset = offset - len;
+		if (transformType === 10) len = 1;
+		while (len > 0) {
+			const c0 = dst[uppercaseOffset] & 255;
+			if (c0 < 192) {
+				if (c0 >= 97 && c0 <= 122) dst[uppercaseOffset] = dst[uppercaseOffset] ^ 32;
+				uppercaseOffset += 1;
+				len -= 1;
+			} else if (c0 < 224) {
+				dst[uppercaseOffset + 1] = dst[uppercaseOffset + 1] ^ 32;
+				uppercaseOffset += 2;
+				len -= 2;
+			} else {
+				dst[uppercaseOffset + 2] = dst[uppercaseOffset + 2] ^ 5;
+				uppercaseOffset += 3;
+				len -= 3;
+			}
+		}
+	} else if (transformType === 21 || transformType === 22) {
+		let shiftOffset = offset - len;
+		const param = transforms.params[transformIndex];
+		let scalar = (param & 32767) + (16777216 - (param & 32768));
+		while (len > 0) {
+			let step = 1;
+			const c0 = dst[shiftOffset] & 255;
+			if (c0 < 128) {
+				scalar += c0;
+				dst[shiftOffset] = scalar & 127;
+			} else if (c0 < 192) {} else if (c0 < 224) if (len >= 2) {
+				const c1 = dst[shiftOffset + 1];
+				scalar += c1 & 63 | (c0 & 31) << 6;
+				dst[shiftOffset] = 192 | scalar >> 6 & 31;
+				dst[shiftOffset + 1] = c1 & 192 | scalar & 63;
+				step = 2;
+			} else step = len;
+			else if (c0 < 240) if (len >= 3) {
+				const c1 = dst[shiftOffset + 1];
+				const c2 = dst[shiftOffset + 2];
+				scalar += c2 & 63 | (c1 & 63) << 6 | (c0 & 15) << 12;
+				dst[shiftOffset] = 224 | scalar >> 12 & 15;
+				dst[shiftOffset + 1] = c1 & 192 | scalar >> 6 & 63;
+				dst[shiftOffset + 2] = c2 & 192 | scalar & 63;
+				step = 3;
+			} else step = len;
+			else if (c0 < 248) if (len >= 4) {
+				const c1 = dst[shiftOffset + 1];
+				const c2 = dst[shiftOffset + 2];
+				const c3 = dst[shiftOffset + 3];
+				scalar += c3 & 63 | (c2 & 63) << 6 | (c1 & 63) << 12 | (c0 & 7) << 18;
+				dst[shiftOffset] = 240 | scalar >> 18 & 7;
+				dst[shiftOffset + 1] = c1 & 192 | scalar >> 12 & 63;
+				dst[shiftOffset + 2] = c2 & 192 | scalar >> 6 & 63;
+				dst[shiftOffset + 3] = c3 & 192 | scalar & 63;
+				step = 4;
+			} else step = len;
+			shiftOffset += step;
+			len -= step;
+			if (transformType === 21) len = 0;
+		}
+	}
+	while (suffix !== suffixEnd) dst[offset++] = prefixSuffixStorage[suffix++];
+	return offset - dstOffset;
+}
+function getNextKey(key, len) {
+	let step = 1 << len - 1;
+	while ((key & step) !== 0) step = step >> 1;
+	return (key & step - 1) + step;
+}
+function replicateValue(table, offset, step, end, item) {
+	let pos = end;
+	while (pos > 0) {
+		pos -= step;
+		table[offset + pos] = item;
+	}
+}
+function nextTableBitSize(count, len, rootBits) {
+	let bits = len;
+	let left = 1 << bits - rootBits;
+	while (bits < 15) {
+		left -= count[bits];
+		if (left <= 0) break;
+		bits++;
+		left = left << 1;
+	}
+	return bits - rootBits;
+}
+function buildHuffmanTable(tableGroup, tableIdx, rootBits, codeLengths, codeLengthsSize) {
+	const tableOffset = tableGroup[tableIdx];
+	const sorted = new Int32Array(codeLengthsSize);
+	const count = new Int32Array(16);
+	const offset = new Int32Array(16);
+	for (let sym = 0; sym < codeLengthsSize; ++sym) count[codeLengths[sym]]++;
+	offset[1] = 0;
+	for (let len = 1; len < 15; ++len) offset[len + 1] = offset[len] + count[len];
+	for (let sym = 0; sym < codeLengthsSize; ++sym) if (codeLengths[sym] !== 0) sorted[offset[codeLengths[sym]]++] = sym;
+	let tableBits = rootBits;
+	let tableSize = 1 << tableBits;
+	let totalSize = tableSize;
+	if (offset[15] === 1) {
+		for (let k = 0; k < totalSize; ++k) tableGroup[tableOffset + k] = sorted[0];
+		return totalSize;
+	}
+	let key = 0;
+	let symbol = 0;
+	let step = 1;
+	for (let len = 1; len <= rootBits; ++len) {
+		step = step << 1;
+		while (count[len] > 0) {
+			replicateValue(tableGroup, tableOffset + key, step, tableSize, len << 16 | sorted[symbol++]);
+			key = getNextKey(key, len);
+			count[len]--;
+		}
+	}
+	const mask = totalSize - 1;
+	let low = -1;
+	let currentOffset = tableOffset;
+	step = 1;
+	for (let len = rootBits + 1; len <= 15; ++len) {
+		step = step << 1;
+		while (count[len] > 0) {
+			if ((key & mask) !== low) {
+				currentOffset += tableSize;
+				tableBits = nextTableBitSize(count, len, rootBits);
+				tableSize = 1 << tableBits;
+				totalSize += tableSize;
+				low = key & mask;
+				tableGroup[tableOffset + low] = tableBits + rootBits << 16 | currentOffset - tableOffset - low;
+			}
+			replicateValue(tableGroup, currentOffset + (key >> rootBits), step, tableSize, len - rootBits << 16 | sorted[symbol++]);
+			key = getNextKey(key, len);
+			count[len]--;
+		}
+	}
+	return totalSize;
+}
+function readMoreInput(s) {
+	if (s.endOfStreamReached !== 0) {
+		if (halfAvailable(s) >= -2) return 0;
+		return makeError(s, -16);
+	}
+	const readOffset = s.halfOffset << 1;
+	let bytesInBuffer = 4096 - readOffset;
+	s.byteBuffer.copyWithin(0, readOffset, 4096);
+	s.halfOffset = 0;
+	while (bytesInBuffer < 4096) {
+		const spaceLeft = 4096 - bytesInBuffer;
+		const len = readInput(s, s.byteBuffer, bytesInBuffer, spaceLeft);
+		if (len < -1) return len;
+		if (len <= 0) {
+			s.endOfStreamReached = 1;
+			s.tailBytes = bytesInBuffer;
+			bytesInBuffer += 1;
+			break;
+		}
+		bytesInBuffer += len;
+	}
+	bytesToNibbles(s, bytesInBuffer);
+	return 0;
+}
+function checkHealth(s, endOfStream) {
+	if (s.endOfStreamReached === 0) return 0;
+	const byteOffset = (s.halfOffset << 1) + (s.bitOffset + 7 >> 3) - 4;
+	if (byteOffset > s.tailBytes) return makeError(s, -13);
+	if (endOfStream !== 0 && byteOffset !== s.tailBytes) return makeError(s, -17);
+	return 0;
+}
+function readFewBits(s, n) {
+	const v = s.accumulator32 >>> s.bitOffset & (1 << n) - 1;
+	s.bitOffset += n;
+	return v;
+}
+function readManyBits(s, n) {
+	const low = readFewBits(s, 16);
+	s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
+	s.bitOffset -= 16;
+	return low | readFewBits(s, n - 16) << 16;
+}
+function initBitReader(s) {
+	s.byteBuffer = new Int8Array(4160);
+	s.byteBuffer16 = new Uint16Array(s.byteBuffer.buffer, s.byteBuffer.byteOffset, 2080);
+	s.accumulator32 = 0;
+	s.shortBuffer = new Int16Array(2080);
+	s.bitOffset = 32;
+	s.halfOffset = 2048;
+	s.endOfStreamReached = 0;
+	return prepare(s);
+}
+function prepare(s) {
+	if (s.halfOffset > 2030) {
+		const result = readMoreInput(s);
+		if (result !== 0) return result;
+	}
+	let health = checkHealth(s, 0);
+	if (health !== 0) return health;
+	s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
+	s.bitOffset -= 16;
+	s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
+	s.bitOffset -= 16;
+	return 0;
+}
+function reload(s) {
+	if (s.bitOffset === 32) return prepare(s);
+	return 0;
+}
+function jumpToByteBoundary(s) {
+	const padding = 32 - s.bitOffset & 7;
+	if (padding !== 0) {
+		if (readFewBits(s, padding) !== 0) return makeError(s, -5);
+	}
+	return 0;
+}
+function halfAvailable(s) {
+	let limit = 2048;
+	if (s.endOfStreamReached !== 0) limit = s.tailBytes + 1 >> 1;
+	return limit - s.halfOffset;
+}
+function copyRawBytes(s, data, offset, length) {
+	let pos = offset;
+	let len = length;
+	if ((s.bitOffset & 7) !== 0) return makeError(s, -30);
+	while (s.bitOffset !== 32 && len !== 0) {
+		data[pos++] = s.accumulator32 >>> s.bitOffset;
+		s.bitOffset += 8;
+		len--;
+	}
+	if (len === 0) return 0;
+	const copyNibbles = Math.min(halfAvailable(s), len >> 1);
+	if (copyNibbles > 0) {
+		const readOffset = s.halfOffset << 1;
+		const delta = copyNibbles << 1;
+		data.set(s.byteBuffer.subarray(readOffset, readOffset + delta), pos);
+		pos += delta;
+		len -= delta;
+		s.halfOffset += copyNibbles;
+	}
+	if (len === 0) return 0;
+	if (halfAvailable(s) > 0) {
+		if (s.bitOffset >= 16) {
+			s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
+			s.bitOffset -= 16;
+		}
+		while (len !== 0) {
+			data[pos++] = s.accumulator32 >>> s.bitOffset;
+			s.bitOffset += 8;
+			len--;
+		}
+		return checkHealth(s, 0);
+	}
+	while (len > 0) {
+		const chunkLen = readInput(s, data, pos, len);
+		if (chunkLen < -1) return chunkLen;
+		if (chunkLen <= 0) return makeError(s, -16);
+		pos += chunkLen;
+		len -= chunkLen;
+	}
+	return 0;
+}
+function bytesToNibbles(s, byteLen) {
+	const halfLen = byteLen >> 1;
+	const shortBuffer = s.shortBuffer;
+	if (IS_LITTLE_ENDIAN) {
+		shortBuffer.set(s.byteBuffer16.subarray(0, halfLen));
+		return;
+	}
+	const byteBuffer = s.byteBuffer;
+	for (let i = 0; i < halfLen; ++i) shortBuffer[i] = byteBuffer[i * 2] & 255 | (byteBuffer[i * 2 + 1] & 255) << 8;
+}
+const LOOKUP = new Int32Array(2048);
+function unpackLookupTable(lookup, utfMap, utfRle) {
+	for (let i = 0; i < 256; ++i) {
+		lookup[i] = i & 63;
+		lookup[512 + i] = i >> 2;
+		lookup[1792 + i] = 2 + (i >> 6);
+	}
+	for (let i = 0; i < 128; ++i) lookup[1024 + i] = 4 * (utfMap.charCodeAt(i) - 32);
+	for (let i = 0; i < 64; ++i) {
+		lookup[1152 + i] = i & 1;
+		lookup[1216 + i] = 2 + (i & 1);
+	}
+	let offset = 1280;
+	for (let k = 0; k < 19; ++k) {
+		const value = k & 3;
+		const rep = utfRle.charCodeAt(k) - 32;
+		for (let i = 0; i < rep; ++i) lookup[offset++] = value;
+	}
+	for (let i = 0; i < 16; ++i) {
+		lookup[1792 + i] = 1;
+		lookup[2032 + i] = 6;
+	}
+	lookup[1792] = 0;
+	lookup[2047] = 7;
+	for (let i = 0; i < 256; ++i) lookup[1536 + i] = lookup[1792 + i] << 3;
+}
+unpackLookupTable(LOOKUP, "         !!  !                  \"#$##%#$&'##(#)#++++++++++((&*'##,---,---,-----,-----,-----&#'###.///.///./////./////./////&#'# ", "A/*  ':  & : $   @");
+var State = class {
+	constructor() {
+		this.ringBuffer = new Uint8Array(0);
+		this.contextModes = new Int8Array(0);
+		this.contextMap = new Int8Array(0);
+		this.distContextMap = new Int8Array(0);
+		this.distExtraBits = new Int8Array(0);
+		this.output = new Uint8Array(0);
+		this.byteBuffer = new Int8Array(0);
+		this.byteBuffer16 = new Uint16Array(0);
+		this.shortBuffer = new Int16Array(0);
+		this.intBuffer = new Int32Array(0);
+		this.rings = new Int32Array(0);
+		this.blockTrees = new Int32Array(0);
+		this.literalTreeGroup = new Int32Array(0);
+		this.commandTreeGroup = new Int32Array(0);
+		this.distanceTreeGroup = new Int32Array(0);
+		this.distOffset = new Int32Array(0);
+		this.accumulator64 = 0;
+		this.runningState = 0;
+		this.nextRunningState = 0;
+		this.accumulator32 = 0;
+		this.bitOffset = 0;
+		this.halfOffset = 0;
+		this.tailBytes = 0;
+		this.endOfStreamReached = 0;
+		this.metaBlockLength = 0;
+		this.inputEnd = 0;
+		this.isUncompressed = 0;
+		this.isMetadata = 0;
+		this.literalBlockLength = 0;
+		this.numLiteralBlockTypes = 0;
+		this.commandBlockLength = 0;
+		this.numCommandBlockTypes = 0;
+		this.distanceBlockLength = 0;
+		this.numDistanceBlockTypes = 0;
+		this.pos = 0;
+		this.maxDistance = 0;
+		this.distRbIdx = 0;
+		this.trivialLiteralContext = 0;
+		this.literalTreeIdx = 0;
+		this.commandTreeIdx = 0;
+		this.j = 0;
+		this.insertLength = 0;
+		this.contextMapSlice = 0;
+		this.distContextMapSlice = 0;
+		this.contextLookupOffset1 = 0;
+		this.contextLookupOffset2 = 0;
+		this.distanceCode = 0;
+		this.numDirectDistanceCodes = 0;
+		this.distancePostfixBits = 0;
+		this.distance = 0;
+		this.copyLength = 0;
+		this.maxBackwardDistance = 0;
+		this.maxRingBufferSize = 0;
+		this.ringBufferSize = 0;
+		this.expectedTotalSize = 0;
+		this.outputOffset = 0;
+		this.outputLength = 0;
+		this.outputUsed = 0;
+		this.ringBufferBytesWritten = 0;
+		this.ringBufferBytesReady = 0;
+		this.isEager = 0;
+		this.isLargeWindow = 0;
+		this.cdNumChunks = 0;
+		this.cdTotalSize = 0;
+		this.cdBrIndex = 0;
+		this.cdBrOffset = 0;
+		this.cdBrLength = 0;
+		this.cdBrCopied = 0;
+		this.cdChunks = new Array(0);
+		this.cdChunkOffsets = new Int32Array(0);
+		this.cdBlockBits = 0;
+		this.cdBlockMap = new Int8Array(0);
+		this.input = new InputStream(new Int8Array(0));
+		this.ringBuffer = new Uint8Array(0);
+		this.rings = new Int32Array(10);
+		this.rings[0] = 16;
+		this.rings[1] = 15;
+		this.rings[2] = 11;
+		this.rings[3] = 4;
+	}
+};
+let data = new Int8Array(0);
+const offsets = new Int32Array(32);
+const sizeBits = new Int32Array(32);
+let dictionaryInitialized = false;
+function ensureDictionary() {
+	if (dictionaryInitialized) return;
+	dictionaryInitialized = true;
+	const binary = atob(compressedDictionary);
+	const compressed = new Uint8Array(binary.length);
+	for (let i = 0; i < binary.length; i++) compressed[i] = binary.charCodeAt(i);
+	const dict = brotliDecode$1(compressed);
+	setData(new Int8Array(dict.buffer, dict.byteOffset, dict.byteLength), new Int32Array([
+		0,
+		0,
+		0,
+		0,
+		10,
+		10,
+		11,
+		11,
+		10,
+		10,
+		10,
+		10,
+		10,
+		9,
+		9,
+		8,
+		7,
+		7,
+		8,
+		7,
+		7,
+		6,
+		6,
+		5,
+		5
+	]));
+}
+function setData(newData, newSizeBits) {
+	const dictionaryOffsets = offsets;
+	const dictionarySizeBits = sizeBits;
+	for (let i = 0; i < newSizeBits.length; ++i) dictionarySizeBits[i] = newSizeBits[i];
+	let pos = 0;
+	for (let i = 0; i < newSizeBits.length; ++i) {
+		dictionaryOffsets[i] = pos;
+		const bits = dictionarySizeBits[i];
+		if (bits !== 0) pos += i << (bits & 31);
+	}
+	for (let i = newSizeBits.length; i < 32; ++i) dictionaryOffsets[i] = pos;
+	data = newData;
+}
+var InputStream = class {
+	constructor(data) {
+		this.data = new Uint8Array(0);
+		this.offset = 0;
+		this.data = data;
+	}
+};
+function readInput(s, dst, offset, length) {
+	if (s.input === null) return -1;
+	const src = s.input;
+	const end = Math.min(src.offset + length, src.data.length);
+	const bytesRead = end - src.offset;
+	dst.set(src.data.subarray(src.offset, end), offset);
+	src.offset += bytesRead;
+	return bytesRead;
+}
+function closeInput(s) {
+	s.input = new InputStream(new Int8Array(0));
+}
+function toUtf8Runes(src) {
+	const n = src.length;
+	const result = new Int32Array(n);
+	for (let i = 0; i < n; ++i) result[i] = src.charCodeAt(i);
+	return result;
+}
+function makeError(s, code) {
+	if (code >= 0) return code;
+	if (s.runningState >= 0) s.runningState = code;
+	throw new Error("Brotli error code: " + code);
+}
+/**
+* Decodes brotli stream.
+*/
+function brotliDecode$1(bytes, options) {
+	const s = new State();
+	s.input = new InputStream(bytes);
+	initState(s);
+	if (options) {
+		const customDictionary = options.customDictionary;
+		if (customDictionary) attachDictionaryChunk(s, customDictionary);
+	}
+	const outputSize = options?.outputSize;
+	if (outputSize !== void 0 && outputSize > 0) {
+		const result = new Uint8Array(outputSize);
+		s.output = result;
+		s.outputOffset = 0;
+		s.outputLength = outputSize;
+		s.outputUsed = 0;
+		decompress(s);
+		close(s);
+		closeInput(s);
+		return result;
+	}
+	let totalOutput = 0;
+	const chunks = [];
+	while (true) {
+		const chunk = new Uint8Array(16384);
+		chunks.push(chunk);
+		s.output = chunk;
+		s.outputOffset = 0;
+		s.outputLength = 16384;
+		s.outputUsed = 0;
+		decompress(s);
+		totalOutput += s.outputUsed;
+		if (s.outputUsed < 16384) break;
+	}
+	close(s);
+	closeInput(s);
+	const result = new Uint8Array(totalOutput);
+	let offset = 0;
+	for (let i = 0; i < chunks.length; ++i) {
+		const chunk = chunks[i];
+		const len = Math.min(totalOutput, offset + 16384) - offset;
+		if (len < 16384) result.set(chunk.subarray(0, len), offset);
+		else result.set(chunk, offset);
+		offset += len;
+	}
+	return result;
+}
+
+//#endregion
+//#region src/decode/decode.ts
+function decodeWindowBits(br) {
+	if (br.readBits(1) === 0) return 16;
+	let n = br.readBits(3);
+	if (n > 0) return 17 + n;
+	n = br.readBits(3);
+	if (n > 0) return 8 + n;
+	return 17;
+}
+function decodeMetaBlockLength(br) {
+	const out = {
+		meta_block_length: 0,
+		input_end: 0,
+		is_uncompressed: 0,
+		is_metadata: false
+	};
+	out.input_end = br.readBits(1);
+	if (out.input_end && br.readBits(1)) return out;
+	const size_nibbles = br.readBits(2) + 4;
+	if (size_nibbles === 7) {
+		out.is_metadata = true;
+		if (br.readBits(1) !== 0) throw new Error("Invalid reserved bit");
+		const size_bytes = br.readBits(2);
+		if (size_bytes === 0) return out;
+		for (let i = 0; i < size_bytes; i++) {
+			const next_byte = br.readBits(8);
+			if (i + 1 === size_bytes && size_bytes > 1 && next_byte === 0) throw new Error("Invalid size byte");
+			out.meta_block_length |= next_byte << i * 8;
+		}
+	} else for (let i = 0; i < size_nibbles; ++i) {
+		const next_nibble = br.readBits(4);
+		if (i + 1 === size_nibbles && size_nibbles > 4 && next_nibble === 0) throw new Error("Invalid size nibble");
+		out.meta_block_length |= next_nibble << i * 4;
+	}
+	++out.meta_block_length;
+	if (!out.input_end && !out.is_metadata) out.is_uncompressed = br.readBits(1);
+	return out;
+}
+function brotliDecodedSize(buffer) {
+	const br = new BrotliBitReader(new BrotliInput(buffer));
+	decodeWindowBits(br);
+	const out = decodeMetaBlockLength(br);
+	if (out.input_end) return out.meta_block_length;
+	return -1;
+}
+function brotliDecode(buffer, options) {
+	let output_size;
+	let maxOutputSize;
+	let customDictionary;
+	if (typeof options === "number") output_size = options;
+	else {
+		maxOutputSize = options?.maxOutputSize;
+		const dict = options?.customDictionary;
+		if (dict) customDictionary = dict instanceof Uint8Array ? dict : new Uint8Array(dict.buffer, dict.byteOffset, dict.byteLength);
+	}
+	if (output_size === void 0) {
+		const estimatedSize = brotliDecodedSize(buffer);
+		if (estimatedSize > 0) output_size = estimatedSize;
+	}
+	if (maxOutputSize !== void 0 && output_size !== void 0 && output_size > maxOutputSize) throw new Error(`Decompressed size ${output_size} exceeds limit ${maxOutputSize}`);
+	const decoded = brotliDecode$1(buffer, {
+		customDictionary,
+		outputSize: output_size
+	});
+	if (maxOutputSize !== void 0 && decoded.length > maxOutputSize) throw new Error(`Decompressed size ${decoded.length} exceeds limit ${maxOutputSize}`);
+	return decoded;
+}
+setDecoder(brotliDecode);
+
+//#endregion
+//#region src/encode/bit-writer.ts
+var BitWriter = class {
+	constructor(initialSize = 4096) {
+		this.buffer = new Uint8Array(initialSize);
+		this.pos = 0;
+		this.flushedBytePos = 0;
+	}
+	ensureCapacity(bits) {
+		const bytesNeeded = (this.pos + bits + 7 >>> 3) + 1;
+		if (bytesNeeded > this.buffer.length) {
+			const newSize = Math.max(this.buffer.length * 2, bytesNeeded);
+			const newBuffer = new Uint8Array(newSize);
+			newBuffer.set(this.buffer);
+			this.buffer = newBuffer;
+		}
+	}
+	writeBits(nBits, value) {
+		this.ensureCapacity(nBits);
+		const bytePos = this.pos >>> 3;
+		const bitOffset = this.pos & 7;
+		let v = this.buffer[bytePos] | 0;
+		v |= value << bitOffset;
+		this.buffer[bytePos] = v & 255;
+		let bitsWritten = 8 - bitOffset;
+		let remaining = value >>> bitsWritten;
+		let pos = bytePos + 1;
+		while (bitsWritten < nBits) {
+			this.buffer[pos++] = remaining & 255;
+			remaining >>>= 8;
+			bitsWritten += 8;
+		}
+		this.pos += nBits;
+	}
+	writeBitsLong(nBits, value) {
+		if (nBits <= 25) {
+			this.writeBits(nBits, Number(value));
+			return;
+		}
+		this.ensureCapacity(nBits);
+		const bytePos = this.pos >>> 3;
+		const bitOffset = this.pos & 7;
+		let v = value << BigInt(bitOffset);
+		const bytesToWrite = nBits + bitOffset + 7 >>> 3;
+		this.buffer[bytePos] |= Number(v & 255n);
+		v >>= 8n;
+		for (let i = 1; i < bytesToWrite; i++) {
+			this.buffer[bytePos + i] = Number(v & 255n);
+			v >>= 8n;
+		}
+		this.pos += nBits;
+	}
+	writeBit(bit) {
+		this.writeBits(1, bit & 1);
+	}
+	writeByte(byte) {
+		if ((this.pos & 7) !== 0) throw new Error("BitWriter not byte-aligned");
+		this.ensureCapacity(8);
+		this.buffer[this.pos >>> 3] = byte & 255;
+		this.pos += 8;
+	}
+	writeBytes(bytes) {
+		if ((this.pos & 7) !== 0) throw new Error("BitWriter not byte-aligned");
+		this.ensureCapacity(bytes.length * 8);
+		this.buffer.set(bytes, this.pos >>> 3);
+		this.pos += bytes.length * 8;
+	}
+	alignToByte() {
+		const padding = 8 - (this.pos & 7) & 7;
+		if (padding > 0) this.writeBits(padding, 0);
+		return padding;
+	}
+	get bytePos() {
+		return this.pos >>> 3;
+	}
+	get bitOffset() {
+		return this.pos & 7;
+	}
+	reset() {
+		this.pos = 0;
+		this.flushedBytePos = 0;
+		this.buffer.fill(0);
+	}
+	takeBytes() {
+		const end = this.pos >>> 3;
+		if (end <= this.flushedBytePos) return new Uint8Array(0);
+		const out = this.buffer.slice(this.flushedBytePos, end);
+		this.flushedBytePos = end;
+		return out;
+	}
+	finish() {
+		const byteLength = this.pos + 7 >>> 3;
+		return this.buffer.slice(0, byteLength);
+	}
+	prepareStorage() {
+		if ((this.pos & 7) !== 0) throw new Error("prepareStorage requires byte alignment");
+		this.ensureCapacity(8);
+		this.buffer[this.pos >>> 3] = 0;
+	}
+};
+function encodeWindowBits(lgwin, largeWindow) {
+	if (largeWindow) return {
+		value: (lgwin & 63) << 8 | 17,
+		bits: 14
+	};
+	if (lgwin === 16) return {
+		value: 0,
+		bits: 1
+	};
+	else if (lgwin === 17) return {
+		value: 1,
+		bits: 7
+	};
+	else if (lgwin > 17 && lgwin <= 24) return {
+		value: lgwin - 17 << 1 | 1,
+		bits: 4
+	};
+	else return {
+		value: lgwin - 8 << 4 | 1,
+		bits: 7
+	};
+}
+
+//#endregion
+//#region src/encode/enc-constants.ts
+const FAST_ONE_PASS_COMPRESSION_QUALITY = 0;
+const FAST_TWO_PASS_COMPRESSION_QUALITY = 1;
+const ZOPFLIFICATION_QUALITY = 10;
+const HQ_ZOPFLIFICATION_QUALITY = 11;
+const MIN_QUALITY = 0;
+const MAX_QUALITY = 11;
+const DEFAULT_QUALITY = 11;
+const MAX_QUALITY_FOR_STATIC_ENTROPY_CODES = 2;
+const MIN_QUALITY_FOR_BLOCK_SPLIT = 4;
+const MIN_WINDOW_BITS = 10;
+const MAX_WINDOW_BITS = 24;
+const LARGE_MAX_WINDOW_BITS = 30;
+const DEFAULT_WINDOW_BITS = 22;
+const MIN_INPUT_BLOCK_BITS = 16;
+const MAX_INPUT_BLOCK_BITS = 24;
+const MAX_ZOPFLI_LEN_QUALITY_10 = 150;
+const MAX_ZOPFLI_LEN_QUALITY_11 = 325;
+let HasherType = /* @__PURE__ */ function(HasherType) {
+	HasherType[HasherType["NONE"] = 0] = "NONE";
+	HasherType[HasherType["H01"] = 1] = "H01";
+	HasherType[HasherType["H02"] = 2] = "H02";
+	HasherType[HasherType["H03"] = 3] = "H03";
+	HasherType[HasherType["H04"] = 4] = "H04";
+	HasherType[HasherType["H05"] = 5] = "H05";
+	HasherType[HasherType["H06"] = 6] = "H06";
+	HasherType[HasherType["H10"] = 10] = "H10";
+	HasherType[HasherType["H35"] = 35] = "H35";
+	HasherType[HasherType["H40"] = 40] = "H40";
+	HasherType[HasherType["H41"] = 41] = "H41";
+	HasherType[HasherType["H42"] = 42] = "H42";
+	HasherType[HasherType["H54"] = 54] = "H54";
+	HasherType[HasherType["H55"] = 55] = "H55";
+	HasherType[HasherType["H58"] = 58] = "H58";
+	HasherType[HasherType["H65"] = 65] = "H65";
+	HasherType[HasherType["H68"] = 68] = "H68";
+	return HasherType;
+}({});
+let EncoderMode = /* @__PURE__ */ function(EncoderMode) {
+	EncoderMode[EncoderMode["GENERIC"] = 0] = "GENERIC";
+	EncoderMode[EncoderMode["TEXT"] = 1] = "TEXT";
+	EncoderMode[EncoderMode["FONT"] = 2] = "FONT";
+	return EncoderMode;
+}({});
+const NUM_COMMAND_CODES = 704;
+const NUM_LITERAL_CODES = 256;
+const NUM_DISTANCE_SHORT_CODES = 16;
+function maxZopfliLen(quality) {
+	return quality <= 10 ? MAX_ZOPFLI_LEN_QUALITY_10 : MAX_ZOPFLI_LEN_QUALITY_11;
+}
+function maxZopfliCandidates(quality) {
+	return quality <= 10 ? 1 : 5;
+}
+function sanitizeParams(params) {
+	params.quality = Math.max(MIN_QUALITY, Math.min(MAX_QUALITY, params.quality));
+	if (params.quality <= MAX_QUALITY_FOR_STATIC_ENTROPY_CODES) params.largeWindow = false;
+	const maxLgwin = params.largeWindow ? LARGE_MAX_WINDOW_BITS : MAX_WINDOW_BITS;
+	params.lgwin = Math.max(MIN_WINDOW_BITS, Math.min(maxLgwin, params.lgwin));
+}
+function computeLgBlock(params) {
+	let lgblock = params.lgblock;
+	if (params.quality === FAST_ONE_PASS_COMPRESSION_QUALITY || params.quality === FAST_TWO_PASS_COMPRESSION_QUALITY) lgblock = params.lgwin;
+	else if (params.quality < MIN_QUALITY_FOR_BLOCK_SPLIT) lgblock = 14;
+	else if (lgblock === 0) {
+		lgblock = 16;
+		if (params.quality >= 9 && params.lgwin > lgblock) lgblock = Math.min(18, params.lgwin);
+	} else lgblock = Math.max(MIN_INPUT_BLOCK_BITS, Math.min(MAX_INPUT_BLOCK_BITS, lgblock));
+	return lgblock;
+}
+function createDefaultParams() {
+	return {
+		mode: EncoderMode.GENERIC,
+		quality: DEFAULT_QUALITY,
+		lgwin: DEFAULT_WINDOW_BITS,
+		lgblock: 0,
+		streamOffset: 0,
+		sizeHint: 0,
+		disableLiteralContextModeling: false,
+		largeWindow: false,
+		hasher: {
+			type: HasherType.H10,
+			bucketBits: 17,
+			blockBits: 0,
+			numLastDistancesToCheck: 16
+		},
+		dist: {
+			distancePostfixBits: 0,
+			numDirectDistanceCodes: 0,
+			alphabetSizeMax: 0,
+			alphabetSizeLimit: 0,
+			maxDistance: 0
+		}
+	};
+}
+
+//#endregion
+//#region src/encode/fast-log.ts
+const kLog2Table = new Float64Array([
+	0,
+	0,
+	1,
+	1.5849625007211563,
+	2,
+	2.321928094887362,
+	2.584962500721156,
+	2.807354922057604,
+	3,
+	3.1699250014423126,
+	3.3219280948873626,
+	3.4594316186372978,
+	3.5849625007211565,
+	3.700439718141092,
+	3.8073549220576037,
+	3.9068905956085187,
+	4,
+	4.08746284125034,
+	4.169925001442312,
+	4.247927513443585,
+	4.321928094887363,
+	4.392317422778761,
+	4.459431618637297,
+	4.523561956057013,
+	4.584962500721157,
+	4.643856189774724,
+	4.700439718141093,
+	4.754887502163469,
+	4.807354922057604,
+	4.857980995127573,
+	4.906890595608519,
+	4.954196310386876,
+	5,
+	5.044394119358453,
+	5.08746284125034,
+	5.129283016944966,
+	5.169925001442312,
+	5.20945336562895,
+	5.247927513443585,
+	5.285402218862249,
+	5.321928094887363,
+	5.357552004618084,
+	5.392317422778761,
+	5.426264754702098,
+	5.459431618637297,
+	5.491853096329675,
+	5.523561956057013,
+	5.554588851677638,
+	5.584962500721157,
+	5.614709844115208,
+	5.643856189774724,
+	5.672425341971496,
+	5.700439718141093,
+	5.7279204545632,
+	5.754887502163469,
+	5.78135971352466,
+	5.807354922057605,
+	5.832890014164742,
+	5.857980995127572,
+	5.882643049361842,
+	5.906890595608519,
+	5.930737337562887,
+	5.954196310386876,
+	5.977279923499917,
+	6,
+	6.022367813028454,
+	6.044394119358453,
+	6.066089190457772,
+	6.08746284125034,
+	6.10852445677817,
+	6.129283016944967,
+	6.149747119504682,
+	6.169925001442312,
+	6.189824558880018,
+	6.209453365628951,
+	6.22881869049588,
+	6.247927513443586,
+	6.266786540694902,
+	6.285402218862249,
+	6.303780748177103,
+	6.321928094887362,
+	6.339850002884625,
+	6.357552004618085,
+	6.375039431346925,
+	6.39231742277876,
+	6.409390936137703,
+	6.426264754702098,
+	6.442943495848729,
+	6.459431618637298,
+	6.475733430966398,
+	6.491853096329675,
+	6.507794640198696,
+	6.523561956057013,
+	6.539158811108032,
+	6.554588851677638,
+	6.569855608330948,
+	6.584962500721156,
+	6.599912842187128,
+	6.614709844115209,
+	6.6293566200796095,
+	6.643856189774725,
+	6.6582114827517955,
+	6.672425341971495,
+	6.6865005271832185,
+	6.700439718141092,
+	6.714245517666122,
+	6.727920454563199,
+	6.7414669864011465,
+	6.754887502163469,
+	6.768184324776926,
+	6.78135971352466,
+	6.794415866350106,
+	6.807354922057604,
+	6.820178962415189,
+	6.832890014164742,
+	6.845490050944376,
+	6.857980995127572,
+	6.870364719583405,
+	6.882643049361842,
+	6.894817763307944,
+	6.906890595608519,
+	6.9188632372745955,
+	6.930737337562887,
+	6.94251450533924,
+	6.954196310386876,
+	6.965784284662088,
+	6.977279923499917,
+	6.988684686772166,
+	7,
+	7.011227255423254,
+	7.022367813028454,
+	7.03342300153745,
+	7.044394119358453,
+	7.05528243550119,
+	7.066089190457772,
+	7.076815597050832,
+	7.08746284125034,
+	7.098032082960527,
+	7.10852445677817,
+	7.118941072723508,
+	7.129283016944966,
+	7.139551352398794,
+	7.149747119504682,
+	7.159871336778389,
+	7.169925001442313,
+	7.1799090900149345,
+	7.189824558880018,
+	7.199672344836364,
+	7.209453365628949,
+	7.219168520462162,
+	7.22881869049588,
+	7.238404739325079,
+	7.247927513443586,
+	7.257387842692652,
+	7.266786540694902,
+	7.276124405274238,
+	7.285402218862249,
+	7.294620748891627,
+	7.303780748177103,
+	7.312882955284356,
+	7.321928094887362,
+	7.330916878114618,
+	7.339850002884624,
+	7.348728154231078,
+	7.357552004618085,
+	7.366322214245815,
+	7.375039431346925,
+	7.383704292474053,
+	7.392317422778761,
+	7.400879436282184,
+	7.409390936137703,
+	7.417852514885899,
+	7.426264754702098,
+	7.4346282276367255,
+	7.442943495848729,
+	7.45121111183233,
+	7.459431618637297,
+	7.467605550082998,
+	7.475733430966398,
+	7.483815777264256,
+	7.491853096329675,
+	7.499845887083206,
+	7.507794640198696,
+	7.515699838284044,
+	7.523561956057013,
+	7.531381460516312,
+	7.539158811108032,
+	7.546894459887637,
+	7.554588851677638,
+	7.562242424221073,
+	7.569855608330948,
+	7.577428828035749,
+	7.584962500721156,
+	7.592457037268081,
+	7.599912842187128,
+	7.607330313749611,
+	7.6147098441152075,
+	7.622051819456376,
+	7.6293566200796095,
+	7.636624620543649,
+	7.643856189774724,
+	7.651051691178929,
+	7.6582114827517955,
+	7.6653359171851765,
+	7.672425341971495,
+	7.679480099505446,
+	7.6865005271832185,
+	7.693486957499325,
+	7.700439718141093,
+	7.7073591320808825,
+	7.714245517666122,
+	7.721099188707186,
+	7.7279204545632,
+	7.734709620225839,
+	7.7414669864011465,
+	7.74819284958946,
+	7.754887502163469,
+	7.7615512324444795,
+	7.768184324776926,
+	7.774787059601174,
+	7.781359713524661,
+	7.787902559391432,
+	7.794415866350106,
+	7.800899899920305,
+	7.807354922057604,
+	7.813781191217037,
+	7.820178962415189,
+	7.826548487290916,
+	7.832890014164742,
+	7.8392037880969445,
+	7.845490050944376,
+	7.851749041416057,
+	7.857980995127572,
+	7.86418614465428,
+	7.870364719583405,
+	7.876516946565,
+	7.8826430493618425,
+	7.88874324889826,
+	7.894817763307945,
+	7.90086680798075,
+	7.906890595608519,
+	7.912889336229962,
+	7.9188632372745955,
+	7.924812503605781,
+	7.930737337562887,
+	7.936637939002572,
+	7.94251450533924,
+	7.948367231584678,
+	7.954196310386876,
+	7.960001932068081,
+	7.965784284662087,
+	7.971543553950772,
+	7.977279923499917,
+	7.98299357469431,
+	7.988684686772166,
+	7.994353436858858
+]);
+const LOG2_TABLE_SIZE = 256;
+const LOG_2_INV = 1.4426950408889634;
+function log2FloorNonZero(n) {
+	return 31 - Math.clz32(n | 0);
+}
+function fastLog2(v) {
+	if (v < LOG2_TABLE_SIZE) return kLog2Table[v];
+	return Math.log(v) * LOG_2_INV;
+}
+
+//#endregion
+//#region src/encode/match.ts
+const LITERAL_BYTE_SCORE = 135;
+const DISTANCE_BIT_PENALTY = 30;
+const SCORE_BASE = DISTANCE_BIT_PENALTY * 8 * 4;
+function backwardReferenceScore(copyLength, backwardDistance) {
+	return SCORE_BASE + LITERAL_BYTE_SCORE * copyLength - DISTANCE_BIT_PENALTY * log2FloorNonZero(backwardDistance);
+}
+function backwardReferenceScoreUsingLastDistance(copyLength) {
+	return LITERAL_BYTE_SCORE * copyLength + SCORE_BASE + 15;
+}
+function findMatchLength(data, s1, s2, limit) {
+	let matched = 0;
+	while (matched + 4 <= limit) {
+		if (data[s1 + matched] !== data[s2 + matched] || data[s1 + matched + 1] !== data[s2 + matched + 1] || data[s1 + matched + 2] !== data[s2 + matched + 2] || data[s1 + matched + 3] !== data[s2 + matched + 3]) break;
+		matched += 4;
+	}
+	while (matched < limit && data[s1 + matched] === data[s2 + matched]) matched++;
+	return matched;
+}
+function createBackwardMatch(distance, length) {
+	return {
+		distance,
+		length,
+		score: backwardReferenceScore(length, distance),
+		lenCodeDelta: 0
+	};
+}
+function createSearchResult() {
+	return {
+		len: 0,
+		distance: 0,
+		score: 0,
+		lenCodeDelta: 0
+	};
+}
+function prepareDistanceCache(distanceCache, numDistances) {
+	if (numDistances > 4) {
+		const lastDistance = distanceCache[0];
+		distanceCache[4] = lastDistance - 1;
+		distanceCache[5] = lastDistance + 1;
+		distanceCache[6] = lastDistance - 2;
+		distanceCache[7] = lastDistance + 2;
+		distanceCache[8] = lastDistance - 3;
+		distanceCache[9] = lastDistance + 3;
+		if (numDistances > 10) {
+			const nextLastDistance = distanceCache[1];
+			distanceCache[10] = nextLastDistance - 1;
+			distanceCache[11] = nextLastDistance + 1;
+			distanceCache[12] = nextLastDistance - 2;
+			distanceCache[13] = nextLastDistance + 2;
+			distanceCache[14] = nextLastDistance - 3;
+			distanceCache[15] = nextLastDistance + 3;
+		}
+	}
+}
+const HASH_MUL_32 = 506832829;
+const HASH_MUL_64 = 506832829n;
+function hashBytes4(data, pos, bucketBits) {
+	const b0 = pos < data.length ? data[pos] : 0;
+	const b1 = pos + 1 < data.length ? data[pos + 1] : 0;
+	const b2 = pos + 2 < data.length ? data[pos + 2] : 0;
+	const b3 = pos + 3 < data.length ? data[pos + 3] : 0;
+	const h32 = (b0 | b1 << 8 | b2 << 16 | b3 << 24) >>> 0;
+	return Math.imul(h32, HASH_MUL_32) >>> 0 >>> 32 - bucketBits;
+}
+function hashBytes8(data, pos, hashLen, bucketBits) {
+	let h64 = 0n;
+	for (let i = 0; i < 8; i++) {
+		const byte = pos + i < data.length ? data[pos + i] : 0;
+		h64 |= BigInt(byte) << BigInt(i * 8);
+	}
+	const shift = BigInt(64 - 8 * hashLen);
+	h64 = (h64 << shift) * HASH_MUL_64;
+	return Number(h64 >> BigInt(64 - bucketBits));
+}
+
+//#endregion
+//#region src/encode/hash-simple.ts
+const Q2_BUCKET_BITS = 16;
+const Q3_BUCKET_BITS = 17;
+const HASH_LEN = 5;
+const MIN_MATCH_LEN$1 = 4;
+var SimpleHasher = class {
+	constructor(bucketBits, _lgwin) {
+		this.bucketBits = bucketBits;
+		const bucketSize = 1 << bucketBits;
+		this.buckets = new Uint32Array(bucketSize);
+	}
+	reset() {
+		this.buckets.fill(0);
+	}
+	prepare(data, inputSize) {
+		if (inputSize <= this.buckets.length >> 5) for (let i = 0; i < inputSize; i++) {
+			const key = this.hashBytes(data, i);
+			this.buckets[key] = 0;
+		}
+		else this.buckets.fill(0);
+	}
+	hashBytes(data, pos) {
+		return hashBytes8(data, pos, HASH_LEN, this.bucketBits);
+	}
+	store(data, mask, ix) {
+		const key = this.hashBytes(data, ix & mask);
+		this.buckets[key] = ix;
+	}
+	storeRange(data, mask, ixStart, ixEnd) {
+		for (let i = ixStart; i < ixEnd; i++) this.store(data, mask, i);
+	}
+	findLongestMatch(data, ringBufferMask, distanceCache, curIx, maxLength, maxBackward, out) {
+		const curIxMasked = curIx & ringBufferMask;
+		let bestLen = out.len;
+		const key = this.hashBytes(data, curIxMasked);
+		let bestScore = out.score;
+		out.lenCodeDelta = 0;
+		const cachedBackward = distanceCache[0];
+		if (cachedBackward > 0 && cachedBackward <= maxBackward) {
+			let prevIx = curIx - cachedBackward;
+			prevIx &= ringBufferMask;
+			if (data[prevIx + bestLen] === data[curIxMasked + bestLen]) {
+				const len = findMatchLength(data, prevIx, curIxMasked, maxLength);
+				if (len >= MIN_MATCH_LEN$1) {
+					const score = backwardReferenceScoreUsingLastDistance(len);
+					if (score > bestScore) {
+						bestLen = len;
+						out.len = len;
+						out.distance = cachedBackward;
+						out.score = score;
+						bestScore = score;
+					}
+				}
+			}
+		}
+		let prevIx = this.buckets[key];
+		this.buckets[key] = curIx;
+		const backward = curIx - prevIx;
+		if (backward === 0 || backward > maxBackward) return;
+		prevIx &= ringBufferMask;
+		if (data[prevIx + bestLen] !== data[curIxMasked + bestLen]) return;
+		const len = findMatchLength(data, prevIx, curIxMasked, maxLength);
+		if (len >= MIN_MATCH_LEN$1) {
+			const score = backwardReferenceScore(len, backward);
+			if (score > bestScore) {
+				out.len = len;
+				out.distance = backward;
+				out.score = score;
+			}
+		}
+	}
+};
+function createSimpleHasher(quality, lgwin) {
+	return new SimpleHasher(quality === 2 ? Q2_BUCKET_BITS : Q3_BUCKET_BITS, lgwin);
+}
+
+//#endregion
+//#region src/encode/hash-chains.ts
+const MIN_MATCH_LEN = 4;
+var HashChainHasher = class {
+	constructor(bucketBits, blockBits, lgwin, numLastDistancesToCheck = 4) {
+		this.bucketBits = bucketBits;
+		this.blockBits = blockBits;
+		this.windowMask = (1 << lgwin) - 1;
+		this.numLastDistancesToCheck = numLastDistancesToCheck;
+		this.buckets = new Uint32Array(1 << bucketBits);
+		this.chains = new Uint32Array(1 << lgwin);
+	}
+	reset() {
+		this.buckets.fill(0);
+	}
+	hashBytes(data, pos) {
+		return hashBytes4(data, pos, this.bucketBits);
+	}
+	store(data, mask, ix) {
+		const maskedIx = ix & mask;
+		const key = this.hashBytes(data, maskedIx);
+		const minorKey = ix & this.windowMask;
+		this.chains[minorKey] = this.buckets[key];
+		this.buckets[key] = ix;
+	}
+	storeRange(data, mask, ixStart, ixEnd) {
+		for (let i = ixStart; i < ixEnd; i++) this.store(data, mask, i);
+	}
+	findLongestMatch(data, ringBufferMask, distanceCache, curIx, maxLength, maxBackward, out) {
+		const curIxMasked = curIx & ringBufferMask;
+		let bestLen = out.len;
+		let bestScore = out.score;
+		const key = this.hashBytes(data, curIxMasked);
+		const minorKey = curIx & this.windowMask;
+		out.lenCodeDelta = 0;
+		prepareDistanceCache(distanceCache, this.numLastDistancesToCheck);
+		for (let i = 0; i < this.numLastDistancesToCheck; i++) {
+			const cachedBackward = distanceCache[i];
+			if (cachedBackward <= 0 || cachedBackward > maxBackward) continue;
+			let prevIx = curIx - cachedBackward;
+			prevIx &= ringBufferMask;
+			if (data[prevIx + bestLen] !== data[curIxMasked + bestLen]) continue;
+			const len = findMatchLength(data, prevIx, curIxMasked, maxLength);
+			if (len >= MIN_MATCH_LEN) {
+				const score = backwardReferenceScoreUsingLastDistance(len);
+				if (score > bestScore) {
+					bestLen = len;
+					out.len = len;
+					out.distance = cachedBackward;
+					out.score = score;
+					bestScore = score;
+				}
+			}
+		}
+		this.chains[minorKey] = this.buckets[key];
+		this.buckets[key] = curIx;
+		const maxChainLength = 1 << this.blockBits;
+		let prevIx = this.chains[minorKey];
+		for (let chainLen = 0; chainLen < maxChainLength; chainLen++) {
+			const backward = curIx - prevIx;
+			if (backward === 0 || backward > maxBackward) break;
+			const prevIxMasked = prevIx & ringBufferMask;
+			if (data[prevIxMasked + bestLen] !== data[curIxMasked + bestLen]) {
+				prevIx = this.chains[prevIx & this.windowMask];
+				continue;
+			}
+			const len = findMatchLength(data, prevIxMasked, curIxMasked, maxLength);
+			if (len >= MIN_MATCH_LEN) {
+				const score = backwardReferenceScore(len, backward);
+				if (score > bestScore) {
+					bestLen = len;
+					out.len = len;
+					out.distance = backward;
+					out.score = score;
+					bestScore = score;
+				}
+			}
+			prevIx = this.chains[prevIx & this.windowMask];
+		}
+	}
+	findAllMatches(data, ringBufferMask, distanceCache, curIx, maxLength, maxBackward) {
+		const curIxMasked = curIx & ringBufferMask;
+		const matches = [];
+		const key = this.hashBytes(data, curIxMasked);
+		const minorKey = curIx & this.windowMask;
+		let bestLen = 0;
+		prepareDistanceCache(distanceCache, this.numLastDistancesToCheck);
+		for (let i = 0; i < this.numLastDistancesToCheck; i++) {
+			const cachedBackward = distanceCache[i];
+			if (cachedBackward <= 0 || cachedBackward > maxBackward) continue;
+			let prevIx = curIx - cachedBackward;
+			prevIx &= ringBufferMask;
+			const len = findMatchLength(data, prevIx, curIxMasked, maxLength);
+			if (len >= MIN_MATCH_LEN && len > bestLen) {
+				bestLen = len;
+				matches.push({
+					distance: cachedBackward,
+					length: len,
+					score: backwardReferenceScoreUsingLastDistance(len),
+					lenCodeDelta: 0
+				});
+			}
+		}
+		this.chains[minorKey] = this.buckets[key];
+		this.buckets[key] = curIx;
+		const maxChainLength = 1 << this.blockBits;
+		let prevIx = this.chains[minorKey];
+		for (let chainLen = 0; chainLen < maxChainLength; chainLen++) {
+			const backward = curIx - prevIx;
+			if (backward === 0 || backward > maxBackward) break;
+			const len = findMatchLength(data, prevIx & ringBufferMask, curIxMasked, maxLength);
+			if (len >= MIN_MATCH_LEN && len > bestLen) {
+				bestLen = len;
+				matches.push({
+					distance: backward,
+					length: len,
+					score: backwardReferenceScore(len, backward),
+					lenCodeDelta: 0
+				});
+			}
+			prevIx = this.chains[prevIx & this.windowMask];
+		}
+		matches.sort((a, b) => a.length - b.length);
+		return matches;
+	}
+};
+function createHashChainHasher(quality, lgwin) {
+	let bucketBits;
+	let blockBits;
+	let numLastDistancesToCheck;
+	if (quality < 7) {
+		bucketBits = 14;
+		blockBits = quality - 1;
+		numLastDistancesToCheck = 4;
+	} else if (quality < 9) {
+		bucketBits = 15;
+		blockBits = quality - 1;
+		numLastDistancesToCheck = 10;
+	} else {
+		bucketBits = 15;
+		blockBits = quality - 1;
+		numLastDistancesToCheck = 16;
+	}
+	return new HashChainHasher(bucketBits, blockBits, lgwin, numLastDistancesToCheck);
+}
+
+//#endregion
+//#region src/encode/hash-binary-tree.ts
+const BUCKET_BITS = 17;
+const MAX_TREE_COMP_LENGTH = 128;
+const MAX_TREE_SEARCH_DEPTH = 64;
+const WINDOW_GAP = 16;
+var BinaryTreeHasher = class {
+	constructor(lgwin, inputSize) {
+		this.windowMask = (1 << lgwin) - 1;
+		this.invalidPos = 0 - this.windowMask >>> 0;
+		this.bucketSize = 1 << BUCKET_BITS;
+		this.buckets = new Uint32Array(this.bucketSize);
+		const numNodes = inputSize !== void 0 ? Math.min(inputSize, 1 << lgwin) : 1 << lgwin;
+		this.forest = new Uint32Array(2 * numNodes);
+		this.forest.fill(this.invalidPos);
+	}
+	reset() {
+		this.buckets.fill(this.invalidPos);
+		this.forest.fill(this.invalidPos);
+	}
+	leftChildIndex(pos) {
+		return 2 * (pos & this.windowMask);
+	}
+	rightChildIndex(pos) {
+		return 2 * (pos & this.windowMask) + 1;
+	}
+	storeAndFindMatches(data, curIx, ringBufferMask, maxLength, maxBackward, matches) {
+		const curIxMasked = curIx & ringBufferMask;
+		const maxCompLen = Math.min(maxLength, MAX_TREE_COMP_LENGTH);
+		const shouldRerootTree = maxLength >= MAX_TREE_COMP_LENGTH;
+		const key = hashBytes4(data, curIxMasked, BUCKET_BITS);
+		let prevIx = this.buckets[key];
+		let nodeLeft = this.leftChildIndex(curIx);
+		let nodeRight = this.rightChildIndex(curIx);
+		let bestLenLeft = 0;
+		let bestLenRight = 0;
+		let bestLen = matches ? 1 : 0;
+		const result = matches || [];
+		if (shouldRerootTree) this.buckets[key] = curIx;
+		for (let depthRemaining = MAX_TREE_SEARCH_DEPTH; depthRemaining > 0; depthRemaining--) {
+			if (prevIx === this.invalidPos) {
+				if (shouldRerootTree) {
+					this.forest[nodeLeft] = this.invalidPos;
+					this.forest[nodeRight] = this.invalidPos;
+				}
+				break;
+			}
+			const backward = curIx - prevIx;
+			const prevIxMasked = prevIx & ringBufferMask;
+			if (backward <= 0 || backward > maxBackward) {
+				if (shouldRerootTree) {
+					this.forest[nodeLeft] = this.invalidPos;
+					this.forest[nodeRight] = this.invalidPos;
+				}
+				break;
+			}
+			const curLen = Math.min(bestLenLeft, bestLenRight);
+			const len = curLen + findMatchLength(data, curIxMasked + curLen, prevIxMasked + curLen, maxLength - curLen);
+			if (matches && len > bestLen) {
+				bestLen = len;
+				result.push(createBackwardMatch(backward, len));
+			}
+			if (len >= maxCompLen) {
+				if (shouldRerootTree) {
+					this.forest[nodeLeft] = this.forest[this.leftChildIndex(prevIx)];
+					this.forest[nodeRight] = this.forest[this.rightChildIndex(prevIx)];
+				}
+				break;
+			}
+			if (data[curIxMasked + len] > data[prevIxMasked + len]) {
+				bestLenLeft = len;
+				if (shouldRerootTree) this.forest[nodeLeft] = prevIx;
+				nodeLeft = this.rightChildIndex(prevIx);
+				prevIx = this.forest[nodeLeft];
+			} else {
+				bestLenRight = len;
+				if (shouldRerootTree) this.forest[nodeRight] = prevIx;
+				nodeRight = this.leftChildIndex(prevIx);
+				prevIx = this.forest[nodeRight];
+			}
+		}
+		return result;
+	}
+	findAllMatches(data, ringBufferMask, curIx, maxLength, maxBackward) {
+		const curIxMasked = curIx & ringBufferMask;
+		const matches = [];
+		let bestLen = 1;
+		const shortMatchMaxBackward = 64;
+		const stop = curIx > shortMatchMaxBackward ? curIx - shortMatchMaxBackward : 0;
+		for (let i = curIx - 1; i > stop && bestLen <= 2; i--) {
+			const backward = curIx - i;
+			if (backward > maxBackward) break;
+			const prevIxMasked = i & ringBufferMask;
+			if (data[curIxMasked] !== data[prevIxMasked] || data[curIxMasked + 1] !== data[prevIxMasked + 1]) continue;
+			const len = findMatchLength(data, prevIxMasked, curIxMasked, maxLength);
+			if (len > bestLen) {
+				bestLen = len;
+				matches.push(createBackwardMatch(backward, len));
+			}
+		}
+		if (bestLen < maxLength) {
+			const treeMatches = this.storeAndFindMatches(data, curIx, ringBufferMask, maxLength, maxBackward, []);
+			for (const m of treeMatches) if (m.length > bestLen) {
+				bestLen = m.length;
+				matches.push(m);
+			}
+		} else this.storeAndFindMatches(data, curIx, ringBufferMask, maxLength, maxBackward, null);
+		matches.sort((a, b) => a.length - b.length);
+		return matches;
+	}
+	store(data, mask, ix) {
+		const maxBackward = this.windowMask - WINDOW_GAP + 1;
+		this.storeAndFindMatches(data, ix, mask, MAX_TREE_COMP_LENGTH, maxBackward, null);
+	}
+	storeRange(data, mask, ixStart, ixEnd) {
+		let i = ixStart;
+		let j = ixStart;
+		if (ixStart + 63 <= ixEnd) i = ixEnd - 63;
+		if (ixStart + 512 <= i) for (; j < i; j += 8) this.store(data, mask, j);
+		for (; i < ixEnd; i++) this.store(data, mask, i);
+	}
+	stitchToPreviousBlock(numBytes, position, ringBuffer, ringBufferMask) {
+		if (numBytes >= 3 && position >= MAX_TREE_COMP_LENGTH) {
+			const iStart = position - MAX_TREE_COMP_LENGTH + 1;
+			const iEnd = Math.min(position, iStart + numBytes);
+			for (let i = iStart; i < iEnd; i++) {
+				const maxBackward = this.windowMask - Math.max(WINDOW_GAP - 1, position - i);
+				this.storeAndFindMatches(ringBuffer, i, ringBufferMask, MAX_TREE_COMP_LENGTH, maxBackward, null);
+			}
+		}
+	}
+};
+function createBinaryTreeHasher(lgwin, inputSize) {
+	return new BinaryTreeHasher(lgwin, inputSize);
+}
+
+//#endregion
+//#region src/encode/command.ts
+const INSERT_LENGTH_BASE = new Uint32Array([
+	0,
+	1,
+	2,
+	3,
+	4,
+	5,
+	6,
+	8,
+	10,
+	14,
+	18,
+	26,
+	34,
+	50,
+	66,
+	98,
+	130,
+	194,
+	322,
+	578,
+	1090,
+	2114,
+	6210,
+	22594
+]);
+const INSERT_LENGTH_EXTRA = new Uint32Array([
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	1,
+	1,
+	2,
+	2,
+	3,
+	3,
+	4,
+	4,
+	5,
+	5,
+	6,
+	7,
+	8,
+	9,
+	10,
+	12,
+	14,
+	24
+]);
+const COPY_LENGTH_BASE = new Uint32Array([
+	2,
+	3,
+	4,
+	5,
+	6,
+	7,
+	8,
+	9,
+	10,
+	12,
+	14,
+	18,
+	22,
+	30,
+	38,
+	54,
+	70,
+	102,
+	134,
+	198,
+	326,
+	582,
+	1094,
+	2118
+]);
+const COPY_LENGTH_EXTRA = new Uint32Array([
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	1,
+	1,
+	2,
+	2,
+	3,
+	3,
+	4,
+	4,
+	5,
+	5,
+	6,
+	7,
+	8,
+	9,
+	10,
+	24
+]);
+function getInsertLengthCode(insertLen) {
+	if (insertLen < 6) return insertLen;
+	else if (insertLen < 130) {
+		const nbits = log2FloorNonZero(insertLen - 2) - 1;
+		return (nbits << 1) + (insertLen - 2 >>> nbits) + 2;
+	} else if (insertLen < 2114) return log2FloorNonZero(insertLen - 66) + 10;
+	else if (insertLen < 6210) return 21;
+	else if (insertLen < 22594) return 22;
+	else return 23;
+}
+function getCopyLengthCode(copyLen) {
+	if (copyLen < 10) return copyLen - 2;
+	else if (copyLen < 134) {
+		const nbits = log2FloorNonZero(copyLen - 6) - 1;
+		return (nbits << 1) + (copyLen - 6 >>> nbits) + 4;
+	} else if (copyLen < 2118) return log2FloorNonZero(copyLen - 70) + 12;
+	else return 23;
+}
+function combineLengthCodes(insCode, copyCode, useLastDistance) {
+	const bits64 = copyCode & 7 | (insCode & 7) << 3;
+	if (useLastDistance && insCode < 8 && copyCode < 16) return copyCode < 8 ? bits64 : bits64 | 64;
+	else {
+		let offset = 2 * ((copyCode >>> 3) + 3 * (insCode >>> 3));
+		offset = (offset << 5) + 64 + (5377344 >>> offset & 192);
+		return offset | bits64;
+	}
+}
+function getLengthCode(insertLen, copyLen, useLastDistance) {
+	return combineLengthCodes(getInsertLengthCode(insertLen), getCopyLengthCode(copyLen), useLastDistance);
+}
+function getInsertBase(insCode) {
+	return INSERT_LENGTH_BASE[insCode];
+}
+function getInsertExtra(insCode) {
+	return INSERT_LENGTH_EXTRA[insCode];
+}
+function getCopyBase(copyCode) {
+	return COPY_LENGTH_BASE[copyCode];
+}
+function getCopyExtra(copyCode) {
+	return COPY_LENGTH_EXTRA[copyCode];
+}
+function prefixEncodeCopyDistance(distanceCode, numDirectCodes, postfixBits) {
+	if (distanceCode < NUM_DISTANCE_SHORT_CODES + numDirectCodes) return [
+		distanceCode,
+		0,
+		0
+	];
+	else {
+		const dist = (1 << postfixBits + 2) + (distanceCode - NUM_DISTANCE_SHORT_CODES - numDirectCodes);
+		const bucket = log2FloorNonZero(dist) - 1;
+		const postfix = dist & (1 << postfixBits) - 1;
+		const prefix = dist >>> bucket & 1;
+		const offset = 2 + prefix << bucket;
+		const nbits = bucket - postfixBits;
+		return [
+			nbits << 10 | NUM_DISTANCE_SHORT_CODES + numDirectCodes + (2 * (nbits - 1) + prefix << postfixBits) + postfix,
+			dist - offset >>> postfixBits,
+			nbits
+		];
+	}
+}
+function createCommand(insertLen, copyLen, copyLenCodeDelta, distanceCode, numDirectCodes = 0, postfixBits = 0) {
+	const copyLenEncoded = copyLen | (copyLenCodeDelta & 127) << 25;
+	const [distCode, distExtra, distNbits] = prefixEncodeCopyDistance(distanceCode, numDirectCodes, postfixBits);
+	const distPrefix = distCode | distNbits << 10;
+	const useLastDistance = (distCode & 1023) === 0;
+	return {
+		insertLen,
+		copyLen: copyLenEncoded,
+		distExtra,
+		cmdPrefix: getLengthCode(insertLen, copyLen + copyLenCodeDelta, useLastDistance),
+		distPrefix
+	};
+}
+function createInsertCommand(insertLen) {
+	const copyLenCode = 2;
+	const insCode = getInsertLengthCode(insertLen);
+	let cmdPrefix;
+	if (insCode < 8) cmdPrefix = getLengthCode(insertLen, copyLenCode, true);
+	else cmdPrefix = getLengthCode(insertLen, copyLenCode, false);
+	return {
+		insertLen,
+		copyLen: 67108864,
+		distExtra: 0,
+		cmdPrefix,
+		distPrefix: 0
+	};
+}
+function commandCopyLen(cmd) {
+	return cmd.copyLen & 33554431;
+}
+function commandCopyLenCode(cmd) {
+	const modifier = cmd.copyLen >>> 25;
+	const delta = modifier & 64 ? modifier | 4294967168 : modifier;
+	return (cmd.copyLen & 33554431) + delta;
+}
+
+//#endregion
+//#region src/encode/backward-references.ts
+function createBackwardReferences(numBytes, position, ringbuffer, ringbufferMask, hasher, distCache, lastInsertLen, _quality) {
+	const commands = [];
+	let numLiterals = 0;
+	let insertLen = lastInsertLen;
+	let pos = position;
+	const posEnd = position + numBytes;
+	const maxWindowBackward = (1 << 22) - 16;
+	while (pos < posEnd) {
+		const maxLen = posEnd - pos;
+		if (maxLen < 4) {
+			insertLen += maxLen;
+			pos += maxLen;
+			break;
+		}
+		const maxBackward = Math.min(pos, maxWindowBackward);
+		const result = createSearchResult();
+		hasher.findLongestMatch(ringbuffer, ringbufferMask, distCache, pos, Math.min(maxLen, 128), maxBackward, result);
+		if (result.len >= 4 && result.score > 0 && result.distance > 0) {
+			const distance = result.distance;
+			const matchLen = result.len;
+			if (distance > pos) {
+				hasher.store(ringbuffer, ringbufferMask, pos);
+				insertLen++;
+				pos++;
+				continue;
+			}
+			const distCode = distanceToCode(distance, distCache);
+			const cmd = createCommand(insertLen, matchLen, result.lenCodeDelta, distCode);
+			commands.push(cmd);
+			numLiterals += insertLen;
+			if (distCode > 0) {
+				distCache[3] = distCache[2];
+				distCache[2] = distCache[1];
+				distCache[1] = distCache[0];
+				distCache[0] = distance;
+			}
+			const storeEnd = Math.min(pos + matchLen, posEnd - 4);
+			for (let i = pos + 1; i < storeEnd; i++) hasher.store(ringbuffer, ringbufferMask, i);
+			pos += matchLen;
+			insertLen = 0;
+		} else {
+			hasher.store(ringbuffer, ringbufferMask, pos);
+			insertLen++;
+			pos++;
+		}
+	}
+	if (insertLen > 0) {
+		const cmd = createInsertCommand(insertLen);
+		commands.push(cmd);
+		numLiterals += insertLen;
+		insertLen = 0;
+	}
+	return [
+		commands,
+		numLiterals,
+		insertLen
+	];
+}
+const DISTANCE_CACHE_INDEX$1 = new Uint8Array([
+	0,
+	1,
+	2,
+	3,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	1,
+	1,
+	1,
+	1,
+	1,
+	1
+]);
+const DISTANCE_CACHE_OFFSET$1 = new Int8Array([
+	0,
+	0,
+	0,
+	0,
+	-1,
+	1,
+	-2,
+	2,
+	-3,
+	3,
+	-1,
+	1,
+	-2,
+	2,
+	-3,
+	3
+]);
+function distanceToCode(distance, distCache) {
+	for (let i = 0; i < NUM_DISTANCE_SHORT_CODES; i++) {
+		const cached = distCache[DISTANCE_CACHE_INDEX$1[i]] + DISTANCE_CACHE_OFFSET$1[i];
+		if (distance === cached && cached > 0) return i;
+	}
+	return distance + NUM_DISTANCE_SHORT_CODES - 1;
+}
+function backwardMatchLength(match) {
+	return match.length;
+}
+
+//#endregion
+//#region src/encode/zopfli-cost-model.ts
+const INFINITY_COST = 17e37;
+var ZopfliCostModel = class {
+	constructor(numBytes, distanceAlphabetSize) {
+		this.minCostCmd = INFINITY_COST;
+		this.numBytes = numBytes;
+		this.distanceHistogramSize = distanceAlphabetSize;
+		this.costCmd = new Float32Array(NUM_COMMAND_CODES);
+		this.costDist = new Float32Array(distanceAlphabetSize);
+		this.literalCosts = new Float32Array(numBytes + 2);
+	}
+	setFromLiteralCosts(position, ringbuffer, ringbufferMask) {
+		const literalHistograms = new Float64Array(3 * 256);
+		this.estimateBitCostsForLiterals(position, this.numBytes, ringbufferMask, ringbuffer, literalHistograms);
+		this.literalCosts[0] = 0;
+		let literalCarry = 0;
+		for (let i = 0; i < this.numBytes; i++) {
+			const byte = ringbuffer[position + i & ringbufferMask];
+			literalCarry += literalHistograms[byte];
+			this.literalCosts[i + 1] = this.literalCosts[i] + literalCarry;
+			literalCarry -= this.literalCosts[i + 1] - this.literalCosts[i];
+		}
+		for (let i = 0; i < NUM_COMMAND_CODES; i++) this.costCmd[i] = fastLog2(11 + i);
+		for (let i = 0; i < this.distanceHistogramSize; i++) this.costDist[i] = fastLog2(20 + i);
+		this.minCostCmd = fastLog2(11);
+	}
+	setFromCommands(position, ringbuffer, ringbufferMask, commands, lastInsertLen) {
+		const histogramLiteral = new Uint32Array(NUM_LITERAL_CODES);
+		const histogramCmd = new Uint32Array(NUM_COMMAND_CODES);
+		const histogramDist = new Uint32Array(this.distanceHistogramSize);
+		const costLiteral = new Float32Array(NUM_LITERAL_CODES);
+		let pos = position - lastInsertLen;
+		for (const cmd of commands) {
+			const insLen = cmd.insertLen;
+			const copyLen = commandCopyLen(cmd);
+			const distCode = cmd.distPrefix & 1023;
+			const cmdCode = cmd.cmdPrefix;
+			histogramCmd[cmdCode]++;
+			if (cmdCode >= 128) histogramDist[distCode]++;
+			for (let j = 0; j < insLen; j++) histogramLiteral[ringbuffer[pos + j & ringbufferMask]]++;
+			pos += insLen + copyLen;
+		}
+		this.setCostFromHistogram(histogramLiteral, true, costLiteral);
+		this.setCostFromHistogram(histogramCmd, false, this.costCmd);
+		this.setCostFromHistogram(histogramDist, false, this.costDist);
+		this.minCostCmd = INFINITY_COST;
+		for (let i = 0; i < NUM_COMMAND_CODES; i++) if (this.costCmd[i] < this.minCostCmd) this.minCostCmd = this.costCmd[i];
+		this.literalCosts[0] = 0;
+		let literalCarry = 0;
+		for (let i = 0; i < this.numBytes; i++) {
+			const byte = ringbuffer[position + i & ringbufferMask];
+			literalCarry += costLiteral[byte];
+			this.literalCosts[i + 1] = this.literalCosts[i] + literalCarry;
+			literalCarry -= this.literalCosts[i + 1] - this.literalCosts[i];
+		}
+	}
+	setCostFromHistogram(histogram, isLiteralHistogram, cost) {
+		let sum = 0;
+		for (let i = 0; i < histogram.length; i++) sum += histogram[i];
+		const log2sum = fastLog2(sum);
+		let missingSymbolSum = sum;
+		if (!isLiteralHistogram) {
+			for (let i = 0; i < histogram.length; i++) if (histogram[i] === 0) missingSymbolSum++;
+		}
+		const missingSymbolCost = fastLog2(missingSymbolSum) + 2;
+		for (let i = 0; i < histogram.length; i++) if (histogram[i] === 0) cost[i] = missingSymbolCost;
+		else {
+			cost[i] = log2sum - fastLog2(histogram[i]);
+			if (cost[i] < 1) cost[i] = 1;
+		}
+	}
+	estimateBitCostsForLiterals(position, numBytes, ringbufferMask, ringbuffer, costs) {
+		const histogram = new Uint32Array(256);
+		for (let i = 0; i < numBytes; i++) histogram[ringbuffer[position + i & ringbufferMask]]++;
+		const log2total = fastLog2(numBytes);
+		for (let i = 0; i < 256; i++) if (histogram[i] === 0) costs[i] = log2total + 2;
+		else {
+			costs[i] = log2total - fastLog2(histogram[i]);
+			if (costs[i] < 1) costs[i] = 1;
+		}
+	}
+	getCommandCost(cmdCode) {
+		return this.costCmd[cmdCode];
+	}
+	getDistanceCost(distCode) {
+		return this.costDist[distCode];
+	}
+	getLiteralCosts(from, to) {
+		return this.literalCosts[to] - this.literalCosts[from];
+	}
+	getMinCostCmd() {
+		return this.minCostCmd;
+	}
+};
+
+//#endregion
+//#region src/encode/backward-references-hq.ts
+const DISTANCE_CACHE_INDEX = new Uint8Array([
+	0,
+	1,
+	2,
+	3,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	1,
+	1,
+	1,
+	1,
+	1,
+	1
+]);
+const DISTANCE_CACHE_OFFSET = new Int8Array([
+	0,
+	0,
+	0,
+	0,
+	-1,
+	1,
+	-2,
+	2,
+	-3,
+	3,
+	-1,
+	1,
+	-2,
+	2,
+	-3,
+	3
+]);
+const LONG_COPY_QUICK_STEP = 16384;
+function createZopfliNodes(length) {
+	const nodes = new Array(length);
+	for (let i = 0; i < length; i++) nodes[i] = {
+		length: 1,
+		distance: 0,
+		dcodeInsertLength: 0,
+		cost: INFINITY_COST,
+		shortcut: 0
+	};
+	return nodes;
+}
+function zopfliNodeCopyLength(node) {
+	return node.length & 33554431;
+}
+function zopfliNodeLengthCode(node) {
+	const modifier = node.length >>> 25;
+	return zopfliNodeCopyLength(node) + 9 - modifier;
+}
+function zopfliNodeCopyDistance(node) {
+	return node.distance;
+}
+function zopfliNodeDistanceCode(node) {
+	const shortCode = node.dcodeInsertLength >>> 27;
+	return shortCode === 0 ? zopfliNodeCopyDistance(node) + NUM_DISTANCE_SHORT_CODES - 1 : shortCode - 1;
+}
+function zopfliNodeCommandLength(node) {
+	return zopfliNodeCopyLength(node) + (node.dcodeInsertLength & 134217727);
+}
+function zopfliNodeInsertLength(node) {
+	return node.dcodeInsertLength & 134217727;
+}
+var StartPosQueue = class {
+	constructor() {
+		this.q = [];
+		this.idx = 0;
+	}
+	push(posdata) {
+		const offset = ~this.idx++ & 7;
+		while (this.q.length < 8) this.q.push({
+			pos: 0,
+			distanceCache: new Int32Array(4),
+			costdiff: INFINITY_COST,
+			cost: INFINITY_COST
+		});
+		this.q[offset] = {
+			pos: posdata.pos,
+			distanceCache: posdata.distanceCache.slice(),
+			costdiff: posdata.costdiff,
+			cost: posdata.cost
+		};
+		const len = this.size();
+		for (let i = 1; i < len; i++) {
+			const a = offset + i - 1 & 7;
+			const b = offset + i & 7;
+			if (this.q[a].costdiff > this.q[b].costdiff) {
+				const tmp = this.q[a];
+				this.q[a] = this.q[b];
+				this.q[b] = tmp;
+			}
+		}
+	}
+	size() {
+		return Math.min(this.idx, 8);
+	}
+	at(k) {
+		return this.q[k - this.idx & 7];
+	}
+	reset() {
+		this.idx = 0;
+	}
+};
+function updateZopfliNode(nodes, pos, startPos, len, lenCode, dist, shortCode, cost) {
+	const next = nodes[pos + len];
+	next.length = len | len + 9 - lenCode << 25;
+	next.distance = dist;
+	next.dcodeInsertLength = shortCode << 27 | pos - startPos;
+	next.cost = cost;
+}
+function computeMinimumCopyLength(startCost, nodes, numBytes, pos) {
+	let minCost = startCost;
+	let len = 2;
+	let nextLenBucket = 4;
+	let nextLenOffset = 10;
+	while (pos + len <= numBytes && nodes[pos + len].cost <= minCost) {
+		len++;
+		if (len === nextLenOffset) {
+			minCost += 1;
+			nextLenOffset += nextLenBucket;
+			nextLenBucket *= 2;
+		}
+	}
+	return len;
+}
+function computeDistanceShortcut(blockStart, pos, maxBackwardLimit, gap, nodes) {
+	if (pos === 0) return 0;
+	const cLen = zopfliNodeCopyLength(nodes[pos]);
+	const iLen = zopfliNodeInsertLength(nodes[pos]);
+	const dist = zopfliNodeCopyDistance(nodes[pos]);
+	if (dist + cLen <= blockStart + pos + gap && dist <= maxBackwardLimit + gap && zopfliNodeDistanceCode(nodes[pos]) > 0) return pos;
+	else return nodes[pos - cLen - iLen].shortcut;
+}
+function computeDistanceCache(pos, startingDistCache, nodes, distCache) {
+	let idx = 0;
+	let p = nodes[pos].shortcut;
+	while (idx < 4 && p > 0) {
+		const iLen = zopfliNodeInsertLength(nodes[p]);
+		const cLen = zopfliNodeCopyLength(nodes[p]);
+		const dist = zopfliNodeCopyDistance(nodes[p]);
+		distCache[idx++] = dist;
+		p = nodes[p - cLen - iLen].shortcut;
+	}
+	for (; idx < 4; idx++) distCache[idx] = startingDistCache[idx - (4 - idx)];
+}
+function evaluateNode(blockStart, pos, maxBackwardLimit, gap, startingDistCache, model, queue, nodes) {
+	const nodeCost = nodes[pos].cost;
+	nodes[pos].shortcut = computeDistanceShortcut(blockStart, pos, maxBackwardLimit, gap, nodes);
+	if (nodeCost <= model.getLiteralCosts(0, pos)) {
+		const distanceCache = new Int32Array(4);
+		computeDistanceCache(pos, startingDistCache, nodes, distanceCache);
+		queue.push({
+			pos,
+			cost: nodeCost,
+			costdiff: nodeCost - model.getLiteralCosts(0, pos),
+			distanceCache
+		});
+	}
+}
+function updateNodes(numBytes, blockStart, pos, ringbuffer, ringbufferMask, quality, maxBackwardLimit, startingDistCache, numMatches, matches, model, queue, nodes) {
+	const curIx = blockStart + pos;
+	const curIxMasked = curIx & ringbufferMask;
+	const maxDistance = Math.min(curIx, maxBackwardLimit);
+	const maxLen = numBytes - pos;
+	const maxZopfliLenVal = maxZopfliLen(quality);
+	const maxIters = maxZopfliCandidates(quality);
+	evaluateNode(blockStart, pos, maxBackwardLimit, 0, startingDistCache, model, queue, nodes);
+	const posdata0 = queue.at(0);
+	let minLen = computeMinimumCopyLength(posdata0.cost + model.getMinCostCmd() + model.getLiteralCosts(posdata0.pos, pos), nodes, numBytes, pos);
+	let result = 0;
+	for (let k = 0; k < maxIters && k < queue.size(); k++) {
+		const posdata = queue.at(k);
+		const start = posdata.pos;
+		const insCode = getInsertLengthCode(pos - start);
+		const baseCost = posdata.costdiff + getInsertExtra(insCode) + model.getLiteralCosts(0, pos);
+		let bestLen = minLen - 1;
+		for (let j = 0; j < NUM_DISTANCE_SHORT_CODES && bestLen < maxLen; j++) {
+			const idx = DISTANCE_CACHE_INDEX[j];
+			const backward = posdata.distanceCache[idx] + DISTANCE_CACHE_OFFSET[j];
+			if (backward <= 0 || backward > maxDistance) continue;
+			let prevIx = curIx - backward;
+			prevIx &= ringbufferMask;
+			if (curIxMasked + bestLen > ringbufferMask) break;
+			if (ringbuffer[prevIx + bestLen] !== ringbuffer[curIxMasked + bestLen]) continue;
+			const len = findMatchLength(ringbuffer, prevIx, curIxMasked, maxLen);
+			if (len >= 4) {
+				const distCost = baseCost + model.getDistanceCost(j);
+				for (let l = bestLen + 1; l <= len; l++) {
+					const copyCode = getCopyLengthCode(l);
+					const cmdCode = combineLengthCodes(insCode, copyCode, j === 0);
+					const cost = (cmdCode < 128 ? baseCost : distCost) + getCopyExtra(copyCode) + model.getCommandCost(cmdCode);
+					if (cost < nodes[pos + l].cost) {
+						updateZopfliNode(nodes, pos, start, l, l, backward, j + 1, cost);
+						result = Math.max(result, l);
+					}
+					bestLen = l;
+				}
+			}
+		}
+		if (k >= 2) continue;
+		let matchLen = minLen;
+		for (let j = 0; j < numMatches; j++) {
+			const match = matches[j];
+			const dist = match.distance;
+			const isDictionaryMatch = dist > maxDistance;
+			const distCode = dist + NUM_DISTANCE_SHORT_CODES - 1;
+			const distCost = baseCost + (distCode < NUM_DISTANCE_SHORT_CODES ? 0 : log2FloorNonZero(dist) - 1) + model.getDistanceCost(distCode & 1023);
+			let maxMatchLen = backwardMatchLength(match);
+			if (matchLen < maxMatchLen && (isDictionaryMatch || maxMatchLen > maxZopfliLenVal)) matchLen = maxMatchLen;
+			for (; matchLen <= maxMatchLen; matchLen++) {
+				const lenCode = isDictionaryMatch ? match.length + match.lenCodeDelta : matchLen;
+				const copyCode = getCopyLengthCode(lenCode);
+				const cmdCode = combineLengthCodes(insCode, copyCode, false);
+				const cost = distCost + getCopyExtra(copyCode) + model.getCommandCost(cmdCode);
+				if (cost < nodes[pos + matchLen].cost) {
+					updateZopfliNode(nodes, pos, start, matchLen, lenCode, dist, 0, cost);
+					result = Math.max(result, matchLen);
+				}
+			}
+		}
+	}
+	return result;
+}
+function computeShortestPathFromNodes(numBytes, nodes) {
+	let index = numBytes;
+	let numCommands = 0;
+	while ((nodes[index].dcodeInsertLength & 134217727) === 0 && nodes[index].length === 1) index--;
+	nodes[index].cost = 4294967295;
+	while (index !== 0) {
+		const len = zopfliNodeCommandLength(nodes[index]);
+		index -= len;
+		nodes[index].cost = len;
+		numCommands++;
+	}
+	return numCommands;
+}
+function createZopfliBackwardReferences(numBytes, position, ringbuffer, ringbufferMask, quality, hasher, distCache, lastInsertLen) {
+	const maxBackwardLimit = (1 << 22) - 16;
+	const maxZopfliLenVal = maxZopfliLen(quality);
+	const nodes = createZopfliNodes(numBytes + 1);
+	nodes[0].length = 0;
+	nodes[0].cost = 0;
+	const model = new ZopfliCostModel(numBytes, 544);
+	model.setFromLiteralCosts(position, ringbuffer, ringbufferMask);
+	const queue = new StartPosQueue();
+	for (let i = 0; i + 3 < numBytes; i++) {
+		const pos = position + i;
+		const maxDistance = Math.min(pos, maxBackwardLimit);
+		const matches = hasher.findAllMatches(ringbuffer, ringbufferMask, pos, numBytes - i, maxDistance);
+		if (matches.length > 0) {
+			const longestMatch = matches[matches.length - 1];
+			if (backwardMatchLength(longestMatch) > maxZopfliLenVal) {
+				matches.length = 0;
+				matches.push(longestMatch);
+			}
+		}
+		const skip = updateNodes(numBytes, position, i, ringbuffer, ringbufferMask, quality, maxBackwardLimit, distCache, matches.length, matches, model, queue, nodes);
+		if (skip >= LONG_COPY_QUICK_STEP) i += skip - 1;
+		else if (matches.length === 1 && backwardMatchLength(matches[0]) > maxZopfliLenVal) i += backwardMatchLength(matches[0]) - 1;
+	}
+	computeShortestPathFromNodes(numBytes, nodes);
+	return createCommandsFromPath(numBytes, position, nodes, distCache, lastInsertLen);
+}
+function createHqZopfliBackwardReferences(numBytes, position, ringbuffer, ringbufferMask, hasher, distCache, lastInsertLen) {
+	const quality = 11;
+	const maxBackwardLimit = (1 << 22) - 16;
+	const maxZopfliLenVal = maxZopfliLen(quality);
+	const allMatches = [];
+	const numMatchesPerPos = [];
+	for (let i = 0; i + 3 < numBytes; i++) {
+		const pos = position + i;
+		const maxDistance = Math.min(pos, maxBackwardLimit);
+		const matches = hasher.findAllMatches(ringbuffer, ringbufferMask, pos, numBytes - i, maxDistance);
+		if (matches.length > 0) {
+			const longestMatch = matches[matches.length - 1];
+			if (backwardMatchLength(longestMatch) > maxZopfliLenVal) {
+				const skip = backwardMatchLength(longestMatch) - 1;
+				allMatches.push([longestMatch]);
+				numMatchesPerPos.push(1);
+				for (let j = 0; j < skip && i + j + 1 < numBytes; j++) {
+					allMatches.push([]);
+					numMatchesPerPos.push(0);
+				}
+				i += skip;
+				continue;
+			}
+		}
+		allMatches.push(matches);
+		numMatchesPerPos.push(matches.length);
+	}
+	while (allMatches.length < numBytes) {
+		allMatches.push([]);
+		numMatchesPerPos.push(0);
+	}
+	const origDistCache = distCache.slice();
+	const origLastInsertLen = lastInsertLen;
+	const model = new ZopfliCostModel(numBytes, 544);
+	let commands = [];
+	let numLiterals = 0;
+	let finalLastInsertLen = lastInsertLen;
+	for (let iteration = 0; iteration < 2; iteration++) {
+		const nodes = createZopfliNodes(numBytes + 1);
+		nodes[0].length = 0;
+		nodes[0].cost = 0;
+		distCache.set(origDistCache);
+		lastInsertLen = origLastInsertLen;
+		if (iteration === 0) model.setFromLiteralCosts(position, ringbuffer, ringbufferMask);
+		else model.setFromCommands(position, ringbuffer, ringbufferMask, commands, origLastInsertLen);
+		const queue = new StartPosQueue();
+		for (let i = 0; i + 3 < numBytes; i++) {
+			const numMatches = numMatchesPerPos[i];
+			const matches = allMatches[i];
+			const skip = updateNodes(numBytes, position, i, ringbuffer, ringbufferMask, quality, maxBackwardLimit, distCache, numMatches, matches, model, queue, nodes);
+			if (skip >= LONG_COPY_QUICK_STEP) i += skip - 1;
+			else if (numMatches === 1 && backwardMatchLength(matches[0]) > maxZopfliLenVal) i += backwardMatchLength(matches[0]) - 1;
+		}
+		computeShortestPathFromNodes(numBytes, nodes);
+		[commands, numLiterals, finalLastInsertLen] = createCommandsFromPath(numBytes, position, nodes, distCache, lastInsertLen);
+	}
+	return [
+		commands,
+		numLiterals,
+		finalLastInsertLen
+	];
+}
+function createCommandsFromPath(numBytes, blockStart, nodes, distCache, lastInsertLen) {
+	const maxBackwardLimit = (1 << 22) - 16;
+	const commands = [];
+	let numLiterals = 0;
+	let pos = 0;
+	let offset = nodes[0].cost;
+	let isFirst = true;
+	while (offset !== 4294967295 && offset !== 0) {
+		const next = nodes[pos + offset];
+		const copyLen = zopfliNodeCopyLength(next);
+		let insertLen = zopfliNodeInsertLength(next);
+		pos += insertLen;
+		if (isFirst) {
+			insertLen += lastInsertLen;
+			isFirst = false;
+		}
+		const distance = zopfliNodeCopyDistance(next);
+		const lenCode = zopfliNodeLengthCode(next);
+		const distCode = zopfliNodeDistanceCode(next);
+		const cmd = createCommand(insertLen, copyLen, lenCode - copyLen, distCode);
+		commands.push(cmd);
+		if (!(distance > Math.min(blockStart + pos, maxBackwardLimit)) && distCode > 0) {
+			distCache[3] = distCache[2];
+			distCache[2] = distCache[1];
+			distCache[1] = distCache[0];
+			distCache[0] = distance;
+		}
+		numLiterals += insertLen;
+		pos += copyLen;
+		offset = next.cost;
+	}
+	const finalInsertLen = numBytes - pos;
+	return [
+		commands,
+		numLiterals,
+		finalInsertLen
+	];
+}
+
+//#endregion
+//#region src/encode/histogram.ts
+const NUM_DISTANCE_HISTOGRAM_SYMBOLS = 544;
+function createHistogramLiteral() {
+	return {
+		data: new Uint32Array(NUM_LITERAL_CODES),
+		totalCount: 0,
+		bitCost: Infinity
+	};
+}
+function createHistogramCommand() {
+	return {
+		data: new Uint32Array(NUM_COMMAND_CODES),
+		totalCount: 0,
+		bitCost: Infinity
+	};
+}
+function createHistogramDistance() {
+	return {
+		data: new Uint32Array(NUM_DISTANCE_HISTOGRAM_SYMBOLS),
+		totalCount: 0,
+		bitCost: Infinity
+	};
+}
+function histogramAdd(histogram, symbol) {
+	histogram.data[symbol]++;
+	histogram.totalCount++;
+}
+
+//#endregion
+//#region src/encode/entropy-encode.ts
+const MAX_HUFFMAN_BITS = 15;
+const SHELL_GAPS = [
+	132,
+	57,
+	23,
+	10,
+	4,
+	1
+];
+function createHuffmanTree(histogram, treeLimit = MAX_HUFFMAN_BITS) {
+	const length = histogram.length;
+	const depths = new Uint8Array(length);
+	const bits = new Uint16Array(length);
+	let nonZeroCount = 0;
+	let lastNonZero = 0;
+	for (let i = 0; i < length; i++) if (histogram[i] > 0) {
+		nonZeroCount++;
+		lastNonZero = i;
+	}
+	if (nonZeroCount === 0) return {
+		depths,
+		bits
+	};
+	if (nonZeroCount === 1) {
+		depths[lastNonZero] = 1;
+		bits[lastNonZero] = 0;
+		return {
+			depths,
+			bits
+		};
+	}
+	const tree = new Array(2 * length + 2);
+	for (let countLimit = 1;; countLimit *= 2) {
+		let n = 0;
+		for (let i = length - 1; i >= 0; i--) if (histogram[i] > 0) {
+			const count = Math.max(histogram[i], countLimit);
+			tree[n++] = {
+				totalCount: count,
+				indexLeft: -1,
+				indexRightOrValue: i
+			};
+		}
+		sortHuffmanNodes(tree, n);
+		const sentinel = {
+			totalCount: 4294967295,
+			indexLeft: -1,
+			indexRightOrValue: -1
+		};
+		tree[n] = sentinel;
+		tree[n + 1] = sentinel;
+		let i = 0;
+		let j = n + 1;
+		for (let k = n - 1; k > 0; k--) {
+			let left;
+			if (tree[i].totalCount <= tree[j].totalCount) left = i++;
+			else left = j++;
+			let right;
+			if (tree[i].totalCount <= tree[j].totalCount) right = i++;
+			else right = j++;
+			const jEnd = 2 * n - k;
+			tree[jEnd] = {
+				totalCount: tree[left].totalCount + tree[right].totalCount,
+				indexLeft: left,
+				indexRightOrValue: right
+			};
+			tree[jEnd + 1] = sentinel;
+		}
+		if (setDepth(2 * n - 1, tree, depths, treeLimit)) break;
+		depths.fill(0);
+	}
+	convertBitDepthsToSymbols(depths, bits);
+	return {
+		depths,
+		bits
+	};
+}
+function setDepth(root, tree, depths, maxDepth) {
+	const stack = new Int32Array(16);
+	let level = 0;
+	let p = root;
+	stack[0] = -1;
+	while (true) {
+		if (tree[p].indexLeft >= 0) {
+			level++;
+			if (level > maxDepth) return false;
+			stack[level] = tree[p].indexRightOrValue;
+			p = tree[p].indexLeft;
+			continue;
+		} else depths[tree[p].indexRightOrValue] = level;
+		while (level >= 0 && stack[level] === -1) level--;
+		if (level < 0) return true;
+		p = stack[level];
+		stack[level] = -1;
+	}
+}
+function sortHuffmanNodes(nodes, n) {
+	if (n < 13) for (let i = 1; i < n; i++) {
+		const tmp = nodes[i];
+		let k = i;
+		let j = i - 1;
+		while (j >= 0 && compareNodes(tmp, nodes[j])) {
+			nodes[k] = nodes[j];
+			k = j;
+			j--;
+		}
+		nodes[k] = tmp;
+	}
+	else {
+		const startGap = n < 57 ? 2 : 0;
+		for (let g = startGap; g < 6; g++) {
+			const gap = SHELL_GAPS[g];
+			for (let i = gap; i < n; i++) {
+				let j = i;
+				const tmp = nodes[i];
+				while (j >= gap && compareNodes(tmp, nodes[j - gap])) {
+					nodes[j] = nodes[j - gap];
+					j -= gap;
+				}
+				nodes[j] = tmp;
+			}
+		}
+	}
+}
+function compareNodes(a, b) {
+	if (a.totalCount !== b.totalCount) return a.totalCount < b.totalCount;
+	return a.indexRightOrValue > b.indexRightOrValue;
+}
+function reverseBits(numBits, bits) {
+	const LUT = [
+		0,
+		8,
+		4,
+		12,
+		2,
+		10,
+		6,
+		14,
+		1,
+		9,
+		5,
+		13,
+		3,
+		11,
+		7,
+		15
+	];
+	let retval = LUT[bits & 15];
+	for (let i = 4; i < numBits; i += 4) {
+		retval <<= 4;
+		bits >>>= 4;
+		retval |= LUT[bits & 15];
+	}
+	retval >>>= -numBits & 3;
+	return retval;
+}
+function convertBitDepthsToSymbols(depths, bits) {
+	const len = depths.length;
+	const blCount = new Uint16Array(MAX_HUFFMAN_BITS + 1);
+	const nextCode = new Uint16Array(MAX_HUFFMAN_BITS + 1);
+	for (let i = 0; i < len; i++) blCount[depths[i]]++;
+	blCount[0] = 0;
+	let code = 0;
+	for (let i = 1; i <= MAX_HUFFMAN_BITS; i++) {
+		code = code + blCount[i - 1] << 1;
+		nextCode[i] = code;
+	}
+	for (let i = 0; i < len; i++) if (depths[i] > 0) bits[i] = reverseBits(depths[i], nextCode[depths[i]]++);
+}
+
+//#endregion
+//#region src/encode/context-map.ts
+function buildAndStoreHuffmanTree(writer, histogram, alphabetSize, depths, bits) {
+	let count = 0;
+	const s4 = [
+		0,
+		0,
+		0,
+		0
+	];
+	for (let i = 0; i < alphabetSize; i++) if (histogram[i]) {
+		if (count < 4) s4[count] = i;
+		count++;
+	}
+	let maxBits = 0;
+	let maxBitsCounter = alphabetSize - 1;
+	while (maxBitsCounter) {
+		maxBitsCounter >>>= 1;
+		maxBits++;
+	}
+	if (count <= 1) {
+		writer.writeBits(4, 1);
+		writer.writeBits(maxBits, s4[0]);
+		depths[s4[0]] = 0;
+		bits[s4[0]] = 0;
+		return;
+	}
+	depths.fill(0);
+	const tree = createHuffmanTree(histogram.subarray(0, alphabetSize), 15);
+	depths.set(tree.depths.subarray(0, alphabetSize));
+	convertBitDepthsToSymbols(depths, bits);
+	if (count <= 4) storeSimpleHuffmanTree(writer, depths, s4, count, maxBits);
+	else storeComplexHuffmanTree(writer, depths, alphabetSize);
+}
+function storeSimpleHuffmanTree(writer, depths, symbols, numSymbols, maxBits) {
+	const sorted = symbols.slice(0, numSymbols);
+	sorted.sort((a, b) => depths[a] - depths[b]);
+	writer.writeBits(2, 1);
+	writer.writeBits(2, numSymbols - 1);
+	for (let i = 0; i < numSymbols; i++) writer.writeBits(maxBits, sorted[i]);
+	if (numSymbols === 4) writer.writeBits(1, depths[sorted[0]] === 1 ? 1 : 0);
+}
+function storeComplexHuffmanTree(writer, depths, length) {
+	const huffmanTree = [];
+	const huffmanTreeExtraBits = [];
+	writeHuffmanTreeRepresentation(depths, length, huffmanTree, huffmanTreeExtraBits);
+	const codeLengthHistogram = new Uint32Array(18);
+	for (const code of huffmanTree) codeLengthHistogram[code]++;
+	let numCodes = 0;
+	let firstCode = 0;
+	for (let i = 0; i < 18; i++) if (codeLengthHistogram[i]) {
+		if (numCodes === 0) firstCode = i;
+		numCodes++;
+	}
+	const codeLengthDepths = new Uint8Array(18);
+	const codeLengthBits = new Uint16Array(18);
+	const tree = createHuffmanTree(codeLengthHistogram, 5);
+	codeLengthDepths.set(tree.depths.subarray(0, 18));
+	convertBitDepthsToSymbols(codeLengthDepths, codeLengthBits);
+	storeHuffmanTreeOfHuffmanTree(writer, numCodes, codeLengthDepths);
+	if (numCodes === 1) codeLengthDepths[firstCode] = 0;
+	for (let i = 0; i < huffmanTree.length; i++) {
+		const code = huffmanTree[i];
+		writer.writeBits(codeLengthDepths[code], codeLengthBits[code]);
+		if (code === 16) writer.writeBits(2, huffmanTreeExtraBits[i]);
+		else if (code === 17) writer.writeBits(3, huffmanTreeExtraBits[i]);
+	}
+}
+function writeHuffmanTreeRepresentation(depths, length, tree, extraBits) {
+	const INITIAL_PREV = 8;
+	let newLength = length;
+	while (newLength > 0 && depths[newLength - 1] === 0) newLength--;
+	let prevValue = INITIAL_PREV;
+	let i = 0;
+	while (i < newLength) {
+		const value = depths[i];
+		let reps = 1;
+		while (i + reps < newLength && depths[i + reps] === value) reps++;
+		i += reps;
+		if (value === 0) writeHuffmanTreeRepetitionsZeros(reps, tree, extraBits);
+		else {
+			writeHuffmanTreeRepetitions(prevValue, value, reps, tree, extraBits);
+			prevValue = value;
+		}
+	}
+}
+function writeHuffmanTreeRepetitions(prevValue, value, reps, tree, extraBits) {
+	const REPEAT_PREVIOUS = 16;
+	if (prevValue !== value) {
+		tree.push(value);
+		extraBits.push(0);
+		reps--;
+	}
+	if (reps === 7) {
+		tree.push(value);
+		extraBits.push(0);
+		reps--;
+	}
+	if (reps < 3) for (let j = 0; j < reps; j++) {
+		tree.push(value);
+		extraBits.push(0);
+	}
+	else {
+		const startIdx = tree.length;
+		reps -= 3;
+		while (true) {
+			tree.push(REPEAT_PREVIOUS);
+			extraBits.push(reps & 3);
+			reps >>>= 2;
+			if (reps === 0) break;
+			reps--;
+		}
+		reverseArraySlice(tree, startIdx, tree.length);
+		reverseArraySlice(extraBits, startIdx, extraBits.length);
+	}
+}
+function writeHuffmanTreeRepetitionsZeros(reps, tree, extraBits) {
+	const REPEAT_ZERO = 17;
+	if (reps === 11) {
+		tree.push(0);
+		extraBits.push(0);
+		reps--;
+	}
+	if (reps < 3) for (let j = 0; j < reps; j++) {
+		tree.push(0);
+		extraBits.push(0);
+	}
+	else {
+		const startIdx = tree.length;
+		reps -= 3;
+		while (true) {
+			tree.push(REPEAT_ZERO);
+			extraBits.push(reps & 7);
+			reps >>>= 3;
+			if (reps === 0) break;
+			reps--;
+		}
+		reverseArraySlice(tree, startIdx, tree.length);
+		reverseArraySlice(extraBits, startIdx, extraBits.length);
+	}
+}
+function reverseArraySlice(arr, start, end) {
+	while (start < end - 1) {
+		const tmp = arr[start];
+		arr[start] = arr[end - 1];
+		arr[end - 1] = tmp;
+		start++;
+		end--;
+	}
+}
+function storeHuffmanTreeOfHuffmanTree(writer, numCodes, depths) {
+	const storageOrder = [
+		1,
+		2,
+		3,
+		4,
+		0,
+		5,
+		17,
+		6,
+		16,
+		7,
+		8,
+		9,
+		10,
+		11,
+		12,
+		13,
+		14,
+		15
+	];
+	const symbols = [
+		0,
+		7,
+		3,
+		2,
+		1,
+		15
+	];
+	const bitLengths = [
+		2,
+		4,
+		3,
+		2,
+		2,
+		4
+	];
+	let codesToStore = 18;
+	if (numCodes > 1) while (codesToStore > 0 && depths[storageOrder[codesToStore - 1]] === 0) codesToStore--;
+	let skipSome = 0;
+	if (depths[storageOrder[0]] === 0 && depths[storageOrder[1]] === 0) {
+		skipSome = 2;
+		if (depths[storageOrder[2]] === 0) skipSome = 3;
+	}
+	writer.writeBits(2, skipSome);
+	for (let i = skipSome; i < codesToStore; i++) {
+		const len = depths[storageOrder[i]];
+		writer.writeBits(bitLengths[len], symbols[len]);
+	}
+}
+
+//#endregion
+//#region src/encode/metablock.ts
+function encodeMlen(length) {
+	const lg = length === 1 ? 1 : log2FloorNonZero(length - 1) + 1;
+	const mnibbles = Math.floor((lg < 16 ? 16 : lg + 3) / 4);
+	return {
+		bits: BigInt(length - 1),
+		numBits: mnibbles * 4,
+		nibblesBits: mnibbles - 4
+	};
+}
+function storeCompressedMetaBlockHeader(writer, isLast, length) {
+	writer.writeBits(1, isLast ? 1 : 0);
+	if (isLast) writer.writeBits(1, 0);
+	const { bits, numBits, nibblesBits } = encodeMlen(length);
+	writer.writeBits(2, nibblesBits);
+	writer.writeBitsLong(numBits, bits);
+	if (!isLast) writer.writeBits(1, 0);
+}
+function storeUncompressedMetaBlockHeader(writer, length) {
+	writer.writeBits(1, 0);
+	const { bits, numBits, nibblesBits } = encodeMlen(length);
+	writer.writeBits(2, nibblesBits);
+	writer.writeBitsLong(numBits, bits);
+	writer.writeBits(1, 1);
+}
+function storeCommandExtra(writer, cmd) {
+	const copyLenCode = commandCopyLenCode(cmd);
+	const insCode = getInsertLengthCode(cmd.insertLen);
+	const copyCode = getCopyLengthCode(copyLenCode);
+	const insNumExtra = getInsertExtra(insCode);
+	const insExtraVal = cmd.insertLen - getInsertBase(insCode);
+	const copyExtraVal = copyLenCode - getCopyBase(copyCode);
+	const totalBits = insNumExtra + getCopyExtra(copyCode);
+	const combinedBits = copyExtraVal << insNumExtra | insExtraVal;
+	writer.writeBits(totalBits, combinedBits);
+}
+function storeMetaBlockTrivial(writer, input, startPos, length, mask, isLast, commands, distanceAlphabetSize) {
+	storeCompressedMetaBlockHeader(writer, isLast, length);
+	const litHisto = createHistogramLiteral();
+	const cmdHisto = createHistogramCommand();
+	const distHisto = createHistogramDistance();
+	let pos = startPos;
+	for (const cmd of commands) {
+		histogramAdd(cmdHisto, cmd.cmdPrefix);
+		for (let j = 0; j < cmd.insertLen; j++) histogramAdd(litHisto, input[pos + j & mask]);
+		pos += cmd.insertLen;
+		const copyLen = commandCopyLen(cmd);
+		pos += copyLen;
+		if (copyLen && cmd.cmdPrefix >= 128) histogramAdd(distHisto, cmd.distPrefix & 1023);
+	}
+	writer.writeBits(13, 0);
+	const litDepths = new Uint8Array(NUM_LITERAL_CODES);
+	const litBits = new Uint16Array(NUM_LITERAL_CODES);
+	const cmdDepths = new Uint8Array(NUM_COMMAND_CODES);
+	const cmdBits = new Uint16Array(NUM_COMMAND_CODES);
+	const distDepths = new Uint8Array(distanceAlphabetSize);
+	const distBits = new Uint16Array(distanceAlphabetSize);
+	buildAndStoreHuffmanTree(writer, litHisto.data, NUM_LITERAL_CODES, litDepths, litBits);
+	buildAndStoreHuffmanTree(writer, cmdHisto.data, NUM_COMMAND_CODES, cmdDepths, cmdBits);
+	buildAndStoreHuffmanTree(writer, distHisto.data, distanceAlphabetSize, distDepths, distBits);
+	pos = startPos;
+	for (const cmd of commands) {
+		writer.writeBits(cmdDepths[cmd.cmdPrefix], cmdBits[cmd.cmdPrefix]);
+		storeCommandExtra(writer, cmd);
+		for (let j = 0; j < cmd.insertLen; j++) {
+			const literal = input[pos + j & mask];
+			writer.writeBits(litDepths[literal], litBits[literal]);
+		}
+		pos += cmd.insertLen;
+		const copyLen = commandCopyLen(cmd);
+		pos += copyLen;
+		if (copyLen && cmd.cmdPrefix >= 128) {
+			const distCode = cmd.distPrefix & 1023;
+			const distNumExtra = cmd.distPrefix >>> 10;
+			const distExtra = cmd.distExtra;
+			writer.writeBits(distDepths[distCode], distBits[distCode]);
+			writer.writeBits(distNumExtra, distExtra);
+		}
+	}
+	if (isLast) writer.alignToByte();
+}
+function storeUncompressedMetaBlock(writer, input, position, mask, length, isFinal) {
+	storeUncompressedMetaBlockHeader(writer, length);
+	writer.alignToByte();
+	let maskedPos = position & mask;
+	if (maskedPos + length > mask + 1) {
+		const len1 = mask + 1 - maskedPos;
+		writer.writeBytes(input.subarray(maskedPos, maskedPos + len1));
+		length -= len1;
+		maskedPos = 0;
+	}
+	writer.writeBytes(input.subarray(maskedPos, maskedPos + length));
+	writer.prepareStorage();
+	if (isFinal) {
+		writer.writeBits(1, 1);
+		writer.writeBits(1, 1);
+		writer.alignToByte();
+	}
+}
+
+//#endregion
+//#region src/encode/encode.ts
+function brotliEncode(input, options = {}) {
+	const params = createDefaultParams();
+	if (options.quality !== void 0) params.quality = Math.max(0, Math.min(11, options.quality));
+	if (options.lgwin !== void 0) params.lgwin = Math.max(10, Math.min(24, options.lgwin));
+	if (options.mode !== void 0) params.mode = options.mode;
+	if (options.sizeHint !== void 0) params.sizeHint = options.sizeHint;
+	sanitizeParams(params);
+	params.lgblock = computeLgBlock(params);
+	if (input.length === 0) return encodeEmptyInput();
+	if (params.quality === 0 || input.length < 64) return encodeUncompressed(input);
+	if (params.quality === 1) return encodeFast(input, params);
+	return encodeStandard(input, params);
+}
+function encodeEmptyInput() {
+	const writer = new BitWriter(16);
+	const windowBits = encodeWindowBits(10, false);
+	writer.writeBits(windowBits.bits, windowBits.value);
+	writer.writeBits(1, 1);
+	writer.writeBits(1, 1);
+	writer.alignToByte();
+	return writer.finish();
+}
+function encodeUncompressed(input) {
+	const writer = new BitWriter(input.length + 32);
+	const windowBits = encodeWindowBits(Math.max(10, Math.min(24, input.length <= 1 ? 10 : Math.ceil(Math.log2(input.length)) + 1)), false);
+	writer.writeBits(windowBits.bits, windowBits.value);
+	const maxBlockSize = (1 << 24) - 1;
+	let pos = 0;
+	while (pos < input.length) {
+		const blockSize = Math.min(input.length - pos, maxBlockSize);
+		if (pos + blockSize >= input.length) storeUncompressedMetaBlock(writer, input, pos, input.length - 1, blockSize, true);
+		else storeUncompressedMetaBlock(writer, input, pos, input.length - 1, blockSize, false);
+		pos += blockSize;
+	}
+	return writer.finish();
+}
+function encodeFast(input, params) {
+	const writer = new BitWriter(input.length);
+	const windowBits = encodeWindowBits(params.lgwin, false);
+	writer.writeBits(windowBits.bits, windowBits.value);
+	const hasher = createSimpleHasher(params.quality, params.lgwin);
+	const distCache = new Int32Array([
+		4,
+		11,
+		15,
+		16
+	]);
+	const ringBufferMask = (1 << params.lgwin) - 1;
+	const blockSize = 1 << params.lgblock;
+	let pos = 0;
+	while (pos < input.length) {
+		const blockLen = Math.min(input.length - pos, blockSize);
+		const isLast = pos + blockLen >= input.length;
+		const [commands] = createBackwardReferences(blockLen, pos, input, ringBufferMask, hasher, distCache, 0, params.quality);
+		const distAlphabetSize = 16 + (48 << params.dist.distancePostfixBits);
+		storeMetaBlockTrivial(writer, input, pos, blockLen, ringBufferMask, isLast, commands, distAlphabetSize);
+		pos += blockLen;
+	}
+	return writer.finish();
+}
+function encodeStandard(input, params) {
+	const writer = new BitWriter(Math.max(1024, Math.floor(input.length * 1.2)));
+	const windowBits = encodeWindowBits(params.lgwin, params.largeWindow);
+	writer.writeBits(windowBits.bits, windowBits.value);
+	let hasher;
+	if (params.quality <= 4) hasher = createSimpleHasher(params.quality, params.lgwin);
+	else if (params.quality <= 9) hasher = createHashChainHasher(params.quality, params.lgwin);
+	else hasher = createBinaryTreeHasher(params.lgwin, input.length);
+	const distCache = new Int32Array([
+		4,
+		11,
+		15,
+		16
+	]);
+	const ringBufferMask = (1 << params.lgwin) - 1;
+	const maxMetablockSize = 1 << 24;
+	let pos = 0;
+	while (pos < input.length) {
+		const metablockLen = Math.min(input.length - pos, maxMetablockSize);
+		const isLast = pos + metablockLen >= input.length;
+		let commands;
+		let lastInsertLen = 0;
+		if (params.quality >= HQ_ZOPFLIFICATION_QUALITY && hasher instanceof BinaryTreeHasher) [commands, , lastInsertLen] = createHqZopfliBackwardReferences(metablockLen, pos, input, ringBufferMask, hasher, distCache, 0);
+		else if (params.quality >= ZOPFLIFICATION_QUALITY && hasher instanceof BinaryTreeHasher) [commands, , lastInsertLen] = createZopfliBackwardReferences(metablockLen, pos, input, ringBufferMask, params.quality, hasher, distCache, 0);
+		else if (hasher instanceof HashChainHasher) [commands, , lastInsertLen] = createBackwardReferences(metablockLen, pos, input, ringBufferMask, hasher, distCache, 0, params.quality);
+		else if (hasher instanceof SimpleHasher) [commands, , lastInsertLen] = createBackwardReferences(metablockLen, pos, input, ringBufferMask, hasher, distCache, 0, params.quality);
+		else commands = [createInsertCommand(metablockLen)];
+		if (lastInsertLen > 0) if (commands.length === 0) commands = [createInsertCommand(metablockLen)];
+		else {
+			const lastCmd = commands[commands.length - 1];
+			if (commandCopyLen(lastCmd) === 0) lastCmd.insertLen += lastInsertLen;
+			else commands.push(createInsertCommand(lastInsertLen));
+		}
+		else if (commands.length === 0) commands = [createInsertCommand(metablockLen)];
+		const distAlphabetSize = calculateDistanceAlphabetSize(params);
+		storeMetaBlockTrivial(writer, input, pos, metablockLen, ringBufferMask, isLast, commands, distAlphabetSize);
+		pos += metablockLen;
+	}
+	return writer.finish();
+}
+function calculateDistanceAlphabetSize(params) {
+	const npostfix = params.dist.distancePostfixBits;
+	return 16 + params.dist.numDirectDistanceCodes + (48 << npostfix);
+}
+var BrotliEncoder = class {
+	constructor(options = {}) {
+		const params = createDefaultParams();
+		if (options.quality !== void 0) params.quality = Math.max(0, Math.min(11, options.quality));
+		if (options.lgwin !== void 0) params.lgwin = Math.max(10, Math.min(24, options.lgwin));
+		if (options.mode !== void 0) params.mode = options.mode;
+		if (options.sizeHint !== void 0) params.sizeHint = options.sizeHint;
+		sanitizeParams(params);
+		params.lgblock = computeLgBlock(params);
+		const ringBufferSize = 1 << params.lgwin;
+		this.state = {
+			params,
+			hasher: null,
+			distCache: new Int32Array([
+				4,
+				11,
+				15,
+				16
+			]),
+			lastInsertLen: 0,
+			commands: [],
+			numLiterals: 0,
+			inputPos: 0,
+			lastProcessedPos: 0,
+			ringBuffer: new Uint8Array(ringBufferSize),
+			ringBufferMask: ringBufferSize - 1,
+			prevByte: 0,
+			prevByte2: 0,
+			isInitialized: false,
+			isLastBlockEmitted: false,
+			writer: new BitWriter()
+		};
+	}
+	initialize() {
+		if (this.state.isInitialized) return;
+		const { params, writer } = this.state;
+		const windowBits = encodeWindowBits(params.lgwin, params.largeWindow);
+		writer.writeBits(windowBits.bits, windowBits.value);
+		if (params.quality <= 4) this.state.hasher = createSimpleHasher(params.quality, params.lgwin);
+		else if (params.quality <= 9) this.state.hasher = createHashChainHasher(params.quality, params.lgwin);
+		else this.state.hasher = createBinaryTreeHasher(params.lgwin);
+		this.state.isInitialized = true;
+	}
+	update(input) {
+		this.initialize();
+		const { ringBuffer, ringBufferMask } = this.state;
+		for (let i = 0; i < input.length; i++) ringBuffer[this.state.inputPos + i & ringBufferMask] = input[i];
+		this.state.inputPos += input.length;
+		const blockSize = 1 << this.state.params.lgblock;
+		const output = [];
+		while (this.state.inputPos - this.state.lastProcessedPos >= blockSize) {
+			const chunk = this.processBlock(blockSize, false);
+			if (chunk.length > 0) output.push(chunk);
+		}
+		if (output.length === 0) return new Uint8Array(0);
+		if (output.length === 1) return output[0];
+		const totalLen = output.reduce((sum, arr) => sum + arr.length, 0);
+		const result = new Uint8Array(totalLen);
+		let offset = 0;
+		for (const chunk of output) {
+			result.set(chunk, offset);
+			offset += chunk.length;
+		}
+		return result;
+	}
+	finish() {
+		this.initialize();
+		const remaining = this.state.inputPos - this.state.lastProcessedPos;
+		if (remaining > 0) return this.processBlock(remaining, true);
+		if (!this.state.isLastBlockEmitted) {
+			const { writer } = this.state;
+			writer.writeBits(1, 1);
+			writer.writeBits(1, 1);
+			writer.alignToByte();
+			this.state.isLastBlockEmitted = true;
+		}
+		return this.state.writer.takeBytes();
+	}
+	processBlock(blockLen, isLast) {
+		const { params, ringBuffer, ringBufferMask, distCache, hasher, writer } = this.state;
+		const pos = this.state.lastProcessedPos;
+		if (!hasher) throw new Error("Encoder not initialized");
+		let commands;
+		let numLiterals;
+		let lastInsertLen;
+		if (hasher instanceof SimpleHasher || hasher instanceof HashChainHasher) [commands, numLiterals, lastInsertLen] = createBackwardReferences(blockLen, pos, ringBuffer, ringBufferMask, hasher, distCache, this.state.lastInsertLen, params.quality);
+		else if (hasher instanceof BinaryTreeHasher) if (params.quality >= HQ_ZOPFLIFICATION_QUALITY) [commands, numLiterals, lastInsertLen] = createHqZopfliBackwardReferences(blockLen, pos, ringBuffer, ringBufferMask, hasher, distCache, this.state.lastInsertLen);
+		else [commands, numLiterals, lastInsertLen] = createZopfliBackwardReferences(blockLen, pos, ringBuffer, ringBufferMask, params.quality, hasher, distCache, this.state.lastInsertLen);
+		else {
+			commands = [createInsertCommand(blockLen)];
+			numLiterals = blockLen;
+			lastInsertLen = 0;
+		}
+		if (lastInsertLen > 0) if (commands.length === 0) commands = [createInsertCommand(blockLen)];
+		else {
+			const lastCmd = commands[commands.length - 1];
+			if (commandCopyLen(lastCmd) === 0) lastCmd.insertLen += lastInsertLen;
+			else commands.push(createInsertCommand(lastInsertLen));
+		}
+		else if (commands.length === 0) commands = [createInsertCommand(blockLen)];
+		const distAlphabetSize = calculateDistanceAlphabetSize(params);
+		storeMetaBlockTrivial(writer, ringBuffer, pos, blockLen, ringBufferMask, isLast, commands, distAlphabetSize);
+		this.state.lastProcessedPos += blockLen;
+		this.state.lastInsertLen = 0;
+		this.state.numLiterals += numLiterals;
+		if (isLast) this.state.isLastBlockEmitted = true;
+		return writer.takeBytes();
+	}
+};
+
+//#endregion
+export { BrotliEncoder, EncoderMode, brotliDecode, brotliDecodedSize, brotliEncode };