@gscdump/engine 1.4.0 → 1.4.2

package/dist/node_modules/.pnpm/hyparquet-writer@0.16.1_patch_hash_7a5e451ac7634d7546ac56bcc5eadacf7715a6241640c2b5a5bc0cfc9763b8ec/node_modules/hyparquet-writer/src/dremel.mjs

@@ -0,0 +1,116 @@
+import { getMaxDefinitionLevel, isListLike, isMapLike } from "../../../../hyparquet@1.26.1/node_modules/hyparquet/src/schema.mjs";
+function encodeNestedValues(treePath, rows) {
+	const schemaPath = treePath.map((n) => n.element);
+	if (treePath.length < 2) throw new Error("parquet schema path must include column");
+	const definitionLevels = [];
+	const repetitionLevels = [];
+	const maxDefinitionLevel = getMaxDefinitionLevel(treePath);
+	if (treePath.length === 2 && maxDefinitionLevel === 0) return {
+		values: rows,
+		definitionLevels,
+		repetitionLevels,
+		maxDefinitionLevel
+	};
+	if (treePath.length === 2 && maxDefinitionLevel === 1) {
+		const definitionLevels = new Array(rows.length);
+		for (let i = 0; i < rows.length; i++) definitionLevels[i] = rows[i] === null || rows[i] === void 0 ? 0 : 1;
+		return {
+			values: rows,
+			definitionLevels,
+			repetitionLevels,
+			maxDefinitionLevel
+		};
+	}
+	const repLevelPrior = new Array(treePath.length);
+	let repeatedCount = 0;
+	for (let i = 0; i < treePath.length; i++) {
+		repLevelPrior[i] = repeatedCount;
+		if (schemaPath[i].repetition_type === "REPEATED") repeatedCount++;
+	}
+	const values = [];
+	for (const row of rows) visit(1, row, 0, 0, false);
+	return {
+		values,
+		definitionLevels,
+		repetitionLevels,
+		maxDefinitionLevel
+	};
+	function visit(depth, value, defLevel, repLevel, allowNull) {
+		const element = schemaPath[depth];
+		const repetition = element.repetition_type || "REQUIRED";
+		if (depth === treePath.length - 1) {
+			if (value === null || value === void 0) {
+				if (repetition === "REQUIRED" && !allowNull) throw new Error("parquet required value is undefined");
+				definitionLevels.push(defLevel);
+			} else definitionLevels.push(repetition === "REQUIRED" ? defLevel : defLevel + 1);
+			repetitionLevels.push(repLevel);
+			values.push(value);
+			return;
+		}
+		if (repetition === "REPEATED") {
+			if (value === null || value === void 0) {
+				if (!allowNull) throw new Error("parquet required value is undefined");
+				visit(depth + 1, void 0, defLevel, repLevel, true);
+				return;
+			}
+			if (!Array.isArray(value)) throw new Error(`parquet repeated field ${element.name} must be an array`);
+			if (!value.length) {
+				visit(depth + 1, void 0, defLevel, repLevel, true);
+				return;
+			}
+			const isMapEntry = isMapLike(treePath[depth - 1]);
+			const childElement = schemaPath[depth + 1];
+			for (let i = 0; i < value.length; i++) {
+				let childValue = value[i];
+				if (isMapEntry && childValue && typeof childValue === "object" && childElement) childValue = childValue[childElement.name];
+				const childRep = i === 0 ? repLevel : repLevelPrior[depth] + 1;
+				visit(depth + 1, childValue, defLevel + 1, childRep, false);
+			}
+			return;
+		}
+		if (repetition === "OPTIONAL") {
+			if (value === null || value === void 0) visit(depth + 1, void 0, defLevel, repLevel, true);
+			else {
+				const childValue = getChildValue(depth, value);
+				const childIsNull = childValue === null || childValue === void 0;
+				const isLogicalContainer = isListLike(treePath[depth]) || isMapLike(treePath[depth]);
+				const nextDef = element.num_children && !element.type && !isLogicalContainer || !childIsNull ? defLevel + 1 : defLevel;
+				visit(depth + 1, childValue, nextDef, repLevel, childIsNull);
+			}
+			return;
+		}
+		if (value === null || value === void 0) {
+			if (!allowNull) throw new Error("parquet required value is undefined");
+			visit(depth + 1, void 0, defLevel, repLevel, true);
+		} else visit(depth + 1, getChildValue(depth, value), defLevel, repLevel, false);
+	}
+	function getChildValue(depth, currentValue) {
+		if (currentValue === null || currentValue === void 0) return void 0;
+		const child = schemaPath[depth + 1];
+		if (!child) return void 0;
+		if (isListLike(treePath[depth])) return currentValue;
+		if (isMapLike(treePath[depth])) return normalizeMap(currentValue, schemaPath[depth]);
+		if (typeof currentValue === "object" && !Array.isArray(currentValue)) return currentValue[child.name];
+		throw new Error(`parquet expected struct, got ${currentValue}`);
+	}
+}
+function normalizeMap(value, element) {
+	if (value instanceof Map) return Array.from(value.entries(), ([k, v]) => ({
+		key: k,
+		value: v
+	}));
+	if (Array.isArray(value)) return value.map((entry) => {
+		if (entry && typeof entry === "object" && "key" in entry && "value" in entry) return entry;
+		if (Array.isArray(entry) && entry.length === 2) return {
+			key: entry[0],
+			value: entry[1]
+		};
+		throw new Error("parquet map entry must provide key and value");
+	});
+	if (typeof value === "object") return Object.entries(value).map(([k, v]) => ({
+		key: k,
+		value: v
+	}));
+	throw new Error(`parquet map field ${element.name} must be Map, array, or object`);
+}
+export { encodeNestedValues };

package/dist/node_modules/.pnpm/hyparquet-writer@0.16.1_patch_hash_7a5e451ac7634d7546ac56bcc5eadacf7715a6241640c2b5a5bc0cfc9763b8ec/node_modules/hyparquet-writer/src/encoding.mjs

@@ -0,0 +1,51 @@
+function writeRleBitPackedHybrid(writer, values, bitWidth) {
+	const offsetStart = writer.offset;
+	let pendingBitPackedGroups = 0;
+	let bitPackedStart = 0;
+	let i = 0;
+	while (i < values.length) {
+		let rleCount = 1;
+		const firstVal = values[i];
+		while (i + rleCount < values.length && values[i + rleCount] === firstVal) rleCount++;
+		if (rleCount >= 8) {
+			if (pendingBitPackedGroups) {
+				writeBitPackedGroups(writer, values, bitPackedStart, pendingBitPackedGroups, bitWidth);
+				pendingBitPackedGroups = 0;
+			}
+			writeRleRun(writer, firstVal, rleCount, bitWidth);
+			i += rleCount;
+		} else {
+			if (pendingBitPackedGroups === 0) bitPackedStart = i;
+			pendingBitPackedGroups++;
+			i += 8;
+		}
+	}
+	if (pendingBitPackedGroups) writeBitPackedGroups(writer, values, bitPackedStart, pendingBitPackedGroups, bitWidth);
+	return writer.offset - offsetStart;
+}
+function writeRleRun(writer, value, count, bitWidth) {
+	writer.appendVarInt(count << 1);
+	const width = bitWidth + 7 >> 3;
+	for (let j = 0; j < width; j++) writer.appendUint8(value >> (j << 3) & 255);
+}
+function writeBitPackedGroups(writer, values, start, numGroups, bitWidth) {
+	writer.appendVarInt(numGroups << 1 | 1);
+	if (bitWidth === 0) return;
+	const mask = (1 << bitWidth) - 1;
+	let buffer = 0;
+	let bitsUsed = 0;
+	const totalValues = numGroups * 8;
+	for (let i = 0; i < totalValues; i++) {
+		const idx = start + i;
+		const v = idx < values.length ? values[idx] & mask : 0;
+		buffer |= v << bitsUsed;
+		bitsUsed += bitWidth;
+		while (bitsUsed >= 8) {
+			writer.appendUint8(buffer & 255);
+			buffer >>>= 8;
+			bitsUsed -= 8;
+		}
+	}
+	if (bitsUsed > 0) writer.appendUint8(buffer & 255);
+}
+export { writeRleBitPackedHybrid };

package/dist/node_modules/.pnpm/hyparquet-writer@0.16.1_patch_hash_7a5e451ac7634d7546ac56bcc5eadacf7715a6241640c2b5a5bc0cfc9763b8ec/node_modules/hyparquet-writer/src/geospatial.mjs

@@ -0,0 +1,84 @@
+function geospatialStatistics(values) {
+	const typeCodes = /* @__PURE__ */ new Set();
+	let partial;
+	for (const value of values) {
+		if (value === null || value === void 0) continue;
+		if (typeof value !== "object") throw new Error("geospatial column expects GeoJSON geometries");
+		partial = extendBoundsFromGeometry(partial, value);
+		typeCodes.add(geometryTypeCodeWithDimension(value));
+	}
+	let bbox;
+	const { xmin, ymin, xmax, ymax } = partial ?? {};
+	if (xmin !== void 0 && ymin !== void 0 && xmax !== void 0 && ymax !== void 0) bbox = {
+		...partial,
+		xmin,
+		ymin,
+		xmax,
+		ymax
+	};
+	if (typeCodes.size || bbox) return {
+		bbox,
+		geospatial_types: typeCodes.size ? Array.from(typeCodes).sort((a, b) => a - b) : []
+	};
+}
+function extendBoundsFromGeometry(bbox, geometry) {
+	if (geometry.type === "GeometryCollection") {
+		for (const child of geometry.geometries || []) bbox = extendBoundsFromGeometry(bbox, child);
+		return bbox;
+	}
+	return extendBoundsFromCoordinates(bbox, geometry.coordinates);
+}
+function extendBoundsFromCoordinates(bbox, coordinates) {
+	if (typeof coordinates[0] === "number") {
+		bbox = updateAxis(bbox, "xmin", "xmax", coordinates[0]);
+		bbox = updateAxis(bbox, "ymin", "ymax", coordinates[1]);
+		if (coordinates.length > 2) bbox = updateAxis(bbox, "zmin", "zmax", coordinates[2]);
+		if (coordinates.length > 3) bbox = updateAxis(bbox, "mmin", "mmax", coordinates[3]);
+		return bbox;
+	}
+	for (const child of coordinates) bbox = extendBoundsFromCoordinates(bbox, child);
+	return bbox;
+}
+function updateAxis(bbox, minKey, maxKey, value) {
+	if (value === void 0 || !Number.isFinite(value)) return bbox;
+	if (!bbox) bbox = {};
+	const min = bbox[minKey];
+	const max = bbox[maxKey];
+	if (min === void 0 || value < min) bbox[minKey] = value;
+	if (max === void 0 || value > max) bbox[maxKey] = value;
+	return bbox;
+}
+function geometryTypeCodeWithDimension(geometry) {
+	const base = geometryTypeCodes[geometry.type];
+	if (base === void 0) throw new Error(`unknown geometry type: ${geometry.type}`);
+	const dim = inferGeometryDimensions(geometry);
+	if (dim === 2) return base;
+	if (dim === 3) return base + 1e3;
+	if (dim === 4) return base + 3e3;
+	throw new Error(`unsupported geometry dimensions: ${dim}`);
+}
+const geometryTypeCodes = {
+	Point: 1,
+	LineString: 2,
+	Polygon: 3,
+	MultiPoint: 4,
+	MultiLineString: 5,
+	MultiPolygon: 6,
+	GeometryCollection: 7
+};
+function inferGeometryDimensions(geometry) {
+	if (geometry.type === "GeometryCollection") {
+		let maxDim = 0;
+		for (const child of geometry.geometries || []) maxDim = Math.max(maxDim, inferGeometryDimensions(child));
+		return maxDim || 2;
+	}
+	return inferCoordinateDimensions(geometry.coordinates);
+}
+function inferCoordinateDimensions(value) {
+	if (!value.length) return 2;
+	if (typeof value[0] === "number") return value.length;
+	let maxDim = 0;
+	for (const item of value) maxDim = Math.max(maxDim, inferCoordinateDimensions(item));
+	return maxDim || 2;
+}
+export { geospatialStatistics };

package/dist/node_modules/.pnpm/hyparquet-writer@0.16.1_patch_hash_7a5e451ac7634d7546ac56bcc5eadacf7715a6241640c2b5a5bc0cfc9763b8ec/node_modules/hyparquet-writer/src/index.mjs

@@ -0,0 +1,7 @@
+import { ByteWriter } from "./bytewriter.mjs";
+import "./schema.mjs";
+import "./wkb.mjs";
+import "./parquet-writer.mjs";
+import "./write.mjs";
+import { parquetWriteRows } from "./write-rows.mjs";
+export { ByteWriter, parquetWriteRows };

package/dist/node_modules/.pnpm/hyparquet-writer@0.16.1_patch_hash_7a5e451ac7634d7546ac56bcc5eadacf7715a6241640c2b5a5bc0cfc9763b8ec/node_modules/hyparquet-writer/src/indexes.mjs

@@ -0,0 +1,31 @@
+import { serializeTCompactProtocol } from "./thrift.mjs";
+import { BoundaryOrders } from "../../../../hyparquet@1.26.1/node_modules/hyparquet/src/constants.mjs";
+function writeIndexes(writer, pageIndexes) {
+	for (const { chunk, columnIndex } of pageIndexes) writeColumnIndex(writer, chunk, columnIndex);
+	for (const { chunk, offsetIndex } of pageIndexes) writeOffsetIndex(writer, chunk, offsetIndex);
+}
+function writeColumnIndex(writer, columnChunk, columnIndex) {
+	if (!columnIndex || columnIndex.min_values.length <= 1) return;
+	const columnIndexOffset = writer.offset;
+	serializeTCompactProtocol(writer, {
+		field_1: columnIndex.null_pages,
+		field_2: columnIndex.min_values,
+		field_3: columnIndex.max_values,
+		field_4: BoundaryOrders.indexOf(columnIndex.boundary_order),
+		field_5: columnIndex.null_counts
+	});
+	columnChunk.column_index_offset = BigInt(columnIndexOffset);
+	columnChunk.column_index_length = writer.offset - columnIndexOffset;
+}
+function writeOffsetIndex(writer, columnChunk, offsetIndex) {
+	if (!offsetIndex || offsetIndex.page_locations.length <= 1) return;
+	const offsetIndexOffset = writer.offset;
+	serializeTCompactProtocol(writer, { field_1: offsetIndex.page_locations.map((p) => ({
+		field_1: p.offset,
+		field_2: p.compressed_page_size,
+		field_3: p.first_row_index
+	})) });
+	columnChunk.offset_index_offset = BigInt(offsetIndexOffset);
+	columnChunk.offset_index_length = writer.offset - offsetIndexOffset;
+}
+export { writeIndexes };

package/dist/node_modules/.pnpm/hyparquet-writer@0.16.1_patch_hash_7a5e451ac7634d7546ac56bcc5eadacf7715a6241640c2b5a5bc0cfc9763b8ec/node_modules/hyparquet-writer/src/metadata.mjs

@@ -0,0 +1,138 @@
+import { getSchemaPath } from "../../../../hyparquet@1.26.1/node_modules/hyparquet/src/schema.mjs";
+import { serializeTCompactProtocol } from "./thrift.mjs";
+import { CompressionCodecs, ConvertedTypes, EdgeInterpolationAlgorithms, Encodings, FieldRepetitionTypes, PageTypes, ParquetTypes } from "../../../../hyparquet@1.26.1/node_modules/hyparquet/src/constants.mjs";
+import { unconvertStatistics } from "./unconvert.mjs";
+function writeMetadata(writer, metadata) {
+	const compact = {
+		field_1: metadata.version,
+		field_2: metadata.schema.map((element) => ({
+			field_1: element.type && ParquetTypes.indexOf(element.type),
+			field_2: element.type_length,
+			field_3: element.repetition_type && FieldRepetitionTypes.indexOf(element.repetition_type),
+			field_4: element.name,
+			field_5: element.num_children,
+			field_6: element.converted_type && ConvertedTypes.indexOf(element.converted_type),
+			field_7: element.scale,
+			field_8: element.precision,
+			field_9: element.field_id,
+			field_10: logicalType(element.logical_type)
+		})),
+		field_3: metadata.num_rows,
+		field_4: metadata.row_groups.map((rg) => ({
+			field_1: rg.columns.map((c) => ({
+				field_1: c.file_path,
+				field_2: c.file_offset,
+				field_3: c.meta_data && {
+					field_1: ParquetTypes.indexOf(c.meta_data.type),
+					field_2: c.meta_data.encodings.map((e) => Encodings.indexOf(e)),
+					field_3: c.meta_data.path_in_schema,
+					field_4: CompressionCodecs.indexOf(c.meta_data.codec),
+					field_5: c.meta_data.num_values,
+					field_6: c.meta_data.total_uncompressed_size,
+					field_7: c.meta_data.total_compressed_size,
+					field_8: c.meta_data.key_value_metadata && c.meta_data.key_value_metadata.map((kv) => ({
+						field_1: kv.key,
+						field_2: kv.value
+					})),
+					field_9: c.meta_data.data_page_offset,
+					field_10: c.meta_data.index_page_offset,
+					field_11: c.meta_data.dictionary_page_offset,
+					field_12: c.meta_data.statistics && unconvertStatistics(c.meta_data.statistics, schemaElement(metadata.schema, c.meta_data.path_in_schema)),
+					field_13: c.meta_data.encoding_stats && c.meta_data.encoding_stats.map((es) => ({
+						field_1: PageTypes.indexOf(es.page_type),
+						field_2: Encodings.indexOf(es.encoding),
+						field_3: es.count
+					})),
+					field_14: c.meta_data.bloom_filter_offset,
+					field_15: c.meta_data.bloom_filter_length,
+					field_16: c.meta_data.size_statistics && {
+						field_1: c.meta_data.size_statistics.unencoded_byte_array_data_bytes,
+						field_2: c.meta_data.size_statistics.repetition_level_histogram,
+						field_3: c.meta_data.size_statistics.definition_level_histogram
+					},
+					field_17: c.meta_data.geospatial_statistics && {
+						field_1: c.meta_data.geospatial_statistics.bbox && {
+							field_1: c.meta_data.geospatial_statistics.bbox.xmin,
+							field_2: c.meta_data.geospatial_statistics.bbox.xmax,
+							field_3: c.meta_data.geospatial_statistics.bbox.ymin,
+							field_4: c.meta_data.geospatial_statistics.bbox.ymax,
+							field_5: c.meta_data.geospatial_statistics.bbox.zmin,
+							field_6: c.meta_data.geospatial_statistics.bbox.zmax,
+							field_7: c.meta_data.geospatial_statistics.bbox.mmin,
+							field_8: c.meta_data.geospatial_statistics.bbox.mmax
+						},
+						field_2: c.meta_data.geospatial_statistics.geospatial_types
+					}
+				},
+				field_4: c.offset_index_offset,
+				field_5: c.offset_index_length,
+				field_6: c.column_index_offset,
+				field_7: c.column_index_length,
+				field_9: c.encrypted_column_metadata
+			})),
+			field_2: rg.total_byte_size,
+			field_3: rg.num_rows,
+			field_4: rg.sorting_columns && rg.sorting_columns.map((sc) => ({
+				field_1: sc.column_idx,
+				field_2: sc.descending,
+				field_3: sc.nulls_first
+			})),
+			field_5: rg.file_offset,
+			field_6: rg.total_compressed_size
+		})),
+		field_5: metadata.key_value_metadata && metadata.key_value_metadata.map((kv) => ({
+			field_1: kv.key,
+			field_2: kv.value
+		})),
+		field_6: metadata.created_by
+	};
+	const metadataStart = writer.offset;
+	serializeTCompactProtocol(writer, compact);
+	const metadataLength = writer.offset - metadataStart;
+	writer.appendUint32(metadataLength);
+}
+function schemaElement(schema, path) {
+	const tree = getSchemaPath(schema, path);
+	return tree[tree.length - 1].element;
+}
+function logicalType(type) {
+	if (!type) return;
+	if (type.type === "STRING") return { field_1: {} };
+	if (type.type === "MAP") return { field_2: {} };
+	if (type.type === "LIST") return { field_3: {} };
+	if (type.type === "ENUM") return { field_4: {} };
+	if (type.type === "DECIMAL") return { field_5: {
+		field_1: type.scale,
+		field_2: type.precision
+	} };
+	if (type.type === "DATE") return { field_6: {} };
+	if (type.type === "TIME") return { field_7: {
+		field_1: type.isAdjustedToUTC,
+		field_2: timeUnit(type.unit)
+	} };
+	if (type.type === "TIMESTAMP") return { field_8: {
+		field_1: type.isAdjustedToUTC,
+		field_2: timeUnit(type.unit)
+	} };
+	if (type.type === "INTEGER") return { field_10: {
+		field_1: type.bitWidth,
+		field_2: type.isSigned
+	} };
+	if (type.type === "NULL") return { field_11: {} };
+	if (type.type === "JSON") return { field_12: {} };
+	if (type.type === "BSON") return { field_13: {} };
+	if (type.type === "UUID") return { field_14: {} };
+	if (type.type === "FLOAT16") return { field_15: {} };
+	if (type.type === "VARIANT") return { field_16: {} };
+	if (type.type === "GEOMETRY") return { field_17: { field_1: type.crs } };
+	if (type.type === "GEOGRAPHY") return { field_18: {
+		field_1: type.crs,
+		field_2: type.algorithm && EdgeInterpolationAlgorithms.indexOf(type.algorithm)
+	} };
+}
+function timeUnit(unit) {
+	if (unit === "NANOS") return { field_3: {} };
+	if (unit === "MICROS") return { field_2: {} };
+	return { field_1: {} };
+}
+export { logicalType, writeMetadata };

package/dist/node_modules/.pnpm/hyparquet-writer@0.16.1_patch_hash_7a5e451ac7634d7546ac56bcc5eadacf7715a6241640c2b5a5bc0cfc9763b8ec/node_modules/hyparquet-writer/src/node.mjs

@@ -0,0 +1,8 @@
+import { ByteWriter } from "./bytewriter.mjs";
+import "./schema.mjs";
+import "./wkb.mjs";
+import "./parquet-writer.mjs";
+import "./write.mjs";
+import { parquetWriteRows } from "./write-rows.mjs";
+import "./index.mjs";
+export { ByteWriter, parquetWriteRows };

package/dist/node_modules/.pnpm/hyparquet-writer@0.16.1_patch_hash_7a5e451ac7634d7546ac56bcc5eadacf7715a6241640c2b5a5bc0cfc9763b8ec/node_modules/hyparquet-writer/src/parquet-writer.mjs

@@ -0,0 +1,139 @@
+import { getSchemaPath } from "../../../../hyparquet@1.26.1/node_modules/hyparquet/src/schema.mjs";
+import { writeBlooms } from "./bloom.mjs";
+import { encodeVariantColumn } from "./variant.mjs";
+import { writeColumn } from "./column.mjs";
+import { encodeNestedValues } from "./dremel.mjs";
+import { writeIndexes } from "./indexes.mjs";
+import { writeMetadata } from "./metadata.mjs";
+import { snappyCompress } from "./snappy.mjs";
+function ParquetWriter({ writer, schema, codec = "SNAPPY", compressors, statistics = true, kvMetadata }) {
+	this.writer = writer;
+	this.schema = schema;
+	this.codec = codec;
+	this.compressors = {
+		SNAPPY: snappyCompress,
+		...compressors
+	};
+	this.statistics = statistics;
+	this.kvMetadata = kvMetadata;
+	this.row_groups = [];
+	this.num_rows = 0n;
+	this.pendingIndexes = [];
+	this.writer.appendUint32(827474256);
+}
+ParquetWriter.prototype.write = function({ columnData, rowGroupSize = [1e3, 1e5], pageSize = 1048576 }) {
+	const columnDataRows = columnData[0]?.data?.length || 0;
+	let pending;
+	for (const { groupStartIndex, groupSize } of groupIterator({
+		columnDataRows,
+		rowGroupSize
+	})) {
+		const writeGroup = () => {
+			const groupStartOffset = this.writer.offset;
+			const columns = [];
+			for (let j = 0; j < columnData.length; j++) {
+				const { name, data, encoding, codec = this.codec, columnIndex = false, offsetIndex = true, shredding, bloomFilter } = columnData[j];
+				if (columnIndex && !offsetIndex) throw new Error("parquet ColumnIndex cannot be present without OffsetIndex");
+				if (data.length !== columnDataRows) throw new Error("parquet columns must have the same length");
+				const groupData = data.slice(groupStartIndex, groupStartIndex + groupSize);
+				const columnPath = getSchemaPath(this.schema, [name]);
+				const leafPaths = getLeafSchemaPaths(columnPath);
+				const columnElement = columnPath.at(-1)?.element;
+				const shreddingConfig = shredding && shredding !== true ? shredding : void 0;
+				const isVariant = columnElement?.logical_type?.type === "VARIANT";
+				const isRequired = columnElement?.repetition_type === "REQUIRED";
+				const rows = isVariant ? encodeVariantColumn(Array.from(groupData), shreddingConfig, {
+					name,
+					required: isRequired
+				}) : groupData;
+				for (const leafPath of leafPaths) {
+					const schemaPath = leafPath.map((node) => node.element);
+					const column = {
+						columnName: schemaPath.slice(1).map((s) => s.name).join("."),
+						element: schemaPath[schemaPath.length - 1],
+						schemaPath,
+						codec,
+						compressors: this.compressors,
+						stats: this.statistics,
+						pageSize,
+						columnIndex,
+						offsetIndex,
+						encoding,
+						bloomFilter
+					};
+					const pageData = encodeNestedValues(leafPath, rows);
+					const result = writeColumn({
+						writer: this.writer,
+						column,
+						pageData
+					});
+					columns.push(result.chunk);
+					this.pendingIndexes.push(result);
+				}
+			}
+			this.num_rows += BigInt(groupSize);
+			this.row_groups.push({
+				columns,
+				total_byte_size: BigInt(this.writer.offset - groupStartOffset),
+				num_rows: BigInt(groupSize)
+			});
+			return this.writer.flush?.();
+		};
+		if (pending) pending = pending.then(writeGroup);
+		else {
+			const r = writeGroup();
+			if (r) pending = Promise.resolve(r);
+		}
+	}
+	return pending;
+};
+ParquetWriter.prototype.finish = function() {
+	writeIndexes(this.writer, this.pendingIndexes);
+	writeBlooms(this.writer, this.pendingIndexes);
+	const metadata = {
+		version: 2,
+		created_by: "hyparquet",
+		schema: this.schema,
+		num_rows: this.num_rows,
+		row_groups: this.row_groups,
+		metadata_length: 0,
+		key_value_metadata: this.kvMetadata
+	};
+	delete metadata.metadata_length;
+	writeMetadata(this.writer, metadata);
+	this.writer.appendUint32(827474256);
+	return this.writer.finish();
+};
+function groupSize(rowGroupSize, i) {
+	return Array.isArray(rowGroupSize) ? rowGroupSize[Math.min(i, rowGroupSize.length - 1)] : rowGroupSize;
+}
+function groupIterator({ columnDataRows, rowGroupSize }) {
+	if (Array.isArray(rowGroupSize) && !rowGroupSize.length) throw new Error("rowGroupSize array cannot be empty");
+	const groups = [];
+	let groupIndex = 0;
+	let groupStartIndex = 0;
+	while (groupStartIndex < columnDataRows) {
+		const size = groupSize(rowGroupSize, groupIndex);
+		groups.push({
+			groupStartIndex,
+			groupSize: Math.min(size, columnDataRows - groupStartIndex)
+		});
+		groupStartIndex += size;
+		groupIndex++;
+	}
+	return groups;
+}
+function getLeafSchemaPaths(schemaPath) {
+	const leaves = [];
+	dfs(schemaPath);
+	return leaves;
+	function dfs(path) {
+		const node = path[path.length - 1];
+		if (!node.children.length) {
+			leaves.push(path);
+			return;
+		}
+		for (const child of node.children) dfs([...path, child]);
+	}
+}
+export { ParquetWriter, groupSize };

package/dist/node_modules/.pnpm/hyparquet-writer@0.16.1_patch_hash_7a5e451ac7634d7546ac56bcc5eadacf7715a6241640c2b5a5bc0cfc9763b8ec/node_modules/hyparquet-writer/src/plain.mjs

@@ -0,0 +1,68 @@
+function writePlain(writer, values, type, fixedLength) {
+	if (type === "BOOLEAN") writePlainBoolean(writer, values);
+	else if (type === "INT32") writePlainInt32(writer, values);
+	else if (type === "INT64") writePlainInt64(writer, values);
+	else if (type === "FLOAT") writePlainFloat(writer, values);
+	else if (type === "DOUBLE") writePlainDouble(writer, values);
+	else if (type === "BYTE_ARRAY") writePlainByteArray(writer, values);
+	else if (type === "FIXED_LEN_BYTE_ARRAY") {
+		if (!fixedLength) throw new Error("parquet FIXED_LEN_BYTE_ARRAY expected type_length");
+		writePlainByteArrayFixed(writer, values, fixedLength);
+	} else throw new Error(`parquet unsupported type: ${type}`);
+}
+function writePlainBoolean(writer, values) {
+	let currentByte = 0;
+	for (let i = 0; i < values.length; i++) {
+		const value = values[i];
+		if (typeof value !== "boolean") throw new Error("parquet expected boolean value, got " + value);
+		const bitOffset = i % 8;
+		if (value) currentByte |= 1 << bitOffset;
+		if (bitOffset === 7) {
+			writer.appendUint8(currentByte);
+			currentByte = 0;
+		}
+	}
+	if (values.length % 8) writer.appendUint8(currentByte);
+}
+function writePlainInt32(writer, values) {
+	for (const value of values) {
+		if (!Number.isSafeInteger(value)) throw new Error("parquet expected integer value, got " + value);
+		if (value < -2147483648 || value > 2147483647) throw new Error("parquet expected int32 value, got " + value);
+		writer.appendInt32(value);
+	}
+}
+function writePlainInt64(writer, values) {
+	for (const value of values) {
+		if (typeof value !== "bigint") throw new Error("parquet expected bigint value, got " + value);
+		writer.appendInt64(value);
+	}
+}
+function writePlainFloat(writer, values) {
+	for (const value of values) {
+		if (typeof value !== "number") throw new Error("parquet expected number value, got " + value);
+		writer.appendFloat32(value);
+	}
+}
+function writePlainDouble(writer, values) {
+	for (const value of values) {
+		if (typeof value !== "number") throw new Error("parquet expected number value, got " + value);
+		writer.appendFloat64(value);
+	}
+}
+function writePlainByteArray(writer, values) {
+	for (const value of values) {
+		let bytes = value;
+		if (typeof bytes === "string") bytes = new TextEncoder().encode(value);
+		if (!(bytes instanceof Uint8Array)) throw new Error("parquet expected Uint8Array value, got " + typeof bytes);
+		writer.appendUint32(bytes.length);
+		writer.appendBytes(bytes);
+	}
+}
+function writePlainByteArrayFixed(writer, values, fixedLength) {
+	for (const value of values) {
+		if (!(value instanceof Uint8Array)) throw new Error("parquet expected Uint8Array value, got " + typeof value);
+		if (value.length !== fixedLength) throw new Error(`parquet expected Uint8Array of length ${fixedLength}`);
+		writer.appendBytes(value);
+	}
+}
+export { writePlain };