@loaders.gl/arrow 4.3.0-alpha.8 → 4.3.0-beta.2

package/dist/arrow-worker.js

@@ -205,954 +205,579 @@
     return await parser(data, { ...options }, context, loader);
   }
 
-  // ../schema/src/lib/table/simple-table/data-type.ts
-  function getDataTypeFromValue(value, defaultNumberType = "float32") {
-    if (value instanceof Date) {
-      return "date-millisecond";
+  // ../../node_modules/tslib/tslib.es6.mjs
+  function __rest(s, e) {
+    var t = {};
+    for (var p in s)
+      if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+      for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+        if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+          t[p[i]] = s[p[i]];
+      }
+    return t;
+  }
+  function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) {
+      return value instanceof P ? value : new P(function(resolve) {
+        resolve(value);
+      });
     }
-    if (value instanceof Number) {
-      return defaultNumberType;
+    return new (P || (P = Promise))(function(resolve, reject) {
+      function fulfilled(value) {
+        try {
+          step(generator.next(value));
+        } catch (e) {
+          reject(e);
+        }
+      }
+      function rejected(value) {
+        try {
+          step(generator["throw"](value));
+        } catch (e) {
+          reject(e);
+        }
+      }
+      function step(result) {
+        result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+      }
+      step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+  }
+  function __values(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m)
+      return m.call(o);
+    if (o && typeof o.length === "number")
+      return {
+        next: function() {
+          if (o && i >= o.length)
+            o = void 0;
+          return { value: o && o[i++], done: !o };
+        }
+      };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+  }
+  function __await(v) {
+    return this instanceof __await ? (this.v = v, this) : new __await(v);
+  }
+  function __asyncGenerator(thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator)
+      throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function() {
+      return this;
+    }, i;
+    function awaitReturn(f) {
+      return function(v) {
+        return Promise.resolve(v).then(f, reject);
+      };
     }
-    if (typeof value === "string") {
-      return "utf8";
+    function verb(n, f) {
+      if (g[n]) {
+        i[n] = function(v) {
+          return new Promise(function(a, b) {
+            q.push([n, v, a, b]) > 1 || resume(n, v);
+          });
+        };
+        if (f)
+          i[n] = f(i[n]);
+      }
     }
-    if (value === null || value === "undefined") {
-      return "null";
+    function resume(n, v) {
+      try {
+        step(g[n](v));
+      } catch (e) {
+        settle(q[0][3], e);
+      }
     }
-    return "null";
-  }
-  function getDataTypeFromArray(array) {
-    let type = getDataTypeFromTypedArray(array);
-    if (type !== "null") {
-      return { type, nullable: false };
+    function step(r) {
+      r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
     }
-    if (array.length > 0) {
-      type = getDataTypeFromValue(array[0]);
-      return { type, nullable: true };
+    function fulfill(value) {
+      resume("next", value);
     }
-    return { type: "null", nullable: true };
-  }
-  function getDataTypeFromTypedArray(array) {
-    switch (array.constructor) {
-      case Int8Array:
-        return "int8";
-      case Uint8Array:
-      case Uint8ClampedArray:
-        return "uint8";
-      case Int16Array:
-        return "int16";
-      case Uint16Array:
-        return "uint16";
-      case Int32Array:
-        return "int32";
-      case Uint32Array:
-        return "uint32";
-      case Float32Array:
-        return "float32";
-      case Float64Array:
-        return "float64";
-      default:
-        return "null";
+    function reject(value) {
+      resume("throw", value);
     }
-  }
-  function getArrayTypeFromDataType(type, nullable) {
-    if (!nullable) {
-      switch (type) {
-        case "int8":
-          return Int8Array;
-        case "uint8":
-          return Uint8Array;
-        case "int16":
-          return Int16Array;
-        case "uint16":
-          return Uint16Array;
-        case "int32":
-          return Int32Array;
-        case "uint32":
-          return Uint32Array;
-        case "float32":
-          return Float32Array;
-        case "float64":
-          return Float64Array;
-        default:
-          break;
-      }
+    function settle(f, v) {
+      if (f(v), q.shift(), q.length)
+        resume(q[0][0], q[0][1]);
     }
-    return Array;
   }
-
-  // ../schema/src/lib/table/simple-table/table-accessors.ts
-  function getTableLength(table) {
-    switch (table.shape) {
-      case "array-row-table":
-      case "object-row-table":
-        return table.data.length;
-      case "geojson-table":
-        return table.features.length;
-      case "arrow-table":
-        const arrowTable = table.data;
-        return arrowTable.numRows;
-      case "columnar-table":
-        for (const column of Object.values(table.data)) {
-          return column.length || 0;
-        }
-        return 0;
-      default:
-        throw new Error("table");
+  function __asyncDelegator(o) {
+    var i, p;
+    return i = {}, verb("next"), verb("throw", function(e) {
+      throw e;
+    }), verb("return"), i[Symbol.iterator] = function() {
+      return this;
+    }, i;
+    function verb(n, f) {
+      i[n] = o[n] ? function(v) {
+        return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v;
+      } : f;
     }
   }
-  function getTableCell(table, rowIndex, columnName) {
-    switch (table.shape) {
-      case "array-row-table":
-        const columnIndex = getTableColumnIndex(table, columnName);
-        return table.data[rowIndex][columnIndex];
-      case "object-row-table":
-        return table.data[rowIndex][columnName];
-      case "geojson-table":
-        return table.features[rowIndex][columnName];
-      case "columnar-table":
-        const column = table.data[columnName];
-        return column[rowIndex];
-      case "arrow-table":
-        const arrowTable = table.data;
-        const arrowColumnIndex = arrowTable.schema.fields.findIndex(
-          (field) => field.name === columnName
-        );
-        return arrowTable.getChildAt(arrowColumnIndex)?.get(rowIndex);
-      default:
-        throw new Error("todo");
+  function __asyncValues(o) {
+    if (!Symbol.asyncIterator)
+      throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
+      return this;
+    }, i);
+    function verb(n) {
+      i[n] = o[n] && function(v) {
+        return new Promise(function(resolve, reject) {
+          v = o[n](v), settle(resolve, reject, v.done, v.value);
+        });
+      };
     }
-  }
-  function getTableColumnIndex(table, columnName) {
-    const columnIndex = table.schema?.fields.findIndex((field) => field.name === columnName);
-    if (columnIndex === void 0) {
-      throw new Error(columnName);
+    function settle(resolve, reject, d, v) {
+      Promise.resolve(v).then(function(v2) {
+        resolve({ value: v2, done: d });
+      }, reject);
     }
-    return columnIndex;
   }
-  function getTableRowAsObject(table, rowIndex, target, copy) {
-    switch (table.shape) {
-      case "object-row-table":
-        return copy ? Object.fromEntries(Object.entries(table.data[rowIndex])) : table.data[rowIndex];
-      case "array-row-table":
-        if (table.schema) {
-          const objectRow2 = target || {};
-          for (let i = 0; i < table.schema.fields.length; i++) {
-            objectRow2[table.schema.fields[i].name] = table.data[rowIndex][i];
-          }
-          return objectRow2;
-        }
-        throw new Error("no schema");
-      case "geojson-table":
-        if (table.schema) {
-          const objectRow2 = target || {};
-          for (let i = 0; i < table.schema.fields.length; i++) {
-            objectRow2[table.schema.fields[i].name] = table.features[rowIndex][i];
-          }
-          return objectRow2;
-        }
-        throw new Error("no schema");
-      case "columnar-table":
-        if (table.schema) {
-          const objectRow2 = target || {};
-          for (let i = 0; i < table.schema.fields.length; i++) {
-            objectRow2[table.schema.fields[i].name] = table.data[table.schema.fields[i].name][rowIndex];
-          }
-          return objectRow2;
-        } else {
-          const objectRow2 = target || {};
-          for (const [name, column] of Object.entries(table.data)) {
-            objectRow2[name] = column[rowIndex];
-          }
-          return objectRow2;
-        }
-      case "arrow-table":
-        const arrowTable = table.data;
-        const objectRow = target || {};
-        const row = arrowTable.get(rowIndex);
-        const schema = arrowTable.schema;
-        for (let i = 0; i < schema.fields.length; i++) {
-          objectRow[schema.fields[i].name] = row?.[schema.fields[i].name];
-        }
-        return objectRow;
-      default:
-        throw new Error("shape");
+
+  // ../../node_modules/apache-arrow/util/buffer.mjs
+  var buffer_exports = {};
+  __export(buffer_exports, {
+    compareArrayLike: () => compareArrayLike,
+    joinUint8Arrays: () => joinUint8Arrays,
+    memcpy: () => memcpy,
+    rebaseValueOffsets: () => rebaseValueOffsets,
+    toArrayBufferView: () => toArrayBufferView,
+    toArrayBufferViewAsyncIterator: () => toArrayBufferViewAsyncIterator,
+    toArrayBufferViewIterator: () => toArrayBufferViewIterator,
+    toBigInt64Array: () => toBigInt64Array,
+    toBigUint64Array: () => toBigUint64Array,
+    toFloat32Array: () => toFloat32Array,
+    toFloat32ArrayAsyncIterator: () => toFloat32ArrayAsyncIterator,
+    toFloat32ArrayIterator: () => toFloat32ArrayIterator,
+    toFloat64Array: () => toFloat64Array,
+    toFloat64ArrayAsyncIterator: () => toFloat64ArrayAsyncIterator,
+    toFloat64ArrayIterator: () => toFloat64ArrayIterator,
+    toInt16Array: () => toInt16Array,
+    toInt16ArrayAsyncIterator: () => toInt16ArrayAsyncIterator,
+    toInt16ArrayIterator: () => toInt16ArrayIterator,
+    toInt32Array: () => toInt32Array,
+    toInt32ArrayAsyncIterator: () => toInt32ArrayAsyncIterator,
+    toInt32ArrayIterator: () => toInt32ArrayIterator,
+    toInt8Array: () => toInt8Array,
+    toInt8ArrayAsyncIterator: () => toInt8ArrayAsyncIterator,
+    toInt8ArrayIterator: () => toInt8ArrayIterator,
+    toUint16Array: () => toUint16Array,
+    toUint16ArrayAsyncIterator: () => toUint16ArrayAsyncIterator,
+    toUint16ArrayIterator: () => toUint16ArrayIterator,
+    toUint32Array: () => toUint32Array,
+    toUint32ArrayAsyncIterator: () => toUint32ArrayAsyncIterator,
+    toUint32ArrayIterator: () => toUint32ArrayIterator,
+    toUint8Array: () => toUint8Array,
+    toUint8ArrayAsyncIterator: () => toUint8ArrayAsyncIterator,
+    toUint8ArrayIterator: () => toUint8ArrayIterator,
+    toUint8ClampedArray: () => toUint8ClampedArray,
+    toUint8ClampedArrayAsyncIterator: () => toUint8ClampedArrayAsyncIterator,
+    toUint8ClampedArrayIterator: () => toUint8ClampedArrayIterator
+  });
+
+  // ../../node_modules/apache-arrow/util/utf8.mjs
+  var decoder = new TextDecoder("utf-8");
+  var decodeUtf8 = (buffer) => decoder.decode(buffer);
+  var encoder = new TextEncoder();
+  var encodeUtf8 = (value) => encoder.encode(value);
+
+  // ../../node_modules/apache-arrow/util/compat.mjs
+  var isNumber = (x) => typeof x === "number";
+  var isBoolean = (x) => typeof x === "boolean";
+  var isFunction = (x) => typeof x === "function";
+  var isObject = (x) => x != null && Object(x) === x;
+  var isPromise = (x) => {
+    return isObject(x) && isFunction(x.then);
+  };
+  var isIterable = (x) => {
+    return isObject(x) && isFunction(x[Symbol.iterator]);
+  };
+  var isAsyncIterable = (x) => {
+    return isObject(x) && isFunction(x[Symbol.asyncIterator]);
+  };
+  var isArrowJSON = (x) => {
+    return isObject(x) && isObject(x["schema"]);
+  };
+  var isIteratorResult = (x) => {
+    return isObject(x) && "done" in x && "value" in x;
+  };
+  var isFileHandle = (x) => {
+    return isObject(x) && isFunction(x["stat"]) && isNumber(x["fd"]);
+  };
+  var isFetchResponse = (x) => {
+    return isObject(x) && isReadableDOMStream(x["body"]);
+  };
+  var isReadableInterop = (x) => "_getDOMStream" in x && "_getNodeStream" in x;
+  var isWritableDOMStream = (x) => {
+    return isObject(x) && isFunction(x["abort"]) && isFunction(x["getWriter"]) && !isReadableInterop(x);
+  };
+  var isReadableDOMStream = (x) => {
+    return isObject(x) && isFunction(x["cancel"]) && isFunction(x["getReader"]) && !isReadableInterop(x);
+  };
+  var isWritableNodeStream = (x) => {
+    return isObject(x) && isFunction(x["end"]) && isFunction(x["write"]) && isBoolean(x["writable"]) && !isReadableInterop(x);
+  };
+  var isReadableNodeStream = (x) => {
+    return isObject(x) && isFunction(x["read"]) && isFunction(x["pipe"]) && isBoolean(x["readable"]) && !isReadableInterop(x);
+  };
+  var isFlatbuffersByteBuffer = (x) => {
+    return isObject(x) && isFunction(x["clear"]) && isFunction(x["bytes"]) && isFunction(x["position"]) && isFunction(x["setPosition"]) && isFunction(x["capacity"]) && isFunction(x["getBufferIdentifier"]) && isFunction(x["createLong"]);
+  };
+
+  // ../../node_modules/apache-arrow/util/buffer.mjs
+  var SharedArrayBuf = typeof SharedArrayBuffer !== "undefined" ? SharedArrayBuffer : ArrayBuffer;
+  function collapseContiguousByteRanges(chunks) {
+    const result = chunks[0] ? [chunks[0]] : [];
+    let xOffset, yOffset, xLen, yLen;
+    for (let x, y, i = 0, j = 0, n = chunks.length; ++i < n; ) {
+      x = result[j];
+      y = chunks[i];
+      if (!x || !y || x.buffer !== y.buffer || y.byteOffset < x.byteOffset) {
+        y && (result[++j] = y);
+        continue;
+      }
+      ({ byteOffset: xOffset, byteLength: xLen } = x);
+      ({ byteOffset: yOffset, byteLength: yLen } = y);
+      if (xOffset + xLen < yOffset || yOffset + yLen < xOffset) {
+        y && (result[++j] = y);
+        continue;
+      }
+      result[j] = new Uint8Array(x.buffer, xOffset, yOffset - xOffset + yLen);
     }
+    return result;
   }
-  function getTableRowAsArray(table, rowIndex, target, copy) {
-    switch (table.shape) {
-      case "array-row-table":
-        return copy ? Array.from(table.data[rowIndex]) : table.data[rowIndex];
-      case "object-row-table":
-        if (table.schema) {
-          const arrayRow2 = target || [];
-          for (let i = 0; i < table.schema.fields.length; i++) {
-            arrayRow2[i] = table.data[rowIndex][table.schema.fields[i].name];
-          }
-          return arrayRow2;
-        }
-        return Object.values(table.data[rowIndex]);
-      case "geojson-table":
-        if (table.schema) {
-          const arrayRow2 = target || [];
-          for (let i = 0; i < table.schema.fields.length; i++) {
-            arrayRow2[i] = table.features[rowIndex][table.schema.fields[i].name];
-          }
-          return arrayRow2;
-        }
-        return Object.values(table.features[rowIndex]);
-      case "columnar-table":
-        if (table.schema) {
-          const arrayRow2 = target || [];
-          for (let i = 0; i < table.schema.fields.length; i++) {
-            arrayRow2[i] = table.data[table.schema.fields[i].name][rowIndex];
-          }
-          return arrayRow2;
-        } else {
-          const arrayRow2 = target || [];
-          let i = 0;
-          for (const column of Object.values(table.data)) {
-            arrayRow2[i] = column[rowIndex];
-            i++;
-          }
-          return arrayRow2;
-        }
-      case "arrow-table":
-        const arrowTable = table.data;
-        const arrayRow = target || [];
-        const row = arrowTable.get(rowIndex);
-        const schema = arrowTable.schema;
-        for (let i = 0; i < schema.fields.length; i++) {
-          arrayRow[i] = row?.[schema.fields[i].name];
+  function memcpy(target, source, targetByteOffset = 0, sourceByteLength = source.byteLength) {
+    const targetByteLength = target.byteLength;
+    const dst = new Uint8Array(target.buffer, target.byteOffset, targetByteLength);
+    const src = new Uint8Array(source.buffer, source.byteOffset, Math.min(sourceByteLength, targetByteLength));
+    dst.set(src, targetByteOffset);
+    return target;
+  }
+  function joinUint8Arrays(chunks, size) {
+    const result = collapseContiguousByteRanges(chunks);
+    const byteLength = result.reduce((x, b) => x + b.byteLength, 0);
+    let source, sliced, buffer;
+    let offset = 0, index = -1;
+    const length = Math.min(size || Number.POSITIVE_INFINITY, byteLength);
+    for (const n = result.length; ++index < n; ) {
+      source = result[index];
+      sliced = source.subarray(0, Math.min(source.length, length - offset));
+      if (length <= offset + sliced.length) {
+        if (sliced.length < source.length) {
+          result[index] = source.subarray(sliced.length);
+        } else if (sliced.length === source.length) {
+          index++;
         }
-        return arrayRow;
-      default:
-        throw new Error("shape");
+        buffer ? memcpy(buffer, sliced, offset) : buffer = sliced;
+        break;
+      }
+      memcpy(buffer || (buffer = new Uint8Array(length)), sliced, offset);
+      offset += sliced.length;
     }
+    return [buffer || new Uint8Array(0), result.slice(index), byteLength - (buffer ? buffer.byteLength : 0)];
   }
-
-  // ../schema/src/lib/table/simple-table/table-schema.ts
-  function deduceTableSchema(table) {
-    switch (table.shape) {
-      case "array-row-table":
-      case "object-row-table":
-        return deduceSchemaFromRows(table.data);
-      case "geojson-table":
-        return deduceSchemaFromGeoJSON(table.features);
-      case "columnar-table":
-        return deduceSchemaFromColumns(table.data);
-      case "arrow-table":
-      default:
-        throw new Error("Deduce schema");
+  function toArrayBufferView(ArrayBufferViewCtor, input) {
+    let value = isIteratorResult(input) ? input.value : input;
+    if (value instanceof ArrayBufferViewCtor) {
+      if (ArrayBufferViewCtor === Uint8Array) {
+        return new ArrayBufferViewCtor(value.buffer, value.byteOffset, value.byteLength);
+      }
+      return value;
     }
-  }
-  function deduceSchemaFromColumns(columnarTable) {
-    const fields = [];
-    for (const [columnName, column] of Object.entries(columnarTable)) {
-      const field = deduceFieldFromColumn(column, columnName);
-      fields.push(field);
+    if (!value) {
+      return new ArrayBufferViewCtor(0);
     }
-    return { fields, metadata: {} };
-  }
-  function deduceSchemaFromRows(rowTable) {
-    if (!rowTable.length) {
-      throw new Error("deduce from empty table");
+    if (typeof value === "string") {
+      value = encodeUtf8(value);
     }
-    const fields = [];
-    const row0 = rowTable[0];
-    for (const [columnName, value] of Object.entries(row0)) {
-      fields.push(deduceFieldFromValue(value, columnName));
+    if (value instanceof ArrayBuffer) {
+      return new ArrayBufferViewCtor(value);
     }
-    return { fields, metadata: {} };
-  }
-  function deduceSchemaFromGeoJSON(features) {
-    if (!features.length) {
-      throw new Error("deduce from empty table");
+    if (value instanceof SharedArrayBuf) {
+      return new ArrayBufferViewCtor(value);
     }
-    const fields = [];
-    const row0 = features[0].properties || {};
-    for (const [columnName, value] of Object.entries(row0)) {
-      fields.push(deduceFieldFromValue(value, columnName));
+    if (isFlatbuffersByteBuffer(value)) {
+      return toArrayBufferView(ArrayBufferViewCtor, value.bytes());
     }
-    return { fields, metadata: {} };
-  }
-  function deduceFieldFromColumn(column, name) {
-    if (ArrayBuffer.isView(column)) {
-      const type = getDataTypeFromArray(column);
-      return {
-        name,
-        type: type.type || "null",
-        nullable: type.nullable
-        // metadata: {}
-      };
-    }
-    if (Array.isArray(column) && column.length > 0) {
-      const value = column[0];
-      const type = getDataTypeFromValue(value);
-      return {
-        name,
-        type,
-        nullable: true
-        // metadata: {},
-      };
-    }
-    throw new Error("empty table");
+    return !ArrayBuffer.isView(value) ? ArrayBufferViewCtor.from(value) : value.byteLength <= 0 ? new ArrayBufferViewCtor(0) : new ArrayBufferViewCtor(value.buffer, value.byteOffset, value.byteLength / ArrayBufferViewCtor.BYTES_PER_ELEMENT);
   }
-  function deduceFieldFromValue(value, name) {
-    const type = getDataTypeFromValue(value);
-    return {
-      name,
-      type,
-      nullable: true
-      // metadata: {}
+  var toInt8Array = (input) => toArrayBufferView(Int8Array, input);
+  var toInt16Array = (input) => toArrayBufferView(Int16Array, input);
+  var toInt32Array = (input) => toArrayBufferView(Int32Array, input);
+  var toBigInt64Array = (input) => toArrayBufferView(BigInt64Array, input);
+  var toUint8Array = (input) => toArrayBufferView(Uint8Array, input);
+  var toUint16Array = (input) => toArrayBufferView(Uint16Array, input);
+  var toUint32Array = (input) => toArrayBufferView(Uint32Array, input);
+  var toBigUint64Array = (input) => toArrayBufferView(BigUint64Array, input);
+  var toFloat32Array = (input) => toArrayBufferView(Float32Array, input);
+  var toFloat64Array = (input) => toArrayBufferView(Float64Array, input);
+  var toUint8ClampedArray = (input) => toArrayBufferView(Uint8ClampedArray, input);
+  var pump = (iterator) => {
+    iterator.next();
+    return iterator;
+  };
+  function* toArrayBufferViewIterator(ArrayCtor, source) {
+    const wrap = function* (x) {
+      yield x;
     };
+    const buffers = typeof source === "string" ? wrap(source) : ArrayBuffer.isView(source) ? wrap(source) : source instanceof ArrayBuffer ? wrap(source) : source instanceof SharedArrayBuf ? wrap(source) : !isIterable(source) ? wrap(source) : source;
+    yield* pump(function* (it) {
+      let r = null;
+      do {
+        r = it.next(yield toArrayBufferView(ArrayCtor, r));
+      } while (!r.done);
+    }(buffers[Symbol.iterator]()));
+    return new ArrayCtor();
   }
-
-  // ../schema/src/lib/table/simple-table/table-column.ts
-  function makeColumnFromField(field, length) {
-    const ArrayType = getArrayTypeFromDataType(field.type, field.nullable);
-    return new ArrayType(length);
-  }
-
-  // ../schema/src/lib/table/simple-table/convert-table.ts
-  function convertTable(table, shape) {
-    switch (shape) {
-      case "object-row-table":
-        return makeObjectRowTable(table);
-      case "array-row-table":
-        return makeArrayRowTable(table);
-      case "columnar-table":
-        return makeColumnarTable(table);
-      case "arrow-table":
-        return makeArrowTable(table);
-      default:
-        throw new Error(shape);
-    }
-  }
-  function makeArrowTable(table) {
-    const _makeArrowTable = globalThis.__loaders?._makeArrowTable;
-    if (!_makeArrowTable) {
-      throw new Error("");
-    }
-    return _makeArrowTable(table);
-  }
-  function makeColumnarTable(table) {
-    const schema = table.schema || deduceTableSchema(table);
-    const fields = table.schema?.fields || [];
-    if (table.shape === "columnar-table") {
-      return { ...table, schema };
-    }
-    const length = getTableLength(table);
-    const columns = {};
-    for (const field of fields) {
-      const column = makeColumnFromField(field, length);
-      columns[field.name] = column;
-      for (let rowIndex = 0; rowIndex < length; rowIndex++) {
-        column[rowIndex] = getTableCell(table, rowIndex, field.name);
+  var toInt8ArrayIterator = (input) => toArrayBufferViewIterator(Int8Array, input);
+  var toInt16ArrayIterator = (input) => toArrayBufferViewIterator(Int16Array, input);
+  var toInt32ArrayIterator = (input) => toArrayBufferViewIterator(Int32Array, input);
+  var toUint8ArrayIterator = (input) => toArrayBufferViewIterator(Uint8Array, input);
+  var toUint16ArrayIterator = (input) => toArrayBufferViewIterator(Uint16Array, input);
+  var toUint32ArrayIterator = (input) => toArrayBufferViewIterator(Uint32Array, input);
+  var toFloat32ArrayIterator = (input) => toArrayBufferViewIterator(Float32Array, input);
+  var toFloat64ArrayIterator = (input) => toArrayBufferViewIterator(Float64Array, input);
+  var toUint8ClampedArrayIterator = (input) => toArrayBufferViewIterator(Uint8ClampedArray, input);
+  function toArrayBufferViewAsyncIterator(ArrayCtor, source) {
+    return __asyncGenerator(this, arguments, function* toArrayBufferViewAsyncIterator_1() {
+      if (isPromise(source)) {
+        return yield __await(yield __await(yield* __asyncDelegator(__asyncValues(toArrayBufferViewAsyncIterator(ArrayCtor, yield __await(source))))));
       }
-    }
-    return {
-      shape: "columnar-table",
-      schema,
-      data: columns
-    };
+      const wrap = function(x) {
+        return __asyncGenerator(this, arguments, function* () {
+          yield yield __await(yield __await(x));
+        });
+      };
+      const emit = function(source2) {
+        return __asyncGenerator(this, arguments, function* () {
+          yield __await(yield* __asyncDelegator(__asyncValues(pump(function* (it) {
+            let r = null;
+            do {
+              r = it.next(yield r === null || r === void 0 ? void 0 : r.value);
+            } while (!r.done);
+          }(source2[Symbol.iterator]())))));
+        });
+      };
+      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(
+        // 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());
+    });
   }
-  function makeArrayRowTable(table) {
-    if (table.shape === "array-row-table") {
-      return table;
-    }
-    const length = getTableLength(table);
-    const data = new Array(length);
-    for (let rowIndex = 0; rowIndex < length; rowIndex++) {
-      data[rowIndex] = getTableRowAsArray(table, rowIndex);
+  var toInt8ArrayAsyncIterator = (input) => toArrayBufferViewAsyncIterator(Int8Array, input);
+  var toInt16ArrayAsyncIterator = (input) => toArrayBufferViewAsyncIterator(Int16Array, input);
+  var toInt32ArrayAsyncIterator = (input) => toArrayBufferViewAsyncIterator(Int32Array, input);
+  var toUint8ArrayAsyncIterator = (input) => toArrayBufferViewAsyncIterator(Uint8Array, input);
+  var toUint16ArrayAsyncIterator = (input) => toArrayBufferViewAsyncIterator(Uint16Array, input);
+  var toUint32ArrayAsyncIterator = (input) => toArrayBufferViewAsyncIterator(Uint32Array, input);
+  var toFloat32ArrayAsyncIterator = (input) => toArrayBufferViewAsyncIterator(Float32Array, input);
+  var toFloat64ArrayAsyncIterator = (input) => toArrayBufferViewAsyncIterator(Float64Array, input);
+  var toUint8ClampedArrayAsyncIterator = (input) => toArrayBufferViewAsyncIterator(Uint8ClampedArray, input);
+  function rebaseValueOffsets(offset, length, valueOffsets) {
+    if (offset !== 0) {
+      valueOffsets = valueOffsets.slice(0, length);
+      for (let i = -1, n = valueOffsets.length; ++i < n; ) {
+        valueOffsets[i] += offset;
+      }
     }
-    return {
-      shape: "array-row-table",
-      schema: table.schema,
-      data
-    };
+    return valueOffsets.subarray(0, length);
   }
-  function makeObjectRowTable(table) {
-    if (table.shape === "object-row-table") {
-      return table;
+  function compareArrayLike(a, b) {
+    let i = 0;
+    const n = a.length;
+    if (n !== b.length) {
+      return false;
     }
-    const length = getTableLength(table);
-    const data = new Array(length);
-    for (let rowIndex = 0; rowIndex < length; rowIndex++) {
-      data[rowIndex] = getTableRowAsObject(table, rowIndex);
+    if (n > 0) {
+      do {
+        if (a[i] !== b[i]) {
+          return false;
+        }
+      } while (++i < n);
     }
-    return {
-      shape: "object-row-table",
-      schema: table.schema,
-      data
-    };
+    return true;
   }
 
-  // ../../node_modules/tslib/tslib.es6.mjs
-  function __rest(s, e) {
-    var t = {};
-    for (var p in s)
-      if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-      for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-        if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-          t[p[i]] = s[p[i]];
+  // ../../node_modules/apache-arrow/io/adapters.mjs
+  var adapters_default = {
+    fromIterable(source) {
+      return pump2(fromIterable(source));
+    },
+    fromAsyncIterable(source) {
+      return pump2(fromAsyncIterable(source));
+    },
+    fromDOMStream(source) {
+      return pump2(fromDOMStream(source));
+    },
+    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`);
+    }
+  };
+  var pump2 = (iterator) => {
+    iterator.next();
+    return iterator;
+  };
+  function* fromIterable(source) {
+    let done, threw = false;
+    let buffers = [], buffer;
+    let cmd, size, bufferLength = 0;
+    function byteRange() {
+      if (cmd === "peek") {
+        return joinUint8Arrays(buffers, size)[0];
       }
-    return t;
-  }
-  function __awaiter(thisArg, _arguments, P, generator) {
-    function adopt(value) {
-      return value instanceof P ? value : new P(function(resolve) {
-        resolve(value);
-      });
+      [buffer, buffers, bufferLength] = joinUint8Arrays(buffers, size);
+      return buffer;
     }
-    return new (P || (P = Promise))(function(resolve, reject) {
-      function fulfilled(value) {
-        try {
-          step(generator.next(value));
-        } catch (e) {
-          reject(e);
+    ({ cmd, size } = (yield (() => null)()) || { cmd: "read", size: 0 });
+    const it = toUint8ArrayIterator(source)[Symbol.iterator]();
+    try {
+      do {
+        ({ done, value: buffer } = Number.isNaN(size - bufferLength) ? it.next() : it.next(size - bufferLength));
+        if (!done && buffer.byteLength > 0) {
+          buffers.push(buffer);
+          bufferLength += buffer.byteLength;
         }
-      }
-      function rejected(value) {
-        try {
-          step(generator["throw"](value));
-        } catch (e) {
-          reject(e);
+        if (done || size <= bufferLength) {
+          do {
+            ({ cmd, size } = yield byteRange());
+          } while (size < bufferLength);
+        }
+      } while (!done);
+    } catch (e) {
+      (threw = true) && typeof it.throw === "function" && it.throw(e);
+    } finally {
+      threw === false && typeof it.return === "function" && it.return(null);
+    }
+    return null;
+  }
+  function fromAsyncIterable(source) {
+    return __asyncGenerator(this, arguments, function* fromAsyncIterable_1() {
+      let done, threw = false;
+      let buffers = [], buffer;
+      let cmd, size, bufferLength = 0;
+      function byteRange() {
+        if (cmd === "peek") {
+          return joinUint8Arrays(buffers, size)[0];
         }
+        [buffer, buffers, bufferLength] = joinUint8Arrays(buffers, size);
+        return buffer;
       }
-      function step(result) {
-        result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+      ({ cmd, size } = (yield yield __await((() => null)())) || { cmd: "read", size: 0 });
+      const it = toUint8ArrayAsyncIterator(source)[Symbol.asyncIterator]();
+      try {
+        do {
+          ({ done, value: buffer } = Number.isNaN(size - bufferLength) ? yield __await(it.next()) : yield __await(it.next(size - bufferLength)));
+          if (!done && buffer.byteLength > 0) {
+            buffers.push(buffer);
+            bufferLength += buffer.byteLength;
+          }
+          if (done || size <= bufferLength) {
+            do {
+              ({ cmd, size } = yield yield __await(byteRange()));
+            } while (size < bufferLength);
+          }
+        } while (!done);
+      } catch (e) {
+        (threw = true) && typeof it.throw === "function" && (yield __await(it.throw(e)));
+      } finally {
+        threw === false && typeof it.return === "function" && (yield __await(it.return(new Uint8Array(0))));
       }
-      step((generator = generator.apply(thisArg, _arguments || [])).next());
+      return yield __await(null);
     });
   }
-  function __values(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m)
-      return m.call(o);
-    if (o && typeof o.length === "number")
-      return {
-        next: function() {
-          if (o && i >= o.length)
-            o = void 0;
-          return { value: o && o[i++], done: !o };
+  function fromDOMStream(source) {
+    return __asyncGenerator(this, arguments, function* fromDOMStream_1() {
+      let done = false, threw = false;
+      let buffers = [], buffer;
+      let cmd, size, bufferLength = 0;
+      function byteRange() {
+        if (cmd === "peek") {
+          return joinUint8Arrays(buffers, size)[0];
         }
-      };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-  }
-  function __await(v) {
-    return this instanceof __await ? (this.v = v, this) : new __await(v);
-  }
-  function __asyncGenerator(thisArg, _arguments, generator) {
-    if (!Symbol.asyncIterator)
-      throw new TypeError("Symbol.asyncIterator is not defined.");
-    var g = generator.apply(thisArg, _arguments || []), i, q = [];
-    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
-      return this;
-    }, i;
-    function verb(n) {
-      if (g[n])
-        i[n] = function(v) {
-          return new Promise(function(a, b) {
-            q.push([n, v, a, b]) > 1 || resume(n, v);
-          });
-        };
-    }
-    function resume(n, v) {
+        [buffer, buffers, bufferLength] = joinUint8Arrays(buffers, size);
+        return buffer;
+      }
+      ({ cmd, size } = (yield yield __await((() => null)())) || { cmd: "read", size: 0 });
+      const it = new AdaptiveByteReader(source);
       try {
-        step(g[n](v));
+        do {
+          ({ done, value: buffer } = Number.isNaN(size - bufferLength) ? yield __await(it["read"]()) : yield __await(it["read"](size - bufferLength)));
+          if (!done && buffer.byteLength > 0) {
+            buffers.push(toUint8Array(buffer));
+            bufferLength += buffer.byteLength;
+          }
+          if (done || size <= bufferLength) {
+            do {
+              ({ cmd, size } = yield yield __await(byteRange()));
+            } while (size < bufferLength);
+          }
+        } while (!done);
       } catch (e) {
-        settle(q[0][3], e);
+        (threw = true) && (yield __await(it["cancel"](e)));
+      } finally {
+        threw === false ? yield __await(it["cancel"]()) : source["locked"] && it.releaseLock();
       }
+      return yield __await(null);
+    });
+  }
+  var AdaptiveByteReader = class {
+    constructor(source) {
+      this.source = source;
+      this.reader = null;
+      this.reader = this.source["getReader"]();
+      this.reader["closed"].catch(() => {
+      });
     }
-    function step(r) {
-      r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
-    }
-    function fulfill(value) {
-      resume("next", value);
-    }
-    function reject(value) {
-      resume("throw", value);
-    }
-    function settle(f, v) {
-      if (f(v), q.shift(), q.length)
-        resume(q[0][0], q[0][1]);
+    get closed() {
+      return this.reader ? this.reader["closed"].catch(() => {
+      }) : Promise.resolve();
     }
-  }
-  function __asyncDelegator(o) {
-    var i, p;
-    return i = {}, verb("next"), verb("throw", function(e) {
-      throw e;
-    }), verb("return"), i[Symbol.iterator] = function() {
-      return this;
-    }, i;
-    function verb(n, f) {
-      i[n] = o[n] ? function(v) {
-        return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v;
-      } : f;
+    releaseLock() {
+      if (this.reader) {
+        this.reader.releaseLock();
+      }
+      this.reader = null;
     }
-  }
-  function __asyncValues(o) {
-    if (!Symbol.asyncIterator)
-      throw new TypeError("Symbol.asyncIterator is not defined.");
-    var m = o[Symbol.asyncIterator], i;
-    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
-      return this;
-    }, i);
-    function verb(n) {
-      i[n] = o[n] && function(v) {
-        return new Promise(function(resolve, reject) {
-          v = o[n](v), settle(resolve, reject, v.done, v.value);
-        });
-      };
+    cancel(reason) {
+      return __awaiter(this, void 0, void 0, function* () {
+        const { reader, source } = this;
+        reader && (yield reader["cancel"](reason).catch(() => {
+        }));
+        source && (source["locked"] && this.releaseLock());
+      });
     }
-    function settle(resolve, reject, d, v) {
-      Promise.resolve(v).then(function(v2) {
-        resolve({ value: v2, done: d });
-      }, reject);
-    }
-  }
-
-  // ../../node_modules/apache-arrow/util/buffer.mjs
-  var buffer_exports = {};
-  __export(buffer_exports, {
-    compareArrayLike: () => compareArrayLike,
-    joinUint8Arrays: () => joinUint8Arrays,
-    memcpy: () => memcpy,
-    rebaseValueOffsets: () => rebaseValueOffsets,
-    toArrayBufferView: () => toArrayBufferView,
-    toArrayBufferViewAsyncIterator: () => toArrayBufferViewAsyncIterator,
-    toArrayBufferViewIterator: () => toArrayBufferViewIterator,
-    toBigInt64Array: () => toBigInt64Array,
-    toBigUint64Array: () => toBigUint64Array,
-    toFloat32Array: () => toFloat32Array,
-    toFloat32ArrayAsyncIterator: () => toFloat32ArrayAsyncIterator,
-    toFloat32ArrayIterator: () => toFloat32ArrayIterator,
-    toFloat64Array: () => toFloat64Array,
-    toFloat64ArrayAsyncIterator: () => toFloat64ArrayAsyncIterator,
-    toFloat64ArrayIterator: () => toFloat64ArrayIterator,
-    toInt16Array: () => toInt16Array,
-    toInt16ArrayAsyncIterator: () => toInt16ArrayAsyncIterator,
-    toInt16ArrayIterator: () => toInt16ArrayIterator,
-    toInt32Array: () => toInt32Array,
-    toInt32ArrayAsyncIterator: () => toInt32ArrayAsyncIterator,
-    toInt32ArrayIterator: () => toInt32ArrayIterator,
-    toInt8Array: () => toInt8Array,
-    toInt8ArrayAsyncIterator: () => toInt8ArrayAsyncIterator,
-    toInt8ArrayIterator: () => toInt8ArrayIterator,
-    toUint16Array: () => toUint16Array,
-    toUint16ArrayAsyncIterator: () => toUint16ArrayAsyncIterator,
-    toUint16ArrayIterator: () => toUint16ArrayIterator,
-    toUint32Array: () => toUint32Array,
-    toUint32ArrayAsyncIterator: () => toUint32ArrayAsyncIterator,
-    toUint32ArrayIterator: () => toUint32ArrayIterator,
-    toUint8Array: () => toUint8Array,
-    toUint8ArrayAsyncIterator: () => toUint8ArrayAsyncIterator,
-    toUint8ArrayIterator: () => toUint8ArrayIterator,
-    toUint8ClampedArray: () => toUint8ClampedArray,
-    toUint8ClampedArrayAsyncIterator: () => toUint8ClampedArrayAsyncIterator,
-    toUint8ClampedArrayIterator: () => toUint8ClampedArrayIterator
-  });
-
-  // ../../node_modules/apache-arrow/util/utf8.mjs
-  var decoder = new TextDecoder("utf-8");
-  var decodeUtf8 = (buffer) => decoder.decode(buffer);
-  var encoder = new TextEncoder();
-  var encodeUtf8 = (value) => encoder.encode(value);
-
-  // ../../node_modules/apache-arrow/util/compat.mjs
-  var isNumber = (x) => typeof x === "number";
-  var isBoolean = (x) => typeof x === "boolean";
-  var isFunction = (x) => typeof x === "function";
-  var isObject = (x) => x != null && Object(x) === x;
-  var isPromise = (x) => {
-    return isObject(x) && isFunction(x.then);
-  };
-  var isIterable = (x) => {
-    return isObject(x) && isFunction(x[Symbol.iterator]);
-  };
-  var isAsyncIterable = (x) => {
-    return isObject(x) && isFunction(x[Symbol.asyncIterator]);
-  };
-  var isArrowJSON = (x) => {
-    return isObject(x) && isObject(x["schema"]);
-  };
-  var isIteratorResult = (x) => {
-    return isObject(x) && "done" in x && "value" in x;
-  };
-  var isFileHandle = (x) => {
-    return isObject(x) && isFunction(x["stat"]) && isNumber(x["fd"]);
-  };
-  var isFetchResponse = (x) => {
-    return isObject(x) && isReadableDOMStream(x["body"]);
-  };
-  var isReadableInterop = (x) => "_getDOMStream" in x && "_getNodeStream" in x;
-  var isWritableDOMStream = (x) => {
-    return isObject(x) && isFunction(x["abort"]) && isFunction(x["getWriter"]) && !isReadableInterop(x);
-  };
-  var isReadableDOMStream = (x) => {
-    return isObject(x) && isFunction(x["cancel"]) && isFunction(x["getReader"]) && !isReadableInterop(x);
-  };
-  var isWritableNodeStream = (x) => {
-    return isObject(x) && isFunction(x["end"]) && isFunction(x["write"]) && isBoolean(x["writable"]) && !isReadableInterop(x);
-  };
-  var isReadableNodeStream = (x) => {
-    return isObject(x) && isFunction(x["read"]) && isFunction(x["pipe"]) && isBoolean(x["readable"]) && !isReadableInterop(x);
-  };
-  var isFlatbuffersByteBuffer = (x) => {
-    return isObject(x) && isFunction(x["clear"]) && isFunction(x["bytes"]) && isFunction(x["position"]) && isFunction(x["setPosition"]) && isFunction(x["capacity"]) && isFunction(x["getBufferIdentifier"]) && isFunction(x["createLong"]);
-  };
-
-  // ../../node_modules/apache-arrow/util/buffer.mjs
-  var SharedArrayBuf = typeof SharedArrayBuffer !== "undefined" ? SharedArrayBuffer : ArrayBuffer;
-  function collapseContiguousByteRanges(chunks) {
-    const result = chunks[0] ? [chunks[0]] : [];
-    let xOffset, yOffset, xLen, yLen;
-    for (let x, y, i = 0, j = 0, n = chunks.length; ++i < n; ) {
-      x = result[j];
-      y = chunks[i];
-      if (!x || !y || x.buffer !== y.buffer || y.byteOffset < x.byteOffset) {
-        y && (result[++j] = y);
-        continue;
-      }
-      ({ byteOffset: xOffset, byteLength: xLen } = x);
-      ({ byteOffset: yOffset, byteLength: yLen } = y);
-      if (xOffset + xLen < yOffset || yOffset + yLen < xOffset) {
-        y && (result[++j] = y);
-        continue;
-      }
-      result[j] = new Uint8Array(x.buffer, xOffset, yOffset - xOffset + yLen);
-    }
-    return result;
-  }
-  function memcpy(target, source, targetByteOffset = 0, sourceByteLength = source.byteLength) {
-    const targetByteLength = target.byteLength;
-    const dst = new Uint8Array(target.buffer, target.byteOffset, targetByteLength);
-    const src = new Uint8Array(source.buffer, source.byteOffset, Math.min(sourceByteLength, targetByteLength));
-    dst.set(src, targetByteOffset);
-    return target;
-  }
-  function joinUint8Arrays(chunks, size) {
-    const result = collapseContiguousByteRanges(chunks);
-    const byteLength = result.reduce((x, b) => x + b.byteLength, 0);
-    let source, sliced, buffer;
-    let offset = 0, index = -1;
-    const length = Math.min(size || Number.POSITIVE_INFINITY, byteLength);
-    for (const n = result.length; ++index < n; ) {
-      source = result[index];
-      sliced = source.subarray(0, Math.min(source.length, length - offset));
-      if (length <= offset + sliced.length) {
-        if (sliced.length < source.length) {
-          result[index] = source.subarray(sliced.length);
-        } else if (sliced.length === source.length) {
-          index++;
-        }
-        buffer ? memcpy(buffer, sliced, offset) : buffer = sliced;
-        break;
-      }
-      memcpy(buffer || (buffer = new Uint8Array(length)), sliced, offset);
-      offset += sliced.length;
-    }
-    return [buffer || new Uint8Array(0), result.slice(index), byteLength - (buffer ? buffer.byteLength : 0)];
-  }
-  function toArrayBufferView(ArrayBufferViewCtor, input) {
-    let value = isIteratorResult(input) ? input.value : input;
-    if (value instanceof ArrayBufferViewCtor) {
-      if (ArrayBufferViewCtor === Uint8Array) {
-        return new ArrayBufferViewCtor(value.buffer, value.byteOffset, value.byteLength);
-      }
-      return value;
-    }
-    if (!value) {
-      return new ArrayBufferViewCtor(0);
-    }
-    if (typeof value === "string") {
-      value = encodeUtf8(value);
-    }
-    if (value instanceof ArrayBuffer) {
-      return new ArrayBufferViewCtor(value);
-    }
-    if (value instanceof SharedArrayBuf) {
-      return new ArrayBufferViewCtor(value);
-    }
-    if (isFlatbuffersByteBuffer(value)) {
-      return toArrayBufferView(ArrayBufferViewCtor, value.bytes());
-    }
-    return !ArrayBuffer.isView(value) ? ArrayBufferViewCtor.from(value) : value.byteLength <= 0 ? new ArrayBufferViewCtor(0) : new ArrayBufferViewCtor(value.buffer, value.byteOffset, value.byteLength / ArrayBufferViewCtor.BYTES_PER_ELEMENT);
-  }
-  var toInt8Array = (input) => toArrayBufferView(Int8Array, input);
-  var toInt16Array = (input) => toArrayBufferView(Int16Array, input);
-  var toInt32Array = (input) => toArrayBufferView(Int32Array, input);
-  var toBigInt64Array = (input) => toArrayBufferView(BigInt64Array, input);
-  var toUint8Array = (input) => toArrayBufferView(Uint8Array, input);
-  var toUint16Array = (input) => toArrayBufferView(Uint16Array, input);
-  var toUint32Array = (input) => toArrayBufferView(Uint32Array, input);
-  var toBigUint64Array = (input) => toArrayBufferView(BigUint64Array, input);
-  var toFloat32Array = (input) => toArrayBufferView(Float32Array, input);
-  var toFloat64Array = (input) => toArrayBufferView(Float64Array, input);
-  var toUint8ClampedArray = (input) => toArrayBufferView(Uint8ClampedArray, input);
-  var pump = (iterator) => {
-    iterator.next();
-    return iterator;
-  };
-  function* toArrayBufferViewIterator(ArrayCtor, source) {
-    const wrap = function* (x) {
-      yield x;
-    };
-    const buffers = typeof source === "string" ? wrap(source) : ArrayBuffer.isView(source) ? wrap(source) : source instanceof ArrayBuffer ? wrap(source) : source instanceof SharedArrayBuf ? wrap(source) : !isIterable(source) ? wrap(source) : source;
-    yield* pump(function* (it) {
-      let r = null;
-      do {
-        r = it.next(yield toArrayBufferView(ArrayCtor, r));
-      } while (!r.done);
-    }(buffers[Symbol.iterator]()));
-    return new ArrayCtor();
-  }
-  var toInt8ArrayIterator = (input) => toArrayBufferViewIterator(Int8Array, input);
-  var toInt16ArrayIterator = (input) => toArrayBufferViewIterator(Int16Array, input);
-  var toInt32ArrayIterator = (input) => toArrayBufferViewIterator(Int32Array, input);
-  var toUint8ArrayIterator = (input) => toArrayBufferViewIterator(Uint8Array, input);
-  var toUint16ArrayIterator = (input) => toArrayBufferViewIterator(Uint16Array, input);
-  var toUint32ArrayIterator = (input) => toArrayBufferViewIterator(Uint32Array, input);
-  var toFloat32ArrayIterator = (input) => toArrayBufferViewIterator(Float32Array, input);
-  var toFloat64ArrayIterator = (input) => toArrayBufferViewIterator(Float64Array, input);
-  var toUint8ClampedArrayIterator = (input) => toArrayBufferViewIterator(Uint8ClampedArray, input);
-  function toArrayBufferViewAsyncIterator(ArrayCtor, source) {
-    return __asyncGenerator(this, arguments, function* toArrayBufferViewAsyncIterator_1() {
-      if (isPromise(source)) {
-        return yield __await(yield __await(yield* __asyncDelegator(__asyncValues(toArrayBufferViewAsyncIterator(ArrayCtor, yield __await(source))))));
-      }
-      const wrap = function(x) {
-        return __asyncGenerator(this, arguments, function* () {
-          yield yield __await(yield __await(x));
-        });
-      };
-      const emit = function(source2) {
-        return __asyncGenerator(this, arguments, function* () {
-          yield __await(yield* __asyncDelegator(__asyncValues(pump(function* (it) {
-            let r = null;
-            do {
-              r = it.next(yield r === null || r === void 0 ? void 0 : r.value);
-            } while (!r.done);
-          }(source2[Symbol.iterator]())))));
-        });
-      };
-      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(
-        // 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());
-    });
-  }
-  var toInt8ArrayAsyncIterator = (input) => toArrayBufferViewAsyncIterator(Int8Array, input);
-  var toInt16ArrayAsyncIterator = (input) => toArrayBufferViewAsyncIterator(Int16Array, input);
-  var toInt32ArrayAsyncIterator = (input) => toArrayBufferViewAsyncIterator(Int32Array, input);
-  var toUint8ArrayAsyncIterator = (input) => toArrayBufferViewAsyncIterator(Uint8Array, input);
-  var toUint16ArrayAsyncIterator = (input) => toArrayBufferViewAsyncIterator(Uint16Array, input);
-  var toUint32ArrayAsyncIterator = (input) => toArrayBufferViewAsyncIterator(Uint32Array, input);
-  var toFloat32ArrayAsyncIterator = (input) => toArrayBufferViewAsyncIterator(Float32Array, input);
-  var toFloat64ArrayAsyncIterator = (input) => toArrayBufferViewAsyncIterator(Float64Array, input);
-  var toUint8ClampedArrayAsyncIterator = (input) => toArrayBufferViewAsyncIterator(Uint8ClampedArray, input);
-  function rebaseValueOffsets(offset, length, valueOffsets) {
-    if (offset !== 0) {
-      valueOffsets = valueOffsets.slice(0, length);
-      for (let i = -1, n = valueOffsets.length; ++i < n; ) {
-        valueOffsets[i] += offset;
-      }
-    }
-    return valueOffsets.subarray(0, length);
-  }
-  function compareArrayLike(a, b) {
-    let i = 0;
-    const n = a.length;
-    if (n !== b.length) {
-      return false;
-    }
-    if (n > 0) {
-      do {
-        if (a[i] !== b[i]) {
-          return false;
-        }
-      } while (++i < n);
-    }
-    return true;
-  }
-
-  // ../../node_modules/apache-arrow/io/adapters.mjs
-  var adapters_default = {
-    fromIterable(source) {
-      return pump2(fromIterable(source));
-    },
-    fromAsyncIterable(source) {
-      return pump2(fromAsyncIterable(source));
-    },
-    fromDOMStream(source) {
-      return pump2(fromDOMStream(source));
-    },
-    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`);
-    }
-  };
-  var pump2 = (iterator) => {
-    iterator.next();
-    return iterator;
-  };
-  function* fromIterable(source) {
-    let done, threw = false;
-    let buffers = [], buffer;
-    let cmd, size, bufferLength = 0;
-    function byteRange() {
-      if (cmd === "peek") {
-        return joinUint8Arrays(buffers, size)[0];
-      }
-      [buffer, buffers, bufferLength] = joinUint8Arrays(buffers, size);
-      return buffer;
-    }
-    ({ cmd, size } = (yield (() => null)()) || { cmd: "read", size: 0 });
-    const it = toUint8ArrayIterator(source)[Symbol.iterator]();
-    try {
-      do {
-        ({ done, value: buffer } = Number.isNaN(size - bufferLength) ? it.next() : it.next(size - bufferLength));
-        if (!done && buffer.byteLength > 0) {
-          buffers.push(buffer);
-          bufferLength += buffer.byteLength;
-        }
-        if (done || size <= bufferLength) {
-          do {
-            ({ cmd, size } = yield byteRange());
-          } while (size < bufferLength);
-        }
-      } while (!done);
-    } catch (e) {
-      (threw = true) && typeof it.throw === "function" && it.throw(e);
-    } finally {
-      threw === false && typeof it.return === "function" && it.return(null);
-    }
-    return null;
-  }
-  function fromAsyncIterable(source) {
-    return __asyncGenerator(this, arguments, function* fromAsyncIterable_1() {
-      let done, threw = false;
-      let buffers = [], buffer;
-      let cmd, size, bufferLength = 0;
-      function byteRange() {
-        if (cmd === "peek") {
-          return joinUint8Arrays(buffers, size)[0];
-        }
-        [buffer, buffers, bufferLength] = joinUint8Arrays(buffers, size);
-        return buffer;
-      }
-      ({ cmd, size } = (yield yield __await((() => null)())) || { cmd: "read", size: 0 });
-      const it = toUint8ArrayAsyncIterator(source)[Symbol.asyncIterator]();
-      try {
-        do {
-          ({ done, value: buffer } = Number.isNaN(size - bufferLength) ? yield __await(it.next()) : yield __await(it.next(size - bufferLength)));
-          if (!done && buffer.byteLength > 0) {
-            buffers.push(buffer);
-            bufferLength += buffer.byteLength;
-          }
-          if (done || size <= bufferLength) {
-            do {
-              ({ cmd, size } = yield yield __await(byteRange()));
-            } while (size < bufferLength);
-          }
-        } while (!done);
-      } catch (e) {
-        (threw = true) && typeof it.throw === "function" && (yield __await(it.throw(e)));
-      } finally {
-        threw === false && typeof it.return === "function" && (yield __await(it.return(new Uint8Array(0))));
-      }
-      return yield __await(null);
-    });
-  }
-  function fromDOMStream(source) {
-    return __asyncGenerator(this, arguments, function* fromDOMStream_1() {
-      let done = false, threw = false;
-      let buffers = [], buffer;
-      let cmd, size, bufferLength = 0;
-      function byteRange() {
-        if (cmd === "peek") {
-          return joinUint8Arrays(buffers, size)[0];
-        }
-        [buffer, buffers, bufferLength] = joinUint8Arrays(buffers, size);
-        return buffer;
-      }
-      ({ cmd, size } = (yield yield __await((() => null)())) || { cmd: "read", size: 0 });
-      const it = new AdaptiveByteReader(source);
-      try {
-        do {
-          ({ done, value: buffer } = Number.isNaN(size - bufferLength) ? yield __await(it["read"]()) : yield __await(it["read"](size - bufferLength)));
-          if (!done && buffer.byteLength > 0) {
-            buffers.push(toUint8Array(buffer));
-            bufferLength += buffer.byteLength;
-          }
-          if (done || size <= bufferLength) {
-            do {
-              ({ cmd, size } = yield yield __await(byteRange()));
-            } while (size < bufferLength);
-          }
-        } while (!done);
-      } catch (e) {
-        (threw = true) && (yield __await(it["cancel"](e)));
-      } finally {
-        threw === false ? yield __await(it["cancel"]()) : source["locked"] && it.releaseLock();
-      }
-      return yield __await(null);
-    });
-  }
-  var AdaptiveByteReader = class {
-    constructor(source) {
-      this.source = source;
-      this.reader = null;
-      this.reader = this.source["getReader"]();
-      this.reader["closed"].catch(() => {
-      });
-    }
-    get closed() {
-      return this.reader ? this.reader["closed"].catch(() => {
-      }) : Promise.resolve();
-    }
-    releaseLock() {
-      if (this.reader) {
-        this.reader.releaseLock();
-      }
-      this.reader = null;
-    }
-    cancel(reason) {
-      return __awaiter(this, void 0, void 0, function* () {
-        const { reader, source } = this;
-        reader && (yield reader["cancel"](reason).catch(() => {
-        }));
-        source && (source["locked"] && this.releaseLock());
-      });
-    }
-    read(size) {
-      return __awaiter(this, void 0, void 0, function* () {
-        if (size === 0) {
-          return { done: this.reader == null, value: new Uint8Array(0) };
-        }
-        const result = yield this.reader.read();
-        !result.done && (result.value = toUint8Array(result));
-        return result;
-      });
+    read(size) {
+      return __awaiter(this, void 0, void 0, function* () {
+        if (size === 0) {
+          return { done: this.reader == null, value: new Uint8Array(0) };
+        }
+        const result = yield this.reader.read();
+        !result.done && (result.value = toUint8Array(result));
+        return result;
+      });
     }
   };
   var onEvent = (stream, event) => {
@@ -11395,905 +11020,1409 @@ return true;`);
         }
       }
     }
-    _readFooter() {
-      const { _handle } = this;
-      const offset = _handle.size - magicAndPadding;
-      const length = _handle.readInt32(offset);
-      const buffer = _handle.readAt(offset - length, length);
-      return Footer_.decode(buffer);
+    _readFooter() {
+      const { _handle } = this;
+      const offset = _handle.size - magicAndPadding;
+      const length = _handle.readInt32(offset);
+      const buffer = _handle.readAt(offset - length, length);
+      return Footer_.decode(buffer);
+    }
+    _readNextMessageAndValidate(type) {
+      var _a5;
+      if (!this._footer) {
+        this.open();
+      }
+      if (this._footer && this._recordBatchIndex < this.numRecordBatches) {
+        const block = (_a5 = this._footer) === null || _a5 === void 0 ? void 0 : _a5.getRecordBatch(this._recordBatchIndex);
+        if (block && this._handle.seek(block.offset)) {
+          return this._reader.readMessage(type);
+        }
+      }
+      return null;
+    }
+  };
+  var AsyncRecordBatchFileReaderImpl = class extends AsyncRecordBatchStreamReaderImpl {
+    get footer() {
+      return this._footer;
+    }
+    get numDictionaries() {
+      return this._footer ? this._footer.numDictionaries : 0;
+    }
+    get numRecordBatches() {
+      return this._footer ? this._footer.numRecordBatches : 0;
+    }
+    constructor(source, ...rest) {
+      const byteLength = typeof rest[0] !== "number" ? rest.shift() : void 0;
+      const dictionaries = rest[0] instanceof Map ? rest.shift() : void 0;
+      super(source instanceof AsyncRandomAccessFile ? source : new AsyncRandomAccessFile(source, byteLength), dictionaries);
+    }
+    isFile() {
+      return true;
+    }
+    isAsync() {
+      return true;
+    }
+    open(options) {
+      const _super = Object.create(null, {
+        open: { get: () => super.open }
+      });
+      return __awaiter(this, void 0, void 0, function* () {
+        if (!this.closed && !this._footer) {
+          this.schema = (this._footer = yield this._readFooter()).schema;
+          for (const block of this._footer.dictionaryBatches()) {
+            block && (yield this._readDictionaryBatch(this._dictionaryIndex++));
+          }
+        }
+        return yield _super.open.call(this, options);
+      });
+    }
+    readRecordBatch(index) {
+      var _a5;
+      return __awaiter(this, void 0, void 0, function* () {
+        if (this.closed) {
+          return null;
+        }
+        if (!this._footer) {
+          yield this.open();
+        }
+        const block = (_a5 = this._footer) === null || _a5 === void 0 ? void 0 : _a5.getRecordBatch(index);
+        if (block && (yield this._handle.seek(block.offset))) {
+          const message = yield this._reader.readMessage(MessageHeader.RecordBatch);
+          if (message === null || message === void 0 ? void 0 : message.isRecordBatch()) {
+            const header = message.header();
+            const buffer = yield this._reader.readMessageBody(message.bodyLength);
+            const recordBatch = this._loadRecordBatch(header, buffer);
+            return recordBatch;
+          }
+        }
+        return null;
+      });
+    }
+    _readDictionaryBatch(index) {
+      var _a5;
+      return __awaiter(this, void 0, void 0, function* () {
+        const block = (_a5 = this._footer) === null || _a5 === void 0 ? void 0 : _a5.getDictionaryBatch(index);
+        if (block && (yield this._handle.seek(block.offset))) {
+          const message = yield this._reader.readMessage(MessageHeader.DictionaryBatch);
+          if (message === null || message === void 0 ? void 0 : message.isDictionaryBatch()) {
+            const header = message.header();
+            const buffer = yield this._reader.readMessageBody(message.bodyLength);
+            const vector = this._loadDictionaryBatch(header, buffer);
+            this.dictionaries.set(header.id, vector);
+          }
+        }
+      });
+    }
+    _readFooter() {
+      return __awaiter(this, void 0, void 0, function* () {
+        const { _handle } = this;
+        _handle._pending && (yield _handle._pending);
+        const offset = _handle.size - magicAndPadding;
+        const length = yield _handle.readInt32(offset);
+        const buffer = yield _handle.readAt(offset - length, length);
+        return Footer_.decode(buffer);
+      });
+    }
+    _readNextMessageAndValidate(type) {
+      return __awaiter(this, void 0, void 0, function* () {
+        if (!this._footer) {
+          yield this.open();
+        }
+        if (this._footer && this._recordBatchIndex < this.numRecordBatches) {
+          const block = this._footer.getRecordBatch(this._recordBatchIndex);
+          if (block && (yield this._handle.seek(block.offset))) {
+            return yield this._reader.readMessage(type);
+          }
+        }
+        return null;
+      });
+    }
+  };
+  var RecordBatchJSONReaderImpl = class extends RecordBatchStreamReaderImpl {
+    constructor(source, dictionaries) {
+      super(source, dictionaries);
+    }
+    _loadVectors(header, body, types) {
+      return new JSONVectorLoader(body, header.nodes, header.buffers, this.dictionaries, this.schema.metadataVersion).visitMany(types);
+    }
+  };
+  function shouldAutoDestroy(self2, options) {
+    return options && typeof options["autoDestroy"] === "boolean" ? options["autoDestroy"] : self2["autoDestroy"];
+  }
+  function* readAllSync(source) {
+    const reader = RecordBatchReader.from(source);
+    try {
+      if (!reader.open({ autoDestroy: false }).closed) {
+        do {
+          yield reader;
+        } while (!reader.reset().open().closed);
+      }
+    } finally {
+      reader.cancel();
+    }
+  }
+  function readAllAsync(source) {
+    return __asyncGenerator(this, arguments, function* readAllAsync_1() {
+      const reader = yield __await(RecordBatchReader.from(source));
+      try {
+        if (!(yield __await(reader.open({ autoDestroy: false }))).closed) {
+          do {
+            yield yield __await(reader);
+          } while (!(yield __await(reader.reset().open())).closed);
+        }
+      } finally {
+        yield __await(reader.cancel());
+      }
+    });
+  }
+  function fromArrowJSON(source) {
+    return new RecordBatchStreamReader(new RecordBatchJSONReaderImpl(source));
+  }
+  function fromByteStream(source) {
+    const bytes = source.peek(magicLength + 7 & ~7);
+    return bytes && bytes.byteLength >= 4 ? !checkForMagicArrowString(bytes) ? new RecordBatchStreamReader(new RecordBatchStreamReaderImpl(source)) : new RecordBatchFileReader(new RecordBatchFileReaderImpl(source.read())) : new RecordBatchStreamReader(new RecordBatchStreamReaderImpl(function* () {
+    }()));
+  }
+  function fromAsyncByteStream(source) {
+    return __awaiter(this, void 0, void 0, function* () {
+      const bytes = yield source.peek(magicLength + 7 & ~7);
+      return bytes && bytes.byteLength >= 4 ? !checkForMagicArrowString(bytes) ? new AsyncRecordBatchStreamReader(new AsyncRecordBatchStreamReaderImpl(source)) : new RecordBatchFileReader(new RecordBatchFileReaderImpl(yield source.read())) : new AsyncRecordBatchStreamReader(new AsyncRecordBatchStreamReaderImpl(function() {
+        return __asyncGenerator(this, arguments, function* () {
+        });
+      }()));
+    });
+  }
+  function fromFileHandle(source) {
+    return __awaiter(this, void 0, void 0, function* () {
+      const { size } = yield source.stat();
+      const file = new AsyncRandomAccessFile(source, size);
+      if (size >= magicX2AndPadding && checkForMagicArrowString(yield file.readAt(0, magicLength + 7 & ~7))) {
+        return new AsyncRecordBatchFileReader(new AsyncRecordBatchFileReaderImpl(file));
+      }
+      return new AsyncRecordBatchStreamReader(new AsyncRecordBatchStreamReaderImpl(file));
+    });
+  }
+
+  // ../../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 RecordBatch2 ? node.data.children : node.data);
+      const assembler = new VectorAssembler();
+      assembler.visitMany(unwrap(args));
+      return assembler;
+    }
+    constructor() {
+      super();
+      this._byteLength = 0;
+      this._nodes = [];
+      this._buffers = [];
+      this._bufferRegions = [];
     }
-    _readNextMessageAndValidate(type) {
-      var _a5;
-      if (!this._footer) {
-        this.open();
+    visit(data) {
+      if (data instanceof Vector) {
+        this.visitMany(data.data);
+        return this;
       }
-      if (this._footer && this._recordBatchIndex < this.numRecordBatches) {
-        const block = (_a5 = this._footer) === null || _a5 === void 0 ? void 0 : _a5.getRecordBatch(this._recordBatchIndex);
-        if (block && this._handle.seek(block.offset)) {
-          return this._reader.readMessage(type);
+      const { type } = data;
+      if (!DataType.isDictionary(type)) {
+        const { length } = data;
+        if (length > 2147483647) {
+          throw new RangeError("Cannot write arrays larger than 2^31 - 1 in length");
+        }
+        if (DataType.isUnion(type)) {
+          this.nodes.push(new FieldNode2(length, 0));
+        } else {
+          const { nullCount } = data;
+          if (!DataType.isNull(type)) {
+            addBuffer.call(this, nullCount <= 0 ? new Uint8Array(0) : truncateBitmap(data.offset, length, data.nullBitmap));
+          }
+          this.nodes.push(new FieldNode2(length, nullCount));
         }
       }
-      return null;
+      return super.visit(data);
     }
-  };
-  var AsyncRecordBatchFileReaderImpl = class extends AsyncRecordBatchStreamReaderImpl {
-    get footer() {
-      return this._footer;
+    visitNull(_null) {
+      return this;
     }
-    get numDictionaries() {
-      return this._footer ? this._footer.numDictionaries : 0;
+    visitDictionary(data) {
+      return this.visit(data.clone(data.type.indices));
     }
-    get numRecordBatches() {
-      return this._footer ? this._footer.numRecordBatches : 0;
+    get nodes() {
+      return this._nodes;
     }
-    constructor(source, ...rest) {
-      const byteLength = typeof rest[0] !== "number" ? rest.shift() : void 0;
-      const dictionaries = rest[0] instanceof Map ? rest.shift() : void 0;
-      super(source instanceof AsyncRandomAccessFile ? source : new AsyncRandomAccessFile(source, byteLength), dictionaries);
+    get buffers() {
+      return this._buffers;
     }
-    isFile() {
-      return true;
+    get byteLength() {
+      return this._byteLength;
     }
-    isAsync() {
-      return true;
+    get bufferRegions() {
+      return this._bufferRegions;
     }
-    open(options) {
-      const _super = Object.create(null, {
-        open: { get: () => super.open }
-      });
-      return __awaiter(this, void 0, void 0, function* () {
-        if (!this.closed && !this._footer) {
-          this.schema = (this._footer = yield this._readFooter()).schema;
-          for (const block of this._footer.dictionaryBatches()) {
-            block && (yield this._readDictionaryBatch(this._dictionaryIndex++));
+  };
+  function addBuffer(values) {
+    const byteLength = values.byteLength + 7 & ~7;
+    this.buffers.push(values);
+    this.bufferRegions.push(new BufferRegion(this._byteLength, byteLength));
+    this._byteLength += byteLength;
+    return this;
+  }
+  function assembleUnion(data) {
+    var _a5;
+    const { type, length, typeIds, valueOffsets } = data;
+    addBuffer.call(this, typeIds);
+    if (type.mode === UnionMode.Sparse) {
+      return assembleNestedVector.call(this, data);
+    } else if (type.mode === UnionMode.Dense) {
+      if (data.offset <= 0) {
+        addBuffer.call(this, valueOffsets);
+        return assembleNestedVector.call(this, data);
+      } else {
+        const shiftedOffsets = new Int32Array(length);
+        const childOffsets = /* @__PURE__ */ Object.create(null);
+        const childLengths = /* @__PURE__ */ Object.create(null);
+        for (let typeId, shift, index = -1; ++index < length; ) {
+          if ((typeId = typeIds[index]) === void 0) {
+            continue;
           }
-        }
-        return yield _super.open.call(this, options);
-      });
-    }
-    readRecordBatch(index) {
-      var _a5;
-      return __awaiter(this, void 0, void 0, function* () {
-        if (this.closed) {
-          return null;
-        }
-        if (!this._footer) {
-          yield this.open();
-        }
-        const block = (_a5 = this._footer) === null || _a5 === void 0 ? void 0 : _a5.getRecordBatch(index);
-        if (block && (yield this._handle.seek(block.offset))) {
-          const message = yield this._reader.readMessage(MessageHeader.RecordBatch);
-          if (message === null || message === void 0 ? void 0 : message.isRecordBatch()) {
-            const header = message.header();
-            const buffer = yield this._reader.readMessageBody(message.bodyLength);
-            const recordBatch = this._loadRecordBatch(header, buffer);
-            return recordBatch;
+          if ((shift = childOffsets[typeId]) === void 0) {
+            shift = childOffsets[typeId] = valueOffsets[index];
           }
+          shiftedOffsets[index] = valueOffsets[index] - shift;
+          childLengths[typeId] = ((_a5 = childLengths[typeId]) !== null && _a5 !== void 0 ? _a5 : 0) + 1;
         }
-        return null;
-      });
+        addBuffer.call(this, shiftedOffsets);
+        this.visitMany(data.children.map((child, childIndex) => {
+          const typeId = type.typeIds[childIndex];
+          const childOffset = childOffsets[typeId];
+          const childLength = childLengths[typeId];
+          return child.slice(childOffset, Math.min(length, childLength));
+        }));
+      }
+    }
+    return this;
+  }
+  function assembleBoolVector(data) {
+    let values;
+    if (data.nullCount >= data.length) {
+      return addBuffer.call(this, new Uint8Array(0));
+    } else if ((values = data.values) instanceof Uint8Array) {
+      return addBuffer.call(this, truncateBitmap(data.offset, data.length, values));
+    }
+    return addBuffer.call(this, packBools(data.values));
+  }
+  function assembleFlatVector(data) {
+    return addBuffer.call(this, data.values.subarray(0, data.length * data.stride));
+  }
+  function assembleFlatListVector(data) {
+    const { length, values, valueOffsets } = data;
+    const begin = bigIntToNumber(valueOffsets[0]);
+    const end = bigIntToNumber(valueOffsets[length]);
+    const byteLength = Math.min(end - begin, values.byteLength - begin);
+    addBuffer.call(this, rebaseValueOffsets(-begin, length + 1, valueOffsets));
+    addBuffer.call(this, values.subarray(begin, begin + byteLength));
+    return this;
+  }
+  function assembleListVector(data) {
+    const { length, valueOffsets } = data;
+    if (valueOffsets) {
+      const { [0]: begin, [length]: end } = valueOffsets;
+      addBuffer.call(this, rebaseValueOffsets(-begin, length + 1, valueOffsets));
+      return this.visit(data.children[0].slice(begin, end - begin));
+    }
+    return this.visit(data.children[0]);
+  }
+  function assembleNestedVector(data) {
+    return this.visitMany(data.type.children.map((_, i) => data.children[i]).filter(Boolean))[0];
+  }
+  VectorAssembler.prototype.visitBool = assembleBoolVector;
+  VectorAssembler.prototype.visitInt = assembleFlatVector;
+  VectorAssembler.prototype.visitFloat = assembleFlatVector;
+  VectorAssembler.prototype.visitUtf8 = assembleFlatListVector;
+  VectorAssembler.prototype.visitLargeUtf8 = assembleFlatListVector;
+  VectorAssembler.prototype.visitBinary = assembleFlatListVector;
+  VectorAssembler.prototype.visitLargeBinary = assembleFlatListVector;
+  VectorAssembler.prototype.visitFixedSizeBinary = assembleFlatVector;
+  VectorAssembler.prototype.visitDate = assembleFlatVector;
+  VectorAssembler.prototype.visitTimestamp = assembleFlatVector;
+  VectorAssembler.prototype.visitTime = assembleFlatVector;
+  VectorAssembler.prototype.visitDecimal = assembleFlatVector;
+  VectorAssembler.prototype.visitList = assembleListVector;
+  VectorAssembler.prototype.visitStruct = assembleNestedVector;
+  VectorAssembler.prototype.visitUnion = assembleUnion;
+  VectorAssembler.prototype.visitInterval = assembleFlatVector;
+  VectorAssembler.prototype.visitDuration = assembleFlatVector;
+  VectorAssembler.prototype.visitFixedSizeList = assembleListVector;
+  VectorAssembler.prototype.visitMap = assembleListVector;
+
+  // ../../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`);
+    }
+    constructor(options) {
+      super();
+      this._position = 0;
+      this._started = false;
+      this._sink = new AsyncByteQueue();
+      this._schema = null;
+      this._dictionaryBlocks = [];
+      this._recordBatchBlocks = [];
+      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;
+    }
+    toString(sync = false) {
+      return this._sink.toString(sync);
+    }
+    toUint8Array(sync = false) {
+      return this._sink.toUint8Array(sync);
     }
-    _readDictionaryBatch(index) {
-      var _a5;
-      return __awaiter(this, void 0, void 0, function* () {
-        const block = (_a5 = this._footer) === null || _a5 === void 0 ? void 0 : _a5.getDictionaryBatch(index);
-        if (block && (yield this._handle.seek(block.offset))) {
-          const message = yield this._reader.readMessage(MessageHeader.DictionaryBatch);
-          if (message === null || message === void 0 ? void 0 : message.isDictionaryBatch()) {
-            const header = message.header();
-            const buffer = yield this._reader.readMessageBody(message.bodyLength);
-            const vector = this._loadDictionaryBatch(header, buffer);
-            this.dictionaries.set(header.id, vector);
-          }
-        }
-      });
+    writeAll(input) {
+      if (isPromise(input)) {
+        return input.then((x) => this.writeAll(x));
+      } else if (isAsyncIterable(input)) {
+        return writeAllAsync(this, input);
+      }
+      return writeAll(this, input);
     }
-    _readFooter() {
-      return __awaiter(this, void 0, void 0, function* () {
-        const { _handle } = this;
-        _handle._pending && (yield _handle._pending);
-        const offset = _handle.size - magicAndPadding;
-        const length = yield _handle.readInt32(offset);
-        const buffer = yield _handle.readAt(offset - length, length);
-        return Footer_.decode(buffer);
-      });
+    get closed() {
+      return this._sink.closed;
     }
-    _readNextMessageAndValidate(type) {
-      return __awaiter(this, void 0, void 0, function* () {
-        if (!this._footer) {
-          yield this.open();
-        }
-        if (this._footer && this._recordBatchIndex < this.numRecordBatches) {
-          const block = this._footer.getRecordBatch(this._recordBatchIndex);
-          if (block && (yield this._handle.seek(block.offset))) {
-            return yield this._reader.readMessage(type);
-          }
-        }
-        return null;
-      });
+    [Symbol.asyncIterator]() {
+      return this._sink[Symbol.asyncIterator]();
     }
-  };
-  var RecordBatchJSONReaderImpl = class extends RecordBatchStreamReaderImpl {
-    constructor(source, dictionaries) {
-      super(source, dictionaries);
+    toDOMStream(options) {
+      return this._sink.toDOMStream(options);
     }
-    _loadVectors(header, body, types) {
-      return new JSONVectorLoader(body, header.nodes, header.buffers, this.dictionaries, this.schema.metadataVersion).visitMany(types);
+    toNodeStream(options) {
+      return this._sink.toNodeStream(options);
     }
-  };
-  function shouldAutoDestroy(self2, options) {
-    return options && typeof options["autoDestroy"] === "boolean" ? options["autoDestroy"] : self2["autoDestroy"];
-  }
-  function* readAllSync(source) {
-    const reader = RecordBatchReader.from(source);
-    try {
-      if (!reader.open({ autoDestroy: false }).closed) {
-        do {
-          yield reader;
-        } while (!reader.reset().open().closed);
-      }
-    } finally {
-      reader.cancel();
+    close() {
+      return this.reset()._sink.close();
     }
-  }
-  function readAllAsync(source) {
-    return __asyncGenerator(this, arguments, function* readAllAsync_1() {
-      const reader = yield __await(RecordBatchReader.from(source));
-      try {
-        if (!(yield __await(reader.open({ autoDestroy: false }))).closed) {
-          do {
-            yield yield __await(reader);
-          } while (!(yield __await(reader.reset().open())).closed);
+    abort(reason) {
+      return this.reset()._sink.abort(reason);
+    }
+    finish() {
+      this._autoDestroy ? this.close() : this.reset(this._sink, this._schema);
+      return this;
+    }
+    reset(sink = this._sink, schema = null) {
+      if (sink === this._sink || sink instanceof AsyncByteQueue) {
+        this._sink = sink;
+      } else {
+        this._sink = new AsyncByteQueue();
+        if (sink && isWritableDOMStream(sink)) {
+          this.toDOMStream({ type: "bytes" }).pipeTo(sink);
+        } else if (sink && isWritableNodeStream(sink)) {
+          this.toNodeStream({ objectMode: false }).pipe(sink);
         }
-      } finally {
-        yield __await(reader.cancel());
       }
-    });
-  }
-  function fromArrowJSON(source) {
-    return new RecordBatchStreamReader(new RecordBatchJSONReaderImpl(source));
-  }
-  function fromByteStream(source) {
-    const bytes = source.peek(magicLength + 7 & ~7);
-    return bytes && bytes.byteLength >= 4 ? !checkForMagicArrowString(bytes) ? new RecordBatchStreamReader(new RecordBatchStreamReaderImpl(source)) : new RecordBatchFileReader(new RecordBatchFileReaderImpl(source.read())) : new RecordBatchStreamReader(new RecordBatchStreamReaderImpl(function* () {
-    }()));
-  }
-  function fromAsyncByteStream(source) {
-    return __awaiter(this, void 0, void 0, function* () {
-      const bytes = yield source.peek(magicLength + 7 & ~7);
-      return bytes && bytes.byteLength >= 4 ? !checkForMagicArrowString(bytes) ? new AsyncRecordBatchStreamReader(new AsyncRecordBatchStreamReaderImpl(source)) : new RecordBatchFileReader(new RecordBatchFileReaderImpl(yield source.read())) : new AsyncRecordBatchStreamReader(new AsyncRecordBatchStreamReaderImpl(function() {
-        return __asyncGenerator(this, arguments, function* () {
-        });
-      }()));
-    });
-  }
-  function fromFileHandle(source) {
-    return __awaiter(this, void 0, void 0, function* () {
-      const { size } = yield source.stat();
-      const file = new AsyncRandomAccessFile(source, size);
-      if (size >= magicX2AndPadding && checkForMagicArrowString(yield file.readAt(0, magicLength + 7 & ~7))) {
-        return new AsyncRecordBatchFileReader(new AsyncRecordBatchFileReaderImpl(file));
+      if (this._started && this._schema) {
+        this._writeFooter(this._schema);
       }
-      return new AsyncRecordBatchStreamReader(new AsyncRecordBatchStreamReaderImpl(file));
-    });
-  }
-
-  // ../../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 RecordBatch2 ? node.data.children : node.data);
-      const assembler = new VectorAssembler();
-      assembler.visitMany(unwrap(args));
-      return assembler;
+      this._started = false;
+      this._dictionaryBlocks = [];
+      this._recordBatchBlocks = [];
+      this._dictionaryDeltaOffsets = /* @__PURE__ */ new Map();
+      if (!schema || !compareSchemas(schema, this._schema)) {
+        if (schema == null) {
+          this._position = 0;
+          this._schema = null;
+        } else {
+          this._started = true;
+          this._schema = schema;
+          this._writeSchema(schema);
+        }
+      }
+      return this;
     }
-    constructor() {
-      super();
-      this._byteLength = 0;
-      this._nodes = [];
-      this._buffers = [];
-      this._bufferRegions = [];
+    write(payload) {
+      let schema = null;
+      if (!this._sink) {
+        throw new Error(`RecordBatchWriter is closed`);
+      } else if (payload == null) {
+        return this.finish() && void 0;
+      } else if (payload instanceof Table && !(schema = payload.schema)) {
+        return this.finish() && void 0;
+      } else if (payload instanceof RecordBatch2 && !(schema = payload.schema)) {
+        return this.finish() && void 0;
+      }
+      if (schema && !compareSchemas(schema, this._schema)) {
+        if (this._started && this._autoDestroy) {
+          return this.close();
+        }
+        this.reset(this._sink, schema);
+      }
+      if (payload instanceof RecordBatch2) {
+        if (!(payload instanceof _InternalEmptyPlaceholderRecordBatch)) {
+          this._writeRecordBatch(payload);
+        }
+      } else if (payload instanceof Table) {
+        this.writeAll(payload.batches);
+      } else if (isIterable(payload)) {
+        this.writeAll(payload);
+      }
     }
-    visit(data) {
-      if (data instanceof Vector) {
-        this.visitMany(data.data);
-        return this;
+    _writeMessage(message, alignment = 8) {
+      const a = alignment - 1;
+      const buffer = Message2.encode(message);
+      const flatbufferSize = buffer.byteLength;
+      const prefixSize = !this._writeLegacyIpcFormat ? 8 : 4;
+      const alignedSize = flatbufferSize + prefixSize + a & ~a;
+      const nPaddingBytes = alignedSize - flatbufferSize - prefixSize;
+      if (message.headerType === MessageHeader.RecordBatch) {
+        this._recordBatchBlocks.push(new FileBlock(alignedSize, message.bodyLength, this._position));
+      } else if (message.headerType === MessageHeader.DictionaryBatch) {
+        this._dictionaryBlocks.push(new FileBlock(alignedSize, message.bodyLength, this._position));
       }
-      const { type } = data;
-      if (!DataType.isDictionary(type)) {
-        const { length } = data;
-        if (length > 2147483647) {
-          throw new RangeError("Cannot write arrays larger than 2^31 - 1 in length");
+      if (!this._writeLegacyIpcFormat) {
+        this._write(Int32Array.of(-1));
+      }
+      this._write(Int32Array.of(alignedSize - prefixSize));
+      if (flatbufferSize > 0) {
+        this._write(buffer);
+      }
+      return this._writePadding(nPaddingBytes);
+    }
+    _write(chunk) {
+      if (this._started) {
+        const buffer = toUint8Array(chunk);
+        if (buffer && buffer.byteLength > 0) {
+          this._sink.write(buffer);
+          this._position += buffer.byteLength;
         }
-        if (DataType.isUnion(type)) {
-          this.nodes.push(new FieldNode2(length, 0));
-        } else {
-          const { nullCount } = data;
-          if (!DataType.isNull(type)) {
-            addBuffer.call(this, nullCount <= 0 ? new Uint8Array(0) : truncateBitmap(data.offset, length, data.nullBitmap));
+      }
+      return this;
+    }
+    _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));
+    }
+    _writeMagic() {
+      return this._write(MAGIC);
+    }
+    _writePadding(nBytes) {
+      return nBytes > 0 ? this._write(new Uint8Array(nBytes)) : this;
+    }
+    _writeRecordBatch(batch) {
+      const { byteLength, nodes, bufferRegions, buffers } = VectorAssembler.assemble(batch);
+      const recordBatch = new RecordBatch3(batch.numRows, nodes, bufferRegions);
+      const message = Message2.from(recordBatch, byteLength);
+      return this._writeDictionaries(batch)._writeMessage(message)._writeBodyBuffers(buffers);
+    }
+    _writeDictionaryBatch(dictionary, id, isDelta = false) {
+      this._dictionaryDeltaOffsets.set(id, dictionary.length + (this._dictionaryDeltaOffsets.get(id) || 0));
+      const { byteLength, nodes, bufferRegions, buffers } = VectorAssembler.assemble(new Vector([dictionary]));
+      const recordBatch = new RecordBatch3(dictionary.length, nodes, bufferRegions);
+      const dictionaryBatch = new DictionaryBatch2(recordBatch, id, isDelta);
+      const message = Message2.from(dictionaryBatch, byteLength);
+      return this._writeMessage(message)._writeBodyBuffers(buffers);
+    }
+    _writeBodyBuffers(buffers) {
+      let buffer;
+      let size, padding;
+      for (let i = -1, n = buffers.length; ++i < n; ) {
+        if ((buffer = buffers[i]) && (size = buffer.byteLength) > 0) {
+          this._write(buffer);
+          if ((padding = (size + 7 & ~7) - size) > 0) {
+            this._writePadding(padding);
           }
-          this.nodes.push(new FieldNode2(length, nullCount));
         }
       }
-      return super.visit(data);
+      return this;
     }
-    visitNull(_null) {
+    _writeDictionaries(batch) {
+      for (let [id, dictionary] of batch.dictionaries) {
+        let offset = this._dictionaryDeltaOffsets.get(id) || 0;
+        if (offset === 0 || (dictionary = dictionary === null || dictionary === void 0 ? void 0 : dictionary.slice(offset)).length > 0) {
+          for (const data of dictionary.data) {
+            this._writeDictionaryBatch(data, id, offset > 0);
+            offset += data.length;
+          }
+        }
+      }
       return this;
     }
-    visitDictionary(data) {
-      return this.visit(data.clone(data.type.indices));
+  };
+  var RecordBatchStreamWriter = class extends RecordBatchWriter {
+    /** @nocollapse */
+    static writeAll(input, options) {
+      const writer = new RecordBatchStreamWriter(options);
+      if (isPromise(input)) {
+        return input.then((x) => writer.writeAll(x));
+      } else if (isAsyncIterable(input)) {
+        return writeAllAsync(writer, input);
+      }
+      return writeAll(writer, input);
     }
-    get nodes() {
-      return this._nodes;
+  };
+  var RecordBatchFileWriter = class extends RecordBatchWriter {
+    /** @nocollapse */
+    static writeAll(input) {
+      const writer = new RecordBatchFileWriter();
+      if (isPromise(input)) {
+        return input.then((x) => writer.writeAll(x));
+      } else if (isAsyncIterable(input)) {
+        return writeAllAsync(writer, input);
+      }
+      return writeAll(writer, input);
     }
-    get buffers() {
-      return this._buffers;
+    constructor() {
+      super();
+      this._autoDestroy = true;
     }
-    get byteLength() {
-      return this._byteLength;
+    // @ts-ignore
+    _writeSchema(schema) {
+      return this._writeMagic()._writePadding(2);
     }
-    get bufferRegions() {
-      return this._bufferRegions;
+    _writeFooter(schema) {
+      const buffer = Footer_.encode(new Footer_(schema, MetadataVersion.V5, this._recordBatchBlocks, this._dictionaryBlocks));
+      return super._writeFooter(schema)._write(buffer)._write(Int32Array.of(buffer.byteLength))._writeMagic();
     }
   };
-  function addBuffer(values) {
-    const byteLength = values.byteLength + 7 & ~7;
-    this.buffers.push(values);
-    this.bufferRegions.push(new BufferRegion(this._byteLength, byteLength));
-    this._byteLength += byteLength;
-    return this;
+  function writeAll(writer, input) {
+    let chunks = input;
+    if (input instanceof Table) {
+      chunks = input.batches;
+      writer.reset(void 0, input.schema);
+    }
+    for (const batch of chunks) {
+      writer.write(batch);
+    }
+    return writer.finish();
   }
-  function assembleUnion(data) {
-    var _a5;
-    const { type, length, typeIds, valueOffsets } = data;
-    addBuffer.call(this, typeIds);
-    if (type.mode === UnionMode.Sparse) {
-      return assembleNestedVector.call(this, data);
-    } else if (type.mode === UnionMode.Dense) {
-      if (data.offset <= 0) {
-        addBuffer.call(this, valueOffsets);
-        return assembleNestedVector.call(this, data);
-      } else {
-        const shiftedOffsets = new Int32Array(length);
-        const childOffsets = /* @__PURE__ */ Object.create(null);
-        const childLengths = /* @__PURE__ */ Object.create(null);
-        for (let typeId, shift, index = -1; ++index < length; ) {
-          if ((typeId = typeIds[index]) === void 0) {
-            continue;
-          }
-          if ((shift = childOffsets[typeId]) === void 0) {
-            shift = childOffsets[typeId] = valueOffsets[index];
-          }
-          shiftedOffsets[index] = valueOffsets[index] - shift;
-          childLengths[typeId] = ((_a5 = childLengths[typeId]) !== null && _a5 !== void 0 ? _a5 : 0) + 1;
+  function writeAllAsync(writer, batches) {
+    var _a5, batches_1, batches_1_1;
+    var _b2, e_1, _c2, _d2;
+    return __awaiter(this, void 0, void 0, function* () {
+      try {
+        for (_a5 = true, batches_1 = __asyncValues(batches); batches_1_1 = yield batches_1.next(), _b2 = batches_1_1.done, !_b2; _a5 = true) {
+          _d2 = batches_1_1.value;
+          _a5 = false;
+          const batch = _d2;
+          writer.write(batch);
+        }
+      } catch (e_1_1) {
+        e_1 = { error: e_1_1 };
+      } finally {
+        try {
+          if (!_a5 && !_b2 && (_c2 = batches_1.return))
+            yield _c2.call(batches_1);
+        } finally {
+          if (e_1)
+            throw e_1.error;
         }
-        addBuffer.call(this, shiftedOffsets);
-        this.visitMany(data.children.map((child, childIndex) => {
-          const typeId = type.typeIds[childIndex];
-          const childOffset = childOffsets[typeId];
-          const childLength = childLengths[typeId];
-          return child.slice(childOffset, Math.min(length, childLength));
-        }));
       }
-    }
-    return this;
+      return writer.finish();
+    });
   }
-  function assembleBoolVector(data) {
-    let values;
-    if (data.nullCount >= data.length) {
-      return addBuffer.call(this, new Uint8Array(0));
-    } else if ((values = data.values) instanceof Uint8Array) {
-      return addBuffer.call(this, truncateBitmap(data.offset, data.length, values));
+
+  // ../../node_modules/apache-arrow/io/whatwg/iterable.mjs
+  function toDOMStream(source, options) {
+    if (isAsyncIterable(source)) {
+      return asyncIterableAsReadableDOMStream(source, options);
     }
-    return addBuffer.call(this, packBools(data.values));
-  }
-  function assembleFlatVector(data) {
-    return addBuffer.call(this, data.values.subarray(0, data.length * data.stride));
-  }
-  function assembleFlatListVector(data) {
-    const { length, values, valueOffsets } = data;
-    const begin = bigIntToNumber(valueOffsets[0]);
-    const end = bigIntToNumber(valueOffsets[length]);
-    const byteLength = Math.min(end - begin, values.byteLength - begin);
-    addBuffer.call(this, rebaseValueOffsets(-begin, length + 1, valueOffsets));
-    addBuffer.call(this, values.subarray(begin, begin + byteLength));
-    return this;
-  }
-  function assembleListVector(data) {
-    const { length, valueOffsets } = data;
-    if (valueOffsets) {
-      const { [0]: begin, [length]: end } = valueOffsets;
-      addBuffer.call(this, rebaseValueOffsets(-begin, length + 1, valueOffsets));
-      return this.visit(data.children[0].slice(begin, end - begin));
+    if (isIterable(source)) {
+      return iterableAsReadableDOMStream(source, options);
     }
-    return this.visit(data.children[0]);
-  }
-  function assembleNestedVector(data) {
-    return this.visitMany(data.type.children.map((_, i) => data.children[i]).filter(Boolean))[0];
+    throw new Error(`toDOMStream() must be called with an Iterable or AsyncIterable`);
   }
-  VectorAssembler.prototype.visitBool = assembleBoolVector;
-  VectorAssembler.prototype.visitInt = assembleFlatVector;
-  VectorAssembler.prototype.visitFloat = assembleFlatVector;
-  VectorAssembler.prototype.visitUtf8 = assembleFlatListVector;
-  VectorAssembler.prototype.visitLargeUtf8 = assembleFlatListVector;
-  VectorAssembler.prototype.visitBinary = assembleFlatListVector;
-  VectorAssembler.prototype.visitLargeBinary = assembleFlatListVector;
-  VectorAssembler.prototype.visitFixedSizeBinary = assembleFlatVector;
-  VectorAssembler.prototype.visitDate = assembleFlatVector;
-  VectorAssembler.prototype.visitTimestamp = assembleFlatVector;
-  VectorAssembler.prototype.visitTime = assembleFlatVector;
-  VectorAssembler.prototype.visitDecimal = assembleFlatVector;
-  VectorAssembler.prototype.visitList = assembleListVector;
-  VectorAssembler.prototype.visitStruct = assembleNestedVector;
-  VectorAssembler.prototype.visitUnion = assembleUnion;
-  VectorAssembler.prototype.visitInterval = assembleFlatVector;
-  VectorAssembler.prototype.visitDuration = assembleFlatVector;
-  VectorAssembler.prototype.visitFixedSizeList = assembleListVector;
-  VectorAssembler.prototype.visitMap = assembleListVector;
-
-  // ../../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`);
+  function iterableAsReadableDOMStream(source, options) {
+    let it = null;
+    const bm = (options === null || options === void 0 ? void 0 : options.type) === "bytes" || false;
+    const hwm = (options === null || options === void 0 ? void 0 : options.highWaterMark) || Math.pow(2, 24);
+    return new ReadableStream(Object.assign(Object.assign({}, options), {
+      start(controller) {
+        next(controller, it || (it = source[Symbol.iterator]()));
+      },
+      pull(controller) {
+        it ? next(controller, it) : controller.close();
+      },
+      cancel() {
+        ((it === null || it === void 0 ? void 0 : it.return) && it.return() || true) && (it = null);
+      }
+    }), Object.assign({ highWaterMark: bm ? hwm : void 0 }, options));
+    function next(controller, it2) {
+      let buf;
+      let r = null;
+      let size = controller.desiredSize || null;
+      while (!(r = it2.next(bm ? size : null)).done) {
+        if (ArrayBuffer.isView(r.value) && (buf = toUint8Array(r.value))) {
+          size != null && bm && (size = size - buf.byteLength + 1);
+          r.value = buf;
+        }
+        controller.enqueue(r.value);
+        if (size != null && --size <= 0) {
+          return;
+        }
+      }
+      controller.close();
     }
-    /** @nocollapse */
-    static throughDOM(writableStrategy, readableStrategy) {
-      throw new Error(`"throughDOM" not available in this environment`);
+  }
+  function asyncIterableAsReadableDOMStream(source, options) {
+    let it = null;
+    const bm = (options === null || options === void 0 ? void 0 : options.type) === "bytes" || false;
+    const hwm = (options === null || options === void 0 ? void 0 : options.highWaterMark) || Math.pow(2, 24);
+    return new ReadableStream(Object.assign(Object.assign({}, options), {
+      start(controller) {
+        return __awaiter(this, void 0, void 0, function* () {
+          yield next(controller, it || (it = source[Symbol.asyncIterator]()));
+        });
+      },
+      pull(controller) {
+        return __awaiter(this, void 0, void 0, function* () {
+          it ? yield next(controller, it) : controller.close();
+        });
+      },
+      cancel() {
+        return __awaiter(this, void 0, void 0, function* () {
+          ((it === null || it === void 0 ? void 0 : it.return) && (yield it.return()) || true) && (it = null);
+        });
+      }
+    }), Object.assign({ highWaterMark: bm ? hwm : void 0 }, options));
+    function next(controller, it2) {
+      return __awaiter(this, void 0, void 0, function* () {
+        let buf;
+        let r = null;
+        let size = controller.desiredSize || null;
+        while (!(r = yield it2.next(bm ? size : null)).done) {
+          if (ArrayBuffer.isView(r.value) && (buf = toUint8Array(r.value))) {
+            size != null && bm && (size = size - buf.byteLength + 1);
+            r.value = buf;
+          }
+          controller.enqueue(r.value);
+          if (size != null && --size <= 0) {
+            return;
+          }
+        }
+        controller.close();
+      });
     }
+  }
+
+  // ../../node_modules/apache-arrow/io/whatwg/builder.mjs
+  function builderThroughDOMStream(options) {
+    return new BuilderTransform(options);
+  }
+  var BuilderTransform = class {
     constructor(options) {
-      super();
-      this._position = 0;
-      this._started = false;
-      this._sink = new AsyncByteQueue();
-      this._schema = null;
-      this._dictionaryBlocks = [];
-      this._recordBatchBlocks = [];
-      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;
-    }
-    toString(sync = false) {
-      return this._sink.toString(sync);
+      this._numChunks = 0;
+      this._finished = false;
+      this._bufferedSize = 0;
+      const { ["readableStrategy"]: readableStrategy, ["writableStrategy"]: writableStrategy, ["queueingStrategy"]: queueingStrategy = "count" } = options, builderOptions = __rest(options, ["readableStrategy", "writableStrategy", "queueingStrategy"]);
+      this._controller = null;
+      this._builder = makeBuilder(builderOptions);
+      this._getSize = queueingStrategy !== "bytes" ? chunkLength : chunkByteLength;
+      const { ["highWaterMark"]: readableHighWaterMark = queueingStrategy === "bytes" ? Math.pow(2, 14) : 1e3 } = Object.assign({}, readableStrategy);
+      const { ["highWaterMark"]: writableHighWaterMark = queueingStrategy === "bytes" ? Math.pow(2, 14) : 1e3 } = Object.assign({}, writableStrategy);
+      this["readable"] = new ReadableStream({
+        ["cancel"]: () => {
+          this._builder.clear();
+        },
+        ["pull"]: (c) => {
+          this._maybeFlush(this._builder, this._controller = c);
+        },
+        ["start"]: (c) => {
+          this._maybeFlush(this._builder, this._controller = c);
+        }
+      }, {
+        "highWaterMark": readableHighWaterMark,
+        "size": queueingStrategy !== "bytes" ? chunkLength : chunkByteLength
+      });
+      this["writable"] = new WritableStream({
+        ["abort"]: () => {
+          this._builder.clear();
+        },
+        ["write"]: () => {
+          this._maybeFlush(this._builder, this._controller);
+        },
+        ["close"]: () => {
+          this._maybeFlush(this._builder.finish(), this._controller);
+        }
+      }, {
+        "highWaterMark": writableHighWaterMark,
+        "size": (value) => this._writeValueAndReturnChunkSize(value)
+      });
     }
-    toUint8Array(sync = false) {
-      return this._sink.toUint8Array(sync);
+    _writeValueAndReturnChunkSize(value) {
+      const bufferedSize = this._bufferedSize;
+      this._bufferedSize = this._getSize(this._builder.append(value));
+      return this._bufferedSize - bufferedSize;
     }
-    writeAll(input) {
-      if (isPromise(input)) {
-        return input.then((x) => this.writeAll(x));
-      } else if (isAsyncIterable(input)) {
-        return writeAllAsync(this, input);
+    _maybeFlush(builder, controller) {
+      if (controller == null) {
+        return;
+      }
+      if (this._bufferedSize >= controller.desiredSize) {
+        ++this._numChunks && this._enqueue(controller, builder.toVector());
+      }
+      if (builder.finished) {
+        if (builder.length > 0 || this._numChunks === 0) {
+          ++this._numChunks && this._enqueue(controller, builder.toVector());
+        }
+        if (!this._finished && (this._finished = true)) {
+          this._enqueue(controller, null);
+        }
       }
-      return writeAll(this, input);
-    }
-    get closed() {
-      return this._sink.closed;
     }
-    [Symbol.asyncIterator]() {
-      return this._sink[Symbol.asyncIterator]();
+    _enqueue(controller, chunk) {
+      this._bufferedSize = 0;
+      this._controller = null;
+      chunk == null ? controller.close() : controller.enqueue(chunk);
     }
-    toDOMStream(options) {
-      return this._sink.toDOMStream(options);
+  };
+  var chunkLength = (chunk) => {
+    var _a5;
+    return (_a5 = chunk === null || chunk === void 0 ? void 0 : chunk.length) !== null && _a5 !== void 0 ? _a5 : 0;
+  };
+  var chunkByteLength = (chunk) => {
+    var _a5;
+    return (_a5 = chunk === null || chunk === void 0 ? void 0 : chunk.byteLength) !== null && _a5 !== void 0 ? _a5 : 0;
+  };
+
+  // ../../node_modules/apache-arrow/io/whatwg/reader.mjs
+  function recordBatchReaderThroughDOMStream(writableStrategy, readableStrategy) {
+    const queue = new AsyncByteQueue();
+    let reader = null;
+    const readable = new ReadableStream({
+      cancel() {
+        return __awaiter(this, void 0, void 0, function* () {
+          yield queue.close();
+        });
+      },
+      start(controller) {
+        return __awaiter(this, void 0, void 0, function* () {
+          yield next(controller, reader || (reader = yield open()));
+        });
+      },
+      pull(controller) {
+        return __awaiter(this, void 0, void 0, function* () {
+          reader ? yield next(controller, reader) : controller.close();
+        });
+      }
+    });
+    return { writable: new WritableStream(queue, Object.assign({ "highWaterMark": Math.pow(2, 14) }, writableStrategy)), readable };
+    function open() {
+      return __awaiter(this, void 0, void 0, function* () {
+        return yield (yield RecordBatchReader.from(queue)).open(readableStrategy);
+      });
     }
-    toNodeStream(options) {
-      return this._sink.toNodeStream(options);
+    function next(controller, reader2) {
+      return __awaiter(this, void 0, void 0, function* () {
+        let size = controller.desiredSize;
+        let r = null;
+        while (!(r = yield reader2.next()).done) {
+          controller.enqueue(r.value);
+          if (size != null && --size <= 0) {
+            return;
+          }
+        }
+        controller.close();
+      });
     }
-    close() {
-      return this.reset()._sink.close();
+  }
+
+  // ../../node_modules/apache-arrow/io/whatwg/writer.mjs
+  function recordBatchWriterThroughDOMStream(writableStrategy, readableStrategy) {
+    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();
+        });
+      },
+      pull(controller) {
+        return __awaiter(this, void 0, void 0, function* () {
+          yield next(controller);
+        });
+      },
+      start(controller) {
+        return __awaiter(this, void 0, void 0, function* () {
+          yield next(controller);
+        });
+      }
+    }, Object.assign({ "highWaterMark": Math.pow(2, 14) }, readableStrategy));
+    return { writable: new WritableStream(writer, writableStrategy), readable };
+    function next(controller) {
+      return __awaiter(this, void 0, void 0, function* () {
+        let buf = null;
+        let size = controller.desiredSize;
+        while (buf = yield reader.read(size || null)) {
+          controller.enqueue(buf);
+          if (size != null && (size -= buf.byteLength) <= 0) {
+            return;
+          }
+        }
+        controller.close();
+      });
     }
-    abort(reason) {
-      return this.reset()._sink.abort(reason);
+  }
+
+  // ../../node_modules/apache-arrow/ipc/serialization.mjs
+  function tableFromIPC(input) {
+    const reader = RecordBatchReader.from(input);
+    if (isPromise(reader)) {
+      return reader.then((reader2) => tableFromIPC(reader2));
     }
-    finish() {
-      this._autoDestroy ? this.close() : this.reset(this._sink, this._schema);
-      return this;
+    if (reader.isAsync()) {
+      return reader.readAll().then((xs) => new Table(xs));
     }
-    reset(sink = this._sink, schema = null) {
-      if (sink === this._sink || sink instanceof AsyncByteQueue) {
-        this._sink = sink;
-      } else {
-        this._sink = new AsyncByteQueue();
-        if (sink && isWritableDOMStream(sink)) {
-          this.toDOMStream({ type: "bytes" }).pipeTo(sink);
-        } else if (sink && isWritableNodeStream(sink)) {
-          this.toNodeStream({ objectMode: false }).pipe(sink);
-        }
-      }
-      if (this._started && this._schema) {
-        this._writeFooter(this._schema);
-      }
-      this._started = false;
-      this._dictionaryBlocks = [];
-      this._recordBatchBlocks = [];
-      this._dictionaryDeltaOffsets = /* @__PURE__ */ new Map();
-      if (!schema || !compareSchemas(schema, this._schema)) {
-        if (schema == null) {
-          this._position = 0;
-          this._schema = null;
-        } else {
-          this._started = true;
-          this._schema = schema;
-          this._writeSchema(schema);
-        }
-      }
-      return this;
+    return new Table(reader.readAll());
+  }
+
+  // ../../node_modules/apache-arrow/Arrow.mjs
+  var util = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, bn_exports), int_exports), bit_exports), math_exports), buffer_exports), vector_exports), pretty_exports), {
+    compareSchemas,
+    compareFields,
+    compareTypes
+  });
+
+  // ../../node_modules/apache-arrow/Arrow.dom.mjs
+  adapters_default.toDOMStream = toDOMStream;
+  Builder2["throughDOM"] = builderThroughDOMStream;
+  RecordBatchReader["throughDOM"] = recordBatchReaderThroughDOMStream;
+  RecordBatchFileReader["throughDOM"] = recordBatchReaderThroughDOMStream;
+  RecordBatchStreamReader["throughDOM"] = recordBatchReaderThroughDOMStream;
+  RecordBatchWriter["throughDOM"] = recordBatchWriterThroughDOMStream;
+  RecordBatchFileWriter["throughDOM"] = recordBatchWriterThroughDOMStream;
+  RecordBatchStreamWriter["throughDOM"] = recordBatchWriterThroughDOMStream;
+
+  // ../schema/src/lib/table/simple-table/data-type.ts
+  function getDataTypeFromValue(value, defaultNumberType = "float32") {
+    if (value instanceof Date) {
+      return "date-millisecond";
     }
-    write(payload) {
-      let schema = null;
-      if (!this._sink) {
-        throw new Error(`RecordBatchWriter is closed`);
-      } else if (payload == null) {
-        return this.finish() && void 0;
-      } else if (payload instanceof Table && !(schema = payload.schema)) {
-        return this.finish() && void 0;
-      } else if (payload instanceof RecordBatch2 && !(schema = payload.schema)) {
-        return this.finish() && void 0;
-      }
-      if (schema && !compareSchemas(schema, this._schema)) {
-        if (this._started && this._autoDestroy) {
-          return this.close();
-        }
-        this.reset(this._sink, schema);
-      }
-      if (payload instanceof RecordBatch2) {
-        if (!(payload instanceof _InternalEmptyPlaceholderRecordBatch)) {
-          this._writeRecordBatch(payload);
-        }
-      } else if (payload instanceof Table) {
-        this.writeAll(payload.batches);
-      } else if (isIterable(payload)) {
-        this.writeAll(payload);
-      }
+    if (value instanceof Number) {
+      return defaultNumberType;
     }
-    _writeMessage(message, alignment = 8) {
-      const a = alignment - 1;
-      const buffer = Message2.encode(message);
-      const flatbufferSize = buffer.byteLength;
-      const prefixSize = !this._writeLegacyIpcFormat ? 8 : 4;
-      const alignedSize = flatbufferSize + prefixSize + a & ~a;
-      const nPaddingBytes = alignedSize - flatbufferSize - prefixSize;
-      if (message.headerType === MessageHeader.RecordBatch) {
-        this._recordBatchBlocks.push(new FileBlock(alignedSize, message.bodyLength, this._position));
-      } else if (message.headerType === MessageHeader.DictionaryBatch) {
-        this._dictionaryBlocks.push(new FileBlock(alignedSize, message.bodyLength, this._position));
-      }
-      if (!this._writeLegacyIpcFormat) {
-        this._write(Int32Array.of(-1));
-      }
-      this._write(Int32Array.of(alignedSize - prefixSize));
-      if (flatbufferSize > 0) {
-        this._write(buffer);
-      }
-      return this._writePadding(nPaddingBytes);
+    if (typeof value === "string") {
+      return "utf8";
     }
-    _write(chunk) {
-      if (this._started) {
-        const buffer = toUint8Array(chunk);
-        if (buffer && buffer.byteLength > 0) {
-          this._sink.write(buffer);
-          this._position += buffer.byteLength;
-        }
-      }
-      return this;
+    if (value === null || value === "undefined") {
+      return "null";
     }
-    _writeSchema(schema) {
-      return this._writeMessage(Message2.from(schema));
+    return "null";
+  }
+  function getDataTypeFromArray(array) {
+    let type = getDataTypeFromTypedArray(array);
+    if (type !== "null") {
+      return { type, nullable: false };
     }
-    // @ts-ignore
-    _writeFooter(schema) {
-      return this._writeLegacyIpcFormat ? this._write(Int32Array.of(0)) : this._write(Int32Array.of(-1, 0));
+    if (array.length > 0) {
+      type = getDataTypeFromValue(array[0]);
+      return { type, nullable: true };
     }
-    _writeMagic() {
-      return this._write(MAGIC);
+    return { type: "null", nullable: true };
+  }
+  function getDataTypeFromTypedArray(array) {
+    switch (array.constructor) {
+      case Int8Array:
+        return "int8";
+      case Uint8Array:
+      case Uint8ClampedArray:
+        return "uint8";
+      case Int16Array:
+        return "int16";
+      case Uint16Array:
+        return "uint16";
+      case Int32Array:
+        return "int32";
+      case Uint32Array:
+        return "uint32";
+      case Float32Array:
+        return "float32";
+      case Float64Array:
+        return "float64";
+      default:
+        return "null";
     }
-    _writePadding(nBytes) {
-      return nBytes > 0 ? this._write(new Uint8Array(nBytes)) : this;
+  }
+  function getArrayTypeFromDataType(type, nullable) {
+    if (!nullable) {
+      switch (type) {
+        case "int8":
+          return Int8Array;
+        case "uint8":
+          return Uint8Array;
+        case "int16":
+          return Int16Array;
+        case "uint16":
+          return Uint16Array;
+        case "int32":
+          return Int32Array;
+        case "uint32":
+          return Uint32Array;
+        case "float32":
+          return Float32Array;
+        case "float64":
+          return Float64Array;
+        default:
+          break;
+      }
     }
-    _writeRecordBatch(batch) {
-      const { byteLength, nodes, bufferRegions, buffers } = VectorAssembler.assemble(batch);
-      const recordBatch = new RecordBatch3(batch.numRows, nodes, bufferRegions);
-      const message = Message2.from(recordBatch, byteLength);
-      return this._writeDictionaries(batch)._writeMessage(message)._writeBodyBuffers(buffers);
+    return Array;
+  }
+
+  // ../schema/src/lib/table/simple-table/table-accessors.ts
+  function getTableLength(table) {
+    switch (table.shape) {
+      case "array-row-table":
+      case "object-row-table":
+        return table.data.length;
+      case "geojson-table":
+        return table.features.length;
+      case "arrow-table":
+        const arrowTable = table.data;
+        return arrowTable.numRows;
+      case "columnar-table":
+        for (const column of Object.values(table.data)) {
+          return column.length || 0;
+        }
+        return 0;
+      default:
+        throw new Error("table");
     }
-    _writeDictionaryBatch(dictionary, id, isDelta = false) {
-      this._dictionaryDeltaOffsets.set(id, dictionary.length + (this._dictionaryDeltaOffsets.get(id) || 0));
-      const { byteLength, nodes, bufferRegions, buffers } = VectorAssembler.assemble(new Vector([dictionary]));
-      const recordBatch = new RecordBatch3(dictionary.length, nodes, bufferRegions);
-      const dictionaryBatch = new DictionaryBatch2(recordBatch, id, isDelta);
-      const message = Message2.from(dictionaryBatch, byteLength);
-      return this._writeMessage(message)._writeBodyBuffers(buffers);
+  }
+  function getTableCell(table, rowIndex, columnName) {
+    switch (table.shape) {
+      case "array-row-table":
+        const columnIndex = getTableColumnIndex(table, columnName);
+        return table.data[rowIndex][columnIndex];
+      case "object-row-table":
+        return table.data[rowIndex][columnName];
+      case "geojson-table":
+        return table.features[rowIndex][columnName];
+      case "columnar-table":
+        const column = table.data[columnName];
+        return column[rowIndex];
+      case "arrow-table":
+        const arrowTable = table.data;
+        const arrowColumnIndex = arrowTable.schema.fields.findIndex(
+          (field) => field.name === columnName
+        );
+        return arrowTable.getChildAt(arrowColumnIndex)?.get(rowIndex);
+      default:
+        throw new Error("todo");
     }
-    _writeBodyBuffers(buffers) {
-      let buffer;
-      let size, padding;
-      for (let i = -1, n = buffers.length; ++i < n; ) {
-        if ((buffer = buffers[i]) && (size = buffer.byteLength) > 0) {
-          this._write(buffer);
-          if ((padding = (size + 7 & ~7) - size) > 0) {
-            this._writePadding(padding);
+  }
+  function getTableColumnIndex(table, columnName) {
+    const columnIndex = table.schema?.fields.findIndex((field) => field.name === columnName);
+    if (columnIndex === void 0) {
+      throw new Error(columnName);
+    }
+    return columnIndex;
+  }
+  function getTableRowAsObject(table, rowIndex, target, copy) {
+    switch (table.shape) {
+      case "object-row-table":
+        return copy ? Object.fromEntries(Object.entries(table.data[rowIndex])) : table.data[rowIndex];
+      case "array-row-table":
+        if (table.schema) {
+          const objectRow2 = target || {};
+          for (let i = 0; i < table.schema.fields.length; i++) {
+            objectRow2[table.schema.fields[i].name] = table.data[rowIndex][i];
+          }
+          return objectRow2;
+        }
+        throw new Error("no schema");
+      case "geojson-table":
+        if (table.schema) {
+          const objectRow2 = target || {};
+          for (let i = 0; i < table.schema.fields.length; i++) {
+            objectRow2[table.schema.fields[i].name] = table.features[rowIndex][i];
+          }
+          return objectRow2;
+        }
+        throw new Error("no schema");
+      case "columnar-table":
+        if (table.schema) {
+          const objectRow2 = target || {};
+          for (let i = 0; i < table.schema.fields.length; i++) {
+            objectRow2[table.schema.fields[i].name] = table.data[table.schema.fields[i].name][rowIndex];
+          }
+          return objectRow2;
+        } else {
+          const objectRow2 = target || {};
+          for (const [name, column] of Object.entries(table.data)) {
+            objectRow2[name] = column[rowIndex];
+          }
+          return objectRow2;
+        }
+      case "arrow-table":
+        const arrowTable = table.data;
+        const objectRow = target || {};
+        const row = arrowTable.get(rowIndex);
+        const schema = arrowTable.schema;
+        for (let i = 0; i < schema.fields.length; i++) {
+          objectRow[schema.fields[i].name] = row?.[schema.fields[i].name];
+        }
+        return objectRow;
+      default:
+        throw new Error("shape");
+    }
+  }
+  function getTableRowAsArray(table, rowIndex, target, copy) {
+    switch (table.shape) {
+      case "array-row-table":
+        return copy ? Array.from(table.data[rowIndex]) : table.data[rowIndex];
+      case "object-row-table":
+        if (table.schema) {
+          const arrayRow2 = target || [];
+          for (let i = 0; i < table.schema.fields.length; i++) {
+            arrayRow2[i] = table.data[rowIndex][table.schema.fields[i].name];
           }
+          return arrayRow2;
         }
-      }
-      return this;
-    }
-    _writeDictionaries(batch) {
-      for (let [id, dictionary] of batch.dictionaries) {
-        let offset = this._dictionaryDeltaOffsets.get(id) || 0;
-        if (offset === 0 || (dictionary = dictionary === null || dictionary === void 0 ? void 0 : dictionary.slice(offset)).length > 0) {
-          for (const data of dictionary.data) {
-            this._writeDictionaryBatch(data, id, offset > 0);
-            offset += data.length;
+        return Object.values(table.data[rowIndex]);
+      case "geojson-table":
+        if (table.schema) {
+          const arrayRow2 = target || [];
+          for (let i = 0; i < table.schema.fields.length; i++) {
+            arrayRow2[i] = table.features[rowIndex][table.schema.fields[i].name];
           }
+          return arrayRow2;
         }
-      }
-      return this;
-    }
-  };
-  var RecordBatchStreamWriter = class extends RecordBatchWriter {
-    /** @nocollapse */
-    static writeAll(input, options) {
-      const writer = new RecordBatchStreamWriter(options);
-      if (isPromise(input)) {
-        return input.then((x) => writer.writeAll(x));
-      } else if (isAsyncIterable(input)) {
-        return writeAllAsync(writer, input);
-      }
-      return writeAll(writer, input);
-    }
-  };
-  var RecordBatchFileWriter = class extends RecordBatchWriter {
-    /** @nocollapse */
-    static writeAll(input) {
-      const writer = new RecordBatchFileWriter();
-      if (isPromise(input)) {
-        return input.then((x) => writer.writeAll(x));
-      } else if (isAsyncIterable(input)) {
-        return writeAllAsync(writer, input);
-      }
-      return writeAll(writer, input);
-    }
-    constructor() {
-      super();
-      this._autoDestroy = true;
+        return Object.values(table.features[rowIndex]);
+      case "columnar-table":
+        if (table.schema) {
+          const arrayRow2 = target || [];
+          for (let i = 0; i < table.schema.fields.length; i++) {
+            arrayRow2[i] = table.data[table.schema.fields[i].name][rowIndex];
+          }
+          return arrayRow2;
+        } else {
+          const arrayRow2 = target || [];
+          let i = 0;
+          for (const column of Object.values(table.data)) {
+            arrayRow2[i] = column[rowIndex];
+            i++;
+          }
+          return arrayRow2;
+        }
+      case "arrow-table":
+        const arrowTable = table.data;
+        const arrayRow = target || [];
+        const row = arrowTable.get(rowIndex);
+        const schema = arrowTable.schema;
+        for (let i = 0; i < schema.fields.length; i++) {
+          arrayRow[i] = row?.[schema.fields[i].name];
+        }
+        return arrayRow;
+      default:
+        throw new Error("shape");
     }
-    // @ts-ignore
-    _writeSchema(schema) {
-      return this._writeMagic()._writePadding(2);
+  }
+
+  // ../schema/src/lib/table/simple-table/table-schema.ts
+  function deduceTableSchema(table) {
+    switch (table.shape) {
+      case "array-row-table":
+      case "object-row-table":
+        return deduceSchemaFromRows(table.data);
+      case "geojson-table":
+        return deduceSchemaFromGeoJSON(table.features);
+      case "columnar-table":
+        return deduceSchemaFromColumns(table.data);
+      case "arrow-table":
+      default:
+        throw new Error("Deduce schema");
     }
-    _writeFooter(schema) {
-      const buffer = Footer_.encode(new Footer_(schema, MetadataVersion.V5, this._recordBatchBlocks, this._dictionaryBlocks));
-      return super._writeFooter(schema)._write(buffer)._write(Int32Array.of(buffer.byteLength))._writeMagic();
+  }
+  function deduceSchemaFromColumns(columnarTable) {
+    const fields = [];
+    for (const [columnName, column] of Object.entries(columnarTable)) {
+      const field = deduceFieldFromColumn(column, columnName);
+      fields.push(field);
     }
-  };
-  function writeAll(writer, input) {
-    let chunks = input;
-    if (input instanceof Table) {
-      chunks = input.batches;
-      writer.reset(void 0, input.schema);
+    return { fields, metadata: {} };
+  }
+  function deduceSchemaFromRows(rowTable) {
+    if (!rowTable.length) {
+      throw new Error("deduce from empty table");
     }
-    for (const batch of chunks) {
-      writer.write(batch);
+    const fields = [];
+    const row0 = rowTable[0];
+    for (const [columnName, value] of Object.entries(row0)) {
+      fields.push(deduceFieldFromValue(value, columnName));
     }
-    return writer.finish();
-  }
-  function writeAllAsync(writer, batches) {
-    var _a5, batches_1, batches_1_1;
-    var _b2, e_1, _c2, _d2;
-    return __awaiter(this, void 0, void 0, function* () {
-      try {
-        for (_a5 = true, batches_1 = __asyncValues(batches); batches_1_1 = yield batches_1.next(), _b2 = batches_1_1.done, !_b2; _a5 = true) {
-          _d2 = batches_1_1.value;
-          _a5 = false;
-          const batch = _d2;
-          writer.write(batch);
-        }
-      } catch (e_1_1) {
-        e_1 = { error: e_1_1 };
-      } finally {
-        try {
-          if (!_a5 && !_b2 && (_c2 = batches_1.return))
-            yield _c2.call(batches_1);
-        } finally {
-          if (e_1)
-            throw e_1.error;
-        }
-      }
-      return writer.finish();
-    });
+    return { fields, metadata: {} };
   }
-
-  // ../../node_modules/apache-arrow/io/whatwg/iterable.mjs
-  function toDOMStream(source, options) {
-    if (isAsyncIterable(source)) {
-      return asyncIterableAsReadableDOMStream(source, options);
+  function deduceSchemaFromGeoJSON(features) {
+    if (!features.length) {
+      throw new Error("deduce from empty table");
     }
-    if (isIterable(source)) {
-      return iterableAsReadableDOMStream(source, options);
+    const fields = [];
+    const row0 = features[0].properties || {};
+    for (const [columnName, value] of Object.entries(row0)) {
+      fields.push(deduceFieldFromValue(value, columnName));
     }
-    throw new Error(`toDOMStream() must be called with an Iterable or AsyncIterable`);
+    return { fields, metadata: {} };
   }
-  function iterableAsReadableDOMStream(source, options) {
-    let it = null;
-    const bm = (options === null || options === void 0 ? void 0 : options.type) === "bytes" || false;
-    const hwm = (options === null || options === void 0 ? void 0 : options.highWaterMark) || Math.pow(2, 24);
-    return new ReadableStream(Object.assign(Object.assign({}, options), {
-      start(controller) {
-        next(controller, it || (it = source[Symbol.iterator]()));
-      },
-      pull(controller) {
-        it ? next(controller, it) : controller.close();
-      },
-      cancel() {
-        ((it === null || it === void 0 ? void 0 : it.return) && it.return() || true) && (it = null);
-      }
-    }), Object.assign({ highWaterMark: bm ? hwm : void 0 }, options));
-    function next(controller, it2) {
-      let buf;
-      let r = null;
-      let size = controller.desiredSize || null;
-      while (!(r = it2.next(bm ? size : null)).done) {
-        if (ArrayBuffer.isView(r.value) && (buf = toUint8Array(r.value))) {
-          size != null && bm && (size = size - buf.byteLength + 1);
-          r.value = buf;
-        }
-        controller.enqueue(r.value);
-        if (size != null && --size <= 0) {
-          return;
-        }
-      }
-      controller.close();
+  function deduceFieldFromColumn(column, name) {
+    if (ArrayBuffer.isView(column)) {
+      const type = getDataTypeFromArray(column);
+      return {
+        name,
+        type: type.type || "null",
+        nullable: type.nullable
+        // metadata: {}
+      };
     }
-  }
-  function asyncIterableAsReadableDOMStream(source, options) {
-    let it = null;
-    const bm = (options === null || options === void 0 ? void 0 : options.type) === "bytes" || false;
-    const hwm = (options === null || options === void 0 ? void 0 : options.highWaterMark) || Math.pow(2, 24);
-    return new ReadableStream(Object.assign(Object.assign({}, options), {
-      start(controller) {
-        return __awaiter(this, void 0, void 0, function* () {
-          yield next(controller, it || (it = source[Symbol.asyncIterator]()));
-        });
-      },
-      pull(controller) {
-        return __awaiter(this, void 0, void 0, function* () {
-          it ? yield next(controller, it) : controller.close();
-        });
-      },
-      cancel() {
-        return __awaiter(this, void 0, void 0, function* () {
-          ((it === null || it === void 0 ? void 0 : it.return) && (yield it.return()) || true) && (it = null);
-        });
-      }
-    }), Object.assign({ highWaterMark: bm ? hwm : void 0 }, options));
-    function next(controller, it2) {
-      return __awaiter(this, void 0, void 0, function* () {
-        let buf;
-        let r = null;
-        let size = controller.desiredSize || null;
-        while (!(r = yield it2.next(bm ? size : null)).done) {
-          if (ArrayBuffer.isView(r.value) && (buf = toUint8Array(r.value))) {
-            size != null && bm && (size = size - buf.byteLength + 1);
-            r.value = buf;
-          }
-          controller.enqueue(r.value);
-          if (size != null && --size <= 0) {
-            return;
-          }
-        }
-        controller.close();
-      });
+    if (Array.isArray(column) && column.length > 0) {
+      const value = column[0];
+      const type = getDataTypeFromValue(value);
+      return {
+        name,
+        type,
+        nullable: true
+        // metadata: {},
+      };
     }
+    throw new Error("empty table");
+  }
+  function deduceFieldFromValue(value, name) {
+    const type = getDataTypeFromValue(value);
+    return {
+      name,
+      type,
+      nullable: true
+      // metadata: {}
+    };
   }
 
-  // ../../node_modules/apache-arrow/io/whatwg/builder.mjs
-  function builderThroughDOMStream(options) {
-    return new BuilderTransform(options);
+  // ../schema/src/lib/table/simple-table/table-column.ts
+  function makeColumnFromField(field, length) {
+    const ArrayType = getArrayTypeFromDataType(field.type, field.nullable);
+    return new ArrayType(length);
   }
-  var BuilderTransform = class {
-    constructor(options) {
-      this._numChunks = 0;
-      this._finished = false;
-      this._bufferedSize = 0;
-      const { ["readableStrategy"]: readableStrategy, ["writableStrategy"]: writableStrategy, ["queueingStrategy"]: queueingStrategy = "count" } = options, builderOptions = __rest(options, ["readableStrategy", "writableStrategy", "queueingStrategy"]);
-      this._controller = null;
-      this._builder = makeBuilder(builderOptions);
-      this._getSize = queueingStrategy !== "bytes" ? chunkLength : chunkByteLength;
-      const { ["highWaterMark"]: readableHighWaterMark = queueingStrategy === "bytes" ? Math.pow(2, 14) : 1e3 } = Object.assign({}, readableStrategy);
-      const { ["highWaterMark"]: writableHighWaterMark = queueingStrategy === "bytes" ? Math.pow(2, 14) : 1e3 } = Object.assign({}, writableStrategy);
-      this["readable"] = new ReadableStream({
-        ["cancel"]: () => {
-          this._builder.clear();
-        },
-        ["pull"]: (c) => {
-          this._maybeFlush(this._builder, this._controller = c);
-        },
-        ["start"]: (c) => {
-          this._maybeFlush(this._builder, this._controller = c);
-        }
-      }, {
-        "highWaterMark": readableHighWaterMark,
-        "size": queueingStrategy !== "bytes" ? chunkLength : chunkByteLength
-      });
-      this["writable"] = new WritableStream({
-        ["abort"]: () => {
-          this._builder.clear();
-        },
-        ["write"]: () => {
-          this._maybeFlush(this._builder, this._controller);
-        },
-        ["close"]: () => {
-          this._maybeFlush(this._builder.finish(), this._controller);
-        }
-      }, {
-        "highWaterMark": writableHighWaterMark,
-        "size": (value) => this._writeValueAndReturnChunkSize(value)
-      });
-    }
-    _writeValueAndReturnChunkSize(value) {
-      const bufferedSize = this._bufferedSize;
-      this._bufferedSize = this._getSize(this._builder.append(value));
-      return this._bufferedSize - bufferedSize;
+
+  // ../schema/src/lib/table/simple-table/convert-table.ts
+  function convertTable(table, shape) {
+    switch (shape) {
+      case "object-row-table":
+        return makeObjectRowTable(table);
+      case "array-row-table":
+        return makeArrayRowTable(table);
+      case "columnar-table":
+        return makeColumnarTable(table);
+      case "arrow-table":
+        return makeArrowTable(table);
+      default:
+        throw new Error(shape);
     }
-    _maybeFlush(builder, controller) {
-      if (controller == null) {
-        return;
-      }
-      if (this._bufferedSize >= controller.desiredSize) {
-        ++this._numChunks && this._enqueue(controller, builder.toVector());
-      }
-      if (builder.finished) {
-        if (builder.length > 0 || this._numChunks === 0) {
-          ++this._numChunks && this._enqueue(controller, builder.toVector());
-        }
-        if (!this._finished && (this._finished = true)) {
-          this._enqueue(controller, null);
-        }
-      }
+  }
+  function makeArrowTable(table) {
+    const _makeArrowTable = globalThis.__loaders?._makeArrowTable;
+    if (!_makeArrowTable) {
+      throw new Error("");
     }
-    _enqueue(controller, chunk) {
-      this._bufferedSize = 0;
-      this._controller = null;
-      chunk == null ? controller.close() : controller.enqueue(chunk);
+    return _makeArrowTable(table);
+  }
+  function makeColumnarTable(table) {
+    const schema = table.schema || deduceTableSchema(table);
+    const fields = table.schema?.fields || [];
+    if (table.shape === "columnar-table") {
+      return { ...table, schema };
     }
-  };
-  var chunkLength = (chunk) => {
-    var _a5;
-    return (_a5 = chunk === null || chunk === void 0 ? void 0 : chunk.length) !== null && _a5 !== void 0 ? _a5 : 0;
-  };
-  var chunkByteLength = (chunk) => {
-    var _a5;
-    return (_a5 = chunk === null || chunk === void 0 ? void 0 : chunk.byteLength) !== null && _a5 !== void 0 ? _a5 : 0;
-  };
-
-  // ../../node_modules/apache-arrow/io/whatwg/reader.mjs
-  function recordBatchReaderThroughDOMStream(writableStrategy, readableStrategy) {
-    const queue = new AsyncByteQueue();
-    let reader = null;
-    const readable = new ReadableStream({
-      cancel() {
-        return __awaiter(this, void 0, void 0, function* () {
-          yield queue.close();
-        });
-      },
-      start(controller) {
-        return __awaiter(this, void 0, void 0, function* () {
-          yield next(controller, reader || (reader = yield open()));
-        });
-      },
-      pull(controller) {
-        return __awaiter(this, void 0, void 0, function* () {
-          reader ? yield next(controller, reader) : controller.close();
-        });
+    const length = getTableLength(table);
+    const columns = {};
+    for (const field of fields) {
+      const column = makeColumnFromField(field, length);
+      columns[field.name] = column;
+      for (let rowIndex = 0; rowIndex < length; rowIndex++) {
+        column[rowIndex] = getTableCell(table, rowIndex, field.name);
       }
-    });
-    return { writable: new WritableStream(queue, Object.assign({ "highWaterMark": Math.pow(2, 14) }, writableStrategy)), readable };
-    function open() {
-      return __awaiter(this, void 0, void 0, function* () {
-        return yield (yield RecordBatchReader.from(queue)).open(readableStrategy);
-      });
-    }
-    function next(controller, reader2) {
-      return __awaiter(this, void 0, void 0, function* () {
-        let size = controller.desiredSize;
-        let r = null;
-        while (!(r = yield reader2.next()).done) {
-          controller.enqueue(r.value);
-          if (size != null && --size <= 0) {
-            return;
-          }
-        }
-        controller.close();
-      });
     }
+    return {
+      shape: "columnar-table",
+      schema,
+      data: columns
+    };
   }
-
-  // ../../node_modules/apache-arrow/io/whatwg/writer.mjs
-  function recordBatchWriterThroughDOMStream(writableStrategy, readableStrategy) {
-    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();
-        });
-      },
-      pull(controller) {
-        return __awaiter(this, void 0, void 0, function* () {
-          yield next(controller);
-        });
-      },
-      start(controller) {
-        return __awaiter(this, void 0, void 0, function* () {
-          yield next(controller);
-        });
-      }
-    }, Object.assign({ "highWaterMark": Math.pow(2, 14) }, readableStrategy));
-    return { writable: new WritableStream(writer, writableStrategy), readable };
-    function next(controller) {
-      return __awaiter(this, void 0, void 0, function* () {
-        let buf = null;
-        let size = controller.desiredSize;
-        while (buf = yield reader.read(size || null)) {
-          controller.enqueue(buf);
-          if (size != null && (size -= buf.byteLength) <= 0) {
-            return;
-          }
-        }
-        controller.close();
-      });
+  function makeArrayRowTable(table) {
+    if (table.shape === "array-row-table") {
+      return table;
+    }
+    const length = getTableLength(table);
+    const data = new Array(length);
+    for (let rowIndex = 0; rowIndex < length; rowIndex++) {
+      data[rowIndex] = getTableRowAsArray(table, rowIndex);
     }
+    return {
+      shape: "array-row-table",
+      schema: table.schema,
+      data
+    };
   }
-
-  // ../../node_modules/apache-arrow/ipc/serialization.mjs
-  function tableFromIPC(input) {
-    const reader = RecordBatchReader.from(input);
-    if (isPromise(reader)) {
-      return reader.then((reader2) => tableFromIPC(reader2));
+  function makeObjectRowTable(table) {
+    if (table.shape === "object-row-table") {
+      return table;
     }
-    if (reader.isAsync()) {
-      return reader.readAll().then((xs) => new Table(xs));
+    const length = getTableLength(table);
+    const data = new Array(length);
+    for (let rowIndex = 0; rowIndex < length; rowIndex++) {
+      data[rowIndex] = getTableRowAsObject(table, rowIndex);
     }
-    return new Table(reader.readAll());
+    return {
+      shape: "object-row-table",
+      schema: table.schema,
+      data
+    };
   }
 
-  // ../../node_modules/apache-arrow/Arrow.mjs
-  var util = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, bn_exports), int_exports), bit_exports), math_exports), buffer_exports), vector_exports), pretty_exports), {
-    compareSchemas,
-    compareFields,
-    compareTypes
-  });
-
-  // ../../node_modules/apache-arrow/Arrow.dom.mjs
-  adapters_default.toDOMStream = toDOMStream;
-  Builder2["throughDOM"] = builderThroughDOMStream;
-  RecordBatchReader["throughDOM"] = recordBatchReaderThroughDOMStream;
-  RecordBatchFileReader["throughDOM"] = recordBatchReaderThroughDOMStream;
-  RecordBatchStreamReader["throughDOM"] = recordBatchReaderThroughDOMStream;
-  RecordBatchWriter["throughDOM"] = recordBatchWriterThroughDOMStream;
-  RecordBatchFileWriter["throughDOM"] = recordBatchWriterThroughDOMStream;
-  RecordBatchStreamWriter["throughDOM"] = recordBatchWriterThroughDOMStream;
+  // ../gis/src/lib/geo/geoarrow-metadata.ts
+  var GEOARROW_ENCODINGS = [
+    "geoarrow.multipolygon",
+    "geoarrow.polygon",
+    "geoarrow.multilinestring",
+    "geoarrow.linestring",
+    "geoarrow.multipoint",
+    "geoarrow.point",
+    "geoarrow.wkb",
+    "geoarrow.wkt"
+  ];
+  var GEOARROW_COLUMN_METADATA_ENCODING = "ARROW:extension:name";
+  var GEOARROW_COLUMN_METADATA_METADATA = "ARROW:extension:metadata";
+  function getGeometryColumnsFromSchema(schema) {
+    const geometryColumns = {};
+    for (const field of schema.fields) {
+      const metadata = getGeometryMetadataForField(field);
+      if (metadata) {
+        geometryColumns[field.name] = metadata;
+      }
+    }
+    return geometryColumns;
+  }
+  function getGeometryMetadataForField(field) {
+    let metadata = null;
+    let geoEncoding = field.metadata?.[GEOARROW_COLUMN_METADATA_ENCODING];
+    if (geoEncoding) {
+      geoEncoding = geoEncoding.toLowerCase();
+      if (geoEncoding === "wkb") {
+        geoEncoding = "geoarrow.wkb";
+      }
+      if (geoEncoding === "wkt") {
+        geoEncoding = "geoarrow.wkt";
+      }
+      if (!GEOARROW_ENCODINGS.includes(geoEncoding)) {
+        console.warn(`Invalid GeoArrow encoding: ${geoEncoding}`);
+      } else {
+        metadata = metadata || {};
+        metadata.encoding = geoEncoding;
+      }
+    }
+    const columnMetadata = field.metadata?.[GEOARROW_COLUMN_METADATA_METADATA];
+    if (columnMetadata) {
+      try {
+        metadata = JSON.parse(columnMetadata);
+      } catch (error) {
+        console.warn("Failed to parse GeoArrow metadata", error);
+      }
+    }
+    return metadata || null;
+  }
 
-  // src/tables/convert-arrow-to-columnar-table.ts
-  function convertArrowToColumnarTable(table) {
-    const arrowTable = table.data;
-    const columnarTable = {};
-    for (const field of arrowTable.schema.fields) {
-      const arrowColumn = arrowTable.getChild(field.name);
-      const values = arrowColumn?.toArray();
-      columnarTable[field.name] = values;
+  // ../gis/src/lib/binary-features/binary-to-geojson.ts
+  function binaryToGeometry(data, startIndex, endIndex) {
+    switch (data.type) {
+      case "Point":
+        return pointToGeoJson(data, startIndex, endIndex);
+      case "LineString":
+        return lineStringToGeoJson(data, startIndex, endIndex);
+      case "Polygon":
+        return polygonToGeoJson(data, startIndex, endIndex);
+      default:
+        const unexpectedInput = data;
+        throw new Error(`Unsupported geometry type: ${unexpectedInput?.type}`);
     }
-    return {
-      shape: "columnar-table",
-      schema: table.schema,
-      data: columnarTable
-    };
+  }
+  function polygonToGeoJson(data, startIndex = -Infinity, endIndex = Infinity) {
+    const { positions } = data;
+    const polygonIndices = data.polygonIndices.value.filter((x) => x >= startIndex && x <= endIndex);
+    const primitivePolygonIndices = data.primitivePolygonIndices.value.filter(
+      (x) => x >= startIndex && x <= endIndex
+    );
+    const multi = polygonIndices.length > 2;
+    if (!multi) {
+      const coordinates2 = [];
+      for (let i = 0; i < primitivePolygonIndices.length - 1; i++) {
+        const startRingIndex = primitivePolygonIndices[i];
+        const endRingIndex = primitivePolygonIndices[i + 1];
+        const ringCoordinates = ringToGeoJson(positions, startRingIndex, endRingIndex);
+        coordinates2.push(ringCoordinates);
+      }
+      return { type: "Polygon", coordinates: coordinates2 };
+    }
+    const coordinates = [];
+    for (let i = 0; i < polygonIndices.length - 1; i++) {
+      const startPolygonIndex = polygonIndices[i];
+      const endPolygonIndex = polygonIndices[i + 1];
+      const polygonCoordinates = polygonToGeoJson(
+        data,
+        startPolygonIndex,
+        endPolygonIndex
+      ).coordinates;
+      coordinates.push(polygonCoordinates);
+    }
+    return { type: "MultiPolygon", coordinates };
+  }
+  function lineStringToGeoJson(data, startIndex = -Infinity, endIndex = Infinity) {
+    const { positions } = data;
+    const pathIndices = data.pathIndices.value.filter((x) => x >= startIndex && x <= endIndex);
+    const multi = pathIndices.length > 2;
+    if (!multi) {
+      const coordinates2 = ringToGeoJson(positions, pathIndices[0], pathIndices[1]);
+      return { type: "LineString", coordinates: coordinates2 };
+    }
+    const coordinates = [];
+    for (let i = 0; i < pathIndices.length - 1; i++) {
+      const ringCoordinates = ringToGeoJson(positions, pathIndices[i], pathIndices[i + 1]);
+      coordinates.push(ringCoordinates);
+    }
+    return { type: "MultiLineString", coordinates };
+  }
+  function pointToGeoJson(data, startIndex, endIndex) {
+    const { positions } = data;
+    const coordinates = ringToGeoJson(positions, startIndex, endIndex);
+    const multi = coordinates.length > 1;
+    if (multi) {
+      return { type: "MultiPoint", coordinates };
+    }
+    return { type: "Point", coordinates: coordinates[0] };
+  }
+  function ringToGeoJson(positions, startIndex, endIndex) {
+    startIndex = startIndex || 0;
+    endIndex = endIndex || positions.value.length / positions.size;
+    const ringCoordinates = [];
+    for (let j = startIndex; j < endIndex; j++) {
+      const coord = Array();
+      for (let k = j * positions.size; k < (j + 1) * positions.size; k++) {
+        coord.push(Number(positions.value[k]));
+      }
+      ringCoordinates.push(coord);
+    }
+    return ringCoordinates;
   }
 
-  // src/schema/convert-arrow-schema.ts
+  // src/lib/tables/convert-arrow-schema.ts
+  function convertArrowToSchema(arrowSchema) {
+    return serializeArrowSchema(arrowSchema);
+  }
   function serializeArrowSchema(arrowSchema) {
     return {
       fields: arrowSchema.fields.map((arrowField) => serializeArrowField(arrowField)),
@@ -12463,32 +12592,845 @@ return true;`);
     }
   }
 
-  // src/parsers/parse-arrow-sync.ts
-  function parseArrowSync(arrayBuffer, options) {
-    const apacheArrowTable = tableFromIPC([new Uint8Array(arrayBuffer)]);
-    const arrowTable = {
-      shape: "arrow-table",
-      schema: serializeArrowSchema(apacheArrowTable.schema),
-      data: apacheArrowTable
+  // ../wkt/src/lib/utils/version.ts
+  var VERSION = true ? "4.3.0-beta.1" : "latest";
+
+  // ../wkt/src/lib/parse-wkt.ts
+  var numberRegexp = /[-+]?([0-9]*\.[0-9]+|[0-9]+)([eE][-+]?[0-9]+)?/;
+  var tuples = new RegExp("^" + numberRegexp.source + "(\\s" + numberRegexp.source + "){1,}");
+  var WKT_MAGIC_STRINGS = [
+    "POINT(",
+    "LINESTRING(",
+    "POLYGON(",
+    "MULTIPOINT(",
+    "MULTILINESTRING(",
+    "MULTIPOLYGON(",
+    "GEOMETRYCOLLECTION("
+    // We only support this "geojson" subset of the OGC simple features standard
+  ];
+  function isWKT(input) {
+    return WKT_MAGIC_STRINGS.some((magicString) => input.startsWith(magicString));
+  }
+  function parseWKT(input, options) {
+    return parseWKTToGeometry(input, options);
+  }
+  function parseWKTToGeometry(input, options) {
+    const parts = input.split(";");
+    let _ = parts.pop();
+    const srid = (parts.shift() || "").split("=").pop();
+    const state = { parts, _, i: 0 };
+    const geometry = parseGeometry(state);
+    return options?.wkt?.crs ? addCRS(geometry, srid) : geometry;
+  }
+  function parseGeometry(state) {
+    return parsePoint(state) || parseLineString(state) || parsePolygon(state) || parseMultiPoint(state) || parseMultiLineString(state) || parseMultiPolygon(state) || parseGeometryCollection(state);
+  }
+  function addCRS(obj, srid) {
+    if (obj && srid?.match(/\d+/)) {
+      const crs = {
+        type: "name",
+        properties: {
+          name: "urn:ogc:def:crs:EPSG::" + srid
+        }
+      };
+      obj.crs = crs;
+    }
+    return obj;
+  }
+  function parsePoint(state) {
+    if (!$(/^(POINT(\sz)?)/i, state)) {
+      return null;
+    }
+    white(state);
+    if (!$(/^(\()/, state)) {
+      return null;
+    }
+    const c = coords(state);
+    if (!c) {
+      return null;
+    }
+    white(state);
+    if (!$(/^(\))/, state)) {
+      return null;
+    }
+    return {
+      type: "Point",
+      coordinates: c[0]
     };
-    const shape = options?.shape || "arrow-table";
+  }
+  function parseMultiPoint(state) {
+    if (!$(/^(MULTIPOINT)/i, state)) {
+      return null;
+    }
+    white(state);
+    const newCoordsFormat = state._?.substring(state._?.indexOf("(") + 1, state._.length - 1).replace(/\(/g, "").replace(/\)/g, "");
+    state._ = "MULTIPOINT (" + newCoordsFormat + ")";
+    const c = multicoords(state);
+    if (!c) {
+      return null;
+    }
+    white(state);
+    return {
+      type: "MultiPoint",
+      coordinates: c
+    };
+  }
+  function parseLineString(state) {
+    if (!$(/^(LINESTRING(\sz)?)/i, state)) {
+      return null;
+    }
+    white(state);
+    if (!$(/^(\()/, state)) {
+      return null;
+    }
+    const c = coords(state);
+    if (!c) {
+      return null;
+    }
+    if (!$(/^(\))/, state)) {
+      return null;
+    }
+    return {
+      type: "LineString",
+      coordinates: c
+    };
+  }
+  function parseMultiLineString(state) {
+    if (!$(/^(MULTILINESTRING)/i, state))
+      return null;
+    white(state);
+    const c = multicoords(state);
+    if (!c) {
+      return null;
+    }
+    white(state);
+    return {
+      // @ts-ignore
+      type: "MultiLineString",
+      // @ts-expect-error
+      coordinates: c
+    };
+  }
+  function parsePolygon(state) {
+    if (!$(/^(POLYGON(\sz)?)/i, state)) {
+      return null;
+    }
+    white(state);
+    const c = multicoords(state);
+    if (!c) {
+      return null;
+    }
+    return {
+      // @ts-ignore
+      type: "Polygon",
+      // @ts-expect-error
+      coordinates: c
+    };
+  }
+  function parseMultiPolygon(state) {
+    if (!$(/^(MULTIPOLYGON)/i, state)) {
+      return null;
+    }
+    white(state);
+    const c = multicoords(state);
+    if (!c) {
+      return null;
+    }
+    return {
+      type: "MultiPolygon",
+      // @ts-expect-error
+      coordinates: c
+    };
+  }
+  function parseGeometryCollection(state) {
+    const geometries = [];
+    let geometry;
+    if (!$(/^(GEOMETRYCOLLECTION)/i, state)) {
+      return null;
+    }
+    white(state);
+    if (!$(/^(\()/, state)) {
+      return null;
+    }
+    while (geometry = parseGeometry(state)) {
+      geometries.push(geometry);
+      white(state);
+      $(/^(,)/, state);
+      white(state);
+    }
+    if (!$(/^(\))/, state)) {
+      return null;
+    }
+    return {
+      type: "GeometryCollection",
+      geometries
+    };
+  }
+  function multicoords(state) {
+    white(state);
+    let depth = 0;
+    const rings = [];
+    const stack = [rings];
+    let pointer = rings;
+    let elem;
+    while (elem = $(/^(\()/, state) || $(/^(\))/, state) || $(/^(,)/, state) || $(tuples, state)) {
+      if (elem === "(") {
+        stack.push(pointer);
+        pointer = [];
+        stack[stack.length - 1].push(pointer);
+        depth++;
+      } else if (elem === ")") {
+        if (pointer.length === 0)
+          return null;
+        pointer = stack.pop();
+        if (!pointer)
+          return null;
+        depth--;
+        if (depth === 0)
+          break;
+      } else if (elem === ",") {
+        pointer = [];
+        stack[stack.length - 1].push(pointer);
+      } else if (!elem.split(/\s/g).some(isNaN)) {
+        Array.prototype.push.apply(pointer, elem.split(/\s/g).map(parseFloat));
+      } else {
+        return null;
+      }
+      white(state);
+    }
+    if (depth !== 0)
+      return null;
+    return rings;
+  }
+  function coords(state) {
+    const list = [];
+    let item;
+    let pt;
+    while (pt = $(tuples, state) || $(/^(,)/, state)) {
+      if (pt === ",") {
+        list.push(item);
+        item = [];
+      } else if (!pt.split(/\s/g).some(isNaN)) {
+        if (!item)
+          item = [];
+        Array.prototype.push.apply(item, pt.split(/\s/g).map(parseFloat));
+      }
+      white(state);
+    }
+    if (item)
+      list.push(item);
+    else
+      return null;
+    return list.length ? list : null;
+  }
+  function $(regexp, state) {
+    const match = state._?.substring(state.i).match(regexp);
+    if (!match)
+      return null;
+    else {
+      state.i += match[0].length;
+      return match[0];
+    }
+  }
+  function white(state) {
+    $(/^\s*/, state);
+  }
+
+  // ../wkt/src/wkt-loader.ts
+  var WKTWorkerLoader = {
+    dataType: null,
+    batchType: null,
+    name: "WKT (Well-Known Text)",
+    id: "wkt",
+    module: "wkt",
+    version: VERSION,
+    worker: true,
+    extensions: ["wkt"],
+    mimeTypes: ["text/plain"],
+    category: "geometry",
+    text: true,
+    tests: WKT_MAGIC_STRINGS,
+    testText: isWKT,
+    options: {
+      wkt: {
+        shape: "geojson-geometry",
+        crs: true
+      }
+    }
+  };
+  var WKTLoader = {
+    ...WKTWorkerLoader,
+    parse: async (arrayBuffer, options) => parseWKT(new TextDecoder().decode(arrayBuffer), options),
+    parseTextSync: (string, options) => parseWKT(string, options)
+  };
+
+  // ../wkt/src/lib/parse-wkb-header.ts
+  var EWKB_FLAG_Z = 2147483648;
+  var EWKB_FLAG_M = 1073741824;
+  var EWKB_FLAG_SRID = 536870912;
+  var MAX_SRID = 1e4;
+  function isWKB(arrayBuffer) {
+    const dataView = new DataView(arrayBuffer);
+    let byteOffset = 0;
+    const endianness = dataView.getUint8(byteOffset);
+    byteOffset += 1;
+    if (endianness > 1) {
+      return false;
+    }
+    const littleEndian = endianness === 1;
+    const geometry = dataView.getUint32(byteOffset, littleEndian);
+    byteOffset += 4;
+    const geometryType = geometry & 7;
+    if (geometryType === 0 || geometryType > 7) {
+      return false;
+    }
+    const geometryFlags = geometry - geometryType;
+    if (geometryFlags === 0 || geometryFlags === 1e3 || geometryFlags === 2e3 || geometryFlags === 3e3) {
+      return true;
+    }
+    if ((geometryFlags & ~(EWKB_FLAG_Z | EWKB_FLAG_M | EWKB_FLAG_SRID)) !== 0) {
+      return false;
+    }
+    if (geometryFlags & EWKB_FLAG_SRID) {
+      const srid = dataView.getUint32(byteOffset, littleEndian);
+      byteOffset += 4;
+      if (srid > MAX_SRID) {
+        return false;
+      }
+    }
+    return true;
+  }
+  function parseWKBHeader(dataView, target) {
+    const wkbHeader = Object.assign(target || {}, {
+      type: "wkb",
+      geometryType: 1,
+      dimensions: 2,
+      coordinates: "xy",
+      littleEndian: true,
+      byteOffset: 0
+    });
+    wkbHeader.littleEndian = dataView.getUint8(wkbHeader.byteOffset) === 1;
+    wkbHeader.byteOffset++;
+    const geometryCode = dataView.getUint32(wkbHeader.byteOffset, wkbHeader.littleEndian);
+    wkbHeader.byteOffset += 4;
+    wkbHeader.geometryType = geometryCode & 7;
+    const isoType = (geometryCode - wkbHeader.geometryType) / 1e3;
+    switch (isoType) {
+      case 0:
+        break;
+      case 1:
+        wkbHeader.type = "iso-wkb";
+        wkbHeader.dimensions = 3;
+        wkbHeader.coordinates = "xyz";
+        break;
+      case 2:
+        wkbHeader.type = "iso-wkb";
+        wkbHeader.dimensions = 3;
+        wkbHeader.coordinates = "xym";
+        break;
+      case 3:
+        wkbHeader.type = "iso-wkb";
+        wkbHeader.dimensions = 4;
+        wkbHeader.coordinates = "xyzm";
+        break;
+      default:
+        throw new Error(`WKB: Unsupported iso-wkb type: ${isoType}`);
+    }
+    const ewkbZ = geometryCode & EWKB_FLAG_Z;
+    const ewkbM = geometryCode & EWKB_FLAG_M;
+    const ewkbSRID = geometryCode & EWKB_FLAG_SRID;
+    if (ewkbZ && ewkbM) {
+      wkbHeader.type = "ewkb";
+      wkbHeader.dimensions = 4;
+      wkbHeader.coordinates = "xyzm";
+    } else if (ewkbZ) {
+      wkbHeader.type = "ewkb";
+      wkbHeader.dimensions = 3;
+      wkbHeader.coordinates = "xyz";
+    } else if (ewkbM) {
+      wkbHeader.type = "ewkb";
+      wkbHeader.dimensions = 3;
+      wkbHeader.coordinates = "xym";
+    }
+    if (ewkbSRID) {
+      wkbHeader.type = "ewkb";
+      wkbHeader.srid = dataView.getUint32(wkbHeader.byteOffset, wkbHeader.littleEndian);
+      wkbHeader.byteOffset += 4;
+    }
+    return wkbHeader;
+  }
+
+  // ../wkt/src/lib/parse-wkb.ts
+  function parseWKB(arrayBuffer, options) {
+    const binaryGeometry = parseWKBToBinary(arrayBuffer, options);
+    const shape = options?.wkb?.shape || "binary-geometry";
+    switch (shape) {
+      case "binary-geometry":
+        return binaryGeometry;
+      case "geojson-geometry":
+        return binaryToGeometry(binaryGeometry);
+      case "geometry":
+        console.error('WKBLoader: "geometry" shape is deprecated, use "binary-geometry" instead');
+        return binaryToGeometry(binaryGeometry);
+      default:
+        throw new Error(shape);
+    }
+  }
+  function parseWKBToBinary(arrayBuffer, options) {
+    const dataView = new DataView(arrayBuffer);
+    const wkbHeader = parseWKBHeader(dataView);
+    const { geometryType, dimensions, littleEndian } = wkbHeader;
+    const offset = wkbHeader.byteOffset;
+    switch (geometryType) {
+      case 1 /* Point */:
+        const point = parsePoint2(dataView, offset, dimensions, littleEndian);
+        return point.geometry;
+      case 2 /* LineString */:
+        const line = parseLineString2(dataView, offset, dimensions, littleEndian);
+        return line.geometry;
+      case 3 /* Polygon */:
+        const polygon = parsePolygon2(dataView, offset, dimensions, littleEndian);
+        return polygon.geometry;
+      case 4 /* MultiPoint */:
+        const multiPoint = parseMultiPoint2(dataView, offset, dimensions, littleEndian);
+        multiPoint.type = "Point";
+        return multiPoint;
+      case 5 /* MultiLineString */:
+        const multiLine = parseMultiLineString2(dataView, offset, dimensions, littleEndian);
+        multiLine.type = "LineString";
+        return multiLine;
+      case 6 /* MultiPolygon */:
+        const multiPolygon = parseMultiPolygon2(dataView, offset, dimensions, littleEndian);
+        multiPolygon.type = "Polygon";
+        return multiPolygon;
+      default:
+        throw new Error(`WKB: Unsupported geometry type: ${geometryType}`);
+    }
+  }
+  function parsePoint2(dataView, offset, dimension, littleEndian) {
+    const positions = new Float64Array(dimension);
+    for (let i = 0; i < dimension; i++) {
+      positions[i] = dataView.getFloat64(offset, littleEndian);
+      offset += 8;
+    }
+    return {
+      geometry: { type: "Point", positions: { value: positions, size: dimension } },
+      offset
+    };
+  }
+  function parseLineString2(dataView, offset, dimension, littleEndian) {
+    const nPoints = dataView.getUint32(offset, littleEndian);
+    offset += 4;
+    const positions = new Float64Array(nPoints * dimension);
+    for (let i = 0; i < nPoints * dimension; i++) {
+      positions[i] = dataView.getFloat64(offset, littleEndian);
+      offset += 8;
+    }
+    const pathIndices = [0];
+    if (nPoints > 0) {
+      pathIndices.push(nPoints);
+    }
+    return {
+      geometry: {
+        type: "LineString",
+        positions: { value: positions, size: dimension },
+        pathIndices: { value: new Uint32Array(pathIndices), size: 1 }
+      },
+      offset
+    };
+  }
+  var cumulativeSum = (sum) => (value) => sum += value;
+  function parsePolygon2(dataView, offset, dimension, littleEndian) {
+    const nRings = dataView.getUint32(offset, littleEndian);
+    offset += 4;
+    const rings = [];
+    for (let i = 0; i < nRings; i++) {
+      const parsed = parseLineString2(dataView, offset, dimension, littleEndian);
+      const { positions } = parsed.geometry;
+      offset = parsed.offset;
+      rings.push(positions.value);
+    }
+    const concatenatedPositions = new Float64Array(concatTypedArrays(rings).buffer);
+    const polygonIndices = [0];
+    if (concatenatedPositions.length > 0) {
+      polygonIndices.push(concatenatedPositions.length / dimension);
+    }
+    const primitivePolygonIndices = rings.map((l) => l.length / dimension).map(cumulativeSum(0));
+    primitivePolygonIndices.unshift(0);
+    return {
+      geometry: {
+        type: "Polygon",
+        positions: { value: concatenatedPositions, size: dimension },
+        polygonIndices: {
+          value: new Uint32Array(polygonIndices),
+          size: 1
+        },
+        primitivePolygonIndices: { value: new Uint32Array(primitivePolygonIndices), size: 1 }
+      },
+      offset
+    };
+  }
+  function parseMultiPoint2(dataView, offset, dimension, littleEndian) {
+    const nPoints = dataView.getUint32(offset, littleEndian);
+    offset += 4;
+    const binaryPointGeometries = [];
+    for (let i = 0; i < nPoints; i++) {
+      const littleEndianPoint = dataView.getUint8(offset) === 1;
+      offset++;
+      if (dataView.getUint32(offset, littleEndianPoint) % 1e3 !== 1) {
+        throw new Error("WKB: Inner geometries of MultiPoint not of type Point");
+      }
+      offset += 4;
+      const parsed = parsePoint2(dataView, offset, dimension, littleEndianPoint);
+      offset = parsed.offset;
+      binaryPointGeometries.push(parsed.geometry);
+    }
+    return concatenateBinaryPointGeometries(binaryPointGeometries, dimension);
+  }
+  function parseMultiLineString2(dataView, offset, dimension, littleEndian) {
+    const nLines = dataView.getUint32(offset, littleEndian);
+    offset += 4;
+    const binaryLineGeometries = [];
+    for (let i = 0; i < nLines; i++) {
+      const littleEndianLine = dataView.getUint8(offset) === 1;
+      offset++;
+      if (dataView.getUint32(offset, littleEndianLine) % 1e3 !== 2) {
+        throw new Error("WKB: Inner geometries of MultiLineString not of type LineString");
+      }
+      offset += 4;
+      const parsed = parseLineString2(dataView, offset, dimension, littleEndianLine);
+      offset = parsed.offset;
+      binaryLineGeometries.push(parsed.geometry);
+    }
+    return concatenateBinaryLineGeometries(binaryLineGeometries, dimension);
+  }
+  function parseMultiPolygon2(dataView, offset, dimension, littleEndian) {
+    const nPolygons = dataView.getUint32(offset, littleEndian);
+    offset += 4;
+    const binaryPolygonGeometries = [];
+    for (let i = 0; i < nPolygons; i++) {
+      const littleEndianPolygon = dataView.getUint8(offset) === 1;
+      offset++;
+      if (dataView.getUint32(offset, littleEndianPolygon) % 1e3 !== 3) {
+        throw new Error("WKB: Inner geometries of MultiPolygon not of type Polygon");
+      }
+      offset += 4;
+      const parsed = parsePolygon2(dataView, offset, dimension, littleEndianPolygon);
+      offset = parsed.offset;
+      binaryPolygonGeometries.push(parsed.geometry);
+    }
+    return concatenateBinaryPolygonGeometries(binaryPolygonGeometries, dimension);
+  }
+  function concatenateBinaryPointGeometries(binaryPointGeometries, dimension) {
+    const positions = binaryPointGeometries.map((geometry) => geometry.positions.value);
+    const concatenatedPositions = new Float64Array(concatTypedArrays(positions).buffer);
+    return {
+      type: "Point",
+      positions: { value: concatenatedPositions, size: dimension }
+    };
+  }
+  function concatenateBinaryLineGeometries(binaryLineGeometries, dimension) {
+    const lines = binaryLineGeometries.map((geometry) => geometry.positions.value);
+    const concatenatedPositions = new Float64Array(concatTypedArrays(lines).buffer);
+    const pathIndices = lines.map((line) => line.length / dimension).map(cumulativeSum(0));
+    pathIndices.unshift(0);
+    return {
+      type: "LineString",
+      positions: { value: concatenatedPositions, size: dimension },
+      pathIndices: { value: new Uint32Array(pathIndices), size: 1 }
+    };
+  }
+  function concatenateBinaryPolygonGeometries(binaryPolygonGeometries, dimension) {
+    const polygons = [];
+    const primitivePolygons = [];
+    for (const binaryPolygon of binaryPolygonGeometries) {
+      const { positions, primitivePolygonIndices: primitivePolygonIndices2 } = binaryPolygon;
+      polygons.push(positions.value);
+      primitivePolygons.push(primitivePolygonIndices2.value);
+    }
+    const concatenatedPositions = new Float64Array(concatTypedArrays(polygons).buffer);
+    const polygonIndices = polygons.map((p) => p.length / dimension).map(cumulativeSum(0));
+    polygonIndices.unshift(0);
+    const primitivePolygonIndices = [0];
+    for (const primitivePolygon of primitivePolygons) {
+      primitivePolygonIndices.push(
+        ...primitivePolygon.filter((x) => x > 0).map((x) => x + primitivePolygonIndices[primitivePolygonIndices.length - 1])
+      );
+    }
+    return {
+      type: "Polygon",
+      positions: { value: concatenatedPositions, size: dimension },
+      polygonIndices: { value: new Uint32Array(polygonIndices), size: 1 },
+      primitivePolygonIndices: { value: new Uint32Array(primitivePolygonIndices), size: 1 }
+    };
+  }
+  function concatTypedArrays(arrays) {
+    let byteLength = 0;
+    for (let i = 0; i < arrays.length; ++i) {
+      byteLength += arrays[i].byteLength;
+    }
+    const buffer = new Uint8Array(byteLength);
+    let byteOffset = 0;
+    for (let i = 0; i < arrays.length; ++i) {
+      const data = new Uint8Array(arrays[i].buffer);
+      byteLength = data.length;
+      for (let j = 0; j < byteLength; ++j) {
+        buffer[byteOffset++] = data[j];
+      }
+    }
+    return buffer;
+  }
+
+  // ../wkt/src/wkb-loader.ts
+  var WKBWorkerLoader = {
+    dataType: null,
+    batchType: null,
+    name: "WKB",
+    id: "wkb",
+    module: "wkt",
+    version: VERSION,
+    worker: true,
+    category: "geometry",
+    extensions: ["wkb"],
+    mimeTypes: [],
+    // TODO can we define static, serializable tests, eg. some binary strings?
+    tests: [isWKB],
+    options: {
+      wkb: {
+        shape: "binary-geometry"
+        // 'geojson-geometry'
+      }
+    }
+  };
+  var WKBLoader = {
+    ...WKBWorkerLoader,
+    parse: async (arrayBuffer) => parseWKB(arrayBuffer),
+    parseSync: parseWKB
+  };
+
+  // src/lib/geoarrow/convert-geoarrow-to-geojson-geometry.ts
+  function parseGeometryFromArrow(arrowCellValue, encoding) {
+    encoding = encoding?.toLowerCase();
+    if (!encoding || !arrowCellValue) {
+      return null;
+    }
+    let geometry;
+    switch (encoding) {
+      case "geoarrow.multipolygon":
+        geometry = arrowMultiPolygonToFeature(arrowCellValue);
+        break;
+      case "geoarrow.polygon":
+        geometry = arrowPolygonToFeature(arrowCellValue);
+        break;
+      case "geoarrow.multipoint":
+        geometry = arrowMultiPointToFeature(arrowCellValue);
+        break;
+      case "geoarrow.point":
+        geometry = arrowPointToFeature(arrowCellValue);
+        break;
+      case "geoarrow.multilinestring":
+        geometry = arrowMultiLineStringToFeature(arrowCellValue);
+        break;
+      case "geoarrow.linestring":
+        geometry = arrowLineStringToFeature(arrowCellValue);
+        break;
+      case "geoarrow.wkb":
+        geometry = arrowWKBToFeature(arrowCellValue);
+        break;
+      case "geoarrow.wkt":
+        geometry = arrowWKTToFeature(arrowCellValue);
+        break;
+      default: {
+        throw Error(`GeoArrow encoding not supported ${encoding}`);
+      }
+    }
+    return geometry;
+  }
+  function arrowWKBToFeature(arrowCellValue) {
+    const arrayBuffer = arrowCellValue.buffer.slice(
+      arrowCellValue.byteOffset,
+      arrowCellValue.byteOffset + arrowCellValue.byteLength
+    );
+    const binaryGeometry = WKBLoader.parseSync?.(arrayBuffer);
+    const geometry = binaryToGeometry(binaryGeometry);
+    return geometry;
+  }
+  function arrowWKTToFeature(arrowCellValue) {
+    const string = arrowCellValue;
+    return WKTLoader.parseTextSync?.(string);
+  }
+  function arrowMultiPolygonToFeature(arrowMultiPolygon) {
+    const multiPolygon = [];
+    for (let m = 0; m < arrowMultiPolygon.length; m++) {
+      const arrowPolygon = arrowMultiPolygon.get(m);
+      const polygon = [];
+      for (let i = 0; arrowPolygon && i < arrowPolygon?.length; i++) {
+        const arrowRing = arrowPolygon?.get(i);
+        const ring = [];
+        for (let j = 0; arrowRing && j < arrowRing.length; j++) {
+          const arrowCoord = arrowRing.get(j);
+          const coord = Array.from(arrowCoord);
+          ring.push(coord);
+        }
+        polygon.push(ring);
+      }
+      multiPolygon.push(polygon);
+    }
+    const geometry = {
+      type: "MultiPolygon",
+      coordinates: multiPolygon
+    };
+    return geometry;
+  }
+  function arrowPolygonToFeature(arrowPolygon) {
+    const polygon = [];
+    for (let i = 0; arrowPolygon && i < arrowPolygon.length; i++) {
+      const arrowRing = arrowPolygon.get(i);
+      const ring = [];
+      for (let j = 0; arrowRing && j < arrowRing.length; j++) {
+        const arrowCoord = arrowRing.get(j);
+        const coords2 = Array.from(arrowCoord);
+        ring.push(coords2);
+      }
+      polygon.push(ring);
+    }
+    const geometry = {
+      type: "Polygon",
+      coordinates: polygon
+    };
+    return geometry;
+  }
+  function arrowMultiPointToFeature(arrowMultiPoint) {
+    const multiPoint = [];
+    for (let i = 0; arrowMultiPoint && i < arrowMultiPoint.length; i++) {
+      const arrowPoint = arrowMultiPoint.get(i);
+      if (arrowPoint) {
+        const coord = Array.from(arrowPoint);
+        multiPoint.push(coord);
+      }
+    }
+    return {
+      type: "MultiPoint",
+      coordinates: multiPoint
+    };
+  }
+  function arrowPointToFeature(arrowPoint) {
+    const point = Array.from(arrowPoint);
+    return {
+      type: "Point",
+      coordinates: point
+    };
+  }
+  function arrowMultiLineStringToFeature(arrowMultiLineString) {
+    const multiLineString = [];
+    for (let i = 0; arrowMultiLineString && i < arrowMultiLineString.length; i++) {
+      const arrowLineString = arrowMultiLineString.get(i);
+      const lineString = [];
+      for (let j = 0; arrowLineString && j < arrowLineString.length; j++) {
+        const arrowCoord = arrowLineString.get(j);
+        if (arrowCoord) {
+          const coords2 = Array.from(arrowCoord);
+          lineString.push(coords2);
+        }
+      }
+      multiLineString.push(lineString);
+    }
+    return {
+      type: "MultiLineString",
+      coordinates: multiLineString
+    };
+  }
+  function arrowLineStringToFeature(arrowLineString) {
+    const lineString = [];
+    for (let i = 0; arrowLineString && i < arrowLineString.length; i++) {
+      const arrowCoord = arrowLineString.get(i);
+      if (arrowCoord) {
+        const coords2 = Array.from(arrowCoord);
+        lineString.push(coords2);
+      }
+    }
+    return {
+      type: "LineString",
+      coordinates: lineString
+    };
+  }
+
+  // src/lib/tables/convert-arrow-to-table.ts
+  function convertArrowToTable(arrowTable, shape) {
     switch (shape) {
       case "arrow-table":
-        return arrowTable;
+        return convertArrowToArrowTable(arrowTable);
+      case "array-row-table":
+        return convertArrowToArrayRowTable(arrowTable);
+      case "object-row-table":
+        return convertArrowToObjectRowTable(arrowTable);
       case "columnar-table":
         return convertArrowToColumnarTable(arrowTable);
-      case "object-row-table":
-        let columnarTable = convertArrowToColumnarTable(arrowTable);
-        return convertTable(columnarTable, "object-row-table");
-      case "array-row-table":
-        columnarTable = convertArrowToColumnarTable(arrowTable);
-        return convertTable(columnarTable, "array-row-table");
+      case "geojson-table":
+        return convertArrowToGeoJSONTable(arrowTable);
       default:
         throw new Error(shape);
     }
   }
+  function convertArrowToArrowTable(arrowTable) {
+    return {
+      shape: "arrow-table",
+      schema: convertArrowToSchema(arrowTable.schema),
+      data: arrowTable
+    };
+  }
+  function convertArrowToArrayRowTable(arrowTable) {
+    const columnarTable = convertArrowToColumnarTable(arrowTable);
+    return convertTable(columnarTable, "array-row-table");
+  }
+  function convertArrowToObjectRowTable(arrowTable) {
+    const columnarTable = convertArrowToColumnarTable(arrowTable);
+    return convertTable(columnarTable, "object-row-table");
+  }
+  function convertArrowToColumnarTable(arrowTable) {
+    const columns = {};
+    for (const field of arrowTable.schema.fields) {
+      const arrowColumn = arrowTable.getChild(field.name);
+      const values = arrowColumn?.toArray();
+      columns[field.name] = values;
+    }
+    const schema = convertArrowToSchema(arrowTable.schema);
+    return {
+      shape: "columnar-table",
+      schema,
+      data: columns
+    };
+  }
+  function convertArrowToGeoJSONTable(arrowTable) {
+    const schema = convertArrowToSchema(arrowTable.schema);
+    const geometryColumns = getGeometryColumnsFromSchema(schema);
+    const encoding = geometryColumns.geometry.encoding;
+    const features = [];
+    const propertyColumnNames = arrowTable.schema.fields.map((field) => field.name).filter((name) => !(name in geometryColumns));
+    const propertiesTable = arrowTable.select(propertyColumnNames);
+    const arrowGeometryColumn = arrowTable.getChild("geometry");
+    for (let row = 0; row < arrowTable.numRows; row++) {
+      const arrowGeometry = arrowGeometryColumn?.get(row);
+      const feature = parseGeometryFromArrow(arrowGeometry, encoding);
+      if (feature) {
+        const properties = propertiesTable.get(row)?.toJSON() || {};
+        features.push({ type: "Feature", geometry: feature, properties });
+      }
+    }
+    return {
+      shape: "geojson-table",
+      type: "FeatureCollection",
+      schema,
+      features
+    };
+  }
 
-  // src/parsers/parse-arrow-in-batches.ts
+  // src/lib/parsers/parse-arrow.ts
+  function parseArrowSync(arrayBuffer, options) {
+    const shape = options?.shape || "arrow-table";
+    const arrowTable = tableFromIPC([new Uint8Array(arrayBuffer)]);
+    return convertArrowToTable(arrowTable, shape);
+  }
   function parseArrowInBatches(asyncIterator, options) {
     async function* makeArrowAsyncIterator() {
       const readers = RecordBatchReader.readAll(asyncIterator);
@@ -12511,15 +13453,15 @@ return true;`);
     return makeArrowAsyncIterator();
   }
 
-  // src/arrow-loader.ts
-  var VERSION = true ? "4.3.0-alpha.7" : "latest";
+  // src/exports/arrow-loader.ts
+  var VERSION2 = true ? "4.3.0-beta.1" : "latest";
   var ArrowWorkerLoader = {
     dataType: null,
     batchType: null,
     name: "Apache Arrow",
     id: "arrow",
     module: "arrow",
-    version: VERSION,
+    version: VERSION2,
     // worker: true,
     category: "table",
     extensions: ["arrow", "feather"],
@@ -12536,6 +13478,8 @@ return true;`);
       }
     }
   };
+
+  // src/arrow-loader.ts
   var ArrowLoader = {
     ...ArrowWorkerLoader,
     parse: async (arraybuffer, options) => parseArrowSync(arraybuffer, options?.arrow),