@gscdump/lakehouse 2.2.0 → 3.0.0

package/dist/_virtual/node_modules/.pnpm/hyparquet-writer@0.16.1_patch_hash=7a5e451ac7634d7546ac56bcc5eadacf7715a6241640c2b5a5bc0cfc9763b8ec/node_modules/hyparquet-writer/src/delta.mjs

@@ -1,111 +0,0 @@
-const BLOCK_SIZE = 128;
-const MINIBLOCKS_PER_BLOCK = 4;
-const VALUES_PER_MINIBLOCK = BLOCK_SIZE / MINIBLOCKS_PER_BLOCK;
-function deltaBinaryPack(writer, values) {
-	const count = values.length;
-	if (count === 0) {
-		writer.appendVarInt(BLOCK_SIZE);
-		writer.appendVarInt(MINIBLOCKS_PER_BLOCK);
-		writer.appendVarInt(0);
-		writer.appendVarInt(0);
-		return;
-	}
-	if (typeof values[0] !== "number" && typeof values[0] !== "bigint") throw new Error("deltaBinaryPack only supports number or bigint arrays");
-	writer.appendVarInt(BLOCK_SIZE);
-	writer.appendVarInt(MINIBLOCKS_PER_BLOCK);
-	writer.appendVarInt(count);
-	writer.appendZigZag(values[0]);
-	let index = 1;
-	while (index < count) {
-		const blockEnd = Math.min(index + BLOCK_SIZE, count);
-		const blockSize = blockEnd - index;
-		const blockDeltas = new BigInt64Array(blockSize);
-		let minDelta = BigInt(values[index]) - BigInt(values[index - 1]);
-		blockDeltas[0] = minDelta;
-		for (let i = 1; i < blockSize; i++) {
-			const delta = BigInt(values[index + i]) - BigInt(values[index + i - 1]);
-			blockDeltas[i] = delta;
-			if (delta < minDelta) minDelta = delta;
-		}
-		writer.appendZigZag(minDelta);
-		const bitWidths = new Uint8Array(MINIBLOCKS_PER_BLOCK);
-		for (let mb = 0; mb < MINIBLOCKS_PER_BLOCK; mb++) {
-			const mbStart = mb * VALUES_PER_MINIBLOCK;
-			const mbEnd = Math.min(mbStart + VALUES_PER_MINIBLOCK, blockSize);
-			let maxAdjusted = 0n;
-			for (let i = mbStart; i < mbEnd; i++) {
-				const adjusted = blockDeltas[i] - minDelta;
-				if (adjusted > maxAdjusted) maxAdjusted = adjusted;
-			}
-			bitWidths[mb] = bitWidth(maxAdjusted);
-		}
-		writer.appendBytes(bitWidths);
-		for (let mb = 0; mb < MINIBLOCKS_PER_BLOCK; mb++) {
-			const bitWidth = bitWidths[mb];
-			if (bitWidth === 0) continue;
-			const mbStart = mb * VALUES_PER_MINIBLOCK;
-			const mbEnd = Math.min(mbStart + VALUES_PER_MINIBLOCK, blockSize);
-			let buffer = 0n;
-			let bitsUsed = 0;
-			for (let i = 0; i < VALUES_PER_MINIBLOCK; i++) {
-				const adjusted = mbStart + i < mbEnd ? blockDeltas[mbStart + i] - minDelta : 0n;
-				buffer |= adjusted << BigInt(bitsUsed);
-				bitsUsed += bitWidth;
-				while (bitsUsed >= 8) {
-					writer.appendUint8(Number(buffer & 255n));
-					buffer >>= 8n;
-					bitsUsed -= 8;
-				}
-			}
-		}
-		index = blockEnd;
-	}
-}
-function deltaLengthByteArray(writer, values) {
-	const lengths = new Int32Array(values.length);
-	for (let i = 0; i < values.length; i++) {
-		const value = values[i];
-		if (!(value instanceof Uint8Array)) throw new Error("deltaLengthByteArray expects Uint8Array values");
-		lengths[i] = value.length;
-	}
-	deltaBinaryPack(writer, lengths);
-	for (const value of values) writer.appendBytes(value);
-}
-function deltaByteArray(writer, values) {
-	if (values.length === 0) {
-		deltaBinaryPack(writer, []);
-		deltaBinaryPack(writer, []);
-		return;
-	}
-	const prefixLengths = new Int32Array(values.length);
-	const suffixLengths = new Int32Array(values.length);
-	const suffixes = new Array(values.length);
-	if (!(values[0] instanceof Uint8Array)) throw new Error("deltaByteArray expects Uint8Array values");
-	prefixLengths[0] = 0;
-	suffixLengths[0] = values[0].length;
-	suffixes[0] = values[0];
-	for (let i = 1; i < values.length; i++) {
-		const prev = values[i - 1];
-		const curr = values[i];
-		if (!(curr instanceof Uint8Array)) throw new Error("deltaByteArray expects Uint8Array values");
-		let prefixLen = 0;
-		const maxPrefix = Math.min(prev.length, curr.length);
-		while (prefixLen < maxPrefix && prev[prefixLen] === curr[prefixLen]) prefixLen++;
-		prefixLengths[i] = prefixLen;
-		suffixLengths[i] = curr.length - prefixLen;
-		suffixes[i] = curr.subarray(prefixLen);
-	}
-	deltaBinaryPack(writer, prefixLengths);
-	deltaBinaryPack(writer, suffixLengths);
-	for (const suffix of suffixes) writer.appendBytes(suffix);
-}
-function bitWidth(value) {
-	if (value === 0n) return 0;
-	let bits = 0;
-	while (value > 0n) {
-		bits++;
-		value >>= 1n;
-	}
-	return bits;
-}
-export { deltaBinaryPack, deltaByteArray, deltaLengthByteArray };

package/dist/_virtual/node_modules/.pnpm/hyparquet-writer@0.16.1_patch_hash=7a5e451ac7634d7546ac56bcc5eadacf7715a6241640c2b5a5bc0cfc9763b8ec/node_modules/hyparquet-writer/src/parquet-writer.mjs

@@ -1,139 +0,0 @@
-import { getSchemaPath } from "../../../../hyparquet@1.26.1/node_modules/hyparquet/src/schema.mjs";
-import { writeBlooms } from "./bloom.mjs";
-import { encodeVariantColumn } from "./variant.mjs";
-import { writeColumn } from "./column.mjs";
-import { encodeNestedValues } from "./dremel.mjs";
-import { writeIndexes } from "./indexes.mjs";
-import { writeMetadata } from "./metadata.mjs";
-import { snappyCompress } from "./snappy.mjs";
-function ParquetWriter({ writer, schema, codec = "SNAPPY", compressors, statistics = true, kvMetadata }) {
-	this.writer = writer;
-	this.schema = schema;
-	this.codec = codec;
-	this.compressors = {
-		SNAPPY: snappyCompress,
-		...compressors
-	};
-	this.statistics = statistics;
-	this.kvMetadata = kvMetadata;
-	this.row_groups = [];
-	this.num_rows = 0n;
-	this.pendingIndexes = [];
-	this.writer.appendUint32(827474256);
-}
-ParquetWriter.prototype.write = function({ columnData, rowGroupSize = [1e3, 1e5], pageSize = 1048576 }) {
-	const columnDataRows = columnData[0]?.data?.length || 0;
-	let pending;
-	for (const { groupStartIndex, groupSize } of groupIterator({
-		columnDataRows,
-		rowGroupSize
-	})) {
-		const writeGroup = () => {
-			const groupStartOffset = this.writer.offset;
-			const columns = [];
-			for (let j = 0; j < columnData.length; j++) {
-				const { name, data, encoding, codec = this.codec, columnIndex = false, offsetIndex = true, shredding, bloomFilter } = columnData[j];
-				if (columnIndex && !offsetIndex) throw new Error("parquet ColumnIndex cannot be present without OffsetIndex");
-				if (data.length !== columnDataRows) throw new Error("parquet columns must have the same length");
-				const groupData = data.slice(groupStartIndex, groupStartIndex + groupSize);
-				const columnPath = getSchemaPath(this.schema, [name]);
-				const leafPaths = getLeafSchemaPaths(columnPath);
-				const columnElement = columnPath.at(-1)?.element;
-				const shreddingConfig = shredding && shredding !== true ? shredding : void 0;
-				const isVariant = columnElement?.logical_type?.type === "VARIANT";
-				const isRequired = columnElement?.repetition_type === "REQUIRED";
-				const rows = isVariant ? encodeVariantColumn(Array.from(groupData), shreddingConfig, {
-					name,
-					required: isRequired
-				}) : groupData;
-				for (const leafPath of leafPaths) {
-					const schemaPath = leafPath.map((node) => node.element);
-					const column = {
-						columnName: schemaPath.slice(1).map((s) => s.name).join("."),
-						element: schemaPath[schemaPath.length - 1],
-						schemaPath,
-						codec,
-						compressors: this.compressors,
-						stats: this.statistics,
-						pageSize,
-						columnIndex,
-						offsetIndex,
-						encoding,
-						bloomFilter
-					};
-					const pageData = encodeNestedValues(leafPath, rows);
-					const result = writeColumn({
-						writer: this.writer,
-						column,
-						pageData
-					});
-					columns.push(result.chunk);
-					this.pendingIndexes.push(result);
-				}
-			}
-			this.num_rows += BigInt(groupSize);
-			this.row_groups.push({
-				columns,
-				total_byte_size: BigInt(this.writer.offset - groupStartOffset),
-				num_rows: BigInt(groupSize)
-			});
-			return this.writer.flush?.();
-		};
-		if (pending) pending = pending.then(writeGroup);
-		else {
-			const r = writeGroup();
-			if (r) pending = Promise.resolve(r);
-		}
-	}
-	return pending;
-};
-ParquetWriter.prototype.finish = function() {
-	writeIndexes(this.writer, this.pendingIndexes);
-	writeBlooms(this.writer, this.pendingIndexes);
-	const metadata = {
-		version: 2,
-		created_by: "hyparquet",
-		schema: this.schema,
-		num_rows: this.num_rows,
-		row_groups: this.row_groups,
-		metadata_length: 0,
-		key_value_metadata: this.kvMetadata
-	};
-	delete metadata.metadata_length;
-	writeMetadata(this.writer, metadata);
-	this.writer.appendUint32(827474256);
-	return this.writer.finish();
-};
-function groupSize(rowGroupSize, i) {
-	return Array.isArray(rowGroupSize) ? rowGroupSize[Math.min(i, rowGroupSize.length - 1)] : rowGroupSize;
-}
-function groupIterator({ columnDataRows, rowGroupSize }) {
-	if (Array.isArray(rowGroupSize) && !rowGroupSize.length) throw new Error("rowGroupSize array cannot be empty");
-	const groups = [];
-	let groupIndex = 0;
-	let groupStartIndex = 0;
-	while (groupStartIndex < columnDataRows) {
-		const size = groupSize(rowGroupSize, groupIndex);
-		groups.push({
-			groupStartIndex,
-			groupSize: Math.min(size, columnDataRows - groupStartIndex)
-		});
-		groupStartIndex += size;
-		groupIndex++;
-	}
-	return groups;
-}
-function getLeafSchemaPaths(schemaPath) {
-	const leaves = [];
-	dfs(schemaPath);
-	return leaves;
-	function dfs(path) {
-		const node = path[path.length - 1];
-		if (!node.children.length) {
-			leaves.push(path);
-			return;
-		}
-		for (const child of node.children) dfs([...path, child]);
-	}
-}
-export { ParquetWriter, groupSize };

package/dist/_virtual/node_modules/.pnpm/hyparquet-writer@0.16.1_patch_hash=7a5e451ac7634d7546ac56bcc5eadacf7715a6241640c2b5a5bc0cfc9763b8ec/node_modules/hyparquet-writer/types/index.d.mts

@@ -1,10 +0,0 @@
-import "../../../../hyparquet@1.26.1/node_modules/hyparquet/types/node.mjs";
-import { Writer as Writer$1 } from "../src/types.mjs";
-import "./write-rows.mjs";
-import "./bytewriter.mjs";
-import "./parquet-writer.mjs";
-import "./wkb.mjs";
-import "./write.mjs";
-import "./schema.mjs";
-type Writer = Writer$1;
-export { Writer };

package/dist/_virtual/node_modules/.pnpm/hyparquet-writer@0.16.1_patch_hash=7a5e451ac7634d7546ac56bcc5eadacf7715a6241640c2b5a5bc0cfc9763b8ec/node_modules/hyparquet-writer/types/parquet-writer.d.mts

@@ -1,2 +0,0 @@
-import "../../../../hyparquet@1.26.1/node_modules/hyparquet/types/node.mjs";
-import "../src/types.mjs";

package/dist/_virtual/node_modules/.pnpm/hyparquet-writer@0.16.1_patch_hash=7a5e451ac7634d7546ac56bcc5eadacf7715a6241640c2b5a5bc0cfc9763b8ec/node_modules/hyparquet-writer/types/schema.d.mts

@@ -1,2 +0,0 @@
-import "../../../../hyparquet@1.26.1/node_modules/hyparquet/types/node.mjs";
-import "../src/types.mjs";

package/dist/_virtual/node_modules/.pnpm/hyparquet@1.26.2/node_modules/hyparquet/src/filter.mjs

@@ -1,98 +0,0 @@
-import { hashParquetValue, sbbfContains } from "./bloom.mjs";
-import { equals } from "./utils.mjs";
-function columnsNeededForFilter(filter) {
-	if (!filter) return [];
-	const columns = [];
-	if ("$and" in filter && Array.isArray(filter.$and)) columns.push(...filter.$and.flatMap(columnsNeededForFilter));
-	else if ("$or" in filter && Array.isArray(filter.$or)) columns.push(...filter.$or.flatMap(columnsNeededForFilter));
-	else if ("$nor" in filter && Array.isArray(filter.$nor)) columns.push(...filter.$nor.flatMap(columnsNeededForFilter));
-	else columns.push(...Object.keys(filter).map((key) => key.split(".")[0]));
-	return [...new Set(columns)];
-}
-function matchFilter(record, filter, strict = true) {
-	if ("$and" in filter && Array.isArray(filter.$and)) return filter.$and.every((subQuery) => matchFilter(record, subQuery, strict));
-	if ("$or" in filter && Array.isArray(filter.$or)) return filter.$or.some((subQuery) => matchFilter(record, subQuery, strict));
-	if ("$nor" in filter && Array.isArray(filter.$nor)) return !filter.$nor.some((subQuery) => matchFilter(record, subQuery, strict));
-	return Object.entries(filter).every(([field, condition]) => {
-		const value = resolve(record, field);
-		if (typeof condition !== "object" || condition === null || Array.isArray(condition)) return equals(value, condition, strict);
-		return Object.entries(condition || {}).every(([operator, target]) => {
-			if (operator === "$gt") return value > target;
-			if (operator === "$gte") return value >= target;
-			if (operator === "$lt") return value < target;
-			if (operator === "$lte") return value <= target;
-			if (operator === "$eq") return equals(value, target, strict);
-			if (operator === "$ne") return !equals(value, target, strict);
-			if (operator === "$in") return Array.isArray(target) && target.includes(value);
-			if (operator === "$nin") return Array.isArray(target) && !target.includes(value);
-			if (operator === "$not") return !matchFilter({ [field]: value }, { [field]: target }, strict);
-			return true;
-		});
-	});
-}
-function canSkipRowGroup({ rowGroup, physicalColumns, filter, strict = true, bloomFilters, schemaElements }) {
-	if (!filter) return false;
-	if ("$and" in filter && Array.isArray(filter.$and)) return filter.$and.some((subFilter) => canSkipRowGroup({
-		rowGroup,
-		physicalColumns,
-		filter: subFilter,
-		strict,
-		bloomFilters,
-		schemaElements
-	}));
-	if ("$or" in filter && Array.isArray(filter.$or)) return filter.$or.every((subFilter) => canSkipRowGroup({
-		rowGroup,
-		physicalColumns,
-		filter: subFilter,
-		strict,
-		bloomFilters,
-		schemaElements
-	}));
-	if ("$nor" in filter && Array.isArray(filter.$nor)) return false;
-	for (const [field, condition] of Object.entries(filter)) {
-		const columnIndex = physicalColumns.indexOf(field);
-		if (columnIndex === -1) continue;
-		const { min, max, min_value, max_value } = rowGroup.columns[columnIndex].meta_data?.statistics || {};
-		const minVal = min_value !== void 0 ? min_value : min;
-		const maxVal = max_value !== void 0 ? max_value : max;
-		const haveStats = minVal !== void 0 && maxVal !== void 0;
-		const bloom = bloomFilters?.[field];
-		const element = schemaElements?.[field];
-		for (const [operator, target] of Object.entries(condition || {})) {
-			if (haveStats) {
-				if (operator === "$gt" && maxVal <= target) return true;
-				if (operator === "$gte" && maxVal < target) return true;
-				if (operator === "$lt" && minVal >= target) return true;
-				if (operator === "$lte" && minVal > target) return true;
-				if (operator === "$eq" && (target < minVal || target > maxVal)) return true;
-				if (operator === "$ne" && equals(minVal, maxVal, strict) && equals(minVal, target, strict)) return true;
-				if (operator === "$in" && Array.isArray(target) && target.every((v) => v < minVal || v > maxVal)) return true;
-				if (operator === "$nin" && Array.isArray(target) && equals(minVal, maxVal, strict) && target.includes(minVal)) return true;
-			}
-			if (bloom && element) {
-				if (operator === "$eq") {
-					const hash = hashParquetValue(target, element);
-					if (hash !== void 0 && !sbbfContains(bloom.blocks, hash)) return true;
-				}
-				if (operator === "$in" && Array.isArray(target) && target.length > 0) {
-					let allAbsent = true;
-					for (const v of target) {
-						const h = hashParquetValue(v, element);
-						if (h === void 0 || sbbfContains(bloom.blocks, h)) {
-							allAbsent = false;
-							break;
-						}
-					}
-					if (allAbsent) return true;
-				}
-			}
-		}
-	}
-	return false;
-}
-function resolve(record, path) {
-	let value = record;
-	for (const part of path.split(".")) value = value?.[part];
-	return value;
-}
-export { canSkipRowGroup, columnsNeededForFilter, matchFilter };

package/dist/_virtual/node_modules/.pnpm/hyparquet@1.26.2/node_modules/hyparquet/src/indexes.mjs

@@ -1,16 +0,0 @@
-import "./constants.mjs";
-import "./convert.mjs";
-import { deserializeTCompactProtocol } from "./thrift.mjs";
-import "./metadata.mjs";
-function readOffsetIndex(reader) {
-	const thrift = deserializeTCompactProtocol(reader);
-	return {
-		page_locations: thrift.field_1.map((loc) => ({
-			offset: loc.field_1,
-			compressed_page_size: loc.field_2,
-			first_row_index: loc.field_3
-		})),
-		unencoded_byte_array_data_bytes: thrift.field_2
-	};
-}
-export { readOffsetIndex };

package/dist/_virtual/node_modules/.pnpm/hyparquet@1.26.2/node_modules/hyparquet/src/plan.mjs

@@ -1,147 +0,0 @@
-import { getPhysicalColumns } from "./schema.mjs";
-import { parquetSchema } from "./metadata.mjs";
-import { bloomEligibleColumns, readBloomFilter } from "./bloom.mjs";
-import { canSkipRowGroup } from "./filter.mjs";
-const runLimit = 1 << 21;
-function parquetPlan({ metadata, rowStart = 0, rowEnd = Infinity, columns, filter, filterStrict = true, useOffsetIndex = false, bloomFiltersByGroup, schemaElements }) {
-	if (!metadata) throw new Error("parquetPlan requires metadata");
-	const groups = [];
-	const fetches = [];
-	const indexes = [];
-	const physicalColumns = getPhysicalColumns(parquetSchema(metadata));
-	let groupStart = 0;
-	let rgIdx = 0;
-	for (const rowGroup of metadata.row_groups) {
-		const groupRows = Number(rowGroup.num_rows);
-		const groupEnd = groupStart + groupRows;
-		const bloomFilters = bloomFiltersByGroup?.[rgIdx];
-		if (groupRows > 0 && groupEnd > rowStart && groupStart < rowEnd && !canSkipRowGroup({
-			rowGroup,
-			physicalColumns,
-			filter,
-			strict: filterStrict,
-			bloomFilters,
-			schemaElements
-		})) {
-			const chunks = [];
-			let groupStartByte = Infinity;
-			let groupEndByte = -Infinity;
-			for (const chunk of rowGroup.columns) {
-				const meta = chunk.meta_data;
-				if (chunk.file_path) throw new Error("parquet file_path not supported");
-				if (!meta) throw new Error("parquet column metadata is undefined");
-				if (!columns || columns.includes(meta.path_in_schema[0])) {
-					const columnOffset = meta.dictionary_page_offset || meta.data_page_offset;
-					const startByte = Number(columnOffset);
-					const endByte = Number(columnOffset + meta.total_compressed_size);
-					if (startByte < groupStartByte) groupStartByte = startByte;
-					if (endByte > groupEndByte) groupEndByte = endByte;
-					if (useOffsetIndex && chunk.offset_index_offset && chunk.offset_index_length && (rowStart > groupStart || rowEnd < groupEnd)) {
-						const offsetIndexStart = Number(chunk.offset_index_offset);
-						chunks.push({
-							columnMetadata: meta,
-							offsetIndex: {
-								startByte: offsetIndexStart,
-								endByte: offsetIndexStart + chunk.offset_index_length
-							},
-							range: {
-								startByte,
-								endByte
-							}
-						});
-					} else chunks.push({
-						columnMetadata: meta,
-						range: {
-							startByte,
-							endByte
-						}
-					});
-				}
-			}
-			const selectStart = Math.max(rowStart - groupStart, 0);
-			const selectEnd = Math.min(rowEnd - groupStart, groupRows);
-			groups.push({
-				chunks,
-				rowGroup,
-				groupStart,
-				groupRows,
-				selectStart,
-				selectEnd
-			});
-			let run;
-			for (const chunk of chunks) if ("offsetIndex" in chunk) indexes.push(chunk.offsetIndex);
-			else {
-				const { range } = chunk;
-				if (columns) fetches.push(range);
-				else if (run && range.endByte - run.startByte <= runLimit) run.endByte = range.endByte;
-				else {
-					if (run) fetches.push(run);
-					run = { ...range };
-				}
-			}
-			if (run) fetches.push(run);
-		}
-		groupStart = groupEnd;
-		rgIdx++;
-	}
-	if (!isFinite(rowEnd)) rowEnd = groupStart;
-	fetches.push(...indexes);
-	return {
-		metadata,
-		rowStart,
-		rowEnd,
-		columns,
-		fetches,
-		groups
-	};
-}
-async function prefetchBloomFilters({ file, metadata, filter, filterStrict = true }) {
-	const result = metadata.row_groups.map(() => ({}));
-	const eligibleCols = bloomEligibleColumns(filter);
-	if (eligibleCols.size === 0) return result;
-	const physicalColumns = getPhysicalColumns(parquetSchema(metadata));
-	const tasks = [];
-	metadata.row_groups.forEach((rowGroup, rgIdx) => {
-		if (canSkipRowGroup({
-			rowGroup,
-			physicalColumns,
-			filter,
-			strict: filterStrict
-		})) return;
-		for (const colName of eligibleCols) {
-			const columnIdx = physicalColumns.indexOf(colName);
-			if (columnIdx === -1) continue;
-			const meta = rowGroup.columns[columnIdx]?.meta_data;
-			if (!meta?.bloom_filter_offset || !meta.bloom_filter_length) continue;
-			const start = Number(meta.bloom_filter_offset);
-			const end = start + meta.bloom_filter_length;
-			tasks.push((async () => {
-				const buffer = await file.slice(start, end);
-				const bloom = readBloomFilter({
-					view: new DataView(buffer),
-					offset: 0
-				});
-				if (bloom) result[rgIdx][colName] = bloom;
-			})());
-		}
-	});
-	if (tasks.length) await Promise.all(tasks);
-	return result;
-}
-function prefetchAsyncBuffer(file, { fetches }) {
-	const promises = fetches.map(({ startByte, endByte }) => file.slice(startByte, endByte));
-	return {
-		byteLength: file.byteLength,
-		slice(start, end = file.byteLength) {
-			const index = fetches.findIndex(({ startByte, endByte }) => startByte <= start && end <= endByte);
-			if (index < 0) return file.slice(start, end);
-			if (fetches[index].startByte !== start || fetches[index].endByte !== end) {
-				const startOffset = start - fetches[index].startByte;
-				const endOffset = end - fetches[index].startByte;
-				if (promises[index] instanceof Promise) return promises[index].then((buffer) => buffer.slice(startOffset, endOffset));
-				else return promises[index].slice(startOffset, endOffset);
-			} else return promises[index];
-		}
-	};
-}
-export { parquetPlan, prefetchAsyncBuffer, prefetchBloomFilters };

package/dist/_virtual/node_modules/.pnpm/icebird@0.8.15_patch_hash=d1902372376af18885e7c7dce807f1ecab86c2f86a9d1ff65d51e3b63b64b057/node_modules/icebird/types/read.d.mts

@@ -1,2 +0,0 @@
-import "../../../../hyparquet@1.26.2/node_modules/hyparquet/types/node.mjs";
-import "../src/types.mjs";

package/dist/_virtual/node_modules/.pnpm/icebird@0.8.15_patch_hash=d1902372376af18885e7c7dce807f1ecab86c2f86a9d1ff65d51e3b63b64b057/node_modules/icebird/types/sql/icebergDataSource.d.mts

@@ -1,2 +0,0 @@
-import "../../src/types.mjs";
-import "../../../../../squirreling@0.15.0/node_modules/squirreling/src/index.mjs";

package/dist/_virtual/node_modules/.pnpm/icebird@0.8.15_patch_hash=d1902372376af18885e7c7dce807f1ecab86c2f86a9d1ff65d51e3b63b64b057/node_modules/icebird/types/sql/icebergQuery.d.mts

@@ -1,2 +0,0 @@
-import "../../src/types.mjs";
-import "../../../../../squirreling@0.15.0/node_modules/squirreling/src/index.mjs";