@gscdump/engine 1.3.2 → 1.4.1

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

@@ -1,2796 +0,0 @@
-import { snappyUncompress as snappyUncompress$1 } from "./hyparquet.mjs";
-import "./fzstd.mjs";
-function decode(input, outputLength) {
-	const output = new Uint8Array(outputLength);
-	snappyUncompress$1(input, output);
-	return output;
-}
-function snappyUncompressor() {
-	return decode;
-}
-function snappyUncompress(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 = /* @__PURE__ */ new Int32Array(16);
-	const offset = /* @__PURE__ */ 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 = /* @__PURE__ */ 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 = /* @__PURE__ */ 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 = /* @__PURE__ */ 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 = /* @__PURE__ */ 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 = /* @__PURE__ */ 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 ?? /* @__PURE__ */ 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 = /* @__PURE__ */ 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 { snappyUncompress, snappyUncompressor };