@gscdump/engine 3.5.0 → 3.6.0

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

@@ -0,0 +1,375 @@
+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 };

package/dist/node_modules/.pnpm/hyparquet@1.30.0/node_modules/hyparquet/src/query.mjs

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

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

@@ -0,0 +1,81 @@
+import { parquetMetadataAsync, parquetSchema } from "./metadata.mjs";
+import { concat } from "./utils.mjs";
+import { columnsNeededForFilter, matchFilter } from "./filter.mjs";
+import "./plan.mjs";
+import { assembleAsync, asyncGroupToRows } from "./rowgroup.mjs";
+import { prepareParquetRead, readParquetPlan } from "./scan.mjs";
+const rowIndex = Symbol("rowIndex");
+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\"");
+	if (options.includeRowIndex && rowFormat !== "object") throw new Error("parquet includeRowIndex 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 (options.includeRowIndex) for (let i = 0; i < groupData.length; i++) Object.defineProperty(groupData[i], rowIndex, { value: asyncGroup.groupStart + selectStart + i });
+			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, rowIndex };

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

@@ -0,0 +1,175 @@
+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 };