@gscdump/engine 1.4.0 → 1.4.2

package/dist/node_modules/.pnpm/hyparquet-compressors@1.1.1/node_modules/hyparquet-compressors/src/brotli.huffman.mjs

@@ -0,0 +1,266 @@
+const kDefaultCodeLength = 8;
+const HUFFMAN_TABLE_BITS = 8;
+const HUFFMAN_TABLE_MASK = 255;
+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 readSymbol(table, index, br) {
+	br.fillBitWindow();
+	index += br.val_ >>> br.bit_pos_ & HUFFMAN_TABLE_MASK;
+	const nbits = table[index].bits - HUFFMAN_TABLE_BITS;
+	if (nbits > 0) {
+		br.bit_pos_ += HUFFMAN_TABLE_BITS;
+		index += table[index].value;
+		index += br.val_ >>> br.bit_pos_ & (1 << nbits) - 1;
+	}
+	br.bit_pos_ += table[index].bits;
+	return table[index].value;
+}
+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);
+	}
+};
+export { HuffmanCode, HuffmanTreeGroup, readHuffmanCode, readSymbol };

package/dist/node_modules/.pnpm/hyparquet-compressors@1.1.1/node_modules/hyparquet-compressors/src/brotli.mjs

@@ -0,0 +1,340 @@
+import { BrotliBitReader } from "./brotli.bitreader.mjs";
+import { HuffmanCode, HuffmanTreeGroup, readHuffmanCode, readSymbol } from "./brotli.huffman.mjs";
+import { kCopyLengthPrefixCode, kCopyRangeLut, kInsertLengthPrefixCode, kInsertRangeLut } from "./brotli.prefix.mjs";
+import { HUFFMAN_MAX_TABLE_SIZE } from "./gzip.huffman.mjs";
+import { copyUncompressedBlockToOutput, decodeBlockType, decodeMetaBlockLength, decodeVarLenUint8, decodeWindowBits, jumpToByteBoundary, readBlockLength } from "./brotli.blocks.mjs";
+import { lookup, lookupOffsets } from "./brotli.context.mjs";
+import { decodeContextMap } from "./brotli.contextmap.mjs";
+import { BrotliInput, BrotliOutput } from "./brotli.streams.mjs";
+import { kNumTransforms, transformDictionaryWord } from "./brotli.transform.mjs";
+const kNumLiteralCodes = 256;
+const kNumInsertAndCopyCodes = 704;
+const kNumBlockLengthCodes = 26;
+const kLiteralContextBits = 6;
+const kDistanceContextBits = 2;
+const NUM_DISTANCE_SHORT_CODES = 16;
+const kDistanceShortCodeIndexOffset = new Uint8Array([
+	3,
+	2,
+	1,
+	0,
+	3,
+	3,
+	3,
+	3,
+	3,
+	3,
+	2,
+	2,
+	2,
+	2,
+	2,
+	2
+]);
+const kDistanceShortCodeValueOffset = new Int8Array([
+	0,
+	0,
+	0,
+	0,
+	-1,
+	1,
+	-2,
+	2,
+	-3,
+	3,
+	-1,
+	1,
+	-2,
+	2,
+	-3,
+	3
+]);
+const offsetsByLength = new Uint32Array([
+	0,
+	0,
+	0,
+	0,
+	0,
+	4096,
+	9216,
+	21504,
+	35840,
+	44032,
+	53248,
+	63488,
+	74752,
+	87040,
+	93696,
+	100864,
+	104704,
+	106752,
+	108928,
+	113536,
+	115968,
+	118528,
+	119872,
+	121280,
+	122016
+]);
+const sizeBitsByLength = new Uint8Array([
+	0,
+	0,
+	0,
+	0,
+	10,
+	10,
+	11,
+	11,
+	10,
+	10,
+	10,
+	10,
+	10,
+	9,
+	9,
+	8,
+	7,
+	7,
+	8,
+	7,
+	7,
+	6,
+	6,
+	5,
+	5
+]);
+const minDictionaryWordLength = 4;
+const maxDictionaryWordLength = 24;
+function decompressBrotli(input, outputLength) {
+	const output = new Uint8Array(outputLength);
+	brotli(new BrotliInput(input), new BrotliOutput(output));
+	return output;
+}
+function brotli(input, output) {
+	let pos = 0;
+	let input_end = 0;
+	let window_bits = 0;
+	let max_distance = 0;
+	const dist_rb = [
+		16,
+		15,
+		11,
+		4
+	];
+	let dist_rb_idx = 0;
+	let prev_byte1 = 0;
+	let prev_byte2 = 0;
+	const hgroup = [
+		new HuffmanTreeGroup(0, 0),
+		new HuffmanTreeGroup(0, 0),
+		new HuffmanTreeGroup(0, 0)
+	];
+	const kRingBufferWriteAheadSlack = 128 + BrotliBitReader.READ_SIZE;
+	const br = new BrotliBitReader(input);
+	window_bits = decodeWindowBits(br);
+	const max_backward_distance = (1 << window_bits) - 16;
+	const ringbuffer_size = 1 << window_bits;
+	const ringbuffer_mask = ringbuffer_size - 1;
+	const ringbuffer = new Uint8Array(ringbuffer_size + kRingBufferWriteAheadSlack + maxDictionaryWordLength);
+	const ringbuffer_end = ringbuffer_size;
+	const block_type_trees = [];
+	const block_len_trees = [];
+	for (let x = 0; x < 3 * HUFFMAN_MAX_TABLE_SIZE; x++) {
+		block_type_trees[x] = new HuffmanCode(0, 0);
+		block_len_trees[x] = new HuffmanCode(0, 0);
+	}
+	while (!input_end) {
+		let meta_block_remaining_len = 0;
+		const block_length = [
+			1 << 28,
+			1 << 28,
+			1 << 28
+		];
+		const block_type = [0];
+		const num_block_types = [
+			1,
+			1,
+			1
+		];
+		const block_type_rb = [
+			0,
+			1,
+			0,
+			1,
+			0,
+			1
+		];
+		const block_type_rb_index = [0];
+		let context_offset = 0;
+		for (let i = 0; i < 3; i++) {
+			hgroup[i].codes = [];
+			hgroup[i].htrees = /* @__PURE__ */ new Uint32Array();
+		}
+		br.readMoreInput();
+		const _out = decodeMetaBlockLength(br);
+		meta_block_remaining_len = _out.meta_block_length;
+		if (pos + meta_block_remaining_len > output.buffer.length) {
+			const tmp = new Uint8Array(pos + meta_block_remaining_len);
+			tmp.set(output.buffer);
+			output.buffer = tmp;
+		}
+		input_end = _out.input_end;
+		if (_out.is_metadata) {
+			jumpToByteBoundary(br);
+			for (; meta_block_remaining_len > 0; --meta_block_remaining_len) {
+				br.readMoreInput();
+				br.readBits(8);
+			}
+			continue;
+		}
+		if (meta_block_remaining_len === 0) continue;
+		if (_out.is_uncompressed) {
+			br.bit_pos_ = br.bit_pos_ + 7 & -8;
+			copyUncompressedBlockToOutput(output, meta_block_remaining_len, pos, ringbuffer, ringbuffer_mask, br);
+			pos += meta_block_remaining_len;
+			continue;
+		}
+		for (let i = 0; i < 3; i++) {
+			num_block_types[i] = decodeVarLenUint8(br) + 1;
+			if (num_block_types[i] >= 2) {
+				readHuffmanCode(num_block_types[i] + 2, block_type_trees, i * HUFFMAN_MAX_TABLE_SIZE, br);
+				readHuffmanCode(kNumBlockLengthCodes, block_len_trees, i * HUFFMAN_MAX_TABLE_SIZE, br);
+				block_length[i] = readBlockLength(block_len_trees, i * HUFFMAN_MAX_TABLE_SIZE, br);
+				block_type_rb_index[i] = 1;
+			}
+		}
+		br.readMoreInput();
+		const distance_postfix_bits = br.readBits(2);
+		const num_direct_distance_codes = NUM_DISTANCE_SHORT_CODES + (br.readBits(4) << distance_postfix_bits);
+		const distance_postfix_mask = (1 << distance_postfix_bits) - 1;
+		const num_distance_codes = num_direct_distance_codes + (48 << distance_postfix_bits);
+		const context_modes = new Uint8Array(num_block_types[0]);
+		for (let i = 0; i < num_block_types[0]; i++) {
+			br.readMoreInput();
+			context_modes[i] = br.readBits(2) << 1;
+		}
+		const [num_literal_htrees, context_map] = decodeContextMap(num_block_types[0] << kLiteralContextBits, br);
+		const [num_dist_htrees, dist_context_map] = decodeContextMap(num_block_types[2] << kDistanceContextBits, br);
+		hgroup[0] = new HuffmanTreeGroup(kNumLiteralCodes, num_literal_htrees);
+		hgroup[1] = new HuffmanTreeGroup(kNumInsertAndCopyCodes, num_block_types[1]);
+		hgroup[2] = new HuffmanTreeGroup(num_distance_codes, num_dist_htrees);
+		for (let i = 0; i < 3; ++i) hgroup[i].decode(br);
+		let context_map_slice = 0;
+		let dist_context_map_slice = 0;
+		let context_mode = context_modes[block_type[0]];
+		let context_lookup_offset1 = lookupOffsets[context_mode];
+		let context_lookup_offset2 = lookupOffsets[context_mode + 1];
+		let htree_command = hgroup[1].htrees[0];
+		while (meta_block_remaining_len > 0) {
+			let distance_code;
+			br.readMoreInput();
+			if (block_length[1] === 0) {
+				decodeBlockType(num_block_types[1], block_type_trees, 1, block_type, block_type_rb, block_type_rb_index, br);
+				block_length[1] = readBlockLength(block_len_trees, HUFFMAN_MAX_TABLE_SIZE, br);
+				htree_command = hgroup[1].htrees[block_type[1]];
+			}
+			block_length[1]--;
+			const cmd_code = readSymbol(hgroup[1].codes, htree_command, br);
+			let range_idx = cmd_code >> 6;
+			if (range_idx >= 2) {
+				range_idx -= 2;
+				distance_code = -1;
+			} else distance_code = 0;
+			const insertPrefix = kInsertLengthPrefixCode[kInsertRangeLut[range_idx] + (cmd_code >> 3 & 7)];
+			const insertLength = insertPrefix.offset + br.readBits(insertPrefix.nbits);
+			const copyCode = kCopyLengthPrefixCode[kCopyRangeLut[range_idx] + (cmd_code & 7)];
+			const copyLength = copyCode.offset + br.readBits(copyCode.nbits);
+			prev_byte1 = ringbuffer[pos - 1 & ringbuffer_mask];
+			prev_byte2 = ringbuffer[pos - 2 & ringbuffer_mask];
+			for (let j = 0; j < insertLength; j++) {
+				br.readMoreInput();
+				if (block_length[0] === 0) {
+					decodeBlockType(num_block_types[0], block_type_trees, 0, block_type, block_type_rb, block_type_rb_index, br);
+					block_length[0] = readBlockLength(block_len_trees, 0, br);
+					context_offset = block_type[0] << kLiteralContextBits;
+					context_map_slice = context_offset;
+					context_mode = context_modes[block_type[0]];
+					context_lookup_offset1 = lookupOffsets[context_mode];
+					context_lookup_offset2 = lookupOffsets[context_mode + 1];
+				}
+				const context = lookup[context_lookup_offset1 + prev_byte1] | lookup[context_lookup_offset2 + prev_byte2];
+				const literal_htree_index = context_map[context_map_slice + context];
+				block_length[0]--;
+				prev_byte2 = prev_byte1;
+				prev_byte1 = readSymbol(hgroup[0].codes, hgroup[0].htrees[literal_htree_index], br);
+				ringbuffer[pos & ringbuffer_mask] = prev_byte1;
+				if ((pos & ringbuffer_mask) === ringbuffer_mask) output.write(ringbuffer, ringbuffer_size);
+				pos++;
+			}
+			meta_block_remaining_len -= insertLength;
+			if (meta_block_remaining_len <= 0) break;
+			if (distance_code < 0) {
+				br.readMoreInput();
+				if (block_length[2] === 0) {
+					decodeBlockType(num_block_types[2], block_type_trees, 2, block_type, block_type_rb, block_type_rb_index, br);
+					block_length[2] = readBlockLength(block_len_trees, 2 * HUFFMAN_MAX_TABLE_SIZE, br);
+					dist_context_map_slice = block_type[2] << kDistanceContextBits;
+				}
+				block_length[2]--;
+				const context = (copyLength > 4 ? 3 : copyLength - 2) & 255;
+				const dist_htree_index = dist_context_map[dist_context_map_slice + context];
+				distance_code = readSymbol(hgroup[2].codes, hgroup[2].htrees[dist_htree_index], br);
+				if (distance_code >= num_direct_distance_codes) {
+					distance_code -= num_direct_distance_codes;
+					const postfix = distance_code & distance_postfix_mask;
+					distance_code >>= distance_postfix_bits;
+					const nbits = (distance_code >> 1) + 1;
+					distance_code = num_direct_distance_codes + ((2 + (distance_code & 1) << nbits) - 4 + br.readBits(nbits) << distance_postfix_bits) + postfix;
+				}
+			}
+			const distance = translateShortCodes(distance_code, dist_rb, dist_rb_idx);
+			if (distance < 0) throw new Error("[BrotliDecompress] invalid distance");
+			if (pos < max_backward_distance && max_distance !== max_backward_distance) max_distance = pos;
+			else max_distance = max_backward_distance;
+			let copy_dst = pos & ringbuffer_mask;
+			if (distance > max_distance) if (copyLength >= minDictionaryWordLength && copyLength <= maxDictionaryWordLength) {
+				let offset = offsetsByLength[copyLength];
+				const word_id = distance - max_distance - 1;
+				const shift = sizeBitsByLength[copyLength];
+				const word_idx = word_id & (1 << shift) - 1;
+				const transform_idx = word_id >> shift;
+				offset += word_idx * copyLength;
+				if (transform_idx < kNumTransforms) {
+					const len = transformDictionaryWord(ringbuffer, copy_dst, offset, copyLength, transform_idx);
+					copy_dst += len;
+					pos += len;
+					meta_block_remaining_len -= len;
+					if (copy_dst >= ringbuffer_end) {
+						output.write(ringbuffer, ringbuffer_size);
+						for (let _x = 0; _x < copy_dst - ringbuffer_end; _x++) ringbuffer[_x] = ringbuffer[ringbuffer_end + _x];
+					}
+				} else throw new Error("Invalid backward reference");
+			} else throw new Error("Invalid backward reference");
+			else {
+				if (distance_code > 0) {
+					dist_rb[dist_rb_idx & 3] = distance;
+					dist_rb_idx++;
+				}
+				if (copyLength > meta_block_remaining_len) throw new Error("Invalid backward reference");
+				for (let j = 0; j < copyLength; j++) {
+					ringbuffer[pos & ringbuffer_mask] = ringbuffer[pos - distance & ringbuffer_mask];
+					if ((pos & ringbuffer_mask) === ringbuffer_mask) output.write(ringbuffer, ringbuffer_size);
+					pos++;
+					meta_block_remaining_len--;
+				}
+			}
+			prev_byte1 = ringbuffer[pos - 1 & ringbuffer_mask];
+			prev_byte2 = ringbuffer[pos - 2 & ringbuffer_mask];
+		}
+		pos &= 1073741823;
+	}
+	output.write(ringbuffer, pos & ringbuffer_mask);
+}
+function translateShortCodes(code, ringbuffer, index) {
+	if (code < NUM_DISTANCE_SHORT_CODES) {
+		index += kDistanceShortCodeIndexOffset[code];
+		index &= 3;
+		return ringbuffer[index] + kDistanceShortCodeValueOffset[code];
+	} else return code - NUM_DISTANCE_SHORT_CODES + 1;
+}
+export { decompressBrotli };

package/dist/node_modules/.pnpm/hyparquet-compressors@1.1.1/node_modules/hyparquet-compressors/src/brotli.prefix.mjs

@@ -0,0 +1,109 @@
+function prefix([offset, nbits]) {
+	return {
+		offset,
+		nbits
+	};
+}
+const kBlockLengthPrefixCode = [
+	[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);
+const kInsertLengthPrefixCode = [
+	[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);
+const kCopyLengthPrefixCode = [
+	[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 kInsertRangeLut = [
+	0,
+	0,
+	8,
+	8,
+	0,
+	16,
+	8,
+	16,
+	16
+];
+const kCopyRangeLut = [
+	0,
+	8,
+	0,
+	8,
+	16,
+	0,
+	16,
+	8,
+	16
+];
+export { kBlockLengthPrefixCode, kCopyLengthPrefixCode, kCopyRangeLut, kInsertLengthPrefixCode, kInsertRangeLut };