@gscdump/engine 1.3.2 → 1.4.1

package/dist/node_modules/.pnpm/hyparquet@1.26.2/node_modules/hyparquet/src/thrift.mjs

@@ -0,0 +1,86 @@
+const STOP = 0;
+const TRUE = 1;
+const FALSE = 2;
+const BYTE = 3;
+const I16 = 4;
+const I32 = 5;
+const I64 = 6;
+const DOUBLE = 7;
+const BINARY = 8;
+const LIST = 9;
+const STRUCT = 12;
+function deserializeTCompactProtocol(reader) {
+	const value = {};
+	let fid = 0;
+	while (reader.offset < reader.view.byteLength) {
+		const byte = reader.view.getUint8(reader.offset++);
+		const type = byte & 15;
+		if (type === STOP) break;
+		const delta = byte >> 4;
+		fid = delta ? fid + delta : readZigZag(reader);
+		value[`field_${fid}`] = readElement(reader, type);
+	}
+	return value;
+}
+function readElement(reader, type) {
+	switch (type) {
+		case TRUE: return true;
+		case FALSE: return false;
+		case BYTE: return reader.view.getInt8(reader.offset++);
+		case I16:
+		case I32: return readZigZag(reader);
+		case I64: return readZigZagBigInt(reader);
+		case DOUBLE: {
+			const value = reader.view.getFloat64(reader.offset, true);
+			reader.offset += 8;
+			return value;
+		}
+		case BINARY: {
+			const stringLength = readVarInt(reader);
+			const strBytes = new Uint8Array(reader.view.buffer, reader.view.byteOffset + reader.offset, stringLength);
+			reader.offset += stringLength;
+			return strBytes;
+		}
+		case LIST: {
+			const byte = reader.view.getUint8(reader.offset++);
+			const elemType = byte & 15;
+			let listSize = byte >> 4;
+			if (listSize === 15) listSize = readVarInt(reader);
+			const boolType = elemType === TRUE || elemType === FALSE;
+			const values = new Array(listSize);
+			for (let i = 0; i < listSize; i++) values[i] = boolType ? readElement(reader, BYTE) === 1 : readElement(reader, elemType);
+			return values;
+		}
+		case STRUCT: return deserializeTCompactProtocol(reader);
+		default: throw new Error(`thrift unhandled type: ${type}`);
+	}
+}
+function readVarInt(reader) {
+	let result = 0;
+	let shift = 0;
+	while (true) {
+		const byte = reader.view.getUint8(reader.offset++);
+		result |= (byte & 127) << shift;
+		if (!(byte & 128)) return result;
+		shift += 7;
+	}
+}
+function readVarBigInt(reader) {
+	let result = 0n;
+	let shift = 0n;
+	while (true) {
+		const byte = reader.view.getUint8(reader.offset++);
+		result |= BigInt(byte & 127) << shift;
+		if (!(byte & 128)) return result;
+		shift += 7n;
+	}
+}
+function readZigZag(reader) {
+	const zigzag = readVarInt(reader);
+	return zigzag >>> 1 ^ -(zigzag & 1);
+}
+function readZigZagBigInt(reader) {
+	const zigzag = readVarBigInt(reader);
+	return zigzag >> 1n ^ -(zigzag & 1n);
+}
+export { deserializeTCompactProtocol, readVarInt, readZigZag, readZigZagBigInt };

package/dist/{_chunks/libs/hyparquet.d.mts → node_modules/.pnpm/hyparquet@1.26.2/node_modules/hyparquet/src/types.d.mts}

@@ -1,12 +1,12 @@
 /**
  * Parquet query options for filtering data
  */
-type ParquetQueryFilter$1 = ParquetQueryColumnsFilter | {
-  $and: ParquetQueryFilter$1[];
+type ParquetQueryFilter = ParquetQueryColumnsFilter | {
+  $and: ParquetQueryFilter[];
 } | {
-  $or: ParquetQueryFilter$1[];
+  $or: ParquetQueryFilter[];
 } | {
-  $nor: ParquetQueryFilter$1[];
+  $nor: ParquetQueryFilter[];
 };
 type ParquetQueryColumnsFilter = {
   [key: string]: ParquetQueryOperator;
@@ -26,11 +26,9 @@ type ParquetQueryOperator = {
 /**
  * File-like object that can read slices of a file asynchronously.
  */
-interface AsyncBuffer$1 {
+interface AsyncBuffer {
   byteLength: number;
   slice(start: number, end?: number): Awaitable<ArrayBuffer>;
 }
 type Awaitable<T> = T | Promise<T>;
-type AsyncBuffer = AsyncBuffer$1;
-type ParquetQueryFilter = ParquetQueryFilter$1;
-export { AsyncBuffer, ParquetQueryFilter };
+export { AsyncBuffer, Awaitable, ParquetQueryFilter, ParquetQueryOperator, ParquetQueryValue };

package/dist/node_modules/.pnpm/hyparquet@1.26.2/node_modules/hyparquet/src/utils.mjs

@@ -0,0 +1,31 @@
+import "./metadata.mjs";
+function concat(aaa, bbb) {
+	const chunk = 1e4;
+	for (let i = 0; i < bbb.length; i += chunk) aaa.push(...bbb.slice(i, i + chunk));
+}
+function equals(a, b, strict = true) {
+	if (strict ? a === b : a == b) return true;
+	if (!a || !b || typeof a !== "object" || typeof b !== "object") return false;
+	if (a instanceof Uint8Array && b instanceof Uint8Array) {
+		if (a.length !== b.length) return false;
+		for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+		return true;
+	}
+	if (Array.isArray(a) && Array.isArray(b)) {
+		if (a.length !== b.length) return false;
+		for (let i = 0; i < a.length; i++) if (!equals(a[i], b[i], strict)) return false;
+		return true;
+	}
+	const aKeys = Object.keys(a);
+	if (aKeys.length !== Object.keys(b).length) return false;
+	for (const k of aKeys) if (!equals(a[k], b[k], strict)) return false;
+	return true;
+}
+function flatten(chunks) {
+	if (!chunks) return [];
+	if (chunks.length === 1) return chunks[0];
+	const output = [];
+	for (const chunk of chunks) concat(output, chunk);
+	return output;
+}
+export { concat, equals, flatten };

package/dist/node_modules/.pnpm/hyparquet@1.26.2/node_modules/hyparquet/src/variant.mjs

@@ -0,0 +1,225 @@
+import { DEFAULT_PARSERS } from "./convert.mjs";
+const decoder = new TextDecoder();
+const metadataCache = /* @__PURE__ */ new WeakMap();
+function decodeVariantColumn(value, parsers = DEFAULT_PARSERS) {
+	if (Array.isArray(value)) return value.map((entry) => decodeVariantColumn(entry, parsers));
+	if (typeof value !== "object") return value;
+	if ("metadata" in value) {
+		const metadata = parseVariantMetadata(value.metadata);
+		const shreddedFields = value.typed_value && decodeTypedValue(value.typed_value, metadata, parsers);
+		const binaryValue = value.value && readVariant(makeReader(value.value), metadata, parsers);
+		if (shreddedFields && binaryValue) return {
+			...binaryValue,
+			...shreddedFields
+		};
+		return shreddedFields ?? binaryValue;
+	}
+	return value;
+}
+function decodeTypedValue(typedValue, metadata, parsers) {
+	if (typedValue instanceof Date) return typedValue;
+	if (typedValue && typeof typedValue === "object" && !Array.isArray(typedValue) && !(typedValue instanceof Uint8Array)) {
+		if ("typed_value" in typedValue && typedValue.typed_value !== null && typedValue.typed_value !== void 0) return decodeTypedValue(typedValue.typed_value, metadata, parsers);
+		if ("value" in typedValue && typedValue.value instanceof Uint8Array) return readVariant(makeReader(typedValue.value), metadata, parsers);
+		if ("typed_value" in typedValue || "value" in typedValue) return null;
+		const result = {};
+		for (const [key, field] of Object.entries(typedValue)) {
+			if (!metadata.dictionary.includes(key)) continue;
+			result[key] = decodeTypedValue(field, metadata, parsers);
+		}
+		return result;
+	}
+	if (typedValue instanceof Uint8Array) return readVariant(makeReader(typedValue), metadata, parsers);
+	if (Array.isArray(typedValue)) return typedValue.map((element) => decodeTypedValue(element, metadata, parsers));
+	return typedValue;
+}
+function makeReader(bytes) {
+	return {
+		view: new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength),
+		offset: 0
+	};
+}
+function parseVariantMetadata(bytes) {
+	let bufferCache = metadataCache.get(bytes.buffer);
+	if (!bufferCache) {
+		bufferCache = /* @__PURE__ */ new Map();
+		metadataCache.set(bytes.buffer, bufferCache);
+	}
+	const key = `${bytes.byteOffset}:${bytes.byteLength}`;
+	const cached = bufferCache.get(key);
+	if (cached) return cached;
+	const reader = makeReader(bytes);
+	const header = reader.view.getUint8(reader.offset++);
+	const version = header & 15;
+	if (version !== 1) throw new Error(`parquet unsupported variant metadata version: ${version}`);
+	const sorted = (header >> 4 & 1) === 1;
+	const offsetSize = (header >> 6 & 3) + 1;
+	const dictionarySize = readUnsigned(reader, offsetSize);
+	const offsets = new Array(dictionarySize + 1);
+	for (let i = 0; i < offsets.length; i++) offsets[i] = readUnsigned(reader, offsetSize);
+	const base = reader.offset;
+	const dictionary = new Array(dictionarySize);
+	for (let i = 0; i < dictionarySize; i++) {
+		const start = offsets[i];
+		const end = offsets[i + 1];
+		const strBytes = new Uint8Array(bytes.buffer, bytes.byteOffset + base + start, end - start);
+		dictionary[i] = decoder.decode(strBytes);
+	}
+	const metadata = {
+		dictionary,
+		sorted
+	};
+	bufferCache.set(key, metadata);
+	return metadata;
+}
+function readUnsigned(reader, byteWidth) {
+	let value = 0;
+	for (let i = 0; i < byteWidth; i++) value |= reader.view.getUint8(reader.offset + i) << i * 8;
+	reader.offset += byteWidth;
+	return value;
+}
+function readVariant(reader, metadata, parsers) {
+	const typeByte = reader.view.getUint8(reader.offset++);
+	const basicType = typeByte & 3;
+	const header = typeByte >> 2;
+	if (basicType === 0) return readVariantPrimitive(reader, header, parsers);
+	if (basicType === 2) return readVariantObject(reader, header, metadata, parsers);
+	if (basicType === 3) return readVariantArray(reader, header, metadata, parsers);
+	const bytes = new Uint8Array(reader.view.buffer, reader.view.byteOffset + reader.offset, header);
+	reader.offset += header;
+	return decoder.decode(bytes);
+}
+function readVariantPrimitive(reader, typeId, parsers) {
+	switch (typeId) {
+		case 0: return null;
+		case 1: return true;
+		case 2: return false;
+		case 3: {
+			const value = reader.view.getInt8(reader.offset);
+			reader.offset += 1;
+			return value;
+		}
+		case 4: {
+			const value = reader.view.getInt16(reader.offset, true);
+			reader.offset += 2;
+			return value;
+		}
+		case 5: {
+			const value = reader.view.getInt32(reader.offset, true);
+			reader.offset += 4;
+			return value;
+		}
+		case 6: {
+			const value = reader.view.getBigInt64(reader.offset, true);
+			reader.offset += 8;
+			return value;
+		}
+		case 7: {
+			const value = reader.view.getFloat64(reader.offset, true);
+			reader.offset += 8;
+			return value;
+		}
+		case 8: return readVariantDecimal(reader, 4);
+		case 9: return readVariantDecimal(reader, 8);
+		case 10: return readVariantDecimal(reader, 16);
+		case 11: {
+			const value = reader.view.getInt32(reader.offset, true);
+			reader.offset += 4;
+			return parsers.dateFromDays(value);
+		}
+		case 12:
+		case 13: {
+			const value = reader.view.getBigInt64(reader.offset, true);
+			reader.offset += 8;
+			return parsers.timestampFromMicroseconds(value);
+		}
+		case 14: {
+			const value = reader.view.getFloat32(reader.offset, true);
+			reader.offset += 4;
+			return value;
+		}
+		case 15: return readVariantBinary(reader);
+		case 16: {
+			const bytes = readVariantBinary(reader);
+			return decoder.decode(bytes);
+		}
+		case 17: {
+			const value = reader.view.getBigInt64(reader.offset, true);
+			reader.offset += 8;
+			return value;
+		}
+		case 18:
+		case 19: {
+			const value = reader.view.getBigInt64(reader.offset, true);
+			reader.offset += 8;
+			return parsers.timestampFromNanoseconds(value);
+		}
+		case 20: {
+			const bytes = new Uint8Array(reader.view.buffer, reader.view.byteOffset + reader.offset, 16);
+			reader.offset += 16;
+			const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+			return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+		}
+		default: throw new Error(`parquet unsupported variant primitive type: ${typeId}`);
+	}
+}
+function readVariantObject(reader, header, metadata, parsers) {
+	const offsetWidth = (header & 3) + 1;
+	const idWidth = (header >> 2 & 3) + 1;
+	const numElements = header >> 4 & 1 ? readUnsigned(reader, 4) : reader.view.getUint8(reader.offset++);
+	const fieldIds = new Array(numElements);
+	for (let i = 0; i < numElements; i++) fieldIds[i] = readUnsigned(reader, idWidth);
+	const offsets = new Array(numElements + 1);
+	for (let i = 0; i < offsets.length; i++) offsets[i] = readUnsigned(reader, offsetWidth);
+	const out = {};
+	for (let i = 0; i < numElements; i++) {
+		const key = metadata.dictionary[fieldIds[i]];
+		out[key] = readVariant({
+			view: reader.view,
+			offset: reader.offset + offsets[i]
+		}, metadata, parsers);
+	}
+	reader.offset += offsets[offsets.length - 1];
+	return out;
+}
+function readVariantArray(reader, header, metadata, parsers) {
+	const fieldOffsetSize = header & 3;
+	const isLarge = header >> 2 & 1;
+	const offsetWidth = fieldOffsetSize + 1;
+	const numElements = readUnsigned(reader, isLarge ? 4 : 1);
+	const offsets = new Array(numElements + 1);
+	for (let i = 0; i < offsets.length; i++) offsets[i] = readUnsigned(reader, offsetWidth);
+	const valuesStart = reader.offset;
+	const result = new Array(numElements);
+	for (let i = 0; i < numElements; i++) result[i] = readVariant({
+		view: reader.view,
+		offset: valuesStart + offsets[i]
+	}, metadata, parsers);
+	reader.offset = valuesStart + offsets[offsets.length - 1];
+	return result;
+}
+function readVariantDecimal(reader, width) {
+	const scale = reader.view.getUint8(reader.offset);
+	reader.offset += 1;
+	let unscaled;
+	if (width === 4) {
+		unscaled = BigInt(reader.view.getInt32(reader.offset, true));
+		reader.offset += 4;
+	} else if (width === 8) {
+		unscaled = reader.view.getBigInt64(reader.offset, true);
+		reader.offset += 8;
+	} else {
+		const low = reader.view.getBigUint64(reader.offset, true);
+		unscaled = reader.view.getBigInt64(reader.offset + 8, true) << 64n | low;
+		reader.offset += 16;
+	}
+	return Number(unscaled) * 10 ** -scale;
+}
+function readVariantBinary(reader) {
+	const length = reader.view.getUint32(reader.offset, true);
+	reader.offset += 4;
+	const bytes = new Uint8Array(reader.view.buffer, reader.view.byteOffset + reader.offset, length);
+	reader.offset += length;
+	return bytes;
+}
+export { decodeVariantColumn };

package/dist/node_modules/.pnpm/hyparquet@1.26.2/node_modules/hyparquet/src/wkb.mjs

@@ -0,0 +1,94 @@
+function wkbToGeojson(reader) {
+	const flags = getFlags(reader);
+	if (flags.type === 1) return {
+		type: "Point",
+		coordinates: readPosition(reader, flags)
+	};
+	else if (flags.type === 2) return {
+		type: "LineString",
+		coordinates: readLine(reader, flags)
+	};
+	else if (flags.type === 3) return {
+		type: "Polygon",
+		coordinates: readPolygon(reader, flags)
+	};
+	else if (flags.type === 4) {
+		const points = [];
+		for (let i = 0; i < flags.count; i++) points.push(readPosition(reader, getFlags(reader)));
+		return {
+			type: "MultiPoint",
+			coordinates: points
+		};
+	} else if (flags.type === 5) {
+		const lines = [];
+		for (let i = 0; i < flags.count; i++) lines.push(readLine(reader, getFlags(reader)));
+		return {
+			type: "MultiLineString",
+			coordinates: lines
+		};
+	} else if (flags.type === 6) {
+		const polygons = [];
+		for (let i = 0; i < flags.count; i++) polygons.push(readPolygon(reader, getFlags(reader)));
+		return {
+			type: "MultiPolygon",
+			coordinates: polygons
+		};
+	} else if (flags.type === 7) {
+		const geometries = [];
+		for (let i = 0; i < flags.count; i++) geometries.push(wkbToGeojson(reader));
+		return {
+			type: "GeometryCollection",
+			geometries
+		};
+	} else throw new Error(`Unsupported geometry type: ${flags.type}`);
+}
+function getFlags(reader) {
+	const { view } = reader;
+	const littleEndian = view.getUint8(reader.offset++) === 1;
+	const rawType = view.getUint32(reader.offset, littleEndian);
+	reader.offset += 4;
+	const type = rawType % 1e3;
+	const flags = Math.floor(rawType / 1e3);
+	let count = 0;
+	if (type > 1 && type <= 7) {
+		count = view.getUint32(reader.offset, littleEndian);
+		reader.offset += 4;
+	}
+	let dim = 2;
+	if (flags) dim++;
+	if (flags === 3) dim++;
+	return {
+		littleEndian,
+		type,
+		dim,
+		count
+	};
+}
+function readPosition(reader, flags) {
+	const points = [];
+	for (let i = 0; i < flags.dim; i++) {
+		const coord = reader.view.getFloat64(reader.offset, flags.littleEndian);
+		reader.offset += 8;
+		points.push(coord);
+	}
+	return points;
+}
+function readLine(reader, flags) {
+	const points = [];
+	for (let i = 0; i < flags.count; i++) points.push(readPosition(reader, flags));
+	return points;
+}
+function readPolygon(reader, flags) {
+	const { view } = reader;
+	const rings = [];
+	for (let r = 0; r < flags.count; r++) {
+		const count = view.getUint32(reader.offset, flags.littleEndian);
+		reader.offset += 4;
+		rings.push(readLine(reader, {
+			...flags,
+			count
+		}));
+	}
+	return rings;
+}
+export { wkbToGeojson };

package/dist/node_modules/.pnpm/hyparquet@1.26.2/node_modules/hyparquet/src/xxhash.mjs

@@ -0,0 +1,68 @@
+const MASK = 18446744073709551615n;
+const PRIME1 = 11400714785074694791n;
+const PRIME2 = 14029467366897019727n;
+const PRIME3 = 1609587929392839161n;
+const PRIME4 = 9650029242287828579n;
+const PRIME5 = 2870177450012600261n;
+function rotl64(x, r) {
+	return (x << r | x >> 64n - r) & MASK;
+}
+function round(acc, val) {
+	acc = acc + val * PRIME2 & MASK;
+	acc = rotl64(acc, 31n);
+	return acc * PRIME1 & MASK;
+}
+function mergeRound(acc, val) {
+	acc ^= round(0n, val);
+	return acc * PRIME1 + PRIME4 & MASK;
+}
+function xxhash64(input, seed = 0n) {
+	const view = new DataView(input.buffer, input.byteOffset, input.byteLength);
+	const len = input.byteLength;
+	let offset = 0;
+	let h64;
+	if (len >= 32) {
+		let v1 = seed + PRIME1 + PRIME2 & MASK;
+		let v2 = seed + PRIME2 & MASK;
+		let v3 = seed;
+		let v4 = seed - PRIME1 & MASK;
+		while (offset + 32 <= len) {
+			v1 = round(v1, view.getBigUint64(offset, true));
+			offset += 8;
+			v2 = round(v2, view.getBigUint64(offset, true));
+			offset += 8;
+			v3 = round(v3, view.getBigUint64(offset, true));
+			offset += 8;
+			v4 = round(v4, view.getBigUint64(offset, true));
+			offset += 8;
+		}
+		h64 = rotl64(v1, 1n) + rotl64(v2, 7n) + rotl64(v3, 12n) + rotl64(v4, 18n) & MASK;
+		h64 = mergeRound(h64, v1);
+		h64 = mergeRound(h64, v2);
+		h64 = mergeRound(h64, v3);
+		h64 = mergeRound(h64, v4);
+	} else h64 = seed + PRIME5 & MASK;
+	h64 = h64 + BigInt(len) & MASK;
+	while (offset + 8 <= len) {
+		h64 ^= round(0n, view.getBigUint64(offset, true));
+		h64 = rotl64(h64, 27n) * PRIME1 + PRIME4 & MASK;
+		offset += 8;
+	}
+	if (offset + 4 <= len) {
+		h64 ^= BigInt(view.getUint32(offset, true)) * PRIME1 & MASK;
+		h64 = rotl64(h64, 23n) * PRIME2 + PRIME3 & MASK;
+		offset += 4;
+	}
+	while (offset < len) {
+		h64 ^= BigInt(view.getUint8(offset)) * PRIME5 & MASK;
+		h64 = rotl64(h64, 11n) * PRIME1 & MASK;
+		offset += 1;
+	}
+	h64 ^= h64 >> 33n;
+	h64 = h64 * PRIME2 & MASK;
+	h64 ^= h64 >> 29n;
+	h64 = h64 * PRIME3 & MASK;
+	h64 ^= h64 >> 32n;
+	return h64;
+}
+export { xxhash64 };

package/dist/node_modules/.pnpm/hyparquet@1.26.2/node_modules/hyparquet/types/index.d.mts

@@ -0,0 +1,10 @@
+import { AsyncBuffer as AsyncBuffer$1, ParquetQueryFilter as ParquetQueryFilter$1 } from "../src/types.mjs";
+import "./query.mjs";
+import "./snappy.mjs";
+import "./indexes.mjs";
+import "./metadata.mjs";
+import "./read.mjs";
+import "./utils.mjs";
+type AsyncBuffer = AsyncBuffer$1;
+type ParquetQueryFilter = ParquetQueryFilter$1;
+export { AsyncBuffer, ParquetQueryFilter };

package/dist/node_modules/.pnpm/hyparquet@1.26.2/node_modules/hyparquet/types/indexes.d.mts

@@ -0,0 +1 @@
+import "../src/types.mjs";

package/dist/node_modules/.pnpm/hyparquet@1.26.2/node_modules/hyparquet/types/metadata.d.mts

@@ -0,0 +1 @@
+import "../src/types.mjs";

package/dist/node_modules/.pnpm/hyparquet@1.26.2/node_modules/hyparquet/types/node.d.mts

@@ -0,0 +1,3 @@
+import "../src/types.mjs";
+import { AsyncBuffer, ParquetQueryFilter } from "./index.mjs";
+export { AsyncBuffer, ParquetQueryFilter };

package/dist/node_modules/.pnpm/hyparquet@1.26.2/node_modules/hyparquet/types/query.d.mts

@@ -0,0 +1 @@
+import "../src/types.mjs";

package/dist/node_modules/.pnpm/hyparquet@1.26.2/node_modules/hyparquet/types/read.d.mts

@@ -0,0 +1 @@
+import "../src/types.mjs";

package/dist/node_modules/.pnpm/hyparquet@1.26.2/node_modules/hyparquet/types/snappy.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/node_modules/.pnpm/hyparquet@1.26.2/node_modules/hyparquet/types/utils.d.mts

@@ -0,0 +1 @@
+import "../src/types.mjs";

package/dist/node_modules/.pnpm/icebird@0.8.15_patch_hash_d1902372376af18885e7c7dce807f1ecab86c2f86a9d1ff65d51e3b63b64b057/node_modules/icebird/src/avro/avro.metadata.mjs

@@ -0,0 +1 @@
+export {};

package/dist/node_modules/.pnpm/icebird@0.8.15_patch_hash_d1902372376af18885e7c7dce807f1ecab86c2f86a9d1ff65d51e3b63b64b057/node_modules/icebird/src/avro/avro.read.mjs

@@ -0,0 +1,4 @@
+import "../../../../../hyparquet@1.26.2/node_modules/hyparquet/src/convert.mjs";
+import "../../../../../hyparquet-compressors@1.1.1/node_modules/hyparquet-compressors/src/index.mjs";
+import "./avro.metadata.mjs";
+export {};

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

@@ -0,0 +1,2 @@
+import "../../../../../hyparquet-writer@0.16.1_patch_hash_7a5e451ac7634d7546ac56bcc5eadacf7715a6241640c2b5a5bc0cfc9763b8ec/node_modules/hyparquet-writer/src/node.mjs";
+export {};

package/dist/node_modules/.pnpm/icebird@0.8.15_patch_hash_d1902372376af18885e7c7dce807f1ecab86c2f86a9d1ff65d51e3b63b64b057/node_modules/icebird/src/catalog/file.mjs

@@ -0,0 +1 @@
+export {};

package/dist/node_modules/.pnpm/icebird@0.8.15_patch_hash_d1902372376af18885e7c7dce807f1ecab86c2f86a9d1ff65d51e3b63b64b057/node_modules/icebird/src/catalog/loadTable.mjs

@@ -0,0 +1,3 @@
+import "../metadata.mjs";
+import "./rest.mjs";
+export {};

package/dist/node_modules/.pnpm/icebird@0.8.15_patch_hash_d1902372376af18885e7c7dce807f1ecab86c2f86a9d1ff65d51e3b63b64b057/node_modules/icebird/src/catalog/rest.mjs

@@ -0,0 +1,73 @@
+import { parseIcebergJson, stringifyIcebergJson } from "../json.mjs";
+async function restCatalogCreateTable(ctx, { namespace, table, schema, location, partitionSpec, writeOrder, stageCreate, properties }) {
+	const ns = encodeNamespace(namespace);
+	const body = {
+		name: table,
+		schema
+	};
+	if (location !== void 0) body.location = location;
+	if (partitionSpec !== void 0) body["partition-spec"] = partitionSpec;
+	if (writeOrder !== void 0) body["write-order"] = writeOrder;
+	if (stageCreate !== void 0) body["stage-create"] = stageCreate;
+	if (properties !== void 0) body.properties = properties;
+	const responseBody = parseIcebergJson(await (await restFetch(ctx, `namespaces/${ns}/tables`, {
+		method: "POST",
+		headers: { "content-type": "application/json" },
+		body: stringifyIcebergJson(body)
+	})).text());
+	return {
+		metadataLocation: responseBody["metadata-location"],
+		metadata: responseBody.metadata,
+		config: responseBody.config ?? {}
+	};
+}
+function encodeNamespace(namespace) {
+	return (Array.isArray(namespace) ? namespace : namespace.split(".")).map((p) => encodeURIComponent(p)).join("%1F");
+}
+async function restFetch(ctx, path, init) {
+	const prefixSegment = ctx.prefix ? `${ctx.prefix.replace(/^\/|\/$/g, "")}/` : "";
+	const fullUrl = `${ctx.url}/v1/${prefixSegment}${path}`;
+	let merged = mergeRequestInit(ctx.requestInit, init);
+	if (ctx.signRequest) merged = await ctx.signRequest(fullUrl, merged);
+	const res = await fetch(fullUrl, merged);
+	if (!res.ok) await throwRestError(res);
+	return res;
+}
+function mergeRequestInit(a, b) {
+	if (!a) return b;
+	if (!b) return a;
+	return {
+		...a,
+		...b,
+		headers: {
+			...headersToObject(a.headers),
+			...headersToObject(b.headers)
+		}
+	};
+}
+function headersToObject(h) {
+	if (!h) return {};
+	if (h instanceof Headers) {
+		const out = {};
+		h.forEach((v, k) => {
+			out[k] = v;
+		});
+		return out;
+	}
+	if (Array.isArray(h)) return Object.fromEntries(h);
+	return h;
+}
+async function throwRestError(res) {
+	let detail = "";
+	try {
+		const body = parseIcebergJson(await res.text());
+		if (body?.error) {
+			const { code, type, message } = body.error;
+			detail = `${code ?? res.status} ${type ?? ""}: ${message ?? ""}`.trim();
+		}
+	} catch {}
+	const err = new Error(detail || `${res.status} ${res.statusText}`);
+	err.status = res.status;
+	throw err;
+}
+export { restCatalogCreateTable };