@gscdump/lakehouse 1.4.0 → 1.4.2

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

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

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

@@ -1,10 +1,9 @@
 /**
  * File-like object that can read slices of a file asynchronously.
  */
-interface AsyncBuffer$1 {
+interface AsyncBuffer {
   byteLength: number;
   slice(start: number, end?: number): Awaitable<ArrayBuffer>;
 }
 type Awaitable<T> = T | Promise<T>;
-type AsyncBuffer = AsyncBuffer$1;
-export { AsyncBuffer };
+export { AsyncBuffer, Awaitable };

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

@@ -0,0 +1,127 @@
+import { defaultInitialFetchSize } from "./metadata.mjs";
+function concat(aaa, bbb) {
+	const chunk = 1e4;
+	for (let i = 0; i < bbb.length; i += chunk) aaa.push(...bbb.slice(i, i + chunk));
+}
+function equals(a, b, strict = true) {
+	if (strict ? a === b : a == b) return true;
+	if (!a || !b || typeof a !== "object" || typeof b !== "object") return false;
+	if (a instanceof Uint8Array && b instanceof Uint8Array) {
+		if (a.length !== b.length) return false;
+		for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+		return true;
+	}
+	if (Array.isArray(a) && Array.isArray(b)) {
+		if (a.length !== b.length) return false;
+		for (let i = 0; i < a.length; i++) if (!equals(a[i], b[i], strict)) return false;
+		return true;
+	}
+	const aKeys = Object.keys(a);
+	if (aKeys.length !== Object.keys(b).length) return false;
+	for (const k of aKeys) if (!equals(a[k], b[k], strict)) return false;
+	return true;
+}
+async function byteLengthFromUrlUsingGet(url, requestInit = {}, fetchFn = globalThis.fetch) {
+	const controller = new AbortController();
+	const headers = new Headers(requestInit.headers);
+	headers.set("Range", "bytes=0-0");
+	const res = await fetchFn(url, {
+		...requestInit,
+		headers,
+		signal: controller.signal
+	});
+	if (!res.ok) throw new Error(`fetch with range failed ${res.status}`);
+	if (res.status === 206) {
+		const contentRange = res.headers.get("Content-Range");
+		if (!contentRange) throw new Error("missing content-range header");
+		const match = contentRange.match(/bytes \d+-\d+\/(\d+)/);
+		if (!match) throw new Error(`invalid content-range header: ${contentRange}`);
+		return parseInt(match[1]);
+	}
+	if (res.status === 200) {
+		const contentLength = res.headers.get("Content-Length");
+		controller.abort();
+		if (contentLength) return parseInt(contentLength);
+	}
+	throw new Error("server does not support range requests and missing content-length");
+}
+async function byteLengthFromUrl(url, requestInit, customFetch) {
+	const fetch = customFetch ?? globalThis.fetch;
+	const res = await fetch(url, {
+		...requestInit,
+		method: "HEAD"
+	});
+	if (res.status === 403) return byteLengthFromUrlUsingGet(url, requestInit, fetch);
+	if (!res.ok) throw new Error(`fetch head failed ${res.status}`);
+	const length = res.headers.get("Content-Length");
+	if (!length) return byteLengthFromUrlUsingGet(url, requestInit, fetch);
+	return parseInt(length);
+}
+async function asyncBufferFromUrl({ url, byteLength, requestInit, fetch: customFetch }) {
+	if (!url) throw new Error("missing url");
+	const fetch = customFetch ?? globalThis.fetch;
+	byteLength ??= await byteLengthFromUrl(url, requestInit, fetch);
+	let buffer = void 0;
+	const init = requestInit || {};
+	return {
+		byteLength,
+		async slice(start, end) {
+			if (buffer) return buffer.then((buffer) => buffer.slice(start, end));
+			const headers = new Headers(init.headers);
+			const endStr = end === void 0 ? "" : end - 1;
+			headers.set("Range", `bytes=${start}-${endStr}`);
+			const res = await fetch(url, {
+				...init,
+				headers
+			});
+			if (!res.ok || !res.body) throw new Error(`fetch failed ${res.status}`);
+			if (res.status === 200) {
+				buffer = res.arrayBuffer();
+				return buffer.then((buffer) => buffer.slice(start, end));
+			} else if (res.status === 206) return res.arrayBuffer();
+			else throw new Error(`fetch received unexpected status code ${res.status}`);
+		}
+	};
+}
+function cachedAsyncBuffer({ byteLength, slice }, { minSize = defaultInitialFetchSize } = {}) {
+	if (byteLength < minSize) {
+		const buffer = slice(0, byteLength);
+		return {
+			byteLength,
+			async slice(start, end) {
+				return (await buffer).slice(start, end);
+			}
+		};
+	}
+	const cache = /* @__PURE__ */ new Map();
+	return {
+		byteLength,
+		slice(start, end) {
+			const key = cacheKey(start, end, byteLength);
+			const cached = cache.get(key);
+			if (cached) return cached;
+			const promise = slice(start, end);
+			cache.set(key, promise);
+			return promise;
+		}
+	};
+}
+function cacheKey(start, end, size) {
+	if (start < 0) {
+		if (end !== void 0) throw new Error(`invalid suffix range [${start}, ${end}]`);
+		if (size === void 0) return `${start},`;
+		return `${size + start},${size}`;
+	} else if (end !== void 0) {
+		if (start > end) throw new Error(`invalid empty range [${start}, ${end}]`);
+		return `${start},${end}`;
+	} else if (size === void 0) return `${start},`;
+	else return `${start},${size}`;
+}
+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 { asyncBufferFromUrl, byteLengthFromUrl, cachedAsyncBuffer, concat, equals, flatten };

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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