@gscdump/engine 1.4.0 → 1.4.2

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

@@ -0,0 +1,144 @@
+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 };

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

@@ -0,0 +1,65 @@
+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 };

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

@@ -0,0 +1,76 @@
+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 };

package/dist/node_modules/.pnpm/hyparquet@1.26.2/node_modules/hyparquet/src/filter.mjs

@@ -0,0 +1,98 @@
+import { hashParquetValue, sbbfContains } from "./bloom.mjs";
+import { equals } from "./utils.mjs";
+function columnsNeededForFilter(filter) {
+	if (!filter) return [];
+	const columns = [];
+	if ("$and" in filter && Array.isArray(filter.$and)) columns.push(...filter.$and.flatMap(columnsNeededForFilter));
+	else if ("$or" in filter && Array.isArray(filter.$or)) columns.push(...filter.$or.flatMap(columnsNeededForFilter));
+	else if ("$nor" in filter && Array.isArray(filter.$nor)) columns.push(...filter.$nor.flatMap(columnsNeededForFilter));
+	else columns.push(...Object.keys(filter).map((key) => key.split(".")[0]));
+	return [...new Set(columns)];
+}
+function matchFilter(record, filter, strict = true) {
+	if ("$and" in filter && Array.isArray(filter.$and)) return filter.$and.every((subQuery) => matchFilter(record, subQuery, strict));
+	if ("$or" in filter && Array.isArray(filter.$or)) return filter.$or.some((subQuery) => matchFilter(record, subQuery, strict));
+	if ("$nor" in filter && Array.isArray(filter.$nor)) return !filter.$nor.some((subQuery) => matchFilter(record, subQuery, strict));
+	return Object.entries(filter).every(([field, condition]) => {
+		const value = resolve(record, field);
+		if (typeof condition !== "object" || condition === null || Array.isArray(condition)) return equals(value, condition, strict);
+		return Object.entries(condition || {}).every(([operator, target]) => {
+			if (operator === "$gt") return value > target;
+			if (operator === "$gte") return value >= target;
+			if (operator === "$lt") return value < target;
+			if (operator === "$lte") return value <= target;
+			if (operator === "$eq") return equals(value, target, strict);
+			if (operator === "$ne") return !equals(value, target, strict);
+			if (operator === "$in") return Array.isArray(target) && target.includes(value);
+			if (operator === "$nin") return Array.isArray(target) && !target.includes(value);
+			if (operator === "$not") return !matchFilter({ [field]: value }, { [field]: target }, strict);
+			return true;
+		});
+	});
+}
+function canSkipRowGroup({ rowGroup, physicalColumns, filter, strict = true, bloomFilters, schemaElements }) {
+	if (!filter) return false;
+	if ("$and" in filter && Array.isArray(filter.$and)) return filter.$and.some((subFilter) => canSkipRowGroup({
+		rowGroup,
+		physicalColumns,
+		filter: subFilter,
+		strict,
+		bloomFilters,
+		schemaElements
+	}));
+	if ("$or" in filter && Array.isArray(filter.$or)) return filter.$or.every((subFilter) => canSkipRowGroup({
+		rowGroup,
+		physicalColumns,
+		filter: subFilter,
+		strict,
+		bloomFilters,
+		schemaElements
+	}));
+	if ("$nor" in filter && Array.isArray(filter.$nor)) return false;
+	for (const [field, condition] of Object.entries(filter)) {
+		const columnIndex = physicalColumns.indexOf(field);
+		if (columnIndex === -1) continue;
+		const { min, max, min_value, max_value } = rowGroup.columns[columnIndex].meta_data?.statistics || {};
+		const minVal = min_value !== void 0 ? min_value : min;
+		const maxVal = max_value !== void 0 ? max_value : max;
+		const haveStats = minVal !== void 0 && maxVal !== void 0;
+		const bloom = bloomFilters?.[field];
+		const element = schemaElements?.[field];
+		for (const [operator, target] of Object.entries(condition || {})) {
+			if (haveStats) {
+				if (operator === "$gt" && maxVal <= target) return true;
+				if (operator === "$gte" && maxVal < target) return true;
+				if (operator === "$lt" && minVal >= target) return true;
+				if (operator === "$lte" && minVal > target) return true;
+				if (operator === "$eq" && (target < minVal || target > maxVal)) return true;
+				if (operator === "$ne" && equals(minVal, maxVal, strict) && equals(minVal, target, strict)) return true;
+				if (operator === "$in" && Array.isArray(target) && target.every((v) => v < minVal || v > maxVal)) return true;
+				if (operator === "$nin" && Array.isArray(target) && equals(minVal, maxVal, strict) && target.includes(minVal)) return true;
+			}
+			if (bloom && element) {
+				if (operator === "$eq") {
+					const hash = hashParquetValue(target, element);
+					if (hash !== void 0 && !sbbfContains(bloom.blocks, hash)) return true;
+				}
+				if (operator === "$in" && Array.isArray(target) && target.length > 0) {
+					let allAbsent = true;
+					for (const v of target) {
+						const h = hashParquetValue(v, element);
+						if (h === void 0 || sbbfContains(bloom.blocks, h)) {
+							allAbsent = false;
+							break;
+						}
+					}
+					if (allAbsent) return true;
+				}
+			}
+		}
+	}
+	return false;
+}
+function resolve(record, path) {
+	let value = record;
+	for (const part of path.split(".")) value = value?.[part];
+	return value;
+}
+export { canSkipRowGroup, columnsNeededForFilter, matchFilter };

package/dist/node_modules/.pnpm/hyparquet@1.26.2/node_modules/hyparquet/src/geoparquet.mjs

@@ -0,0 +1,24 @@
+function markGeoColumns(schema, key_value_metadata) {
+	const columns = /* @__PURE__ */ new Map();
+	const geo = key_value_metadata?.find(({ key }) => key === "geo")?.value;
+	const decodedColumns = (geo && JSON.parse(geo)?.columns) ?? {};
+	for (const [name, column] of Object.entries(decodedColumns)) {
+		if (column.encoding !== "WKB") continue;
+		const type = column.edges === "spherical" ? "GEOGRAPHY" : "GEOMETRY";
+		const id = column.crs?.id ?? column.crs?.ids?.[0];
+		const crs = id ? `${id.authority}:${id.code.toString()}` : void 0;
+		columns.set(name, {
+			type,
+			crs
+		});
+	}
+	for (let i = 1; i < schema.length; i++) {
+		const { logical_type, name, num_children, type } = schema[i];
+		if (num_children) {
+			i += num_children;
+			continue;
+		}
+		if (type === "BYTE_ARRAY" && !logical_type) schema[i].logical_type = columns.get(name);
+	}
+}
+export { markGeoColumns };

package/dist/node_modules/.pnpm/hyparquet@1.26.2/node_modules/hyparquet/src/index.mjs

@@ -0,0 +1,7 @@
+import "./metadata.mjs";
+import "./indexes.mjs";
+import "./utils.mjs";
+import "./snappy.mjs";
+import { parquetReadObjects } from "./read.mjs";
+import "./query.mjs";
+export { parquetReadObjects };

package/dist/node_modules/.pnpm/hyparquet@1.26.2/node_modules/hyparquet/src/indexes.mjs

@@ -0,0 +1,16 @@
+import "./constants.mjs";
+import "./convert.mjs";
+import { deserializeTCompactProtocol } from "./thrift.mjs";
+import "./metadata.mjs";
+function readOffsetIndex(reader) {
+	const thrift = deserializeTCompactProtocol(reader);
+	return {
+		page_locations: thrift.field_1.map((loc) => ({
+			offset: loc.field_1,
+			compressed_page_size: loc.field_2,
+			first_row_index: loc.field_3
+		})),
+		unencoded_byte_array_data_bytes: thrift.field_2
+	};
+}
+export { readOffsetIndex };

package/dist/node_modules/.pnpm/hyparquet@1.26.2/node_modules/hyparquet/src/metadata.mjs

@@ -0,0 +1,235 @@
+import { CompressionCodecs, ConvertedTypes, EdgeInterpolationAlgorithms, Encodings, FieldRepetitionTypes, PageTypes, ParquetTypes } from "./constants.mjs";
+import { DEFAULT_PARSERS, parseDecimal, parseFloat16 } from "./convert.mjs";
+import { getSchemaPath } from "./schema.mjs";
+import { deserializeTCompactProtocol } from "./thrift.mjs";
+import { markGeoColumns } from "./geoparquet.mjs";
+const defaultInitialFetchSize = 1 << 19;
+const decoder = new TextDecoder();
+function decode(value) {
+	return value && decoder.decode(value);
+}
+async function parquetMetadataAsync(asyncBuffer, { parsers, initialFetchSize = defaultInitialFetchSize, geoparquet = true } = {}) {
+	if (!asyncBuffer || !(asyncBuffer.byteLength >= 0)) throw new Error("parquet expected AsyncBuffer");
+	const footerOffset = Math.max(0, asyncBuffer.byteLength - initialFetchSize);
+	const footerBuffer = await asyncBuffer.slice(footerOffset, asyncBuffer.byteLength);
+	const footerView = new DataView(footerBuffer);
+	if (footerView.getUint32(footerBuffer.byteLength - 4, true) !== 827474256) throw new Error("parquet file invalid (footer != PAR1)");
+	const metadataLength = footerView.getUint32(footerBuffer.byteLength - 8, true);
+	if (metadataLength > asyncBuffer.byteLength - 8) throw new Error(`parquet metadata length ${metadataLength} exceeds available buffer ${asyncBuffer.byteLength - 8}`);
+	if (metadataLength + 8 > initialFetchSize) {
+		const metadataOffset = asyncBuffer.byteLength - metadataLength - 8;
+		const metadataBuffer = await asyncBuffer.slice(metadataOffset, footerOffset);
+		const combinedBuffer = new ArrayBuffer(metadataLength + 8);
+		const combinedView = new Uint8Array(combinedBuffer);
+		combinedView.set(new Uint8Array(metadataBuffer));
+		combinedView.set(new Uint8Array(footerBuffer), footerOffset - metadataOffset);
+		return parquetMetadata(combinedBuffer, {
+			parsers,
+			geoparquet
+		});
+	} else return parquetMetadata(footerBuffer, {
+		parsers,
+		geoparquet
+	});
+}
+function parquetMetadata(arrayBuffer, { parsers, geoparquet = true } = {}) {
+	if (!(arrayBuffer instanceof ArrayBuffer)) throw new Error("parquet expected ArrayBuffer");
+	const view = new DataView(arrayBuffer);
+	parsers = {
+		...DEFAULT_PARSERS,
+		...parsers
+	};
+	if (view.byteLength < 8) throw new Error("parquet file is too short");
+	if (view.getUint32(view.byteLength - 4, true) !== 827474256) throw new Error("parquet file invalid (footer != PAR1)");
+	const metadataLengthOffset = view.byteLength - 8;
+	const metadataLength = view.getUint32(metadataLengthOffset, true);
+	if (metadataLength > view.byteLength - 8) throw new Error(`parquet metadata length ${metadataLength} exceeds available buffer ${view.byteLength - 8}`);
+	const metadata = deserializeTCompactProtocol({
+		view,
+		offset: metadataLengthOffset - metadataLength
+	});
+	const version = metadata.field_1;
+	const schema = metadata.field_2.map((field) => ({
+		type: ParquetTypes[field.field_1],
+		type_length: field.field_2,
+		repetition_type: FieldRepetitionTypes[field.field_3],
+		name: decode(field.field_4),
+		num_children: field.field_5,
+		converted_type: ConvertedTypes[field.field_6],
+		scale: field.field_7,
+		precision: field.field_8,
+		field_id: field.field_9,
+		logical_type: logicalType(field.field_10)
+	}));
+	const columnSchema = schema.filter((e) => e.type);
+	const num_rows = metadata.field_3;
+	const row_groups = metadata.field_4.map((rowGroup) => ({
+		columns: rowGroup.field_1.map((column, columnIndex) => ({
+			file_path: decode(column.field_1),
+			file_offset: column.field_2,
+			meta_data: column.field_3 && {
+				type: ParquetTypes[column.field_3.field_1],
+				encodings: column.field_3.field_2?.map((e) => Encodings[e]),
+				path_in_schema: column.field_3.field_3.map(decode),
+				codec: CompressionCodecs[column.field_3.field_4],
+				num_values: column.field_3.field_5,
+				total_uncompressed_size: column.field_3.field_6,
+				total_compressed_size: column.field_3.field_7,
+				key_value_metadata: column.field_3.field_8?.map((kv) => ({
+					key: decode(kv.field_1),
+					value: decode(kv.field_2)
+				})),
+				data_page_offset: column.field_3.field_9,
+				index_page_offset: column.field_3.field_10,
+				dictionary_page_offset: column.field_3.field_11,
+				statistics: convertStats(column.field_3.field_12, columnSchema[columnIndex], parsers),
+				encoding_stats: column.field_3.field_13?.map((encodingStat) => ({
+					page_type: PageTypes[encodingStat.field_1],
+					encoding: Encodings[encodingStat.field_2],
+					count: encodingStat.field_3
+				})),
+				bloom_filter_offset: column.field_3.field_14,
+				bloom_filter_length: column.field_3.field_15,
+				size_statistics: column.field_3.field_16 && {
+					unencoded_byte_array_data_bytes: column.field_3.field_16.field_1,
+					repetition_level_histogram: column.field_3.field_16.field_2,
+					definition_level_histogram: column.field_3.field_16.field_3
+				},
+				geospatial_statistics: column.field_3.field_17 && {
+					bbox: column.field_3.field_17.field_1 && {
+						xmin: column.field_3.field_17.field_1.field_1,
+						xmax: column.field_3.field_17.field_1.field_2,
+						ymin: column.field_3.field_17.field_1.field_3,
+						ymax: column.field_3.field_17.field_1.field_4,
+						zmin: column.field_3.field_17.field_1.field_5,
+						zmax: column.field_3.field_17.field_1.field_6,
+						mmin: column.field_3.field_17.field_1.field_7,
+						mmax: column.field_3.field_17.field_1.field_8
+					},
+					geospatial_types: column.field_3.field_17.field_2
+				}
+			},
+			offset_index_offset: column.field_4,
+			offset_index_length: column.field_5,
+			column_index_offset: column.field_6,
+			column_index_length: column.field_7,
+			crypto_metadata: column.field_8,
+			encrypted_column_metadata: column.field_9
+		})),
+		total_byte_size: rowGroup.field_2,
+		num_rows: rowGroup.field_3,
+		sorting_columns: rowGroup.field_4?.map((sortingColumn) => ({
+			column_idx: sortingColumn.field_1,
+			descending: sortingColumn.field_2,
+			nulls_first: sortingColumn.field_3
+		})),
+		file_offset: rowGroup.field_5,
+		total_compressed_size: rowGroup.field_6,
+		ordinal: rowGroup.field_7
+	}));
+	const key_value_metadata = metadata.field_5?.map((kv) => ({
+		key: decode(kv.field_1),
+		value: decode(kv.field_2)
+	}));
+	const created_by = decode(metadata.field_6);
+	if (geoparquet) markGeoColumns(schema, key_value_metadata);
+	return {
+		version,
+		schema,
+		num_rows,
+		row_groups,
+		key_value_metadata,
+		created_by,
+		metadata_length: metadataLength
+	};
+}
+function parquetSchema({ schema }) {
+	return getSchemaPath(schema, [])[0];
+}
+function logicalType(logicalType) {
+	if (logicalType?.field_1) return { type: "STRING" };
+	if (logicalType?.field_2) return { type: "MAP" };
+	if (logicalType?.field_3) return { type: "LIST" };
+	if (logicalType?.field_4) return { type: "ENUM" };
+	if (logicalType?.field_5) return {
+		type: "DECIMAL",
+		scale: logicalType.field_5.field_1,
+		precision: logicalType.field_5.field_2
+	};
+	if (logicalType?.field_6) return { type: "DATE" };
+	if (logicalType?.field_7) return {
+		type: "TIME",
+		isAdjustedToUTC: logicalType.field_7.field_1,
+		unit: timeUnit(logicalType.field_7.field_2)
+	};
+	if (logicalType?.field_8) return {
+		type: "TIMESTAMP",
+		isAdjustedToUTC: logicalType.field_8.field_1,
+		unit: timeUnit(logicalType.field_8.field_2)
+	};
+	if (logicalType?.field_10) return {
+		type: "INTEGER",
+		bitWidth: logicalType.field_10.field_1,
+		isSigned: logicalType.field_10.field_2
+	};
+	if (logicalType?.field_11) return { type: "NULL" };
+	if (logicalType?.field_12) return { type: "JSON" };
+	if (logicalType?.field_13) return { type: "BSON" };
+	if (logicalType?.field_14) return { type: "UUID" };
+	if (logicalType?.field_15) return { type: "FLOAT16" };
+	if (logicalType?.field_16) return {
+		type: "VARIANT",
+		specification_version: logicalType.field_16.field_1
+	};
+	if (logicalType?.field_17) return {
+		type: "GEOMETRY",
+		crs: decode(logicalType.field_17.field_1)
+	};
+	if (logicalType?.field_18) return {
+		type: "GEOGRAPHY",
+		crs: decode(logicalType.field_18.field_1),
+		algorithm: EdgeInterpolationAlgorithms[logicalType.field_18.field_2]
+	};
+	return logicalType;
+}
+function timeUnit(unit) {
+	if (unit.field_1) return "MILLIS";
+	if (unit.field_2) return "MICROS";
+	if (unit.field_3) return "NANOS";
+	throw new Error("parquet time unit required");
+}
+function convertStats(stats, schema, parsers) {
+	return stats && {
+		max: convertMetadata(stats.field_1, schema, parsers),
+		min: convertMetadata(stats.field_2, schema, parsers),
+		null_count: stats.field_3,
+		distinct_count: stats.field_4,
+		max_value: convertMetadata(stats.field_5, schema, parsers),
+		min_value: convertMetadata(stats.field_6, schema, parsers),
+		is_max_value_exact: stats.field_7,
+		is_min_value_exact: stats.field_8
+	};
+}
+function convertMetadata(value, schema, parsers) {
+	const { type, converted_type, logical_type } = schema;
+	if (value === void 0) return value;
+	if (type === "BOOLEAN") return value[0] === 1;
+	if (type === "BYTE_ARRAY") return parsers.stringFromBytes(value);
+	const view = new DataView(value.buffer, value.byteOffset, value.byteLength);
+	if (type === "FLOAT" && view.byteLength === 4) return view.getFloat32(0, true);
+	if (type === "DOUBLE" && view.byteLength === 8) return view.getFloat64(0, true);
+	if (type === "INT32" && converted_type === "DATE") return parsers.dateFromDays(view.getInt32(0, true));
+	if (type === "INT64" && converted_type === "TIMESTAMP_MILLIS") return parsers.timestampFromMilliseconds(view.getBigInt64(0, true));
+	if (type === "INT64" && converted_type === "TIMESTAMP_MICROS") return parsers.timestampFromMicroseconds(view.getBigInt64(0, true));
+	if (type === "INT64" && logical_type?.type === "TIMESTAMP" && logical_type?.unit === "NANOS") return parsers.timestampFromNanoseconds(view.getBigInt64(0, true));
+	if (type === "INT64" && logical_type?.type === "TIMESTAMP" && logical_type?.unit === "MICROS") return parsers.timestampFromMicroseconds(view.getBigInt64(0, true));
+	if (type === "INT64" && logical_type?.type === "TIMESTAMP") return parsers.timestampFromMilliseconds(view.getBigInt64(0, true));
+	if (type === "INT32" && view.byteLength === 4) return view.getInt32(0, true);
+	if (type === "INT64" && view.byteLength === 8) return view.getBigInt64(0, true);
+	if (converted_type === "DECIMAL") return parseDecimal(value) * 10 ** -(schema.scale || 0);
+	if (logical_type?.type === "FLOAT16") return parseFloat16(value);
+	if (logical_type?.type === "UUID") return parsers.uuidFromBytes(value);
+	if (type === "FIXED_LEN_BYTE_ARRAY") return value;
+	return value;
+}
+export { convertMetadata, defaultInitialFetchSize, parquetMetadata, parquetMetadataAsync, parquetSchema };

package/dist/node_modules/.pnpm/hyparquet@1.26.2/node_modules/hyparquet/src/node.mjs

@@ -0,0 +1,7 @@
+import "./metadata.mjs";
+import "./indexes.mjs";
+import "./utils.mjs";
+import "./snappy.mjs";
+import { parquetReadObjects } from "./read.mjs";
+import "./index.mjs";
+export { parquetReadObjects };