@gscdump/engine 3.5.0 → 3.6.0

package/dist/node_modules/.pnpm/hyparquet@1.30.0/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.30.0/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.30.0/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.30.0/node_modules/hyparquet/src/filter.mjs

@@ -0,0 +1,212 @@
+import { hashParquetValue, sbbfContains } from "./bloom.mjs";
+import { equals } from "./utils.mjs";
+const encoder = new TextEncoder();
+function pathsNeededForFilter(filter) {
+	if (!filter) return [];
+	const paths = [];
+	if ("$and" in filter && Array.isArray(filter.$and)) paths.push(...filter.$and.flatMap(pathsNeededForFilter));
+	else if ("$or" in filter && Array.isArray(filter.$or)) paths.push(...filter.$or.flatMap(pathsNeededForFilter));
+	else if ("$nor" in filter && Array.isArray(filter.$nor)) paths.push(...filter.$nor.flatMap(pathsNeededForFilter));
+	else paths.push(...Object.keys(filter));
+	return [...new Set(paths)];
+}
+function columnsNeededForFilter(filter) {
+	return [...new Set(pathsNeededForFilter(filter).map((path) => path.split(".")[0]))];
+}
+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 !== null && value !== void 0 && value > target;
+			if (operator === "$gte") return value !== null && value !== void 0 && value >= target;
+			if (operator === "$lt") return value !== null && value !== void 0 && value < target;
+			if (operator === "$lte") return value !== null && value !== void 0 && 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) && matchesIn(value, target, strict);
+			if (operator === "$nin") return Array.isArray(target) && !matchesIn(value, target, strict);
+			if (operator === "$not") return !matchFilter({ [field]: value }, { [field]: target }, strict);
+			return true;
+		});
+	});
+}
+function matchesIn(value, targets, strict) {
+	return targets.some((target) => equals(value, target, strict) || Array.isArray(value) && value.some((element) => equals(element, target, strict)));
+}
+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, null_count: nullCount } = 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];
+		const matchingNulls = matchFilter({ value: null }, { value: condition }, strict) && (nullCount === void 0 || nullCount > 0);
+		if (haveStats && !matchingNulls && canSkipStats(condition, minVal, maxVal, strict, element)) return true;
+		for (const [operator, target] of Object.entries(condition || {})) 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 canSkipStats(condition, minVal, maxVal, strict, element) {
+	if (minVal === void 0 || maxVal === void 0) return false;
+	const mayContainNaN = element?.type === "FLOAT" || element?.type === "DOUBLE" || element?.logical_type?.type === "FLOAT16";
+	for (const [operator, target] of Object.entries(condition || {})) {
+		const minComparison = compareParquetValues(minVal, target, strict, element);
+		const maxComparison = compareParquetValues(maxVal, target, strict, element);
+		const relationalBoundsAreSafe = !(minVal instanceof Uint8Array || maxVal instanceof Uint8Array) && (element?.type !== "BYTE_ARRAY" || typeof target === "string" && [...target].every((character) => character.charCodeAt(0) <= 127));
+		if (operator === "$gt" && relationalBoundsAreSafe && maxComparison !== void 0 && maxComparison <= 0) return true;
+		if (operator === "$gte" && relationalBoundsAreSafe && maxComparison !== void 0 && maxComparison < 0) return true;
+		if (operator === "$lt" && relationalBoundsAreSafe && minComparison !== void 0 && minComparison >= 0) return true;
+		if (operator === "$lte" && relationalBoundsAreSafe && minComparison !== void 0 && minComparison > 0) return true;
+		if (operator === "$eq") {
+			const targetMinComparison = compareParquetValues(target, minVal, strict, element);
+			const targetMaxComparison = compareParquetValues(target, maxVal, strict, element);
+			if (targetMinComparison !== void 0 && targetMinComparison < 0 || targetMaxComparison !== void 0 && targetMaxComparison > 0) return true;
+		}
+		if (operator === "$ne" && !mayContainNaN && equals(minVal, maxVal, strict) && equals(minVal, target, strict)) return true;
+		if (operator === "$in" && Array.isArray(target) && target.every((value) => {
+			const valueMinComparison = compareParquetValues(value, minVal, strict, element);
+			const valueMaxComparison = compareParquetValues(value, maxVal, strict, element);
+			return valueMinComparison !== void 0 && valueMinComparison < 0 || valueMaxComparison !== void 0 && valueMaxComparison > 0;
+		})) return true;
+		if (operator === "$nin" && !mayContainNaN && Array.isArray(target) && equals(minVal, maxVal, strict) && target.some((value) => equals(minVal, value, strict))) return true;
+	}
+	return false;
+}
+function compareParquetValues(a, b, strict, element) {
+	if (element?.type === "BYTE_ARRAY") {
+		if (typeof a !== "string" || typeof b !== "string") return void 0;
+		return compareBytes(encoder.encode(a), encoder.encode(b));
+	}
+	if (a instanceof Uint8Array || b instanceof Uint8Array) {
+		if (!(a instanceof Uint8Array) || !(b instanceof Uint8Array)) return void 0;
+		return compareBytes(a, b);
+	}
+	if (a < b) return -1;
+	if (a > b) return 1;
+	if (equals(a, b, strict)) return 0;
+}
+function compareBytes(a, b) {
+	const length = Math.min(a.length, b.length);
+	for (let i = 0; i < length; i++) {
+		if (a[i] < b[i]) return -1;
+		if (a[i] > b[i]) return 1;
+	}
+	if (a.length < b.length) return -1;
+	if (a.length > b.length) return 1;
+	return 0;
+}
+function matchesNull(condition, strict) {
+	return matchFilter({ value: null }, { value: condition }, strict);
+}
+function filterPageRanges(filter, columnPages, groupRows, strict = true) {
+	if (!filter) return void 0;
+	if ("$and" in filter && Array.isArray(filter.$and)) {
+		let ranges;
+		for (const subFilter of filter.$and) ranges = intersectRanges(ranges, filterPageRanges(subFilter, columnPages, groupRows, strict));
+		return ranges;
+	}
+	if ("$or" in filter && Array.isArray(filter.$or)) {
+		let ranges = [];
+		for (const subFilter of filter.$or) {
+			const subRanges = filterPageRanges(subFilter, columnPages, groupRows, strict);
+			if (!subRanges) return void 0;
+			ranges = unionRanges(ranges, subRanges);
+		}
+		return ranges;
+	}
+	if ("$nor" in filter && Array.isArray(filter.$nor)) return;
+	let result;
+	for (const [field, condition] of Object.entries(filter)) {
+		const pages = columnPages[field];
+		if (!pages) continue;
+		const nullCanMatch = matchesNull(condition, strict);
+		const keep = [];
+		for (let i = 0; i < pages.pageStarts.length; i++) {
+			const start = pages.pageStarts[i];
+			const end = i + 1 < pages.pageStarts.length ? pages.pageStarts[i + 1] : groupRows;
+			const nullCount = pages.nullCounts?.[i];
+			const matchingNulls = nullCanMatch && (nullCount === void 0 || nullCount > 0);
+			if (!(!pages.nullPages[i] && !matchingNulls && canSkipStats(condition, pages.minValues[i], pages.maxValues[i], strict, pages.element))) {
+				const last = keep[keep.length - 1];
+				if (last && last[1] === start) last[1] = end;
+				else keep.push([start, end]);
+			}
+		}
+		result = intersectRanges(result, keep);
+	}
+	return result;
+}
+function intersectRanges(a, b) {
+	if (!a) return b;
+	if (!b) return a;
+	const out = [];
+	let i = 0;
+	let j = 0;
+	while (i < a.length && j < b.length) {
+		const start = Math.max(a[i][0], b[j][0]);
+		const end = Math.min(a[i][1], b[j][1]);
+		if (start < end) out.push([start, end]);
+		if (a[i][1] < b[j][1]) i++;
+		else j++;
+	}
+	return out;
+}
+function unionRanges(a, b) {
+	const out = [];
+	let i = 0;
+	let j = 0;
+	while (i < a.length || j < b.length) {
+		const next = j >= b.length || i < a.length && a[i][0] <= b[j][0] ? a[i++] : b[j++];
+		const last = out[out.length - 1];
+		if (last && next[0] <= last[1]) last[1] = Math.max(last[1], next[1]);
+		else out.push([next[0], next[1]]);
+	}
+	return out;
+}
+function resolve(record, path) {
+	let value = record;
+	for (const part of path.split(".")) value = value?.[part];
+	return value;
+}
+export { canSkipRowGroup, columnsNeededForFilter, filterPageRanges, intersectRanges, matchFilter, pathsNeededForFilter, unionRanges };

package/dist/node_modules/.pnpm/hyparquet@1.30.0/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.30.0/node_modules/hyparquet/src/index.mjs

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

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

@@ -0,0 +1,32 @@
+import { BoundaryOrders } from "./constants.mjs";
+import { DEFAULT_PARSERS } from "./convert.mjs";
+import { deserializeTCompactProtocol } from "./thrift.mjs";
+import { convertMetadata } from "./metadata.mjs";
+function readColumnIndex(reader, schema, parsers = void 0) {
+	parsers = {
+		...DEFAULT_PARSERS,
+		...parsers
+	};
+	const thrift = deserializeTCompactProtocol(reader);
+	return {
+		null_pages: thrift.field_1,
+		min_values: thrift.field_2.map((m) => convertMetadata(m, schema, parsers)),
+		max_values: thrift.field_3.map((m) => convertMetadata(m, schema, parsers)),
+		boundary_order: BoundaryOrders[thrift.field_4],
+		null_counts: thrift.field_5,
+		repetition_level_histograms: thrift.field_6,
+		definition_level_histograms: thrift.field_7
+	};
+}
+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 { readColumnIndex, readOffsetIndex };