@gscdump/lakehouse 1.4.0 → 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,391 @@
+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;
+	}
+}
+const MAX_SHRED_DEPTH = 3;
+const MAX_SHRED_LEAVES = 256;
+function autoDetectShredding(values) {
+	const detected = detectShred(values, 0);
+	if (detected === void 0 || typeof detected !== "object") return void 0;
+	const normalized = normalizeShreddingConfig(detected);
+	if (normalized === void 0 || countShredLeaves(normalized) > MAX_SHRED_LEAVES) return void 0;
+	return normalized;
+}
+function countShredLeaves(shredType) {
+	if (Array.isArray(shredType)) return shredType.length ? countShredLeaves(shredType[0]) : 0;
+	if (shredType && typeof shredType === "object") {
+		let leaves = 0;
+		for (const key of Object.keys(shredType)) leaves += countShredLeaves(shredType[key]);
+		return leaves;
+	}
+	return 1;
+}
+function detectShred(values, depth) {
+	const nonNull = [];
+	for (const v of values) if (v !== null && v !== void 0) nonNull.push(v);
+	if (!nonNull.length) return void 0;
+	if (nonNull.some(isPlainObject)) {
+		if (depth >= MAX_SHRED_DEPTH) return void 0;
+		const fieldValues = /* @__PURE__ */ new Map();
+		for (const v of nonNull) {
+			if (!isPlainObject(v)) continue;
+			for (const [key, fieldValue] of Object.entries(v)) {
+				if (fieldValue === void 0) continue;
+				const arr = fieldValues.get(key);
+				if (arr) arr.push(fieldValue);
+				else fieldValues.set(key, [fieldValue]);
+			}
+		}
+		const shredding = {};
+		for (const [key, vals] of fieldValues) {
+			const fieldShred = detectShred(vals, depth + 1);
+			if (fieldShred !== void 0) shredding[key] = fieldShred;
+		}
+		return Object.keys(shredding).length > 0 ? shredding : void 0;
+	}
+	if (nonNull.every(Array.isArray)) {
+		if (depth >= MAX_SHRED_DEPTH) return void 0;
+		const elements = [];
+		for (const arr of nonNull) for (const el of arr) elements.push(el);
+		const elemShred = detectShred(elements, depth + 1);
+		return elemShred === void 0 ? void 0 : [elemShred];
+	}
+	let jsType;
+	for (const v of nonNull) {
+		if (Array.isArray(v)) return void 0;
+		const t = v instanceof Date ? "date" : typeof v;
+		if (jsType === void 0) jsType = t;
+		else if (jsType !== t) return void 0;
+	}
+	return jsType ? jsTypeToBasicType(jsType) : void 0;
+}
+function isPlainObject(v) {
+	return typeof v === "object" && v !== null && !Array.isArray(v) && !(v instanceof Date) && !(v instanceof Uint8Array);
+}
+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 jsTypeToBasicType(jsType) {
+	switch (jsType) {
+		case "boolean": return "BOOLEAN";
+		case "string": return "STRING";
+		case "number": return "DOUBLE";
+		case "bigint": return "INT64";
+		case "date": return "TIMESTAMP";
+		default: return;
+	}
+}
+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 { autoDetectShredding, encodeVariantColumn, normalizeShreddingConfig };