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

package/src/parquetjs/utils/thrift-runtime.ts

@@ -0,0 +1,109 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+/** Minimal Thrift runtime types needed by the generated Parquet metadata classes. */
+export namespace Thrift {
+  /** Thrift wire types used by the Parquet compact protocol. */
+  export enum Type {
+    STOP = 0,
+    VOID = 1,
+    BOOL = 2,
+    BYTE = 3,
+    DOUBLE = 4,
+    I16 = 6,
+    I32 = 8,
+    I64 = 10,
+    STRING = 11,
+    STRUCT = 12,
+    MAP = 13,
+    SET = 14,
+    LIST = 15,
+    UTF8 = 16,
+    UTF16 = 17
+  }
+
+  /** Protocol failure categories retained for generated-code compatibility. */
+  export enum TProtocolExceptionType {
+    UNKNOWN = 0,
+    INVALID_DATA = 1,
+    NEGATIVE_SIZE = 2,
+    SIZE_LIMIT = 3,
+    BAD_VERSION = 4,
+    NOT_IMPLEMENTED = 5,
+    DEPTH_LIMIT = 6
+  }
+
+  /** Error raised when generated metadata cannot be encoded or decoded. */
+  export class TProtocolException extends Error {
+    /** Thrift protocol error category. */
+    readonly type: TProtocolExceptionType;
+
+    /** Creates a protocol exception without importing the Node-oriented thrift package. */
+    constructor(type: TProtocolExceptionType, message = 'Thrift protocol error') {
+      super(message);
+      this.name = 'TProtocolException';
+      this.type = type;
+    }
+  }
+}
+
+/** Thrift struct descriptor returned by compact-protocol readers. */
+export type TStruct = {fname: string};
+
+/** Thrift field descriptor returned by compact-protocol readers. */
+export type TField = {fname: string; ftype: Thrift.Type; fid: number};
+
+/** Thrift map descriptor returned by compact-protocol readers. */
+export type TMap = {ktype: Thrift.Type; vtype: Thrift.Type; size: number};
+
+/** Thrift list descriptor returned by compact-protocol readers. */
+export type TList = {etype: Thrift.Type; size: number};
+
+/** Thrift set descriptor returned by compact-protocol readers. */
+export type TSet = TList;
+
+/**
+ * Compact-protocol surface consumed by the generated Parquet metadata classes.
+ * Binary values use typed-array views and remain browser-native.
+ */
+export interface TProtocol {
+  writeStructBegin(name: string): void;
+  writeStructEnd(): void;
+  writeFieldBegin(name: string, fieldType: Thrift.Type, fieldId: number): void;
+  writeFieldEnd(): void;
+  writeFieldStop(): void;
+  writeMapBegin(keyType: Thrift.Type, valueType: Thrift.Type, size: number): void;
+  writeMapEnd(): void;
+  writeListBegin(elementType: Thrift.Type, size: number): void;
+  writeListEnd(): void;
+  writeSetBegin(elementType: Thrift.Type, size: number): void;
+  writeSetEnd(): void;
+  writeBool(value: boolean): void;
+  writeByte(value: number): void;
+  writeI16(value: number): void;
+  writeI32(value: number): void;
+  writeI64(value: unknown): void;
+  writeDouble(value: number): void;
+  writeString(value: string): void;
+  writeBinary(value: ArrayBuffer | ArrayBufferView): void;
+  readStructBegin(): TStruct;
+  readStructEnd(): void;
+  readFieldBegin(): TField;
+  readFieldEnd(): void;
+  readMapBegin(): TMap;
+  readMapEnd(): void;
+  readListBegin(): TList;
+  readListEnd(): void;
+  readSetBegin(): TSet;
+  readSetEnd(): void;
+  readBool(): boolean;
+  readByte(): number;
+  readI16(): number;
+  readI32(): number;
+  readI64(): any;
+  readDouble(): number;
+  readString(): string;
+  readBinary(): Uint8Array;
+  skip(type: Thrift.Type): void;
+}

package/src/parquetjs/utils/uint8-array-compact-protocol-writer.ts

@@ -0,0 +1,254 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import * as thrift from './thrift-runtime';
+import {concatUint8Arrays, encodeUtf8, toUint8Array, writeDoubleLE} from './binary-utils';
+
+const COMPACT_TYPE_STOP = 0x00;
+const COMPACT_TYPE_BOOLEAN_TRUE = 0x01;
+const COMPACT_TYPE_BOOLEAN_FALSE = 0x02;
+const COMPACT_TYPE_BYTE = 0x03;
+const COMPACT_TYPE_I16 = 0x04;
+const COMPACT_TYPE_I32 = 0x05;
+const COMPACT_TYPE_I64 = 0x06;
+const COMPACT_TYPE_DOUBLE = 0x07;
+const COMPACT_TYPE_BINARY = 0x08;
+const COMPACT_TYPE_LIST = 0x09;
+const COMPACT_TYPE_SET = 0x0a;
+const COMPACT_TYPE_MAP = 0x0b;
+const COMPACT_TYPE_STRUCT = 0x0c;
+
+type Int64Like = number | bigint | {toString(radix?: number): string; valueOf?: () => number};
+
+/** Write-only Thrift compact protocol that assembles exact Uint8Array output. */
+export class Uint8ArrayCompactProtocolWriter {
+  /** Serialized byte chunks accumulated by thrift write calls. */
+  private readonly chunks: Uint8Array[] = [];
+
+  /** Field id at the current nesting depth, used to emit compact field-id deltas. */
+  private lastFieldId = 0;
+
+  /** Parent struct field ids restored when nested structs end. */
+  private readonly lastFieldIds: number[] = [];
+
+  /** Boolean field header waiting for the following boolean payload. */
+  private pendingBooleanField: {fid: number} | null = null;
+
+  /** Enter a struct and reset the delta-encoded field id state. */
+  writeStructBegin(_name: string): void {
+    this.lastFieldIds.push(this.lastFieldId);
+    this.lastFieldId = 0;
+  }
+
+  /** Exit a struct and restore the parent field id state. */
+  writeStructEnd(): void {
+    this.lastFieldId = this.lastFieldIds.pop() || 0;
+  }
+
+  /** Write a field header, deferring boolean fields until their value is known. */
+  writeFieldBegin(_name: string, fieldType: thrift.Thrift.Type, fid: number): void {
+    if (fieldType === thrift.Thrift.Type.BOOL) {
+      this.pendingBooleanField = {fid};
+      return;
+    }
+
+    this.writeFieldHeader(this.getCompactType(fieldType), fid);
+  }
+
+  /** Complete the current field; compact protocol has no field-end bytes. */
+  writeFieldEnd(): void {}
+
+  /** Write the stop marker that terminates a thrift struct. */
+  writeFieldStop(): void {
+    this.writeByteDirect(COMPACT_TYPE_STOP);
+  }
+
+  /** Write a map header with compact key/value element types. */
+  writeMapBegin(keyType: thrift.Thrift.Type, valueType: thrift.Thrift.Type, size: number): void {
+    if (size === 0) {
+      this.writeByteDirect(0);
+      return;
+    }
+
+    this.writeVarint32(size);
+    this.writeByteDirect((this.getCompactType(keyType) << 4) | this.getCompactType(valueType));
+  }
+
+  /** Complete the current map; compact protocol has no map-end bytes. */
+  writeMapEnd(): void {}
+
+  /** Write a list header with compact element type and element count. */
+  writeListBegin(elementType: thrift.Thrift.Type, size: number): void {
+    this.writeCollectionBegin(elementType, size);
+  }
+
+  /** Complete the current list; compact protocol has no list-end bytes. */
+  writeListEnd(): void {}
+
+  /** Write a set header with compact element type and element count. */
+  writeSetBegin(elementType: thrift.Thrift.Type, size: number): void {
+    this.writeCollectionBegin(elementType, size);
+  }
+
+  /** Complete the current set; compact protocol has no set-end bytes. */
+  writeSetEnd(): void {}
+
+  /** Write a boolean, either inline in its field header or as a value byte. */
+  writeBool(value: boolean): void {
+    const compactType = value ? COMPACT_TYPE_BOOLEAN_TRUE : COMPACT_TYPE_BOOLEAN_FALSE;
+    if (this.pendingBooleanField) {
+      this.writeFieldHeader(compactType, this.pendingBooleanField.fid);
+      this.pendingBooleanField = null;
+      return;
+    }
+
+    this.writeByteDirect(compactType);
+  }
+
+  /** Write a signed byte. */
+  writeByte(value: number): void {
+    this.writeByteDirect(value);
+  }
+
+  /** Write a signed 16-bit integer as zig-zag varint. */
+  writeI16(value: number): void {
+    this.writeI32(value);
+  }
+
+  /** Write a signed 32-bit integer as zig-zag varint. */
+  writeI32(value: number): void {
+    this.writeVarint32(this.encodeZigZag32(value));
+  }
+
+  /** Write a signed 64-bit-like value as zig-zag varint. */
+  writeI64(value: Int64Like): void {
+    this.writeVarint64(this.encodeZigZag64(this.toBigInt(value)));
+  }
+
+  /** Write a little-endian 64-bit float. */
+  writeDouble(value: number): void {
+    const bytes = new Uint8Array(8);
+    writeDoubleLE(bytes, value, 0);
+    this.writeBytes(bytes);
+  }
+
+  /** Write a length-prefixed UTF-8 string. */
+  writeString(value: string): void {
+    this.writeBinary(encodeUtf8(value));
+  }
+
+  /** Write a length-prefixed binary payload from any typed-array view. */
+  writeBinary(value: ArrayBuffer | ArrayBufferView): void {
+    const bytes = toUint8Array(value);
+    this.writeVarint32(bytes.length);
+    this.writeBytes(bytes);
+  }
+
+  /** Return all serialized chunks as one contiguous byte array. */
+  getBytes(): Uint8Array {
+    return concatUint8Arrays(this.chunks);
+  }
+
+  /** Write a compact collection header for list or set values. */
+  private writeCollectionBegin(elementType: thrift.Thrift.Type, size: number): void {
+    const compactType = this.getCompactType(elementType);
+    if (size <= 14) {
+      this.writeByteDirect((size << 4) | compactType);
+      return;
+    }
+
+    this.writeByteDirect(0xf0 | compactType);
+    this.writeVarint32(size);
+  }
+
+  /** Write a compact field header using a field-id delta when possible. */
+  private writeFieldHeader(compactType: number, fid: number): void {
+    const fieldIdDelta = fid - this.lastFieldId;
+    if (fieldIdDelta > 0 && fieldIdDelta <= 15) {
+      this.writeByteDirect((fieldIdDelta << 4) | compactType);
+    } else {
+      this.writeByteDirect(compactType);
+      this.writeI16(fid);
+    }
+    this.lastFieldId = fid;
+  }
+
+  /** Append an already serialized byte range without copying. */
+  private writeBytes(bytes: Uint8Array): void {
+    this.chunks.push(bytes);
+  }
+
+  /** Append one byte to the serialized output. */
+  private writeByteDirect(value: number): void {
+    this.chunks.push(new Uint8Array([value & 0xff]));
+  }
+
+  /** Write an unsigned 32-bit value as a compact varint. */
+  private writeVarint32(value: number): void {
+    this.writeVarint64(BigInt(value >>> 0));
+  }
+
+  /** Write an unsigned 64-bit value as a compact varint. */
+  private writeVarint64(value: bigint): void {
+    let nextValue = value;
+    while (true) {
+      if ((nextValue & ~0x7fn) === 0n) {
+        this.writeByteDirect(Number(nextValue));
+        return;
+      }
+
+      this.writeByteDirect(Number((nextValue & 0x7fn) | 0x80n));
+      nextValue >>= 7n;
+    }
+  }
+
+  /** Encode a signed 32-bit integer as an unsigned zig-zag value. */
+  private encodeZigZag32(value: number): number {
+    return ((value << 1) ^ (value >> 31)) >>> 0;
+  }
+
+  /** Encode a signed 64-bit integer as an unsigned zig-zag value. */
+  private encodeZigZag64(value: bigint): bigint {
+    return (value << 1n) ^ (value >> 63n);
+  }
+
+  /** Normalize thrift int64-like values to bigint before zig-zag encoding. */
+  private toBigInt(value: Int64Like): bigint {
+    return typeof value === 'bigint' || typeof value === 'number'
+      ? BigInt(value)
+      : BigInt(value.toString());
+  }
+
+  /** Convert a generated-thrift type to a compact protocol wire type. */
+  private getCompactType(thriftType: thrift.Thrift.Type): number {
+    switch (thriftType) {
+      case thrift.Thrift.Type.STOP:
+        return COMPACT_TYPE_STOP;
+      case thrift.Thrift.Type.BOOL:
+        return COMPACT_TYPE_BOOLEAN_TRUE;
+      case thrift.Thrift.Type.BYTE:
+        return COMPACT_TYPE_BYTE;
+      case thrift.Thrift.Type.I16:
+        return COMPACT_TYPE_I16;
+      case thrift.Thrift.Type.I32:
+        return COMPACT_TYPE_I32;
+      case thrift.Thrift.Type.I64:
+        return COMPACT_TYPE_I64;
+      case thrift.Thrift.Type.DOUBLE:
+        return COMPACT_TYPE_DOUBLE;
+      case thrift.Thrift.Type.STRING:
+        return COMPACT_TYPE_BINARY;
+      case thrift.Thrift.Type.LIST:
+        return COMPACT_TYPE_LIST;
+      case thrift.Thrift.Type.SET:
+        return COMPACT_TYPE_SET;
+      case thrift.Thrift.Type.MAP:
+        return COMPACT_TYPE_MAP;
+      case thrift.Thrift.Type.STRUCT:
+        return COMPACT_TYPE_STRUCT;
+      default:
+        throw new Error(`Unsupported thrift type: ${thriftType}`);
+    }
+  }
+}

package/src/parquetjs/utils/uint8-array-compact-protocol.ts

@@ -0,0 +1,322 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import * as thrift from './thrift-runtime';
+import {readDoubleLE} from './binary-utils';
+import {Uint8ArrayTransport} from './uint8-array-transport';
+
+const COMPACT_TYPE_STOP = 0x00;
+const COMPACT_TYPE_BOOLEAN_TRUE = 0x01;
+const COMPACT_TYPE_BOOLEAN_FALSE = 0x02;
+const COMPACT_TYPE_BYTE = 0x03;
+const COMPACT_TYPE_I16 = 0x04;
+const COMPACT_TYPE_I32 = 0x05;
+const COMPACT_TYPE_I64 = 0x06;
+const COMPACT_TYPE_DOUBLE = 0x07;
+const COMPACT_TYPE_BINARY = 0x08;
+const COMPACT_TYPE_LIST = 0x09;
+const COMPACT_TYPE_SET = 0x0a;
+const COMPACT_TYPE_MAP = 0x0b;
+const COMPACT_TYPE_STRUCT = 0x0c;
+
+/** Number-like replacement for node-int64 used by the compact protocol. */
+export class CompactInt64 {
+  /** Signed integer payload represented without precision loss. */
+  private readonly value: bigint;
+
+  /** Create a compact-protocol int64 wrapper from a bigint. */
+  constructor(value: bigint | number | string | {toString(): string}) {
+    this.value = typeof value === 'bigint' ? value : BigInt(value.toString());
+  }
+
+  /** Return the payload as a JavaScript number. */
+  toNumber(): number {
+    return Number(this.value);
+  }
+
+  /** Return the payload as a JavaScript number for generated thrift arithmetic. */
+  valueOf(): number {
+    return this.toNumber();
+  }
+
+  /** Format the payload as a string. */
+  toString(radix?: number): string {
+    return this.value.toString(radix);
+  }
+}
+
+/** Read-only Thrift compact protocol backed by Uint8Array. */
+export class Uint8ArrayCompactProtocol {
+  /** Byte transport that provides thrift-compatible read, borrow, and consume methods. */
+  private readonly transport: Uint8ArrayTransport;
+
+  /** Field id at the current nesting depth, used for compact field-id deltas. */
+  private lastFieldId = 0;
+
+  /** Parent struct field ids restored when nested structs end. */
+  private readonly lastFieldIds: number[] = [];
+
+  /** Boolean payload encoded in a compact field header. */
+  private boolValue: boolean | null = null;
+
+  /** Create a compact protocol reader over a Uint8Array-backed transport. */
+  constructor(transport: Uint8ArrayTransport) {
+    this.transport = transport;
+  }
+
+  /** Enter a struct and reset the delta-encoded field id state. */
+  readStructBegin(): thrift.TStruct {
+    this.lastFieldIds.push(this.lastFieldId);
+    this.lastFieldId = 0;
+    return {fname: ''};
+  }
+
+  readStructEnd(): void {
+    this.lastFieldId = this.lastFieldIds.pop() || 0;
+  }
+
+  /** Read a compact field header and expand it to a thrift field descriptor. */
+  readFieldBegin(): thrift.TField {
+    const fieldHeader = this.transport.readByte();
+    const compactType = fieldHeader & 0x0f;
+
+    if (compactType === COMPACT_TYPE_STOP) {
+      return {fname: null!, ftype: thrift.Thrift.Type.STOP, fid: 0};
+    }
+
+    const fieldIdDelta = (fieldHeader & 0xf0) >>> 4;
+    const fieldId = fieldIdDelta === 0 ? this.readI16() : this.lastFieldId + fieldIdDelta;
+    const fieldType = this.getThriftType(compactType);
+
+    if (compactType === COMPACT_TYPE_BOOLEAN_TRUE || compactType === COMPACT_TYPE_BOOLEAN_FALSE) {
+      this.boolValue = compactType === COMPACT_TYPE_BOOLEAN_TRUE;
+    }
+
+    this.lastFieldId = fieldId;
+    return {fname: null!, ftype: fieldType, fid: fieldId};
+  }
+
+  readFieldEnd(): void {}
+
+  /** Read a map header, including element compact types when the map is non-empty. */
+  readMapBegin(): thrift.TMap {
+    const size = this.readVarint32();
+    const keyAndValueType = size === 0 ? 0 : this.transport.readByte();
+    return {
+      ktype: this.getThriftType((keyAndValueType & 0xf0) >>> 4),
+      vtype: this.getThriftType(keyAndValueType & 0x0f),
+      size
+    };
+  }
+
+  readMapEnd(): void {}
+
+  /** Read a list header and expand the inline or varint element count. */
+  readListBegin(): thrift.TList {
+    const sizeAndType = this.transport.readByte();
+    let size = (sizeAndType >>> 4) & 0x0f;
+    if (size === 15) {
+      size = this.readVarint32();
+    }
+
+    return {
+      etype: this.getThriftType(sizeAndType & 0x0f),
+      size
+    };
+  }
+
+  readListEnd(): void {}
+
+  /** Read a set header; compact protocol encodes sets and lists the same way. */
+  readSetBegin(): thrift.TSet {
+    return this.readListBegin();
+  }
+
+  readSetEnd(): void {}
+
+  /** Read a boolean from the field header or from the next compact boolean byte. */
+  readBool(): boolean {
+    if (this.boolValue !== null) {
+      const value = this.boolValue;
+      this.boolValue = null;
+      return value;
+    }
+
+    return this.transport.readByte() === COMPACT_TYPE_BOOLEAN_TRUE;
+  }
+
+  /** Read a signed byte from the transport. */
+  readByte(): number {
+    return this.transport.readByte();
+  }
+
+  /** Read a signed 16-bit integer encoded as zig-zag varint. */
+  readI16(): number {
+    return this.readI32();
+  }
+
+  /** Read a signed 32-bit integer encoded as zig-zag varint. */
+  readI32(): number {
+    return this.decodeZigZag32(this.readVarint32());
+  }
+
+  /** Read a signed 64-bit integer encoded as zig-zag varint. */
+  readI64(): CompactInt64 {
+    return new CompactInt64(this.decodeZigZag64(this.readVarint64()));
+  }
+
+  /** Read a little-endian 64-bit float. */
+  readDouble(): number {
+    return readDoubleLE(this.transport.read(8), 0);
+  }
+
+  /** Read a length-prefixed binary payload as an exact Uint8Array. */
+  readBinary(): Uint8Array {
+    const size = this.readVarint32();
+    return size === 0 ? new Uint8Array(0) : this.transport.read(size);
+  }
+
+  /** Read a length-prefixed UTF-8 string. */
+  readString(): string {
+    const size = this.readVarint32();
+    return size === 0 ? '' : this.transport.readString(size);
+  }
+
+  /** Consume and discard a value with the supplied thrift type. */
+  skip(type: thrift.Thrift.Type): void {
+    switch (type) {
+      case thrift.Thrift.Type.STOP:
+        return;
+      case thrift.Thrift.Type.BOOL:
+        this.readBool();
+        return;
+      case thrift.Thrift.Type.BYTE:
+        this.readByte();
+        return;
+      case thrift.Thrift.Type.I16:
+        this.readI16();
+        return;
+      case thrift.Thrift.Type.I32:
+        this.readI32();
+        return;
+      case thrift.Thrift.Type.I64:
+        this.readI64();
+        return;
+      case thrift.Thrift.Type.DOUBLE:
+        this.readDouble();
+        return;
+      case thrift.Thrift.Type.STRING:
+        this.readBinary();
+        return;
+      case thrift.Thrift.Type.STRUCT:
+        this.skipStruct();
+        return;
+      case thrift.Thrift.Type.MAP:
+        this.skipMap();
+        return;
+      case thrift.Thrift.Type.SET:
+      case thrift.Thrift.Type.LIST:
+        this.skipList();
+        return;
+      default:
+        throw new Error(`Unsupported thrift type: ${type}`);
+    }
+  }
+
+  /** Read an unsigned 32-bit compact varint. */
+  private readVarint32(): number {
+    return Number(this.readVarint64());
+  }
+
+  /** Read an unsigned 64-bit compact varint. */
+  private readVarint64(): bigint {
+    let value = 0n;
+    let shift = 0n;
+
+    while (true) {
+      const byte = BigInt(this.transport.readByte() & 0xff);
+      value |= (byte & 0x7fn) << shift;
+      if ((byte & 0x80n) === 0n) {
+        return value;
+      }
+      shift += 7n;
+    }
+  }
+
+  /** Decode a zig-zag 32-bit integer to a signed integer. */
+  private decodeZigZag32(value: number): number {
+    return (value >>> 1) ^ -(value & 1);
+  }
+
+  /** Decode a zig-zag 64-bit integer to a signed integer. */
+  private decodeZigZag64(value: bigint): bigint {
+    return (value >> 1n) ^ -(value & 1n);
+  }
+
+  /** Convert a compact wire type to a generated-thrift type. */
+  private getThriftType(compactType: number): thrift.Thrift.Type {
+    switch (compactType) {
+      case COMPACT_TYPE_STOP:
+        return thrift.Thrift.Type.STOP;
+      case COMPACT_TYPE_BOOLEAN_TRUE:
+      case COMPACT_TYPE_BOOLEAN_FALSE:
+        return thrift.Thrift.Type.BOOL;
+      case COMPACT_TYPE_BYTE:
+        return thrift.Thrift.Type.BYTE;
+      case COMPACT_TYPE_I16:
+        return thrift.Thrift.Type.I16;
+      case COMPACT_TYPE_I32:
+        return thrift.Thrift.Type.I32;
+      case COMPACT_TYPE_I64:
+        return thrift.Thrift.Type.I64;
+      case COMPACT_TYPE_DOUBLE:
+        return thrift.Thrift.Type.DOUBLE;
+      case COMPACT_TYPE_BINARY:
+        return thrift.Thrift.Type.STRING;
+      case COMPACT_TYPE_LIST:
+        return thrift.Thrift.Type.LIST;
+      case COMPACT_TYPE_SET:
+        return thrift.Thrift.Type.SET;
+      case COMPACT_TYPE_MAP:
+        return thrift.Thrift.Type.MAP;
+      case COMPACT_TYPE_STRUCT:
+        return thrift.Thrift.Type.STRUCT;
+      default:
+        throw new Error(`Unknown compact thrift type: ${compactType}`);
+    }
+  }
+
+  /** Skip every field in the current struct. */
+  private skipStruct(): void {
+    this.readStructBegin();
+    while (true) {
+      const field = this.readFieldBegin();
+      if (field.ftype === thrift.Thrift.Type.STOP) {
+        break;
+      }
+      this.skip(field.ftype);
+      this.readFieldEnd();
+    }
+    this.readStructEnd();
+  }
+
+  /** Skip every key and value in the current map. */
+  private skipMap(): void {
+    const map = this.readMapBegin();
+    for (let index = 0; index < map.size; index++) {
+      this.skip(map.ktype);
+      this.skip(map.vtype);
+    }
+    this.readMapEnd();
+  }
+
+  /** Skip every element in the current list or set. */
+  private skipList(): void {
+    const list = this.readListBegin();
+    for (let index = 0; index < list.size; index++) {
+      this.skip(list.etype);
+    }
+    this.readListEnd();
+  }
+}