@loaders.gl/arrow 4.3.2 → 4.4.0-alpha.1

package/dist/arrow-worker.js

@@ -205,7 +205,7 @@
     return await parser(data, { ...options }, context, loader);
   }
 
-  // ../../node_modules/tslib/tslib.es6.mjs
+  // ../../node_modules/apache-arrow/node_modules/tslib/tslib.es6.mjs
   function __rest(s, e) {
     var t = {};
     for (var p in s)
@@ -1610,9 +1610,22 @@
       this.addInt8(0);
       this.startVector(1, utf8.length, 1);
       this.bb.setPosition(this.space -= utf8.length);
-      for (let i = 0, offset = this.space, bytes = this.bb.bytes(); i < utf8.length; i++) {
-        bytes[offset++] = utf8[i];
+      this.bb.bytes().set(utf8, this.space);
+      return this.endVector();
+    }
+    /**
+     * Create a byte vector.
+     *
+     * @param v The bytes to add
+     * @returns The offset in the buffer where the byte vector starts
+     */
+    createByteVector(v) {
+      if (v === null || v === void 0) {
+        return 0;
       }
+      this.startVector(1, v.length, 1);
+      this.bb.setPosition(this.space -= v.length);
+      this.bb.bytes().set(v, this.space);
       return this.endVector();
     }
     /**
@@ -3215,9 +3228,9 @@
   // ../../node_modules/apache-arrow/util/vector.mjs
   var vector_exports = {};
   __export(vector_exports, {
-    clampIndex: () => clampIndex,
     clampRange: () => clampRange,
-    createElementComparator: () => createElementComparator
+    createElementComparator: () => createElementComparator,
+    wrapIndex: () => wrapIndex
   });
 
   // ../../node_modules/apache-arrow/util/pretty.mjs
@@ -3258,9 +3271,23 @@
   __export(bn_exports, {
     BN: () => BN,
     bigNumToBigInt: () => bigNumToBigInt,
+    bigNumToNumber: () => bigNumToNumber,
     bigNumToString: () => bigNumToString,
     isArrowBigNumSymbol: () => isArrowBigNumSymbol
   });
+
+  // ../../node_modules/apache-arrow/util/bigint.mjs
+  function bigIntToNumber(number) {
+    if (typeof number === "bigint" && (number < Number.MIN_SAFE_INTEGER || number > Number.MAX_SAFE_INTEGER)) {
+      throw new TypeError(`${number} is not safe to convert to a number.`);
+    }
+    return Number(number);
+  }
+  function divideBigInts(number, divisor) {
+    return bigIntToNumber(number / divisor) + bigIntToNumber(number % divisor) / bigIntToNumber(divisor);
+  }
+
+  // ../../node_modules/apache-arrow/util/bn.mjs
   var isArrowBigNumSymbol = Symbol.for("isArrowBigNum");
   function BigNum(x, ...xs) {
     if (xs.length === 0) {
@@ -3272,8 +3299,8 @@
   BigNum.prototype.toJSON = function() {
     return `"${bigNumToString(this)}"`;
   };
-  BigNum.prototype.valueOf = function() {
-    return bigNumToNumber(this);
+  BigNum.prototype.valueOf = function(scale) {
+    return bigNumToNumber(this, scale);
   };
   BigNum.prototype.toString = function() {
     return bigNumToString(this);
@@ -3304,25 +3331,34 @@
   Object.assign(SignedBigNum.prototype, BigNum.prototype, { "constructor": SignedBigNum, "signed": true, "TypedArray": Int32Array, "BigIntArray": BigInt64Array });
   Object.assign(UnsignedBigNum.prototype, BigNum.prototype, { "constructor": UnsignedBigNum, "signed": false, "TypedArray": Uint32Array, "BigIntArray": BigUint64Array });
   Object.assign(DecimalBigNum.prototype, BigNum.prototype, { "constructor": DecimalBigNum, "signed": true, "TypedArray": Uint32Array, "BigIntArray": BigUint64Array });
-  function bigNumToNumber(bn) {
-    const { buffer, byteOffset, length, "signed": signed } = bn;
-    const words = new BigUint64Array(buffer, byteOffset, length);
+  var TWO_TO_THE_64 = BigInt(4294967296) * BigInt(4294967296);
+  var TWO_TO_THE_64_MINUS_1 = TWO_TO_THE_64 - BigInt(1);
+  function bigNumToNumber(bn, scale) {
+    const { buffer, byteOffset, byteLength, "signed": signed } = bn;
+    const words = new BigUint64Array(buffer, byteOffset, byteLength / 8);
     const negative = signed && words.at(-1) & BigInt(1) << BigInt(63);
-    let number = negative ? BigInt(1) : BigInt(0);
-    let i = BigInt(0);
-    if (!negative) {
+    let number = BigInt(0);
+    let i = 0;
+    if (negative) {
       for (const word of words) {
-        number += word * (BigInt(1) << BigInt(32) * i++);
+        number |= (word ^ TWO_TO_THE_64_MINUS_1) * (BigInt(1) << BigInt(64 * i++));
       }
+      number *= BigInt(-1);
+      number -= BigInt(1);
     } else {
       for (const word of words) {
-        number += ~word * (BigInt(1) << BigInt(32) * i++);
+        number |= word * (BigInt(1) << BigInt(64 * i++));
       }
-      number *= BigInt(-1);
     }
-    return number;
+    if (typeof scale === "number") {
+      const denominator = BigInt(Math.pow(10, scale));
+      const quotient = number / denominator;
+      const remainder = number % denominator;
+      return bigIntToNumber(quotient) + bigIntToNumber(remainder) / bigIntToNumber(denominator);
+    }
+    return bigIntToNumber(number);
   }
-  var bigNumToString = (a) => {
+  function bigNumToString(a) {
     if (a.byteLength === 8) {
       const bigIntArray = new a["BigIntArray"](a.buffer, a.byteOffset, 1);
       return `${bigIntArray[0]}`;
@@ -3345,15 +3381,15 @@
     }
     const negated = unsignedBigNumToString(array);
     return `-${negated}`;
-  };
-  var bigNumToBigInt = (a) => {
+  }
+  function bigNumToBigInt(a) {
     if (a.byteLength === 8) {
       const bigIntArray = new a["BigIntArray"](a.buffer, a.byteOffset, 1);
       return bigIntArray[0];
     } else {
       return bigNumToString(a);
     }
-  };
+  }
   function unsignedBigNumToString(a) {
     let digits = "";
     const base64 = new Uint32Array(2);
@@ -3410,14 +3446,6 @@
     }
   };
 
-  // ../../node_modules/apache-arrow/util/bigint.mjs
-  function bigIntToNumber(number) {
-    if (typeof number === "bigint" && (number < Number.MIN_SAFE_INTEGER || number > Number.MAX_SAFE_INTEGER)) {
-      throw new TypeError(`${number} is not safe to convert to a number.`);
-    }
-    return Number(number);
-  }
-
   // ../../node_modules/apache-arrow/type.mjs
   var _a;
   var _b;
@@ -3792,11 +3820,13 @@
     toString() {
       return `Date${(this.unit + 1) * 32}<${DateUnit[this.unit]}>`;
     }
+    get ArrayType() {
+      return this.unit === DateUnit.DAY ? Int32Array : BigInt64Array;
+    }
   };
   _l = Symbol.toStringTag;
   Date_[_l] = ((proto) => {
     proto.unit = null;
-    proto.ArrayType = Int32Array;
     return proto[Symbol.toStringTag] = "Date";
   })(Date_.prototype);
   var DateDay = class extends Date_ {
@@ -3868,7 +3898,7 @@
   Timestamp_[_o] = ((proto) => {
     proto.unit = null;
     proto.timezone = null;
-    proto.ArrayType = Int32Array;
+    proto.ArrayType = BigInt64Array;
     return proto[Symbol.toStringTag] = "Timestamp";
   })(Timestamp_.prototype);
   var TimestampSecond = class extends Timestamp_ {
@@ -4103,10 +4133,6 @@
     switch (type.typeId) {
       case Type2.Decimal:
         return type.bitWidth / 32;
-      case Type2.Timestamp:
-        return 2;
-      case Type2.Date:
-        return 1 + t.unit;
       case Type2.Interval:
         return 1 + t.unit;
       case Type2.FixedSizeList:
@@ -4573,19 +4599,7 @@
     };
   }
   var setEpochMsToDays = (data, index, epochMs) => {
-    data[index] = Math.trunc(epochMs / 864e5);
-  };
-  var setEpochMsToMillisecondsLong = (data, index, epochMs) => {
-    data[index] = Math.trunc(epochMs % 4294967296);
-    data[index + 1] = Math.trunc(epochMs / 4294967296);
-  };
-  var setEpochMsToMicrosecondsLong = (data, index, epochMs) => {
-    data[index] = Math.trunc(epochMs * 1e3 % 4294967296);
-    data[index + 1] = Math.trunc(epochMs * 1e3 / 4294967296);
-  };
-  var setEpochMsToNanosecondsLong = (data, index, epochMs) => {
-    data[index] = Math.trunc(epochMs * 1e6 % 4294967296);
-    data[index + 1] = Math.trunc(epochMs * 1e6 / 4294967296);
+    data[index] = Math.floor(epochMs / 864e5);
   };
   var setVariableWidthBytes = (values, valueOffsets, index, value) => {
     if (index + 1 < valueOffsets.length) {
@@ -4620,7 +4634,7 @@
     setEpochMsToDays(values, index, value.valueOf());
   };
   var setDateMillisecond = ({ values }, index, value) => {
-    setEpochMsToMillisecondsLong(values, index * 2, value.valueOf());
+    values[index] = BigInt(value);
   };
   var setFixedSizeBinary = ({ stride, values }, index, value) => {
     values.set(value.subarray(0, stride), stride * index);
@@ -4630,10 +4644,18 @@
   var setDate = (data, index, value) => {
     data.type.unit === DateUnit.DAY ? setDateDay(data, index, value) : setDateMillisecond(data, index, value);
   };
-  var setTimestampSecond = ({ values }, index, value) => setEpochMsToMillisecondsLong(values, index * 2, value / 1e3);
-  var setTimestampMillisecond = ({ values }, index, value) => setEpochMsToMillisecondsLong(values, index * 2, value);
-  var setTimestampMicrosecond = ({ values }, index, value) => setEpochMsToMicrosecondsLong(values, index * 2, value);
-  var setTimestampNanosecond = ({ values }, index, value) => setEpochMsToNanosecondsLong(values, index * 2, value);
+  var setTimestampSecond = ({ values }, index, value) => {
+    values[index] = BigInt(value / 1e3);
+  };
+  var setTimestampMillisecond = ({ values }, index, value) => {
+    values[index] = BigInt(value);
+  };
+  var setTimestampMicrosecond = ({ values }, index, value) => {
+    values[index] = BigInt(value * 1e3);
+  };
+  var setTimestampNanosecond = ({ values }, index, value) => {
+    values[index] = BigInt(value * 1e6);
+  };
   var setTimestamp = (data, index, value) => {
     switch (data.type.unit) {
       case TimeUnit.SECOND:
@@ -4938,12 +4960,6 @@
     return (data, _1) => data.getValid(_1) ? fn(data, _1) : null;
   }
   var epochDaysToMs = (data, index) => 864e5 * data[index];
-  var epochMillisecondsLongToMs = (data, index) => 4294967296 * data[index + 1] + (data[index] >>> 0);
-  var epochMicrosecondsLongToMs = (data, index) => 4294967296 * (data[index + 1] / 1e3) + (data[index] >>> 0) / 1e3;
-  var epochNanosecondsLongToMs = (data, index) => 4294967296 * (data[index + 1] / 1e6) + (data[index] >>> 0) / 1e6;
-  var epochMillisecondsToDate = (epochMs) => new Date(epochMs);
-  var epochDaysToDate = (data, index) => epochMillisecondsToDate(epochDaysToMs(data, index));
-  var epochMillisecondsLongToDate = (data, index) => epochMillisecondsToDate(epochMillisecondsLongToMs(data, index));
   var getNull = (_data, _index) => null;
   var getVariableWidthBytes = (values, valueOffsets, index) => {
     if (index + 1 >= valueOffsets.length) {
@@ -4958,8 +4974,8 @@
     const byte = values[idx >> 3];
     return (byte & 1 << idx % 8) !== 0;
   };
-  var getDateDay = ({ values }, index) => epochDaysToDate(values, index);
-  var getDateMillisecond = ({ values }, index) => epochMillisecondsLongToDate(values, index * 2);
+  var getDateDay = ({ values }, index) => epochDaysToMs(values, index);
+  var getDateMillisecond = ({ values }, index) => bigIntToNumber(values[index]);
   var getNumeric = ({ stride, values }, index) => values[stride * index];
   var getFloat16 = ({ stride, values }, index) => uint16ToFloat64(values[stride * index]);
   var getBigInts = ({ values }, index) => values[index];
@@ -4972,10 +4988,10 @@
   var getInt = ({ values }, index) => values[index];
   var getFloat = ({ type, values }, index) => type.precision !== Precision.HALF ? values[index] : uint16ToFloat64(values[index]);
   var getDate = (data, index) => data.type.unit === DateUnit.DAY ? getDateDay(data, index) : getDateMillisecond(data, index);
-  var getTimestampSecond = ({ values }, index) => 1e3 * epochMillisecondsLongToMs(values, index * 2);
-  var getTimestampMillisecond = ({ values }, index) => epochMillisecondsLongToMs(values, index * 2);
-  var getTimestampMicrosecond = ({ values }, index) => epochMicrosecondsLongToMs(values, index * 2);
-  var getTimestampNanosecond = ({ values }, index) => epochNanosecondsLongToMs(values, index * 2);
+  var getTimestampSecond = ({ values }, index) => 1e3 * bigIntToNumber(values[index]);
+  var getTimestampMillisecond = ({ values }, index) => bigIntToNumber(values[index]);
+  var getTimestampMicrosecond = ({ values }, index) => divideBigInts(values[index], BigInt(1e3));
+  var getTimestampNanosecond = ({ values }, index) => divideBigInts(values[index], BigInt(1e6));
   var getTimestamp = (data, index) => {
     switch (data.type.unit) {
       case TimeUnit.SECOND:
@@ -5124,12 +5140,18 @@
   // ../../node_modules/apache-arrow/row/map.mjs
   var kKeys = Symbol.for("keys");
   var kVals = Symbol.for("vals");
+  var kKeysAsStrings = Symbol.for("kKeysAsStrings");
+  var _kKeysAsStrings = Symbol.for("_kKeysAsStrings");
   var MapRow = class {
     constructor(slice) {
       this[kKeys] = new Vector([slice.children[0]]).memoize();
       this[kVals] = slice.children[1];
       return new Proxy(this, new MapRowProxyHandler());
     }
+    /** @ignore */
+    get [kKeysAsStrings]() {
+      return this[_kKeysAsStrings] || (this[_kKeysAsStrings] = Array.from(this[kKeys].toArray(), String));
+    }
     [Symbol.iterator]() {
       return new MapRowIterator(this[kKeys], this[kVals]);
     }
@@ -5191,13 +5213,13 @@
       return true;
     }
     ownKeys(row) {
-      return row[kKeys].toArray().map(String);
+      return row[kKeysAsStrings];
     }
     has(row, key) {
-      return row[kKeys].includes(key);
+      return row[kKeysAsStrings].includes(key);
     }
     getOwnPropertyDescriptor(row, key) {
-      const idx = row[kKeys].indexOf(key);
+      const idx = row[kKeysAsStrings].indexOf(key);
       if (idx !== -1) {
         return { writable: true, enumerable: true, configurable: true };
       }
@@ -5207,7 +5229,7 @@
       if (Reflect.has(row, key)) {
         return row[key];
       }
-      const idx = row[kKeys].indexOf(key);
+      const idx = row[kKeysAsStrings].indexOf(key);
       if (idx !== -1) {
         const val = instance2.visit(Reflect.get(row, kVals), idx);
         Reflect.set(row, key, val);
@@ -5215,7 +5237,7 @@
       }
     }
     set(row, key, val) {
-      const idx = row[kKeys].indexOf(key);
+      const idx = row[kKeysAsStrings].indexOf(key);
       if (idx !== -1) {
         instance.visit(Reflect.get(row, kVals), idx, val);
         return Reflect.set(row, key, val);
@@ -5228,15 +5250,11 @@
   Object.defineProperties(MapRow.prototype, {
     [Symbol.toStringTag]: { enumerable: false, configurable: false, value: "Row" },
     [kKeys]: { writable: true, enumerable: false, configurable: false, value: null },
-    [kVals]: { writable: true, enumerable: false, configurable: false, value: null }
+    [kVals]: { writable: true, enumerable: false, configurable: false, value: null },
+    [_kKeysAsStrings]: { writable: true, enumerable: false, configurable: false, value: null }
   });
 
   // ../../node_modules/apache-arrow/util/vector.mjs
-  function clampIndex(source, index, then) {
-    const length = source.length;
-    const adjust = index > -1 ? index : length + index % length;
-    return then ? then(source, adjust) : adjust;
-  }
   var tmp;
   function clampRange(source, begin, end, then) {
     const { length: len = 0 } = source;
@@ -5248,6 +5266,7 @@
     rhs > len && (rhs = len);
     return then ? then(source, lhs, rhs) : [lhs, rhs];
   }
+  var wrapIndex = (index, len) => index < 0 ? len + index : index;
   var isNaNFast = (value) => value !== value;
   function createElementComparator(search) {
     const typeofSearch = typeof search;
@@ -5536,7 +5555,10 @@
       let nullCount = this._nullCount;
       let nullBitmap;
       if (nullCount <= kUnknownNullCount && (nullBitmap = this.nullBitmap)) {
-        this._nullCount = nullCount = this.length - popcnt_bit_range(nullBitmap, this.offset, this.offset + this.length);
+        this._nullCount = nullCount = nullBitmap.length === 0 ? (
+          // no null bitmap, so all values are valid
+          0
+        ) : this.length - popcnt_bit_range(nullBitmap, this.offset, this.offset + this.length);
       }
       return nullCount;
     }
@@ -5598,12 +5620,14 @@
           nullBitmap = new Uint8Array((offset + length + 63 & ~63) >> 3).fill(255);
           if (this.nullCount > 0) {
             nullBitmap.set(truncateBitmap(offset, length, this.nullBitmap), 0);
+            Object.assign(this, { nullBitmap });
+          } else {
+            Object.assign(this, { nullBitmap, _nullCount: 0 });
           }
-          Object.assign(this, { nullBitmap, _nullCount: -1 });
         }
         const byte = nullBitmap[byteOffset];
         prev = (byte & mask) !== 0;
-        value ? nullBitmap[byteOffset] = byte | mask : nullBitmap[byteOffset] = byte & ~mask;
+        nullBitmap[byteOffset] = value ? byte | mask : byte & ~mask;
       }
       if (prev !== !!value) {
         this._nullCount = this.nullCount + (value ? -1 : 1);
@@ -6044,7 +6068,9 @@
   };
   function vectorIterator(vector) {
     const { type } = vector;
-    if (vector.nullCount === 0 && vector.stride === 1 && (type.typeId === Type2.Timestamp || type instanceof Int_ && type.bitWidth !== 64 || type instanceof Time_ && type.bitWidth !== 64 || type instanceof Float && type.precision !== Precision.HALF)) {
+    if (vector.nullCount === 0 && vector.stride === 1 && // Don't defer to native iterator for timestamps since Numbers are expected
+    // (DataType.isTimestamp(type)) && type.unit === TimeUnit.MILLISECOND ||
+    (DataType.isInt(type) && type.bitWidth !== 64 || DataType.isTime(type) && type.bitWidth !== 64 || DataType.isFloat(type) && type.precision !== Precision.HALF)) {
       return new ChunkedIterator(vector.data.length, (chunkIndex) => {
         const data = vector.data[chunkIndex];
         return data.values.subarray(0, data.length)[Symbol.iterator]();
@@ -6218,6 +6244,13 @@
     get(index) {
       return null;
     }
+    /**
+     * Get an element value by position.
+     * @param index The index of the element to read. A negative index will count back from the last element.
+     */
+    at(index) {
+      return this.get(wrapIndex(index, this.length));
+    }
     /**
      * Set an element value by position.
      * @param index The index of the element to write.
@@ -6995,7 +7028,7 @@ return true;`);
       this.fields = fields || [];
       this.metadata = metadata || /* @__PURE__ */ new Map();
       if (!dictionaries) {
-        dictionaries = generateDictionaryMap(fields);
+        dictionaries = generateDictionaryMap(this.fields);
       }
       this.dictionaries = dictionaries;
       this.metadataVersion = metadataVersion;
@@ -7497,8 +7530,8 @@ return true;`);
         return (yield this.next(size, "peek")).value;
       });
     }
-    next(size, cmd = "read") {
-      return __awaiter(this, void 0, void 0, function* () {
+    next(size_1) {
+      return __awaiter(this, arguments, void 0, function* (size, cmd = "read") {
         return yield this.source.next({ cmd, size });
       });
     }
@@ -9075,6 +9108,14 @@ return true;`);
     get(index) {
       return null;
     }
+    /**
+      * Get an element value by position.
+      * @param index The index of the element to read. A negative index will count back from the last element.
+      */
+    // @ts-ignore
+    at(index) {
+      return this.get(wrapIndex(index, this.numRows));
+    }
     /**
      * Set an element value by position.
      *
@@ -9312,7 +9353,7 @@ return true;`);
       return this.data.nullCount;
     }
     /**
-     * Check whether an element is null.
+     * Check whether an row is null.
      * @param index The index at which to read the validity bitmap.
      */
     isValid(index) {
@@ -9320,14 +9361,21 @@ return true;`);
     }
     /**
      * Get a row by position.
-     * @param index The index of the element to read.
+     * @param index The index of the row to read.
      */
     get(index) {
       return instance2.visit(this.data, index);
     }
+    /**
+      * Get a row value by position.
+      * @param index The index of the row to read. A negative index will count back from the last row.
+      */
+    at(index) {
+      return this.get(wrapIndex(index, this.numRows));
+    }
     /**
      * Set a row by position.
-     * @param index The index of the element to write.
+     * @param index The index of the row to write.
      * @param value The value to set.
      */
     set(index, value) {
@@ -9364,7 +9412,7 @@ return true;`);
     /**
      * Return a zero-copy sub-section of this RecordBatch.
      * @param start The beginning of the specified portion of the RecordBatch.
-     * @param end The end of the specified portion of the RecordBatch. This is exclusive of the element at the index 'end'.
+     * @param end The end of the specified portion of the RecordBatch. This is exclusive of the row at the index 'end'.
      */
     slice(begin, end) {
       const [slice] = new Vector([this.data]).slice(begin, end).data;
@@ -10452,8 +10500,8 @@ return true;`);
         );
       });
     }
-    readSchema(throwIfNull = false) {
-      return __awaiter(this, void 0, void 0, function* () {
+    readSchema() {
+      return __awaiter(this, arguments, void 0, function* (throwIfNull = false) {
         const type = MessageHeader.Schema;
         const message = yield this.readMessage(type);
         const schema = message === null || message === void 0 ? void 0 : message.header();
@@ -10701,8 +10749,8 @@ return true;`);
       this._impl = _impl;
     }
     readAll() {
-      var _a5, e_1, _b2, _c2;
       return __awaiter(this, void 0, void 0, function* () {
+        var _a5, e_1, _b2, _c2;
         const batches = new Array();
         try {
           for (var _d2 = true, _e2 = __asyncValues(this), _f2; _f2 = yield _e2.next(), _a5 = _f2.done, !_a5; _d2 = true) {
@@ -10786,12 +10834,9 @@ return true;`);
       const { id, isDelta } = header;
       const { dictionaries, schema } = this;
       const dictionary = dictionaries.get(id);
-      if (isDelta || !dictionary) {
-        const type = schema.dictionaries.get(id);
-        const data = this._loadVectors(header.data, body, [type]);
-        return (dictionary && isDelta ? dictionary.concat(new Vector(data)) : new Vector(data)).memoize();
-      }
-      return dictionary.memoize();
+      const type = schema.dictionaries.get(id);
+      const data = this._loadVectors(header.data, body, [type]);
+      return (dictionary && isDelta ? dictionary.concat(new Vector(data)) : new Vector(data)).memoize();
     }
     _loadVectors(header, body, types) {
       return new VectorLoader(body, header.nodes, header.buffers, this.dictionaries, this.schema.metadataVersion).visitMany(types);
@@ -11077,8 +11122,8 @@ return true;`);
       });
     }
     readRecordBatch(index) {
-      var _a5;
       return __awaiter(this, void 0, void 0, function* () {
+        var _a5;
         if (this.closed) {
           return null;
         }
@@ -11099,8 +11144,8 @@ return true;`);
       });
     }
     _readDictionaryBatch(index) {
-      var _a5;
       return __awaiter(this, void 0, void 0, function* () {
+        var _a5;
         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);
@@ -11375,6 +11420,7 @@ return true;`);
       this._schema = null;
       this._dictionaryBlocks = [];
       this._recordBatchBlocks = [];
+      this._seenDictionaries = /* @__PURE__ */ new Map();
       this._dictionaryDeltaOffsets = /* @__PURE__ */ new Map();
       isObject(options) || (options = { autoDestroy: true, writeLegacyIpcFormat: false });
       this._autoDestroy = typeof options.autoDestroy === "boolean" ? options.autoDestroy : true;
@@ -11433,6 +11479,7 @@ return true;`);
       this._started = false;
       this._dictionaryBlocks = [];
       this._recordBatchBlocks = [];
+      this._seenDictionaries = /* @__PURE__ */ new Map();
       this._dictionaryDeltaOffsets = /* @__PURE__ */ new Map();
       if (!schema || !compareSchemas(schema, this._schema)) {
         if (schema == null) {
@@ -11524,7 +11571,6 @@ return true;`);
       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);
@@ -11545,14 +11591,20 @@ return true;`);
       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;
-          }
-        }
+      var _a5, _b2;
+      for (const [id, dictionary] of batch.dictionaries) {
+        const chunks = (_a5 = dictionary === null || dictionary === void 0 ? void 0 : dictionary.data) !== null && _a5 !== void 0 ? _a5 : [];
+        const prevDictionary = this._seenDictionaries.get(id);
+        const offset = (_b2 = this._dictionaryDeltaOffsets.get(id)) !== null && _b2 !== void 0 ? _b2 : 0;
+        if (!prevDictionary || prevDictionary.data[0] !== chunks[0]) {
+          for (const [index, chunk] of chunks.entries())
+            this._writeDictionaryBatch(chunk, id, index > 0);
+        } else if (offset < chunks.length) {
+          for (const chunk of chunks.slice(offset))
+            this._writeDictionaryBatch(chunk, id, true);
+        }
+        this._seenDictionaries.set(id, dictionary);
+        this._dictionaryDeltaOffsets.set(id, chunks.length);
       }
       return this;
     }
@@ -11588,6 +11640,12 @@ return true;`);
     _writeSchema(schema) {
       return this._writeMagic()._writePadding(2);
     }
+    _writeDictionaryBatch(dictionary, id, isDelta = false) {
+      if (!isDelta && this._seenDictionaries.has(id)) {
+        throw new Error("The Arrow File format does not support replacement dictionaries. ");
+      }
+      return super._writeDictionaryBatch(dictionary, id, isDelta);
+    }
     _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();
@@ -11605,9 +11663,9 @@ return true;`);
     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* () {
+      var _a5, batches_1, batches_1_1;
+      var _b2, e_1, _c2, _d2;
       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;
@@ -11902,7 +11960,7 @@ return true;`);
   RecordBatchFileWriter["throughDOM"] = recordBatchWriterThroughDOMStream;
   RecordBatchStreamWriter["throughDOM"] = recordBatchWriterThroughDOMStream;
 
-  // ../schema/src/lib/table/simple-table/data-type.ts
+  // ../schema-utils/src/lib/schema/data-type.ts
   function getDataTypeFromValue(value, defaultNumberType = "float32") {
     if (value instanceof Date) {
       return "date-millisecond";
@@ -11978,459 +12036,30 @@ return true;`);
     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 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");
-    }
+  // ../schema-utils/src/lib/schema/convert-arrow-schema.ts
+  function convertArrowToSchema(arrowSchema) {
+    return serializeArrowSchema(arrowSchema);
   }
-  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 convertSchemaToArrow(schema) {
+    return deserializeArrowSchema(schema);
   }
-  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 serializeArrowSchema(arrowSchema) {
+    return {
+      fields: arrowSchema.fields.map((arrowField) => serializeArrowField(arrowField)),
+      metadata: serializeArrowMetadata(arrowSchema.metadata)
+    };
   }
-  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];
-        }
-        return arrayRow;
-      default:
-        throw new Error("shape");
-    }
+  function deserializeArrowSchema(schema) {
+    return new Schema2(
+      schema.fields.map((field) => deserializeArrowField(field)),
+      deserializeArrowMetadata(schema.metadata)
+    );
   }
-
-  // ../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 serializeArrowMetadata(arrowMetadata) {
+    return Object.fromEntries(arrowMetadata);
   }
-  function deduceSchemaFromColumns(columnarTable) {
-    const fields = [];
-    for (const [columnName, column] of Object.entries(columnarTable)) {
-      const field = deduceFieldFromColumn(column, columnName);
-      fields.push(field);
-    }
-    return { fields, metadata: {} };
-  }
-  function deduceSchemaFromRows(rowTable) {
-    if (!rowTable.length) {
-      throw new Error("deduce from empty table");
-    }
-    const fields = [];
-    const row0 = rowTable[0];
-    for (const [columnName, value] of Object.entries(row0)) {
-      fields.push(deduceFieldFromValue(value, columnName));
-    }
-    return { fields, metadata: {} };
-  }
-  function deduceSchemaFromGeoJSON(features) {
-    if (!features.length) {
-      throw new Error("deduce from empty table");
-    }
-    const fields = [];
-    const row0 = features[0].properties || {};
-    for (const [columnName, value] of Object.entries(row0)) {
-      fields.push(deduceFieldFromValue(value, columnName));
-    }
-    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");
-  }
-  function deduceFieldFromValue(value, name) {
-    const type = getDataTypeFromValue(value);
-    return {
-      name,
-      type,
-      nullable: true
-      // metadata: {}
-    };
-  }
-
-  // ../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);
-      }
-    }
-    return {
-      shape: "columnar-table",
-      schema,
-      data: columns
-    };
-  }
-  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
-    };
-  }
-  function makeObjectRowTable(table) {
-    if (table.shape === "object-row-table") {
-      return table;
-    }
-    const length = getTableLength(table);
-    const data = new Array(length);
-    for (let rowIndex = 0; rowIndex < length; rowIndex++) {
-      data[rowIndex] = getTableRowAsObject(table, rowIndex);
-    }
-    return {
-      shape: "object-row-table",
-      schema: table.schema,
-      data
-    };
-  }
-
-  // ../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;
-  }
-
-  // ../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}`);
-    }
-  }
-  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/lib/tables/convert-arrow-schema.ts
-  function convertArrowToSchema(arrowSchema) {
-    return serializeArrowSchema(arrowSchema);
-  }
-  function serializeArrowSchema(arrowSchema) {
-    return {
-      fields: arrowSchema.fields.map((arrowField) => serializeArrowField(arrowField)),
-      metadata: serializeArrowMetadata(arrowSchema.metadata)
-    };
-  }
-  function serializeArrowMetadata(arrowMetadata) {
-    return Object.fromEntries(arrowMetadata);
+  function deserializeArrowMetadata(metadata) {
+    return metadata ? new Map(Object.entries(metadata)) : /* @__PURE__ */ new Map();
   }
   function serializeArrowField(field) {
     return {
@@ -12440,6 +12069,14 @@ return true;`);
       metadata: serializeArrowMetadata(field.metadata)
     };
   }
+  function deserializeArrowField(field) {
+    return new Field2(
+      field.name,
+      deserializeArrowType(field.type),
+      field.nullable,
+      deserializeArrowMetadata(field.metadata)
+    );
+  }
   function serializeArrowType(arrowType) {
     switch (arrowType.constructor) {
       case Null2:
@@ -12591,771 +12228,414 @@ return true;`);
         throw new Error(`arrow type not supported: ${arrowType.constructor.name}`);
     }
   }
-
-  // ../wkt/src/lib/utils/version.ts
-  var VERSION = true ? "4.3.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;
+  function deserializeArrowType(dataType) {
+    if (typeof dataType === "object") {
+      switch (dataType.type) {
+        case "decimal":
+          return new Decimal2(dataType.precision, dataType.scale, dataType.bitWidth);
+        case "map":
+          let children = dataType.children.map((arrowField) => deserializeArrowField(arrowField));
+          return new Map_(children, dataType.keysSorted);
+        case "list":
+          const field = deserializeArrowField(dataType.children[0]);
+          return new List2(field);
+        case "fixed-size-list":
+          const child = deserializeArrowField(dataType.children[0]);
+          return new FixedSizeList2(dataType.listSize, child);
+        case "struct":
+          children = dataType.children.map((arrowField) => deserializeArrowField(arrowField));
+          return new Struct(children);
+        default:
+          throw new Error("array type not supported");
+      }
     }
-    white(state);
-    if (!$(/^(\()/, state)) {
-      return null;
+    switch (dataType) {
+      case "null":
+        return new Null2();
+      case "binary":
+        return new Binary2();
+      case "bool":
+        return new Bool2();
+      case "int8":
+        return new Int8();
+      case "int16":
+        return new Int16();
+      case "int32":
+        return new Int32();
+      case "int64":
+        return new Int64();
+      case "uint8":
+        return new Uint8();
+      case "uint16":
+        return new Uint16();
+      case "uint32":
+        return new Uint32();
+      case "uint64":
+        return new Uint64();
+      case "float16":
+        return new Float16();
+      case "float32":
+        return new Float32();
+      case "float64":
+        return new Float64();
+      case "utf8":
+        return new Utf82();
+      case "date-day":
+        return new DateDay();
+      case "date-millisecond":
+        return new DateMillisecond();
+      case "time-second":
+        return new TimeSecond();
+      case "time-millisecond":
+        return new TimeMillisecond();
+      case "time-microsecond":
+        return new TimeMicrosecond();
+      case "time-nanosecond":
+        return new TimeNanosecond();
+      case "timestamp-second":
+        return new TimestampSecond();
+      case "timestamp-millisecond":
+        return new TimestampMillisecond();
+      case "timestamp-microsecond":
+        return new TimestampMicrosecond();
+      case "timestamp-nanosecond":
+        return new TimestampNanosecond();
+      case "interval-daytime":
+        return new IntervalDayTime();
+      case "interval-yearmonth":
+        return new IntervalYearMonth();
+      default:
+        throw new Error("array type not supported");
     }
-    const c = coords(state);
-    if (!c) {
-      return null;
+  }
+
+  // ../schema-utils/src/lib/schema/deduce-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");
     }
-    white(state);
-    if (!$(/^(\))/, state)) {
-      return null;
+  }
+  function deduceSchemaFromColumns(columnarTable) {
+    const fields = [];
+    for (const [columnName, column] of Object.entries(columnarTable)) {
+      const field = deduceFieldFromColumn(column, columnName);
+      fields.push(field);
     }
-    return {
-      type: "Point",
-      coordinates: c[0]
-    };
+    return { fields, metadata: {} };
   }
-  function parseMultiPoint(state) {
-    if (!$(/^(MULTIPOINT)/i, state)) {
-      return null;
+  function deduceSchemaFromRows(rowTable) {
+    if (!rowTable.length) {
+      throw new Error("deduce from empty table");
     }
-    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;
+    const fields = [];
+    const row0 = rowTable[0];
+    for (const [columnName, value] of Object.entries(row0)) {
+      fields.push(deduceFieldFromValue(value, columnName));
     }
-    white(state);
-    return {
-      type: "MultiPoint",
-      coordinates: c
-    };
+    return { fields, metadata: {} };
   }
-  function parseLineString(state) {
-    if (!$(/^(LINESTRING(\sz)?)/i, state)) {
-      return null;
+  function deduceSchemaFromGeoJSON(features) {
+    if (!features.length) {
+      throw new Error("deduce from empty table");
     }
-    white(state);
-    if (!$(/^(\()/, state)) {
-      return null;
+    const fields = [];
+    const row0 = features[0].properties || {};
+    for (const [columnName, value] of Object.entries(row0)) {
+      fields.push(deduceFieldFromValue(value, columnName));
     }
-    const c = coords(state);
-    if (!c) {
-      return null;
+    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 (!$(/^(\))/, state)) {
-      return null;
+    if (Array.isArray(column) && column.length > 0) {
+      const value = column[0];
+      const type = getDataTypeFromValue(value);
+      return {
+        name,
+        type,
+        nullable: true
+        // metadata: {},
+      };
     }
-    return {
-      type: "LineString",
-      coordinates: c
-    };
+    throw new Error("empty table");
   }
-  function parseMultiLineString(state) {
-    if (!$(/^(MULTILINESTRING)/i, state))
-      return null;
-    white(state);
-    const c = multicoords(state);
-    if (!c) {
-      return null;
-    }
-    white(state);
+  function deduceFieldFromValue(value, name) {
+    const type = getDataTypeFromValue(value);
     return {
-      // @ts-ignore
-      type: "MultiLineString",
-      // @ts-expect-error
-      coordinates: c
+      name,
+      type,
+      nullable: true
+      // metadata: {}
     };
   }
-  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;
+  // ../schema-utils/src/lib/table/tables/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");
     }
-    const littleEndian = endianness === 1;
-    const geometry = dataView.getUint32(byteOffset, littleEndian);
-    byteOffset += 4;
-    const geometryType = geometry & 7;
-    if (geometryType === 0 || geometryType > 7) {
-      return false;
+  }
+  function getTableNumCols(table) {
+    if (table.schema) {
+      return table.schema.fields.length;
     }
-    const geometryFlags = geometry - geometryType;
-    if (geometryFlags === 0 || geometryFlags === 1e3 || geometryFlags === 2e3 || geometryFlags === 3e3) {
-      return true;
+    if (getTableLength(table) === 0) {
+      throw new Error("empty table");
     }
-    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;
-      }
+    switch (table.shape) {
+      case "array-row-table":
+        return table.data[0].length;
+      case "object-row-table":
+        return Object.keys(table.data[0]).length;
+      case "geojson-table":
+        return Object.keys(table.features[0]).length;
+      case "columnar-table":
+        return Object.keys(table.data).length;
+      case "arrow-table":
+        const arrowTable = table.data;
+        return arrowTable.numCols;
+      default:
+        throw new Error("table");
     }
-    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);
+  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(shape);
+        throw new Error("todo");
     }
   }
-  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;
+  function getTableCellAt(table, rowIndex, columnIndex) {
+    switch (table.shape) {
+      case "array-row-table":
+        return table.data[rowIndex][columnIndex];
+      case "object-row-table":
+        const columnName1 = getTableColumnName(table, columnIndex);
+        return table.data[rowIndex][columnName1];
+      case "geojson-table":
+        const columnName2 = getTableColumnName(table, columnIndex);
+        return table.features[rowIndex][columnName2];
+      case "columnar-table":
+        const columnName3 = getTableColumnName(table, columnIndex);
+        const column = table.data[columnName3];
+        return column[rowIndex];
+      case "arrow-table":
+        const arrowTable = table.data;
+        return arrowTable.getChildAt(columnIndex)?.get(rowIndex);
       default:
-        throw new Error(`WKB: Unsupported geometry type: ${geometryType}`);
+        throw new Error("todo");
     }
   }
-  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;
+  function getTableColumnIndex(table, columnName) {
+    const columnIndex = table.schema?.fields.findIndex((field) => field.name === columnName);
+    if (columnIndex === void 0) {
+      throw new Error(columnName);
     }
-    return {
-      geometry: { type: "Point", positions: { value: positions, size: dimension } },
-      offset
-    };
+    return columnIndex;
   }
-  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);
+  function getTableColumnName(table, columnIndex) {
+    const columnName = table.schema?.fields[columnIndex]?.name;
+    if (!columnName) {
+      throw new Error(`${columnIndex}`);
     }
-    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
-    };
+    return columnName;
   }
-  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])
-      );
+  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");
     }
-    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];
-      }
+  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];
+        }
+        return arrayRow;
+      default:
+        throw new Error("shape");
     }
-    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
-    };
+  // ../schema-utils/src/lib/table/tables/table-column.ts
+  function makeColumnFromField(field, length) {
+    const ArrayType = getArrayTypeFromDataType(field.type, field.nullable);
+    return new ArrayType(length);
   }
-  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);
+
+  // ../schema-utils/src/lib/table/batches/make-arrow-batch-iterator.ts
+  function* makeArrowRecordBatchIterator(table, options) {
+    const arrowSchema = convertSchemaToArrow(table.schema);
+    const length = getTableLength(table);
+    const numColumns = getTableNumCols(table);
+    const batchSize = options?.batchSize || length;
+    const builders = arrowSchema?.fields.map((arrowField) => makeBuilder(arrowField));
+    const structField = new Struct(arrowSchema.fields);
+    let batchLength = 0;
+    for (let rowIndex = 0; rowIndex < length; rowIndex++) {
+      for (let columnIndex = 0; columnIndex < numColumns; ++columnIndex) {
+        const value = getTableCellAt(table, rowIndex, columnIndex);
+        const builder = builders[columnIndex];
+        builder.append(value);
+        batchLength++;
+        if (batchLength >= batchSize) {
+          const datas = builders.map((builder2) => builder2.flush());
+          const structData = new Data(structField, 0, batchLength, 0, void 0, datas);
+          yield new RecordBatch2(arrowSchema, structData);
+          batchLength = 0;
         }
       }
-      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);
-      }
+    if (batchLength > 0) {
+      const datas = builders.map((builder) => builder.flush());
+      const structData = new Data(structField, 0, batchLength, 0, void 0, datas);
+      yield new RecordBatch2(arrowSchema, structData);
+      batchLength = 0;
     }
-    return {
-      type: "LineString",
-      coordinates: lineString
-    };
+    builders.map((builder) => builder.finish());
   }
 
-  // src/lib/tables/convert-arrow-to-table.ts
+  // ../schema-utils/src/lib/table/tables/convert-arrow-table.ts
+  function convertTableToArrow(table, options) {
+    switch (table.shape) {
+      case "arrow-table":
+        return table.data;
+      case "columnar-table":
+      default:
+        const arrowBatchIterator = makeArrowRecordBatchIterator(table, options);
+        return new Table(arrowBatchIterator);
+    }
+  }
   function convertArrowToTable(arrowTable, shape) {
     switch (shape) {
       case "arrow-table":
@@ -13403,19 +12683,10 @@ return true;`);
   }
   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 });
-      }
+      const properties = arrowTable.get(row)?.toJSON() || {};
+      features.push({ type: "Feature", geometry: null, properties });
     }
     return {
       shape: "geojson-table",
@@ -13425,6 +12696,81 @@ return true;`);
     };
   }
 
+  // ../schema-utils/src/lib/table/tables/convert-table.ts
+  function convertTable(table, shape) {
+    switch (shape) {
+      case "object-row-table":
+        return convertToObjectRowTable(table);
+      case "array-row-table":
+        return convertToArrayRowTable(table);
+      case "columnar-table":
+        return convertToColumnarTable(table);
+      case "arrow-table":
+        return convertToArrowTable(table);
+      default:
+        throw new Error(shape);
+    }
+  }
+  function convertToColumnarTable(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);
+      }
+    }
+    return {
+      shape: "columnar-table",
+      schema,
+      data: columns
+    };
+  }
+  function convertToArrayRowTable(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
+    };
+  }
+  function convertToObjectRowTable(table) {
+    if (table.shape === "object-row-table") {
+      return table;
+    }
+    const length = getTableLength(table);
+    const data = new Array(length);
+    for (let rowIndex = 0; rowIndex < length; rowIndex++) {
+      data[rowIndex] = getTableRowAsObject(table, rowIndex);
+    }
+    return {
+      shape: "object-row-table",
+      schema: table.schema,
+      data
+    };
+  }
+  function convertToArrowTable(table) {
+    const arrowTable = convertTableToArrow(table);
+    return {
+      shape: "arrow-table",
+      schema: table.schema,
+      data: arrowTable
+    };
+  }
+
   // src/lib/parsers/parse-arrow.ts
   function parseArrowSync(arrayBuffer, options) {
     const shape = options?.shape || "arrow-table";
@@ -13454,14 +12800,14 @@ return true;`);
   }
 
   // src/exports/arrow-loader.ts
-  var VERSION2 = true ? "4.3.1" : "latest";
+  var VERSION = true ? "4.4.0-alpha.0" : "latest";
   var ArrowWorkerLoader = {
     dataType: null,
     batchType: null,
     name: "Apache Arrow",
     id: "arrow",
     module: "arrow",
-    version: VERSION2,
+    version: VERSION,
     // worker: true,
     category: "table",
     extensions: ["arrow", "feather"],