@gscdump/lakehouse 1.4.0 → 1.4.1

package/dist/node_modules/.pnpm/icebird@0.8.15_patch_hash_d1902372376af18885e7c7dce807f1ecab86c2f86a9d1ff65d51e3b63b64b057/node_modules/icebird/src/write/parquet.mjs

@@ -0,0 +1,305 @@
+import { parquetWrite } from "../../../../../hyparquet-writer@0.16.1_patch_hash_7a5e451ac7634d7546ac56bcc5eadacf7715a6241640c2b5a5bc0cfc9763b8ec/node_modules/hyparquet-writer/src/write.mjs";
+import "../../../../../hyparquet-writer@0.16.1_patch_hash_7a5e451ac7634d7546ac56bcc5eadacf7715a6241640c2b5a5bc0cfc9763b8ec/node_modules/hyparquet-writer/src/node.mjs";
+import { sanitize } from "../utils.mjs";
+import { typeName } from "../schema.mjs";
+import { decimalRequiredBytes, parseDecimalType } from "./conversions.mjs";
+function writeParquet({ writer, schema, records, codec }) {
+	const columnData = [];
+	const parquetFields = [];
+	let rootChildren = 0;
+	for (const field of schema.fields) {
+		const name = sanitize(field.name);
+		const fieldElements = icebergTypeToParquetFields(name, field.type, field.required, field.id);
+		if (!fieldElements.length) continue;
+		columnData.push({
+			name,
+			data: extractColumn(records, field)
+		});
+		parquetFields.push(...fieldElements);
+		rootChildren++;
+	}
+	return parquetWrite({
+		writer,
+		columnData,
+		schema: [{
+			name: "root",
+			num_children: rootChildren
+		}, ...parquetFields],
+		kvMetadata: [{
+			key: "iceberg.schema",
+			value: JSON.stringify(schema)
+		}],
+		codec
+	});
+}
+function extractColumn(records, field) {
+	const out = new Array(records.length);
+	for (let i = 0; i < records.length; i++) out[i] = materializeFieldValue(records[i][field.name], field);
+	return out;
+}
+function materializeFieldValue(value, field) {
+	const writeDefault = field["write-default"];
+	return materializeNestedDefaults(value !== void 0 ? value : writeDefault !== void 0 ? writeDefault : null, field.type);
+}
+function materializeNestedDefaults(value, type) {
+	if (value === null || value === void 0 || typeof type !== "object") return value;
+	if (type.type === "struct") {
+		if (typeof value !== "object" || Array.isArray(value)) return value;
+		const out = { ...value };
+		for (const child of type.fields) out[child.name] = materializeFieldValue(value[child.name], child);
+		return out;
+	}
+	if (type.type === "list") {
+		if (!Array.isArray(value)) return value;
+		return value.map((v) => materializeNestedDefaults(v, type.element));
+	}
+	if (type.type === "map") return materializeMapDefaults(value, type);
+	return value;
+}
+function materializeMapDefaults(value, type) {
+	if (typeof type.key !== "object" && typeof type.value !== "object") return value;
+	if (value instanceof Map) return Array.from(value.entries(), ([key, entryValue]) => ({
+		key: materializeNestedDefaults(key, type.key),
+		value: materializeNestedDefaults(entryValue, type.value)
+	}));
+	if (Array.isArray(value)) return value.map((entry) => {
+		if (entry && typeof entry === "object" && "key" in entry && "value" in entry) return {
+			key: materializeNestedDefaults(entry.key, type.key),
+			value: materializeNestedDefaults(entry.value, type.value)
+		};
+		if (Array.isArray(entry) && entry.length === 2) return {
+			key: materializeNestedDefaults(entry[0], type.key),
+			value: materializeNestedDefaults(entry[1], type.value)
+		};
+		return entry;
+	});
+	if (typeof value === "object") return Object.fromEntries(Object.entries(value).map(([key, entryValue]) => [key, materializeNestedDefaults(entryValue, type.value)]));
+	return value;
+}
+function icebergTypeToParquetFields(name, type, required, fieldId) {
+	const repetition_type = required ? "REQUIRED" : "OPTIONAL";
+	if (typeof type === "object") {
+		if (type.type === "list") {
+			const elementFields = icebergTypeToParquetFields("element", type.element, type["element-required"], type["element-id"]);
+			if (!elementFields.length) throw new Error(`unsupported iceberg list element type: ${typeName(type.element)}`);
+			return [
+				{
+					name,
+					converted_type: "LIST",
+					logical_type: { type: "LIST" },
+					repetition_type,
+					num_children: 1,
+					field_id: fieldId
+				},
+				{
+					name: "list",
+					repetition_type: "REPEATED",
+					num_children: 1
+				},
+				...elementFields
+			];
+		}
+		if (type.type === "struct") {
+			const allChildren = [];
+			let directChildren = 0;
+			for (const child of type.fields) {
+				const sub = icebergTypeToParquetFields(child.name, child.type, child.required, child.id);
+				if (!sub.length) continue;
+				allChildren.push(...sub);
+				directChildren++;
+			}
+			if (!directChildren) throw new Error(`struct ${name} has no writable children`);
+			return [{
+				name,
+				repetition_type,
+				num_children: directChildren,
+				field_id: fieldId
+			}, ...allChildren];
+		}
+		if (type.type === "map") {
+			if (type.key !== "string" && type.key !== "int") throw new Error(`unsupported iceberg map key type: ${typeName(type.key)}`);
+			const keyFields = icebergTypeToParquetFields("key", type.key, true, type["key-id"]);
+			const valueFields = icebergTypeToParquetFields("value", type.value, type["value-required"], type["value-id"]);
+			if (!keyFields.length) throw new Error(`unsupported iceberg map key type: ${typeName(type.key)}`);
+			if (!valueFields.length) throw new Error(`unsupported iceberg map value type: ${typeName(type.value)}`);
+			return [
+				{
+					name,
+					converted_type: "MAP",
+					logical_type: { type: "MAP" },
+					repetition_type,
+					num_children: 1,
+					field_id: fieldId
+				},
+				{
+					name: "key_value",
+					repetition_type: "REPEATED",
+					num_children: 2
+				},
+				...keyFields,
+				...valueFields
+			];
+		}
+		throw new Error(`unsupported iceberg nested type: ${JSON.stringify(type)}`);
+	}
+	if (type.startsWith("geometry")) return [{
+		name,
+		type: "BYTE_ARRAY",
+		logical_type: { type: "GEOMETRY" },
+		repetition_type,
+		field_id: fieldId
+	}];
+	if (type.startsWith("geography")) return [{
+		name,
+		type: "BYTE_ARRAY",
+		logical_type: { type: "GEOGRAPHY" },
+		repetition_type,
+		field_id: fieldId
+	}];
+	const decimal = parseDecimalType(type);
+	if (decimal) {
+		const { precision, scale } = decimal;
+		return [{
+			name,
+			type: "FIXED_LEN_BYTE_ARRAY",
+			type_length: decimalRequiredBytes(precision),
+			converted_type: "DECIMAL",
+			logical_type: {
+				type: "DECIMAL",
+				precision,
+				scale
+			},
+			precision,
+			scale,
+			repetition_type,
+			field_id: fieldId
+		}];
+	}
+	const fixedLen = parseFixedType(type);
+	if (fixedLen !== void 0) return [{
+		name,
+		type: "FIXED_LEN_BYTE_ARRAY",
+		type_length: fixedLen,
+		repetition_type,
+		field_id: fieldId
+	}];
+	switch (type) {
+		case "unknown":
+			if (required) throw new Error("unsupported required iceberg type: unknown");
+			return [];
+		case "variant": return [
+			{
+				name,
+				repetition_type,
+				num_children: 2,
+				logical_type: { type: "VARIANT" },
+				field_id: fieldId
+			},
+			{
+				name: "metadata",
+				type: "BYTE_ARRAY",
+				repetition_type: "REQUIRED"
+			},
+			{
+				name: "value",
+				type: "BYTE_ARRAY",
+				repetition_type: "OPTIONAL"
+			}
+		];
+		case "boolean": return [{
+			name,
+			type: "BOOLEAN",
+			repetition_type,
+			field_id: fieldId
+		}];
+		case "int": return [{
+			name,
+			type: "INT32",
+			repetition_type,
+			field_id: fieldId
+		}];
+		case "long": return [{
+			name,
+			type: "INT64",
+			repetition_type,
+			field_id: fieldId
+		}];
+		case "float": return [{
+			name,
+			type: "FLOAT",
+			repetition_type,
+			field_id: fieldId
+		}];
+		case "double": return [{
+			name,
+			type: "DOUBLE",
+			repetition_type,
+			field_id: fieldId
+		}];
+		case "string": return [{
+			name,
+			type: "BYTE_ARRAY",
+			converted_type: "UTF8",
+			repetition_type,
+			field_id: fieldId
+		}];
+		case "binary": return [{
+			name,
+			type: "BYTE_ARRAY",
+			repetition_type,
+			field_id: fieldId
+		}];
+		case "uuid": return [{
+			name,
+			type: "FIXED_LEN_BYTE_ARRAY",
+			type_length: 16,
+			logical_type: { type: "UUID" },
+			repetition_type,
+			field_id: fieldId
+		}];
+		case "date": return [{
+			name,
+			type: "INT32",
+			converted_type: "DATE",
+			logical_type: { type: "DATE" },
+			repetition_type,
+			field_id: fieldId
+		}];
+		case "time": return [{
+			name,
+			type: "INT64",
+			converted_type: "TIME_MICROS",
+			logical_type: {
+				type: "TIME",
+				isAdjustedToUTC: false,
+				unit: "MICROS"
+			},
+			repetition_type,
+			field_id: fieldId
+		}];
+		case "timestamp": return [timestampField(name, repetition_type, false, "MICROS", fieldId)];
+		case "timestamptz": return [timestampField(name, repetition_type, true, "MICROS", fieldId)];
+		case "timestamp_ns": return [timestampField(name, repetition_type, false, "NANOS", fieldId)];
+		case "timestamptz_ns": return [timestampField(name, repetition_type, true, "NANOS", fieldId)];
+		default: throw new Error(`unsupported iceberg type: ${type}`);
+	}
+}
+function parseFixedType(type) {
+	const m = /^fixed\[(\d+)\]$/.exec(type);
+	if (!m) return void 0;
+	return parseInt(m[1], 10);
+}
+function timestampField(name, repetition_type, isAdjustedToUTC, unit, field_id) {
+	return {
+		name,
+		type: "INT64",
+		logical_type: {
+			type: "TIMESTAMP",
+			isAdjustedToUTC,
+			unit
+		},
+		repetition_type,
+		field_id
+	};
+}
+export { writeParquet };

package/dist/node_modules/.pnpm/icebird@0.8.15_patch_hash_d1902372376af18885e7c7dce807f1ecab86c2f86a9d1ff65d51e3b63b64b057/node_modules/icebird/src/write/partition.mjs

@@ -0,0 +1,178 @@
+import { bytesToHex } from "../utils.mjs";
+import { decimalRequiredBytes, decimalToFixedBytes, parseDecimalType, toUint8Array, uuidToBytes } from "./conversions.mjs";
+import { applyTransform, transformResultType } from "./transform.mjs";
+function groupByPartition(records, schema, partitionSpec) {
+	const sourceFields = partitionSpec.fields.map((pf) => {
+		const sourceId = pf["source-id"];
+		if (sourceId === void 0) throw new Error(`partition field ${pf.name} is missing source-id`);
+		const sourceField = schema.fields.find((f) => f.id === sourceId);
+		if (!sourceField) throw new Error(`partition source field id ${sourceId} not found in schema`);
+		return {
+			partitionName: pf.name,
+			sourceName: sourceField.name,
+			sourceType: sourceField.type,
+			sourceWriteDefault: sourceField["write-default"],
+			transform: pf.transform,
+			resultType: transformResultType(pf.transform, sourceField.type)
+		};
+	});
+	const groups = /* @__PURE__ */ new Map();
+	for (const record of records) {
+		const partition = {};
+		const keyParts = [];
+		for (const { partitionName, sourceName, sourceType, sourceWriteDefault, transform, resultType } of sourceFields) {
+			let v = record[sourceName];
+			if (v === void 0 && sourceWriteDefault !== void 0) v = sourceWriteDefault;
+			partition[partitionName] = applyTransform(transform, v === void 0 ? null : v, sourceType);
+			keyParts.push(partitionKeyPart(partition[partitionName], resultType));
+		}
+		const key = JSON.stringify(keyParts);
+		let group = groups.get(key);
+		if (!group) {
+			group = {
+				partition,
+				records: []
+			};
+			groups.set(key, group);
+		}
+		group.records.push(record);
+	}
+	return [...groups.values()];
+}
+function validatePartitionSpecForWrite(schema, partitionSpec, label = "partition spec") {
+	for (const pf of partitionSpec.fields) {
+		const sourceId = pf["source-id"];
+		if (sourceId === void 0) throw new Error(`${label}: partition field ${pf.name} is missing source-id`);
+		const sourceField = schema.fields.find((f) => f.id === sourceId);
+		if (!sourceField) throw new Error(`${label}: partition source field id ${sourceId} not found in schema`);
+		icebergTypeToAvro(transformResultType(pf.transform, sourceField.type), pf["field-id"]);
+	}
+}
+function partitionAvroSchema(schema, partitionSpec) {
+	return {
+		type: "record",
+		name: "r102",
+		fields: partitionSpec.fields.map((pf) => {
+			const sourceField = schema.fields.find((f) => f.id === pf["source-id"]);
+			if (!sourceField) throw new Error(`partition source field id ${pf["source-id"]} not found`);
+			const resultType = transformResultType(pf.transform, sourceField.type);
+			return {
+				name: pf.name,
+				"field-id": pf["field-id"],
+				default: null,
+				type: ["null", icebergTypeToAvro(resultType, pf["field-id"])]
+			};
+		})
+	};
+}
+function partitionSpecJson(partitionSpec) {
+	return JSON.stringify(partitionSpec.fields);
+}
+function partitionToAvroRecord(partition, schema, partitionSpec) {
+	const out = {};
+	for (const pf of partitionSpec.fields) {
+		const sourceField = schema.fields.find((f) => f.id === pf["source-id"]);
+		if (!sourceField) throw new Error(`partition source field id ${pf["source-id"]} not found`);
+		const resultType = transformResultType(pf.transform, sourceField.type);
+		const value = partition[pf.name];
+		out[pf.name] = value == null ? null : coerceForAvro(value, resultType);
+	}
+	return out;
+}
+function partitionKeyPart(value, type) {
+	if (value === null || value === void 0) return "__null__";
+	const name = typeof type === "string" ? type : type.type;
+	if (name === "uuid") return `uuid:${bytesToHex(uuidToBytes(value, "uuid partition value"))}`;
+	if (typeof value === "number" && (name === "float" || name === "double")) return `${name}:${floatPartitionKey(value, name)}`;
+	if (name === "long") return `long:${BigInt(value)}`;
+	if (typeof value === "bigint") return `b:${value.toString()}`;
+	if (value instanceof Date) return `d:${value.getTime()}`;
+	if (value instanceof Uint8Array) return `x:${bytesToHex(value)}`;
+	return `${typeof value}:${String(value)}`;
+}
+function floatPartitionKey(value, type) {
+	if (Number.isNaN(value)) return "nan";
+	const bytes = new Uint8Array(type === "float" ? 4 : 8);
+	const view = new DataView(bytes.buffer);
+	if (type === "float") view.setFloat32(0, value, false);
+	else view.setFloat64(0, value, false);
+	return bytesToHex(bytes);
+}
+function icebergTypeToAvro(type, fieldId) {
+	const name = typeof type === "string" ? type : type.type;
+	const decimal = parseDecimalType(name);
+	if (decimal) return {
+		type: "fixed",
+		name: `r102_${fieldId}`,
+		size: decimalRequiredBytes(decimal.precision),
+		logicalType: "decimal",
+		precision: decimal.precision,
+		scale: decimal.scale
+	};
+	const fixed = /^fixed\[(\d+)\]$/.exec(name);
+	if (fixed) return {
+		type: "fixed",
+		name: `r102_${fieldId}`,
+		size: parseInt(fixed[1], 10)
+	};
+	switch (name) {
+		case "boolean": return "boolean";
+		case "int": return "int";
+		case "long": return "long";
+		case "float": return "float";
+		case "double": return "double";
+		case "string": return "string";
+		case "uuid": return {
+			type: "fixed",
+			name: `r102_${fieldId}`,
+			size: 16,
+			logicalType: "uuid"
+		};
+		case "binary": return "bytes";
+		case "date": return {
+			type: "int",
+			logicalType: "date"
+		};
+		case "time": return {
+			type: "long",
+			logicalType: "time-micros"
+		};
+		case "timestamp": return {
+			type: "long",
+			logicalType: "timestamp-micros",
+			"adjust-to-utc": false
+		};
+		case "timestamptz": return {
+			type: "long",
+			logicalType: "timestamp-micros",
+			"adjust-to-utc": true
+		};
+		case "timestamp_ns": return {
+			type: "long",
+			logicalType: "timestamp-nanos",
+			"adjust-to-utc": false
+		};
+		case "timestamptz_ns": return {
+			type: "long",
+			logicalType: "timestamp-nanos",
+			"adjust-to-utc": true
+		};
+		default: throw new Error(`unsupported partition source type: ${name}`);
+	}
+}
+function coerceForAvro(value, type) {
+	const name = typeof type === "string" ? type : type.type;
+	if (name === "long") return typeof value === "bigint" ? value : BigInt(value);
+	if (name === "uuid") return uuidToBytes(value, "uuid partition value");
+	const decimal = parseDecimalType(name);
+	if (decimal) return decimalToFixedBytes(value, decimal.precision, decimal.scale, `decimal(${decimal.precision},${decimal.scale}) partition value`);
+	const fixed = /^fixed\[(\d+)\]$/.exec(name);
+	if (fixed) {
+		const bytes = toUint8Array(value);
+		const expected = parseInt(fixed[1], 10);
+		if (bytes.length !== expected) throw new Error(`expected fixed[${expected}] partition value`);
+		return bytes;
+	}
+	return value;
+}
+export { groupByPartition, partitionAvroSchema, partitionSpecJson, partitionToAvroRecord, validatePartitionSpecForWrite };

package/dist/node_modules/.pnpm/icebird@0.8.15_patch_hash_d1902372376af18885e7c7dce807f1ecab86c2f86a9d1ff65d51e3b63b64b057/node_modules/icebird/src/write/rewrite.mjs

@@ -0,0 +1,10 @@
+import "../utils.mjs";
+import "./partition.mjs";
+import "./manifest.mjs";
+import "./stats.mjs";
+import "./snapshot.mjs";
+import "./parquet.mjs";
+import "./sort.mjs";
+import "./stage.mjs";
+import "../read.mjs";
+export {};

package/dist/node_modules/.pnpm/icebird@0.8.15_patch_hash_d1902372376af18885e7c7dce807f1ecab86c2f86a9d1ff65d51e3b63b64b057/node_modules/icebird/src/write/serde.mjs

@@ -0,0 +1,148 @@
+import { typeName } from "../schema.mjs";
+function serializeValue(value, type) {
+	const name = typeName(type);
+	if (name.startsWith("decimal(")) {
+		const m = /^decimal\((\d+),\s*(\d+)\)$/.exec(name);
+		if (!m) return void 0;
+		const scale = parseInt(m[2], 10);
+		if (typeof value !== "number" && typeof value !== "bigint") return void 0;
+		const factor = 10n ** BigInt(scale);
+		return twosComplementMinBigEndian(typeof value === "bigint" ? value * factor : BigInt(Math.round(value * Number(factor))));
+	}
+	if (name.startsWith("fixed[")) return value instanceof Uint8Array ? value : void 0;
+	switch (name) {
+		case "boolean": return new Uint8Array([value ? 1 : 0]);
+		case "int": {
+			const buf = /* @__PURE__ */ new ArrayBuffer(4);
+			new DataView(buf).setInt32(0, value, true);
+			return new Uint8Array(buf);
+		}
+		case "long": {
+			const buf = /* @__PURE__ */ new ArrayBuffer(8);
+			new DataView(buf).setBigInt64(0, typeof value === "bigint" ? value : BigInt(value), true);
+			return new Uint8Array(buf);
+		}
+		case "float": {
+			const buf = /* @__PURE__ */ new ArrayBuffer(4);
+			new DataView(buf).setFloat32(0, value, true);
+			return new Uint8Array(buf);
+		}
+		case "double": {
+			const buf = /* @__PURE__ */ new ArrayBuffer(8);
+			new DataView(buf).setFloat64(0, value, true);
+			return new Uint8Array(buf);
+		}
+		case "date": {
+			const days = value instanceof Date ? Math.floor(value.getTime() / 864e5) : Number(value);
+			const buf = /* @__PURE__ */ new ArrayBuffer(4);
+			new DataView(buf).setInt32(0, days, true);
+			return new Uint8Array(buf);
+		}
+		case "time": {
+			const buf = /* @__PURE__ */ new ArrayBuffer(8);
+			new DataView(buf).setBigInt64(0, typeof value === "bigint" ? value : BigInt(value), true);
+			return new Uint8Array(buf);
+		}
+		case "timestamp":
+		case "timestamptz": {
+			const buf = /* @__PURE__ */ new ArrayBuffer(8);
+			new DataView(buf).setBigInt64(0, timestampToMicros(value), true);
+			return new Uint8Array(buf);
+		}
+		case "timestamp_ns":
+		case "timestamptz_ns": {
+			const buf = /* @__PURE__ */ new ArrayBuffer(8);
+			new DataView(buf).setBigInt64(0, timestampToNanos(value), true);
+			return new Uint8Array(buf);
+		}
+		case "string": return new TextEncoder().encode(value);
+		case "binary": return value instanceof Uint8Array ? value : void 0;
+		case "uuid":
+			if (value instanceof Uint8Array && value.length === 16) return value;
+			if (typeof value === "string") return uuidStringToBytes(value);
+			return;
+		default: return;
+	}
+}
+function compare(a, b, type) {
+	switch (typeName(type)) {
+		case "boolean": return (a ? 1 : 0) - (b ? 1 : 0);
+		case "int": return a < b ? -1 : a > b ? 1 : 0;
+		case "float":
+		case "double": return compareFloating(a, b);
+		case "long": {
+			const ai = typeof a === "bigint" ? a : BigInt(a);
+			const bi = typeof b === "bigint" ? b : BigInt(b);
+			return ai < bi ? -1 : ai > bi ? 1 : 0;
+		}
+		case "date": {
+			const ad = dateToDays(a);
+			const bd = dateToDays(b);
+			if (Number.isNaN(ad) || Number.isNaN(bd)) return NaN;
+			return ad < bd ? -1 : ad > bd ? 1 : 0;
+		}
+		case "timestamp":
+		case "timestamptz": return compareBigInt(timestampToMicros(a), timestampToMicros(b));
+		case "timestamp_ns":
+		case "timestamptz_ns": return compareBigInt(timestampToNanos(a), timestampToNanos(b));
+		case "string": return a < b ? -1 : a > b ? 1 : 0;
+		case "binary":
+		case "uuid": return compareBytes(a, b);
+		default:
+			if (typeName(type).startsWith("fixed[")) return compareBytes(a, b);
+			return a < b ? -1 : a > b ? 1 : 0;
+	}
+}
+function compareFloating(a, b) {
+	if (Object.is(a, b)) return 0;
+	if (a === 0 && b === 0) return Object.is(a, -0) ? -1 : 1;
+	return a < b ? -1 : a > b ? 1 : 0;
+}
+function compareBigInt(a, b) {
+	return a < b ? -1 : a > b ? 1 : 0;
+}
+function dateToDays(value) {
+	if (value instanceof Date) return Math.floor(value.getTime() / 864e5);
+	if (typeof value === "bigint") return Number(value);
+	if (typeof value === "number") return value;
+	if (typeof value === "string") {
+		const ms = Date.parse(value);
+		return Number.isNaN(ms) ? NaN : Math.floor(ms / 864e5);
+	}
+	return NaN;
+}
+function timestampToMicros(value) {
+	return typeof value === "bigint" ? value : value instanceof Date ? BigInt(value.getTime()) * 1000n : BigInt(value);
+}
+function timestampToNanos(value) {
+	return typeof value === "bigint" ? value : value instanceof Date ? BigInt(value.getTime()) * 1000000n : BigInt(value);
+}
+function compareBytes(a, b) {
+	const len = Math.min(a.length, b.length);
+	for (let i = 0; i < len; i++) if (a[i] !== b[i]) return a[i] - b[i];
+	return a.length - b.length;
+}
+function twosComplementMinBigEndian(value) {
+	const bytes = [];
+	let v = value;
+	while (true) {
+		const byte = Number(v & 255n);
+		bytes.unshift(byte);
+		v >>= 8n;
+		const sign = byte & 128;
+		if (!sign && v === 0n || sign && v === -1n) break;
+	}
+	return new Uint8Array(bytes);
+}
+function uuidStringToBytes(s) {
+	const hex = s.replace(/-/g, "");
+	if (hex.length !== 32) return void 0;
+	const out = /* @__PURE__ */ new Uint8Array(16);
+	for (let i = 0; i < 16; i++) {
+		const byte = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+		if (Number.isNaN(byte)) return void 0;
+		out[i] = byte;
+	}
+	return out;
+}
+export { compare, compareBigInt, compareBytes, compareFloating, dateToDays, serializeValue, timestampToMicros, timestampToNanos, twosComplementMinBigEndian, uuidStringToBytes };