@gscdump/engine 1.4.0 → 1.4.2

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

@@ -0,0 +1,88 @@
+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;
+};
+export { BrotliBitReader };

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

@@ -0,0 +1,120 @@
+import { BrotliBitReader } from "./brotli.bitreader.mjs";
+import { readSymbol } from "./brotli.huffman.mjs";
+import { kBlockLengthPrefixCode } from "./brotli.prefix.mjs";
+import { HUFFMAN_MAX_TABLE_SIZE } from "./gzip.huffman.mjs";
+function decodeBlockType(max_block_type, trees, tree_type, block_types, ringbuffers, indexes, br) {
+	const ringbuffer = tree_type * 2;
+	const index = tree_type;
+	const type_code = readSymbol(trees, tree_type * HUFFMAN_MAX_TABLE_SIZE, br);
+	let block_type;
+	if (type_code === 0) block_type = ringbuffers[ringbuffer + (indexes[index] & 1)];
+	else if (type_code === 1) block_type = ringbuffers[ringbuffer + (indexes[index] - 1 & 1)] + 1;
+	else block_type = type_code - 2;
+	if (block_type >= max_block_type) block_type -= max_block_type;
+	block_types[tree_type] = block_type;
+	ringbuffers[ringbuffer + (indexes[index] & 1)] = block_type;
+	indexes[index]++;
+}
+function decodeMetaBlockLength(br) {
+	const out = {
+		meta_block_length: 0,
+		input_end: 0,
+		is_uncompressed: 0,
+		is_metadata: false
+	};
+	out.input_end = br.readBits(1);
+	if (out.input_end && br.readBits(1)) return out;
+	const size_nibbles = br.readBits(2) + 4;
+	if (size_nibbles === 7) {
+		out.is_metadata = true;
+		if (br.readBits(1) !== 0) throw new Error("Invalid reserved bit");
+		const size_bytes = br.readBits(2);
+		if (size_bytes === 0) return out;
+		for (let i = 0; i < size_bytes; i++) {
+			const next_byte = br.readBits(8);
+			if (i + 1 === size_bytes && size_bytes > 1 && next_byte === 0) throw new Error("Invalid size byte");
+			out.meta_block_length |= next_byte << i * 8;
+		}
+	} else for (let i = 0; i < size_nibbles; i++) {
+		const next_nibble = br.readBits(4);
+		if (i + 1 === size_nibbles && size_nibbles > 4 && next_nibble === 0) throw new Error("Invalid size nibble");
+		out.meta_block_length |= next_nibble << i * 4;
+	}
+	out.meta_block_length++;
+	if (!out.input_end && !out.is_metadata) out.is_uncompressed = br.readBits(1);
+	return out;
+}
+function copyUncompressedBlockToOutput(output, len, pos, ringbuffer, ringbuffer_mask, br) {
+	const rb_size = ringbuffer_mask + 1;
+	let rb_pos = pos & ringbuffer_mask;
+	let br_pos = br.pos_ & BrotliBitReader.IBUF_MASK;
+	if (len < 8 || br.bit_pos_ + (len << 3) < br.bit_end_pos_) {
+		while (len-- > 0) {
+			br.readMoreInput();
+			ringbuffer[rb_pos++] = br.readBits(8);
+			if (rb_pos === rb_size) {
+				output.write(ringbuffer, rb_size);
+				rb_pos = 0;
+			}
+		}
+		return;
+	}
+	if (br.bit_end_pos_ < 32) throw new Error("copyUncompressedBlockToOutput: br.bit_end_pos_ < 32");
+	while (br.bit_pos_ < 32) {
+		ringbuffer[rb_pos] = br.val_ >>> br.bit_pos_;
+		br.bit_pos_ += 8;
+		rb_pos++;
+		len--;
+	}
+	let nbytes = br.bit_end_pos_ - br.bit_pos_ >> 3;
+	if (br_pos + nbytes > BrotliBitReader.IBUF_MASK) {
+		const tail = BrotliBitReader.IBUF_MASK + 1 - br_pos;
+		for (let x = 0; x < tail; x++) ringbuffer[rb_pos + x] = br.buf_[br_pos + x];
+		nbytes -= tail;
+		rb_pos += tail;
+		len -= tail;
+		br_pos = 0;
+	}
+	for (let x = 0; x < nbytes; x++) ringbuffer[rb_pos + x] = br.buf_[br_pos + x];
+	rb_pos += nbytes;
+	len -= nbytes;
+	if (rb_pos >= rb_size) {
+		output.write(ringbuffer, rb_size);
+		rb_pos -= rb_size;
+		for (let x = 0; x < rb_pos; x++) ringbuffer[x] = ringbuffer[rb_size + x];
+	}
+	while (rb_pos + len >= rb_size) {
+		nbytes = rb_size - rb_pos;
+		if (br.input_.read(ringbuffer, rb_pos, nbytes) < nbytes) throw new Error("copyUncompressedBlockToOutput: not enough bytes");
+		output.write(ringbuffer, rb_size);
+		len -= nbytes;
+		rb_pos = 0;
+	}
+	if (br.input_.read(ringbuffer, rb_pos, len) < len) throw new Error("copyUncompressedBlockToOutput: not enough bytes");
+	br.reset();
+}
+function decodeVarLenUint8(br) {
+	if (br.readBits(1)) {
+		const nbits = br.readBits(3);
+		if (nbits === 0) return 1;
+		else return br.readBits(nbits) + (1 << nbits);
+	}
+	return 0;
+}
+function decodeWindowBits(br) {
+	if (br.readBits(1) === 0) return 16;
+	let n = br.readBits(3);
+	if (n > 0) return 17 + n;
+	n = br.readBits(3);
+	if (n > 0) return 8 + n;
+	return 17;
+}
+function jumpToByteBoundary(br) {
+	const new_bit_pos = br.bit_pos_ + 7 & -8;
+	return !br.readBits(new_bit_pos - br.bit_pos_);
+}
+function readBlockLength(table, index, br) {
+	const { offset, nbits } = kBlockLengthPrefixCode[readSymbol(table, index, br)];
+	return offset + br.readBits(nbits);
+}
+export { copyUncompressedBlockToOutput, decodeBlockType, decodeMetaBlockLength, decodeVarLenUint8, decodeWindowBits, jumpToByteBoundary, readBlockLength };