@gscdump/engine 1.4.0 → 1.4.1

package/dist/_chunks/libs/hyparquet-writer.mjs

@@ -1,2524 +0,0 @@
-import { BoundaryOrders, CompressionCodecs, ConvertedTypes, EdgeInterpolationAlgorithms, Encodings, FieldRepetitionTypes, PageTypes, ParquetTypes, getMaxDefinitionLevel, getSchemaPath, hashParquetValue, isListLike, isMapLike, toJson } from "./hyparquet.mjs";
-function ByteWriter(initalSize = 1024) {
-	this.buffer = new ArrayBuffer(initalSize);
-	this.view = new DataView(this.buffer);
-	this.offset = 0;
-	this.index = 0;
-	return this;
-}
-ByteWriter.prototype.ensure = function(size) {
-	if (this.index + size > this.buffer.byteLength) {
-		const newSize = Math.max(this.buffer.byteLength * 2, this.index + size);
-		const newBuffer = new ArrayBuffer(newSize);
-		new Uint8Array(newBuffer).set(new Uint8Array(this.buffer));
-		this.buffer = newBuffer;
-		this.view = new DataView(this.buffer);
-	}
-};
-ByteWriter.prototype.finish = function() {};
-ByteWriter.prototype.getBuffer = function() {
-	return this.buffer.slice(0, this.index);
-};
-ByteWriter.prototype.getBytes = function() {
-	return new Uint8Array(this.buffer, 0, this.index);
-};
-ByteWriter.prototype.appendUint8 = function(value) {
-	this.ensure(this.index + 1);
-	this.view.setUint8(this.index, value);
-	this.offset++;
-	this.index++;
-};
-ByteWriter.prototype.appendUint32 = function(value) {
-	this.ensure(this.index + 4);
-	this.view.setUint32(this.index, value, true);
-	this.offset += 4;
-	this.index += 4;
-};
-ByteWriter.prototype.appendInt32 = function(value) {
-	this.ensure(this.index + 4);
-	this.view.setInt32(this.index, value, true);
-	this.offset += 4;
-	this.index += 4;
-};
-ByteWriter.prototype.appendInt64 = function(value) {
-	this.ensure(this.index + 8);
-	this.view.setBigInt64(this.index, BigInt(value), true);
-	this.offset += 8;
-	this.index += 8;
-};
-ByteWriter.prototype.appendFloat32 = function(value) {
-	this.ensure(this.index + 8);
-	this.view.setFloat32(this.index, value, true);
-	this.offset += 4;
-	this.index += 4;
-};
-ByteWriter.prototype.appendFloat64 = function(value) {
-	this.ensure(this.index + 8);
-	this.view.setFloat64(this.index, value, true);
-	this.offset += 8;
-	this.index += 8;
-};
-ByteWriter.prototype.appendBuffer = function(value) {
-	this.appendBytes(new Uint8Array(value));
-};
-ByteWriter.prototype.appendBytes = function(value) {
-	this.ensure(this.index + value.length);
-	new Uint8Array(this.buffer, this.index, value.length).set(value);
-	this.offset += value.length;
-	this.index += value.length;
-};
-ByteWriter.prototype.appendVarInt = function(value) {
-	while (true) if ((value & -128) === 0) {
-		this.appendUint8(value);
-		return;
-	} else {
-		this.appendUint8(value & 127 | 128);
-		value >>>= 7;
-	}
-};
-ByteWriter.prototype.appendVarBigInt = function(value) {
-	while (true) if ((value & -128n) === 0n) {
-		this.appendUint8(Number(value));
-		return;
-	} else {
-		this.appendUint8(Number(value & 127n | 128n));
-		value >>= 7n;
-	}
-};
-ByteWriter.prototype.appendZigZag = function(value) {
-	if (typeof value === "number") this.appendVarInt(value << 1 ^ value >> 31);
-	else this.appendVarBigInt(value << 1n ^ value >> 63n);
-};
-const STOP = 0;
-const TRUE = 1;
-const FALSE = 2;
-const BYTE = 3;
-const I32 = 5;
-const I64 = 6;
-const DOUBLE = 7;
-const BINARY = 8;
-const LIST = 9;
-const STRUCT = 12;
-function serializeTCompactProtocol(writer, data) {
-	writeElement(writer, STRUCT, data);
-}
-function writeElement(writer, type, value) {
-	if (type === TRUE) return;
-	if (type === FALSE) return;
-	if (type === BYTE && typeof value === "number") writer.appendUint8(value);
-	else if (type === I32 && typeof value === "number") writer.appendZigZag(value);
-	else if (type === I64 && typeof value === "bigint") writer.appendZigZag(value);
-	else if (type === DOUBLE && typeof value === "number") writer.appendFloat64(value);
-	else if (type === BINARY && typeof value === "string") {
-		const bytes = new TextEncoder().encode(value);
-		writer.appendVarInt(bytes.length);
-		writer.appendBytes(bytes);
-	} else if (type === BINARY && value instanceof Uint8Array) {
-		writer.appendVarInt(value.byteLength);
-		writer.appendBytes(value);
-	} else if (type === LIST && Array.isArray(value)) {
-		const elemType = getCompactTypeForList(value);
-		if (value.length > 14) {
-			writer.appendUint8(240 | elemType);
-			writer.appendVarInt(value.length);
-		} else writer.appendUint8(value.length << 4 | elemType);
-		if (elemType === FALSE) for (const v of value) writer.appendUint8(v ? 1 : 0);
-		else for (const v of value) writeElement(writer, elemType, v);
-	} else if (type === STRUCT && typeof value === "object") {
-		let lastFid = 0;
-		for (const [k, v] of Object.entries(value)) {
-			if (v === void 0) continue;
-			const fid = parseInt(k.replace(/^field_/, ""), 10);
-			if (Number.isNaN(fid)) throw new Error(`thrift invalid field name: ${k}. Expected "field_###"`);
-			const t = getCompactTypeForValue(v);
-			const delta = fid - lastFid;
-			if (delta <= 0) throw new Error(`thrift non-monotonic field id: fid=${fid}, lastFid=${lastFid}`);
-			if (delta > 15) {
-				writer.appendUint8(t);
-				writer.appendZigZag(fid);
-			} else writer.appendUint8(delta << 4 | t);
-			writeElement(writer, t, v);
-			lastFid = fid;
-		}
-		writer.appendUint8(STOP);
-	} else throw new Error(`thrift invalid type ${type} for value ${value}`);
-}
-function getCompactTypeForValue(value) {
-	if (value === true) return TRUE;
-	if (value === false) return FALSE;
-	if (Number.isInteger(value)) return I32;
-	if (typeof value === "number") return DOUBLE;
-	if (typeof value === "bigint") return I64;
-	if (typeof value === "string") return BINARY;
-	if (value instanceof Uint8Array) return BINARY;
-	if (Array.isArray(value)) return LIST;
-	if (value && typeof value === "object") return STRUCT;
-	throw new Error(`Cannot determine thrift compact type for: ${value}`);
-}
-function getCompactTypeForList(value) {
-	let elemType = 0;
-	for (const v of value) {
-		let t = getCompactTypeForValue(v);
-		if (t === TRUE) t = FALSE;
-		if (!elemType) elemType = t;
-		if (elemType === DOUBLE && t === I32) t = DOUBLE;
-		if (elemType === I32 && t === DOUBLE) elemType = DOUBLE;
-		if (t !== elemType) throw new Error(`thrift invalid type for list element: ${v} (expected type ${elemType})`);
-	}
-	return elemType ?? BYTE;
-}
-const SALT = new Uint32Array([
-	1203114875,
-	1150766481,
-	2284105051,
-	2729912477,
-	1884591559,
-	770785867,
-	2667333959,
-	1550580529
-]);
-const BYTES_PER_BLOCK = 32;
-const MIN_BYTES = 32;
-const MAX_BYTES = 128 * 1024 * 1024;
-function blockIndex(hash, numBlocks) {
-	return Number((hash >> 32n) * BigInt(numBlocks) >> 32n);
-}
-function blockMask(hash) {
-	const m = /* @__PURE__ */ new Uint32Array(8);
-	const low = Number(hash & 4294967295n) | 0;
-	for (let i = 0; i < 8; i++) m[i] = 1 << (Math.imul(low, SALT[i]) >>> 27);
-	return m;
-}
-function sbbfInsert(blocks, hash) {
-	const offset = blockIndex(hash, blocks.length >> 3) << 3;
-	const m = blockMask(hash);
-	for (let i = 0; i < 8; i++) blocks[offset + i] |= m[i];
-}
-function nextPowerOfTwo(n) {
-	let p = 1;
-	while (p < n) p <<= 1;
-	return p;
-}
-function optimalNumBytes(ndv, fpp) {
-	if (!(fpp > 0 && fpp < 1)) throw new Error(`bloom filter fpp must be in (0, 1), got ${fpp}`);
-	if (!(ndv >= 0)) throw new Error(`bloom filter ndv must be >= 0, got ${ndv}`);
-	const m = -8 * ndv / Math.log(1 - fpp ** (1 / 8));
-	let numBits = Math.ceil(m);
-	if (!isFinite(numBits) || numBits > MAX_BYTES << 3) numBits = MAX_BYTES << 3;
-	const blockBits = BYTES_PER_BLOCK << 3;
-	numBits = Math.ceil(numBits / blockBits) * blockBits;
-	let numBytes = numBits >> 3;
-	if (numBytes < MIN_BYTES) numBytes = MIN_BYTES;
-	if (numBytes < 1024) numBytes = nextPowerOfTwo(numBytes);
-	return numBytes;
-}
-var BloomBuilder = class {
-	constructor(element, { fpp = .01, maxBytes = 1024 * 1024 } = {}) {
-		this.element = element;
-		this.fpp = fpp;
-		this.maxBytes = maxBytes;
-		this.hashes = /* @__PURE__ */ new Set();
-		this.skipped = 0;
-	}
-	insert(value) {
-		if (value === null || value === void 0) return;
-		const h = hashParquetValue(value, this.element);
-		if (h === void 0) {
-			this.skipped++;
-			return;
-		}
-		this.hashes.add(h);
-	}
-	finalize() {
-		if (this.skipped > 0 || this.hashes.size === 0) return void 0;
-		const numBytes = optimalNumBytes(this.hashes.size, this.fpp);
-		if (numBytes > this.maxBytes) return void 0;
-		const blocks = new Uint32Array(numBytes >> 2);
-		for (const h of this.hashes) sbbfInsert(blocks, h);
-		return blocks;
-	}
-};
-function writeBloomFilter(writer, blocks) {
-	if (blocks.length % 8 !== 0) throw new Error(`bloom filter block count must be a multiple of 8 uint32 words, got ${blocks.length}`);
-	serializeTCompactProtocol(writer, {
-		field_1: blocks.byteLength,
-		field_2: { field_1: {} },
-		field_3: { field_1: {} },
-		field_4: { field_1: {} }
-	});
-	for (let i = 0; i < blocks.length; i++) writer.appendUint32(blocks[i]);
-}
-function writeBlooms(writer, pageIndexes) {
-	for (const { chunk, bloomFilter } of pageIndexes) {
-		if (!bloomFilter || !chunk.meta_data) continue;
-		const offset = writer.offset;
-		writeBloomFilter(writer, bloomFilter);
-		chunk.meta_data.bloom_filter_offset = BigInt(offset);
-		chunk.meta_data.bloom_filter_length = writer.offset - offset;
-	}
-}
-const BLOCK_SIZE$1 = 128;
-const MINIBLOCKS_PER_BLOCK = 4;
-const VALUES_PER_MINIBLOCK = BLOCK_SIZE$1 / MINIBLOCKS_PER_BLOCK;
-function deltaBinaryPack(writer, values) {
-	const count = values.length;
-	if (count === 0) {
-		writer.appendVarInt(BLOCK_SIZE$1);
-		writer.appendVarInt(MINIBLOCKS_PER_BLOCK);
-		writer.appendVarInt(0);
-		writer.appendVarInt(0);
-		return;
-	}
-	if (typeof values[0] !== "number" && typeof values[0] !== "bigint") throw new Error("deltaBinaryPack only supports number or bigint arrays");
-	writer.appendVarInt(BLOCK_SIZE$1);
-	writer.appendVarInt(MINIBLOCKS_PER_BLOCK);
-	writer.appendVarInt(count);
-	writer.appendZigZag(values[0]);
-	let index = 1;
-	while (index < count) {
-		const blockEnd = Math.min(index + BLOCK_SIZE$1, count);
-		const blockSize = blockEnd - index;
-		const blockDeltas = new BigInt64Array(blockSize);
-		let minDelta = BigInt(values[index]) - BigInt(values[index - 1]);
-		blockDeltas[0] = minDelta;
-		for (let i = 1; i < blockSize; i++) {
-			const delta = BigInt(values[index + i]) - BigInt(values[index + i - 1]);
-			blockDeltas[i] = delta;
-			if (delta < minDelta) minDelta = delta;
-		}
-		writer.appendZigZag(minDelta);
-		const bitWidths = new Uint8Array(MINIBLOCKS_PER_BLOCK);
-		for (let mb = 0; mb < MINIBLOCKS_PER_BLOCK; mb++) {
-			const mbStart = mb * VALUES_PER_MINIBLOCK;
-			const mbEnd = Math.min(mbStart + VALUES_PER_MINIBLOCK, blockSize);
-			let maxAdjusted = 0n;
-			for (let i = mbStart; i < mbEnd; i++) {
-				const adjusted = blockDeltas[i] - minDelta;
-				if (adjusted > maxAdjusted) maxAdjusted = adjusted;
-			}
-			bitWidths[mb] = bitWidth(maxAdjusted);
-		}
-		writer.appendBytes(bitWidths);
-		for (let mb = 0; mb < MINIBLOCKS_PER_BLOCK; mb++) {
-			const bitWidth = bitWidths[mb];
-			if (bitWidth === 0) continue;
-			const mbStart = mb * VALUES_PER_MINIBLOCK;
-			const mbEnd = Math.min(mbStart + VALUES_PER_MINIBLOCK, blockSize);
-			let buffer = 0n;
-			let bitsUsed = 0;
-			for (let i = 0; i < VALUES_PER_MINIBLOCK; i++) {
-				const adjusted = mbStart + i < mbEnd ? blockDeltas[mbStart + i] - minDelta : 0n;
-				buffer |= adjusted << BigInt(bitsUsed);
-				bitsUsed += bitWidth;
-				while (bitsUsed >= 8) {
-					writer.appendUint8(Number(buffer & 255n));
-					buffer >>= 8n;
-					bitsUsed -= 8;
-				}
-			}
-		}
-		index = blockEnd;
-	}
-}
-function deltaLengthByteArray(writer, values) {
-	const lengths = new Int32Array(values.length);
-	for (let i = 0; i < values.length; i++) {
-		const value = values[i];
-		if (!(value instanceof Uint8Array)) throw new Error("deltaLengthByteArray expects Uint8Array values");
-		lengths[i] = value.length;
-	}
-	deltaBinaryPack(writer, lengths);
-	for (const value of values) writer.appendBytes(value);
-}
-function deltaByteArray(writer, values) {
-	if (values.length === 0) {
-		deltaBinaryPack(writer, []);
-		deltaBinaryPack(writer, []);
-		return;
-	}
-	const prefixLengths = new Int32Array(values.length);
-	const suffixLengths = new Int32Array(values.length);
-	const suffixes = new Array(values.length);
-	if (!(values[0] instanceof Uint8Array)) throw new Error("deltaByteArray expects Uint8Array values");
-	prefixLengths[0] = 0;
-	suffixLengths[0] = values[0].length;
-	suffixes[0] = values[0];
-	for (let i = 1; i < values.length; i++) {
-		const prev = values[i - 1];
-		const curr = values[i];
-		if (!(curr instanceof Uint8Array)) throw new Error("deltaByteArray expects Uint8Array values");
-		let prefixLen = 0;
-		const maxPrefix = Math.min(prev.length, curr.length);
-		while (prefixLen < maxPrefix && prev[prefixLen] === curr[prefixLen]) prefixLen++;
-		prefixLengths[i] = prefixLen;
-		suffixLengths[i] = curr.length - prefixLen;
-		suffixes[i] = curr.subarray(prefixLen);
-	}
-	deltaBinaryPack(writer, prefixLengths);
-	deltaBinaryPack(writer, suffixLengths);
-	for (const suffix of suffixes) writer.appendBytes(suffix);
-}
-function bitWidth(value) {
-	if (value === 0n) return 0;
-	let bits = 0;
-	while (value > 0n) {
-		bits++;
-		value >>= 1n;
-	}
-	return bits;
-}
-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);
-}
-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);
-	}
-}
-const encoder = new TextEncoder();
-const INT64_MIN = -(2n ** 63n);
-const INT64_MAX = 2n ** 63n - 1n;
-const VARIANT_NULL = new Uint8Array([0]);
-const RESERVED_SHREDDING_FIELDS = /* @__PURE__ */ new Set(["value", "typed_value"]);
-const EMPTY_KEY_INDEX = /* @__PURE__ */ new Map();
-const EMPTY_METADATA = writeVariantMetadata([]);
-function encodeVariantColumn(values, shredding, column) {
-	if (column?.required) {
-		for (let i = 0; i < values.length; i++) if (values[i] === void 0) throw new Error(`required variant column ${column.name} has undefined value at index ${i}`);
-	}
-	const shreddingConfig = shredding && normalizeShreddingConfig(shredding);
-	if (shreddingConfig) {
-		const metadataCache = /* @__PURE__ */ new Map();
-		return values.map((value) => {
-			if (value === void 0) return null;
-			const keys = /* @__PURE__ */ new Set();
-			collectKeys(value, keys);
-			const { metadata, keyIndex } = getVariantRowMetadata(keys, metadataCache);
-			return {
-				metadata,
-				...encodeShredded(value, shreddingConfig, keyIndex, true)
-			};
-		});
-	}
-	const dictionary = buildVariantDictionary(values);
-	const metadata = writeVariantMetadata(dictionary);
-	const keyIndex = /* @__PURE__ */ new Map();
-	for (let i = 0; i < dictionary.length; i++) keyIndex.set(dictionary[i], i);
-	return values.map((value) => {
-		if (value === void 0) return null;
-		return {
-			metadata,
-			value: writeVariantValue(value, keyIndex)
-		};
-	});
-}
-function encodeShredded(value, shredType, keyIndex, allowPartialObjects) {
-	if (value === null || value === void 0) return {
-		value: VARIANT_NULL,
-		typed_value: null
-	};
-	if (Array.isArray(shredType)) {
-		if (!Array.isArray(value)) return {
-			value: writeVariantValue(value, keyIndex),
-			typed_value: null
-		};
-		const elemShred = shredType[0];
-		return {
-			value: null,
-			typed_value: value.map((el) => encodeShredded(el, elemShred, keyIndex, false))
-		};
-	}
-	if (typeof shredType === "object") {
-		if (typeof value !== "object" || Array.isArray(value) || value instanceof Date || value instanceof Uint8Array) return {
-			value: writeVariantValue(value, keyIndex),
-			typed_value: null
-		};
-		const remaining = {};
-		let hasRemaining = false;
-		for (const k of Object.keys(value)) {
-			if (k in shredType || value[k] === void 0) continue;
-			remaining[k] = value[k];
-			hasRemaining = true;
-		}
-		if (hasRemaining && !allowPartialObjects) return {
-			value: writeVariantValue(value, keyIndex),
-			typed_value: null
-		};
-		const fieldNames = Object.keys(shredType);
-		if (fieldNames.some((fieldName) => (!Object.prototype.hasOwnProperty.call(value, fieldName) || value[fieldName] === void 0) && keyIndex.has(fieldName))) return {
-			value: writeVariantValue(value, keyIndex),
-			typed_value: null
-		};
-		const typedValue = {};
-		for (const fieldName of fieldNames) {
-			if (!Object.prototype.hasOwnProperty.call(value, fieldName) || value[fieldName] === void 0) continue;
-			typedValue[fieldName] = encodeShredded(value[fieldName], shredType[fieldName], keyIndex, false);
-		}
-		return {
-			value: hasRemaining ? writeVariantValue(remaining, keyIndex) : null,
-			typed_value: typedValue
-		};
-	}
-	if (matchesType(value, shredType)) return {
-		value: null,
-		typed_value: value
-	};
-	return {
-		value: writeVariantValue(value, keyIndex),
-		typed_value: null
-	};
-}
-function getVariantRowMetadata(keys, metadataCache) {
-	if (keys.size === 0) return {
-		metadata: EMPTY_METADATA,
-		keyIndex: EMPTY_KEY_INDEX
-	};
-	const dictionary = [...keys].sort();
-	const cacheKey = dictionary.join("\0");
-	const cached = metadataCache.get(cacheKey);
-	if (cached) return cached;
-	const metadata = writeVariantMetadata(dictionary);
-	const keyIndex = /* @__PURE__ */ new Map();
-	for (let i = 0; i < dictionary.length; i++) keyIndex.set(dictionary[i], i);
-	const rowMetadata = {
-		metadata,
-		keyIndex
-	};
-	metadataCache.set(cacheKey, rowMetadata);
-	return rowMetadata;
-}
-function matchesType(value, type) {
-	if (value === null || value === void 0) return false;
-	switch (type) {
-		case "BOOLEAN": return typeof value === "boolean";
-		case "INT32": return typeof value === "number" && Number.isInteger(value) && value >= -2147483648 && value <= 2147483647;
-		case "INT64": return typeof value === "bigint" && value >= INT64_MIN && value <= INT64_MAX;
-		case "FLOAT": return typeof value === "number";
-		case "DOUBLE": return typeof value === "number";
-		case "STRING": return typeof value === "string";
-		case "TIMESTAMP": return value instanceof Date;
-		default: return false;
-	}
-}
-function normalizeShreddingConfig(shredding) {
-	if (Array.isArray(shredding)) {
-		const elem = shredding.length ? normalizeShreddingConfig(shredding[0]) : void 0;
-		return elem === void 0 ? void 0 : [elem];
-	}
-	if (typeof shredding === "object") {
-		const normalized = {};
-		for (const [key, type] of Object.entries(shredding)) {
-			if (RESERVED_SHREDDING_FIELDS.has(key)) continue;
-			const norm = normalizeShreddingConfig(type);
-			if (norm !== void 0) normalized[key] = norm;
-		}
-		return Object.keys(normalized).length > 0 ? normalized : void 0;
-	}
-	return shredding;
-}
-function buildVariantDictionary(values) {
-	const keys = /* @__PURE__ */ new Set();
-	collectKeys(values, keys);
-	return [...keys].sort();
-}
-function collectKeys(value, keys) {
-	if (value === null || value === void 0) return;
-	if (Array.isArray(value)) {
-		for (const item of value) collectKeys(item, keys);
-		return;
-	}
-	if (value instanceof Date || value instanceof Uint8Array) return;
-	if (typeof value === "object") for (const key of Object.keys(value)) {
-		keys.add(key);
-		collectKeys(value[key], keys);
-	}
-}
-function writeVariantMetadata(dictionary) {
-	const n = dictionary.length;
-	const encoded = new Array(n);
-	let totalStringBytes = 0;
-	for (let i = 0; i < n; i++) {
-		const e = encoder.encode(dictionary[i]);
-		encoded[i] = e;
-		totalStringBytes += e.length;
-	}
-	const offsetSize = byteWidth(totalStringBytes);
-	const header = 17 | offsetSize - 1 << 6;
-	const totalSize = 1 + offsetSize + (n + 1) * offsetSize + totalStringBytes;
-	const bytes = new Uint8Array(totalSize);
-	let offset = 0;
-	bytes[offset++] = header;
-	for (let j = 0; j < offsetSize; j++) bytes[offset++] = n >> j * 8 & 255;
-	let strOffset = 0;
-	for (let i = 0; i < n; i++) {
-		for (let j = 0; j < offsetSize; j++) bytes[offset++] = strOffset >> j * 8 & 255;
-		strOffset += encoded[i].length;
-	}
-	for (let j = 0; j < offsetSize; j++) bytes[offset++] = strOffset >> j * 8 & 255;
-	for (let i = 0; i < n; i++) {
-		bytes.set(encoded[i], offset);
-		offset += encoded[i].length;
-	}
-	return bytes;
-}
-function writeVariantValue(value, keyIndex) {
-	const writer = new ByteWriter(8);
-	writeValue(value, writer, keyIndex);
-	return writer.getBytes();
-}
-function writeValue(val, writer, keyIndex) {
-	if (val === null || val === void 0) {
-		writer.appendUint8(0);
-		return;
-	}
-	if (val === true) {
-		writer.appendUint8(4);
-		return;
-	}
-	if (val === false) {
-		writer.appendUint8(8);
-		return;
-	}
-	if (typeof val === "bigint") {
-		if (val < INT64_MIN || val > INT64_MAX) throw new RangeError(`variant bigint out of int64 range: ${val}`);
-		writer.appendUint8(24);
-		writer.appendInt64(val);
-		return;
-	}
-	if (typeof val === "number") {
-		if (Number.isInteger(val)) {
-			if (val >= -128 && val <= 127) {
-				writer.appendUint8(12);
-				writer.appendUint8(val & 255);
-				return;
-			}
-			if (val >= -32768 && val <= 32767) {
-				writer.appendUint8(16);
-				appendUnsignedLE(writer, val, 2);
-				return;
-			}
-			if (val >= -2147483648 && val <= 2147483647) {
-				writer.appendUint8(20);
-				writer.appendInt32(val);
-				return;
-			}
-		}
-		writer.appendUint8(28);
-		writer.appendFloat64(val);
-		return;
-	}
-	if (typeof val === "string") {
-		const strBytes = encoder.encode(val);
-		if (strBytes.length <= 63) {
-			writer.appendUint8(strBytes.length << 2 | 1);
-			writer.appendBytes(strBytes);
-		} else {
-			writer.appendUint8(64);
-			writer.appendUint32(strBytes.length);
-			writer.appendBytes(strBytes);
-		}
-		return;
-	}
-	if (val instanceof Date) {
-		writer.appendUint8(52);
-		writer.appendInt64(BigInt(val.getTime()) * 1000n);
-		return;
-	}
-	if (val instanceof Uint8Array) {
-		writer.appendUint8(60);
-		writer.appendUint32(val.length);
-		writer.appendBytes(val);
-		return;
-	}
-	if (Array.isArray(val)) {
-		writeVariantArray(val, writer, keyIndex);
-		return;
-	}
-	if (typeof val === "object") {
-		writeVariantObject(val, writer, keyIndex);
-		return;
-	}
-	throw new Error(`variant cannot encode value: ${val}`);
-}
-function writeVariantObject(obj, writer, keyIndex) {
-	const entries = Object.keys(obj).filter((key) => obj[key] !== void 0).map((key) => {
-		const id = keyIndex.get(key);
-		if (id === void 0) throw new Error(`variant key not in dictionary: ${key}`);
-		return {
-			id,
-			key
-		};
-	});
-	entries.sort((a, b) => a.id - b.id);
-	const numElements = entries.length;
-	const idWidth = byteWidth(numElements > 0 ? entries[numElements - 1].id : 0);
-	const scratch = new ByteWriter(8);
-	const offsets = new Array(numElements + 1);
-	offsets[0] = 0;
-	for (let i = 0; i < numElements; i++) {
-		writeValue(obj[entries[i].key], scratch, keyIndex);
-		offsets[i + 1] = scratch.index;
-	}
-	const offsetWidth = byteWidth(offsets[numElements]);
-	const isLarge = numElements > 255 ? 1 : 0;
-	writer.appendUint8((offsetWidth - 1 | idWidth - 1 << 2 | isLarge << 4) << 2 | 2);
-	if (isLarge) writer.appendUint32(numElements);
-	else writer.appendUint8(numElements);
-	for (const { id } of entries) appendUnsignedLE(writer, id, idWidth);
-	for (const off of offsets) appendUnsignedLE(writer, off, offsetWidth);
-	writer.appendBytes(scratch.getBytes());
-}
-function writeVariantArray(arr, writer, keyIndex) {
-	const numElements = arr.length;
-	const scratch = new ByteWriter(8);
-	const offsets = new Array(numElements + 1);
-	offsets[0] = 0;
-	for (let i = 0; i < numElements; i++) {
-		writeValue(arr[i], scratch, keyIndex);
-		offsets[i + 1] = scratch.index;
-	}
-	const offsetWidth = byteWidth(offsets[numElements]);
-	const isLarge = numElements > 255 ? 1 : 0;
-	writer.appendUint8((offsetWidth - 1 | isLarge << 2) << 2 | 3);
-	if (isLarge) writer.appendUint32(numElements);
-	else writer.appendUint8(numElements);
-	for (const off of offsets) appendUnsignedLE(writer, off, offsetWidth);
-	writer.appendBytes(scratch.getBytes());
-}
-function byteWidth(maxValue) {
-	if (maxValue <= 255) return 1;
-	if (maxValue <= 65535) return 2;
-	if (maxValue <= 16777215) return 3;
-	return 4;
-}
-function appendUnsignedLE(writer, value, width) {
-	for (let i = 0; i < width; i++) writer.appendUint8(value >> i * 8 & 255);
-}
-function schemaFromColumnData({ columnData, schemaOverrides }) {
-	const schema = [{
-		name: "root",
-		num_children: columnData.length
-	}];
-	for (const { name, data, type, nullable, shredding } of columnData) if (schemaOverrides?.[name]) {
-		const override = schemaOverrides[name];
-		if (type || nullable !== void 0) throw new Error(`cannot provide both type and schema override for column ${name}`);
-		if (override.name !== name) throw new Error(`schema override for column ${name} must have matching name, got ${override.name}`);
-		if (override.type === "FIXED_LEN_BYTE_ARRAY" && !override.type_length) throw new Error("schema override for FIXED_LEN_BYTE_ARRAY must include type_length");
-		if (override.num_children) throw new Error("schema override does not support nested types");
-		schema.push(override);
-	} else if (type === "VARIANT") {
-		const repetition_type = nullable === false ? "REQUIRED" : "OPTIONAL";
-		const shreddingConfig = shredding && shredding !== true ? normalizeShreddingConfig(shredding) : void 0;
-		if (shreddingConfig) schema.push({
-			name,
-			repetition_type,
-			num_children: 3,
-			logical_type: { type: "VARIANT" }
-		}, {
-			name: "metadata",
-			type: "BYTE_ARRAY",
-			repetition_type: "REQUIRED"
-		}, {
-			name: "value",
-			type: "BYTE_ARRAY",
-			repetition_type: "OPTIONAL"
-		}, ...buildVariantTypedValue(shreddingConfig));
-		else schema.push({
-			name,
-			repetition_type,
-			num_children: 2,
-			logical_type: { type: "VARIANT" }
-		}, {
-			name: "metadata",
-			type: "BYTE_ARRAY",
-			repetition_type: "REQUIRED"
-		}, {
-			name: "value",
-			type: "BYTE_ARRAY",
-			repetition_type: "OPTIONAL"
-		});
-	} else if (type) schema.push(basicTypeToSchemaElement(name, type, nullable));
-	else schema.push(autoSchemaElement(name, data.slice(0, 1e3)));
-	return schema;
-}
-function buildVariantTypedValue(shredType) {
-	if (Array.isArray(shredType)) return [
-		{
-			name: "typed_value",
-			repetition_type: "OPTIONAL",
-			converted_type: "LIST",
-			num_children: 1
-		},
-		{
-			name: "list",
-			repetition_type: "REPEATED",
-			num_children: 1
-		},
-		{
-			name: "element",
-			repetition_type: "REQUIRED",
-			num_children: 2
-		},
-		{
-			name: "value",
-			type: "BYTE_ARRAY",
-			repetition_type: "OPTIONAL"
-		},
-		...buildVariantTypedValue(shredType[0])
-	];
-	if (typeof shredType === "object") {
-		const fieldNames = Object.keys(shredType);
-		const elements = [{
-			name: "typed_value",
-			repetition_type: "OPTIONAL",
-			num_children: fieldNames.length
-		}];
-		for (const fieldName of fieldNames) elements.push({
-			name: fieldName,
-			repetition_type: "OPTIONAL",
-			num_children: 2
-		}, {
-			name: "value",
-			type: "BYTE_ARRAY",
-			repetition_type: "OPTIONAL"
-		}, ...buildVariantTypedValue(shredType[fieldName]));
-		return elements;
-	}
-	return [shreddedLeafElement(shredType)];
-}
-function shreddedLeafElement(type) {
-	switch (type) {
-		case "STRING": return {
-			name: "typed_value",
-			type: "BYTE_ARRAY",
-			converted_type: "UTF8",
-			repetition_type: "OPTIONAL"
-		};
-		case "INT32": return {
-			name: "typed_value",
-			type: "INT32",
-			repetition_type: "OPTIONAL"
-		};
-		case "INT64": return {
-			name: "typed_value",
-			type: "INT64",
-			repetition_type: "OPTIONAL"
-		};
-		case "DOUBLE": return {
-			name: "typed_value",
-			type: "DOUBLE",
-			repetition_type: "OPTIONAL"
-		};
-		case "FLOAT": return {
-			name: "typed_value",
-			type: "FLOAT",
-			repetition_type: "OPTIONAL"
-		};
-		case "BOOLEAN": return {
-			name: "typed_value",
-			type: "BOOLEAN",
-			repetition_type: "OPTIONAL"
-		};
-		case "TIMESTAMP": return {
-			name: "typed_value",
-			type: "INT64",
-			converted_type: "TIMESTAMP_MICROS",
-			repetition_type: "OPTIONAL"
-		};
-		default: throw new Error(`unsupported shredded field type: ${type}`);
-	}
-}
-function basicTypeToSchemaElement(name, type, nullable) {
-	const repetition_type = nullable === false ? "REQUIRED" : "OPTIONAL";
-	if (type === "STRING") return {
-		name,
-		type: "BYTE_ARRAY",
-		converted_type: "UTF8",
-		repetition_type
-	};
-	if (type === "JSON") return {
-		name,
-		type: "BYTE_ARRAY",
-		converted_type: "JSON",
-		repetition_type
-	};
-	if (type === "TIMESTAMP") return {
-		name,
-		type: "INT64",
-		converted_type: "TIMESTAMP_MILLIS",
-		repetition_type
-	};
-	if (type === "UUID") return {
-		name,
-		type: "FIXED_LEN_BYTE_ARRAY",
-		type_length: 16,
-		logical_type: { type: "UUID" },
-		repetition_type
-	};
-	if (type === "FLOAT16") return {
-		name,
-		type: "FIXED_LEN_BYTE_ARRAY",
-		type_length: 2,
-		logical_type: { type: "FLOAT16" },
-		repetition_type
-	};
-	if (type === "GEOMETRY") return {
-		name,
-		type: "BYTE_ARRAY",
-		logical_type: { type: "GEOMETRY" },
-		repetition_type
-	};
-	if (type === "GEOGRAPHY") return {
-		name,
-		type: "BYTE_ARRAY",
-		logical_type: { type: "GEOGRAPHY" },
-		repetition_type
-	};
-	return {
-		name,
-		type,
-		repetition_type
-	};
-}
-function autoSchemaElement(name, values) {
-	let type;
-	let repetition_type = "REQUIRED";
-	let converted_type;
-	if (values instanceof Int32Array) return {
-		name,
-		type: "INT32",
-		repetition_type
-	};
-	if (values instanceof BigInt64Array) return {
-		name,
-		type: "INT64",
-		repetition_type
-	};
-	if (values instanceof Float32Array) return {
-		name,
-		type: "FLOAT",
-		repetition_type
-	};
-	if (values instanceof Float64Array) return {
-		name,
-		type: "DOUBLE",
-		repetition_type
-	};
-	for (const value of values) if (value === null || value === void 0) repetition_type = "OPTIONAL";
-	else {
-		let valueType;
-		let valueConvertedType;
-		if (typeof value === "boolean") valueType = "BOOLEAN";
-		else if (typeof value === "bigint") valueType = "INT64";
-		else if (Number.isInteger(value)) valueType = "INT32";
-		else if (typeof value === "number") valueType = "DOUBLE";
-		else if (value instanceof Uint8Array) valueType = "BYTE_ARRAY";
-		else if (typeof value === "string") {
-			valueType = "BYTE_ARRAY";
-			valueConvertedType = "UTF8";
-		} else if (value instanceof Date) {
-			valueType = "INT64";
-			valueConvertedType = "TIMESTAMP_MILLIS";
-		} else if (typeof value === "object") {
-			valueType = "BYTE_ARRAY";
-			valueConvertedType = "JSON";
-		} else throw new Error(`cannot determine parquet type for: ${value}`);
-		if (type === void 0) {
-			type = valueType;
-			converted_type = valueConvertedType;
-		} else if (type === "INT32" && valueType === "DOUBLE") type = "DOUBLE";
-		else if (type === "DOUBLE" && valueType === "INT32") valueType = "DOUBLE";
-		else if (type !== valueType || converted_type !== valueConvertedType) throw new Error(`parquet cannot write mixed types: ${converted_type ?? type} and ${valueConvertedType ?? valueType}`);
-	}
-	if (!type) {
-		type = "BYTE_ARRAY";
-		repetition_type = "OPTIONAL";
-	}
-	return {
-		name,
-		type,
-		repetition_type,
-		converted_type
-	};
-}
-function getMaxRepetitionLevel(schemaPath) {
-	let maxLevel = 0;
-	for (const element of schemaPath) if (element.repetition_type === "REPEATED") maxLevel++;
-	return maxLevel;
-}
-function writeByteStreamSplit(writer, values, type, typeLength) {
-	const count = values.length;
-	let bytes;
-	let width;
-	if (type === "FLOAT") {
-		const typed = values instanceof Float32Array ? values : new Float32Array(numberArray(values));
-		bytes = new Uint8Array(typed.buffer, typed.byteOffset, typed.byteLength);
-		width = 4;
-	} else if (type === "DOUBLE") {
-		const typed = values instanceof Float64Array ? values : new Float64Array(numberArray(values));
-		bytes = new Uint8Array(typed.buffer, typed.byteOffset, typed.byteLength);
-		width = 8;
-	} else if (type === "INT32") {
-		const typed = values instanceof Int32Array ? values : new Int32Array(numberArray(values));
-		bytes = new Uint8Array(typed.buffer, typed.byteOffset, typed.byteLength);
-		width = 4;
-	} else if (type === "INT64") {
-		const typed = bigIntArray(values);
-		bytes = new Uint8Array(typed.buffer, typed.byteOffset, typed.byteLength);
-		width = 8;
-	} else if (type === "FIXED_LEN_BYTE_ARRAY") {
-		if (!typeLength) throw new Error("parquet byte_stream_split missing type_length");
-		width = typeLength;
-		bytes = new Uint8Array(count * width);
-		for (let i = 0; i < count; i++) bytes.set(values[i], i * width);
-	} else throw new Error(`parquet byte_stream_split unsupported type: ${type}`);
-	for (let b = 0; b < width; b++) for (let i = 0; i < count; i++) writer.appendUint8(bytes[i * width + b]);
-}
-function numberArray(values) {
-	if (Array.isArray(values) && values.every((v) => typeof v === "number")) return values;
-	throw new Error("Expected number array for BYTE_STREAM_SPLIT encoding");
-}
-function bigIntArray(values) {
-	if (values instanceof BigInt64Array) return values;
-	if (Array.isArray(values) && values.every((v) => typeof v === "bigint")) return new BigInt64Array(values);
-	throw new Error("Expected bigint array for BYTE_STREAM_SPLIT encoding");
-}
-function writeDataPageV2({ writer, column, encoding, pageData }) {
-	const { columnName, element, codec, compressors } = column;
-	const { type, type_length, repetition_type } = element;
-	if (!type) throw new Error(`column ${columnName} cannot determine type`);
-	if (repetition_type === "REPEATED") throw new Error(`column ${columnName} repeated types not supported`);
-	const levelWriter = new ByteWriter();
-	const { definition_levels_byte_length, repetition_levels_byte_length, num_nulls, num_values, num_rows } = writeLevels(levelWriter, column, pageData);
-	const nonnull = num_nulls ? pageData.values.filter((v) => v !== null && v !== void 0) : pageData.values;
-	const page = new ByteWriter();
-	if (encoding === "PLAIN") writePlain(page, nonnull, type, type_length);
-	else if (encoding === "RLE") {
-		if (type !== "BOOLEAN") throw new Error("RLE encoding only supported for BOOLEAN type");
-		const rleData = new ByteWriter();
-		writeRleBitPackedHybrid(rleData, nonnull, 1);
-		page.appendUint32(rleData.offset);
-		page.appendBytes(rleData.getBytes());
-	} else if (encoding === "PLAIN_DICTIONARY" || encoding === "RLE_DICTIONARY") {
-		let maxValue = 0;
-		for (const v of nonnull) if (v > maxValue) maxValue = v;
-		const bitWidth = Math.ceil(Math.log2(maxValue + 1));
-		page.appendUint8(bitWidth);
-		writeRleBitPackedHybrid(page, nonnull, bitWidth);
-	} else if (encoding === "DELTA_BINARY_PACKED") {
-		if (type !== "INT32" && type !== "INT64") throw new Error("DELTA_BINARY_PACKED encoding only supported for INT32 and INT64 types");
-		deltaBinaryPack(page, nonnull);
-	} else if (encoding === "DELTA_LENGTH_BYTE_ARRAY") {
-		if (type !== "BYTE_ARRAY") throw new Error("DELTA_LENGTH_BYTE_ARRAY encoding only supported for BYTE_ARRAY type");
-		deltaLengthByteArray(page, nonnull);
-	} else if (encoding === "DELTA_BYTE_ARRAY") {
-		if (type !== "BYTE_ARRAY") throw new Error("DELTA_BYTE_ARRAY encoding only supported for BYTE_ARRAY type");
-		deltaByteArray(page, nonnull);
-	} else if (encoding === "BYTE_STREAM_SPLIT") writeByteStreamSplit(page, nonnull, type, type_length);
-	else throw new Error(`parquet unsupported encoding: ${encoding}`);
-	const pageBytes = page.getBytes();
-	const compressedBytes = compressors[codec]?.(pageBytes) ?? pageBytes;
-	writePageHeader(writer, {
-		type: "DATA_PAGE_V2",
-		uncompressed_page_size: levelWriter.offset + page.offset,
-		compressed_page_size: levelWriter.offset + compressedBytes.length,
-		data_page_header_v2: {
-			num_values,
-			num_nulls,
-			num_rows,
-			encoding,
-			definition_levels_byte_length,
-			repetition_levels_byte_length,
-			is_compressed: !!codec
-		}
-	});
-	writer.appendBytes(levelWriter.getBytes());
-	writer.appendBytes(compressedBytes);
-}
-function writePageHeader(writer, header) {
-	serializeTCompactProtocol(writer, {
-		field_1: PageTypes.indexOf(header.type),
-		field_2: header.uncompressed_page_size,
-		field_3: header.compressed_page_size,
-		field_4: header.crc,
-		field_5: header.data_page_header && {
-			field_1: header.data_page_header.num_values,
-			field_2: Encodings.indexOf(header.data_page_header.encoding),
-			field_3: Encodings.indexOf(header.data_page_header.definition_level_encoding),
-			field_4: Encodings.indexOf(header.data_page_header.repetition_level_encoding)
-		},
-		field_7: header.dictionary_page_header && {
-			field_1: header.dictionary_page_header.num_values,
-			field_2: Encodings.indexOf(header.dictionary_page_header.encoding)
-		},
-		field_8: header.data_page_header_v2 && {
-			field_1: header.data_page_header_v2.num_values,
-			field_2: header.data_page_header_v2.num_nulls,
-			field_3: header.data_page_header_v2.num_rows,
-			field_4: Encodings.indexOf(header.data_page_header_v2.encoding),
-			field_5: header.data_page_header_v2.definition_levels_byte_length,
-			field_6: header.data_page_header_v2.repetition_levels_byte_length,
-			field_7: header.data_page_header_v2.is_compressed ? void 0 : false
-		}
-	});
-}
-function writeLevels(writer, column, dataPage) {
-	const { schemaPath } = column;
-	const { values, definitionLevels, repetitionLevels, maxDefinitionLevel } = dataPage;
-	const num_values = definitionLevels.length || values.length;
-	let num_nulls = 0;
-	let num_rows = 0;
-	if (repetitionLevels.length) {
-		for (let i = 0; i < repetitionLevels.length; i++) if (repetitionLevels[i] === 0) num_rows++;
-	} else num_rows = values.length;
-	if (definitionLevels.length) {
-		for (let i = 0; i < definitionLevels.length; i++) if (definitionLevels[i] < maxDefinitionLevel) num_nulls++;
-	}
-	const maxRepetitionLevel = getMaxRepetitionLevel(schemaPath);
-	let repetition_levels_byte_length = 0;
-	if (maxRepetitionLevel) repetition_levels_byte_length = writeRleBitPackedHybrid(writer, repetitionLevels, Math.ceil(Math.log2(maxRepetitionLevel + 1)));
-	let definition_levels_byte_length = 0;
-	if (maxDefinitionLevel) definition_levels_byte_length = writeRleBitPackedHybrid(writer, definitionLevels, Math.ceil(Math.log2(maxDefinitionLevel + 1)));
-	return {
-		definition_levels_byte_length,
-		repetition_levels_byte_length,
-		num_values,
-		num_nulls,
-		num_rows
-	};
-}
-function estimateValueSize(value, type, type_length) {
-	if (value === null || value === void 0) return 0;
-	if (type === "BOOLEAN") return .125;
-	if (type === "INT32" || type === "FLOAT") return 4;
-	if (type === "INT64" || type === "DOUBLE") return 8;
-	if (type === "INT96") return 12;
-	if (type === "FIXED_LEN_BYTE_ARRAY") return type_length ?? 0;
-	if (type === "BYTE_ARRAY") {
-		if (value instanceof Uint8Array) return value.byteLength;
-		if (typeof value === "string") return value.length;
-	}
-	return 0;
-}
-function hashBytes(bytes) {
-	let h = 2166136261;
-	for (let i = 0; i < bytes.length; i++) {
-		h ^= bytes[i];
-		h = Math.imul(h, 16777619);
-	}
-	return h >>> 0;
-}
-function bytesEqual(a, b) {
-	if (a.length !== b.length) return false;
-	for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
-	return true;
-}
-function useDictionary(values, type, type_length, encoding, pageSize) {
-	if (encoding && encoding !== "RLE_DICTIONARY") return {};
-	if (type === "BOOLEAN") return {};
-	const sample = values.slice(0, 1e3);
-	const sampleKeys = /* @__PURE__ */ new Set();
-	for (const value of sample) sampleKeys.add(value instanceof Uint8Array ? hashBytes(value) : value);
-	if (sampleKeys.size === 0 || sampleKeys.size / sample.length > .5) return {};
-	const dictionary = [];
-	const indexes = new Array(values.length);
-	const valueIndex = /* @__PURE__ */ new Map();
-	const hashBuckets = /* @__PURE__ */ new Map();
-	let dictSize = 0;
-	for (let i = 0; i < values.length; i++) {
-		const value = values[i];
-		if (value === null || value === void 0) continue;
-		let index;
-		if (value instanceof Uint8Array) {
-			const hash = hashBytes(value);
-			const bucket = hashBuckets.get(hash);
-			if (bucket) {
-				for (const j of bucket) if (bytesEqual(dictionary[j], value)) {
-					index = j;
-					break;
-				}
-			}
-			if (index === void 0) {
-				dictSize += value.byteLength;
-				if (pageSize && dictSize > pageSize) return {};
-				index = dictionary.length;
-				dictionary.push(value);
-				if (bucket) bucket.push(index);
-				else hashBuckets.set(hash, [index]);
-			}
-		} else {
-			index = valueIndex.get(value);
-			if (index === void 0) {
-				dictSize += estimateValueSize(value, type, type_length);
-				if (pageSize && dictSize > pageSize) return {};
-				index = dictionary.length;
-				dictionary.push(value);
-				valueIndex.set(value, index);
-			}
-		}
-		indexes[i] = index;
-	}
-	return {
-		dictionary,
-		indexes
-	};
-}
-function writeDictionaryPage(writer, column, dictionary) {
-	const { element, codec, compressors } = column;
-	const { type, type_length } = element;
-	if (!type) throw new Error(`column ${column.columnName} cannot determine type`);
-	const dictionaryPage = new ByteWriter();
-	writePlain(dictionaryPage, dictionary, type, type_length);
-	const dictionaryBytes = dictionaryPage.getBytes();
-	const compressedBytes = compressors[codec]?.(dictionaryBytes) ?? dictionaryBytes;
-	writePageHeader(writer, {
-		type: "DICTIONARY_PAGE",
-		uncompressed_page_size: dictionaryBytes.byteLength,
-		compressed_page_size: compressedBytes.byteLength,
-		dictionary_page_header: {
-			num_values: dictionary.length,
-			encoding: "PLAIN"
-		}
-	});
-	writer.appendBytes(compressedBytes);
-}
-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$1(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$1(geometry) {
-	if (geometry.type === "GeometryCollection") {
-		let maxDim = 0;
-		for (const child of geometry.geometries || []) maxDim = Math.max(maxDim, inferGeometryDimensions$1(child));
-		return maxDim || 2;
-	}
-	return inferCoordinateDimensions$1(geometry.coordinates);
-}
-function inferCoordinateDimensions$1(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$1(item));
-	return maxDim || 2;
-}
-function geojsonToWkb(geometry) {
-	const writer = new ByteWriter();
-	writeGeometry(writer, geometry);
-	return writer.getBytes();
-}
-function writeGeometry(writer, geometry) {
-	if (typeof geometry !== "object") throw new Error("geometry values must be GeoJSON geometries");
-	const typeCode = geometryTypeCode(geometry.type);
-	const dim = inferGeometryDimensions(geometry);
-	let flag = 0;
-	if (dim === 3) flag = 1;
-	else if (dim === 4) flag = 3;
-	else if (dim > 4) throw new Error(`unsupported geometry dimensions: ${dim}`);
-	writer.appendUint8(1);
-	writer.appendUint32(typeCode + flag * 1e3);
-	if (geometry.type === "Point") writePosition(writer, geometry.coordinates, dim);
-	else if (geometry.type === "LineString") writeLine(writer, geometry.coordinates, dim);
-	else if (geometry.type === "Polygon") {
-		writer.appendUint32(geometry.coordinates.length);
-		for (const ring of geometry.coordinates) writeLine(writer, ring, dim);
-	} else if (geometry.type === "MultiPoint") {
-		writer.appendUint32(geometry.coordinates.length);
-		for (const coordinates of geometry.coordinates) writeGeometry(writer, {
-			type: "Point",
-			coordinates
-		});
-	} else if (geometry.type === "MultiLineString") {
-		writer.appendUint32(geometry.coordinates.length);
-		for (const coordinates of geometry.coordinates) writeGeometry(writer, {
-			type: "LineString",
-			coordinates
-		});
-	} else if (geometry.type === "MultiPolygon") {
-		writer.appendUint32(geometry.coordinates.length);
-		for (const coordinates of geometry.coordinates) writeGeometry(writer, {
-			type: "Polygon",
-			coordinates
-		});
-	} else if (geometry.type === "GeometryCollection") {
-		writer.appendUint32(geometry.geometries.length);
-		for (const child of geometry.geometries) writeGeometry(writer, child);
-	} else throw new Error("unsupported geometry type");
-}
-function writePosition(writer, position, dim) {
-	if (position.length < dim) throw new Error("geometry position dimensions mismatch");
-	for (let i = 0; i < dim; i++) writer.appendFloat64(position[i]);
-}
-function writeLine(writer, coordinates, dim) {
-	writer.appendUint32(coordinates.length);
-	for (const position of coordinates) writePosition(writer, position, dim);
-}
-function geometryTypeCode(type) {
-	if (type === "Point") return 1;
-	if (type === "LineString") return 2;
-	if (type === "Polygon") return 3;
-	if (type === "MultiPoint") return 4;
-	if (type === "MultiLineString") return 5;
-	if (type === "MultiPolygon") return 6;
-	if (type === "GeometryCollection") return 7;
-	throw new Error(`unknown geometry type: ${type}`);
-}
-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 (!Array.isArray(value)) return 2;
-	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;
-}
-const dayMillis = 864e5;
-function unconvert(element, values) {
-	const { type, converted_type: ctype, logical_type: ltype } = element;
-	if (ctype === "DECIMAL") {
-		const factor = 10 ** (element.scale || 0);
-		return values.map((v) => {
-			if (v === null || v === void 0) return v;
-			if (typeof v !== "number") throw new Error("DECIMAL must be a number");
-			return unconvertDecimal(element, BigInt(Math.round(v * factor)));
-		});
-	}
-	if (ctype === "DATE") return Array.from(values).map((v) => {
-		if (v instanceof Date) return Math.floor(v.getTime() / dayMillis);
-		return v;
-	});
-	if (ctype === "TIMESTAMP_MILLIS") return Array.from(values).map((v) => {
-		if (v === null || v === void 0) return v;
-		if (v instanceof Date) return BigInt(v.getTime());
-		return BigInt(v);
-	});
-	if (ctype === "TIMESTAMP_MICROS") return Array.from(values).map((v) => {
-		if (v === null || v === void 0) return v;
-		if (v instanceof Date) return BigInt(v.getTime() * 1e3);
-		return BigInt(v);
-	});
-	if (ctype === "JSON") {
-		if (!Array.isArray(values)) throw new Error("JSON must be an array");
-		const encoder = new TextEncoder();
-		return values.map((v) => v === void 0 ? void 0 : encoder.encode(JSON.stringify(toJson(v))));
-	}
-	if (ctype === "UTF8") {
-		if (!Array.isArray(values)) throw new Error("strings must be an array");
-		const encoder = new TextEncoder();
-		return values.map((v) => typeof v === "string" ? encoder.encode(v) : v);
-	}
-	if (ctype === "UINT_32" || ltype?.type === "INTEGER" && ltype.bitWidth === 32 && !ltype.isSigned) {
-		if (values instanceof Uint32Array) return values;
-		if (values instanceof Int32Array) return new Uint32Array(values.buffer, values.byteOffset, values.length);
-		return Array.from(values).map((v) => {
-			if (v === null || v === void 0) return v;
-			if (!Number.isSafeInteger(v)) throw new Error("expected integer value, got " + v);
-			if (v < 0 || v > 4294967295) throw new Error("expected uint32 value, got " + v);
-			if (v > 2147483647) return v - 4294967296;
-			return v;
-		});
-	}
-	if (ltype?.type === "FLOAT16") {
-		if (type !== "FIXED_LEN_BYTE_ARRAY") throw new Error("FLOAT16 must be FIXED_LEN_BYTE_ARRAY type");
-		if (element.type_length !== 2) throw new Error("FLOAT16 expected type_length to be 2 bytes");
-		return Array.from(values).map(unconvertFloat16);
-	}
-	if (ltype?.type === "UUID") {
-		if (!Array.isArray(values)) throw new Error("UUID must be an array");
-		if (type !== "FIXED_LEN_BYTE_ARRAY") throw new Error("UUID must be FIXED_LEN_BYTE_ARRAY type");
-		if (element.type_length !== 16) throw new Error("UUID expected type_length to be 16 bytes");
-		return values.map(unconvertUuid);
-	}
-	if (ltype?.type === "TIMESTAMP") return Array.from(values).map((v) => {
-		if (v === null || v === void 0) return v;
-		if (v instanceof Date) {
-			const millis = BigInt(v.getTime());
-			if (ltype.unit === "NANOS") return millis * 1000000n;
-			if (ltype.unit === "MICROS") return millis * 1000n;
-			return millis;
-		}
-		return BigInt(v);
-	});
-	if (ltype?.type === "GEOMETRY" || ltype?.type === "GEOGRAPHY") {
-		if (!Array.isArray(values)) throw new Error("geometry must be an array");
-		return values.map((v) => {
-			if (v === null || v === void 0) return v;
-			return geojsonToWkb(v);
-		});
-	}
-	return values;
-}
-function unconvertUuid(value) {
-	if (value === void 0 || value === null) return;
-	if (value instanceof Uint8Array) return value;
-	if (typeof value === "string") {
-		if (!/^[0-9a-f]{8}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{12}$/i.test(value)) throw new Error("UUID must be a valid UUID string");
-		value = value.replace(/-/g, "").toLowerCase();
-		const bytes = /* @__PURE__ */ new Uint8Array(16);
-		for (let i = 0; i < 16; i++) bytes[i] = parseInt(value.slice(i * 2, i * 2 + 2), 16);
-		return bytes;
-	}
-	throw new Error("UUID must be a string or Uint8Array");
-}
-const STATS_TRUNCATE_LENGTH = 16;
-function truncateStatistic(bytes, isMax) {
-	if (bytes.length <= STATS_TRUNCATE_LENGTH) return bytes;
-	let cut = STATS_TRUNCATE_LENGTH;
-	while (cut > 0 && (bytes[cut] & 192) === 128) cut--;
-	const prefix = bytes.slice(0, cut);
-	if (!isMax) return prefix;
-	const out = new Uint8Array(prefix.length + 4);
-	out.set(prefix, 0);
-	out.set([
-		244,
-		143,
-		191,
-		191
-	], prefix.length);
-	return out;
-}
-function minMaxIsExact(value, element) {
-	if (value === void 0 || value === null) return void 0;
-	const { type } = element;
-	if (type !== "BYTE_ARRAY" && type !== "FIXED_LEN_BYTE_ARRAY") return void 0;
-	if (element.logical_type?.type === "UUID") return void 0;
-	return (value instanceof Uint8Array ? value : new TextEncoder().encode(value.toString())).length > STATS_TRUNCATE_LENGTH ? false : void 0;
-}
-function unconvertMinMax(value, element, isMax) {
-	if (value === void 0 || value === null) return void 0;
-	const { type, converted_type } = element;
-	if (type === "BOOLEAN") return new Uint8Array([value ? 1 : 0]);
-	if (element.logical_type?.type === "UUID" && (typeof value === "string" || value instanceof Uint8Array)) return unconvertUuid(value);
-	if (converted_type === "DECIMAL") {
-		if (typeof value !== "number") throw new Error("DECIMAL must be a number");
-		const factor = 10 ** (element.scale || 0);
-		const out = unconvertDecimal(element, BigInt(Math.round(value * factor)));
-		if (out instanceof Uint8Array) return out;
-		if (typeof out === "number") {
-			const buffer = /* @__PURE__ */ new ArrayBuffer(4);
-			new DataView(buffer).setFloat32(0, out, true);
-			return new Uint8Array(buffer);
-		}
-		if (typeof out === "bigint") {
-			const buffer = /* @__PURE__ */ new ArrayBuffer(8);
-			new DataView(buffer).setBigInt64(0, out, true);
-			return new Uint8Array(buffer);
-		}
-	}
-	if (type === "BYTE_ARRAY" || type === "FIXED_LEN_BYTE_ARRAY") return truncateStatistic(value instanceof Uint8Array ? value : new TextEncoder().encode(value.toString()), isMax);
-	if (type === "FLOAT" && typeof value === "number") {
-		const buffer = /* @__PURE__ */ new ArrayBuffer(4);
-		new DataView(buffer).setFloat32(0, value, true);
-		return new Uint8Array(buffer);
-	}
-	if (type === "DOUBLE" && typeof value === "number") {
-		const buffer = /* @__PURE__ */ new ArrayBuffer(8);
-		new DataView(buffer).setFloat64(0, value, true);
-		return new Uint8Array(buffer);
-	}
-	if (type === "INT32" && typeof value === "number") {
-		const buffer = /* @__PURE__ */ new ArrayBuffer(4);
-		new DataView(buffer).setInt32(0, value, true);
-		return new Uint8Array(buffer);
-	}
-	if (type === "INT64" && typeof value === "bigint") {
-		const buffer = /* @__PURE__ */ new ArrayBuffer(8);
-		new DataView(buffer).setBigInt64(0, value, true);
-		return new Uint8Array(buffer);
-	}
-	if (type === "INT32" && converted_type === "DATE" && value instanceof Date) {
-		const buffer = /* @__PURE__ */ new ArrayBuffer(4);
-		new DataView(buffer).setInt32(0, Math.floor(value.getTime() / dayMillis), true);
-		return new Uint8Array(buffer);
-	}
-	if (type === "INT64" && converted_type === "TIMESTAMP_MILLIS" && value instanceof Date) {
-		const buffer = /* @__PURE__ */ new ArrayBuffer(8);
-		new DataView(buffer).setBigInt64(0, BigInt(value.getTime()), true);
-		return new Uint8Array(buffer);
-	}
-	if (type === "INT64" && converted_type === "TIMESTAMP_MICROS" && value instanceof Date) {
-		const buffer = /* @__PURE__ */ new ArrayBuffer(8);
-		new DataView(buffer).setBigInt64(0, BigInt(value.getTime() * 1e3), true);
-		return new Uint8Array(buffer);
-	}
-	if (type === "INT64" && element.logical_type?.type === "TIMESTAMP" && value instanceof Date) {
-		const millis = BigInt(value.getTime());
-		const { unit } = element.logical_type;
-		let bigintValue = millis;
-		if (unit === "NANOS") bigintValue = millis * 1000000n;
-		else if (unit === "MICROS") bigintValue = millis * 1000n;
-		const buffer = /* @__PURE__ */ new ArrayBuffer(8);
-		new DataView(buffer).setBigInt64(0, bigintValue, true);
-		return new Uint8Array(buffer);
-	}
-	throw new Error(`unsupported type for statistics: ${type} with value ${value}`);
-}
-function unconvertStatistics(stats, element) {
-	return {
-		field_1: unconvertMinMax(stats.max, element, true),
-		field_2: unconvertMinMax(stats.min, element, false),
-		field_3: stats.null_count,
-		field_4: stats.distinct_count,
-		field_5: unconvertMinMax(stats.max_value, element, true),
-		field_6: unconvertMinMax(stats.min_value, element, false),
-		field_7: stats.is_max_value_exact ?? minMaxIsExact(stats.max_value ?? stats.max, element),
-		field_8: stats.is_min_value_exact ?? minMaxIsExact(stats.min_value ?? stats.min, element)
-	};
-}
-function unconvertDecimal({ type, type_length }, value) {
-	if (type === "INT32") return Number(value);
-	if (type === "INT64") return value;
-	if (type === "FIXED_LEN_BYTE_ARRAY" && !type_length) throw new Error("fixed length byte array type_length is required");
-	if (!type_length && !value) return /* @__PURE__ */ new Uint8Array();
-	const bytes = [];
-	while (true) {
-		const byte = Number(value & 255n);
-		bytes.unshift(byte);
-		value >>= 8n;
-		if (type_length) {
-			if (bytes.length >= type_length) break;
-		} else {
-			const sign = byte & 128;
-			if (!sign && value === 0n || sign && value === -1n) break;
-		}
-	}
-	return new Uint8Array(bytes);
-}
-function unconvertFloat16(value) {
-	if (value === void 0 || value === null) return;
-	if (typeof value !== "number") throw new Error("parquet float16 expected number value");
-	if (Number.isNaN(value)) return new Uint8Array([0, 126]);
-	const sign = value < 0 || Object.is(value, -0) ? 1 : 0;
-	const abs = Math.abs(value);
-	if (!isFinite(abs)) return new Uint8Array([0, sign << 7 | 124]);
-	if (abs === 0) return new Uint8Array([0, sign << 7]);
-	const buf = /* @__PURE__ */ new ArrayBuffer(4);
-	new Float32Array(buf)[0] = abs;
-	const bits32 = new Uint32Array(buf)[0];
-	let exp32 = bits32 >>> 23 & 255;
-	let mant32 = bits32 & 8388607;
-	exp32 -= 127;
-	if (exp32 < -14) {
-		const shift = -14 - exp32;
-		mant32 = (mant32 | 8388608) >> shift + 13;
-		if (mant32 & 1) mant32 += 1;
-		const bits16 = sign << 15 | mant32;
-		return new Uint8Array([bits16 & 255, bits16 >> 8]);
-	}
-	if (exp32 > 15) return new Uint8Array([0, sign << 7 | 124]);
-	let exp16 = exp32 + 15;
-	mant32 = mant32 + 4096;
-	if (mant32 & 8388608) {
-		mant32 = 0;
-		if (++exp16 === 31) return new Uint8Array([0, sign << 7 | 124]);
-	}
-	const bits16 = sign << 15 | exp16 << 10 | mant32 >> 13;
-	return new Uint8Array([bits16 & 255, bits16 >> 8]);
-}
-function writeColumn({ writer, column, pageData }) {
-	const { columnName, element, schemaPath, stats, pageSize, encoding: userEncoding } = column;
-	const { type, type_length } = element;
-	if (!type) throw new Error(`column ${columnName} cannot determine type`);
-	const { values, definitionLevels, repetitionLevels, maxDefinitionLevel } = pageData;
-	const offsetStart = writer.offset;
-	const encodings = [];
-	const isGeospatial = element?.logical_type?.type === "GEOMETRY" || element?.logical_type?.type === "GEOGRAPHY";
-	const statistics = stats ? getStatistics(values) : void 0;
-	const geospatial_statistics = stats && isGeospatial ? geospatialStatistics(values) : void 0;
-	let bloomFilter;
-	if (column.bloomFilter) {
-		const builder = new BloomBuilder(element, typeof column.bloomFilter === "object" ? column.bloomFilter : void 0);
-		for (const v of values) builder.insert(v);
-		bloomFilter = builder.finalize();
-	}
-	let dictionary_page_offset;
-	const { dictionary, indexes } = useDictionary(values, type, type_length, userEncoding, pageSize);
-	let encoding;
-	let writeValues;
-	let writeType = type;
-	if (dictionary && indexes) {
-		writeValues = indexes;
-		writeType = "INT32";
-		encoding = "RLE_DICTIONARY";
-		dictionary_page_offset = BigInt(writer.offset);
-		writeDictionaryPage(writer, column, unconvert(element, dictionary));
-	} else {
-		writeValues = unconvert(element, values);
-		encoding = userEncoding ?? (type === "BOOLEAN" && values.length > 16 ? "RLE" : "PLAIN");
-	}
-	encodings.push(encoding);
-	const pageBoundaries = getPageBoundaries(writeValues, writeType, type_length, pageSize);
-	const columnIndex = column.columnIndex && pageBoundaries.length > 1 ? {
-		null_pages: [],
-		min_values: [],
-		max_values: [],
-		boundary_order: "UNORDERED",
-		null_counts: []
-	} : void 0;
-	const offsetIndex = column.offsetIndex && pageBoundaries.length > 1 ? { page_locations: [] } : void 0;
-	const data_page_offset = BigInt(writer.offset);
-	let first_row_index = 0n;
-	let prevStart = 0;
-	let prevMinValue;
-	let prevMaxValue;
-	let ascending = true;
-	let descending = true;
-	for (const { start, end } of pageBoundaries) {
-		const pageOffset = writer.offset;
-		const pageChunk = {
-			values: writeValues.slice(start, end),
-			definitionLevels: definitionLevels.slice(start, end),
-			repetitionLevels: repetitionLevels.slice(start, end),
-			maxDefinitionLevel
-		};
-		writeDataPageV2({
-			writer,
-			column,
-			encoding,
-			pageData: pageChunk
-		});
-		if (columnIndex) {
-			const { min_value, max_value, null_count = 0n } = getStatistics(values.slice(start, end));
-			columnIndex.null_pages.push(null_count === BigInt(end - start));
-			columnIndex.min_values.push(unconvertMinMax(min_value, element, false) ?? /* @__PURE__ */ new Uint8Array());
-			columnIndex.max_values.push(unconvertMinMax(max_value, element, true) ?? /* @__PURE__ */ new Uint8Array());
-			columnIndex.null_counts?.push(null_count);
-			if (prevMinValue !== void 0 && min_value !== void 0) {
-				if (prevMinValue > min_value) ascending = false;
-				if (prevMinValue < min_value) descending = false;
-			}
-			if (prevMaxValue !== void 0 && max_value !== void 0) {
-				if (prevMaxValue > max_value) ascending = false;
-				if (prevMaxValue < max_value) descending = false;
-			}
-			prevMinValue = min_value;
-			prevMaxValue = max_value;
-		}
-		if (offsetIndex) {
-			if (repetitionLevels.length) {
-				for (let i = prevStart + 1; i <= start; i++) if (repetitionLevels[i] === 0) first_row_index++;
-			} else first_row_index = BigInt(start);
-			offsetIndex.page_locations.push({
-				offset: BigInt(pageOffset),
-				compressed_page_size: writer.offset - pageOffset,
-				first_row_index
-			});
-		}
-		prevStart = start;
-	}
-	if (columnIndex) {
-		if (ascending) columnIndex.boundary_order = "ASCENDING";
-		else if (descending) columnIndex.boundary_order = "DESCENDING";
-	}
-	let encoding_stats;
-	if (stats) {
-		encoding_stats = [];
-		if (dictionary_page_offset !== void 0) encoding_stats.push({
-			page_type: "DICTIONARY_PAGE",
-			encoding: "PLAIN",
-			count: 1
-		});
-		encoding_stats.push({
-			page_type: "DATA_PAGE_V2",
-			encoding,
-			count: pageBoundaries.length
-		});
-	}
-	return {
-		chunk: {
-			meta_data: {
-				type,
-				encodings,
-				path_in_schema: schemaPath.slice(1).map((s) => s.name),
-				codec: column.codec ?? "UNCOMPRESSED",
-				num_values: BigInt(values.length),
-				total_compressed_size: BigInt(writer.offset - offsetStart),
-				total_uncompressed_size: BigInt(writer.offset - offsetStart),
-				data_page_offset,
-				dictionary_page_offset,
-				statistics,
-				encoding_stats,
-				geospatial_statistics
-			},
-			file_offset: BigInt(offsetStart)
-		},
-		columnIndex,
-		offsetIndex,
-		bloomFilter
-	};
-}
-function getPageBoundaries(values, type, type_length, pageSize) {
-	if (!pageSize) return [{
-		start: 0,
-		end: values.length
-	}];
-	const boundaries = [];
-	let start = 0;
-	let accumulatedBytes = 0;
-	for (let i = 0; i < values.length; i++) {
-		const valueSize = estimateValueSize(values[i], type, type_length);
-		accumulatedBytes += valueSize;
-		if (accumulatedBytes >= pageSize && i > start) {
-			boundaries.push({
-				start,
-				end: i
-			});
-			start = i;
-			accumulatedBytes = valueSize;
-		}
-	}
-	if (start < values.length) boundaries.push({
-		start,
-		end: values.length
-	});
-	return boundaries;
-}
-function getStatistics(values) {
-	let min_value = void 0;
-	let max_value = void 0;
-	let null_count = 0n;
-	for (const value of values) {
-		if (value === null || value === void 0) {
-			null_count++;
-			continue;
-		}
-		if (typeof value === "object") continue;
-		if (typeof value === "number" && Number.isNaN(value)) continue;
-		if (min_value === void 0 || value < min_value) min_value = value;
-		if (max_value === void 0 || value > max_value) max_value = value;
-	}
-	if (min_value === 0) min_value = -0;
-	if (max_value === 0) max_value = 0;
-	return {
-		min_value,
-		max_value,
-		null_count
-	};
-}
-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`);
-}
-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;
-}
-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: {} };
-}
-const BLOCK_SIZE = 65536;
-const MAX_HASH_TABLE_BITS = 14;
-const globalHashTables = new Array(15);
-function snappyCompress(input) {
-	const writer = new ByteWriter();
-	writer.appendVarInt(input.length);
-	let pos = 0;
-	while (pos < input.length) {
-		const fragmentSize = Math.min(input.length - pos, BLOCK_SIZE);
-		compressFragment(writer, input, pos, fragmentSize);
-		pos += fragmentSize;
-	}
-	return writer.getBytes();
-}
-function hashFunc(key, hashFuncShift) {
-	return key * 506832829 >>> hashFuncShift;
-}
-function load32(array, pos) {
-	return array[pos] + (array[pos + 1] << 8) + (array[pos + 2] << 16) + (array[pos + 3] << 24);
-}
-function equals32(array, pos1, pos2) {
-	return array[pos1] === array[pos2] && array[pos1 + 1] === array[pos2 + 1] && array[pos1 + 2] === array[pos2 + 2] && array[pos1 + 3] === array[pos2 + 3];
-}
-function emitLiteral(writer, input, ip, len) {
-	if (len <= 60) writer.appendUint8(len - 1 << 2);
-	else if (len < 256) {
-		writer.appendUint8(240);
-		writer.appendUint8(len - 1);
-	} else {
-		writer.appendUint8(244);
-		writer.appendUint8(len - 1 & 255);
-		writer.appendUint8(len - 1 >>> 8);
-	}
-	writer.appendBytes(input.subarray(ip, ip + len));
-}
-function emitCopyLessThan64(writer, offset, len) {
-	if (len < 12 && offset < 2048) {
-		writer.appendUint8(1 + (len - 4 << 2) + (offset >>> 8 << 5));
-		writer.appendUint8(offset & 255);
-	} else {
-		writer.appendUint8(2 + (len - 1 << 2));
-		writer.appendUint8(offset & 255);
-		writer.appendUint8(offset >>> 8);
-	}
-}
-function emitCopy(writer, offset, len) {
-	while (len >= 68) {
-		emitCopyLessThan64(writer, offset, 64);
-		len -= 64;
-	}
-	if (len > 64) {
-		emitCopyLessThan64(writer, offset, 60);
-		len -= 60;
-	}
-	emitCopyLessThan64(writer, offset, len);
-}
-function compressFragment(writer, input, ip, inputSize) {
-	let hashTableBits = 1;
-	while (1 << hashTableBits <= inputSize && hashTableBits <= MAX_HASH_TABLE_BITS) hashTableBits++;
-	hashTableBits--;
-	const hashFuncShift = 32 - hashTableBits;
-	globalHashTables[hashTableBits] ??= new Uint16Array(1 << hashTableBits);
-	const hashTable = globalHashTables[hashTableBits];
-	hashTable.fill(0);
-	const ipEnd = ip + inputSize;
-	let ipLimit;
-	const baseIp = ip;
-	let nextEmit = ip;
-	let hash, nextHash;
-	let nextIp, candidate, skip;
-	let bytesBetweenHashLookups;
-	let base, matched, offset;
-	let prevHash, curHash;
-	let flag = true;
-	const INPUT_MARGIN = 15;
-	if (inputSize >= INPUT_MARGIN) {
-		ipLimit = ipEnd - INPUT_MARGIN;
-		ip++;
-		nextHash = hashFunc(load32(input, ip), hashFuncShift);
-		while (flag) {
-			skip = 32;
-			nextIp = ip;
-			do {
-				ip = nextIp;
-				hash = nextHash;
-				bytesBetweenHashLookups = skip >>> 5;
-				skip++;
-				nextIp = ip + bytesBetweenHashLookups;
-				if (ip > ipLimit) {
-					flag = false;
-					break;
-				}
-				nextHash = hashFunc(load32(input, nextIp), hashFuncShift);
-				candidate = baseIp + hashTable[hash];
-				hashTable[hash] = ip - baseIp;
-			} while (!equals32(input, ip, candidate));
-			if (!flag) break;
-			emitLiteral(writer, input, nextEmit, ip - nextEmit);
-			do {
-				base = ip;
-				matched = 4;
-				while (ip + matched < ipEnd && input[ip + matched] === input[candidate + matched]) matched++;
-				ip += matched;
-				offset = base - candidate;
-				emitCopy(writer, offset, matched);
-				nextEmit = ip;
-				if (ip >= ipLimit) {
-					flag = false;
-					break;
-				}
-				prevHash = hashFunc(load32(input, ip - 1), hashFuncShift);
-				hashTable[prevHash] = ip - 1 - baseIp;
-				curHash = hashFunc(load32(input, ip), hashFuncShift);
-				candidate = baseIp + hashTable[curHash];
-				hashTable[curHash] = ip - baseIp;
-			} while (equals32(input, ip, candidate));
-			if (!flag) break;
-			ip++;
-			nextHash = hashFunc(load32(input, ip), hashFuncShift);
-		}
-	}
-	if (nextEmit < ipEnd) emitLiteral(writer, input, nextEmit, ipEnd - nextEmit);
-}
-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]);
-	}
-}
-function parquetWriteRows({ writer, rows, columns, schema, rowGroupSize = [1e3, 1e5], pageSize, ...options }) {
-	if (!Array.isArray(columns) || columns.length === 0) throw new Error("parquetWriteRows requires a non-empty columns array");
-	const isArray = Array.isArray(rows);
-	const source = rows;
-	const isAsync = !isArray && source && typeof source[Symbol.asyncIterator] === "function";
-	const isSync = !isArray && source && typeof source[Symbol.iterator] === "function";
-	if (!isArray && !isAsync && !isSync) throw new Error("parquetWriteRows expects a rows array, iterable, or async iterable");
-	if (Array.isArray(rowGroupSize) && !rowGroupSize.length) throw new Error("rowGroupSize array cannot be empty");
-	const fields = columns.map((s) => s.name);
-	let pq;
-	function* windows() {
-		if (isArray) {
-			let i = 0;
-			let g = 0;
-			while (i < rows.length) {
-				const size = Math.min(groupSize(rowGroupSize, g++), rows.length - i);
-				yield {
-					src: rows,
-					start: i,
-					size
-				};
-				i += size;
-			}
-		} else {
-			let batch = [];
-			let g = 0;
-			let target = groupSize(rowGroupSize, 0);
-			for (const row of source) {
-				batch.push(row);
-				if (batch.length >= target) {
-					yield {
-						src: batch,
-						start: 0,
-						size: batch.length
-					};
-					batch = [];
-					target = groupSize(rowGroupSize, ++g);
-				}
-			}
-			if (batch.length) yield {
-				src: batch,
-				start: 0,
-				size: batch.length
-			};
-		}
-	}
-	function writeWindow(src, start, size) {
-		const cols = transposeWindow(src, fields, start, size);
-		const columnData = columns.map((spec, c) => ({
-			...spec,
-			data: cols[c]
-		}));
-		if (!pq) pq = new ParquetWriter({
-			writer,
-			schema: schema ?? schemaFromColumnData({ columnData }),
-			...options
-		});
-		return pq.write({
-			columnData,
-			rowGroupSize: size,
-			pageSize
-		});
-	}
-	const it = windows();
-	function drain() {
-		for (let next = it.next(); !next.done; next = it.next()) {
-			const { src, start, size } = next.value;
-			const r = writeWindow(src, start, size);
-			if (r) return r.then(drain);
-		}
-	}
-	async function drainAsync() {
-		let batch = [];
-		let g = 0;
-		let target = groupSize(rowGroupSize, 0);
-		for await (const row of source) {
-			batch.push(row);
-			if (batch.length >= target) {
-				await writeWindow(batch, 0, batch.length);
-				batch = [];
-				target = groupSize(rowGroupSize, ++g);
-			}
-		}
-		if (batch.length) await writeWindow(batch, 0, batch.length);
-	}
-	function finish() {
-		if (!pq) {
-			const columnData = columns.map((spec) => ({
-				...spec,
-				data: []
-			}));
-			pq = new ParquetWriter({
-				writer,
-				schema: schema ?? schemaFromColumnData({ columnData }),
-				...options
-			});
-			const w = pq.write({
-				columnData,
-				rowGroupSize,
-				pageSize
-			});
-			if (w) return w.then(() => pq?.finish());
-		}
-		return pq?.finish();
-	}
-	if (isAsync) return drainAsync().then(finish);
-	const drained = drain();
-	return drained ? drained.then(finish) : finish();
-}
-function transposeWindow(rows, fields, start, size) {
-	const width = fields.length;
-	const cols = new Array(width);
-	for (let c = 0; c < width; c++) cols[c] = new Array(size);
-	for (let k = 0; k < size; k++) {
-		const row = rows[start + k];
-		for (let c = 0; c < width; c++) cols[c][k] = row[fields[c]];
-	}
-	return cols;
-}
-export { ByteWriter, parquetWriteRows };