@gscdump/engine 3.5.0 → 3.6.1

package/dist/node_modules/.pnpm/hyparquet@1.29.2/node_modules/hyparquet/src/plan.mjs

@@ -1,375 +1,6 @@
-import { getPhysicalColumns } from "./schema.mjs";
-import { parquetSchema } from "./metadata.mjs";
-import { readColumnIndex, readOffsetIndex } from "./indexes.mjs";
-import { bloomEligibleColumns, readBloomFilter } from "./bloom.mjs";
-import { canSkipRowGroup, filterPageRanges, pathsNeededForFilter } from "./filter.mjs";
-const runLimit = 1 << 21;
-function parquetPlan(options) {
-	const { metadata, rowStart = 0, columns, useOffsetIndex = false } = options;
-	if (!metadata) throw new Error("parquetPlan requires metadata");
-	const groups = [];
-	const fetches = [];
-	const indexes = [];
-	const scanPlan = parquetPlanGroups(options);
-	for (const group of scanPlan.groups) {
-		const groupPlan = parquetPlanGroup({
-			...group,
-			columns,
-			useOffsetIndex
-		});
-		groups.push(...groupPlan.groups);
-		fetches.push(...groupPlan.fetches);
-		indexes.push(...groupPlan.indexes);
-	}
-	fetches.push(...indexes);
-	return {
-		metadata,
-		rowStart,
-		rowEnd: scanPlan.rowEnd,
-		columns,
-		fetches,
-		groups
-	};
-}
-function parquetPlanGroups({ metadata, rowStart = 0, rowEnd = Infinity, columns, filter, filterStrict = true, bloomFiltersByGroup, schemaElements, pageRangesByGroup, pageLocationsByGroup }) {
-	if (!metadata) throw new Error("parquetPlan requires metadata");
-	const schemaTree = parquetSchema(metadata);
-	const physicalColumns = getPhysicalColumns(schemaTree);
-	const elementsByPath = filter ? {
-		...physicalSchemaElements(schemaTree),
-		...schemaElements
-	} : schemaElements;
-	const groups = [];
-	let groupStart = 0;
-	for (let groupIndex = 0; groupIndex < metadata.row_groups.length; groupIndex++) {
-		const rowGroup = metadata.row_groups[groupIndex];
-		const groupRows = Number(rowGroup.num_rows);
-		const groupEnd = groupStart + groupRows;
-		if (groupRows > 0 && groupEnd > rowStart && groupStart < rowEnd && !canSkipRowGroup({
-			rowGroup,
-			physicalColumns,
-			filter,
-			strict: filterStrict,
-			bloomFilters: bloomFiltersByGroup?.[groupIndex],
-			schemaElements: elementsByPath
-		})) {
-			const selectStart = Math.max(rowStart - groupStart, 0);
-			const selectEnd = Math.min(rowEnd - groupStart, groupRows);
-			const pageRanges = pageRangesByGroup?.[groupIndex];
-			const pageLocations = pageLocationsByGroup?.[groupIndex];
-			let ranges = pageRanges ? pageRanges.map(([start, end]) => {
-				return [Math.max(start, selectStart), Math.min(end, selectEnd)];
-			}).filter(([start, end]) => start < end) : [[selectStart, selectEnd]];
-			if (ranges.length > 1) ranges = rowGroup.columns.every((chunk) => {
-				const columnName = chunk.meta_data?.path_in_schema[0];
-				const columnPath = chunk.meta_data?.path_in_schema.join(".");
-				if (columns && columnName && !columns.includes(columnName)) return true;
-				return !!(chunk.offset_index_offset && chunk.offset_index_length) || !!(columnPath && pageLocations?.[columnPath]);
-			}) ? coalesceOverlappingPageRanges(ranges, rowGroup, columns, pageLocations) : [[ranges[0][0], ranges[ranges.length - 1][1]]];
-			if (ranges.length) groups.push({
-				rowGroup,
-				groupIndex,
-				groupStart,
-				groupRows,
-				ranges,
-				pageRanges,
-				pageLocations
-			});
-		}
-		groupStart = groupEnd;
-	}
-	return {
-		groups,
-		rowEnd: isFinite(rowEnd) ? rowEnd : groupStart
-	};
-}
-function parquetPlanGroup({ rowGroup, groupStart, groupRows, ranges, columns, useOffsetIndex = false, pageRanges, pageLocations }) {
-	const chunks = [];
-	const fetches = [];
-	const indexes = [];
-	const narrowed = ranges.length > 1 || ranges[0][0] > 0 || ranges[0][1] < groupRows;
-	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])) continue;
-		const columnOffset = meta.dictionary_page_offset || meta.data_page_offset;
-		const startByte = Number(columnOffset);
-		const endByte = Number(columnOffset + meta.total_compressed_size);
-		const chunkPageLocations = pageLocations?.[meta.path_in_schema.join(".")];
-		if (chunkPageLocations && narrowed) chunks.push({
-			columnMetadata: meta,
-			pageLocations: chunkPageLocations,
-			range: {
-				startByte,
-				endByte
-			}
-		});
-		else if ((useOffsetIndex || pageRanges) && chunk.offset_index_offset && chunk.offset_index_length && narrowed) {
-			const startByte = Number(chunk.offset_index_offset);
-			chunks.push({
-				columnMetadata: meta,
-				offsetIndex: {
-					startByte,
-					endByte: startByte + chunk.offset_index_length
-				},
-				range: {
-					startByte: Number(columnOffset),
-					endByte
-				}
-			});
-		} else chunks.push({
-			columnMetadata: meta,
-			range: {
-				startByte,
-				endByte
-			}
-		});
-	}
-	let run;
-	for (const chunk of chunks) {
-		if ("pageLocations" in chunk) continue;
-		if ("offsetIndex" in chunk) indexes.push(chunk.offsetIndex);
-		else if (columns) fetches.push(chunk.range);
-		else if (run && chunk.range.endByte - run.startByte <= runLimit) run.endByte = chunk.range.endByte;
-		else {
-			if (run) fetches.push(run);
-			run = { ...chunk.range };
-		}
-	}
-	if (run) fetches.push(run);
-	return {
-		groups: ranges.map(([selectStart, selectEnd]) => ({
-			chunks,
-			rowGroup,
-			groupStart,
-			groupRows,
-			selectStart,
-			selectEnd
-		})),
-		fetches,
-		indexes
-	};
-}
-function coalesceOverlappingPageRanges(ranges, rowGroup, columns, pageLocations) {
-	const selectedPageLayouts = rowGroup.columns.filter((chunk) => !columns || columns.includes(chunk.meta_data?.path_in_schema[0] || "")).map((chunk) => pageLocations?.[chunk.meta_data?.path_in_schema.join(".") || ""]);
-	const merged = [];
-	for (const range of ranges) {
-		const last = merged[merged.length - 1];
-		const overlapsPage = last && selectedPageLayouts.some((pages) => {
-			if (!pages) return true;
-			const lastPages = pagesForRange(last, pages, Number(rowGroup.num_rows));
-			const rangePages = pagesForRange(range, pages, Number(rowGroup.num_rows));
-			return lastPages[0] <= rangePages[1] && rangePages[0] <= lastPages[1];
-		});
-		if (last && overlapsPage) last[1] = range[1];
-		else merged.push([...range]);
-	}
-	return merged;
-}
-function pagesForRange([rangeStart, rangeEnd], pages, groupRows) {
-	let first = Infinity;
-	let last = -Infinity;
-	for (let i = 0; i < pages.length; i++) {
-		const pageStart = Number(pages[i].first_row_index);
-		if ((i + 1 < pages.length ? Number(pages[i + 1].first_row_index) : groupRows) > rangeStart && pageStart < rangeEnd) {
-			first = Math.min(first, i);
-			last = i;
-		}
-	}
-	return [first, last];
-}
-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;
-}
-async function prefetchPageIndexes({ file, metadata, filter, filterStrict = true, rowStart = 0, rowEnd = Infinity, columns, bloomFiltersByGroup, schemaElements, parsers }) {
-	const pageRangesByGroup = metadata.row_groups.map(() => void 0);
-	const pageLocationsByGroup = metadata.row_groups.map(() => ({}));
-	if (filter && "$nor" in filter && Array.isArray(filter.$nor)) return {
-		pageRangesByGroup,
-		pageLocationsByGroup
-	};
-	const filterColumns = pathsNeededForFilter(filter);
-	if (!filterColumns.length) return {
-		pageRangesByGroup,
-		pageLocationsByGroup
-	};
-	const schemaTree = parquetSchema(metadata);
-	const physicalColumns = getPhysicalColumns(schemaTree);
-	const elementsByPath = {
-		...physicalSchemaElements(schemaTree),
-		...schemaElements
-	};
-	const indexRanges = [];
-	const indexTasks = [];
-	const candidateGroups = [];
-	let groupStart = 0;
-	metadata.row_groups.forEach((rowGroup, rgIdx) => {
-		const groupRows = Number(rowGroup.num_rows);
-		const groupEnd = groupStart + groupRows;
-		const overlaps = groupRows > 0 && groupEnd > rowStart && groupStart < rowEnd;
-		groupStart = groupEnd;
-		if (!overlaps) return;
-		if (canSkipRowGroup({
-			rowGroup,
-			physicalColumns,
-			filter,
-			strict: filterStrict,
-			bloomFilters: bloomFiltersByGroup?.[rgIdx],
-			schemaElements: elementsByPath
-		})) return;
-		const columnPages = {};
-		let columnTaskCount = 0;
-		const scheduledOffsetPaths = /* @__PURE__ */ new Set();
-		let hasFilterIndex = false;
-		for (const columnName of filterColumns) {
-			const columnIdx = physicalColumns.indexOf(columnName);
-			if (columnIdx === -1) continue;
-			const chunk = rowGroup.columns[columnIdx];
-			if (!chunk?.meta_data) continue;
-			if (!chunk.column_index_offset || !chunk.column_index_length) continue;
-			if (!chunk.offset_index_offset || !chunk.offset_index_length) continue;
-			const element = elementsByPath[columnName];
-			if (!element) continue;
-			hasFilterIndex = true;
-			scheduledOffsetPaths.add(columnName);
-			const columnIndexStart = Number(chunk.column_index_offset);
-			const offsetIndexStart = Number(chunk.offset_index_offset);
-			const columnIndexEnd = columnIndexStart + chunk.column_index_length;
-			const offsetIndexEnd = offsetIndexStart + chunk.offset_index_length;
-			indexRanges.push({
-				startByte: columnIndexStart,
-				endByte: columnIndexEnd
-			}, {
-				startByte: offsetIndexStart,
-				endByte: offsetIndexEnd
-			});
-			columnTaskCount++;
-			indexTasks.push(async (prefetchedFile) => {
-				const [columnIndexBuffer, offsetIndexBuffer] = await Promise.all([prefetchedFile.slice(columnIndexStart, columnIndexEnd), prefetchedFile.slice(offsetIndexStart, offsetIndexEnd)]);
-				const columnIndex = readColumnIndex({
-					view: new DataView(columnIndexBuffer),
-					offset: 0
-				}, element, parsers);
-				const offsetIndex = readOffsetIndex({
-					view: new DataView(offsetIndexBuffer),
-					offset: 0
-				});
-				pageLocationsByGroup[rgIdx][columnName] = offsetIndex.page_locations;
-				columnPages[columnName] = {
-					minValues: columnIndex.min_values,
-					maxValues: columnIndex.max_values,
-					nullPages: columnIndex.null_pages,
-					nullCounts: columnIndex.null_counts,
-					pageStarts: offsetIndex.page_locations.map((page) => Number(page.first_row_index)),
-					element
-				};
-			});
-		}
-		if (hasFilterIndex) for (const chunk of rowGroup.columns) {
-			const meta = chunk.meta_data;
-			if (!meta) continue;
-			const columnName = meta.path_in_schema[0];
-			const columnPath = meta.path_in_schema.join(".");
-			if (columns && !columns.includes(columnName)) continue;
-			if (scheduledOffsetPaths.has(columnPath)) continue;
-			if (!chunk.offset_index_offset || !chunk.offset_index_length) continue;
-			scheduledOffsetPaths.add(columnPath);
-			const offsetIndexStart = Number(chunk.offset_index_offset);
-			const offsetIndexEnd = offsetIndexStart + chunk.offset_index_length;
-			indexRanges.push({
-				startByte: offsetIndexStart,
-				endByte: offsetIndexEnd
-			});
-			columnTaskCount++;
-			indexTasks.push(async (prefetchedFile) => {
-				const offsetIndexBuffer = await prefetchedFile.slice(offsetIndexStart, offsetIndexEnd);
-				const offsetIndex = readOffsetIndex({
-					view: new DataView(offsetIndexBuffer),
-					offset: 0
-				});
-				pageLocationsByGroup[rgIdx][columnPath] = offsetIndex.page_locations;
-			});
-		}
-		if (columnTaskCount) candidateGroups.push({
-			rgIdx,
-			groupRows,
-			columnPages
-		});
-	});
-	if (indexTasks.length) {
-		const prefetchedFile = prefetchAsyncBuffer(file, { fetches: coalesceByteRanges(indexRanges) });
-		await Promise.all(indexTasks.map((task) => task(prefetchedFile)));
-		for (const { rgIdx, groupRows, columnPages } of candidateGroups) pageRangesByGroup[rgIdx] = filterPageRanges(filter, columnPages, groupRows, filterStrict);
-	}
-	return {
-		pageRangesByGroup,
-		pageLocationsByGroup
-	};
-}
-function coalesceByteRanges(ranges) {
-	const sorted = ranges.map((range) => ({ ...range })).sort((a, b) => a.startByte - b.startByte || a.endByte - b.endByte);
-	const merged = [];
-	for (const range of sorted) {
-		const last = merged[merged.length - 1];
-		if (last && range.startByte <= last.endByte) last.endByte = Math.max(last.endByte, range.endByte);
-		else merged.push(range);
-	}
-	return merged;
-}
-function physicalSchemaElements(schemaTree) {
-	const elements = {};
-	function traverse(node) {
-		if (node.children.length) for (const child of node.children) traverse(child);
-		else elements[node.path.join(".")] = node.element;
-	}
-	traverse(schemaTree);
-	return elements;
-}
-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, parquetPlanGroup, parquetPlanGroups, prefetchAsyncBuffer, prefetchBloomFilters, prefetchPageIndexes };
+import "./schema.mjs";
+import "./bloom.mjs";
+import "./metadata.mjs";
+import "./indexes.mjs";
+import "./filter.mjs";
+export {};

package/dist/node_modules/.pnpm/hyparquet@1.29.2/node_modules/hyparquet/src/read.mjs

@@ -1,78 +1,7 @@
-import { parquetMetadataAsync, parquetSchema } from "./metadata.mjs";
-import { concat } from "./utils.mjs";
-import { columnsNeededForFilter, matchFilter } from "./filter.mjs";
+import "./metadata.mjs";
+import "./utils.mjs";
+import "./filter.mjs";
 import "./plan.mjs";
-import { assembleAsync, asyncGroupToRows } from "./rowgroup.mjs";
-import { prepareParquetRead, readParquetPlan } from "./scan.mjs";
-async function parquetRead(options) {
-	options.metadata ??= await parquetMetadataAsync(options.file, options);
-	const { rowStart = 0, rowEnd, columns, onChunk, onComplete, rowFormat, filter, filterStrict = true } = options;
-	if (filter && rowFormat !== "object") throw new Error("parquet filter requires rowFormat: \"object\"");
-	const filterColumns = columnsNeededForFilter(filter);
-	let readColumns = columns;
-	if (columns && filterColumns.length) {
-		const selectedColumns = new Set(columns);
-		const extraColumns = filterColumns.filter((column) => !selectedColumns.has(column));
-		if (extraColumns.length) readColumns = [...columns, ...extraColumns];
-	}
-	const readOptions = readColumns === columns ? options : {
-		...options,
-		columns: readColumns
-	};
-	const prepared = await prepareParquetRead(readOptions);
-	const preparedOptions = prepared.options;
-	const requiresProjection = readColumns !== columns;
-	const asyncGroups = readParquetPlan(preparedOptions, prepared.plan);
-	if (!onComplete && !onChunk) {
-		await awaitAllColumns(asyncGroups);
-		return;
-	}
-	if (!preparedOptions.metadata) throw new Error("parquet requires metadata");
-	const schemaTree = parquetSchema(preparedOptions.metadata);
-	const assembled = asyncGroups.map((arg) => assembleAsync(arg, schemaTree, options.parsers));
-	if (onChunk) for (const asyncGroup of assembled) for (const asyncColumn of asyncGroup.asyncColumns) asyncColumn.data.then(({ data, skipped }) => {
-		let rowStart = asyncGroup.groupStart + skipped;
-		for (const columnData of data) {
-			onChunk({
-				columnName: asyncColumn.pathInSchema[0],
-				columnData,
-				rowStart,
-				rowEnd: rowStart + columnData.length
-			});
-			rowStart += columnData.length;
-		}
-	}, () => {});
-	if (onComplete) {
-		await awaitAllColumns(assembled);
-		const rows = [];
-		for (const asyncGroup of assembled) {
-			const selectStart = asyncGroup.selectStart ?? Math.max(rowStart - asyncGroup.groupStart, 0);
-			const selectEnd = asyncGroup.selectEnd ?? Math.min((rowEnd ?? Infinity) - asyncGroup.groupStart, asyncGroup.groupRows);
-			const groupData = rowFormat === "object" ? await asyncGroupToRows(asyncGroup, selectStart, selectEnd, readColumns, "object") : await asyncGroupToRows(asyncGroup, selectStart, selectEnd, columns, "array");
-			if (filter) {
-				for (const row of groupData) if (matchFilter(row, filter, filterStrict)) {
-					if (requiresProjection && columns) {
-						for (const col of filterColumns) if (!columns.includes(col)) delete row[col];
-					}
-					rows.push(row);
-				}
-			} else concat(rows, groupData);
-		}
-		onComplete(rows);
-	} else await awaitAllColumns(assembled);
-}
-async function awaitAllColumns(asyncGroups) {
-	const all = asyncGroups.flatMap((g) => g.asyncColumns.map((c) => c.data));
-	const failed = (await Promise.allSettled(all)).find((r) => r.status === "rejected");
-	if (failed) throw failed.reason;
-}
-function parquetReadObjects(options) {
-	return new Promise((onComplete, reject) => {
-		parquetRead({
-			...options,
-			rowFormat: "object",
-			onComplete
-		}).catch(reject);
-	});
-}
-export { parquetRead, parquetReadObjects };
+import "./rowgroup.mjs";
+import "./scan.mjs";
+export {};

package/dist/node_modules/.pnpm/hyparquet@1.29.2/node_modules/hyparquet/src/rowgroup.mjs

@@ -1,175 +1,7 @@
-import { DEFAULT_PARSERS } from "./convert.mjs";
-import { getSchemaPath } from "./schema.mjs";
-import { readOffsetIndex } from "./indexes.mjs";
-import { flatten } from "./utils.mjs";
-import { assembleNested } from "./assemble.mjs";
-import { readColumn } from "./column.mjs";
-function readRowGroup(options, { metadata }, groupPlan) {
-	const asyncColumns = [];
-	for (const chunk of groupPlan.chunks) {
-		const { path_in_schema: pathInSchema } = chunk.columnMetadata;
-		const schemaPath = getSchemaPath(metadata.schema, pathInSchema);
-		const columnDecoder = {
-			pathInSchema,
-			element: schemaPath[schemaPath.length - 1].element,
-			schemaPath,
-			parsers: {
-				...DEFAULT_PARSERS,
-				...options.parsers
-			},
-			...options,
-			...chunk.columnMetadata
-		};
-		const { startByte, endByte } = chunk.range;
-		if ("pageLocations" in chunk) asyncColumns.push({
-			pathInSchema,
-			data: readSelectedPages(options, groupPlan, chunk, chunk.pageLocations, columnDecoder)
-		});
-		else if ("offsetIndex" in chunk) asyncColumns.push({
-			pathInSchema,
-			data: Promise.resolve(options.file.slice(chunk.offsetIndex.startByte, chunk.offsetIndex.endByte)).then((arrayBuffer) => {
-				const pages = readOffsetIndex({
-					view: new DataView(arrayBuffer),
-					offset: 0
-				}).page_locations;
-				return readSelectedPages(options, groupPlan, chunk, pages, columnDecoder);
-			})
-		});
-		else asyncColumns.push({
-			pathInSchema,
-			data: Promise.resolve(options.file.slice(startByte, endByte)).then((buffer) => {
-				const reader = {
-					view: new DataView(buffer),
-					offset: 0
-				};
-				return readColumn(reader, groupPlan, columnDecoder, options.onPage);
-			})
-		});
-	}
-	return {
-		groupStart: groupPlan.groupStart,
-		groupRows: groupPlan.groupRows,
-		selectStart: groupPlan.selectStart,
-		selectEnd: groupPlan.selectEnd,
-		asyncColumns
-	};
-}
-async function readSelectedPages(options, groupPlan, chunk, pages, columnDecoder) {
-	const { data_page_offset, dictionary_page_offset } = chunk.columnMetadata;
-	const { selectStart, selectEnd } = groupPlan;
-	let { startByte, endByte } = chunk.range;
-	let skipped = -1;
-	const hasDict = dictionary_page_offset || data_page_offset < pages[0].offset;
-	for (let i = 0; i < pages.length; i++) {
-		const page = pages[i];
-		const pageStart = Number(page.first_row_index);
-		const pageEnd = i + 1 < pages.length ? Number(pages[i + 1].first_row_index) : groupPlan.groupRows;
-		if (skipped < 0 && pageEnd > selectStart) {
-			startByte = Number(page.offset);
-			skipped = pageStart;
-		}
-		if (pageStart < selectEnd) endByte = Number(page.offset) + page.compressed_page_size;
-	}
-	if (skipped < 0) skipped = 0;
-	let view;
-	if (hasDict && skipped) {
-		const dictLength = Number(pages[0].offset) - chunk.range.startByte;
-		const [dictBuffer, dataBuffer] = await Promise.all([options.file.slice(chunk.range.startByte, Number(pages[0].offset)), options.file.slice(startByte, endByte)]);
-		const combined = new Uint8Array(dictLength + dataBuffer.byteLength);
-		combined.set(new Uint8Array(dictBuffer, 0, dictLength));
-		combined.set(new Uint8Array(dataBuffer), dictLength);
-		view = new DataView(combined.buffer);
-	} else if (hasDict) view = new DataView(await options.file.slice(chunk.range.startByte, endByte));
-	else view = new DataView(await options.file.slice(startByte, endByte));
-	const reader = {
-		view,
-		offset: 0
-	};
-	const adjustedGroupPlan = skipped ? {
-		...groupPlan,
-		groupStart: groupPlan.groupStart + skipped,
-		selectStart: groupPlan.selectStart - skipped,
-		selectEnd: groupPlan.selectEnd - skipped
-	} : groupPlan;
-	const { data, skipped: columnSkipped } = readColumn(reader, adjustedGroupPlan, columnDecoder, options.onPage);
-	return {
-		data,
-		skipped: skipped + columnSkipped
-	};
-}
-async function asyncGroupToRows({ asyncColumns }, selectStart, selectEnd, columns, rowFormat) {
-	const asyncPages = await Promise.all(asyncColumns.map((column) => column.data.then(({ skipped, data }) => ({
-		skipped,
-		data: flatten(data)
-	}))));
-	const selectCount = selectEnd - selectStart;
-	if (rowFormat === "object") {
-		const groupData = Array(selectCount);
-		for (let selectRow = 0; selectRow < selectCount; selectRow++) {
-			const rowData = {};
-			for (let i = 0; i < asyncColumns.length; i++) {
-				const { data, skipped } = asyncPages[i];
-				rowData[asyncColumns[i].pathInSchema[0]] = data[selectStart + selectRow - skipped];
-			}
-			groupData[selectRow] = rowData;
-		}
-		return groupData;
-	}
-	const includedColumnNames = asyncColumns.map((child) => child.pathInSchema[0]).filter((name) => !columns || columns.includes(name));
-	const columnOrder = columns ?? includedColumnNames;
-	const columnIndexes = columnOrder.map((name) => asyncColumns.findIndex((column) => column.pathInSchema[0] === name));
-	const groupData = Array(selectCount);
-	for (let selectRow = 0; selectRow < selectCount; selectRow++) {
-		const rowData = Array(asyncColumns.length);
-		for (let i = 0; i < columnOrder.length; i++) {
-			const colIdx = columnIndexes[i];
-			if (colIdx < 0) throw new Error(`parquet column not found: ${columnOrder[i]}`);
-			const { data, skipped } = asyncPages[colIdx];
-			rowData[i] = data[selectStart + selectRow - skipped];
-		}
-		groupData[selectRow] = rowData;
-	}
-	return groupData;
-}
-function assembleAsync(asyncRowGroup, schemaTree, parsers) {
-	const { asyncColumns } = asyncRowGroup;
-	parsers = {
-		...DEFAULT_PARSERS,
-		...parsers
-	};
-	const assembled = [];
-	for (const child of schemaTree.children) if (child.children.length) {
-		const childColumns = asyncColumns.filter((column) => column.pathInSchema[0] === child.element.name);
-		if (!childColumns.length) continue;
-		assembled.push({
-			pathInSchema: child.path,
-			data: (async () => {
-				const resolved = await Promise.all(childColumns.map((c) => c.data));
-				const subcolumnData = /* @__PURE__ */ new Map();
-				const flattened = resolved.map(({ data }) => flatten(data));
-				const skipped = Math.max(...resolved.map((result) => result.skipped));
-				const end = Math.min(...resolved.map((result, i) => result.skipped + flattened[i].length));
-				for (let i = 0; i < childColumns.length; i++) {
-					const start = skipped - resolved[i].skipped;
-					const length = Math.max(0, end - skipped);
-					subcolumnData.set(childColumns[i].pathInSchema.join("."), flattened[i].slice(start, start + length));
-				}
-				assembleNested(subcolumnData, child, parsers);
-				const assembled = subcolumnData.get(child.element.name);
-				if (!assembled) throw new Error("parquet column data not assembled");
-				return {
-					data: [assembled],
-					skipped
-				};
-			})()
-		});
-	} else {
-		const asyncColumn = asyncColumns.find((column) => column.pathInSchema[0] === child.element.name);
-		if (asyncColumn) assembled.push(asyncColumn);
-	}
-	return {
-		...asyncRowGroup,
-		asyncColumns: assembled
-	};
-}
-export { assembleAsync, asyncGroupToRows, readRowGroup };
+import "./schema.mjs";
+import "./convert.mjs";
+import "./indexes.mjs";
+import "./utils.mjs";
+import "./assemble.mjs";
+import "./column.mjs";
+export {};