@gscdump/engine 1.3.2 → 1.4.1

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

@@ -0,0 +1,247 @@
+import { toJson } from "../../../../hyparquet@1.26.1/node_modules/hyparquet/src/utils.mjs";
+import "../../../../hyparquet@1.26.1/node_modules/hyparquet/src/node.mjs";
+import { geojsonToWkb } from "./wkb.mjs";
+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]);
+}
+export { unconvert, unconvertDecimal, unconvertFloat16, unconvertMinMax, unconvertStatistics };

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

@@ -0,0 +1,321 @@
+import { ByteWriter } from "./bytewriter.mjs";
+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);
+}
+export { encodeVariantColumn, normalizeShreddingConfig };

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

@@ -0,0 +1,79 @@
+import { ByteWriter } from "./bytewriter.mjs";
+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;
+}
+export { geojsonToWkb };