@loaders.gl/parquet 4.2.0-alpha.5 → 4.2.0-beta.1

package/dist/index.cjs

@@ -5,6 +5,7 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -26,6 +27,10 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
 
 // dist/index.js
 var dist_exports = {};
@@ -57,21 +62,30 @@ var import_base64_js = __toESM(require("base64-js"), 1);
 var import_ieee754 = __toESM(require("ieee754"), 1);
 var kMaxLength = 2147483647;
 var INSPECT_MAX_BYTES = 50;
-var Buffer2 = class extends Uint8Array {
+var _Buffer = class extends Uint8Array {
+  // not used by this implementation
   // length: number; inherited
   get parent() {
-    if (!Buffer2.isBuffer(this))
+    if (!_Buffer.isBuffer(this))
       return void 0;
     return this.buffer;
   }
   get offset() {
-    if (!Buffer2.isBuffer(this))
+    if (!_Buffer.isBuffer(this))
       return void 0;
     return this.byteOffset;
   }
+  /** This property is used by `Buffer.isBuffer` (and the `is-buffer` npm package)
+   * to detect a Buffer instance. It's not possible to use `instanceof Buffer`
+   * reliably in a browserify context because there could be multiple different
+   * copies of the 'buffer' package in use. This method works even for Buffer
+   * instances that were created from another copy of the `buffer` package.
+   * @see: https://github.com/feross/buffer/issues/154
+   */
+  _isBuffer = true;
   constructor(arg, encodingOrOffset, length) {
     if (typeof arg !== "number") {
-      return Buffer2.from(arg, encodingOrOffset, length);
+      return _Buffer.from(arg, encodingOrOffset, length);
     }
     const size = arg;
     if (size > kMaxLength) {
@@ -81,7 +95,6 @@ var Buffer2 = class extends Uint8Array {
       throw new TypeError('The "string" argument must be of type string. Received type number');
     }
     super(size < 0 ? 0 : checked(size) | 0);
-    this._isBuffer = true;
     return;
   }
   static from(value, encodingOrOffset, length) {
@@ -105,13 +118,13 @@ var Buffer2 = class extends Uint8Array {
     }
     const valueOf = value.valueOf && value.valueOf();
     if (valueOf != null && valueOf !== value) {
-      return Buffer2.from(valueOf, encodingOrOffset, length);
+      return _Buffer.from(valueOf, encodingOrOffset, length);
     }
     const b = fromObject(value);
     if (b)
       return b;
     if (typeof Symbol !== "undefined" && Symbol.toPrimitive != null && typeof value[Symbol.toPrimitive] === "function") {
-      return Buffer2.from(value[Symbol.toPrimitive]("string"), encodingOrOffset, length);
+      return _Buffer.from(value[Symbol.toPrimitive]("string"), encodingOrOffset, length);
     }
     throw new TypeError(`${"The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type "}${typeof value}`);
   }
@@ -121,17 +134,17 @@ var Buffer2 = class extends Uint8Array {
    * @param obj object to test.
    */
   static isBuffer(b) {
-    return b != null && b._isBuffer === true && b !== Buffer2.prototype;
+    return b != null && b._isBuffer === true && b !== _Buffer.prototype;
   }
   /**
    * The same as buf1.compare(buf2).
    */
   static compare(a, b) {
-    if (!Buffer2.isBuffer(a) && isInstance(a, Uint8Array))
-      a = Buffer2.from(a, a.offset, a.byteLength);
-    if (!Buffer2.isBuffer(b) && isInstance(b, Uint8Array))
-      b = Buffer2.from(b, b.offset, b.byteLength);
-    if (!Buffer2.isBuffer(a) || !Buffer2.isBuffer(b)) {
+    if (!_Buffer.isBuffer(a) && isInstance(a, Uint8Array))
+      a = _Buffer.from(a, a.offset, a.byteLength);
+    if (!_Buffer.isBuffer(b) && isInstance(b, Uint8Array))
+      b = _Buffer.from(b, b.offset, b.byteLength);
+    if (!_Buffer.isBuffer(a) || !_Buffer.isBuffer(b)) {
       throw new TypeError('The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array');
     }
     if (a === b)
@@ -191,7 +204,7 @@ var Buffer2 = class extends Uint8Array {
       throw new TypeError('"list" argument must be an Array of Buffers');
     }
     if (list.length === 0) {
-      return Buffer2.alloc(0);
+      return _Buffer.alloc(0);
     }
     let i;
     if (length === void 0) {
@@ -200,20 +213,20 @@ var Buffer2 = class extends Uint8Array {
         length += list[i].length;
       }
     }
-    const buffer = Buffer2.allocUnsafe(length);
+    const buffer = _Buffer.allocUnsafe(length);
     let pos = 0;
     for (i = 0; i < list.length; ++i) {
       let buf = list[i];
       if (isInstance(buf, Uint8Array)) {
         if (pos + buf.length > buffer.length) {
-          if (!Buffer2.isBuffer(buf)) {
-            buf = Buffer2.from(buf.buffer, buf.byteOffset, buf.byteLength);
+          if (!_Buffer.isBuffer(buf)) {
+            buf = _Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength);
           }
           buf.copy(buffer, pos);
         } else {
           Uint8Array.prototype.set.call(buffer, buf, pos);
         }
-      } else if (!Buffer2.isBuffer(buf)) {
+      } else if (!_Buffer.isBuffer(buf)) {
         throw new TypeError('"list" argument must be an Array of Buffers');
       } else {
         buf.copy(buffer, pos);
@@ -241,7 +254,7 @@ var Buffer2 = class extends Uint8Array {
    */
   static allocUnsafe(size) {
     assertSize(size);
-    return new Buffer2(size);
+    return new _Buffer(size);
   }
   /**
    * Allocates a new non-pooled buffer of {size} octets, leaving memory not initialized, so the contents
@@ -707,7 +720,7 @@ var Buffer2 = class extends Uint8Array {
   }
   // copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)
   copy(target, targetStart, start, end) {
-    if (!Buffer2.isBuffer(target))
+    if (!_Buffer.isBuffer(target))
       throw new TypeError("argument should be a Buffer");
     if (!start)
       start = 0;
@@ -760,7 +773,7 @@ var Buffer2 = class extends Uint8Array {
       if (encoding !== void 0 && typeof encoding !== "string") {
         throw new TypeError("encoding must be a string");
       }
-      if (typeof encoding === "string" && !Buffer2.isEncoding(encoding)) {
+      if (typeof encoding === "string" && !_Buffer.isEncoding(encoding)) {
         throw new TypeError(`Unknown encoding: ${encoding}`);
       }
       if (val.length === 1) {
@@ -790,7 +803,7 @@ var Buffer2 = class extends Uint8Array {
         this[i] = val;
       }
     } else {
-      const bytes = Buffer2.isBuffer(val) ? val : Buffer2.from(val, encoding);
+      const bytes = _Buffer.isBuffer(val) ? val : _Buffer.from(val, encoding);
       const len = bytes.length;
       if (len === 0) {
         throw new TypeError(`The value "${val}" is invalid for argument "value"`);
@@ -861,17 +874,17 @@ var Buffer2 = class extends Uint8Array {
   // }
   // }
   equals(b) {
-    if (!Buffer2.isBuffer(b))
+    if (!_Buffer.isBuffer(b))
       throw new TypeError("Argument must be a Buffer");
     if (this === b)
       return true;
-    return Buffer2.compare(this, b) === 0;
+    return _Buffer.compare(this, b) === 0;
   }
   compare(target, start, end, thisStart, thisEnd) {
-    if (!Buffer2.isBuffer(target) && isInstance(target, Uint8Array)) {
-      target = Buffer2.from(target, target.offset, target.byteLength);
+    if (!_Buffer.isBuffer(target) && isInstance(target, Uint8Array)) {
+      target = _Buffer.from(target, target.offset, target.byteLength);
     }
-    if (!Buffer2.isBuffer(target)) {
+    if (!_Buffer.isBuffer(target)) {
       throw new TypeError(`${'The "target" argument must be one of type Buffer or Uint8Array. Received type '}${typeof target}`);
     }
     if (start === void 0) {
@@ -949,7 +962,7 @@ var Buffer2 = class extends Uint8Array {
     if (end < start)
       end = start;
     const newBuf = this.subarray(start, end);
-    Object.setPrototypeOf(newBuf, Buffer2.prototype);
+    Object.setPrototypeOf(newBuf, _Buffer.prototype);
     return newBuf;
   }
   // Typo support?
@@ -1024,7 +1037,8 @@ var Buffer2 = class extends Uint8Array {
     }
   }
 };
-Buffer2.poolSize = 8192;
+var Buffer2 = _Buffer;
+__publicField(Buffer2, "poolSize", 8192);
 function checkInt(buf, value, offset, ext, max, min) {
   if (!Buffer2.isBuffer(buf))
     throw new TypeError('"buffer" argument must be a Buffer instance');
@@ -1729,7 +1743,7 @@ globalThis.process.env = globalThis.process.env || {};
 var Buffer3 = installBufferPolyfill();
 
 // dist/parquet-loader.js
-var import_loader_utils = require("@loaders.gl/loader-utils");
+var import_loader_utils2 = require("@loaders.gl/loader-utils");
 
 // dist/parquetjs/codecs/plain.js
 var import_int53 = __toESM(require("int53"), 1);
@@ -2088,6 +2102,7 @@ var PARQUET_CODECS = {
 
 // dist/parquetjs/compression.js
 var import_compression = require("@loaders.gl/compression");
+var import_loader_utils = require("@loaders.gl/loader-utils");
 var import_lz4js = __toESM(require("lz4js"), 1);
 function toBuffer(arrayBuffer) {
   return Buffer.from(arrayBuffer);
@@ -2124,8 +2139,9 @@ var PARQUET_COMPRESSION_METHODS = {
   ZSTD: new import_compression.ZstdCompression({ modules })
 };
 async function preloadCompressions(options) {
+  (0, import_loader_utils.registerJSModules)(options == null ? void 0 : options.modules);
   const compressions = Object.values(PARQUET_COMPRESSION_METHODS);
-  return await Promise.all(compressions.map((compression) => compression.preload()));
+  return await Promise.all(compressions.map((compression) => compression.preload(options == null ? void 0 : options.modules)));
 }
 async function deflate(method, value) {
   const compression = PARQUET_COMPRESSION_METHODS[method];
@@ -2773,6 +2789,9 @@ function materializeColumnAsColumnarArray(schema, columnData, rowCount, key, col
 
 // dist/parquetjs/schema/schema.js
 var ParquetSchema = class {
+  schema;
+  fields;
+  fieldList;
   /**
    * Create a new schema from a JSON schema definition
    */
@@ -3004,6 +3023,12 @@ var PageType;
 var import_node_int64 = __toESM(require("node-int64"), 1);
 var thrift = __toESM(require("thrift"), 1);
 var Statistics = class {
+  max;
+  min;
+  null_count;
+  distinct_count;
+  max_value;
+  min_value;
   constructor(args) {
     if (args != null && args.max != null) {
       this.max = args.max;
@@ -3365,6 +3390,8 @@ var NullType = class {
 // dist/parquetjs/parquet-thrift/DecimalType.js
 var thrift9 = __toESM(require("thrift"), 1);
 var DecimalType = class {
+  scale;
+  precision;
   constructor(args) {
     if (args != null && args.scale != null) {
       this.scale = args.scale;
@@ -3505,6 +3532,8 @@ var thrift13 = __toESM(require("thrift"), 1);
 // dist/parquetjs/parquet-thrift/TimeUnit.js
 var thrift12 = __toESM(require("thrift"), 1);
 var TimeUnit = class {
+  MILLIS;
+  MICROS;
   constructor(args) {
     let _fieldsSet = 0;
     if (args != null) {
@@ -3597,6 +3626,8 @@ var TimeUnit = class {
 
 // dist/parquetjs/parquet-thrift/TimestampType.js
 var TimestampType = class {
+  isAdjustedToUTC;
+  unit;
   constructor(args) {
     if (args != null && args.isAdjustedToUTC != null) {
       this.isAdjustedToUTC = args.isAdjustedToUTC;
@@ -3670,6 +3701,8 @@ var TimestampType = class {
 // dist/parquetjs/parquet-thrift/TimeType.js
 var thrift14 = __toESM(require("thrift"), 1);
 var TimeType = class {
+  isAdjustedToUTC;
+  unit;
   constructor(args) {
     if (args != null && args.isAdjustedToUTC != null) {
       this.isAdjustedToUTC = args.isAdjustedToUTC;
@@ -3743,6 +3776,8 @@ var TimeType = class {
 // dist/parquetjs/parquet-thrift/IntType.js
 var thrift15 = __toESM(require("thrift"), 1);
 var IntType = class {
+  bitWidth;
+  isSigned;
   constructor(args) {
     if (args != null && args.bitWidth != null) {
       this.bitWidth = args.bitWidth;
@@ -3883,6 +3918,19 @@ var thrift19 = __toESM(require("thrift"), 1);
 // dist/parquetjs/parquet-thrift/LogicalType.js
 var thrift18 = __toESM(require("thrift"), 1);
 var LogicalType = class {
+  STRING;
+  MAP;
+  LIST;
+  ENUM;
+  DECIMAL;
+  DATE;
+  TIME;
+  TIMESTAMP;
+  INTEGER;
+  UNKNOWN;
+  JSON;
+  BSON;
+  UUID;
   constructor(args) {
     let _fieldsSet = 0;
     if (args != null) {
@@ -4206,6 +4254,16 @@ var LogicalType = class {
 
 // dist/parquetjs/parquet-thrift/SchemaElement.js
 var SchemaElement = class {
+  type;
+  type_length;
+  repetition_type;
+  name;
+  num_children;
+  converted_type;
+  scale;
+  precision;
+  field_id;
+  logicalType;
   constructor(args) {
     if (args != null && args.type != null) {
       this.type = args.type;
@@ -4405,6 +4463,11 @@ var SchemaElement = class {
 // dist/parquetjs/parquet-thrift/DataPageHeader.js
 var thrift20 = __toESM(require("thrift"), 1);
 var DataPageHeader = class {
+  num_values;
+  encoding;
+  definition_level_encoding;
+  repetition_level_encoding;
+  statistics;
   constructor(args) {
     if (args != null && args.num_values != null) {
       this.num_values = args.num_values;
@@ -4562,6 +4625,9 @@ var IndexPageHeader = class {
 // dist/parquetjs/parquet-thrift/DictionaryPageHeader.js
 var thrift22 = __toESM(require("thrift"), 1);
 var DictionaryPageHeader = class {
+  num_values;
+  encoding;
+  is_sorted;
   constructor(args) {
     if (args != null && args.num_values != null) {
       this.num_values = args.num_values;
@@ -4651,8 +4717,15 @@ var DictionaryPageHeader = class {
 // dist/parquetjs/parquet-thrift/DataPageHeaderV2.js
 var thrift23 = __toESM(require("thrift"), 1);
 var DataPageHeaderV2 = class {
+  num_values;
+  num_nulls;
+  num_rows;
+  encoding;
+  definition_levels_byte_length;
+  repetition_levels_byte_length;
+  is_compressed = true;
+  statistics;
   constructor(args) {
-    this.is_compressed = true;
     if (args != null && args.num_values != null) {
       this.num_values = args.num_values;
     } else {
@@ -4829,6 +4902,14 @@ var DataPageHeaderV2 = class {
 // dist/parquetjs/parquet-thrift/PageHeader.js
 var thrift24 = __toESM(require("thrift"), 1);
 var PageHeader = class {
+  type;
+  uncompressed_page_size;
+  compressed_page_size;
+  crc;
+  data_page_header;
+  index_page_header;
+  dictionary_page_header;
+  data_page_header_v2;
   constructor(args) {
     if (args != null && args.type != null) {
       this.type = args.type;
@@ -5000,6 +5081,8 @@ var PageHeader = class {
 // dist/parquetjs/parquet-thrift/KeyValue.js
 var thrift25 = __toESM(require("thrift"), 1);
 var KeyValue = class {
+  key;
+  value;
   constructor(args) {
     if (args != null && args.key != null) {
       this.key = args.key;
@@ -5071,6 +5154,9 @@ var KeyValue = class {
 // dist/parquetjs/parquet-thrift/SortingColumn.js
 var thrift26 = __toESM(require("thrift"), 1);
 var SortingColumn = class {
+  column_idx;
+  descending;
+  nulls_first;
   constructor(args) {
     if (args != null && args.column_idx != null) {
       this.column_idx = args.column_idx;
@@ -5162,6 +5248,9 @@ var SortingColumn = class {
 // dist/parquetjs/parquet-thrift/PageEncodingStats.js
 var thrift27 = __toESM(require("thrift"), 1);
 var PageEncodingStats = class {
+  page_type;
+  encoding;
+  count;
   constructor(args) {
     if (args != null && args.page_type != null) {
       this.page_type = args.page_type;
@@ -5254,6 +5343,19 @@ var PageEncodingStats = class {
 var import_node_int642 = __toESM(require("node-int64"), 1);
 var thrift28 = __toESM(require("thrift"), 1);
 var ColumnMetaData = class {
+  type;
+  encodings;
+  path_in_schema;
+  codec;
+  num_values;
+  total_uncompressed_size;
+  total_compressed_size;
+  key_value_metadata;
+  data_page_offset;
+  index_page_offset;
+  dictionary_page_offset;
+  statistics;
+  encoding_stats;
   constructor(args) {
     if (args != null && args.type != null) {
       this.type = args.type;
@@ -5584,6 +5686,13 @@ var ColumnMetaData = class {
 var import_node_int643 = __toESM(require("node-int64"), 1);
 var thrift29 = __toESM(require("thrift"), 1);
 var ColumnChunk = class {
+  file_path;
+  file_offset;
+  meta_data;
+  offset_index_offset;
+  offset_index_length;
+  column_index_offset;
+  column_index_length;
   constructor(args) {
     if (args != null && args.file_path != null) {
       this.file_path = args.file_path;
@@ -5748,6 +5857,10 @@ var ColumnChunk = class {
 var import_node_int644 = __toESM(require("node-int64"), 1);
 var thrift30 = __toESM(require("thrift"), 1);
 var RowGroup = class {
+  columns;
+  total_byte_size;
+  num_rows;
+  sorting_columns;
   constructor(args) {
     if (args != null && args.columns != null) {
       this.columns = args.columns;
@@ -5921,6 +6034,7 @@ var thrift33 = __toESM(require("thrift"), 1);
 // dist/parquetjs/parquet-thrift/ColumnOrder.js
 var thrift32 = __toESM(require("thrift"), 1);
 var ColumnOrder = class {
+  TYPE_ORDER;
   constructor(args) {
     let _fieldsSet = 0;
     if (args != null) {
@@ -5992,6 +6106,13 @@ var ColumnOrder = class {
 
 // dist/parquetjs/parquet-thrift/FileMetaData.js
 var FileMetaData = class {
+  version;
+  schema;
+  num_rows;
+  row_groups;
+  key_value_metadata;
+  created_by;
+  column_orders;
   constructor(args = null) {
     if (args != null && args.version != null) {
       this.version = args.version;
@@ -6195,7 +6316,7 @@ var FileMetaData = class {
 };
 
 // dist/lib/constants.js
-var VERSION = true ? "4.2.0-alpha.4" : "latest";
+var VERSION = true ? "4.2.0-alpha.6" : "latest";
 var PARQUET_WASM_URL = "https://unpkg.com/parquet-wasm@0.6.0-beta.1/esm/arrow1_bg.wasm";
 var PARQUET_MAGIC = "PAR1";
 var PARQUET_MAGIC_ENCRYPTED = "PARE";
@@ -6204,10 +6325,7 @@ var PARQUET_RDLVL_ENCODING = "RLE";
 
 // dist/parquetjs/utils/read-utils.js
 var UFramedTransport = class extends import_thrift.TFramedTransport {
-  constructor() {
-    super(...arguments);
-    this.readPos = 0;
-  }
+  readPos = 0;
 };
 function serializeThrift(obj) {
   const output = [];
@@ -6547,11 +6665,13 @@ function preserveBinary(d) {
 }
 
 // dist/parquetjs/parser/parquet-reader.js
-var ParquetReader = class {
+var _ParquetReader = class {
+  props;
+  file;
+  metadata = null;
   constructor(file, props) {
-    this.metadata = null;
     this.file = file;
-    this.props = { ...ParquetReader.defaultProps, ...props };
+    this.props = { ..._ParquetReader.defaultProps, ...props };
   }
   close() {
     this.file.close();
@@ -6723,10 +6843,12 @@ var ParquetReader = class {
     return decodedPage.dictionary;
   }
 };
-ParquetReader.defaultProps = {
-  defaultDictionarySize: 1e6,
+var ParquetReader = _ParquetReader;
+__publicField(ParquetReader, "defaultProps", {
+  // max ArrayBuffer size in js is 2Gb
+  defaultDictionarySize: 2147483648,
   preserveBinary: false
-};
+});
 
 // dist/lib/arrow/convert-schema-from-parquet.js
 var PARQUET_TYPE_MAPPING = {
@@ -6825,6 +6947,7 @@ async function getSchemaFromParquetReader(reader) {
 async function parseParquetFile(file, options) {
   var _a, _b;
   installBufferPolyfill();
+  await preloadCompressions(options);
   const reader = new ParquetReader(file, {
     preserveBinary: (_a = options == null ? void 0 : options.parquet) == null ? void 0 : _a.preserveBinary
   });
@@ -6846,6 +6969,8 @@ async function parseParquetFile(file, options) {
 }
 async function* parseParquetFileInBatches(file, options) {
   var _a, _b;
+  installBufferPolyfill();
+  await preloadCompressions(options);
   const reader = new ParquetReader(file, {
     preserveBinary: (_a = options == null ? void 0 : options.parquet) == null ? void 0 : _a.preserveBinary
   });
@@ -6937,6 +7062,7 @@ function convertBatch(objectRowBatch, shape) {
 // dist/lib/parsers/parse-parquet-to-columns.js
 async function parseParquetFileInColumns(file, options) {
   installBufferPolyfill();
+  await preloadCompressions(options);
   for await (const batch of parseParquetFileInColumnarBatches(file, options)) {
     return {
       shape: "columnar-table",
@@ -6947,6 +7073,8 @@ async function parseParquetFileInColumns(file, options) {
   throw new Error("empty table");
 }
 async function* parseParquetFileInColumnarBatches(file, options) {
+  installBufferPolyfill();
+  await preloadCompressions(options);
   const reader = new ParquetReader(file);
   const schema = await getSchemaFromParquetReader(reader);
   const parquetSchema = await reader.getSchema();
@@ -6967,8 +7095,10 @@ function convertRowGroupToTableBatch(rowGroup, parquetSchema, schema) {
 }
 
 // dist/parquet-loader.js
-var VERSION2 = true ? "4.2.0-alpha.4" : "latest";
+var VERSION2 = true ? "4.2.0-alpha.6" : "latest";
 var ParquetWorkerLoader = {
+  dataType: null,
+  batchType: null,
   name: "Apache Parquet",
   id: "parquet",
   module: "parquet",
@@ -6991,12 +7121,16 @@ var ParquetWorkerLoader = {
 };
 var ParquetLoader = {
   ...ParquetWorkerLoader,
-  parse: (arrayBuffer, options) => parseParquetFile(new import_loader_utils.BlobFile(arrayBuffer), options),
+  dataType: null,
+  batchType: null,
+  parse: (arrayBuffer, options) => parseParquetFile(new import_loader_utils2.BlobFile(arrayBuffer), options),
   parseFile: parseParquetFile,
   parseFileInBatches: parseParquetFileInBatches
 };
 ParquetLoader.Buffer = Buffer;
 var GeoParquetWorkerLoader = {
+  dataType: null,
+  batchType: null,
   name: "Apache Parquet",
   id: "parquet",
   module: "parquet",
@@ -7020,12 +7154,14 @@ var GeoParquetWorkerLoader = {
 var GeoParquetLoader = {
   ...GeoParquetWorkerLoader,
   parse(arrayBuffer, options) {
-    return parseGeoParquetFile(new import_loader_utils.BlobFile(arrayBuffer), options);
+    return parseGeoParquetFile(new import_loader_utils2.BlobFile(arrayBuffer), options);
   },
   parseFile: parseGeoParquetFile,
   parseFileInBatches: parseGeoParquetFileInBatches
 };
 var ParquetColumnarWorkerLoader = {
+  dataType: null,
+  batchType: null,
   name: "Apache Parquet",
   id: "parquet",
   module: "parquet",
@@ -7041,14 +7177,14 @@ var ParquetColumnarWorkerLoader = {
 var ParquetColumnarLoader = {
   ...ParquetColumnarWorkerLoader,
   parse(arrayBuffer, options) {
-    return parseParquetFileInColumns(new import_loader_utils.BlobFile(arrayBuffer), options);
+    return parseParquetFileInColumns(new import_loader_utils2.BlobFile(arrayBuffer), options);
   },
   parseFile: parseParquetFileInColumns,
   parseFileInBatches: parseParquetFileInColumnarBatches
 };
 
 // dist/parquet-writer.js
-var VERSION3 = true ? "4.2.0-alpha.4" : "latest";
+var VERSION3 = true ? "4.2.0-alpha.6" : "latest";
 var ParquetWriter = {
   name: "Apache Parquet",
   id: "parquet",
@@ -7105,6 +7241,8 @@ async function parseParquetWasm(arrayBuffer, options) {
 
 // dist/parquet-wasm-loader.js
 var ParquetWasmWorkerLoader = {
+  dataType: null,
+  batchType: null,
   name: "Apache Parquet",
   id: "parquet-wasm",
   module: "parquet",
@@ -7224,6 +7362,12 @@ var ParquetEncoder = class {
     const envelopeWriter = await ParquetEnvelopeWriter.openStream(schema, outputStream, opts);
     return new ParquetEncoder(schema, envelopeWriter, opts);
   }
+  schema;
+  envelopeWriter;
+  rowBuffer;
+  rowGroupSize;
+  closed;
+  userMetadata;
   /**
    * Create a new buffered parquet writer for a given envelope writer
    */
@@ -7309,6 +7453,14 @@ var ParquetEnvelopeWriter = class {
     const closeFn = osclose.bind(void 0, outputStream);
     return new ParquetEnvelopeWriter(schema, writeFn, closeFn, 0, opts);
   }
+  schema;
+  write;
+  close;
+  offset;
+  rowCount;
+  rowGroups;
+  pageSize;
+  useDataPageV2;
   constructor(schema, writeFn, closeFn, fileOffset, opts) {
     this.schema = schema;
     this.write = writeFn;