@loaders.gl/arrow 4.0.0-beta.2 → 4.0.0-beta.4

package/dist/arrow-worker.js

@@ -1,15 +1,14 @@
+"use strict";
 (() => {
   var __defProp = Object.defineProperty;
-  var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
   var __export = (target, all) => {
-    __markAsModule(target);
     for (var name in all)
       __defProp(target, name, { get: all[name], enumerable: true });
   };
 
   // ../worker-utils/src/lib/worker-utils/get-transfer-list.ts
   function getTransferList(object, recursive = true, transfers) {
-    const transfersSet = transfers || new Set();
+    const transfersSet = transfers || /* @__PURE__ */ new Set();
     if (!object) {
     } else if (isTransferable(object)) {
       transfersSet.add(object);
@@ -52,11 +51,15 @@
     }
     return parentPort;
   }
-  var onMessageWrapperMap = new Map();
+  var onMessageWrapperMap = /* @__PURE__ */ new Map();
   var WorkerBody = class {
+    /** Check that we are actually in a worker thread */
     static inWorkerThread() {
       return typeof self !== "undefined" || Boolean(getParentPort());
     }
+    /*
+     * (type: WorkerMessageType, payload: WorkerMessagePayload) => any
+     */
     static set onmessage(onMessage) {
       function handleMessage(message) {
         const parentPort3 = getParentPort();
@@ -100,6 +103,11 @@
         globalThis.removeEventListener("message", onMessageWrapper);
       }
     }
+    /**
+     * Send a message from a worker to creating thread (main thread)
+     * @param type
+     * @param payload
+     */
     static postMessage(type, payload) {
       const data = { source: "loaders.gl", type, payload };
       const transferList = getTransferList(payload);
@@ -131,6 +139,7 @@
               loader,
               arrayBuffer: input,
               options,
+              // @ts-expect-error fetch missing
               context: {
                 ...context,
                 _parse: parseOnMainThread
@@ -398,6 +407,7 @@
       };
       return batch;
     }
+    // HELPERS
     _reallocateColumns() {
       if (this.length < this.allocated) {
         return;
@@ -458,6 +468,7 @@
       }
       return false;
     }
+    /** @deprecated Use addArrayRow or addObjectRow */
     addRow(row) {
       if (this.limitReached()) {
         return;
@@ -471,6 +482,7 @@
         this.addObjectRow(row);
       }
     }
+    /** Add one row to the batch */
     addArrayRow(row) {
       if (!this.aggregator) {
         const TableBatchType = this._getTableBatchType();
@@ -478,6 +490,7 @@
       }
       this.aggregator.addArrayRow(row);
     }
+    /** Add one row to the batch */
     addObjectRow(row) {
       if (!this.aggregator) {
         const TableBatchType = this._getTableBatchType();
@@ -485,6 +498,7 @@
       }
       this.aggregator.addObjectRow(row);
     }
+    /** Mark an incoming raw memory chunk has completed */
     chunkComplete(chunk) {
       if (chunk instanceof ArrayBuffer) {
         this.bytesUsed += chunk.byteLength;
@@ -500,6 +514,7 @@
     getFinalBatch(options) {
       return this._getBatch(options);
     }
+    // INTERNAL
     _estimateRowMB(row) {
       return Array.isArray(row) ? row.length * 8 : Object.keys(row).length * 8;
     }
@@ -521,6 +536,9 @@
       this.lastBatchEmittedMs = Date.now();
       return true;
     }
+    /**
+     * bytesUsed can be set via chunkComplete or via getBatch*
+     */
     _getBatch(options) {
       if (!this.aggregator) {
         return null;
@@ -590,7 +608,9 @@
         return column[rowIndex];
       case "arrow-table":
         const arrowTable = table.data;
-        const arrowColumnIndex = arrowTable.schema.fields.findIndex((field) => field.name === columnName);
+        const arrowColumnIndex = arrowTable.schema.fields.findIndex(
+          (field) => field.name === columnName
+        );
         return arrowTable.getChildAt(arrowColumnIndex)?.get(rowIndex);
       default:
         throw new Error("todo");
@@ -819,6 +839,7 @@
         name,
         type: type.type || "null",
         nullable: type.nullable
+        // metadata: {}
       };
     }
     if (Array.isArray(column) && column.length > 0) {
@@ -828,6 +849,7 @@
         name,
         type,
         nullable: true
+        // metadata: {},
       };
     }
     throw new Error("empty table");
@@ -838,6 +860,7 @@
       name,
       type,
       nullable: true
+      // metadata: {}
     };
   }
 
@@ -921,7 +944,31 @@
     };
   }
 
-  // ../../node_modules/apache-arrow/node_modules/tslib/tslib.es6.mjs
+  // src/arrow-loader.ts
+  var VERSION = true ? "4.0.0-beta.4" : "latest";
+  var ArrowLoader = {
+    name: "Apache Arrow",
+    id: "arrow",
+    module: "arrow",
+    version: VERSION,
+    // worker: true,
+    category: "table",
+    extensions: ["arrow", "feather"],
+    mimeTypes: [
+      "application/vnd.apache.arrow.file",
+      "application/vnd.apache.arrow.stream",
+      "application/octet-stream"
+    ],
+    binary: true,
+    tests: ["ARROW"],
+    options: {
+      arrow: {
+        shape: "columnar-table"
+      }
+    }
+  };
+
+  // ../../node_modules/tslib/tslib.es6.mjs
   function __rest(s, e) {
     var t = {};
     for (var p in s)
@@ -1273,14 +1320,17 @@
         });
       };
       const buffers = typeof source === "string" ? wrap(source) : ArrayBuffer.isView(source) ? wrap(source) : source instanceof ArrayBuffer ? wrap(source) : source instanceof SharedArrayBuf ? wrap(source) : isIterable(source) ? emit(source) : !isAsyncIterable(source) ? wrap(source) : source;
-      yield __await(yield* __asyncDelegator(__asyncValues(pump(function(it) {
-        return __asyncGenerator(this, arguments, function* () {
-          let r = null;
-          do {
-            r = yield __await(it.next(yield yield __await(toArrayBufferView(ArrayCtor, r))));
-          } while (!r.done);
-        });
-      }(buffers[Symbol.asyncIterator]())))));
+      yield __await(
+        // otherwise if AsyncIterable, use it
+        yield* __asyncDelegator(__asyncValues(pump(function(it) {
+          return __asyncGenerator(this, arguments, function* () {
+            let r = null;
+            do {
+              r = yield __await(it.next(yield yield __await(toArrayBufferView(ArrayCtor, r))));
+            } while (!r.done);
+          });
+        }(buffers[Symbol.asyncIterator]()))))
+      );
       return yield __await(new ArrayCtor());
     });
   }
@@ -1332,9 +1382,11 @@
     fromNodeStream(stream) {
       return pump2(fromNodeStream(stream));
     },
+    // @ts-ignore
     toDOMStream(source, options) {
       throw new Error(`"toDOMStream" not available in this environment`);
     },
+    // @ts-ignore
     toNodeStream(source, options) {
       throw new Error(`"toNodeStream" not available in this environment`);
     }
@@ -1819,6 +1871,7 @@
     return digits !== null && digits !== void 0 ? digits : `0`;
   }
   var BN = class {
+    /** @nocollapse */
     static new(num, isSigned) {
       switch (isSigned) {
         case true:
@@ -1838,12 +1891,15 @@
       }
       return new UnsignedBigNum(num);
     }
+    /** @nocollapse */
     static signed(num) {
       return new SignedBigNum(num);
     }
+    /** @nocollapse */
     static unsigned(num) {
       return new UnsignedBigNum(num);
     }
+    /** @nocollapse */
     static decimal(num) {
       return new DecimalBigNum(num);
     }
@@ -1881,63 +1937,83 @@
   var _t;
   var _u;
   var DataType = class {
+    /** @nocollapse */
     static isNull(x) {
       return (x === null || x === void 0 ? void 0 : x.typeId) === Type.Null;
     }
+    /** @nocollapse */
     static isInt(x) {
       return (x === null || x === void 0 ? void 0 : x.typeId) === Type.Int;
     }
+    /** @nocollapse */
     static isFloat(x) {
       return (x === null || x === void 0 ? void 0 : x.typeId) === Type.Float;
     }
+    /** @nocollapse */
     static isBinary(x) {
       return (x === null || x === void 0 ? void 0 : x.typeId) === Type.Binary;
     }
+    /** @nocollapse */
     static isUtf8(x) {
       return (x === null || x === void 0 ? void 0 : x.typeId) === Type.Utf8;
     }
+    /** @nocollapse */
     static isBool(x) {
       return (x === null || x === void 0 ? void 0 : x.typeId) === Type.Bool;
     }
+    /** @nocollapse */
     static isDecimal(x) {
       return (x === null || x === void 0 ? void 0 : x.typeId) === Type.Decimal;
     }
+    /** @nocollapse */
     static isDate(x) {
       return (x === null || x === void 0 ? void 0 : x.typeId) === Type.Date;
     }
+    /** @nocollapse */
     static isTime(x) {
       return (x === null || x === void 0 ? void 0 : x.typeId) === Type.Time;
     }
+    /** @nocollapse */
     static isTimestamp(x) {
       return (x === null || x === void 0 ? void 0 : x.typeId) === Type.Timestamp;
     }
+    /** @nocollapse */
     static isInterval(x) {
       return (x === null || x === void 0 ? void 0 : x.typeId) === Type.Interval;
     }
+    /** @nocollapse */
     static isList(x) {
       return (x === null || x === void 0 ? void 0 : x.typeId) === Type.List;
     }
+    /** @nocollapse */
     static isStruct(x) {
       return (x === null || x === void 0 ? void 0 : x.typeId) === Type.Struct;
     }
+    /** @nocollapse */
     static isUnion(x) {
       return (x === null || x === void 0 ? void 0 : x.typeId) === Type.Union;
     }
+    /** @nocollapse */
     static isFixedSizeBinary(x) {
       return (x === null || x === void 0 ? void 0 : x.typeId) === Type.FixedSizeBinary;
     }
+    /** @nocollapse */
     static isFixedSizeList(x) {
       return (x === null || x === void 0 ? void 0 : x.typeId) === Type.FixedSizeList;
     }
+    /** @nocollapse */
     static isMap(x) {
       return (x === null || x === void 0 ? void 0 : x.typeId) === Type.Map;
     }
+    /** @nocollapse */
     static isDictionary(x) {
       return (x === null || x === void 0 ? void 0 : x.typeId) === Type.Dictionary;
     }
+    /** @nocollapse */
     static isDenseUnion(x) {
       return DataType.isUnion(x) && x.mode === UnionMode.Dense;
     }
+    /** @nocollapse */
     static isSparseUnion(x) {
       return DataType.isUnion(x) && x.mode === UnionMode.Sparse;
     }
@@ -2313,7 +2389,7 @@
       this.mode = mode;
       this.children = children;
       this.typeIds = typeIds = Int32Array.from(typeIds);
-      this.typeIdToChildIndex = typeIds.reduce((typeIdToChildIndex, typeId, idx) => (typeIdToChildIndex[typeId] = idx) && typeIdToChildIndex || typeIdToChildIndex, Object.create(null));
+      this.typeIdToChildIndex = typeIds.reduce((typeIdToChildIndex, typeId, idx) => (typeIdToChildIndex[typeId] = idx) && typeIdToChildIndex || typeIdToChildIndex, /* @__PURE__ */ Object.create(null));
     }
     get typeId() {
       return Type.Union;
@@ -3635,7 +3711,10 @@
     const alignedSize = bitmap.byteLength + 7 & ~7;
     if (offset > 0 || bitmap.byteLength < alignedSize) {
       const bytes = new Uint8Array(alignedSize);
-      bytes.set(offset % 8 === 0 ? bitmap.subarray(offset >> 3) : packBools(new BitIterator(bitmap, offset, length, null, getBool2)).subarray(0, alignedSize));
+      bytes.set(offset % 8 === 0 ? bitmap.subarray(offset >> 3) : (
+        // Otherwise iterate each bit from the offset and return a new one
+        packBools(new BitIterator(bitmap, offset, length, null, getBool2)).subarray(0, alignedSize)
+      ));
       return bytes;
     }
     return bitmap;
@@ -3697,7 +3776,12 @@
     }
     const rhsInside = rhs >> 3 << 3;
     const lhsInside = lhs + (lhs % 8 === 0 ? 0 : 8 - lhs % 8);
-    return popcnt_bit_range(data, lhs, lhsInside) + popcnt_bit_range(data, rhsInside, rhs) + popcnt_array(data, lhsInside >> 3, rhsInside - lhsInside >> 3);
+    return (
+      // Get the popcnt of bits between the left hand side, and the next highest multiple of 8
+      popcnt_bit_range(data, lhs, lhsInside) + // Get the popcnt of bits between the right hand side, and the next lowest multiple of 8
+      popcnt_bit_range(data, rhsInside, rhs) + // Get the popcnt of all bits between the left and right hand sides' multiples of 8
+      popcnt_array(data, lhsInside >> 3, rhsInside - lhsInside >> 3)
+    );
   }
   function popcnt_array(arr, byteOffset, byteLength) {
     let cnt = 0, pos = Math.trunc(byteOffset);
@@ -3809,7 +3893,15 @@
       const nullCount = +(this._nullCount === 0) - 1;
       const childStride = typeId === 16 ? stride : 1;
       const buffers = this._sliceBuffers(offset, length, stride, typeId);
-      return this.clone(this.type, this.offset + offset, length, nullCount, buffers, children.length === 0 || this.valueOffsets ? children : this._sliceChildren(children, childStride * offset, childStride * length));
+      return this.clone(
+        this.type,
+        this.offset + offset,
+        length,
+        nullCount,
+        buffers,
+        // Don't slice children if we have value offsets (the variable-width types)
+        children.length === 0 || this.valueOffsets ? children : this._sliceChildren(children, childStride * offset, childStride * length)
+      );
     }
     _changeLengthAndBackfillNullBitmap(newLength) {
       if (this.typeId === Type.Null) {
@@ -3829,7 +3921,8 @@
       let arr;
       const { buffers } = this;
       (arr = buffers[BufferType.TYPE]) && (buffers[BufferType.TYPE] = arr.subarray(offset, offset + length));
-      (arr = buffers[BufferType.OFFSET]) && (buffers[BufferType.OFFSET] = arr.subarray(offset, offset + length + 1)) || (arr = buffers[BufferType.DATA]) && (buffers[BufferType.DATA] = typeId === 6 ? arr : arr.subarray(stride * offset, stride * (offset + length)));
+      (arr = buffers[BufferType.OFFSET]) && (buffers[BufferType.OFFSET] = arr.subarray(offset, offset + length + 1)) || // Otherwise if no offsets, slice the data buffer. Don't slice the data vector for Booleans, since the offset goes by bits not bytes
+      (arr = buffers[BufferType.DATA]) && (buffers[BufferType.DATA] = typeId === 6 ? arr : arr.subarray(stride * offset, stride * (offset + length)));
       return buffers;
     }
     _sliceChildren(children, offset, length) {
@@ -4392,57 +4485,123 @@
       this.numChildren = (_d2 = (_c2 = type.children) === null || _c2 === void 0 ? void 0 : _c2.length) !== null && _d2 !== void 0 ? _d2 : 0;
       this.length = this._offsets.at(-1);
     }
+    /**
+     * The aggregate size (in bytes) of this Vector's buffers and/or child Vectors.
+     */
     get byteLength() {
       if (this._byteLength === -1) {
         this._byteLength = this.data.reduce((byteLength, data) => byteLength + data.byteLength, 0);
       }
       return this._byteLength;
     }
+    /**
+     * The number of null elements in this Vector.
+     */
     get nullCount() {
       if (this._nullCount === -1) {
         this._nullCount = computeChunkNullCounts(this.data);
       }
       return this._nullCount;
     }
+    /**
+     * The Array or TypedArray constructor used for the JS representation
+     *  of the element's values in {@link Vector.prototype.toArray `toArray()`}.
+     */
     get ArrayType() {
       return this.type.ArrayType;
     }
+    /**
+     * The name that should be printed when the Vector is logged in a message.
+     */
     get [Symbol.toStringTag]() {
       return `${this.VectorName}<${this.type[Symbol.toStringTag]}>`;
     }
+    /**
+     * The name of this Vector.
+     */
     get VectorName() {
       return `${Type[this.type.typeId]}Vector`;
     }
+    /**
+     * Check whether an element is null.
+     * @param index The index at which to read the validity bitmap.
+     */
+    // @ts-ignore
     isValid(index) {
       return false;
     }
+    /**
+     * Get an element value by position.
+     * @param index The index of the element to read.
+     */
+    // @ts-ignore
     get(index) {
       return null;
     }
+    /**
+     * Set an element value by position.
+     * @param index The index of the element to write.
+     * @param value The value to set.
+     */
+    // @ts-ignore
     set(index, value) {
       return;
     }
+    /**
+     * Retrieve the index of the first occurrence of a value in an Vector.
+     * @param element The value to locate in the Vector.
+     * @param offset The index at which to begin the search. If offset is omitted, the search starts at index 0.
+     */
+    // @ts-ignore
     indexOf(element, offset) {
       return -1;
     }
     includes(element, offset) {
       return this.indexOf(element, offset) > 0;
     }
+    /**
+     * Get the size in bytes of an element by index.
+     * @param index The index at which to get the byteLength.
+     */
+    // @ts-ignore
     getByteLength(index) {
       return 0;
     }
+    /**
+     * Iterator for the Vector's elements.
+     */
     [Symbol.iterator]() {
       return instance4.visit(this);
     }
+    /**
+     * Combines two or more Vectors of the same type.
+     * @param others Additional Vectors to add to the end of this Vector.
+     */
     concat(...others) {
       return new Vector(this.data.concat(others.flatMap((x) => x.data).flat(Number.POSITIVE_INFINITY)));
     }
+    /**
+     * Return a zero-copy sub-section of this Vector.
+     * @param start The beginning of the specified portion of the Vector.
+     * @param end The end of the specified portion of the Vector. This is exclusive of the element at the index 'end'.
+     */
     slice(begin, end) {
       return new Vector(clampRange(this, begin, end, ({ data, _offsets }, begin2, end2) => sliceChunks(data, _offsets, begin2, end2)));
     }
     toJSON() {
       return [...this];
     }
+    /**
+     * Return a JavaScript Array or TypedArray of the Vector's elements.
+     *
+     * @note If this Vector contains a single Data chunk and the Vector's type is a
+     *  primitive numeric type corresponding to one of the JavaScript TypedArrays, this
+     *  method returns a zero-copy slice of the underlying TypedArray values. If there's
+     *  more than one chunk, the resulting TypedArray will be a copy of the data from each
+     *  chunk's underlying TypedArray values.
+     *
+     * @returns An Array or TypedArray of the Vector's elements, based on the Vector's DataType.
+     */
     toArray() {
       const { type, data, length, stride, ArrayType } = this;
       switch (type.typeId) {
@@ -4466,13 +4625,26 @@
       }
       return [...this];
     }
+    /**
+     * Returns a string representation of the Vector.
+     *
+     * @returns A string representation of the Vector.
+     */
     toString() {
       return `[${[...this].join(",")}]`;
     }
+    /**
+     * Returns a child Vector by name, or null if this Vector has no child with the given name.
+     * @param name The name of the child to retrieve.
+     */
     getChild(name) {
       var _b2;
       return this.getChildAt((_b2 = this.type.children) === null || _b2 === void 0 ? void 0 : _b2.findIndex((f) => f.name === name));
     }
+    /**
+     * Returns a child Vector by index, or null if this Vector has no child at the supplied index.
+     * @param index The index of the child to retrieve.
+     */
     getChildAt(index) {
       if (index > -1 && index < this.numChildren) {
         return new Vector(this.data.map(({ children }) => children[index]));
@@ -4485,6 +4657,17 @@
       }
       return false;
     }
+    /**
+     * Adds memoization to the Vector's {@link get} method. For dictionary
+     * vectors, this method return a vector that memoizes only the dictionary
+     * values.
+     *
+     * Memoization is very useful when decoding a value is expensive such as
+     * Uft8. The memoization creates a cache of the size of the Vector and
+     * therfore increases memory usage.
+     *
+     * @returns A new vector that memoizes calls to {@link get}.
+     */
     memoize() {
       if (DataType.isDictionary(this.type)) {
         const dictionary = new MemoizedVector(this.data[0].dictionary);
@@ -4497,6 +4680,12 @@
       }
       return new MemoizedVector(this);
     }
+    /**
+     * Returns a vector without memoization of the {@link get} method. If this
+     * vector is not memoized, this method returns this vector.
+     *
+     * @returns A a vector without memoization.
+     */
     unmemoize() {
       if (DataType.isDictionary(this.type) && this.isMemoized) {
         const dictionary = this.data[0].dictionary.unmemoize();
@@ -4682,6 +4871,7 @@ return true;`);
     get reservedByteLength() {
       return this.buffer.byteLength;
     }
+    // @ts-ignore
     set(index, value) {
       return this;
     }
@@ -4777,12 +4967,21 @@ return true;`);
 
   // ../../node_modules/apache-arrow/builder.mjs
   var Builder = class {
+    /** @nocollapse */
+    // @ts-ignore
     static throughNode(options) {
       throw new Error(`"throughNode" not available in this environment`);
     }
+    /** @nocollapse */
+    // @ts-ignore
     static throughDOM(options) {
       throw new Error(`"throughDOM" not available in this environment`);
     }
+    /**
+     * Construct a builder with the given Arrow DataType with optional null values,
+     * which will be interpreted as "null" when set or appended to the `Builder`.
+     * @param {{ type: T, nullValues?: any[] }} options A `BuilderOptions` object used to create this `Builder`.
+     */
     constructor({ "type": type, "nullValues": nulls }) {
       this.length = 0;
       this.finished = false;
@@ -4795,6 +4994,10 @@ return true;`);
         this._isValid = createIsValidFunction(nulls);
       }
     }
+    /**
+     * Flush the `Builder` and return a `Vector<T>`.
+     * @returns {Vector<T>} A `Vector<T>` of the flushed values.
+     */
     toVector() {
       return new Vector([this.flush()]);
     }
@@ -4807,6 +5010,9 @@ return true;`);
     get numChildren() {
       return this.children.length;
     }
+    /**
+     * @returns The aggregate length (in bytes) of the values that have been written.
+     */
     get byteLength() {
       let size = 0;
       const { _offsets, _values, _nulls, _typeIds, children } = this;
@@ -4816,9 +5022,15 @@ return true;`);
       _typeIds && (size += _typeIds.byteLength);
       return children.reduce((size2, child) => size2 + child.byteLength, size);
     }
+    /**
+     * @returns The aggregate number of rows that have been reserved to write new values.
+     */
     get reservedLength() {
       return this._nulls.reservedLength;
     }
+    /**
+     * @returns The aggregate length (in bytes) that has been reserved to write new values.
+     */
     get reservedByteLength() {
       let size = 0;
       this._offsets && (size += this._offsets.reservedByteLength);
@@ -4839,18 +5051,43 @@ return true;`);
     get typeIds() {
       return this._typeIds ? this._typeIds.buffer : null;
     }
+    /**
+     * Appends a value (or null) to this `Builder`.
+     * This is equivalent to `builder.set(builder.length, value)`.
+     * @param {T['TValue'] | TNull } value The value to append.
+     */
     append(value) {
       return this.set(this.length, value);
     }
+    /**
+     * Validates whether a value is valid (true), or null (false)
+     * @param {T['TValue'] | TNull } value The value to compare against null the value representations
+     */
     isValid(value) {
       return this._isValid(value);
     }
+    /**
+     * Write a value (or null-value sentinel) at the supplied index.
+     * If the value matches one of the null-value representations, a 1-bit is
+     * written to the null `BitmapBufferBuilder`. Otherwise, a 0 is written to
+     * the null `BitmapBufferBuilder`, and the value is passed to
+     * `Builder.prototype.setValue()`.
+     * @param {number} index The index of the value to write.
+     * @param {T['TValue'] | TNull } value The value to write at the supplied index.
+     * @returns {this} The updated `Builder` instance.
+     */
     set(index, value) {
       if (this.setValid(index, this.isValid(value))) {
         this.setValue(index, value);
       }
       return this;
     }
+    /**
+     * Write a value to the underlying buffers at the supplied index, bypassing
+     * the null-value check. This is a low-level method that
+     * @param {number} index
+     * @param {T['TValue'] | TNull } value
+     */
     setValue(index, value) {
       this._setValue(this, index, value);
     }
@@ -4858,12 +5095,25 @@ return true;`);
       this.length = this._nulls.set(index, +valid).length;
       return valid;
     }
+    // @ts-ignore
     addChild(child, name = `${this.numChildren}`) {
       throw new Error(`Cannot append children to non-nested type "${this.type}"`);
     }
+    /**
+     * Retrieve the child `Builder` at the supplied `index`, or null if no child
+     * exists at that index.
+     * @param {number} index The index of the child `Builder` to retrieve.
+     * @returns {Builder | null} The child Builder at the supplied index or null.
+     */
     getChildAt(index) {
       return this.children[index] || null;
     }
+    /**
+     * Commit all the values that have been written to their underlying
+     * ArrayBuffers, including any child Builders if applicable, and reset
+     * the internal `Builder` state.
+     * @returns A `Data<T>` of the buffers and children representing the values written.
+     */
     flush() {
       let data;
       let typeIds;
@@ -4894,12 +5144,20 @@ return true;`);
         valueOffsets
       });
     }
+    /**
+     * Finalize this `Builder`, and child builders if applicable.
+     * @returns {this} The finalized `Builder` instance.
+     */
     finish() {
       this.finished = true;
       for (const child of this.children)
         child.finish();
       return this;
     }
+    /**
+     * Clear this Builder's internal state, including child Builders if applicable, and reset the length to 0.
+     * @returns {this} The cleared `Builder` instance.
+     */
     clear() {
       var _a5, _b2, _c2, _d2;
       this.length = 0;
@@ -4936,7 +5194,7 @@ return true;`);
       this._offsets = new OffsetsBufferBuilder();
     }
     setValue(index, value) {
-      const pending = this._pending || (this._pending = new Map());
+      const pending = this._pending || (this._pending = /* @__PURE__ */ new Map());
       const current = pending.get(index);
       current && (this._pendingLength -= current.length);
       this._pendingLength += value instanceof MapRow ? value[kKeys].length : value.length;
@@ -4944,7 +5202,7 @@ return true;`);
     }
     setValid(index, isValid) {
       if (!super.setValid(index, isValid)) {
-        (this._pending || (this._pending = new Map())).set(index, void 0);
+        (this._pending || (this._pending = /* @__PURE__ */ new Map())).set(index, void 0);
         return false;
       }
       return true;
@@ -4985,12 +5243,22 @@ return true;`);
       this.bb = bb;
       return this;
     }
+    /**
+     * Index to the start of the RecordBlock (note this is past the Message header)
+     */
     offset() {
       return this.bb.readInt64(this.bb_pos);
     }
+    /**
+     * Length of the metadata
+     */
     metaDataLength() {
       return this.bb.readInt32(this.bb_pos + 8);
     }
+    /**
+     * Length of the data (this is aligned so there can be a gap between this and
+     * the metadata).
+     */
     bodyLength() {
       return this.bb.readInt64(this.bb_pos + 16);
     }
@@ -5028,26 +5296,44 @@ return true;`);
 
   // ../../node_modules/apache-arrow/node_modules/flatbuffers/mjs/byte-buffer.js
   var ByteBuffer = class {
+    /**
+     * Create a new ByteBuffer with a given array of bytes (`Uint8Array`)
+     */
     constructor(bytes_) {
       this.bytes_ = bytes_;
       this.position_ = 0;
       this.text_decoder_ = new TextDecoder();
     }
+    /**
+     * Create and allocate a new ByteBuffer with a given size.
+     */
     static allocate(byte_size) {
       return new ByteBuffer(new Uint8Array(byte_size));
     }
     clear() {
       this.position_ = 0;
     }
+    /**
+     * Get the underlying `Uint8Array`.
+     */
     bytes() {
       return this.bytes_;
     }
+    /**
+     * Get the buffer's position.
+     */
     position() {
       return this.position_;
     }
+    /**
+     * Set the buffer's position.
+     */
     setPosition(position) {
       this.position_ = position;
     }
+    /**
+     * Get the buffer's capacity.
+     */
     capacity() {
       return this.bytes_.length;
     }
@@ -5127,6 +5413,11 @@ return true;`);
       this.writeInt32(offset, int32[isLittleEndian ? 0 : 1]);
       this.writeInt32(offset + 4, int32[isLittleEndian ? 1 : 0]);
     }
+    /**
+     * Return the file identifier.   Behavior is undefined for FlatBuffers whose
+     * schema does not include a file_identifier (likely points at padding or the
+     * start of a the root vtable).
+     */
     getBufferIdentifier() {
       if (this.bytes_.length < this.position_ + SIZEOF_INT + FILE_IDENTIFIER_LENGTH) {
         throw new Error("FlatBuffers: ByteBuffer is too short to contain an identifier.");
@@ -5137,15 +5428,33 @@ return true;`);
       }
       return result;
     }
+    /**
+     * Look up a field in the vtable, return an offset into the object, or 0 if the
+     * field is not present.
+     */
     __offset(bb_pos, vtable_offset) {
       const vtable = bb_pos - this.readInt32(bb_pos);
       return vtable_offset < this.readInt16(vtable) ? this.readInt16(vtable + vtable_offset) : 0;
     }
+    /**
+     * Initialize any Table-derived type to point to the union at the given offset.
+     */
     __union(t, offset) {
       t.bb_pos = offset + this.readInt32(offset);
       t.bb = this;
       return t;
     }
+    /**
+     * Create a JavaScript string from UTF-8 data stored inside the FlatBuffer.
+     * This allocates a new string and converts to wide chars upon each access.
+     *
+     * To avoid the conversion to string, pass Encoding.UTF8_BYTES as the
+     * "optionalEncoding" argument. This is useful for avoiding conversion when
+     * the data will just be packaged back up in another FlatBuffer later on.
+     *
+     * @param offset
+     * @param opt_encoding Defaults to UTF16_STRING
+     */
     __string(offset, opt_encoding) {
       offset += this.readInt32(offset);
       const length = this.readInt32(offset);
@@ -5156,18 +5465,34 @@ return true;`);
       else
         return this.text_decoder_.decode(utf8bytes);
     }
+    /**
+     * Handle unions that can contain string as its member, if a Table-derived type then initialize it,
+     * if a string then return a new one
+     *
+     * WARNING: strings are immutable in JS so we can't change the string that the user gave us, this
+     * makes the behaviour of __union_with_string different compared to __union
+     */
     __union_with_string(o, offset) {
       if (typeof o === "string") {
         return this.__string(offset);
       }
       return this.__union(o, offset);
     }
+    /**
+     * Retrieve the relative offset stored at "offset"
+     */
     __indirect(offset) {
       return offset + this.readInt32(offset);
     }
+    /**
+     * Get the start of data of a vector whose offset is stored at "offset" in this object.
+     */
     __vector(offset) {
       return offset + this.readInt32(offset) + SIZEOF_INT;
     }
+    /**
+     * Get the length of a vector whose offset is stored at "offset" in this object.
+     */
     __vector_len(offset) {
       return this.readInt32(offset + this.readInt32(offset));
     }
@@ -5182,6 +5507,9 @@ return true;`);
       }
       return true;
     }
+    /**
+     * A helper function for generating list for obj api
+     */
     createScalarList(listAccessor, listLength) {
       const ret = [];
       for (let i = 0; i < listLength; ++i) {
@@ -5192,6 +5520,12 @@ return true;`);
       }
       return ret;
     }
+    /**
+     * A helper function for generating list for obj api
+     * @param listAccessor function that accepts an index and return data at that index
+     * @param listLength listLength
+     * @param res result list
+     */
     createObjList(listAccessor, listLength) {
       const ret = [];
       for (let i = 0; i < listLength; ++i) {
@@ -5206,6 +5540,9 @@ return true;`);
 
   // ../../node_modules/apache-arrow/node_modules/flatbuffers/mjs/builder.js
   var Builder2 = class {
+    /**
+     * Create a FlatBufferBuilder.
+     */
     constructor(opt_initial_size) {
       this.minalign = 1;
       this.vtable = null;
@@ -5239,15 +5576,40 @@ return true;`);
       this.force_defaults = false;
       this.string_maps = null;
     }
+    /**
+     * In order to save space, fields that are set to their default value
+     * don't get serialized into the buffer. Forcing defaults provides a
+     * way to manually disable this optimization.
+     *
+     * @param forceDefaults true always serializes default values
+     */
     forceDefaults(forceDefaults) {
       this.force_defaults = forceDefaults;
     }
+    /**
+     * Get the ByteBuffer representing the FlatBuffer. Only call this after you've
+     * called finish(). The actual data starts at the ByteBuffer's current position,
+     * not necessarily at 0.
+     */
     dataBuffer() {
       return this.bb;
     }
+    /**
+     * Get the bytes representing the FlatBuffer. Only call this after you've
+     * called finish().
+     */
     asUint8Array() {
       return this.bb.bytes().subarray(this.bb.position(), this.bb.position() + this.offset());
     }
+    /**
+     * Prepare to write an element of `size` after `additional_bytes` have been
+     * written, e.g. if you write a string, you need to align such the int length
+     * field is aligned to 4 bytes, and the string data follows it directly. If all
+     * you need to do is alignment, `additional_bytes` will be 0.
+     *
+     * @param size This is the of the new element to write
+     * @param additional_bytes The padding size
+     */
     prep(size, additional_bytes) {
       if (size > this.minalign) {
         this.minalign = size;
@@ -5283,26 +5645,50 @@ return true;`);
     writeFloat64(value) {
       this.bb.writeFloat64(this.space -= 8, value);
     }
+    /**
+     * Add an `int8` to the buffer, properly aligned, and grows the buffer (if necessary).
+     * @param value The `int8` to add the buffer.
+     */
     addInt8(value) {
       this.prep(1, 0);
       this.writeInt8(value);
     }
+    /**
+     * Add an `int16` to the buffer, properly aligned, and grows the buffer (if necessary).
+     * @param value The `int16` to add the buffer.
+     */
     addInt16(value) {
       this.prep(2, 0);
       this.writeInt16(value);
     }
+    /**
+     * Add an `int32` to the buffer, properly aligned, and grows the buffer (if necessary).
+     * @param value The `int32` to add the buffer.
+     */
     addInt32(value) {
       this.prep(4, 0);
       this.writeInt32(value);
     }
+    /**
+     * Add an `int64` to the buffer, properly aligned, and grows the buffer (if necessary).
+     * @param value The `int64` to add the buffer.
+     */
     addInt64(value) {
       this.prep(8, 0);
       this.writeInt64(value);
     }
+    /**
+     * Add a `float32` to the buffer, properly aligned, and grows the buffer (if necessary).
+     * @param value The `float32` to add the buffer.
+     */
     addFloat32(value) {
       this.prep(4, 0);
       this.writeFloat32(value);
     }
+    /**
+     * Add a `float64` to the buffer, properly aligned, and grows the buffer (if necessary).
+     * @param value The `float64` to add the buffer.
+     */
     addFloat64(value) {
       this.prep(8, 0);
       this.writeFloat64(value);
@@ -5349,29 +5735,59 @@ return true;`);
         this.slot(voffset);
       }
     }
+    /**
+     * Structs are stored inline, so nothing additional is being added. `d` is always 0.
+     */
     addFieldStruct(voffset, value, defaultValue) {
       if (value != defaultValue) {
         this.nested(value);
         this.slot(voffset);
       }
     }
+    /**
+     * Structures are always stored inline, they need to be created right
+     * where they're used.  You'll get this assertion failure if you
+     * created it elsewhere.
+     */
     nested(obj) {
       if (obj != this.offset()) {
         throw new TypeError("FlatBuffers: struct must be serialized inline.");
       }
     }
+    /**
+     * Should not be creating any other object, string or vector
+     * while an object is being constructed
+     */
     notNested() {
       if (this.isNested) {
         throw new TypeError("FlatBuffers: object serialization must not be nested.");
       }
     }
+    /**
+     * Set the current vtable at `voffset` to the current location in the buffer.
+     */
     slot(voffset) {
       if (this.vtable !== null)
         this.vtable[voffset] = this.offset();
     }
+    /**
+     * @returns Offset relative to the end of the buffer.
+     */
     offset() {
       return this.bb.capacity() - this.space;
     }
+    /**
+     * Doubles the size of the backing ByteBuffer and copies the old data towards
+     * the end of the new buffer (since we build the buffer backwards).
+     *
+     * @param bb The current buffer with the existing data
+     * @returns A new byte buffer with the old data copied
+     * to it. The data is located at the end of the buffer.
+     *
+     * uint8Array.set() formally takes {Array<number>|ArrayBufferView}, so to pass
+     * it a uint8Array we need to suppress the type check:
+     * @suppress {checkTypes}
+     */
     static growByteBuffer(bb) {
       const old_buf_size = bb.capacity();
       if (old_buf_size & 3221225472) {
@@ -5383,10 +5799,20 @@ return true;`);
       nbb.bytes().set(bb.bytes(), new_buf_size - old_buf_size);
       return nbb;
     }
+    /**
+     * Adds on offset, relative to where it will be written.
+     *
+     * @param offset The offset to add.
+     */
     addOffset(offset) {
       this.prep(SIZEOF_INT, 0);
       this.writeInt32(this.offset() - offset + SIZEOF_INT);
     }
+    /**
+     * Start encoding a new object in the buffer.  Users will not usually need to
+     * call this directly. The FlatBuffers compiler will generate helper methods
+     * that call this method internally.
+     */
     startObject(numfields) {
       this.notNested();
       if (this.vtable == null) {
@@ -5399,6 +5825,11 @@ return true;`);
       this.isNested = true;
       this.object_start = this.offset();
     }
+    /**
+     * Finish off writing the object that is under construction.
+     *
+     * @returns The offset to the object inside `dataBuffer`
+     */
     endObject() {
       if (this.vtable == null || !this.isNested) {
         throw new Error("FlatBuffers: endObject called without startObject");
@@ -5441,6 +5872,9 @@ return true;`);
       this.isNested = false;
       return vtableloc;
     }
+    /**
+     * Finalize a buffer, poiting to the given `root_table`.
+     */
     finish(root_table, opt_file_identifier, opt_size_prefix) {
       const size_prefix = opt_size_prefix ? SIZE_PREFIX_LENGTH : 0;
       if (opt_file_identifier) {
@@ -5460,9 +5894,16 @@ return true;`);
       }
       this.bb.setPosition(this.space);
     }
+    /**
+     * Finalize a size prefixed buffer, pointing to the given `root_table`.
+     */
     finishSizePrefixed(root_table, opt_file_identifier) {
       this.finish(root_table, opt_file_identifier, true);
     }
+    /**
+     * This checks a required field has been set in a given table that has
+     * just been constructed.
+     */
     requiredField(table, field) {
       const table_start = this.bb.capacity() - table;
       const vtable_start = table_start - this.bb.readInt32(table_start);
@@ -5471,22 +5912,45 @@ return true;`);
         throw new TypeError("FlatBuffers: field " + field + " must be set");
       }
     }
+    /**
+     * Start a new array/vector of objects.  Users usually will not call
+     * this directly. The FlatBuffers compiler will create a start/end
+     * method for vector types in generated code.
+     *
+     * @param elem_size The size of each element in the array
+     * @param num_elems The number of elements in the array
+     * @param alignment The alignment of the array
+     */
     startVector(elem_size, num_elems, alignment) {
       this.notNested();
       this.vector_num_elems = num_elems;
       this.prep(SIZEOF_INT, elem_size * num_elems);
       this.prep(alignment, elem_size * num_elems);
     }
+    /**
+     * Finish off the creation of an array and all its elements. The array must be
+     * created with `startVector`.
+     *
+     * @returns The offset at which the newly created array
+     * starts.
+     */
     endVector() {
       this.writeInt32(this.vector_num_elems);
       return this.offset();
     }
+    /**
+     * Encode the string `s` in the buffer using UTF-8. If the string passed has
+     * already been seen, we return the offset of the already written string
+     *
+     * @param s The string to encode
+     * @return The offset in the buffer where the encoded string starts
+     */
     createSharedString(s) {
       if (!s) {
         return 0;
       }
       if (!this.string_maps) {
-        this.string_maps = new Map();
+        this.string_maps = /* @__PURE__ */ new Map();
       }
       if (this.string_maps.has(s)) {
         return this.string_maps.get(s);
@@ -5495,6 +5959,13 @@ return true;`);
       this.string_maps.set(s, offset);
       return offset;
     }
+    /**
+     * Encode the string `s` in the buffer using UTF-8. If a Uint8Array is passed
+     * instead of a string, it is assumed to contain valid UTF-8 encoded data.
+     *
+     * @param s The string to encode
+     * @return The offset in the buffer where the encoded string starts
+     */
     createString(s) {
       if (s === null || s === void 0) {
         return 0;
@@ -5513,6 +5984,11 @@ return true;`);
       }
       return this.endVector();
     }
+    /**
+     * A helper function to pack an object
+     *
+     * @returns offset of obj
+     */
     createObjectOffset(obj) {
       if (obj === null) {
         return 0;
@@ -5523,6 +5999,11 @@ return true;`);
         return obj.pack(this);
       }
     }
+    /**
+     * A helper function to pack a list of object
+     *
+     * @returns list of offsets of each non null object
+     */
     createObjectOffsetList(list) {
       const ret = [];
       for (let i = 0; i < list.length; ++i) {
@@ -5677,14 +6158,32 @@ return true;`);
       bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH);
       return (obj || new DictionaryEncoding()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
     }
+    /**
+     * The known dictionary id in the application where this data is used. In
+     * the file or streaming formats, the dictionary ids are found in the
+     * DictionaryBatch messages
+     */
     id() {
       const offset = this.bb.__offset(this.bb_pos, 4);
       return offset ? this.bb.readInt64(this.bb_pos + offset) : BigInt("0");
     }
+    /**
+     * The dictionary indices are constrained to be non-negative integers. If
+     * this field is null, the indices must be signed int32. To maximize
+     * cross-language compatibility and performance, implementations are
+     * recommended to prefer signed integer types over unsigned integer types
+     * and to avoid uint64 indices unless they are required by an application.
+     */
     indexType(obj) {
       const offset = this.bb.__offset(this.bb_pos, 6);
       return offset ? (obj || new Int()).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
     }
+    /**
+     * By default, dictionaries are not ordered, or the order does not have
+     * semantic meaning. In some statistical, applications, dictionary-encoding
+     * is used to represent ordered categorical data, and we provide a way to
+     * preserve that metadata here
+     */
     isOrdered() {
       const offset = this.bb.__offset(this.bb_pos, 8);
       return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
@@ -5840,14 +6339,24 @@ return true;`);
       bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH);
       return (obj || new Decimal2()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
     }
+    /**
+     * Total number of decimal digits
+     */
     precision() {
       const offset = this.bb.__offset(this.bb_pos, 4);
       return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
     }
+    /**
+     * Number of digits after the decimal point "."
+     */
     scale() {
       const offset = this.bb.__offset(this.bb_pos, 6);
       return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
     }
+    /**
+     * Number of bits per value. The only accepted widths are 128 and 256.
+     * We use bitWidth for consistency with Int::bitWidth.
+     */
     bitWidth() {
       const offset = this.bb.__offset(this.bb_pos, 8);
       return offset ? this.bb.readInt32(this.bb_pos + offset) : 128;
@@ -5904,6 +6413,9 @@ return true;`);
       bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH);
       return (obj || new FixedSizeBinary2()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
     }
+    /**
+     * Number of bytes per value
+     */
     byteWidth() {
       const offset = this.bb.__offset(this.bb_pos, 4);
       return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
@@ -5943,6 +6455,9 @@ return true;`);
       bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH);
       return (obj || new FixedSizeList2()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
     }
+    /**
+     * Number of list items per value
+     */
     listSize() {
       const offset = this.bb.__offset(this.bb_pos, 4);
       return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
@@ -6107,6 +6622,9 @@ return true;`);
       bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH);
       return (obj || new Map2()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
     }
+    /**
+     * Set to true if the keys within each value are sorted
+     */
     keysSorted() {
       const offset = this.bb.__offset(this.bb_pos, 4);
       return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
@@ -6437,6 +6955,9 @@ return true;`);
       const offset = this.bb.__offset(this.bb_pos, 4);
       return offset ? this.bb.__string(this.bb_pos + offset, optionalEncoding) : null;
     }
+    /**
+     * Whether or not this field can contain nulls. Should be true in general.
+     */
     nullable() {
       const offset = this.bb.__offset(this.bb_pos, 6);
       return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
@@ -6445,14 +6966,24 @@ return true;`);
       const offset = this.bb.__offset(this.bb_pos, 8);
       return offset ? this.bb.readUint8(this.bb_pos + offset) : Type2.NONE;
     }
+    /**
+     * This is the type of the decoded value if the field is dictionary encoded.
+     */
     type(obj) {
       const offset = this.bb.__offset(this.bb_pos, 10);
       return offset ? this.bb.__union(obj, this.bb_pos + offset) : null;
     }
+    /**
+     * Present only if the field is dictionary encoded.
+     */
     dictionary(obj) {
       const offset = this.bb.__offset(this.bb_pos, 12);
       return offset ? (obj || new DictionaryEncoding()).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
     }
+    /**
+     * children apply only to nested data types like Struct, List and Union. For
+     * primitive types children will have length 0.
+     */
     children(index, obj) {
       const offset = this.bb.__offset(this.bb_pos, 14);
       return offset ? (obj || new Field()).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
@@ -6461,6 +6992,9 @@ return true;`);
       const offset = this.bb.__offset(this.bb_pos, 14);
       return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
     }
+    /**
+     * User-defined metadata
+     */
     customMetadata(index, obj) {
       const offset = this.bb.__offset(this.bb_pos, 16);
       return offset ? (obj || new KeyValue()).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
@@ -6537,6 +7071,11 @@ return true;`);
       bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH);
       return (obj || new Schema()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
     }
+    /**
+     * endianness of the buffer
+     * it is Little Endian by default
+     * if endianness doesn't match the underlying system then the vectors need to be converted
+     */
     endianness() {
       const offset = this.bb.__offset(this.bb_pos, 4);
       return offset ? this.bb.readInt16(this.bb_pos + offset) : Endianness.Little;
@@ -6557,6 +7096,9 @@ return true;`);
       const offset = this.bb.__offset(this.bb_pos, 8);
       return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
     }
+    /**
+     * Features used in the stream/file.
+     */
     features(index) {
       const offset = this.bb.__offset(this.bb_pos, 10);
       return offset ? this.bb.readInt64(this.bb.__vector(this.bb_pos + offset) + index * 8) : BigInt(0);
@@ -6672,6 +7214,9 @@ return true;`);
       const offset = this.bb.__offset(this.bb_pos, 10);
       return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
     }
+    /**
+     * User-defined metadata
+     */
     customMetadata(index, obj) {
       const offset = this.bb.__offset(this.bb_pos, 12);
       return offset ? (obj || new KeyValue()).__init(this.bb.__indirect(this.bb.__vector(this.bb_pos + offset) + index * 4), this.bb) : null;
@@ -6728,9 +7273,9 @@ return true;`);
 
   // ../../node_modules/apache-arrow/schema.mjs
   var Schema2 = class {
-    constructor(fields = [], metadata2, dictionaries) {
+    constructor(fields = [], metadata, dictionaries) {
       this.fields = fields || [];
-      this.metadata = metadata2 || new Map();
+      this.metadata = metadata || /* @__PURE__ */ new Map();
       if (!dictionaries) {
         dictionaries = generateDictionaryMap(fields);
       }
@@ -6745,11 +7290,23 @@ return true;`);
     toString() {
       return `Schema<{ ${this.fields.map((f, i) => `${i}: ${f}`).join(", ")} }>`;
     }
+    /**
+     * Construct a new Schema containing only specified fields.
+     *
+     * @param fieldNames Names of fields to keep.
+     * @returns A new Schema of fields matching the specified names.
+     */
     select(fieldNames) {
       const names = new Set(fieldNames);
       const fields = this.fields.filter((f) => names.has(f.name));
       return new Schema2(fields, this.metadata);
     }
+    /**
+     * Construct a new Schema containing only fields at the specified indices.
+     *
+     * @param fieldIndices Indices of fields to keep.
+     * @returns A new Schema of fields at the specified indices.
+     */
     selectAt(fieldIndices) {
       const fields = fieldIndices.map((i) => this.fields[i]).filter(Boolean);
       return new Schema2(fields, this.metadata);
@@ -6757,36 +7314,37 @@ return true;`);
     assign(...args) {
       const other = args[0] instanceof Schema2 ? args[0] : Array.isArray(args[0]) ? new Schema2(args[0]) : new Schema2(args);
       const curFields = [...this.fields];
-      const metadata2 = mergeMaps(mergeMaps(new Map(), this.metadata), other.metadata);
+      const metadata = mergeMaps(mergeMaps(/* @__PURE__ */ new Map(), this.metadata), other.metadata);
       const newFields = other.fields.filter((f2) => {
         const i = curFields.findIndex((f) => f.name === f2.name);
         return ~i ? (curFields[i] = f2.clone({
-          metadata: mergeMaps(mergeMaps(new Map(), curFields[i].metadata), f2.metadata)
+          metadata: mergeMaps(mergeMaps(/* @__PURE__ */ new Map(), curFields[i].metadata), f2.metadata)
         })) && false : true;
       });
-      const newDictionaries = generateDictionaryMap(newFields, new Map());
-      return new Schema2([...curFields, ...newFields], metadata2, new Map([...this.dictionaries, ...newDictionaries]));
+      const newDictionaries = generateDictionaryMap(newFields, /* @__PURE__ */ new Map());
+      return new Schema2([...curFields, ...newFields], metadata, new Map([...this.dictionaries, ...newDictionaries]));
     }
   };
   Schema2.prototype.fields = null;
   Schema2.prototype.metadata = null;
   Schema2.prototype.dictionaries = null;
   var Field2 = class {
+    /** @nocollapse */
     static new(...args) {
-      let [name, type, nullable, metadata2] = args;
+      let [name, type, nullable, metadata] = args;
       if (args[0] && typeof args[0] === "object") {
         ({ name } = args[0]);
         type === void 0 && (type = args[0].type);
         nullable === void 0 && (nullable = args[0].nullable);
-        metadata2 === void 0 && (metadata2 = args[0].metadata);
+        metadata === void 0 && (metadata = args[0].metadata);
       }
-      return new Field2(`${name}`, type, nullable, metadata2);
+      return new Field2(`${name}`, type, nullable, metadata);
     }
-    constructor(name, type, nullable = false, metadata2) {
+    constructor(name, type, nullable = false, metadata) {
       this.name = name;
       this.type = type;
       this.nullable = nullable;
-      this.metadata = metadata2 || new Map();
+      this.metadata = metadata || /* @__PURE__ */ new Map();
     }
     get typeId() {
       return this.type.typeId;
@@ -6798,9 +7356,9 @@ return true;`);
       return `${this.name}: ${this.type}`;
     }
     clone(...args) {
-      let [name, type, nullable, metadata2] = args;
-      !args[0] || typeof args[0] !== "object" ? [name = this.name, type = this.type, nullable = this.nullable, metadata2 = this.metadata] = args : { name = this.name, type = this.type, nullable = this.nullable, metadata: metadata2 = this.metadata } = args[0];
-      return Field2.new(name, type, nullable, metadata2);
+      let [name, type, nullable, metadata] = args;
+      !args[0] || typeof args[0] !== "object" ? [name = this.name, type = this.type, nullable = this.nullable, metadata = this.metadata] = args : { name = this.name, type = this.type, nullable = this.nullable, metadata = this.metadata } = args[0];
+      return Field2.new(name, type, nullable, metadata);
     }
   };
   Field2.prototype.type = null;
@@ -6808,9 +7366,9 @@ return true;`);
   Field2.prototype.nullable = null;
   Field2.prototype.metadata = null;
   function mergeMaps(m1, m2) {
-    return new Map([...m1 || new Map(), ...m2 || new Map()]);
+    return new Map([...m1 || /* @__PURE__ */ new Map(), ...m2 || /* @__PURE__ */ new Map()]);
   }
-  function generateDictionaryMap(fields, dictionaries = new Map()) {
+  function generateDictionaryMap(fields, dictionaries = /* @__PURE__ */ new Map()) {
     for (let i = -1, n = fields.length; ++i < n; ) {
       const field = fields[i];
       const type = field.type;
@@ -6832,12 +7390,14 @@ return true;`);
   var Builder3 = Builder2;
   var ByteBuffer2 = ByteBuffer;
   var Footer_ = class {
+    /** @nocollapse */
     static decode(buf) {
       buf = new ByteBuffer2(toUint8Array(buf));
       const footer = Footer.getRootAsFooter(buf);
       const schema = Schema2.decode(footer.schema());
       return new OffHeapFooter(schema, footer);
     }
+    /** @nocollapse */
     static encode(footer) {
       const b = new Builder3();
       const schemaOffset = Schema2.encode(b, footer.schema);
@@ -6923,9 +7483,11 @@ return true;`);
     }
   };
   var FileBlock = class {
+    /** @nocollapse */
     static decode(block) {
       return new FileBlock(block.metaDataLength(), block.bodyLength(), block.offset());
     }
+    /** @nocollapse */
     static encode(b, fileBlock) {
       const { metaDataLength } = fileBlock;
       const offset = BigInt(fileBlock.offset);
@@ -7456,12 +8018,15 @@ return true;`);
       this._plus(other);
       return this;
     }
+    /** @nocollapse */
     static from(val, out_buffer = new Uint32Array(2)) {
       return Uint642.fromString(typeof val === "string" ? val : val.toString(), out_buffer);
     }
+    /** @nocollapse */
     static fromNumber(num, out_buffer = new Uint32Array(2)) {
       return Uint642.fromString(num.toString(), out_buffer);
     }
+    /** @nocollapse */
     static fromString(str, out_buffer = new Uint32Array(2)) {
       const length = str.length;
       const out = new Uint642(out_buffer);
@@ -7475,6 +8040,7 @@ return true;`);
       }
       return out;
     }
+    /** @nocollapse */
     static convertArray(values) {
       const data = new Uint32Array(values.length * 2);
       for (let i = -1, n = values.length; ++i < n; ) {
@@ -7482,10 +8048,12 @@ return true;`);
       }
       return data;
     }
+    /** @nocollapse */
     static multiply(left, right) {
       const rtrn = new Uint642(new Uint32Array(left.buffer));
       return rtrn.times(right);
     }
+    /** @nocollapse */
     static add(left, right) {
       const rtrn = new Uint642(new Uint32Array(left.buffer));
       return rtrn.plus(right);
@@ -7513,12 +8081,15 @@ return true;`);
       const other_high = other.buffer[1] << 0;
       return this_high < other_high || this_high === other_high && this.buffer[0] < other.buffer[0];
     }
+    /** @nocollapse */
     static from(val, out_buffer = new Uint32Array(2)) {
       return Int642.fromString(typeof val === "string" ? val : val.toString(), out_buffer);
     }
+    /** @nocollapse */
     static fromNumber(num, out_buffer = new Uint32Array(2)) {
       return Int642.fromString(num.toString(), out_buffer);
     }
+    /** @nocollapse */
     static fromString(str, out_buffer = new Uint32Array(2)) {
       const negate = str.startsWith("-");
       const length = str.length;
@@ -7533,6 +8104,7 @@ return true;`);
       }
       return negate ? out.negate() : out;
     }
+    /** @nocollapse */
     static convertArray(values) {
       const data = new Uint32Array(values.length * 2);
       for (let i = -1, n = values.length; ++i < n; ) {
@@ -7540,10 +8112,12 @@ return true;`);
       }
       return data;
     }
+    /** @nocollapse */
     static multiply(left, right) {
       const rtrn = new Int642(new Uint32Array(left.buffer));
       return rtrn.times(right);
     }
+    /** @nocollapse */
     static add(left, right) {
       const rtrn = new Int642(new Uint32Array(left.buffer));
       return rtrn.plus(right);
@@ -7623,20 +8197,25 @@ return true;`);
     hex() {
       return `${intAsHex(this.buffer[3])} ${intAsHex(this.buffer[2])} ${intAsHex(this.buffer[1])} ${intAsHex(this.buffer[0])}`;
     }
+    /** @nocollapse */
     static multiply(left, right) {
       const rtrn = new Int128(new Uint32Array(left.buffer));
       return rtrn.times(right);
     }
+    /** @nocollapse */
     static add(left, right) {
       const rtrn = new Int128(new Uint32Array(left.buffer));
       return rtrn.plus(right);
     }
+    /** @nocollapse */
     static from(val, out_buffer = new Uint32Array(4)) {
       return Int128.fromString(typeof val === "string" ? val : val.toString(), out_buffer);
     }
+    /** @nocollapse */
     static fromNumber(num, out_buffer = new Uint32Array(4)) {
       return Int128.fromString(num.toString(), out_buffer);
     }
+    /** @nocollapse */
     static fromString(str, out_buffer = new Uint32Array(4)) {
       const negate = str.startsWith("-");
       const length = str.length;
@@ -7651,6 +8230,7 @@ return true;`);
       }
       return negate ? out.negate() : out;
     }
+    /** @nocollapse */
     static convertArray(values) {
       const data = new Uint32Array(values.length * 4);
       for (let i = -1, n = values.length; ++i < n; ) {
@@ -7865,7 +8445,7 @@ return true;`);
       super({ type: new Dictionary(type.dictionary, type.indices, type.id, type.isOrdered) });
       this._nulls = null;
       this._dictionaryOffset = 0;
-      this._keysToIndices = Object.create(null);
+      this._keysToIndices = /* @__PURE__ */ Object.create(null);
       this.indices = makeBuilder({ "type": this.type.indices, "nullValues": nulls });
       this.dictionary = makeBuilder({ "type": this.type.dictionary, "nullValues": null });
       if (typeof hashFn === "function") {
@@ -7923,7 +8503,7 @@ return true;`);
       this.indices.finish();
       this.dictionary.finish();
       this._dictionaryOffset = 0;
-      this._keysToIndices = Object.create(null);
+      this._keysToIndices = /* @__PURE__ */ Object.create(null);
       return super.finish();
     }
     clear() {
@@ -8049,7 +8629,7 @@ return true;`);
     }
     setValue(index, value) {
       const row = value instanceof Map ? value : new Map(Object.entries(value));
-      const pending = this._pending || (this._pending = new Map());
+      const pending = this._pending || (this._pending = /* @__PURE__ */ new Map());
       const current = pending.get(index);
       current && (this._pendingLength -= current.size);
       this._pendingLength += row.size;
@@ -8083,6 +8663,7 @@ return true;`);
 
   // ../../node_modules/apache-arrow/builder/null.mjs
   var NullBuilder = class extends Builder {
+    // @ts-ignore
     setValue(index, value) {
     }
     setValid(index, valid) {
@@ -8104,6 +8685,7 @@ return true;`);
           return type.children.forEach((f, i) => children[i].set(index, value[f.name]));
       }
     }
+    /** @inheritdoc */
     setValid(index, valid) {
       if (!super.setValid(index, valid)) {
         this.children.forEach((child) => child.setValid(index, valid));
@@ -8188,6 +8770,8 @@ return true;`);
       this.type = new Union_(mode, [...typeIds, childTypeId], fields);
       return childTypeId;
     }
+    /** @ignore */
+    // @ts-ignore
     _valueToChildTypeId(builder, value, offset) {
       throw new Error(`Cannot map UnionBuilder value to child typeId. Pass the \`childTypeId\` as the second argument to unionBuilder.append(), or supply a \`valueToChildTypeId\` function as part of the UnionBuilder constructor options.`);
     }
@@ -8199,6 +8783,7 @@ return true;`);
       super(options);
       this._offsets = new DataBufferBuilder(new Int32Array(0));
     }
+    /** @ignore */
     setValue(index, value, childTypeId) {
       const id = this._typeIds.set(index, childTypeId).buffer[index];
       const child = this.getChildAt(this.type.typeIdToChildIndex[id]);
@@ -8223,6 +8808,7 @@ return true;`);
     setValue(index, value) {
       return super.setValue(index, encodeUtf8(value));
     }
+    // @ts-ignore
     _flushPending(pending, pendingLength) {
     }
   };
@@ -8611,64 +9197,141 @@ return true;`);
       this.batches = batches;
       this._offsets = offsets !== null && offsets !== void 0 ? offsets : computeChunkOffsets(this.data);
     }
+    /**
+     * The contiguous {@link RecordBatch `RecordBatch`} chunks of the Table rows.
+     */
     get data() {
       return this.batches.map(({ data }) => data);
     }
+    /**
+     * The number of columns in this Table.
+     */
     get numCols() {
       return this.schema.fields.length;
     }
+    /**
+     * The number of rows in this Table.
+     */
     get numRows() {
       return this.data.reduce((numRows, data) => numRows + data.length, 0);
     }
+    /**
+     * The number of null rows in this Table.
+     */
     get nullCount() {
       if (this._nullCount === -1) {
         this._nullCount = computeChunkNullCounts(this.data);
       }
       return this._nullCount;
     }
+    /**
+     * Check whether an element is null.
+     *
+     * @param index The index at which to read the validity bitmap.
+     */
+    // @ts-ignore
     isValid(index) {
       return false;
     }
+    /**
+     * Get an element value by position.
+     *
+     * @param index The index of the element to read.
+     */
+    // @ts-ignore
     get(index) {
       return null;
     }
+    /**
+     * Set an element value by position.
+     *
+     * @param index The index of the element to write.
+     * @param value The value to set.
+     */
+    // @ts-ignore
     set(index, value) {
       return;
     }
+    /**
+     * Retrieve the index of the first occurrence of a value in an Vector.
+     *
+     * @param element The value to locate in the Vector.
+     * @param offset The index at which to begin the search. If offset is omitted, the search starts at index 0.
+     */
+    // @ts-ignore
     indexOf(element, offset) {
       return -1;
     }
+    /**
+     * Get the size in bytes of an element by index.
+     * @param index The index at which to get the byteLength.
+     */
+    // @ts-ignore
     getByteLength(index) {
       return 0;
     }
+    /**
+     * Iterator for rows in this Table.
+     */
     [Symbol.iterator]() {
       if (this.batches.length > 0) {
         return instance4.visit(new Vector(this.data));
       }
       return new Array(0)[Symbol.iterator]();
     }
+    /**
+     * Return a JavaScript Array of the Table rows.
+     *
+     * @returns An Array of Table rows.
+     */
     toArray() {
       return [...this];
     }
+    /**
+     * Returns a string representation of the Table rows.
+     *
+     * @returns A string representation of the Table rows.
+     */
     toString() {
       return `[
   ${this.toArray().join(",\n  ")}
 ]`;
     }
+    /**
+     * Combines two or more Tables of the same schema.
+     *
+     * @param others Additional Tables to add to the end of this Tables.
+     */
     concat(...others) {
       const schema = this.schema;
       const data = this.data.concat(others.flatMap(({ data: data2 }) => data2));
       return new Table(schema, data.map((data2) => new RecordBatch(schema, data2)));
     }
+    /**
+     * Return a zero-copy sub-section of this Table.
+     *
+     * @param begin The beginning of the specified portion of the Table.
+     * @param end The end of the specified portion of the Table. This is exclusive of the element at the index 'end'.
+     */
     slice(begin, end) {
       const schema = this.schema;
       [begin, end] = clampRange({ length: this.numRows }, begin, end);
       const data = sliceChunks(this.data, this._offsets, begin, end);
       return new Table(schema, data.map((chunk) => new RecordBatch(schema, chunk)));
     }
+    /**
+     * Returns a child Vector by name, or null if this Vector has no child with the given name.
+     *
+     * @param name The name of the child to retrieve.
+     */
     getChild(name) {
       return this.getChildAt(this.schema.fields.findIndex((f) => f.name === name));
     }
+    /**
+     * Returns a child Vector by index, or null if this Vector has no child at the supplied index.
+     *
+     * @param index The index of the child to retrieve.
+     */
     getChildAt(index) {
       if (index > -1 && index < this.schema.fields.length) {
         const data = this.data.map((data2) => data2.children[index]);
@@ -8681,6 +9344,12 @@ return true;`);
       }
       return null;
     }
+    /**
+     * Sets a child Vector by name.
+     *
+     * @param name The name of the child to overwrite.
+     * @returns A new Table with the supplied child for the specified name.
+     */
     setChild(name, child) {
       var _b2;
       return this.setChildAt((_b2 = this.schema.fields) === null || _b2 === void 0 ? void 0 : _b2.findIndex((f) => f.name === name), child);
@@ -8700,10 +9369,22 @@ return true;`);
       }
       return new Table(schema, batches);
     }
+    /**
+     * Construct a new Table containing only specified columns.
+     *
+     * @param columnNames Names of columns to keep.
+     * @returns A new Table of columns matching the specified names.
+     */
     select(columnNames) {
-      const nameToIndex = this.schema.fields.reduce((m, f, i) => m.set(f.name, i), new Map());
+      const nameToIndex = this.schema.fields.reduce((m, f, i) => m.set(f.name, i), /* @__PURE__ */ new Map());
       return this.selectAt(columnNames.map((columnName) => nameToIndex.get(columnName)).filter((x) => x > -1));
     }
+    /**
+     * Construct a new Table containing only columns at the specified indices.
+     *
+     * @param columnIndices Indices of columns to keep.
+     * @returns A new Table of columns at the specified indices.
+     */
     selectAt(columnIndices) {
       const schema = this.schema.selectAt(columnIndices);
       const data = this.batches.map((batch) => batch.selectAt(columnIndices));
@@ -8788,53 +9469,113 @@ return true;`);
     get dictionaries() {
       return this._dictionaries || (this._dictionaries = collectDictionaries(this.schema.fields, this.data.children));
     }
+    /**
+     * The number of columns in this RecordBatch.
+     */
     get numCols() {
       return this.schema.fields.length;
     }
+    /**
+     * The number of rows in this RecordBatch.
+     */
     get numRows() {
       return this.data.length;
     }
+    /**
+     * The number of null rows in this RecordBatch.
+     */
     get nullCount() {
       return this.data.nullCount;
     }
+    /**
+     * Check whether an element is null.
+     * @param index The index at which to read the validity bitmap.
+     */
     isValid(index) {
       return this.data.getValid(index);
     }
+    /**
+     * Get a row by position.
+     * @param index The index of the element to read.
+     */
     get(index) {
       return instance2.visit(this.data, index);
     }
+    /**
+     * Set a row by position.
+     * @param index The index of the element to write.
+     * @param value The value to set.
+     */
     set(index, value) {
       return instance.visit(this.data, index, value);
     }
+    /**
+     * Retrieve the index of the first occurrence of a row in an RecordBatch.
+     * @param element The row to locate in the RecordBatch.
+     * @param offset The index at which to begin the search. If offset is omitted, the search starts at index 0.
+     */
     indexOf(element, offset) {
       return instance3.visit(this.data, element, offset);
     }
+    /**
+     * Get the size (in bytes) of a row by index.
+     * @param index The row index for which to compute the byteLength.
+     */
     getByteLength(index) {
       return instance5.visit(this.data, index);
     }
+    /**
+     * Iterator for rows in this RecordBatch.
+     */
     [Symbol.iterator]() {
       return instance4.visit(new Vector([this.data]));
     }
+    /**
+     * Return a JavaScript Array of the RecordBatch rows.
+     * @returns An Array of RecordBatch rows.
+     */
     toArray() {
       return [...this];
     }
+    /**
+     * Combines two or more RecordBatch of the same schema.
+     * @param others Additional RecordBatch to add to the end of this RecordBatch.
+     */
     concat(...others) {
       return new Table(this.schema, [this, ...others]);
     }
+    /**
+     * Return a zero-copy sub-section of this RecordBatch.
+     * @param start The beginning of the specified portion of the RecordBatch.
+     * @param end The end of the specified portion of the RecordBatch. This is exclusive of the element at the index 'end'.
+     */
     slice(begin, end) {
       const [slice] = new Vector([this.data]).slice(begin, end).data;
       return new RecordBatch(this.schema, slice);
     }
+    /**
+     * Returns a child Vector by name, or null if this Vector has no child with the given name.
+     * @param name The name of the child to retrieve.
+     */
     getChild(name) {
       var _b2;
       return this.getChildAt((_b2 = this.schema.fields) === null || _b2 === void 0 ? void 0 : _b2.findIndex((f) => f.name === name));
     }
+    /**
+     * Returns a child Vector by index, or null if this Vector has no child at the supplied index.
+     * @param index The index of the child to retrieve.
+     */
     getChildAt(index) {
       if (index > -1 && index < this.schema.fields.length) {
         return new Vector([this.data.children[index]]);
       }
       return null;
     }
+    /**
+     * Sets a child Vector by name.
+     * @param name The name of the child to overwrite.
+     * @returns A new RecordBatch with the new child for the specified name.
+     */
     setChild(name, child) {
       var _b2;
       return this.setChildAt((_b2 = this.schema.fields) === null || _b2 === void 0 ? void 0 : _b2.findIndex((f) => f.name === name), child);
@@ -8855,6 +9596,12 @@ return true;`);
       }
       return new RecordBatch(schema, data);
     }
+    /**
+     * Construct a new RecordBatch containing only specified columns.
+     *
+     * @param columnNames Names of columns to keep.
+     * @returns A new RecordBatch of columns matching the specified names.
+     */
     select(columnNames) {
       const schema = this.schema.select(columnNames);
       const type = new Struct(schema.fields);
@@ -8867,6 +9614,12 @@ return true;`);
       }
       return new RecordBatch(schema, makeData({ type, length: this.numRows, children }));
     }
+    /**
+     * Construct a new RecordBatch containing only columns at the specified indices.
+     *
+     * @param columnIndices Indices of columns to keep.
+     * @returns A new RecordBatch of columns matching at the specified indices.
+     */
     selectAt(columnIndices) {
       const schema = this.schema.selectAt(columnIndices);
       const children = columnIndices.map((i) => this.data.children[i]).filter(Boolean);
@@ -8902,7 +9655,7 @@ return true;`);
       makeData({ type: new Struct(fields), length: maxLength, children })
     ];
   }
-  function collectDictionaries(fields, children, dictionaries = new Map()) {
+  function collectDictionaries(fields, children, dictionaries = /* @__PURE__ */ new Map()) {
     for (let i = -1, n = fields.length; ++i < n; ) {
       const field = fields[i];
       const type = field.type;
@@ -8961,10 +9714,17 @@ return true;`);
       bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH);
       return (obj || new BodyCompression()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
     }
+    /**
+     * Compressor library.
+     * For LZ4_FRAME, each compressed buffer must consist of a single frame.
+     */
     codec() {
       const offset = this.bb.__offset(this.bb_pos, 4);
       return offset ? this.bb.readInt8(this.bb_pos + offset) : CompressionType.LZ4_FRAME;
     }
+    /**
+     * Indicates the way the record batch body was compressed
+     */
     method() {
       const offset = this.bb.__offset(this.bb_pos, 6);
       return offset ? this.bb.readInt8(this.bb_pos + offset) : BodyCompressionMethod.BUFFER;
@@ -9001,9 +9761,20 @@ return true;`);
       this.bb = bb;
       return this;
     }
+    /**
+     * The relative offset into the shared memory page where the bytes for this
+     * buffer starts
+     */
     offset() {
       return this.bb.readInt64(this.bb_pos);
     }
+    /**
+     * The absolute length (in bytes) of the memory buffer. The memory is found
+     * from offset (inclusive) to offset + length (non-inclusive). When building
+     * messages using the encapsulated IPC message, padding bytes may be written
+     * after a buffer, but such padding bytes do not need to be accounted for in
+     * the size here.
+     */
     length() {
       return this.bb.readInt64(this.bb_pos + 8);
     }
@@ -9029,9 +9800,18 @@ return true;`);
       this.bb = bb;
       return this;
     }
+    /**
+     * The number of value slots in the Arrow array at this level of a nested
+     * tree
+     */
     length() {
       return this.bb.readInt64(this.bb_pos);
     }
+    /**
+     * The number of observed nulls. Fields with null_count == 0 may choose not
+     * to write their physical validity bitmap out as a materialized buffer,
+     * instead setting the length of the bitmap buffer to 0.
+     */
     nullCount() {
       return this.bb.readInt64(this.bb_pos + 8);
     }
@@ -9064,10 +9844,17 @@ return true;`);
       bb.setPosition(bb.position() + SIZE_PREFIX_LENGTH);
       return (obj || new RecordBatch2()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
     }
+    /**
+     * number of records / rows. The arrays in the batch should all have this
+     * length
+     */
     length() {
       const offset = this.bb.__offset(this.bb_pos, 4);
       return offset ? this.bb.readInt64(this.bb_pos + offset) : BigInt("0");
     }
+    /**
+     * Nodes correspond to the pre-ordered flattened logical schema
+     */
     nodes(index, obj) {
       const offset = this.bb.__offset(this.bb_pos, 6);
       return offset ? (obj || new FieldNode()).__init(this.bb.__vector(this.bb_pos + offset) + index * 16, this.bb) : null;
@@ -9076,6 +9863,14 @@ return true;`);
       const offset = this.bb.__offset(this.bb_pos, 6);
       return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
     }
+    /**
+     * Buffers correspond to the pre-ordered flattened buffer tree
+     *
+     * The number of buffers appended to this list depends on the schema. For
+     * example, most primitive arrays will have 2 buffers, 1 for the validity
+     * bitmap and 1 for the values. For struct arrays, there will only be a
+     * single buffer for the validity (nulls) bitmap
+     */
     buffers(index, obj) {
       const offset = this.bb.__offset(this.bb_pos, 8);
       return offset ? (obj || new Buffer2()).__init(this.bb.__vector(this.bb_pos + offset) + index * 16, this.bb) : null;
@@ -9084,6 +9879,9 @@ return true;`);
       const offset = this.bb.__offset(this.bb_pos, 8);
       return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
     }
+    /**
+     * Optional compression of the message body
+     */
     compression(obj) {
       const offset = this.bb.__offset(this.bb_pos, 10);
       return offset ? (obj || new BodyCompression()).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
@@ -9141,6 +9939,11 @@ return true;`);
       const offset = this.bb.__offset(this.bb_pos, 6);
       return offset ? (obj || new RecordBatch2()).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null;
     }
+    /**
+     * If isDelta is true the values in the dictionary are to be appended to a
+     * dictionary with the indicated id. If isDelta is false this dictionary
+     * should replace the existing dictionary.
+     */
     isDelta() {
       const offset = this.bb.__offset(this.bb_pos, 8);
       return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
@@ -9374,7 +10177,7 @@ return true;`);
   var instance8 = new TypeAssembler();
 
   // ../../node_modules/apache-arrow/ipc/metadata/json.mjs
-  function schemaFromJSON(_schema, dictionaries = new Map()) {
+  function schemaFromJSON(_schema, dictionaries = /* @__PURE__ */ new Map()) {
     return new Schema2(schemaFieldsFromJSON(_schema, dictionaries), customMetadataFromJSON(_schema["customMetadata"]), dictionaries);
   }
   function recordBatchFromJSON(b) {
@@ -9511,11 +10314,13 @@ return true;`);
   var Builder4 = Builder2;
   var ByteBuffer3 = ByteBuffer;
   var Message2 = class {
+    /** @nocollapse */
     static fromJSON(msg, headerType) {
       const message = new Message2(0, MetadataVersion.V4, headerType);
       message._createHeader = messageHeaderFromJSON(msg, headerType);
       return message;
     }
+    /** @nocollapse */
     static decode(buf) {
       buf = new ByteBuffer3(toUint8Array(buf));
       const _message = Message.getRootAsMessage(buf);
@@ -9526,6 +10331,7 @@ return true;`);
       message._createHeader = decodeMessageHeader(_message, headerType);
       return message;
     }
+    /** @nocollapse */
     static encode(message) {
       const b = new Builder4();
       let headerOffset = -1;
@@ -9544,6 +10350,7 @@ return true;`);
       Message.finishMessageBuffer(b, Message.endMessage(b));
       return b.asUint8Array();
     }
+    /** @nocollapse */
     static from(header, bodyLength = 0) {
       if (header instanceof Schema2) {
         return new Message2(0, MetadataVersion.V4, MessageHeader.Schema, header);
@@ -9683,7 +10490,7 @@ return true;`);
   FieldNode2["decode"] = decodeFieldNode;
   BufferRegion["encode"] = encodeBufferRegion;
   BufferRegion["decode"] = decodeBufferRegion;
-  function decodeSchema(_schema, dictionaries = new Map()) {
+  function decodeSchema(_schema, dictionaries = /* @__PURE__ */ new Map()) {
     const fields = decodeSchemaFields(_schema, dictionaries);
     return new Schema2(fields, decodeCustomMetadata(_schema), dictionaries);
   }
@@ -9764,7 +10571,7 @@ return true;`);
     return field || null;
   }
   function decodeCustomMetadata(parent) {
-    const data = new Map();
+    const data = /* @__PURE__ */ new Map();
     if (parent) {
       for (let entry, key, i = -1, n = Math.trunc(parent.customMetadataLength()); ++i < n; ) {
         if ((entry = parent.customMetadata(i)) && (key = entry.key()) != null) {
@@ -9938,7 +10745,12 @@ return true;`);
   }
   var platformIsLittleEndian = (() => {
     const buffer = new ArrayBuffer(2);
-    new DataView(buffer).setInt16(0, 256, true);
+    new DataView(buffer).setInt16(
+      0,
+      256,
+      true
+      /* littleEndian */
+    );
     return new Int16Array(buffer)[0] === 256;
   })();
 
@@ -9991,7 +10803,11 @@ return true;`);
       if (buf.byteLength < bodyLength) {
         throw new Error(invalidMessageBodyLength(bodyLength, buf.byteLength));
       }
-      return buf.byteOffset % 8 === 0 && buf.byteOffset + buf.byteLength <= buf.buffer.byteLength ? buf : buf.slice();
+      return (
+        /* 1. */
+        buf.byteOffset % 8 === 0 && /* 2. */
+        buf.byteOffset + buf.byteLength <= buf.buffer.byteLength ? buf : buf.slice()
+      );
     }
     readSchema(throwIfNull = false) {
       const type = MessageHeader.Schema;
@@ -10072,7 +10888,11 @@ return true;`);
         if (buf.byteLength < bodyLength) {
           throw new Error(invalidMessageBodyLength(bodyLength, buf.byteLength));
         }
-        return buf.byteOffset % 8 === 0 && buf.byteOffset + buf.byteLength <= buf.buffer.byteLength ? buf : buf.slice();
+        return (
+          /* 1. */
+          buf.byteOffset % 8 === 0 && /* 2. */
+          buf.byteOffset + buf.byteLength <= buf.buffer.byteLength ? buf : buf.slice()
+        );
       });
     }
     readSchema(throwIfNull = false) {
@@ -10265,12 +11085,16 @@ return true;`);
     toNodeStream() {
       return adapters_default.toNodeStream(this.isSync() ? { [Symbol.iterator]: () => this } : { [Symbol.asyncIterator]: () => this }, { objectMode: true });
     }
+    /** @nocollapse */
+    // @ts-ignore
     static throughNode(options) {
       throw new Error(`"throughNode" not available in this environment`);
     }
+    /** @nocollapse */
     static throughDOM(writableStrategy, readableStrategy) {
       throw new Error(`"throughDOM" not available in this environment`);
     }
+    /** @nocollapse */
     static from(source) {
       if (source instanceof RecordBatchReader) {
         return source;
@@ -10287,6 +11111,7 @@ return true;`);
       }
       return fromByteStream(new ByteStream(source));
     }
+    /** @nocollapse */
     static readAll(source) {
       if (source instanceof RecordBatchReader) {
         return source.isSync() ? readAllSync(source) : readAllAsync(source);
@@ -10369,7 +11194,7 @@ return true;`);
     get numRecordBatches() {
       return this._recordBatchIndex;
     }
-    constructor(dictionaries = new Map()) {
+    constructor(dictionaries = /* @__PURE__ */ new Map()) {
       this.closed = false;
       this.autoDestroy = true;
       this._dictionaryIndex = 0;
@@ -10392,7 +11217,7 @@ return true;`);
       this._dictionaryIndex = 0;
       this._recordBatchIndex = 0;
       this.schema = schema;
-      this.dictionaries = new Map();
+      this.dictionaries = /* @__PURE__ */ new Map();
       return this;
     }
     _loadRecordBatch(header, body) {
@@ -10823,6 +11648,7 @@ return true;`);
 
   // ../../node_modules/apache-arrow/visitor/vectorassembler.mjs
   var VectorAssembler = class extends Visitor {
+    /** @nocollapse */
     static assemble(...args) {
       const unwrap = (nodes) => nodes.flatMap((node) => Array.isArray(node) ? unwrap(node) : node instanceof RecordBatch ? node.data.children : node.data);
       const assembler = new VectorAssembler();
@@ -10964,9 +11790,12 @@ return true;`);
 
   // ../../node_modules/apache-arrow/ipc/writer.mjs
   var RecordBatchWriter = class extends ReadableInterop {
+    /** @nocollapse */
+    // @ts-ignore
     static throughNode(options) {
       throw new Error(`"throughNode" not available in this environment`);
     }
+    /** @nocollapse */
     static throughDOM(writableStrategy, readableStrategy) {
       throw new Error(`"throughDOM" not available in this environment`);
     }
@@ -10978,7 +11807,7 @@ return true;`);
       this._schema = null;
       this._dictionaryBlocks = [];
       this._recordBatchBlocks = [];
-      this._dictionaryDeltaOffsets = new Map();
+      this._dictionaryDeltaOffsets = /* @__PURE__ */ new Map();
       isObject(options) || (options = { autoDestroy: true, writeLegacyIpcFormat: false });
       this._autoDestroy = typeof options.autoDestroy === "boolean" ? options.autoDestroy : true;
       this._writeLegacyIpcFormat = typeof options.writeLegacyIpcFormat === "boolean" ? options.writeLegacyIpcFormat : false;
@@ -11036,7 +11865,7 @@ return true;`);
       this._started = false;
       this._dictionaryBlocks = [];
       this._recordBatchBlocks = [];
-      this._dictionaryDeltaOffsets = new Map();
+      this._dictionaryDeltaOffsets = /* @__PURE__ */ new Map();
       if (!schema || !compareSchemas(schema, this._schema)) {
         if (schema == null) {
           this._position = 0;
@@ -11110,6 +11939,7 @@ return true;`);
     _writeSchema(schema) {
       return this._writeMessage(Message2.from(schema));
     }
+    // @ts-ignore
     _writeFooter(schema) {
       return this._writeLegacyIpcFormat ? this._write(Int32Array.of(0)) : this._write(Int32Array.of(-1, 0));
     }
@@ -11160,6 +11990,7 @@ return true;`);
     }
   };
   var RecordBatchStreamWriter = class extends RecordBatchWriter {
+    /** @nocollapse */
     static writeAll(input, options) {
       const writer = new RecordBatchStreamWriter(options);
       if (isPromise(input)) {
@@ -11171,6 +12002,7 @@ return true;`);
     }
   };
   var RecordBatchFileWriter = class extends RecordBatchWriter {
+    /** @nocollapse */
     static writeAll(input) {
       const writer = new RecordBatchFileWriter();
       if (isPromise(input)) {
@@ -11184,6 +12016,7 @@ return true;`);
       super();
       this._autoDestroy = true;
     }
+    // @ts-ignore
     _writeSchema(schema) {
       return this._writeMagic()._writePadding(2);
     }
@@ -11439,6 +12272,7 @@ return true;`);
     const writer = new this(writableStrategy);
     const reader = new AsyncByteStream(writer);
     const readable = new ReadableStream({
+      // type: 'bytes',
       cancel() {
         return __awaiter(this, void 0, void 0, function* () {
           yield reader.cancel();
@@ -11500,29 +12334,6 @@ return true;`);
   RecordBatchFileWriter["throughDOM"] = recordBatchWriterThroughDOMStream;
   RecordBatchStreamWriter["throughDOM"] = recordBatchWriterThroughDOMStream;
 
-  // src/arrow-loader.ts
-  var VERSION = true ? "4.0.0-beta.2" : "latest";
-  var ArrowLoader = {
-    name: "Apache Arrow",
-    id: "arrow",
-    module: "arrow",
-    version: VERSION,
-    category: "table",
-    extensions: ["arrow", "feather"],
-    mimeTypes: [
-      "application/vnd.apache.arrow.file",
-      "application/vnd.apache.arrow.stream",
-      "application/octet-stream"
-    ],
-    binary: true,
-    tests: ["ARROW"],
-    options: {
-      arrow: {
-        shape: "columnar-table"
-      }
-    }
-  };
-
   // src/lib/convert-table.ts
   function convertApacheArrowToArrowTable(arrowTable) {
     return {
@@ -11593,10 +12404,13 @@ return true;`);
       if (batch) {
         this.arrowSchema = this.arrowSchema || getArrowSchema(batch.schema);
         const arrowVectors = getArrowVectors(this.arrowSchema, batch.data);
-        const recordBatch = new RecordBatch(this.arrowSchema, makeData({
-          type: new Struct(this.arrowSchema.fields),
-          children: arrowVectors.map(({ data }) => data[0])
-        }));
+        const recordBatch = new RecordBatch(
+          this.arrowSchema,
+          makeData({
+            type: new Struct(this.arrowSchema.fields),
+            children: arrowVectors.map(({ data }) => data[0])
+          })
+        );
         return {
           shape: "arrow-table",
           batchType: "data",
@@ -11612,8 +12426,8 @@ return true;`);
     for (const key in schema) {
       const field = schema[key];
       if (field.type === Float32Array) {
-        const metadata2 = new Map();
-        const arrowField = new Field2(field.name, new Float32(), field.nullable, metadata2);
+        const metadata = /* @__PURE__ */ new Map();
+        const arrowField = new Field2(field.name, new Float32(), field.nullable, metadata);
         arrowFields.push(arrowField);
       }
     }