@gscdump/engine 0.27.2 → 0.28.1

package/dist/_chunks/libs/hyparquet-compressors.mjs

@@ -0,0 +1,2796 @@
+import "./fzstd.mjs";
+import { snappyUncompress } from "hyparquet/src/snappy.js";
+function decode(input, outputLength) {
+	const output = new Uint8Array(outputLength);
+	snappyUncompress(input, output);
+	return output;
+}
+function snappyUncompressor() {
+	return decode;
+}
+function snappyUncompress$1(input, outputLength) {
+	return decode(input, outputLength);
+}
+const BROTLI_READ_SIZE = 4096;
+const BROTLI_IBUF_SIZE = 8224;
+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
+]);
+function BrotliBitReader(input) {
+	this.buf_ = new Uint8Array(BROTLI_IBUF_SIZE);
+	this.input_ = input;
+	this.buf_ptr_ = 0;
+	this.val_ = 0;
+	this.pos_ = 0;
+	this.reset();
+}
+BrotliBitReader.READ_SIZE = BROTLI_READ_SIZE;
+BrotliBitReader.IBUF_MASK = BROTLI_IBUF_MASK;
+BrotliBitReader.prototype.reset = function() {
+	this.buf_ptr_ = 0;
+	this.val_ = 0;
+	this.pos_ = 0;
+	this.bit_pos_ = 0;
+	this.bit_end_pos_ = 0;
+	this.eos_ = 0;
+	this.readMoreInput();
+	for (let i = 0; i < 4; i++) {
+		this.val_ |= this.buf_[this.pos_] << 8 * i;
+		this.pos_++;
+	}
+	return this.bit_end_pos_ > 0;
+};
+BrotliBitReader.prototype.readMoreInput = function() {
+	if (this.bit_end_pos_ > 256) {} else if (this.eos_) {
+		if (this.bit_pos_ > this.bit_end_pos_) throw new Error("Unexpected end of input " + this.bit_pos_ + " " + this.bit_end_pos_);
+	} else {
+		const dst = this.buf_ptr_;
+		const bytes_read = this.input_.read(this.buf_, dst, BROTLI_READ_SIZE);
+		if (bytes_read < 0) throw new Error("Unexpected end of input");
+		if (bytes_read < BROTLI_READ_SIZE) {
+			this.eos_ = 1;
+			for (let p = 0; p < 32; p++) this.buf_[dst + bytes_read + p] = 0;
+		}
+		if (dst === 0) {
+			for (let p = 0; p < 32; p++) this.buf_[(BROTLI_READ_SIZE << 1) + p] = this.buf_[p];
+			this.buf_ptr_ = BROTLI_READ_SIZE;
+		} else this.buf_ptr_ = 0;
+		this.bit_end_pos_ += bytes_read << 3;
+	}
+};
+BrotliBitReader.prototype.fillBitWindow = function() {
+	while (this.bit_pos_ >= 8) {
+		this.val_ >>>= 8;
+		this.val_ |= this.buf_[this.pos_ & BROTLI_IBUF_MASK] << 24;
+		this.pos_++;
+		this.bit_pos_ = this.bit_pos_ - 8 >>> 0;
+		this.bit_end_pos_ = this.bit_end_pos_ - 8 >>> 0;
+	}
+};
+BrotliBitReader.prototype.readBits = function(n_bits) {
+	if (32 - this.bit_pos_ < n_bits) this.fillBitWindow();
+	const val = this.val_ >>> this.bit_pos_ & kBitMask[n_bits];
+	this.bit_pos_ += n_bits;
+	return val;
+};
+const kDefaultCodeLength = 8;
+const HUFFMAN_TABLE_BITS = 8;
+const CODE_LENGTH_CODES = 18;
+const kCodeLengthCodeOrder = new Uint8Array([
+	1,
+	2,
+	3,
+	4,
+	0,
+	5,
+	17,
+	6,
+	16,
+	7,
+	8,
+	9,
+	10,
+	11,
+	12,
+	13,
+	14,
+	15
+]);
+const kMaxHuffmanTableSize = new Uint16Array([
+	256,
+	402,
+	436,
+	468,
+	500,
+	534,
+	566,
+	598,
+	630,
+	662,
+	694,
+	726,
+	758,
+	790,
+	822,
+	854,
+	886,
+	920,
+	952,
+	984,
+	1016,
+	1048,
+	1080
+]);
+function HuffmanCode(bits, value) {
+	this.bits = bits;
+	this.value = value;
+}
+const kCodeLengthRepeatCode = 16;
+const MAX_LENGTH = 15;
+function getNextKey(key, len) {
+	let step = 1 << len - 1;
+	while (key & step) step >>= 1;
+	return (key & step - 1) + step;
+}
+function replicateValue(table, i, step, end, code) {
+	do {
+		end -= step;
+		table[i + end] = new HuffmanCode(code.bits, code.value);
+	} while (end > 0);
+}
+function nextTableBitSize(count, len, root_bits) {
+	let left = 1 << len - root_bits;
+	while (len < MAX_LENGTH) {
+		left -= count[len];
+		if (left <= 0) break;
+		++len;
+		left <<= 1;
+	}
+	return len - root_bits;
+}
+function buildHuffmanTable(root_table, table, root_bits, code_lengths, code_lengths_size) {
+	const start_table = table;
+	const count = new Int32Array(16);
+	const offset = new Int32Array(16);
+	const sorted = new Int32Array(code_lengths_size);
+	for (let i = 0; i < code_lengths_size; i++) count[code_lengths[i]]++;
+	offset[1] = 0;
+	for (let i = 1; i < MAX_LENGTH; i++) offset[i + 1] = offset[i] + count[i];
+	for (let i = 0; i < code_lengths_size; i++) if (code_lengths[i] !== 0) sorted[offset[code_lengths[i]]++] = i;
+	let table_bits = root_bits;
+	let table_size = 1 << table_bits;
+	let total_size = table_size;
+	if (offset[MAX_LENGTH] === 1) {
+		for (let key = 0; key < total_size; ++key) root_table[table + key] = new HuffmanCode(0, sorted[0] & 65535);
+		return total_size;
+	}
+	let key = 0;
+	let symbol = 0;
+	for (let len = 1, step = 2; len <= root_bits; ++len, step <<= 1) for (; count[len] > 0; --count[len]) {
+		const code = new HuffmanCode(len & 255, sorted[symbol++] & 65535);
+		replicateValue(root_table, table + key, step, table_size, code);
+		key = getNextKey(key, len);
+	}
+	const mask = total_size - 1;
+	let low = -1;
+	for (let len = root_bits + 1, step = 2; len <= MAX_LENGTH; ++len, step <<= 1) for (; count[len] > 0; --count[len]) {
+		if ((key & mask) !== low) {
+			table += table_size;
+			table_bits = nextTableBitSize(count, len, root_bits);
+			table_size = 1 << table_bits;
+			total_size += table_size;
+			low = key & mask;
+			root_table[start_table + low] = new HuffmanCode(table_bits + root_bits & 255, table - start_table - low & 65535);
+		}
+		const code = new HuffmanCode(len - root_bits & 255, sorted[symbol++] & 65535);
+		replicateValue(root_table, table + (key >> root_bits), step, table_size, code);
+		key = getNextKey(key, len);
+	}
+	return total_size;
+}
+function readHuffmanCode(alphabet_size, tables, table, br) {
+	const code_lengths = new Uint8Array(alphabet_size);
+	br.readMoreInput();
+	const simple_code_or_skip = br.readBits(2);
+	if (simple_code_or_skip === 1) {
+		let max_bits_counter = alphabet_size - 1;
+		let max_bits = 0;
+		const symbols = new Int32Array(4);
+		const num_symbols = br.readBits(2) + 1;
+		while (max_bits_counter) {
+			max_bits_counter >>= 1;
+			max_bits++;
+		}
+		for (let i = 0; i < num_symbols; i++) {
+			symbols[i] = br.readBits(max_bits) % alphabet_size;
+			code_lengths[symbols[i]] = 2;
+		}
+		code_lengths[symbols[0]] = 1;
+		switch (num_symbols) {
+			case 1: break;
+			case 3:
+				if (symbols[0] === symbols[1] || symbols[0] === symbols[2] || symbols[1] === symbols[2]) throw new Error("[ReadHuffmanCode] invalid symbols");
+				break;
+			case 2:
+				if (symbols[0] === symbols[1]) throw new Error("[ReadHuffmanCode] invalid symbols");
+				code_lengths[symbols[1]] = 1;
+				break;
+			case 4:
+				if (symbols[0] === symbols[1] || symbols[0] === symbols[2] || symbols[0] === symbols[3] || symbols[1] === symbols[2] || symbols[1] === symbols[3] || symbols[2] === symbols[3]) throw new Error("[ReadHuffmanCode] invalid symbols");
+				if (br.readBits(1)) {
+					code_lengths[symbols[2]] = 3;
+					code_lengths[symbols[3]] = 3;
+				} else code_lengths[symbols[0]] = 2;
+				break;
+		}
+	} else {
+		const code_length_code_lengths = new Uint8Array(CODE_LENGTH_CODES);
+		let space = 32;
+		let num_codes = 0;
+		const huff = [
+			new HuffmanCode(2, 0),
+			new HuffmanCode(2, 4),
+			new HuffmanCode(2, 3),
+			new HuffmanCode(3, 2),
+			new HuffmanCode(2, 0),
+			new HuffmanCode(2, 4),
+			new HuffmanCode(2, 3),
+			new HuffmanCode(4, 1),
+			new HuffmanCode(2, 0),
+			new HuffmanCode(2, 4),
+			new HuffmanCode(2, 3),
+			new HuffmanCode(3, 2),
+			new HuffmanCode(2, 0),
+			new HuffmanCode(2, 4),
+			new HuffmanCode(2, 3),
+			new HuffmanCode(4, 5)
+		];
+		for (let i = simple_code_or_skip; i < CODE_LENGTH_CODES && space > 0; i++) {
+			const code_len_idx = kCodeLengthCodeOrder[i];
+			let p = 0;
+			br.fillBitWindow();
+			p += br.val_ >>> br.bit_pos_ & 15;
+			br.bit_pos_ += huff[p].bits;
+			const v = huff[p].value;
+			code_length_code_lengths[code_len_idx] = v;
+			if (v !== 0) {
+				space -= 32 >> v;
+				num_codes++;
+			}
+		}
+		if (!(num_codes === 1 || space === 0)) throw new Error("[ReadHuffmanCode] invalid num_codes or space");
+		readHuffmanCodeLengths(code_length_code_lengths, alphabet_size, code_lengths, br);
+	}
+	const table_size = buildHuffmanTable(tables, table, HUFFMAN_TABLE_BITS, code_lengths, alphabet_size);
+	if (!table_size) throw new Error("brotli BuildHuffmanTable failed");
+	return table_size;
+}
+function readHuffmanCodeLengths(code_length_code_lengths, num_symbols, code_lengths, br) {
+	let symbol = 0;
+	let prev_code_len = kDefaultCodeLength;
+	let repeat = 0;
+	let repeat_code_len = 0;
+	let space = 32768;
+	const table = [];
+	for (let i = 0; i < 32; i++) table.push(new HuffmanCode(0, 0));
+	buildHuffmanTable(table, 0, 5, code_length_code_lengths, CODE_LENGTH_CODES);
+	while (symbol < num_symbols && space > 0) {
+		let p = 0;
+		br.readMoreInput();
+		br.fillBitWindow();
+		p += br.val_ >>> br.bit_pos_ & 31;
+		br.bit_pos_ += table[p].bits;
+		const code_len = table[p].value & 255;
+		if (code_len < kCodeLengthRepeatCode) {
+			repeat = 0;
+			code_lengths[symbol++] = code_len;
+			if (code_len !== 0) {
+				prev_code_len = code_len;
+				space -= 32768 >> code_len;
+			}
+		} else {
+			const extra_bits = code_len - 14;
+			let new_len = 0;
+			if (code_len === kCodeLengthRepeatCode) new_len = prev_code_len;
+			if (repeat_code_len !== new_len) {
+				repeat = 0;
+				repeat_code_len = new_len;
+			}
+			const old_repeat = repeat;
+			if (repeat > 0) {
+				repeat -= 2;
+				repeat <<= extra_bits;
+			}
+			repeat += br.readBits(extra_bits) + 3;
+			const repeat_delta = repeat - old_repeat;
+			if (symbol + repeat_delta > num_symbols) throw new Error("[ReadHuffmanCodeLengths] symbol + repeat_delta > num_symbols");
+			for (let x = 0; x < repeat_delta; x++) code_lengths[symbol + x] = repeat_code_len;
+			symbol += repeat_delta;
+			if (repeat_code_len !== 0) space -= repeat_delta << 15 - repeat_code_len;
+		}
+	}
+	if (space !== 0) throw new Error("[ReadHuffmanCodeLengths] space = " + space);
+	for (; symbol < num_symbols; symbol++) code_lengths[symbol] = 0;
+}
+function HuffmanTreeGroup(alphabet_size, num_htrees) {
+	this.alphabet_size = alphabet_size;
+	this.num_htrees = num_htrees;
+	this.codes = new Array(num_htrees + num_htrees * kMaxHuffmanTableSize[alphabet_size + 31 >>> 5]);
+	this.htrees = new Uint32Array(num_htrees);
+}
+HuffmanTreeGroup.prototype.decode = function(br) {
+	let next = 0;
+	for (let i = 0; i < this.num_htrees; i++) {
+		this.htrees[i] = next;
+		next += readHuffmanCode(this.alphabet_size, this.codes, next, br);
+	}
+};
+function prefix([offset, nbits]) {
+	return {
+		offset,
+		nbits
+	};
+}
+[
+	[1, 2],
+	[5, 2],
+	[9, 2],
+	[13, 2],
+	[17, 3],
+	[25, 3],
+	[33, 3],
+	[41, 3],
+	[49, 4],
+	[65, 4],
+	[81, 4],
+	[97, 4],
+	[113, 5],
+	[145, 5],
+	[177, 5],
+	[209, 5],
+	[241, 6],
+	[305, 6],
+	[369, 7],
+	[497, 8],
+	[753, 9],
+	[1265, 10],
+	[2289, 11],
+	[4337, 12],
+	[8433, 13],
+	[16625, 24]
+].map(prefix);
+[
+	[0, 0],
+	[1, 0],
+	[2, 0],
+	[3, 0],
+	[4, 0],
+	[5, 0],
+	[6, 1],
+	[8, 1],
+	[10, 2],
+	[14, 2],
+	[18, 3],
+	[26, 3],
+	[34, 4],
+	[50, 4],
+	[66, 5],
+	[98, 5],
+	[130, 6],
+	[194, 7],
+	[322, 8],
+	[578, 9],
+	[1090, 10],
+	[2114, 12],
+	[6210, 14],
+	[22594, 24]
+].map(prefix);
+[
+	[2, 0],
+	[3, 0],
+	[4, 0],
+	[5, 0],
+	[6, 0],
+	[7, 0],
+	[8, 0],
+	[9, 0],
+	[10, 1],
+	[12, 1],
+	[14, 2],
+	[18, 2],
+	[22, 3],
+	[30, 3],
+	[38, 4],
+	[54, 4],
+	[70, 5],
+	[102, 5],
+	[134, 6],
+	[198, 7],
+	[326, 8],
+	[582, 9],
+	[1094, 10],
+	[2118, 24]
+].map(prefix);
+const fixedLengthExtraBits = new Uint8Array([
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	1,
+	1,
+	1,
+	1,
+	2,
+	2,
+	2,
+	2,
+	3,
+	3,
+	3,
+	3,
+	4,
+	4,
+	4,
+	4,
+	5,
+	5,
+	5,
+	5,
+	0,
+	0,
+	0,
+	0
+]);
+const fixedDistanceExtraBits = new Uint8Array([
+	0,
+	0,
+	0,
+	0,
+	1,
+	1,
+	2,
+	2,
+	3,
+	3,
+	4,
+	4,
+	5,
+	5,
+	6,
+	6,
+	7,
+	7,
+	8,
+	8,
+	9,
+	9,
+	10,
+	10,
+	11,
+	11,
+	12,
+	12,
+	13,
+	13,
+	0,
+	0
+]);
+function freb(eb, start) {
+	const base = new Uint16Array(31);
+	for (let i = 0; i < 31; i++) base[i] = start += 1 << eb[i - 1];
+	const rev = new Int32Array(base[30]);
+	for (let i = 1; i < 30; i++) for (let j = base[i]; j < base[i + 1]; ++j) rev[j] = j - base[i] << 5 | i;
+	return {
+		base,
+		rev
+	};
+}
+const { base: fixedLength, rev: revfl } = freb(fixedLengthExtraBits, 2);
+fixedLength[28] = 258;
+revfl[258] = 28;
+const { base: fixedDistance } = freb(fixedDistanceExtraBits, 0);
+const rev = new Uint16Array(32768);
+for (let i = 0; i < 32768; i++) {
+	let x = (i & 43690) >> 1 | (i & 21845) << 1;
+	x = (x & 52428) >> 2 | (x & 13107) << 2;
+	x = (x & 61680) >> 4 | (x & 3855) << 4;
+	rev[i] = ((x & 65280) >> 8 | (x & 255) << 8) >> 1;
+}
+function huffMap(cd, maxBits, r) {
+	const l = new Uint16Array(maxBits);
+	for (let i = 0; i < cd.length; i++) if (cd[i]) ++l[cd[i] - 1];
+	const le = new Uint16Array(maxBits);
+	for (let i = 1; i < maxBits; i++) le[i] = le[i - 1] + l[i - 1] << 1;
+	let co;
+	if (r) {
+		co = new Uint16Array(1 << maxBits);
+		const rvb = 15 - maxBits;
+		for (let i = 0; i < cd.length; i++) if (cd[i]) {
+			const sv = i << 4 | cd[i];
+			const freeBits = maxBits - cd[i];
+			let startValue = le[cd[i] - 1]++ << freeBits;
+			for (const endValue = startValue | (1 << freeBits) - 1; startValue <= endValue; startValue++) co[rev[startValue] >> rvb] = sv;
+		}
+	} else {
+		co = new Uint16Array(cd.length);
+		for (let i = 0; i < cd.length; i++) if (cd[i]) co[i] = rev[le[cd[i] - 1]++] >> 15 - cd[i];
+	}
+	return co;
+}
+const fixedLengthTree = new Uint8Array(288);
+for (let i = 0; i < 144; i++) fixedLengthTree[i] = 8;
+for (let i = 144; i < 256; i++) fixedLengthTree[i] = 9;
+for (let i = 256; i < 280; i++) fixedLengthTree[i] = 7;
+for (let i = 280; i < 288; i++) fixedLengthTree[i] = 8;
+const fixedDistanceTree = new Uint8Array(32);
+for (let i = 0; i < 32; i++) fixedDistanceTree[i] = 5;
+const fixedLengthMap = /*#__PURE__*/ huffMap(fixedLengthTree, 9, 1);
+const fixedDistanceMap = /*#__PURE__*/ huffMap(fixedDistanceTree, 5, 1);
+new Uint8Array([
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	4,
+	4,
+	0,
+	0,
+	4,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	8,
+	12,
+	16,
+	12,
+	12,
+	20,
+	12,
+	16,
+	24,
+	28,
+	12,
+	12,
+	32,
+	12,
+	36,
+	12,
+	44,
+	44,
+	44,
+	44,
+	44,
+	44,
+	44,
+	44,
+	44,
+	44,
+	32,
+	32,
+	24,
+	40,
+	28,
+	12,
+	12,
+	48,
+	52,
+	52,
+	52,
+	48,
+	52,
+	52,
+	52,
+	48,
+	52,
+	52,
+	52,
+	52,
+	52,
+	48,
+	52,
+	52,
+	52,
+	52,
+	52,
+	48,
+	52,
+	52,
+	52,
+	52,
+	52,
+	24,
+	12,
+	28,
+	12,
+	12,
+	12,
+	56,
+	60,
+	60,
+	60,
+	56,
+	60,
+	60,
+	60,
+	56,
+	60,
+	60,
+	60,
+	60,
+	60,
+	56,
+	60,
+	60,
+	60,
+	60,
+	60,
+	56,
+	60,
+	60,
+	60,
+	60,
+	60,
+	24,
+	12,
+	28,
+	12,
+	0,
+	0,
+	1,
+	0,
+	1,
+	0,
+	1,
+	0,
+	1,
+	0,
+	1,
+	0,
+	1,
+	0,
+	1,
+	0,
+	1,
+	0,
+	1,
+	0,
+	1,
+	0,
+	1,
+	0,
+	1,
+	0,
+	1,
+	0,
+	1,
+	0,
+	1,
+	0,
+	1,
+	0,
+	1,
+	0,
+	1,
+	0,
+	1,
+	0,
+	1,
+	0,
+	1,
+	0,
+	1,
+	0,
+	1,
+	0,
+	1,
+	0,
+	1,
+	0,
+	1,
+	0,
+	1,
+	0,
+	1,
+	0,
+	1,
+	0,
+	1,
+	0,
+	1,
+	0,
+	1,
+	2,
+	3,
+	2,
+	3,
+	2,
+	3,
+	2,
+	3,
+	2,
+	3,
+	2,
+	3,
+	2,
+	3,
+	2,
+	3,
+	2,
+	3,
+	2,
+	3,
+	2,
+	3,
+	2,
+	3,
+	2,
+	3,
+	2,
+	3,
+	2,
+	3,
+	2,
+	3,
+	2,
+	3,
+	2,
+	3,
+	2,
+	3,
+	2,
+	3,
+	2,
+	3,
+	2,
+	3,
+	2,
+	3,
+	2,
+	3,
+	2,
+	3,
+	2,
+	3,
+	2,
+	3,
+	2,
+	3,
+	2,
+	3,
+	2,
+	3,
+	2,
+	3,
+	2,
+	3,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	1,
+	1,
+	1,
+	1,
+	1,
+	1,
+	1,
+	1,
+	1,
+	1,
+	1,
+	1,
+	1,
+	1,
+	1,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	1,
+	1,
+	1,
+	1,
+	1,
+	1,
+	1,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	1,
+	1,
+	1,
+	1,
+	1,
+	1,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	1,
+	1,
+	1,
+	1,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	0,
+	1,
+	1,
+	1,
+	1,
+	1,
+	1,
+	1,
+	1,
+	1,
+	1,
+	1,
+	1,
+	1,
+	1,
+	1,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	4,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	5,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	6,
+	7,
+	0,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	8,
+	16,
+	16,
+	16,
+	16,
+	16,
+	16,
+	16,
+	16,
+	16,
+	16,
+	16,
+	16,
+	16,
+	16,
+	16,
+	16,
+	16,
+	16,
+	16,
+	16,
+	16,
+	16,
+	16,
+	16,
+	16,
+	16,
+	16,
+	16,
+	16,
+	16,
+	16,
+	16,
+	16,
+	16,
+	16,
+	16,
+	16,
+	16,
+	16,
+	16,
+	16,
+	16,
+	16,
+	16,
+	16,
+	16,
+	16,
+	16,
+	24,
+	24,
+	24,
+	24,
+	24,
+	24,
+	24,
+	24,
+	24,
+	24,
+	24,
+	24,
+	24,
+	24,
+	24,
+	24,
+	24,
+	24,
+	24,
+	24,
+	24,
+	24,
+	24,
+	24,
+	24,
+	24,
+	24,
+	24,
+	24,
+	24,
+	24,
+	24,
+	24,
+	24,
+	24,
+	24,
+	24,
+	24,
+	24,
+	24,
+	24,
+	24,
+	24,
+	24,
+	24,
+	24,
+	24,
+	24,
+	24,
+	24,
+	24,
+	24,
+	24,
+	24,
+	24,
+	24,
+	24,
+	24,
+	24,
+	24,
+	24,
+	24,
+	24,
+	24,
+	32,
+	32,
+	32,
+	32,
+	32,
+	32,
+	32,
+	32,
+	32,
+	32,
+	32,
+	32,
+	32,
+	32,
+	32,
+	32,
+	32,
+	32,
+	32,
+	32,
+	32,
+	32,
+	32,
+	32,
+	32,
+	32,
+	32,
+	32,
+	32,
+	32,
+	32,
+	32,
+	32,
+	32,
+	32,
+	32,
+	32,
+	32,
+	32,
+	32,
+	32,
+	32,
+	32,
+	32,
+	32,
+	32,
+	32,
+	32,
+	32,
+	32,
+	32,
+	32,
+	32,
+	32,
+	32,
+	32,
+	32,
+	32,
+	32,
+	32,
+	32,
+	32,
+	32,
+	32,
+	40,
+	40,
+	40,
+	40,
+	40,
+	40,
+	40,
+	40,
+	40,
+	40,
+	40,
+	40,
+	40,
+	40,
+	40,
+	40,
+	40,
+	40,
+	40,
+	40,
+	40,
+	40,
+	40,
+	40,
+	40,
+	40,
+	40,
+	40,
+	40,
+	40,
+	40,
+	40,
+	40,
+	40,
+	40,
+	40,
+	40,
+	40,
+	40,
+	40,
+	40,
+	40,
+	40,
+	40,
+	40,
+	40,
+	40,
+	40,
+	48,
+	48,
+	48,
+	48,
+	48,
+	48,
+	48,
+	48,
+	48,
+	48,
+	48,
+	48,
+	48,
+	48,
+	48,
+	56,
+	0,
+	1,
+	2,
+	3,
+	4,
+	5,
+	6,
+	7,
+	8,
+	9,
+	10,
+	11,
+	12,
+	13,
+	14,
+	15,
+	16,
+	17,
+	18,
+	19,
+	20,
+	21,
+	22,
+	23,
+	24,
+	25,
+	26,
+	27,
+	28,
+	29,
+	30,
+	31,
+	32,
+	33,
+	34,
+	35,
+	36,
+	37,
+	38,
+	39,
+	40,
+	41,
+	42,
+	43,
+	44,
+	45,
+	46,
+	47,
+	48,
+	49,
+	50,
+	51,
+	52,
+	53,
+	54,
+	55,
+	56,
+	57,
+	58,
+	59,
+	60,
+	61,
+	62,
+	63,
+	0,
+	1,
+	2,
+	3,
+	4,
+	5,
+	6,
+	7,
+	8,
+	9,
+	10,
+	11,
+	12,
+	13,
+	14,
+	15,
+	16,
+	17,
+	18,
+	19,
+	20,
+	21,
+	22,
+	23,
+	24,
+	25,
+	26,
+	27,
+	28,
+	29,
+	30,
+	31,
+	32,
+	33,
+	34,
+	35,
+	36,
+	37,
+	38,
+	39,
+	40,
+	41,
+	42,
+	43,
+	44,
+	45,
+	46,
+	47,
+	48,
+	49,
+	50,
+	51,
+	52,
+	53,
+	54,
+	55,
+	56,
+	57,
+	58,
+	59,
+	60,
+	61,
+	62,
+	63,
+	0,
+	1,
+	2,
+	3,
+	4,
+	5,
+	6,
+	7,
+	8,
+	9,
+	10,
+	11,
+	12,
+	13,
+	14,
+	15,
+	16,
+	17,
+	18,
+	19,
+	20,
+	21,
+	22,
+	23,
+	24,
+	25,
+	26,
+	27,
+	28,
+	29,
+	30,
+	31,
+	32,
+	33,
+	34,
+	35,
+	36,
+	37,
+	38,
+	39,
+	40,
+	41,
+	42,
+	43,
+	44,
+	45,
+	46,
+	47,
+	48,
+	49,
+	50,
+	51,
+	52,
+	53,
+	54,
+	55,
+	56,
+	57,
+	58,
+	59,
+	60,
+	61,
+	62,
+	63,
+	0,
+	1,
+	2,
+	3,
+	4,
+	5,
+	6,
+	7,
+	8,
+	9,
+	10,
+	11,
+	12,
+	13,
+	14,
+	15,
+	16,
+	17,
+	18,
+	19,
+	20,
+	21,
+	22,
+	23,
+	24,
+	25,
+	26,
+	27,
+	28,
+	29,
+	30,
+	31,
+	32,
+	33,
+	34,
+	35,
+	36,
+	37,
+	38,
+	39,
+	40,
+	41,
+	42,
+	43,
+	44,
+	45,
+	46,
+	47,
+	48,
+	49,
+	50,
+	51,
+	52,
+	53,
+	54,
+	55,
+	56,
+	57,
+	58,
+	59,
+	60,
+	61,
+	62,
+	63,
+	0,
+	0,
+	0,
+	0,
+	1,
+	1,
+	1,
+	1,
+	2,
+	2,
+	2,
+	2,
+	3,
+	3,
+	3,
+	3,
+	4,
+	4,
+	4,
+	4,
+	5,
+	5,
+	5,
+	5,
+	6,
+	6,
+	6,
+	6,
+	7,
+	7,
+	7,
+	7,
+	8,
+	8,
+	8,
+	8,
+	9,
+	9,
+	9,
+	9,
+	10,
+	10,
+	10,
+	10,
+	11,
+	11,
+	11,
+	11,
+	12,
+	12,
+	12,
+	12,
+	13,
+	13,
+	13,
+	13,
+	14,
+	14,
+	14,
+	14,
+	15,
+	15,
+	15,
+	15,
+	16,
+	16,
+	16,
+	16,
+	17,
+	17,
+	17,
+	17,
+	18,
+	18,
+	18,
+	18,
+	19,
+	19,
+	19,
+	19,
+	20,
+	20,
+	20,
+	20,
+	21,
+	21,
+	21,
+	21,
+	22,
+	22,
+	22,
+	22,
+	23,
+	23,
+	23,
+	23,
+	24,
+	24,
+	24,
+	24,
+	25,
+	25,
+	25,
+	25,
+	26,
+	26,
+	26,
+	26,
+	27,
+	27,
+	27,
+	27,
+	28,
+	28,
+	28,
+	28,
+	29,
+	29,
+	29,
+	29,
+	30,
+	30,
+	30,
+	30,
+	31,
+	31,
+	31,
+	31,
+	32,
+	32,
+	32,
+	32,
+	33,
+	33,
+	33,
+	33,
+	34,
+	34,
+	34,
+	34,
+	35,
+	35,
+	35,
+	35,
+	36,
+	36,
+	36,
+	36,
+	37,
+	37,
+	37,
+	37,
+	38,
+	38,
+	38,
+	38,
+	39,
+	39,
+	39,
+	39,
+	40,
+	40,
+	40,
+	40,
+	41,
+	41,
+	41,
+	41,
+	42,
+	42,
+	42,
+	42,
+	43,
+	43,
+	43,
+	43,
+	44,
+	44,
+	44,
+	44,
+	45,
+	45,
+	45,
+	45,
+	46,
+	46,
+	46,
+	46,
+	47,
+	47,
+	47,
+	47,
+	48,
+	48,
+	48,
+	48,
+	49,
+	49,
+	49,
+	49,
+	50,
+	50,
+	50,
+	50,
+	51,
+	51,
+	51,
+	51,
+	52,
+	52,
+	52,
+	52,
+	53,
+	53,
+	53,
+	53,
+	54,
+	54,
+	54,
+	54,
+	55,
+	55,
+	55,
+	55,
+	56,
+	56,
+	56,
+	56,
+	57,
+	57,
+	57,
+	57,
+	58,
+	58,
+	58,
+	58,
+	59,
+	59,
+	59,
+	59,
+	60,
+	60,
+	60,
+	60,
+	61,
+	61,
+	61,
+	61,
+	62,
+	62,
+	62,
+	62,
+	63,
+	63,
+	63,
+	63,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0
+]);
+new Uint16Array([
+	1024,
+	1536,
+	1280,
+	1536,
+	0,
+	256,
+	768,
+	512
+]);
+function BrotliInput(buffer) {
+	this.buffer = buffer;
+	this.pos = 0;
+}
+BrotliInput.prototype.read = function(buf, i, count) {
+	if (this.pos + count > this.buffer.length) count = this.buffer.length - this.pos;
+	for (let p = 0; p < count; p++) buf[i + p] = this.buffer[this.pos + p];
+	this.pos += count;
+	return count;
+};
+function BrotliOutput(buf) {
+	this.buffer = buf;
+	this.pos = 0;
+}
+BrotliOutput.prototype.write = function(buf, count) {
+	if (this.pos + count > this.buffer.length) throw new Error("brotli output buffer is not large enough");
+	this.buffer.set(buf.subarray(0, count), this.pos);
+	this.pos += count;
+	return count;
+};
+const codeLengthIndexMap = new Uint8Array([
+	16,
+	17,
+	18,
+	0,
+	8,
+	7,
+	9,
+	6,
+	10,
+	5,
+	11,
+	4,
+	12,
+	3,
+	13,
+	2,
+	14,
+	1,
+	15
+]);
+function bits(input, pos, mask) {
+	const o = pos / 8 | 0;
+	return (input[o] | input[o + 1] << 8) >> (pos & 7) & mask;
+}
+function bits16(d, p) {
+	const o = p / 8 | 0;
+	return (d[o] | d[o + 1] << 8 | d[o + 2] << 16) >> (p & 7);
+}
+function shft(p) {
+	return (p + 7) / 8 | 0;
+}
+function gzipStart(input, i) {
+	if (input[i++] !== 31 || input[i++] !== 139 || input[i++] !== 8) return 0;
+	const flag = input[i++];
+	i += 6;
+	if (flag & 4) i += (input[i + 10] | input[i + 11] << 8) + 2;
+	for (let zs = (flag >> 3 & 1) + (flag >> 4 & 1); zs > 0; zs -= Number(!input[i++]));
+	return i + (flag & 2);
+}
+function gunzip(input, output, inputIndex = 0, outputIndex = 0) {
+	let out = output ?? new Uint8Array(1024);
+	if (!(input.length - inputIndex)) return out;
+	const payloadStart = gzipStart(input, inputIndex);
+	if (payloadStart === input.length - 8) return out;
+	if (payloadStart > input.length - 8) throw new Error("unexpected EOF");
+	let pos = payloadStart * 8;
+	let final = 0;
+	let lengthBits = 0;
+	let distBits = 0;
+	let lengthMap;
+	let distMap;
+	const totalBits = input.length * 8;
+	function ensureSize(length) {
+		if (!output && length > out.length) {
+			const old = out;
+			out = new Uint8Array(Math.max(old.length * 2, length));
+			out.set(old);
+		}
+	}
+	do {
+		if (!lengthMap) {
+			final = bits(input, pos, 1);
+			const type = bits(input, pos + 1, 3);
+			pos += 3;
+			if (!type) {
+				const s = shft(pos) + 4;
+				const l = input[s - 4] | input[s - 3] << 8;
+				const t = s + l;
+				if (t > input.length) throw new Error("unexpected EOF");
+				ensureSize(outputIndex + l);
+				out.set(input.subarray(s, t), outputIndex);
+				outputIndex += l;
+				pos = t * 8;
+				continue;
+			} else if (type === 1) {
+				lengthMap = fixedLengthMap;
+				distMap = fixedDistanceMap;
+				lengthBits = 9;
+				distBits = 5;
+			} else if (type === 2) {
+				const hLiteral = bits(input, pos, 31) + 257;
+				const hcLengths = bits(input, pos + 10, 15) + 4;
+				const tl = hLiteral + bits(input, pos + 5, 31) + 1;
+				pos += 14;
+				const lengthDistanceTree = new Uint8Array(tl);
+				const codeLengthTree = new Uint8Array(19);
+				for (let i = 0; i < hcLengths; ++i) codeLengthTree[codeLengthIndexMap[i]] = bits(input, pos + i * 3, 7);
+				pos += hcLengths * 3;
+				const codeLengthBits = Math.max(...codeLengthTree);
+				const clbMask = (1 << codeLengthBits) - 1;
+				const codeLengthMap = huffMap(codeLengthTree, codeLengthBits, 1);
+				for (let i = 0; i < tl;) {
+					const r = codeLengthMap[bits(input, pos, clbMask)];
+					pos += r & 15;
+					const symbol = r >> 4;
+					if (symbol < 16) lengthDistanceTree[i++] = symbol;
+					else {
+						let copy = 0;
+						let n = 0;
+						if (symbol === 16) {
+							n = 3 + bits(input, pos, 3);
+							pos += 2;
+							copy = lengthDistanceTree[i - 1];
+						} else if (symbol === 17) {
+							n = 3 + bits(input, pos, 7);
+							pos += 3;
+						} else if (symbol === 18) {
+							n = 11 + bits(input, pos, 127);
+							pos += 7;
+						}
+						while (n--) lengthDistanceTree[i++] = copy;
+					}
+				}
+				const lengthTree = lengthDistanceTree.subarray(0, hLiteral);
+				const distanceTree = lengthDistanceTree.subarray(hLiteral);
+				lengthBits = Math.max(...lengthTree);
+				distBits = Math.max(...distanceTree);
+				lengthMap = huffMap(lengthTree, lengthBits, 1);
+				distMap = huffMap(distanceTree, distBits, 1);
+			} else throw new Error("invalid block type");
+			if (pos > totalBits) throw new Error("unexpected EOF");
+		}
+		ensureSize(outputIndex + 131072);
+		const lms = (1 << lengthBits) - 1;
+		const dms = (1 << distBits) - 1;
+		let lpos = pos;
+		for (;; lpos = pos) {
+			const code = lengthMap[bits16(input, pos) & lms];
+			const sym = code >> 4;
+			pos += code & 15;
+			if (pos > totalBits) throw new Error("unexpected EOF");
+			if (!code) throw new Error("invalid length/literal");
+			if (sym < 256) out[outputIndex++] = sym;
+			else if (sym === 256) {
+				lpos = pos;
+				lengthMap = void 0;
+				break;
+			} else {
+				let add = sym - 254;
+				if (sym > 264) {
+					const index = sym - 257;
+					const b = fixedLengthExtraBits[index];
+					add = bits(input, pos, (1 << b) - 1) + fixedLength[index];
+					pos += b;
+				}
+				if (!distMap) throw new Error("invalid distance map");
+				const d = distMap[bits16(input, pos) & dms];
+				const dsym = d >> 4;
+				if (!d) throw new Error("invalid distance");
+				pos += d & 15;
+				let dt = fixedDistance[dsym];
+				if (dsym > 3) {
+					const b = fixedDistanceExtraBits[dsym];
+					dt += bits16(input, pos) & (1 << b) - 1;
+					pos += b;
+				}
+				if (pos > totalBits) throw new Error("unexpected EOF");
+				const end = outputIndex + add;
+				if (outputIndex < dt) throw new Error("unexpected dictionary case");
+				ensureSize(end);
+				for (; outputIndex < end; outputIndex++) out[outputIndex] = out[outputIndex - dt];
+			}
+		}
+		pos = lpos;
+		if (lengthMap) final = 1;
+	} while (!final);
+	if (outputIndex < out.length) {
+		const nextBlock = Math.ceil(pos / 8) + 8;
+		gunzip(input, out, nextBlock, outputIndex);
+	}
+	if (!output) return out.subarray(0, outputIndex);
+	return out;
+}
+const kIdentity = 0;
+const kOmitLast1 = 1;
+const kOmitLast2 = 2;
+const kOmitLast3 = 3;
+const kOmitLast4 = 4;
+const kOmitLast5 = 5;
+const kOmitLast6 = 6;
+const kOmitLast7 = 7;
+const kOmitLast8 = 8;
+const kOmitLast9 = 9;
+const kUppercaseFirst = 10;
+const kUppercaseAll = 11;
+const kOmitFirst1 = 12;
+const kOmitFirst2 = 13;
+const kOmitFirst3 = 14;
+const kOmitFirst4 = 15;
+const kOmitFirst5 = 16;
+const kOmitFirst6 = 17;
+const kOmitFirst7 = 18;
+const kOmitFirst9 = 20;
+function Transform(prefix, transform, suffix) {
+	this.prefix = new Uint8Array(prefix.length);
+	this.transform = transform;
+	this.suffix = new Uint8Array(suffix.length);
+	for (let i = 0; i < prefix.length; i++) this.prefix[i] = prefix.charCodeAt(i);
+	for (let i = 0; i < suffix.length; i++) this.suffix[i] = suffix.charCodeAt(i);
+}
+[
+	new Transform("", kIdentity, ""),
+	new Transform("", kIdentity, " "),
+	new Transform(" ", kIdentity, " "),
+	new Transform("", kOmitFirst1, ""),
+	new Transform("", kUppercaseFirst, " "),
+	new Transform("", kIdentity, " the "),
+	new Transform(" ", kIdentity, ""),
+	new Transform("s ", kIdentity, " "),
+	new Transform("", kIdentity, " of "),
+	new Transform("", kUppercaseFirst, ""),
+	new Transform("", kIdentity, " and "),
+	new Transform("", kOmitFirst2, ""),
+	new Transform("", kOmitLast1, ""),
+	new Transform(", ", kIdentity, " "),
+	new Transform("", kIdentity, ", "),
+	new Transform(" ", kUppercaseFirst, " "),
+	new Transform("", kIdentity, " in "),
+	new Transform("", kIdentity, " to "),
+	new Transform("e ", kIdentity, " "),
+	new Transform("", kIdentity, "\""),
+	new Transform("", kIdentity, "."),
+	new Transform("", kIdentity, "\">"),
+	new Transform("", kIdentity, "\n"),
+	new Transform("", kOmitLast3, ""),
+	new Transform("", kIdentity, "]"),
+	new Transform("", kIdentity, " for "),
+	new Transform("", kOmitFirst3, ""),
+	new Transform("", kOmitLast2, ""),
+	new Transform("", kIdentity, " a "),
+	new Transform("", kIdentity, " that "),
+	new Transform(" ", kUppercaseFirst, ""),
+	new Transform("", kIdentity, ". "),
+	new Transform(".", kIdentity, ""),
+	new Transform(" ", kIdentity, ", "),
+	new Transform("", kOmitFirst4, ""),
+	new Transform("", kIdentity, " with "),
+	new Transform("", kIdentity, "'"),
+	new Transform("", kIdentity, " from "),
+	new Transform("", kIdentity, " by "),
+	new Transform("", kOmitFirst5, ""),
+	new Transform("", kOmitFirst6, ""),
+	new Transform(" the ", kIdentity, ""),
+	new Transform("", kOmitLast4, ""),
+	new Transform("", kIdentity, ". The "),
+	new Transform("", kUppercaseAll, ""),
+	new Transform("", kIdentity, " on "),
+	new Transform("", kIdentity, " as "),
+	new Transform("", kIdentity, " is "),
+	new Transform("", kOmitLast7, ""),
+	new Transform("", kOmitLast1, "ing "),
+	new Transform("", kIdentity, "\n	"),
+	new Transform("", kIdentity, ":"),
+	new Transform(" ", kIdentity, ". "),
+	new Transform("", kIdentity, "ed "),
+	new Transform("", kOmitFirst9, ""),
+	new Transform("", kOmitFirst7, ""),
+	new Transform("", kOmitLast6, ""),
+	new Transform("", kIdentity, "("),
+	new Transform("", kUppercaseFirst, ", "),
+	new Transform("", kOmitLast8, ""),
+	new Transform("", kIdentity, " at "),
+	new Transform("", kIdentity, "ly "),
+	new Transform(" the ", kIdentity, " of "),
+	new Transform("", kOmitLast5, ""),
+	new Transform("", kOmitLast9, ""),
+	new Transform(" ", kUppercaseFirst, ", "),
+	new Transform("", kUppercaseFirst, "\""),
+	new Transform(".", kIdentity, "("),
+	new Transform("", kUppercaseAll, " "),
+	new Transform("", kUppercaseFirst, "\">"),
+	new Transform("", kIdentity, "=\""),
+	new Transform(" ", kIdentity, "."),
+	new Transform(".com/", kIdentity, ""),
+	new Transform(" the ", kIdentity, " of the "),
+	new Transform("", kUppercaseFirst, "'"),
+	new Transform("", kIdentity, ". This "),
+	new Transform("", kIdentity, ","),
+	new Transform(".", kIdentity, " "),
+	new Transform("", kUppercaseFirst, "("),
+	new Transform("", kUppercaseFirst, "."),
+	new Transform("", kIdentity, " not "),
+	new Transform(" ", kIdentity, "=\""),
+	new Transform("", kIdentity, "er "),
+	new Transform(" ", kUppercaseAll, " "),
+	new Transform("", kIdentity, "al "),
+	new Transform(" ", kUppercaseAll, ""),
+	new Transform("", kIdentity, "='"),
+	new Transform("", kUppercaseAll, "\""),
+	new Transform("", kUppercaseFirst, ". "),
+	new Transform(" ", kIdentity, "("),
+	new Transform("", kIdentity, "ful "),
+	new Transform(" ", kUppercaseFirst, ". "),
+	new Transform("", kIdentity, "ive "),
+	new Transform("", kIdentity, "less "),
+	new Transform("", kUppercaseAll, "'"),
+	new Transform("", kIdentity, "est "),
+	new Transform(" ", kUppercaseFirst, "."),
+	new Transform("", kUppercaseAll, "\">"),
+	new Transform(" ", kIdentity, "='"),
+	new Transform("", kUppercaseFirst, ","),
+	new Transform("", kIdentity, "ize "),
+	new Transform("", kUppercaseAll, "."),
+	new Transform("Â\xA0", kIdentity, ""),
+	new Transform(" ", kIdentity, ","),
+	new Transform("", kUppercaseFirst, "=\""),
+	new Transform("", kUppercaseAll, "=\""),
+	new Transform("", kIdentity, "ous "),
+	new Transform("", kUppercaseAll, ", "),
+	new Transform("", kUppercaseFirst, "='"),
+	new Transform(" ", kUppercaseFirst, ","),
+	new Transform(" ", kUppercaseAll, "=\""),
+	new Transform(" ", kUppercaseAll, ", "),
+	new Transform("", kUppercaseAll, ","),
+	new Transform("", kUppercaseAll, "("),
+	new Transform("", kUppercaseAll, ". "),
+	new Transform(" ", kUppercaseAll, "."),
+	new Transform("", kUppercaseAll, "='"),
+	new Transform(" ", kUppercaseAll, ". "),
+	new Transform(" ", kUppercaseFirst, "=\""),
+	new Transform(" ", kUppercaseAll, "='"),
+	new Transform(" ", kUppercaseFirst, "='")
+].length;
+new Uint8Array([
+	3,
+	2,
+	1,
+	0,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2
+]);
+new Int8Array([
+	0,
+	0,
+	0,
+	0,
+	-1,
+	1,
+	-2,
+	2,
+	-3,
+	3,
+	-1,
+	1,
+	-2,
+	2,
+	-3,
+	3
+]);
+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
+]);
+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
+]);
+export { gunzip, snappyUncompress$1 as snappyUncompress, snappyUncompressor };