@gscdump/engine 3.5.0 → 3.6.1

package/dist/node_modules/.pnpm/hyparquet@1.29.2/node_modules/hyparquet/src/column.mjs

@@ -1,129 +1,8 @@
-import { Encodings, PageTypes } from "./constants.mjs";
-import { convert, convertWithDictionary } from "./convert.mjs";
-import { isFlatColumn } from "./schema.mjs";
-import { deserializeTCompactProtocol } from "./thrift.mjs";
-import { assembleLists } from "./assemble.mjs";
-import { readPlain } from "./plain.mjs";
-import { decompressPage, readDataPage, readDataPageV2 } from "./datapage.mjs";
-function readColumn(reader, { groupStart, selectStart, selectEnd }, columnDecoder, onPage) {
-	const { pathInSchema, schemaPath } = columnDecoder;
-	const isFlat = isFlatColumn(schemaPath);
-	const chunks = [];
-	let dictionary = void 0;
-	let lastChunk = void 0;
-	let rowCount = 0;
-	let skipped = 0;
-	const emitLastChunk = onPage && (() => {
-		lastChunk && onPage({
-			pathInSchema,
-			columnData: lastChunk,
-			rowStart: groupStart + rowCount - lastChunk.length,
-			rowEnd: groupStart + rowCount
-		});
-	});
-	while (isFlat ? rowCount < selectEnd : reader.offset < reader.view.byteLength - 1) {
-		if (reader.offset >= reader.view.byteLength - 1) break;
-		const header = parquetHeader(reader);
-		if (header.type === "DICTIONARY_PAGE") {
-			const { data } = readPage(reader, header, columnDecoder, dictionary, void 0, 0);
-			if (data) dictionary = convert(data, columnDecoder);
-		} else {
-			const lastChunkLength = lastChunk?.length || 0;
-			const result = readPage(reader, header, columnDecoder, dictionary, lastChunk, selectStart - rowCount);
-			if (result.skipped) {
-				if (!chunks.length) skipped += result.skipped;
-				rowCount += result.skipped;
-			} else if (result.data && lastChunk === result.data) rowCount += result.data.length - lastChunkLength;
-			else if (result.data && result.data.length) {
-				emitLastChunk?.();
-				chunks.push(result.data);
-				rowCount += result.data.length;
-				lastChunk = result.data;
-			}
-		}
-	}
-	emitLastChunk?.();
-	return {
-		data: chunks,
-		skipped
-	};
-}
-function readPage(reader, header, columnDecoder, dictionary, previousChunk, pageStart) {
-	const { type, element, schemaPath, codec, compressors } = columnDecoder;
-	const compressedBytes = new Uint8Array(reader.view.buffer, reader.view.byteOffset + reader.offset, header.compressed_page_size);
-	reader.offset += header.compressed_page_size;
-	if (header.type === "DATA_PAGE") {
-		const daph = header.data_page_header;
-		if (!daph) throw new Error("parquet data page header is undefined");
-		if (pageStart > daph.num_values && isFlatColumn(schemaPath)) return { skipped: daph.num_values };
-		const page = decompressPage(compressedBytes, Number(header.uncompressed_page_size), codec, compressors);
-		const { definitionLevels, repetitionLevels, dataPage } = readDataPage(page, daph, columnDecoder);
-		const values = convertWithDictionary(dataPage, dictionary, daph.encoding, columnDecoder);
-		return {
-			skipped: 0,
-			data: assembleLists(Array.isArray(previousChunk) ? previousChunk : [], definitionLevels, repetitionLevels, values, schemaPath)
-		};
-	} else if (header.type === "DATA_PAGE_V2") {
-		const daph2 = header.data_page_header_v2;
-		if (!daph2) throw new Error("parquet data page header v2 is undefined");
-		if (pageStart > daph2.num_rows) return { skipped: daph2.num_values };
-		const { definitionLevels, repetitionLevels, dataPage } = readDataPageV2(compressedBytes, header, columnDecoder);
-		const values = convertWithDictionary(dataPage, dictionary, daph2.encoding, columnDecoder);
-		return {
-			skipped: 0,
-			data: assembleLists(Array.isArray(previousChunk) ? previousChunk : [], definitionLevels, repetitionLevels, values, schemaPath)
-		};
-	} else if (header.type === "DICTIONARY_PAGE") {
-		const diph = header.dictionary_page_header;
-		if (!diph) throw new Error("parquet dictionary page header is undefined");
-		const page = decompressPage(compressedBytes, Number(header.uncompressed_page_size), codec, compressors);
-		const reader = {
-			view: new DataView(page.buffer, page.byteOffset, page.byteLength),
-			offset: 0
-		};
-		return {
-			skipped: 0,
-			data: readPlain(reader, type, diph.num_values, element.type_length)
-		};
-	} else throw new Error(`parquet unsupported page type: ${header.type}`);
-}
-function parquetHeader(reader) {
-	const header = deserializeTCompactProtocol(reader);
-	return {
-		type: PageTypes[header.field_1],
-		uncompressed_page_size: header.field_2,
-		compressed_page_size: header.field_3,
-		crc: header.field_4,
-		data_page_header: header.field_5 && {
-			num_values: header.field_5.field_1,
-			encoding: Encodings[header.field_5.field_2],
-			definition_level_encoding: Encodings[header.field_5.field_3],
-			repetition_level_encoding: Encodings[header.field_5.field_4],
-			statistics: header.field_5.field_5 && {
-				max: header.field_5.field_5.field_1,
-				min: header.field_5.field_5.field_2,
-				null_count: header.field_5.field_5.field_3,
-				distinct_count: header.field_5.field_5.field_4,
-				max_value: header.field_5.field_5.field_5,
-				min_value: header.field_5.field_5.field_6
-			}
-		},
-		index_page_header: header.field_6,
-		dictionary_page_header: header.field_7 && {
-			num_values: header.field_7.field_1,
-			encoding: Encodings[header.field_7.field_2],
-			is_sorted: header.field_7.field_3
-		},
-		data_page_header_v2: header.field_8 && {
-			num_values: header.field_8.field_1,
-			num_nulls: header.field_8.field_2,
-			num_rows: header.field_8.field_3,
-			encoding: Encodings[header.field_8.field_4],
-			definition_levels_byte_length: header.field_8.field_5,
-			repetition_levels_byte_length: header.field_8.field_6,
-			is_compressed: header.field_8.field_7 === void 0 ? true : header.field_8.field_7,
-			statistics: header.field_8.field_8
-		}
-	};
-}
-export { readColumn, readPage };
+import "./schema.mjs";
+import "./thrift.mjs";
+import "./constants.mjs";
+import "./convert.mjs";
+import "./assemble.mjs";
+import "./plain.mjs";
+import "./datapage.mjs";
+export {};

package/dist/node_modules/.pnpm/hyparquet@1.29.2/node_modules/hyparquet/src/convert.mjs

@@ -1,118 +1,3 @@
-import { wkbToGeojson } from "./wkb.mjs";
-const decoder = new TextDecoder();
-const DEFAULT_PARSERS = {
-	timestampFromMilliseconds(millis) {
-		return new Date(Number(millis));
-	},
-	timestampFromMicroseconds(micros) {
-		return new Date(Number(micros / 1000n));
-	},
-	timestampFromNanoseconds(nanos) {
-		return new Date(Number(nanos / 1000000n));
-	},
-	dateFromDays(days) {
-		return /* @__PURE__ */ new Date(days * 864e5);
-	},
-	stringFromBytes(bytes) {
-		return bytes && decoder.decode(bytes);
-	},
-	jsonFromBytes(bytes) {
-		return bytes && JSON.parse(decoder.decode(bytes));
-	},
-	geometryFromBytes(bytes) {
-		return bytes && wkbToGeojson({
-			view: new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength),
-			offset: 0
-		});
-	},
-	geographyFromBytes(bytes) {
-		return bytes && wkbToGeojson({
-			view: new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength),
-			offset: 0
-		});
-	},
-	uuidFromBytes(bytes) {
-		if (!bytes) return void 0;
-		const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
-		return hex.slice(0, 8) + "-" + hex.slice(8, 12) + "-" + hex.slice(12, 16) + "-" + hex.slice(16, 20) + "-" + hex.slice(20, 32);
-	}
-};
-function convertWithDictionary(data, dictionary, encoding, columnDecoder) {
-	if (dictionary && encoding.endsWith("_DICTIONARY")) {
-		let output = data;
-		if (data instanceof Uint8Array && !(dictionary instanceof Uint8Array)) output = new dictionary.constructor(data.length);
-		for (let i = 0; i < data.length; i++) output[i] = dictionary[data[i]];
-		return output;
-	} else return convert(data, columnDecoder);
-}
-function convert(data, columnDecoder) {
-	const { element, parsers, utf8 = true, schemaPath } = columnDecoder;
-	const { type, converted_type: ctype, logical_type: ltype } = element;
-	const nullable = element.repetition_type !== "REQUIRED";
-	if (schemaPath?.some((s) => s.element.logical_type?.type === "VARIANT") && type === "BYTE_ARRAY" && ctype !== "UTF8" && ltype?.type !== "STRING") return data;
-	if (ctype === "DECIMAL") {
-		const factor = 10 ** -(element.scale || 0);
-		const arr = new Array(data.length);
-		for (let i = 0; i < arr.length; i++) if (data[i] instanceof Uint8Array) arr[i] = parseDecimal(data[i]) * factor;
-		else arr[i] = Number(data[i]) * factor;
-		return arr;
-	}
-	if (!ctype && type === "INT96") return Array.from(data).map((v) => parsers.timestampFromNanoseconds(parseInt96Nanos(v)));
-	if (ctype === "DATE") return Array.from(data).map((v) => parsers.dateFromDays(v));
-	if (ctype === "TIMESTAMP_MILLIS") return Array.from(data).map((v) => parsers.timestampFromMilliseconds(v));
-	if (ctype === "TIMESTAMP_MICROS") return Array.from(data).map((v) => parsers.timestampFromMicroseconds(v));
-	if (ctype === "JSON") return data.map((v) => parsers.jsonFromBytes(v));
-	if (ctype === "BSON") throw new Error("parquet bson not supported");
-	if (ctype === "INTERVAL") throw new Error("parquet interval not supported");
-	if (ltype?.type === "GEOMETRY") return data.map((v) => parsers.geometryFromBytes(v));
-	if (ltype?.type === "GEOGRAPHY") return data.map((v) => parsers.geographyFromBytes(v));
-	if (ltype?.type === "UUID") return data.map((v) => parsers.uuidFromBytes(v));
-	if (ctype === "UTF8" || ltype?.type === "STRING" || utf8 && type === "BYTE_ARRAY") return data.map((v) => parsers.stringFromBytes(v));
-	if (ctype === "UINT_64" || ltype?.type === "INTEGER" && ltype.bitWidth === 64 && !ltype.isSigned) {
-		if (data instanceof BigInt64Array) return new BigUint64Array(data.buffer, data.byteOffset, data.length);
-		const arr = nullable ? new Array(data.length) : new BigUint64Array(data.length);
-		for (let i = 0; i < arr.length; i++) arr[i] = data[i];
-		return arr;
-	}
-	if (ctype === "UINT_32" || ltype?.type === "INTEGER" && ltype.bitWidth === 32 && !ltype.isSigned) {
-		if (data instanceof Int32Array) return new Uint32Array(data.buffer, data.byteOffset, data.length);
-		const arr = nullable ? new Array(data.length) : new Uint32Array(data.length);
-		for (let i = 0; i < arr.length; i++) arr[i] = data[i] < 0 ? 4294967296 + data[i] : data[i];
-		return arr;
-	}
-	if (ltype?.type === "FLOAT16") return Array.from(data).map(parseFloat16);
-	if (ltype?.type === "TIMESTAMP") {
-		const { unit } = ltype;
-		let parser = parsers.timestampFromMilliseconds;
-		if (unit === "MICROS") parser = parsers.timestampFromMicroseconds;
-		if (unit === "NANOS") parser = parsers.timestampFromNanoseconds;
-		const arr = new Array(data.length);
-		for (let i = 0; i < arr.length; i++) arr[i] = parser(data[i]);
-		return arr;
-	}
-	return data;
-}
-function parseDecimal(bytes) {
-	if (!bytes.length) return 0;
-	let value = 0n;
-	for (const byte of bytes) value = value * 256n + BigInt(byte);
-	const bits = bytes.length * 8;
-	if (value >= 2n ** BigInt(bits - 1)) value -= 2n ** BigInt(bits);
-	return Number(value);
-}
-function parseInt96Nanos(value) {
-	const days = (value >> 64n) - 2440588n;
-	const nano = value & 18446744073709551615n;
-	return days * 86400000000000n + nano;
-}
-function parseFloat16(bytes) {
-	if (!bytes) return void 0;
-	const int16 = bytes[1] << 8 | bytes[0];
-	const sign = int16 >> 15 ? -1 : 1;
-	const exp = int16 >> 10 & 31;
-	const frac = int16 & 1023;
-	if (exp === 0) return sign * 2 ** -14 * (frac / 1024);
-	if (exp === 31) return frac ? NaN : sign * Infinity;
-	return sign * 2 ** (exp - 15) * (1 + frac / 1024);
-}
-export { DEFAULT_PARSERS, convert, convertWithDictionary, parseDecimal, parseFloat16 };
+import "./wkb.mjs";
+new TextDecoder();
+export {};

package/dist/node_modules/.pnpm/hyparquet@1.29.2/node_modules/hyparquet/src/datapage.mjs

@@ -1,144 +1,6 @@
-import { getMaxDefinitionLevel, getMaxRepetitionLevel } from "./schema.mjs";
-import { deltaBinaryUnpack, deltaByteArray, deltaLengthByteArray } from "./delta.mjs";
-import { byteStreamSplit, readRleBitPackedHybrid } from "./encoding.mjs";
-import { readPlain } from "./plain.mjs";
-import { snappyUncompress } from "./snappy.mjs";
-function readDataPage(bytes, daph, { type, element, schemaPath }) {
-	const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-	const reader = {
-		view,
-		offset: 0
-	};
-	let dataPage;
-	const repetitionLevels = readRepetitionLevels(reader, daph, schemaPath);
-	const { definitionLevels, numNulls } = readDefinitionLevels(reader, daph, schemaPath);
-	const nValues = daph.num_values - numNulls;
-	if (daph.encoding === "PLAIN") dataPage = readPlain(reader, type, nValues, element.type_length);
-	else if (daph.encoding === "PLAIN_DICTIONARY" || daph.encoding === "RLE_DICTIONARY" || daph.encoding === "RLE") {
-		const bitWidth = type === "BOOLEAN" ? 1 : view.getUint8(reader.offset++);
-		if (bitWidth) {
-			dataPage = new Array(nValues);
-			if (type === "BOOLEAN") {
-				readRleBitPackedHybrid(reader, bitWidth, dataPage);
-				dataPage = dataPage.map((x) => !!x);
-			} else readRleBitPackedHybrid(reader, bitWidth, dataPage, view.byteLength - reader.offset);
-		} else dataPage = new Uint8Array(nValues);
-	} else if (daph.encoding === "BYTE_STREAM_SPLIT") dataPage = byteStreamSplit(reader, nValues, type, element.type_length);
-	else if (daph.encoding === "DELTA_BINARY_PACKED") {
-		dataPage = type === "INT32" ? new Int32Array(nValues) : new BigInt64Array(nValues);
-		deltaBinaryUnpack(reader, nValues, dataPage);
-	} else if (daph.encoding === "DELTA_LENGTH_BYTE_ARRAY") {
-		dataPage = new Array(nValues);
-		deltaLengthByteArray(reader, nValues, dataPage);
-	} else throw new Error(`parquet unsupported encoding: ${daph.encoding}`);
-	return {
-		definitionLevels,
-		repetitionLevels,
-		dataPage
-	};
-}
-function readRepetitionLevels(reader, daph, schemaPath) {
-	if (schemaPath.length > 1) {
-		const maxRepetitionLevel = getMaxRepetitionLevel(schemaPath);
-		if (maxRepetitionLevel) {
-			const values = new Array(daph.num_values);
-			readRleBitPackedHybrid(reader, bitWidth(maxRepetitionLevel), values);
-			return values;
-		}
-	}
-	return [];
-}
-function readDefinitionLevels(reader, daph, schemaPath) {
-	const maxDefinitionLevel = getMaxDefinitionLevel(schemaPath);
-	if (!maxDefinitionLevel) return {
-		definitionLevels: [],
-		numNulls: 0
-	};
-	const definitionLevels = new Array(daph.num_values);
-	readRleBitPackedHybrid(reader, bitWidth(maxDefinitionLevel), definitionLevels);
-	let numNulls = daph.num_values;
-	for (const def of definitionLevels) if (def === maxDefinitionLevel) numNulls--;
-	if (numNulls === 0) definitionLevels.length = 0;
-	return {
-		definitionLevels,
-		numNulls
-	};
-}
-function decompressPage(compressedBytes, uncompressed_page_size, codec, compressors) {
-	let page;
-	const customDecompressor = compressors?.[codec];
-	if (codec === "UNCOMPRESSED") page = compressedBytes;
-	else if (customDecompressor) page = customDecompressor(compressedBytes, uncompressed_page_size);
-	else if (codec === "SNAPPY") {
-		page = new Uint8Array(uncompressed_page_size);
-		snappyUncompress(compressedBytes, page);
-	} else throw new Error(`parquet unsupported compression codec: ${codec}`);
-	if (page?.length !== uncompressed_page_size) throw new Error(`parquet decompressed page length ${page?.length} does not match header ${uncompressed_page_size}`);
-	return page;
-}
-function readDataPageV2(compressedBytes, ph, columnDecoder) {
-	const reader = {
-		view: new DataView(compressedBytes.buffer, compressedBytes.byteOffset, compressedBytes.byteLength),
-		offset: 0
-	};
-	const { type, element, schemaPath, codec, compressors } = columnDecoder;
-	const daph2 = ph.data_page_header_v2;
-	if (!daph2) throw new Error("parquet data page header v2 is undefined");
-	const repetitionLevels = readRepetitionLevelsV2(reader, daph2, schemaPath);
-	reader.offset = daph2.repetition_levels_byte_length;
-	const definitionLevels = readDefinitionLevelsV2(reader, daph2, schemaPath);
-	const uncompressedPageSize = ph.uncompressed_page_size - daph2.definition_levels_byte_length - daph2.repetition_levels_byte_length;
-	let page = compressedBytes.subarray(reader.offset);
-	if (daph2.is_compressed !== false) page = decompressPage(page, uncompressedPageSize, codec, compressors);
-	const pageView = new DataView(page.buffer, page.byteOffset, page.byteLength);
-	const pageReader = {
-		view: pageView,
-		offset: 0
-	};
-	let dataPage;
-	const nValues = daph2.num_values - daph2.num_nulls;
-	if (daph2.encoding === "PLAIN") dataPage = readPlain(pageReader, type, nValues, element.type_length);
-	else if (daph2.encoding === "RLE") {
-		dataPage = new Array(nValues);
-		readRleBitPackedHybrid(pageReader, 1, dataPage);
-		dataPage = dataPage.map((x) => !!x);
-	} else if (daph2.encoding === "PLAIN_DICTIONARY" || daph2.encoding === "RLE_DICTIONARY") {
-		const bitWidth = pageView.getUint8(pageReader.offset++);
-		dataPage = new Array(nValues);
-		readRleBitPackedHybrid(pageReader, bitWidth, dataPage, uncompressedPageSize - 1);
-	} else if (daph2.encoding === "DELTA_BINARY_PACKED") {
-		dataPage = type === "INT32" ? new Int32Array(nValues) : new BigInt64Array(nValues);
-		deltaBinaryUnpack(pageReader, nValues, dataPage);
-	} else if (daph2.encoding === "DELTA_LENGTH_BYTE_ARRAY") {
-		dataPage = new Array(nValues);
-		deltaLengthByteArray(pageReader, nValues, dataPage);
-	} else if (daph2.encoding === "DELTA_BYTE_ARRAY") {
-		dataPage = new Array(nValues);
-		deltaByteArray(pageReader, nValues, dataPage);
-	} else if (daph2.encoding === "BYTE_STREAM_SPLIT") dataPage = byteStreamSplit(pageReader, nValues, type, element.type_length);
-	else throw new Error(`parquet unsupported encoding: ${daph2.encoding}`);
-	return {
-		definitionLevels,
-		repetitionLevels,
-		dataPage
-	};
-}
-function readRepetitionLevelsV2(reader, daph2, schemaPath) {
-	const maxRepetitionLevel = getMaxRepetitionLevel(schemaPath);
-	if (!maxRepetitionLevel) return [];
-	const values = new Array(daph2.num_values);
-	readRleBitPackedHybrid(reader, bitWidth(maxRepetitionLevel), values, daph2.repetition_levels_byte_length);
-	return values;
-}
-function readDefinitionLevelsV2(reader, daph2, schemaPath) {
-	const maxDefinitionLevel = getMaxDefinitionLevel(schemaPath);
-	if (maxDefinitionLevel) {
-		const values = new Array(daph2.num_values);
-		readRleBitPackedHybrid(reader, bitWidth(maxDefinitionLevel), values, daph2.definition_levels_byte_length);
-		return values;
-	}
-}
-function bitWidth(value) {
-	return 32 - Math.clz32(value);
-}
-export { decompressPage, readDataPage, readDataPageV2 };
+import "./schema.mjs";
+import "./delta.mjs";
+import "./encoding.mjs";
+import "./plain.mjs";
+import "./snappy.mjs";
+export {};

package/dist/node_modules/.pnpm/hyparquet@1.29.2/node_modules/hyparquet/src/delta.mjs

@@ -1,65 +1,2 @@
-import { readVarInt, readZigZagBigInt } from "./thrift.mjs";
-function deltaBinaryUnpack(reader, count, output) {
-	const int32 = output instanceof Int32Array;
-	const blockSize = readVarInt(reader);
-	const miniblockPerBlock = readVarInt(reader);
-	readVarInt(reader);
-	let value = readZigZagBigInt(reader);
-	let outputIndex = 0;
-	output[outputIndex++] = int32 ? Number(value) : value;
-	const valuesPerMiniblock = blockSize / miniblockPerBlock;
-	while (outputIndex < count) {
-		const minDelta = readZigZagBigInt(reader);
-		const bitWidths = new Uint8Array(miniblockPerBlock);
-		for (let i = 0; i < miniblockPerBlock; i++) bitWidths[i] = reader.view.getUint8(reader.offset++);
-		for (let i = 0; i < miniblockPerBlock && outputIndex < count; i++) {
-			const bitWidth = BigInt(bitWidths[i]);
-			if (bitWidth) {
-				let bitpackPos = 0n;
-				let miniblockCount = valuesPerMiniblock;
-				const mask = (1n << bitWidth) - 1n;
-				while (miniblockCount && outputIndex < count) {
-					let bits = BigInt(reader.view.getUint8(reader.offset)) >> bitpackPos & mask;
-					bitpackPos += bitWidth;
-					while (bitpackPos >= 8) {
-						bitpackPos -= 8n;
-						reader.offset++;
-						if (bitpackPos) bits |= BigInt(reader.view.getUint8(reader.offset)) << bitWidth - bitpackPos & mask;
-					}
-					const delta = minDelta + bits;
-					value += delta;
-					output[outputIndex++] = int32 ? Number(value) : value;
-					miniblockCount--;
-				}
-				if (miniblockCount) reader.offset += Math.ceil((miniblockCount * Number(bitWidth) + Number(bitpackPos)) / 8);
-			} else for (let j = 0; j < valuesPerMiniblock && outputIndex < count; j++) {
-				value += minDelta;
-				output[outputIndex++] = int32 ? Number(value) : value;
-			}
-		}
-	}
-}
-function deltaLengthByteArray(reader, count, output) {
-	const lengths = new Int32Array(count);
-	deltaBinaryUnpack(reader, count, lengths);
-	for (let i = 0; i < count; i++) {
-		output[i] = new Uint8Array(reader.view.buffer, reader.view.byteOffset + reader.offset, lengths[i]);
-		reader.offset += lengths[i];
-	}
-}
-function deltaByteArray(reader, count, output) {
-	const prefixData = new Int32Array(count);
-	deltaBinaryUnpack(reader, count, prefixData);
-	const suffixData = new Int32Array(count);
-	deltaBinaryUnpack(reader, count, suffixData);
-	for (let i = 0; i < count; i++) {
-		const suffix = new Uint8Array(reader.view.buffer, reader.view.byteOffset + reader.offset, suffixData[i]);
-		if (prefixData[i]) {
-			output[i] = new Uint8Array(prefixData[i] + suffixData[i]);
-			output[i].set(output[i - 1].subarray(0, prefixData[i]));
-			output[i].set(suffix, prefixData[i]);
-		} else output[i] = suffix;
-		reader.offset += suffixData[i];
-	}
-}
-export { deltaBinaryUnpack, deltaByteArray, deltaLengthByteArray };
+import "./thrift.mjs";
+export {};

package/dist/node_modules/.pnpm/hyparquet@1.29.2/node_modules/hyparquet/src/encoding.mjs

@@ -1,76 +1,2 @@
-import { readVarInt } from "./thrift.mjs";
-function readRleBitPackedHybrid(reader, width, output, length) {
-	if (length === void 0) {
-		length = reader.view.getUint32(reader.offset, true);
-		reader.offset += 4;
-	}
-	const startOffset = reader.offset;
-	let seen = 0;
-	while (seen < output.length) {
-		const header = readVarInt(reader);
-		if (header & 1) seen = readBitPacked(reader, header, width, output, seen);
-		else {
-			const count = header >>> 1;
-			readRle(reader, count, width, output, seen);
-			seen += count;
-		}
-	}
-	reader.offset = startOffset + length;
-}
-function readRle(reader, count, bitWidth, output, seen) {
-	const width = bitWidth + 7 >> 3;
-	let value = 0;
-	for (let i = 0; i < width; i++) value |= reader.view.getUint8(reader.offset++) << (i << 3);
-	for (let i = 0; i < count; i++) output[seen + i] = value;
-}
-function readBitPacked(reader, header, bitWidth, output, seen) {
-	let count = header >> 1 << 3;
-	const mask = (1 << bitWidth) - 1;
-	let data = 0;
-	if (reader.offset < reader.view.byteLength) data = reader.view.getUint8(reader.offset++);
-	else if (mask) throw new Error(`parquet bitpack offset ${reader.offset} out of range`);
-	let left = 8;
-	let right = 0;
-	while (count) if (right > 8) {
-		right -= 8;
-		left -= 8;
-		data >>>= 8;
-	} else if (left - right < bitWidth) {
-		data |= reader.view.getUint8(reader.offset) << left;
-		reader.offset++;
-		left += 8;
-	} else {
-		if (seen < output.length) output[seen++] = data >> right & mask;
-		count--;
-		right += bitWidth;
-	}
-	return seen;
-}
-function byteStreamSplit(reader, count, type, typeLength) {
-	const width = byteWidth(type, typeLength);
-	const bytes = new Uint8Array(count * width);
-	for (let b = 0; b < width; b++) for (let i = 0; i < count; i++) bytes[i * width + b] = reader.view.getUint8(reader.offset++);
-	if (type === "FLOAT") return new Float32Array(bytes.buffer);
-	else if (type === "DOUBLE") return new Float64Array(bytes.buffer);
-	else if (type === "INT32") return new Int32Array(bytes.buffer);
-	else if (type === "INT64") return new BigInt64Array(bytes.buffer);
-	else if (type === "FIXED_LEN_BYTE_ARRAY") {
-		const split = new Array(count);
-		for (let i = 0; i < count; i++) split[i] = bytes.subarray(i * width, (i + 1) * width);
-		return split;
-	}
-	throw new Error(`parquet byte_stream_split unsupported type: ${type}`);
-}
-function byteWidth(type, typeLength) {
-	switch (type) {
-		case "INT32":
-		case "FLOAT": return 4;
-		case "INT64":
-		case "DOUBLE": return 8;
-		case "FIXED_LEN_BYTE_ARRAY":
-			if (!typeLength) throw new Error("parquet byteWidth missing type_length");
-			return typeLength;
-		default: throw new Error(`parquet unsupported type: ${type}`);
-	}
-}
-export { byteStreamSplit, readRleBitPackedHybrid };
+import "./thrift.mjs";
+export {};