brotli-lib 0.0.1

package/dist/encode.cjs

@@ -0,0 +1,2426 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+//#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
+exports.BrotliEncoder = BrotliEncoder;
+exports.EncoderMode = EncoderMode;
+exports.brotliEncode = brotliEncode;