@loaders.gl/parquet 4.5.3 → 5.0.0-alpha.10

package/src/parquetjs/schema/variant.ts

@@ -0,0 +1,313 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {decodeUtf8, toUint8Array} from '../utils/binary-utils';
+
+const MAXIMUM_VARIANT_NESTING = 1024;
+
+/** Decodes the binary metadata/value pair used by the Parquet VARIANT type. */
+export function decodeVariant(
+  metadataInput: ArrayBuffer | ArrayBufferView,
+  valueInput: ArrayBuffer | ArrayBufferView
+): unknown {
+  const metadata = toUint8Array(metadataInput);
+  const value = toUint8Array(valueInput);
+  const dictionary = decodeVariantMetadata(metadata);
+  const decoded = decodeVariantValue(value, 0, value.length, dictionary, 0);
+  if (decoded.nextOffset !== value.length) {
+    throw new Error(
+      `parquet: trailing bytes in VARIANT value (${value.length - decoded.nextOffset})`
+    );
+  }
+  return decoded.value;
+}
+
+interface VariantMetadata {
+  /** Dictionary strings used by object field IDs. */
+  dictionary: string[];
+}
+
+interface DecodedVariantValue {
+  /** Decoded JavaScript value. */
+  value: unknown;
+  /** Offset immediately following the encoded value. */
+  nextOffset: number;
+}
+
+/** Parses the versioned dictionary at the start of every Variant value. */
+function decodeVariantMetadata(bytes: Uint8Array): VariantMetadata {
+  if (bytes.length < 2) {
+    throw new Error('parquet: VARIANT metadata is truncated');
+  }
+  const header = bytes[0];
+  const version = header & 0xf;
+  if (version !== 1) {
+    throw new Error(`parquet: unsupported VARIANT metadata version ${version}`);
+  }
+  const offsetSize = ((header >> 6) & 0x3) + 1;
+  const dictionarySize = readUnsigned(bytes, 1, offsetSize);
+  const offsetsStart = 1 + offsetSize;
+  const offsetsEnd = offsetsStart + (dictionarySize + 1) * offsetSize;
+  if (offsetsEnd > bytes.length) {
+    throw new Error('parquet: VARIANT metadata offsets are truncated');
+  }
+  const dictionaryBytes = bytes.subarray(offsetsEnd);
+  const dictionary: string[] = [];
+  let previousOffset = 0;
+  for (let index = 0; index < dictionarySize + 1; index++) {
+    const offset = readUnsigned(bytes, offsetsStart + index * offsetSize, offsetSize);
+    if (offset < previousOffset || offset > dictionaryBytes.length) {
+      throw new Error('parquet: invalid VARIANT metadata dictionary offset');
+    }
+    if (index < dictionarySize) {
+      dictionary.push(
+        decodeUtf8(
+          dictionaryBytes.subarray(
+            offset,
+            readUnsigned(bytes, offsetsStart + (index + 1) * offsetSize, offsetSize)
+          )
+        )
+      );
+    }
+    previousOffset = offset;
+  }
+  if (previousOffset !== dictionaryBytes.length) {
+    throw new Error('parquet: VARIANT metadata does not consume its dictionary bytes');
+  }
+  return {dictionary};
+}
+
+/** Decodes one self-contained Variant value within the enclosing byte range. */
+function decodeVariantValue(
+  bytes: Uint8Array,
+  offset: number,
+  endOffset: number,
+  metadata: VariantMetadata,
+  depth: number
+): DecodedVariantValue {
+  if (depth > MAXIMUM_VARIANT_NESTING || offset >= endOffset) {
+    throw new Error('parquet: invalid or excessively nested VARIANT value');
+  }
+  const valueMetadata = bytes[offset++];
+  const basicType = valueMetadata & 0x3;
+  const valueHeader = valueMetadata >> 2;
+  switch (basicType) {
+    case 0:
+      return decodePrimitiveValue(bytes, offset, endOffset, valueHeader);
+    case 1: {
+      const stringEnd = checkedEnd(offset + valueHeader, endOffset);
+      return {value: decodeUtf8(bytes.subarray(offset, stringEnd)), nextOffset: stringEnd};
+    }
+    case 2:
+      return decodeObjectValue(bytes, offset, endOffset, valueHeader, metadata, depth + 1);
+    case 3:
+      return decodeArrayValue(bytes, offset, endOffset, valueHeader, metadata, depth + 1);
+    default:
+      throw new Error(`parquet: invalid VARIANT basic type ${basicType}`);
+  }
+}
+
+/** Decodes a Variant primitive identified by its six-bit primitive header. */
+function decodePrimitiveValue(
+  bytes: Uint8Array,
+  offset: number,
+  endOffset: number,
+  primitiveType: number
+): DecodedVariantValue {
+  switch (primitiveType) {
+    case 0:
+      return {value: null, nextOffset: offset};
+    case 1:
+      return {value: true, nextOffset: offset};
+    case 2:
+      return {value: false, nextOffset: offset};
+    case 3:
+      return {value: readSigned(bytes, offset, 1), nextOffset: checkedEnd(offset + 1, endOffset)};
+    case 4:
+      return {value: readSigned(bytes, offset, 2), nextOffset: checkedEnd(offset + 2, endOffset)};
+    case 5:
+      return {value: readSigned(bytes, offset, 4), nextOffset: checkedEnd(offset + 4, endOffset)};
+    case 6:
+      return {value: readBigInt(bytes, offset, 8), nextOffset: checkedEnd(offset + 8, endOffset)};
+    case 7:
+      return {value: readFloat64(bytes, offset), nextOffset: checkedEnd(offset + 8, endOffset)};
+    case 8:
+    case 9:
+    case 10: {
+      const scale = readSigned(bytes, offset, 1);
+      const width = primitiveType === 8 ? 4 : primitiveType === 9 ? 8 : 16;
+      const unscaled = readBigInt(bytes, offset + 1, width);
+      return {
+        value: formatVariantDecimal(unscaled, scale),
+        nextOffset: checkedEnd(offset + 1 + width, endOffset)
+      };
+    }
+    case 11:
+      return {value: readSigned(bytes, offset, 4), nextOffset: checkedEnd(offset + 4, endOffset)};
+    case 12:
+    case 13:
+    case 17:
+    case 18:
+    case 19:
+      return {value: readBigInt(bytes, offset, 8), nextOffset: checkedEnd(offset + 8, endOffset)};
+    case 14:
+      return {value: readFloat32(bytes, offset), nextOffset: checkedEnd(offset + 4, endOffset)};
+    case 15: {
+      const length = readUnsigned(bytes, offset, 4);
+      const start = checkedEnd(offset + 4, endOffset);
+      const binaryEnd = checkedEnd(start + length, endOffset);
+      return {value: bytes.slice(start, binaryEnd), nextOffset: binaryEnd};
+    }
+    case 16: {
+      const length = readUnsigned(bytes, offset, 4);
+      const start = checkedEnd(offset + 4, endOffset);
+      const stringEnd = checkedEnd(start + length, endOffset);
+      return {value: decodeUtf8(bytes.subarray(start, stringEnd)), nextOffset: stringEnd};
+    }
+    case 20: {
+      const uuidEnd = checkedEnd(offset + 16, endOffset);
+      return {value: bytes.slice(offset, uuidEnd), nextOffset: uuidEnd};
+    }
+    default:
+      throw new Error(`parquet: unsupported VARIANT primitive type ${primitiveType}`);
+  }
+}
+
+/** Decodes an object using metadata dictionary field IDs and relative value offsets. */
+function decodeObjectValue(
+  bytes: Uint8Array,
+  offset: number,
+  endOffset: number,
+  valueHeader: number,
+  metadata: VariantMetadata,
+  depth: number
+): DecodedVariantValue {
+  const isLarge = (valueHeader & 0x10) !== 0;
+  const fieldIdSize = ((valueHeader >> 2) & 0x3) + 1;
+  const fieldOffsetSize = (valueHeader & 0x3) + 1;
+  const countSize = isLarge ? 4 : 1;
+  const count = readUnsigned(bytes, offset, countSize);
+  offset = checkedEnd(offset + countSize, endOffset);
+  const fieldIds: number[] = [];
+  for (let index = 0; index < count; index++) {
+    fieldIds.push(readUnsigned(bytes, offset, fieldIdSize));
+    offset = checkedEnd(offset + fieldIdSize, endOffset);
+  }
+  const offsets: number[] = [];
+  for (let index = 0; index <= count; index++) {
+    offsets.push(readUnsigned(bytes, offset, fieldOffsetSize));
+    offset = checkedEnd(offset + fieldOffsetSize, endOffset);
+  }
+  const valuesStart = offset;
+  const valuesEnd = checkedEnd(valuesStart + offsets[offsets.length - 1], endOffset);
+  const object: Record<string, unknown> = Object.create(null) as Record<string, unknown>;
+  for (let index = 0; index < count; index++) {
+    const fieldId = fieldIds[index];
+    const fieldName = metadata.dictionary[fieldId];
+    if (fieldName === undefined) {
+      throw new Error(`parquet: invalid VARIANT object field id ${fieldId}`);
+    }
+    if (Object.prototype.hasOwnProperty.call(object, fieldName)) {
+      throw new Error(`parquet: duplicate VARIANT object field ${fieldName}`);
+    }
+    const valueOffset = checkedEnd(valuesStart + offsets[index], valuesEnd);
+    const decoded = decodeVariantValue(bytes, valueOffset, valuesEnd, metadata, depth);
+    object[fieldName] = decoded.value;
+  }
+  return {value: object, nextOffset: valuesEnd};
+}
+
+/** Decodes an array using relative offsets into its contiguous value region. */
+function decodeArrayValue(
+  bytes: Uint8Array,
+  offset: number,
+  endOffset: number,
+  valueHeader: number,
+  metadata: VariantMetadata,
+  depth: number
+): DecodedVariantValue {
+  const isLarge = (valueHeader & 0x4) !== 0;
+  const fieldOffsetSize = (valueHeader & 0x3) + 1;
+  const countSize = isLarge ? 4 : 1;
+  const count = readUnsigned(bytes, offset, countSize);
+  offset = checkedEnd(offset + countSize, endOffset);
+  const offsets: number[] = [];
+  for (let index = 0; index <= count; index++) {
+    offsets.push(readUnsigned(bytes, offset, fieldOffsetSize));
+    offset = checkedEnd(offset + fieldOffsetSize, endOffset);
+  }
+  const valuesStart = offset;
+  const valuesEnd = checkedEnd(valuesStart + offsets[offsets.length - 1], endOffset);
+  const array = new Array<unknown>(count);
+  for (let index = 0; index < count; index++) {
+    const valueOffset = checkedEnd(valuesStart + offsets[index], valuesEnd);
+    array[index] = decodeVariantValue(bytes, valueOffset, valuesEnd, metadata, depth).value;
+  }
+  return {value: array, nextOffset: valuesEnd};
+}
+
+/** Reads an unsigned little-endian integer of up to four bytes. */
+function readUnsigned(bytes: Uint8Array, offset: number, byteLength: number): number {
+  let value = 0;
+  for (let index = 0; index < byteLength; index++) {
+    value += bytes[offset + index] * 2 ** (index * 8);
+  }
+  if (!Number.isSafeInteger(value)) {
+    throw new Error('parquet: VARIANT integer exceeds JavaScript safe range');
+  }
+  return value;
+}
+
+/** Reads a signed little-endian integer of up to four bytes. */
+function readSigned(bytes: Uint8Array, offset: number, byteLength: number): number {
+  const unsigned = readUnsigned(bytes, offset, byteLength);
+  const signBit = 2 ** (byteLength * 8 - 1);
+  return unsigned >= signBit ? unsigned - 2 ** (byteLength * 8) : unsigned;
+}
+
+/** Reads a signed little-endian integer while preserving 64- and 128-bit precision. */
+function readBigInt(bytes: Uint8Array, offset: number, byteLength: number): bigint {
+  let value = 0n;
+  for (let index = 0; index < byteLength; index++) {
+    value |= BigInt(bytes[offset + index]) << BigInt(index * 8);
+  }
+  const signBit = 1n << BigInt(byteLength * 8 - 1);
+  return value >= signBit ? value - (1n << BigInt(byteLength * 8)) : value;
+}
+
+/** Reads a little-endian IEEE-754 single-precision value. */
+function readFloat32(bytes: Uint8Array, offset: number): number {
+  return new DataView(bytes.buffer, bytes.byteOffset + offset, 4).getFloat32(0, true);
+}
+
+/** Reads a little-endian IEEE-754 double-precision value. */
+function readFloat64(bytes: Uint8Array, offset: number): number {
+  return new DataView(bytes.buffer, bytes.byteOffset + offset, 8).getFloat64(0, true);
+}
+
+/** Formats a Variant decimal without losing precision when JavaScript numbers are unsafe. */
+function formatVariantDecimal(unscaled: bigint, scale: number): number | string {
+  if (scale < 0) {
+    return `${unscaled.toString()}${'0'.repeat(-scale)}`;
+  }
+  if (
+    scale === 0 &&
+    unscaled >= BigInt(Number.MIN_SAFE_INTEGER) &&
+    unscaled <= BigInt(Number.MAX_SAFE_INTEGER)
+  ) {
+    return Number(unscaled);
+  }
+  const sign = unscaled < 0n ? '-' : '';
+  const digits = (unscaled < 0n ? -unscaled : unscaled).toString().padStart(scale + 1, '0');
+  const split = digits.length - scale;
+  return `${sign}${digits.slice(0, split)}.${digits.slice(split)}`;
+}
+
+/** Validates an offset against the enclosing value boundary. */
+function checkedEnd(offset: number, endOffset: number): number {
+  if (!Number.isSafeInteger(offset) || offset < 0 || offset > endOffset) {
+    throw new Error('parquet: truncated VARIANT value');
+  }
+  return offset;
+}

package/src/parquetjs/utils/binary-utils.ts

@@ -0,0 +1,132 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+const TEXT_DECODER = new TextDecoder();
+const TEXT_ENCODER = new TextEncoder();
+
+/** Returns bytes as an exact Uint8Array view. */
+export function toUint8Array(binary: ArrayBuffer | ArrayBufferView): Uint8Array {
+  if (binary instanceof Uint8Array) {
+    return binary;
+  }
+  if (ArrayBuffer.isView(binary)) {
+    return new Uint8Array(binary.buffer, binary.byteOffset, binary.byteLength);
+  }
+  return new Uint8Array(binary);
+}
+
+/** Returns bytes as a copied ArrayBuffer with no extra prefix/suffix bytes. */
+export function toArrayBuffer(binary: ArrayBuffer | ArrayBufferView): ArrayBuffer {
+  const bytes = toUint8Array(binary);
+  return bytes.slice().buffer;
+}
+
+/** Returns a copied Uint8Array. */
+export function copyUint8Array(binary: Uint8Array): Uint8Array {
+  return binary.slice();
+}
+
+/** Decode UTF-8 bytes. */
+export function decodeUtf8(binary: Uint8Array): string {
+  return TEXT_DECODER.decode(binary);
+}
+
+/** Encode text as UTF-8 bytes. */
+export function encodeUtf8(text: string): Uint8Array {
+  return TEXT_ENCODER.encode(text);
+}
+
+/** Decode an ASCII/UTF-8 range from bytes. */
+export function decodeString(
+  binary: Uint8Array,
+  start: number = 0,
+  end: number = binary.length
+): string {
+  return decodeUtf8(binary.subarray(start, end));
+}
+
+function getDataView(binary: Uint8Array): DataView {
+  return new DataView(binary.buffer, binary.byteOffset, binary.byteLength);
+}
+
+/** Read signed little-endian 32-bit integer. */
+export function readInt32LE(binary: Uint8Array, offset: number): number {
+  return getDataView(binary).getInt32(offset, true);
+}
+
+/** Read unsigned little-endian 32-bit integer. */
+export function readUInt32LE(binary: Uint8Array, offset: number): number {
+  return getDataView(binary).getUint32(offset, true);
+}
+
+/** Read signed little-endian 64-bit integer without losing precision. */
+export function readInt64LE(binary: Uint8Array, offset: number): bigint {
+  return getDataView(binary).getBigInt64(offset, true);
+}
+
+/** Read unsigned little-endian 64-bit integer without losing precision. */
+export function readUInt64LE(binary: Uint8Array, offset: number): bigint {
+  return getDataView(binary).getBigUint64(offset, true);
+}
+
+/** Read little-endian 32-bit float. */
+export function readFloatLE(binary: Uint8Array, offset: number): number {
+  return getDataView(binary).getFloat32(offset, true);
+}
+
+/** Read little-endian 64-bit float. */
+export function readDoubleLE(binary: Uint8Array, offset: number): number {
+  return getDataView(binary).getFloat64(offset, true);
+}
+
+/** Concatenate bytes into one exact Uint8Array. */
+export function concatUint8Arrays(chunks: Uint8Array[]): Uint8Array {
+  let byteLength = 0;
+  for (const chunk of chunks) {
+    byteLength += chunk.length;
+  }
+
+  const result = new Uint8Array(byteLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    result.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return result;
+}
+
+/** Write signed little-endian 16-bit integer. */
+export function writeInt16LE(binary: Uint8Array, value: number, offset: number): void {
+  getDataView(binary).setInt16(offset, value, true);
+}
+
+/** Write unsigned little-endian 16-bit integer. */
+export function writeUInt16LE(binary: Uint8Array, value: number, offset: number): void {
+  getDataView(binary).setUint16(offset, value, true);
+}
+
+/** Write signed little-endian 32-bit integer. */
+export function writeInt32LE(binary: Uint8Array, value: number, offset: number): void {
+  getDataView(binary).setInt32(offset, value, true);
+}
+
+/** Write unsigned little-endian 32-bit integer. */
+export function writeUInt32LE(binary: Uint8Array, value: number, offset: number): void {
+  getDataView(binary).setUint32(offset, value, true);
+}
+
+/** Write signed little-endian 64-bit integer. */
+export function writeInt64LE(binary: Uint8Array, value: number | bigint, offset: number): void {
+  getDataView(binary).setBigInt64(offset, BigInt(value), true);
+}
+
+/** Write little-endian 32-bit float. */
+export function writeFloatLE(binary: Uint8Array, value: number, offset: number): void {
+  getDataView(binary).setFloat32(offset, value, true);
+}
+
+/** Write little-endian 64-bit float. */
+export function writeDoubleLE(binary: Uint8Array, value: number, offset: number): void {
+  getDataView(binary).setFloat64(offset, value, true);
+}

package/src/parquetjs/utils/crc32.ts

@@ -0,0 +1,15 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+/** Computes the IEEE CRC-32 checksum used by Parquet page headers. */
+export function crc32(bytes: Uint8Array): number {
+  let checksum = 0xffffffff;
+  for (const byte of bytes) {
+    checksum ^= byte;
+    for (let bit = 0; bit < 8; bit++) {
+      checksum = (checksum >>> 1) ^ (0xedb88320 & -(checksum & 1));
+    }
+  }
+  return (checksum ^ 0xffffffff) >>> 0;
+}

package/src/parquetjs/utils/file-utils.ts

@@ -19,9 +19,9 @@ export interface WriteStreamOptions {
   start?: number;
 }
 
-export function oswrite(os: stream.Writable, buf: Buffer): Promise<void> {
+export function oswrite(os: stream.Writable, buf: Uint8Array): Promise<void> {
   return new Promise((resolve, reject) => {
-    os.write(buf, (err) => {
+    os.write(buf, err => {
       if (err) {
         reject(err);
       } else {
@@ -46,7 +46,7 @@ export function osclose(os: stream.Writable): Promise<void> {
 export function osopen(path: string, opts?: WriteStreamOptions): Promise<fs.WriteStream> {
   return new Promise((resolve, reject) => {
     const outputStream = fs.createWriteStream(path, opts as any);
-    outputStream.once('open', (fd) => resolve(outputStream));
-    outputStream.once('error', (err) => reject(err));
+    outputStream.once('open', _fd => resolve(outputStream));
+    outputStream.once('error', err => reject(err));
   });
 }

package/src/parquetjs/utils/read-utils.ts

@@ -5,82 +5,103 @@
 // Forked from https://github.com/kbajalc/parquets under MIT license
 
 import {
-  TBufferedTransport,
-  TCompactProtocol,
-  TFramedTransport,
+  ColumnMetaData,
+  FileCryptoMetaData,
   FileMetaData,
   PageHeader
 } from '../parquet-thrift/index';
-
-class UFramedTransport extends TFramedTransport {
-  public readPos: number = 0;
-}
+import {Uint8ArrayCompactProtocol} from './uint8-array-compact-protocol';
+import {Uint8ArrayCompactProtocolWriter} from './uint8-array-compact-protocol-writer';
+import {Uint8ArrayTransport} from './uint8-array-transport';
 
 /**
  * Helper function that serializes a thrift object into a buffer
  */
-export function serializeThrift(obj: any): Buffer {
-  const output: Buffer[] = [];
-
-  const transport = new TBufferedTransport(undefined, (buf) => {
-    output.push(buf as unknown as Buffer);
-  });
-
-  const protocol = new TCompactProtocol(transport);
-  obj.write(protocol);
-  transport.flush();
-
-  return Buffer.concat(output as Uint8Array[]);
+export function serializeThrift(obj: any): Uint8Array {
+  const protocol = new Uint8ArrayCompactProtocolWriter();
+  obj.write(protocol as any);
+  return protocol.getBytes();
 }
 
-export function decodeThrift(obj: any, buf: Buffer, offset?: number) {
+export function decodeThrift(obj: any, buf: Uint8Array, offset?: number) {
   if (!offset) {
     // tslint:disable-next-line:no-parameter-reassignment
     offset = 0;
   }
 
-  const transport = new UFramedTransport(buf);
+  const transport = new Uint8ArrayTransport(buf);
   transport.readPos = offset;
-  const protocol = new TCompactProtocol(transport);
+  const protocol = new Uint8ArrayCompactProtocol(transport);
   obj.read(protocol);
   return transport.readPos - offset;
 }
 
 /**
- * FIXME not ideal that this is linear
+ * Returns the generated TypeScript enum member for a Thrift value.
+ * @param thriftEnum generated numeric enum object
+ * @param value serialized enum value
+ * @returns enum member name
  */
-export function getThriftEnum(klass: any, value: number | string): string {
-  for (const k in klass) {
-    if (klass[k] === value) {
-      return k;
+export function getThriftEnum(thriftEnum: object, value: number | string): string {
+  const enumValues = thriftEnum as Record<string | number, number | string>;
+  if (typeof value === 'number') {
+    const enumName = enumValues[value];
+    if (typeof enumName === 'string') {
+      return enumName;
+    }
+  }
+
+  for (const enumName in enumValues) {
+    if (enumValues[enumName] === value) {
+      return enumName;
     }
   }
   throw new Error('Invalid ENUM value');
 }
 
-export function decodeFileMetadata(buf: Buffer, offset?: number) {
+export function decodeFileMetadata(buf: Uint8Array, offset?: number) {
   if (!offset) {
     // tslint:disable-next-line:no-parameter-reassignment
     offset = 0;
   }
 
-  const transport = new UFramedTransport(buf);
+  const transport = new Uint8ArrayTransport(buf);
+  transport.readPos = offset;
+  const protocol = new Uint8ArrayCompactProtocol(transport);
+  const metadata = FileMetaData.read(protocol as any);
+  return {length: transport.readPos - offset, metadata};
+}
+
+/** Decodes the FileCryptoMetaData prefix used by encrypted-footer files. */
+export function decodeFileCryptoMetadata(buf: Uint8Array, offset?: number) {
+  if (!offset) offset = 0;
+  const transport = new Uint8ArrayTransport(buf);
+  transport.readPos = offset;
+  const protocol = new Uint8ArrayCompactProtocol(transport);
+  const metadata = FileCryptoMetaData.read(protocol as any);
+  return {length: transport.readPos - offset, metadata};
+}
+
+/** Decodes a serialized ColumnMetaData encryption module. */
+export function decodeColumnMetadata(buf: Uint8Array, offset?: number) {
+  if (!offset) offset = 0;
+  const transport = new Uint8ArrayTransport(buf);
   transport.readPos = offset;
-  const protocol = new TCompactProtocol(transport);
-  const metadata = FileMetaData.read(protocol);
+  const protocol = new Uint8ArrayCompactProtocol(transport);
+  const metadata = ColumnMetaData.read(protocol as any);
   return {length: transport.readPos - offset, metadata};
 }
 
-export function decodePageHeader(buf: Buffer, offset?: number) {
+export function decodePageHeader(buf: Uint8Array, offset?: number) {
   if (!offset) {
     // tslint:disable-next-line:no-parameter-reassignment
     offset = 0;
   }
 
-  const transport = new UFramedTransport(buf);
+  const transport = new Uint8ArrayTransport(buf);
   transport.readPos = offset;
-  const protocol = new TCompactProtocol(transport);
-  const pageHeader = PageHeader.read(protocol);
+  const protocol = new Uint8ArrayCompactProtocol(transport);
+  const pageHeader = PageHeader.read(protocol as any);
   return {length: transport.readPos - offset, pageHeader};
 }
 
@@ -95,26 +116,31 @@ export function getBitWidth(val: number): number {
   return Math.ceil(Math.log2(val + 1));
 }
 
-// Supports MQTT path wildcards
-// + all immediate children
-// # all descendents
+/**
+ * Finds the selected field path that contains a Parquet leaf path.
+ * A selected parent includes all descendant leaves. MQTT-style `+` and `#` path wildcards are
+ * retained for internal callers (`+` matches one segment and `#` matches all remaining segments).
+ */
 export function fieldIndexOf(arr: string[][], elem: string[]): number {
-  for (let j = 0; j < arr.length; j++) {
-    if (arr[j].length > elem.length) {
-      continue; // eslint-disable-line no-continue
-    }
-    let m = true;
-    for (let i = 0; i < elem.length; i++) {
-      if (arr[j][i] === elem[i] || arr[j][i] === '+' || arr[j][i] === '#') {
-        continue; // eslint-disable-line no-continue
+  for (let fieldIndex = 0; fieldIndex < arr.length; fieldIndex++) {
+    const selectedPath = arr[fieldIndex];
+    let matches = true;
+    for (let pathIndex = 0; pathIndex < selectedPath.length; pathIndex++) {
+      const selectedSegment = selectedPath[pathIndex];
+      if (selectedSegment === '#') {
+        return fieldIndex;
       }
-      if (i >= arr[j].length && arr[j][arr[j].length - 1] === '#') {
-        continue; // eslint-disable-line no-continue
+      if (
+        pathIndex >= elem.length ||
+        (selectedSegment !== '+' && selectedSegment !== elem[pathIndex])
+      ) {
+        matches = false;
+        break;
       }
-      m = false;
-      break;
     }
-    if (m) return j;
+    if (matches) {
+      return fieldIndex;
+    }
   }
   return -1;
 }