@gscdump/engine 3.5.0 → 3.6.1

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

@@ -1,74 +1,6 @@
-import { parquetMetadataAsync, parquetSchema } from "./metadata.mjs";
+import "./metadata.mjs";
 import "./utils.mjs";
-import { columnsNeededForFilter } from "./filter.mjs";
-import { parquetPlan, prefetchAsyncBuffer, prefetchBloomFilters, prefetchPageIndexes } from "./plan.mjs";
-import { readRowGroup } from "./rowgroup.mjs";
-async function prepareParquetRead(options) {
-	const prepared = await prepareParquetOptions(options);
-	return {
-		options: prepared,
-		plan: parquetPlan(prepared)
-	};
-}
-async function prepareParquetOptions(options) {
-	const metadata = options.metadata ?? await parquetMetadataAsync(options.file, options);
-	const schemaColumns = parquetSchema(metadata).children.map((child) => child.element.name);
-	const missingFilterColumns = columnsNeededForFilter(options.filter).filter((column) => !schemaColumns.includes(column));
-	if (missingFilterColumns.length) throw new Error(`parquet filter columns not found: ${missingFilterColumns.join(", ")}`);
-	if (options.columns) {
-		const missingColumns = options.columns.filter((column) => !schemaColumns.includes(column));
-		if (missingColumns.length) throw new Error(`parquet column not found: ${missingColumns[0]}`);
-	}
-	let prepared = {
-		...options,
-		metadata
-	};
-	prepared = await withBloomFilters(prepared);
-	prepared = await withPageIndexes(prepared);
-	return prepared;
-}
-function readParquetPlan(options, plan) {
-	const readOptions = {
-		...options,
-		file: prefetchAsyncBuffer(options.file, plan)
-	};
-	return plan.groups.map((group) => readRowGroup(readOptions, plan, group));
-}
-async function withBloomFilters(options) {
-	if (!options.useBloomFilters || !options.filter || !options.metadata) return options;
-	const schemaTree = parquetSchema(options.metadata);
-	const schemaElements = {};
-	for (const child of schemaTree.children) schemaElements[child.element.name] = child.element;
-	const bloomFiltersByGroup = await prefetchBloomFilters({
-		file: options.file,
-		metadata: options.metadata,
-		filter: options.filter,
-		filterStrict: options.filterStrict
-	});
-	return {
-		...options,
-		bloomFiltersByGroup,
-		schemaElements
-	};
-}
-async function withPageIndexes(options) {
-	if (!options.usePageIndex || !options.filter || !options.metadata) return options;
-	const { pageRangesByGroup, pageLocationsByGroup } = await prefetchPageIndexes({
-		file: options.file,
-		metadata: options.metadata,
-		filter: options.filter,
-		filterStrict: options.filterStrict,
-		rowStart: options.rowStart,
-		rowEnd: options.rowEnd,
-		columns: options.columns,
-		bloomFiltersByGroup: options.bloomFiltersByGroup,
-		schemaElements: options.schemaElements,
-		parsers: options.parsers
-	});
-	return {
-		...options,
-		pageRangesByGroup,
-		pageLocationsByGroup
-	};
-}
-export { prepareParquetRead, readParquetPlan };
+import "./filter.mjs";
+import "./plan.mjs";
+import "./rowgroup.mjs";
+export {};

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

@@ -26,20 +26,6 @@ function getSchemaPath(schema, name) {
 	}
 	return path;
 }
-function getPhysicalColumns(schemaTree) {
-	const columns = [];
-	function traverse(node) {
-		if (node.children.length) for (const child of node.children) traverse(child);
-		else columns.push(node.path.join("."));
-	}
-	traverse(schemaTree);
-	return columns;
-}
-function getMaxRepetitionLevel(schemaPath) {
-	let maxLevel = 0;
-	for (const { element } of schemaPath) if (element.repetition_type === "REPEATED") maxLevel++;
-	return maxLevel;
-}
 function getMaxDefinitionLevel(schemaPath) {
 	let maxLevel = 0;
 	for (const { element } of schemaPath.slice(1)) if (element.repetition_type !== "REQUIRED") maxLevel++;
@@ -65,11 +51,4 @@ function isMapLike(schema) {
 	if (firstChild.children.find((child) => child.element.name === "value")?.element.repetition_type === "REPEATED") return false;
 	return true;
 }
-function isFlatColumn(schemaPath) {
-	if (schemaPath.length !== 2) return false;
-	const [, column] = schemaPath;
-	if (column.element.repetition_type === "REPEATED") return false;
-	if (column.children.length) return false;
-	return true;
-}
-export { getMaxDefinitionLevel, getMaxRepetitionLevel, getPhysicalColumns, getSchemaPath, isFlatColumn, isListLike, isMapLike };
+export { getMaxDefinitionLevel, getSchemaPath, isListLike, isMapLike };

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

@@ -1,68 +1 @@
-const WORD_MASK = [
-	0,
-	255,
-	65535,
-	16777215,
-	4294967295
-];
-function copyBytes(fromArray, fromPos, toArray, toPos, length) {
-	for (let i = 0; i < length; i++) toArray[toPos + i] = fromArray[fromPos + i];
-}
-function snappyUncompress(input, output) {
-	const inputLength = input.byteLength;
-	const outputLength = output.byteLength;
-	let pos = 0;
-	let outPos = 0;
-	while (pos < inputLength) {
-		const c = input[pos];
-		pos++;
-		if (c < 128) break;
-	}
-	if (outputLength && pos >= inputLength) throw new Error("invalid snappy length header");
-	while (pos < inputLength) {
-		const c = input[pos];
-		let len = 0;
-		pos++;
-		if (pos >= inputLength) throw new Error("missing eof marker");
-		if ((c & 3) === 0) {
-			let len = (c >>> 2) + 1;
-			if (len > 60) {
-				if (pos + 3 >= inputLength) throw new Error("snappy error literal pos + 3 >= inputLength");
-				const lengthSize = len - 60;
-				len = input[pos] + (input[pos + 1] << 8) + (input[pos + 2] << 16) + (input[pos + 3] << 24);
-				len = (len & WORD_MASK[lengthSize]) + 1;
-				pos += lengthSize;
-			}
-			if (pos + len > inputLength) throw new Error("snappy error literal exceeds input length");
-			copyBytes(input, pos, output, outPos, len);
-			pos += len;
-			outPos += len;
-		} else {
-			let offset = 0;
-			switch (c & 3) {
-				case 1:
-					len = (c >>> 2 & 7) + 4;
-					offset = input[pos] + (c >>> 5 << 8);
-					pos++;
-					break;
-				case 2:
-					if (inputLength <= pos + 1) throw new Error("snappy error end of input");
-					len = (c >>> 2) + 1;
-					offset = input[pos] + (input[pos + 1] << 8);
-					pos += 2;
-					break;
-				case 3:
-					if (inputLength <= pos + 3) throw new Error("snappy error end of input");
-					len = (c >>> 2) + 1;
-					offset = input[pos] + (input[pos + 1] << 8) + (input[pos + 2] << 16) + (input[pos + 3] << 24);
-					pos += 4;
-			}
-			if (offset === 0 || isNaN(offset)) throw new Error(`invalid offset ${offset} pos ${pos} inputLength ${inputLength}`);
-			if (offset > outPos) throw new Error("cannot copy from before start of buffer");
-			copyBytes(output, outPos - offset, output, outPos, len);
-			outPos += len;
-		}
-	}
-	if (outPos !== outputLength) throw new Error("premature end of input");
-}
-export { snappyUncompress };
+export {};

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

@@ -1,86 +1 @@
-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 };
+export {};

package/dist/node_modules/.pnpm/hyparquet@1.29.2/node_modules/hyparquet/src/types.d.mts

@@ -1,34 +1,8 @@
-/**
- * Parquet query options for filtering data
- */
-type ParquetQueryFilter = ParquetQueryColumnsFilter | {
-  $and: ParquetQueryFilter[];
-} | {
-  $or: ParquetQueryFilter[];
-} | {
-  $nor: ParquetQueryFilter[];
-};
-type ParquetQueryColumnsFilter = {
-  [key: string]: ParquetQueryOperator;
-};
-type ParquetQueryValue = string | number | bigint | boolean | object | null | undefined;
-type ParquetQueryOperator = {
-  $gt?: ParquetQueryValue;
-  $gte?: ParquetQueryValue;
-  $lt?: ParquetQueryValue;
-  $lte?: ParquetQueryValue;
-  $eq?: ParquetQueryValue;
-  $ne?: ParquetQueryValue;
-  $in?: ParquetQueryValue[];
-  $nin?: ParquetQueryValue[];
-  $not?: ParquetQueryOperator;
-};
 /**
  * File-like object that can read slices of a file asynchronously.
  */
-interface AsyncBuffer {
+export interface AsyncBuffer {
   byteLength: number;
   slice(start: number, end?: number): Awaitable<ArrayBuffer>;
 }
-type Awaitable<T> = T | Promise<T>;
-export { AsyncBuffer, Awaitable, ParquetQueryFilter, ParquetQueryOperator, ParquetQueryValue };
+export type Awaitable<T> = T | Promise<T>;

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

@@ -16,34 +16,4 @@ function toJson(obj) {
 	}
 	return obj;
 }
-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 (a instanceof Date || b instanceof Date) return a instanceof Date && b instanceof Date && a.getTime() === b.getTime();
-	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, toJson };
+export { toJson };

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

@@ -1,228 +1,3 @@
-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++) {
-		const valueReader = {
-			view: reader.view,
-			offset: valuesStart + offsets[i]
-		};
-		result[i] = readVariant(valueReader, 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 };
+import "./convert.mjs";
+new TextDecoder();
+export {};

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

@@ -1,94 +1 @@
-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 };
+export {};