@nika-js/onlymap 0.1.0

package/dist/recordbatch-HRu0SMKp.js

@@ -0,0 +1,4742 @@
+function Zo(e, t) {
+  var n = {};
+  for (var i in e) Object.prototype.hasOwnProperty.call(e, i) && t.indexOf(i) < 0 && (n[i] = e[i]);
+  if (e != null && typeof Object.getOwnPropertySymbols == "function")
+    for (var r = 0, i = Object.getOwnPropertySymbols(e); r < i.length; r++)
+      t.indexOf(i[r]) < 0 && Object.prototype.propertyIsEnumerable.call(e, i[r]) && (n[i[r]] = e[i[r]]);
+  return n;
+}
+function ta(e, t, n, i) {
+  function r(s) {
+    return s instanceof n ? s : new n(function(o) {
+      o(s);
+    });
+  }
+  return new (n || (n = Promise))(function(s, o) {
+    function a(d) {
+      try {
+        u(i.next(d));
+      } catch (h) {
+        o(h);
+      }
+    }
+    function c(d) {
+      try {
+        u(i.throw(d));
+      } catch (h) {
+        o(h);
+      }
+    }
+    function u(d) {
+      d.done ? s(d.value) : r(d.value).then(a, c);
+    }
+    u((i = i.apply(e, t || [])).next());
+  });
+}
+function cn(e) {
+  var t = typeof Symbol == "function" && Symbol.iterator, n = t && e[t], i = 0;
+  if (n) return n.call(e);
+  if (e && typeof e.length == "number") return {
+    next: function() {
+      return e && i >= e.length && (e = void 0), { value: e && e[i++], done: !e };
+    }
+  };
+  throw new TypeError(t ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+function L(e) {
+  return this instanceof L ? (this.v = e, this) : new L(e);
+}
+function Nt(e, t, n) {
+  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+  var i = n.apply(e, t || []), r, s = [];
+  return r = Object.create((typeof AsyncIterator == "function" ? AsyncIterator : Object).prototype), a("next"), a("throw"), a("return", o), r[Symbol.asyncIterator] = function() {
+    return this;
+  }, r;
+  function o(B) {
+    return function(E) {
+      return Promise.resolve(E).then(B, h);
+    };
+  }
+  function a(B, E) {
+    i[B] && (r[B] = function(Mt) {
+      return new Promise(function(Or, Mr) {
+        s.push([B, Mt, Or, Mr]) > 1 || c(B, Mt);
+      });
+    }, E && (r[B] = E(r[B])));
+  }
+  function c(B, E) {
+    try {
+      u(i[B](E));
+    } catch (Mt) {
+      U(s[0][3], Mt);
+    }
+  }
+  function u(B) {
+    B.value instanceof L ? Promise.resolve(B.value.v).then(d, h) : U(s[0][2], B);
+  }
+  function d(B) {
+    c("next", B);
+  }
+  function h(B) {
+    c("throw", B);
+  }
+  function U(B, E) {
+    B(E), s.shift(), s.length && c(s[0][0], s[0][1]);
+  }
+}
+function ye(e) {
+  var t, n;
+  return t = {}, i("next"), i("throw", function(r) {
+    throw r;
+  }), i("return"), t[Symbol.iterator] = function() {
+    return this;
+  }, t;
+  function i(r, s) {
+    t[r] = e[r] ? function(o) {
+      return (n = !n) ? { value: L(e[r](o)), done: !1 } : s ? s(o) : o;
+    } : s;
+  }
+}
+function Wt(e) {
+  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+  var t = e[Symbol.asyncIterator], n;
+  return t ? t.call(e) : (e = typeof cn == "function" ? cn(e) : e[Symbol.iterator](), n = {}, i("next"), i("throw"), i("return"), n[Symbol.asyncIterator] = function() {
+    return this;
+  }, n);
+  function i(s) {
+    n[s] = e[s] && function(o) {
+      return new Promise(function(a, c) {
+        o = e[s](o), r(a, c, o.done, o.value);
+      });
+    };
+  }
+  function r(s, o, a, c) {
+    Promise.resolve(c).then(function(u) {
+      s({ value: u, done: a });
+    }, o);
+  }
+}
+const un = new TextDecoder("utf-8"), Nr = un.decode.bind(un), Ur = new TextEncoder(), ne = (e) => Ur.encode(e), Cr = (e) => typeof e == "number", An = (e) => typeof e == "boolean", F = (e) => typeof e == "function", H = (e) => e != null && Object(e) === e, Fr = (e) => H(e) && F(e.then), Dn = (e) => H(e) && F(e[Symbol.iterator]), Lr = (e) => H(e) && F(e[Symbol.asyncIterator]), ea = (e) => H(e) && H(e.schema), Er = (e) => H(e) && "done" in e && "value" in e, na = (e) => H(e) && F(e.stat) && Cr(e.fd), ia = (e) => H(e) && Vr(e.body), ie = (e) => "_getDOMStream" in e && "_getNodeStream" in e, ra = (e) => H(e) && F(e.abort) && F(e.getWriter) && !ie(e), Vr = (e) => H(e) && F(e.cancel) && F(e.getReader) && !ie(e), sa = (e) => H(e) && F(e.end) && F(e.write) && An(e.writable) && !ie(e), oa = (e) => H(e) && F(e.read) && F(e.pipe) && An(e.readable) && !ie(e), xr = (e) => H(e) && F(e.clear) && F(e.bytes) && F(e.position) && F(e.setPosition) && F(e.capacity) && F(e.getBufferIdentifier) && F(e.createLong), Te = typeof SharedArrayBuffer < "u" ? SharedArrayBuffer : ArrayBuffer;
+function kr(e) {
+  const t = e[0] ? [e[0]] : [];
+  let n, i, r, s;
+  for (let o, a, c = 0, u = 0, d = e.length; ++c < d; ) {
+    if (o = t[u], a = e[c], !o || !a || o.buffer !== a.buffer || a.byteOffset < o.byteOffset) {
+      a && (t[++u] = a);
+      continue;
+    }
+    if ({ byteOffset: n, byteLength: r } = o, { byteOffset: i, byteLength: s } = a, n + r < i || i + s < n) {
+      a && (t[++u] = a);
+      continue;
+    }
+    t[u] = new Uint8Array(o.buffer, n, i - n + s);
+  }
+  return t;
+}
+function Gt(e, t, n = 0, i = t.byteLength) {
+  const r = e.byteLength, s = new Uint8Array(e.buffer, e.byteOffset, r), o = new Uint8Array(t.buffer, t.byteOffset, Math.min(i, r));
+  return s.set(o, n), e;
+}
+function jr(e, t) {
+  const n = kr(e), i = n.reduce((d, h) => d + h.byteLength, 0);
+  let r, s, o, a = 0, c = -1;
+  const u = Math.min(t || Number.POSITIVE_INFINITY, i);
+  for (const d = n.length; ++c < d; ) {
+    if (r = n[c], s = r.subarray(0, Math.min(r.length, u - a)), u <= a + s.length) {
+      s.length < r.length ? n[c] = r.subarray(s.length) : s.length === r.length && c++, o ? Gt(o, s, a) : o = s;
+      break;
+    }
+    Gt(o || (o = new Uint8Array(u)), s, a), a += s.length;
+  }
+  return [o || new Uint8Array(0), n.slice(c), i - (o ? o.byteLength : 0)];
+}
+function O(e, t) {
+  let n = Er(t) ? t.value : t;
+  return n instanceof e ? e === Uint8Array ? new e(n.buffer, n.byteOffset, n.byteLength) : n : n ? (typeof n == "string" && (n = ne(n)), n instanceof ArrayBuffer ? new e(n) : n instanceof Te ? new e(n) : xr(n) ? O(e, n.bytes()) : ArrayBuffer.isView(n) ? n.byteLength <= 0 ? new e(0) : new e(n.buffer, n.byteOffset, n.byteLength / e.BYTES_PER_ELEMENT) : e.from(n)) : new e(0);
+}
+const zr = (e) => O(Int8Array, e), $r = (e) => O(Int16Array, e), pt = (e) => O(Int32Array, e), me = (e) => O(BigInt64Array, e), N = (e) => O(Uint8Array, e), Pr = (e) => O(Uint16Array, e), Rr = (e) => O(Uint32Array, e), Yr = (e) => O(BigUint64Array, e), Wr = (e) => O(Float32Array, e), Hr = (e) => O(Float64Array, e), Kr = (e) => O(Uint8ClampedArray, e), ve = (e) => (e.next(), e);
+function* nt(e, t) {
+  const n = function* (r) {
+    yield r;
+  }, i = typeof t == "string" || ArrayBuffer.isView(t) || t instanceof ArrayBuffer || t instanceof Te ? n(t) : Dn(t) ? t : n(t);
+  return yield* ve((function* (r) {
+    let s = null;
+    do
+      s = r.next(yield O(e, s));
+    while (!s.done);
+  })(i[Symbol.iterator]())), new e();
+}
+const Gr = (e) => nt(Int8Array, e), Jr = (e) => nt(Int16Array, e), qr = (e) => nt(Int32Array, e), Qr = (e) => nt(Uint8Array, e), Xr = (e) => nt(Uint16Array, e), Zr = (e) => nt(Uint32Array, e), ts = (e) => nt(Float32Array, e), es = (e) => nt(Float64Array, e), ns = (e) => nt(Uint8ClampedArray, e);
+function q(e, t) {
+  return Nt(this, arguments, function* () {
+    if (Fr(t))
+      return yield L(yield L(yield* ye(Wt(q(e, yield L(t))))));
+    const i = function(o) {
+      return Nt(this, arguments, function* () {
+        yield yield L(yield L(o));
+      });
+    }, r = function(o) {
+      return Nt(this, arguments, function* () {
+        yield L(yield* ye(Wt(ve((function* (a) {
+          let c = null;
+          do
+            c = a.next(yield c == null ? void 0 : c.value);
+          while (!c.done);
+        })(o[Symbol.iterator]())))));
+      });
+    }, s = typeof t == "string" || ArrayBuffer.isView(t) || t instanceof ArrayBuffer || t instanceof Te ? i(t) : Dn(t) ? r(t) : Lr(t) ? t : i(t);
+    return yield L(
+      // otherwise if AsyncIterable, use it
+      yield* ye(Wt(ve((function(o) {
+        return Nt(this, arguments, function* () {
+          let a = null;
+          do
+            a = yield L(o.next(yield yield L(O(e, a))));
+          while (!a.done);
+        });
+      })(s[Symbol.asyncIterator]()))))
+    ), yield L(new e());
+  });
+}
+const is = (e) => q(Int8Array, e), rs = (e) => q(Int16Array, e), ss = (e) => q(Int32Array, e), os = (e) => q(Uint8Array, e), as = (e) => q(Uint16Array, e), ls = (e) => q(Uint32Array, e), cs = (e) => q(Float32Array, e), us = (e) => q(Float64Array, e), ds = (e) => q(Uint8ClampedArray, e);
+function hs(e, t, n) {
+  if (e !== 0) {
+    n = n.slice(0, t);
+    for (let i = -1, r = n.length; ++i < r; )
+      n[i] += e;
+  }
+  return n.subarray(0, t);
+}
+function _n(e, t) {
+  let n = 0;
+  const i = e.length;
+  if (i !== t.length)
+    return !1;
+  if (i > 0)
+    do
+      if (e[n] !== t[n])
+        return !1;
+    while (++n < i);
+  return !0;
+}
+const aa = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  compareArrayLike: _n,
+  joinUint8Arrays: jr,
+  memcpy: Gt,
+  rebaseValueOffsets: hs,
+  toArrayBufferView: O,
+  toArrayBufferViewAsyncIterator: q,
+  toArrayBufferViewIterator: nt,
+  toBigInt64Array: me,
+  toBigUint64Array: Yr,
+  toFloat32Array: Wr,
+  toFloat32ArrayAsyncIterator: cs,
+  toFloat32ArrayIterator: ts,
+  toFloat64Array: Hr,
+  toFloat64ArrayAsyncIterator: us,
+  toFloat64ArrayIterator: es,
+  toInt16Array: $r,
+  toInt16ArrayAsyncIterator: rs,
+  toInt16ArrayIterator: Jr,
+  toInt32Array: pt,
+  toInt32ArrayAsyncIterator: ss,
+  toInt32ArrayIterator: qr,
+  toInt8Array: zr,
+  toInt8ArrayAsyncIterator: is,
+  toInt8ArrayIterator: Gr,
+  toUint16Array: Pr,
+  toUint16ArrayAsyncIterator: as,
+  toUint16ArrayIterator: Xr,
+  toUint32Array: Rr,
+  toUint32ArrayAsyncIterator: ls,
+  toUint32ArrayIterator: Zr,
+  toUint8Array: N,
+  toUint8ArrayAsyncIterator: os,
+  toUint8ArrayIterator: Qr,
+  toUint8ClampedArray: Kr,
+  toUint8ClampedArrayAsyncIterator: ds,
+  toUint8ClampedArrayIterator: ns
+}, Symbol.toStringTag, { value: "Module" }));
+var be;
+(function(e) {
+  e[e.V1 = 0] = "V1", e[e.V2 = 1] = "V2", e[e.V3 = 2] = "V3", e[e.V4 = 3] = "V4", e[e.V5 = 4] = "V5";
+})(be || (be = {}));
+var K;
+(function(e) {
+  e[e.Sparse = 0] = "Sparse", e[e.Dense = 1] = "Dense";
+})(K || (K = {}));
+var x;
+(function(e) {
+  e[e.HALF = 0] = "HALF", e[e.SINGLE = 1] = "SINGLE", e[e.DOUBLE = 2] = "DOUBLE";
+})(x || (x = {}));
+var Z;
+(function(e) {
+  e[e.DAY = 0] = "DAY", e[e.MILLISECOND = 1] = "MILLISECOND";
+})(Z || (Z = {}));
+var y;
+(function(e) {
+  e[e.SECOND = 0] = "SECOND", e[e.MILLISECOND = 1] = "MILLISECOND", e[e.MICROSECOND = 2] = "MICROSECOND", e[e.NANOSECOND = 3] = "NANOSECOND";
+})(y || (y = {}));
+var j;
+(function(e) {
+  e[e.YEAR_MONTH = 0] = "YEAR_MONTH", e[e.DAY_TIME = 1] = "DAY_TIME", e[e.MONTH_DAY_NANO = 2] = "MONTH_DAY_NANO";
+})(j || (j = {}));
+var l;
+(function(e) {
+  e[e.NONE = 0] = "NONE", e[e.Null = 1] = "Null", e[e.Int = 2] = "Int", e[e.Float = 3] = "Float", e[e.Binary = 4] = "Binary", e[e.Utf8 = 5] = "Utf8", e[e.Bool = 6] = "Bool", e[e.Decimal = 7] = "Decimal", e[e.Date = 8] = "Date", e[e.Time = 9] = "Time", e[e.Timestamp = 10] = "Timestamp", e[e.Interval = 11] = "Interval", e[e.List = 12] = "List", e[e.Struct = 13] = "Struct", e[e.Union = 14] = "Union", e[e.FixedSizeBinary = 15] = "FixedSizeBinary", e[e.FixedSizeList = 16] = "FixedSizeList", e[e.Map = 17] = "Map", e[e.Duration = 18] = "Duration", e[e.LargeBinary = 19] = "LargeBinary", e[e.LargeUtf8 = 20] = "LargeUtf8", e[e.Dictionary = -1] = "Dictionary", e[e.Int8 = -2] = "Int8", e[e.Int16 = -3] = "Int16", e[e.Int32 = -4] = "Int32", e[e.Int64 = -5] = "Int64", e[e.Uint8 = -6] = "Uint8", e[e.Uint16 = -7] = "Uint16", e[e.Uint32 = -8] = "Uint32", e[e.Uint64 = -9] = "Uint64", e[e.Float16 = -10] = "Float16", e[e.Float32 = -11] = "Float32", e[e.Float64 = -12] = "Float64", e[e.DateDay = -13] = "DateDay", e[e.DateMillisecond = -14] = "DateMillisecond", e[e.TimestampSecond = -15] = "TimestampSecond", e[e.TimestampMillisecond = -16] = "TimestampMillisecond", e[e.TimestampMicrosecond = -17] = "TimestampMicrosecond", e[e.TimestampNanosecond = -18] = "TimestampNanosecond", e[e.TimeSecond = -19] = "TimeSecond", e[e.TimeMillisecond = -20] = "TimeMillisecond", e[e.TimeMicrosecond = -21] = "TimeMicrosecond", e[e.TimeNanosecond = -22] = "TimeNanosecond", e[e.DenseUnion = -23] = "DenseUnion", e[e.SparseUnion = -24] = "SparseUnion", e[e.IntervalDayTime = -25] = "IntervalDayTime", e[e.IntervalYearMonth = -26] = "IntervalYearMonth", e[e.DurationSecond = -27] = "DurationSecond", e[e.DurationMillisecond = -28] = "DurationMillisecond", e[e.DurationMicrosecond = -29] = "DurationMicrosecond", e[e.DurationNanosecond = -30] = "DurationNanosecond", e[e.IntervalMonthDayNano = -31] = "IntervalMonthDayNano";
+})(l || (l = {}));
+var it;
+(function(e) {
+  e[e.OFFSET = 0] = "OFFSET", e[e.DATA = 1] = "DATA", e[e.VALIDITY = 2] = "VALIDITY", e[e.TYPE = 3] = "TYPE";
+})(it || (it = {}));
+const ys = void 0;
+function lt(e) {
+  if (e === null)
+    return "null";
+  if (e === ys)
+    return "undefined";
+  switch (typeof e) {
+    case "number":
+      return `${e}`;
+    case "bigint":
+      return `${e}`;
+    case "string":
+      return `"${e}"`;
+  }
+  return typeof e[Symbol.toPrimitive] == "function" ? e[Symbol.toPrimitive]("string") : ArrayBuffer.isView(e) ? e instanceof BigInt64Array || e instanceof BigUint64Array ? `[${[...e].map((t) => lt(t))}]` : `[${e}]` : ArrayBuffer.isView(e) ? `[${e}]` : JSON.stringify(e, (t, n) => typeof n == "bigint" ? `${n}` : n);
+}
+const la = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  valueToString: lt
+}, Symbol.toStringTag, { value: "Module" }));
+function W(e) {
+  if (typeof e == "bigint" && (e < Number.MIN_SAFE_INTEGER || e > Number.MAX_SAFE_INTEGER))
+    throw new TypeError(`${e} is not safe to convert to a number.`);
+  return Number(e);
+}
+function Bn(e, t) {
+  return W(e / t) + W(e % t) / W(t);
+}
+const Tn = Symbol.for("isArrowBigNum");
+function Q(e, ...t) {
+  return t.length === 0 ? Object.setPrototypeOf(O(this.TypedArray, e), this.constructor.prototype) : Object.setPrototypeOf(new this.TypedArray(e, ...t), this.constructor.prototype);
+}
+Q.prototype[Tn] = !0;
+Q.prototype.toJSON = function() {
+  return `"${St(this)}"`;
+};
+Q.prototype.valueOf = function(e) {
+  return Oe(this, e);
+};
+Q.prototype.toString = function() {
+  return St(this);
+};
+Q.prototype[Symbol.toPrimitive] = function(e = "default") {
+  switch (e) {
+    case "number":
+      return Oe(this);
+    case "string":
+      return St(this);
+    case "default":
+      return On(this);
+  }
+  return St(this);
+};
+function mt(...e) {
+  return Q.apply(this, e);
+}
+function vt(...e) {
+  return Q.apply(this, e);
+}
+function Ct(...e) {
+  return Q.apply(this, e);
+}
+Object.setPrototypeOf(mt.prototype, Object.create(Int32Array.prototype));
+Object.setPrototypeOf(vt.prototype, Object.create(Uint32Array.prototype));
+Object.setPrototypeOf(Ct.prototype, Object.create(Uint32Array.prototype));
+Object.assign(mt.prototype, Q.prototype, { constructor: mt, signed: !0, TypedArray: Int32Array, BigIntArray: BigInt64Array });
+Object.assign(vt.prototype, Q.prototype, { constructor: vt, signed: !1, TypedArray: Uint32Array, BigIntArray: BigUint64Array });
+Object.assign(Ct.prototype, Q.prototype, { constructor: Ct, signed: !0, TypedArray: Uint32Array, BigIntArray: BigUint64Array });
+const ps = BigInt(4294967296) * BigInt(4294967296), fs = ps - BigInt(1);
+function Oe(e, t) {
+  const { buffer: n, byteOffset: i, byteLength: r, signed: s } = e, o = new BigUint64Array(n, i, r / 8), a = s && o.at(-1) & BigInt(1) << BigInt(63);
+  let c = BigInt(0), u = 0;
+  if (a) {
+    for (const d of o)
+      c |= (d ^ fs) * (BigInt(1) << BigInt(64 * u++));
+    c *= BigInt(-1), c -= BigInt(1);
+  } else
+    for (const d of o)
+      c |= d * (BigInt(1) << BigInt(64 * u++));
+  if (typeof t == "number" && t > 0) {
+    const d = BigInt("1".padEnd(t + 1, "0")), h = c / d, U = a ? -(c % d) : c % d, B = W(h), E = `${U}`.padStart(t, "0");
+    return +`${a && B === 0 ? "-" : ""}${B}.${E}`;
+  }
+  return W(c);
+}
+function St(e) {
+  if (e.byteLength === 8)
+    return `${new e.BigIntArray(e.buffer, e.byteOffset, 1)[0]}`;
+  if (!e.signed)
+    return pe(e);
+  let t = new Uint16Array(e.buffer, e.byteOffset, e.byteLength / 2);
+  if (new Int16Array([t.at(-1)])[0] >= 0)
+    return pe(e);
+  t = t.slice();
+  let i = 1;
+  for (let s = 0; s < t.length; s++) {
+    const o = t[s], a = ~o + i;
+    t[s] = a, i &= o === 0 ? 1 : 0;
+  }
+  return `-${pe(t)}`;
+}
+function On(e) {
+  return e.byteLength === 8 ? new e.BigIntArray(e.buffer, e.byteOffset, 1)[0] : St(e);
+}
+function pe(e) {
+  let t = "";
+  const n = new Uint32Array(2);
+  let i = new Uint16Array(e.buffer, e.byteOffset, e.byteLength / 2);
+  const r = new Uint32Array((i = new Uint16Array(i).reverse()).buffer);
+  let s = -1;
+  const o = i.length - 1;
+  do {
+    for (n[0] = i[s = 0]; s < o; )
+      i[s++] = n[1] = n[0] / 10, n[0] = (n[0] - n[1] * 10 << 16) + i[s];
+    i[s] = n[1] = n[0] / 10, n[0] = n[0] - n[1] * 10, t = `${n[0]}${t}`;
+  } while (r[0] || r[1] || r[2] || r[3]);
+  return t ?? "0";
+}
+class re {
+  /** @nocollapse */
+  static new(t, n) {
+    switch (n) {
+      case !0:
+        return new mt(t);
+      case !1:
+        return new vt(t);
+    }
+    switch (t.constructor) {
+      case Int8Array:
+      case Int16Array:
+      case Int32Array:
+      case BigInt64Array:
+        return new mt(t);
+    }
+    return t.byteLength === 16 ? new Ct(t) : new vt(t);
+  }
+  /** @nocollapse */
+  static signed(t) {
+    return new mt(t);
+  }
+  /** @nocollapse */
+  static unsigned(t) {
+    return new vt(t);
+  }
+  /** @nocollapse */
+  static decimal(t) {
+    return new Ct(t);
+  }
+  constructor(t, n) {
+    return re.new(t, n);
+  }
+}
+const ca = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  BN: re,
+  bigNumToBigInt: On,
+  bigNumToNumber: Oe,
+  bigNumToString: St,
+  isArrowBigNumSymbol: Tn
+}, Symbol.toStringTag, { value: "Module" }));
+var Mn, Nn, Un, Cn, Fn, Ln, En, Vn, xn, kn, jn, zn, $n, Pn, Rn, Yn, Wn, Hn, Kn, Gn, Jn, qn;
+class A {
+  /** @nocollapse */
+  static isNull(t) {
+    return (t == null ? void 0 : t.typeId) === l.Null;
+  }
+  /** @nocollapse */
+  static isInt(t) {
+    return (t == null ? void 0 : t.typeId) === l.Int;
+  }
+  /** @nocollapse */
+  static isFloat(t) {
+    return (t == null ? void 0 : t.typeId) === l.Float;
+  }
+  /** @nocollapse */
+  static isBinary(t) {
+    return (t == null ? void 0 : t.typeId) === l.Binary;
+  }
+  /** @nocollapse */
+  static isLargeBinary(t) {
+    return (t == null ? void 0 : t.typeId) === l.LargeBinary;
+  }
+  /** @nocollapse */
+  static isUtf8(t) {
+    return (t == null ? void 0 : t.typeId) === l.Utf8;
+  }
+  /** @nocollapse */
+  static isLargeUtf8(t) {
+    return (t == null ? void 0 : t.typeId) === l.LargeUtf8;
+  }
+  /** @nocollapse */
+  static isBool(t) {
+    return (t == null ? void 0 : t.typeId) === l.Bool;
+  }
+  /** @nocollapse */
+  static isDecimal(t) {
+    return (t == null ? void 0 : t.typeId) === l.Decimal;
+  }
+  /** @nocollapse */
+  static isDate(t) {
+    return (t == null ? void 0 : t.typeId) === l.Date;
+  }
+  /** @nocollapse */
+  static isTime(t) {
+    return (t == null ? void 0 : t.typeId) === l.Time;
+  }
+  /** @nocollapse */
+  static isTimestamp(t) {
+    return (t == null ? void 0 : t.typeId) === l.Timestamp;
+  }
+  /** @nocollapse */
+  static isInterval(t) {
+    return (t == null ? void 0 : t.typeId) === l.Interval;
+  }
+  /** @nocollapse */
+  static isDuration(t) {
+    return (t == null ? void 0 : t.typeId) === l.Duration;
+  }
+  /** @nocollapse */
+  static isList(t) {
+    return (t == null ? void 0 : t.typeId) === l.List;
+  }
+  /** @nocollapse */
+  static isStruct(t) {
+    return (t == null ? void 0 : t.typeId) === l.Struct;
+  }
+  /** @nocollapse */
+  static isUnion(t) {
+    return (t == null ? void 0 : t.typeId) === l.Union;
+  }
+  /** @nocollapse */
+  static isFixedSizeBinary(t) {
+    return (t == null ? void 0 : t.typeId) === l.FixedSizeBinary;
+  }
+  /** @nocollapse */
+  static isFixedSizeList(t) {
+    return (t == null ? void 0 : t.typeId) === l.FixedSizeList;
+  }
+  /** @nocollapse */
+  static isMap(t) {
+    return (t == null ? void 0 : t.typeId) === l.Map;
+  }
+  /** @nocollapse */
+  static isDictionary(t) {
+    return (t == null ? void 0 : t.typeId) === l.Dictionary;
+  }
+  /** @nocollapse */
+  static isDenseUnion(t) {
+    return A.isUnion(t) && t.mode === K.Dense;
+  }
+  /** @nocollapse */
+  static isSparseUnion(t) {
+    return A.isUnion(t) && t.mode === K.Sparse;
+  }
+  constructor(t) {
+    this.typeId = t;
+  }
+}
+Mn = Symbol.toStringTag;
+A[Mn] = ((e) => (e.children = null, e.ArrayType = Array, e.OffsetArrayType = Int32Array, e[Symbol.toStringTag] = "DataType"))(A.prototype);
+class Ft extends A {
+  constructor() {
+    super(l.Null);
+  }
+  toString() {
+    return "Null";
+  }
+}
+Nn = Symbol.toStringTag;
+Ft[Nn] = ((e) => e[Symbol.toStringTag] = "Null")(Ft.prototype);
+class tt extends A {
+  constructor(t, n) {
+    super(l.Int), this.isSigned = t, this.bitWidth = n;
+  }
+  get ArrayType() {
+    switch (this.bitWidth) {
+      case 8:
+        return this.isSigned ? Int8Array : Uint8Array;
+      case 16:
+        return this.isSigned ? Int16Array : Uint16Array;
+      case 32:
+        return this.isSigned ? Int32Array : Uint32Array;
+      case 64:
+        return this.isSigned ? BigInt64Array : BigUint64Array;
+    }
+    throw new Error(`Unrecognized ${this[Symbol.toStringTag]} type`);
+  }
+  toString() {
+    return `${this.isSigned ? "I" : "Ui"}nt${this.bitWidth}`;
+  }
+}
+Un = Symbol.toStringTag;
+tt[Un] = ((e) => (e.isSigned = null, e.bitWidth = null, e[Symbol.toStringTag] = "Int"))(tt.prototype);
+class Qn extends tt {
+  constructor() {
+    super(!0, 8);
+  }
+  get ArrayType() {
+    return Int8Array;
+  }
+}
+class Xn extends tt {
+  constructor() {
+    super(!0, 16);
+  }
+  get ArrayType() {
+    return Int16Array;
+  }
+}
+class Me extends tt {
+  constructor() {
+    super(!0, 32);
+  }
+  get ArrayType() {
+    return Int32Array;
+  }
+}
+class Ne extends tt {
+  constructor() {
+    super(!0, 64);
+  }
+  get ArrayType() {
+    return BigInt64Array;
+  }
+}
+class Zn extends tt {
+  constructor() {
+    super(!1, 8);
+  }
+  get ArrayType() {
+    return Uint8Array;
+  }
+}
+class ti extends tt {
+  constructor() {
+    super(!1, 16);
+  }
+  get ArrayType() {
+    return Uint16Array;
+  }
+}
+class ei extends tt {
+  constructor() {
+    super(!1, 32);
+  }
+  get ArrayType() {
+    return Uint32Array;
+  }
+}
+class ni extends tt {
+  constructor() {
+    super(!1, 64);
+  }
+  get ArrayType() {
+    return BigUint64Array;
+  }
+}
+Object.defineProperty(Qn.prototype, "ArrayType", { value: Int8Array });
+Object.defineProperty(Xn.prototype, "ArrayType", { value: Int16Array });
+Object.defineProperty(Me.prototype, "ArrayType", { value: Int32Array });
+Object.defineProperty(Ne.prototype, "ArrayType", { value: BigInt64Array });
+Object.defineProperty(Zn.prototype, "ArrayType", { value: Uint8Array });
+Object.defineProperty(ti.prototype, "ArrayType", { value: Uint16Array });
+Object.defineProperty(ei.prototype, "ArrayType", { value: Uint32Array });
+Object.defineProperty(ni.prototype, "ArrayType", { value: BigUint64Array });
+class Lt extends A {
+  constructor(t) {
+    super(l.Float), this.precision = t;
+  }
+  get ArrayType() {
+    switch (this.precision) {
+      case x.HALF:
+        return Uint16Array;
+      case x.SINGLE:
+        return Float32Array;
+      case x.DOUBLE:
+        return Float64Array;
+    }
+    throw new Error(`Unrecognized ${this[Symbol.toStringTag]} type`);
+  }
+  toString() {
+    return `Float${this.precision << 5 || 16}`;
+  }
+}
+Cn = Symbol.toStringTag;
+Lt[Cn] = ((e) => (e.precision = null, e[Symbol.toStringTag] = "Float"))(Lt.prototype);
+class gs extends Lt {
+  constructor() {
+    super(x.HALF);
+  }
+}
+class ii extends Lt {
+  constructor() {
+    super(x.SINGLE);
+  }
+}
+class Ue extends Lt {
+  constructor() {
+    super(x.DOUBLE);
+  }
+}
+Object.defineProperty(gs.prototype, "ArrayType", { value: Uint16Array });
+Object.defineProperty(ii.prototype, "ArrayType", { value: Float32Array });
+Object.defineProperty(Ue.prototype, "ArrayType", { value: Float64Array });
+class dn extends A {
+  constructor() {
+    super(l.Binary);
+  }
+  toString() {
+    return "Binary";
+  }
+}
+Fn = Symbol.toStringTag;
+dn[Fn] = ((e) => (e.ArrayType = Uint8Array, e[Symbol.toStringTag] = "Binary"))(dn.prototype);
+class hn extends A {
+  constructor() {
+    super(l.LargeBinary);
+  }
+  toString() {
+    return "LargeBinary";
+  }
+}
+Ln = Symbol.toStringTag;
+hn[Ln] = ((e) => (e.ArrayType = Uint8Array, e.OffsetArrayType = BigInt64Array, e[Symbol.toStringTag] = "LargeBinary"))(hn.prototype);
+class Ie extends A {
+  constructor() {
+    super(l.Utf8);
+  }
+  toString() {
+    return "Utf8";
+  }
+}
+En = Symbol.toStringTag;
+Ie[En] = ((e) => (e.ArrayType = Uint8Array, e[Symbol.toStringTag] = "Utf8"))(Ie.prototype);
+class yn extends A {
+  constructor() {
+    super(l.LargeUtf8);
+  }
+  toString() {
+    return "LargeUtf8";
+  }
+}
+Vn = Symbol.toStringTag;
+yn[Vn] = ((e) => (e.ArrayType = Uint8Array, e.OffsetArrayType = BigInt64Array, e[Symbol.toStringTag] = "LargeUtf8"))(yn.prototype);
+class Se extends A {
+  constructor() {
+    super(l.Bool);
+  }
+  toString() {
+    return "Bool";
+  }
+}
+xn = Symbol.toStringTag;
+Se[xn] = ((e) => (e.ArrayType = Uint8Array, e[Symbol.toStringTag] = "Bool"))(Se.prototype);
+class pn extends A {
+  constructor(t, n, i = 128) {
+    super(l.Decimal), this.scale = t, this.precision = n, this.bitWidth = i;
+  }
+  toString() {
+    return `Decimal[${this.precision}e${this.scale > 0 ? "+" : ""}${this.scale}]`;
+  }
+}
+kn = Symbol.toStringTag;
+pn[kn] = ((e) => (e.scale = null, e.precision = null, e.ArrayType = Uint32Array, e[Symbol.toStringTag] = "Decimal"))(pn.prototype);
+class Jt extends A {
+  constructor(t) {
+    super(l.Date), this.unit = t;
+  }
+  toString() {
+    return `Date${(this.unit + 1) * 32}<${Z[this.unit]}>`;
+  }
+  get ArrayType() {
+    return this.unit === Z.DAY ? Int32Array : BigInt64Array;
+  }
+}
+jn = Symbol.toStringTag;
+Jt[jn] = ((e) => (e.unit = null, e[Symbol.toStringTag] = "Date"))(Jt.prototype);
+class ua extends Jt {
+  constructor() {
+    super(Z.DAY);
+  }
+}
+class da extends Jt {
+  constructor() {
+    super(Z.MILLISECOND);
+  }
+}
+class wt extends A {
+  constructor(t, n) {
+    super(l.Time), this.unit = t, this.bitWidth = n;
+  }
+  toString() {
+    return `Time${this.bitWidth}<${y[this.unit]}>`;
+  }
+  get ArrayType() {
+    switch (this.bitWidth) {
+      case 32:
+        return Int32Array;
+      case 64:
+        return BigInt64Array;
+    }
+    throw new Error(`Unrecognized ${this[Symbol.toStringTag]} type`);
+  }
+}
+zn = Symbol.toStringTag;
+wt[zn] = ((e) => (e.unit = null, e.bitWidth = null, e[Symbol.toStringTag] = "Time"))(wt.prototype);
+class ha extends wt {
+  constructor() {
+    super(y.SECOND, 32);
+  }
+}
+class ya extends wt {
+  constructor() {
+    super(y.MILLISECOND, 32);
+  }
+}
+class pa extends wt {
+  constructor() {
+    super(y.MICROSECOND, 64);
+  }
+}
+class fa extends wt {
+  constructor() {
+    super(y.NANOSECOND, 64);
+  }
+}
+class At extends A {
+  constructor(t, n) {
+    super(l.Timestamp), this.unit = t, this.timezone = n;
+  }
+  toString() {
+    return `Timestamp<${y[this.unit]}${this.timezone ? `, ${this.timezone}` : ""}>`;
+  }
+}
+$n = Symbol.toStringTag;
+At[$n] = ((e) => (e.unit = null, e.timezone = null, e.ArrayType = BigInt64Array, e[Symbol.toStringTag] = "Timestamp"))(At.prototype);
+class ga extends At {
+  constructor(t) {
+    super(y.SECOND, t);
+  }
+}
+class ms extends At {
+  constructor(t) {
+    super(y.MILLISECOND, t);
+  }
+}
+class ma extends At {
+  constructor(t) {
+    super(y.MICROSECOND, t);
+  }
+}
+class va extends At {
+  constructor(t) {
+    super(y.NANOSECOND, t);
+  }
+}
+class Et extends A {
+  constructor(t) {
+    super(l.Interval), this.unit = t;
+  }
+  toString() {
+    return `Interval<${j[this.unit]}>`;
+  }
+}
+Pn = Symbol.toStringTag;
+Et[Pn] = ((e) => (e.unit = null, e.ArrayType = Int32Array, e[Symbol.toStringTag] = "Interval"))(Et.prototype);
+class ba extends Et {
+  constructor() {
+    super(j.DAY_TIME);
+  }
+}
+class Ia extends Et {
+  constructor() {
+    super(j.YEAR_MONTH);
+  }
+}
+class Sa extends Et {
+  constructor() {
+    super(j.MONTH_DAY_NANO);
+  }
+}
+class Dt extends A {
+  constructor(t) {
+    super(l.Duration), this.unit = t;
+  }
+  toString() {
+    return `Duration<${y[this.unit]}>`;
+  }
+}
+Rn = Symbol.toStringTag;
+Dt[Rn] = ((e) => (e.unit = null, e.ArrayType = BigInt64Array, e[Symbol.toStringTag] = "Duration"))(Dt.prototype);
+class wa extends Dt {
+  constructor() {
+    super(y.SECOND);
+  }
+}
+class Aa extends Dt {
+  constructor() {
+    super(y.MILLISECOND);
+  }
+}
+class Da extends Dt {
+  constructor() {
+    super(y.MICROSECOND);
+  }
+}
+class _a extends Dt {
+  constructor() {
+    super(y.NANOSECOND);
+  }
+}
+class qt extends A {
+  constructor(t) {
+    super(l.List), this.children = [t];
+  }
+  toString() {
+    return `List<${this.valueType}>`;
+  }
+  get valueType() {
+    return this.children[0].type;
+  }
+  get valueField() {
+    return this.children[0];
+  }
+  get ArrayType() {
+    return this.valueType.ArrayType;
+  }
+}
+Yn = Symbol.toStringTag;
+qt[Yn] = ((e) => (e.children = null, e[Symbol.toStringTag] = "List"))(qt.prototype);
+class Y extends A {
+  constructor(t) {
+    super(l.Struct), this.children = t;
+  }
+  toString() {
+    return `Struct<{${this.children.map((t) => `${t.name}:${t.type}`).join(", ")}}>`;
+  }
+}
+Wn = Symbol.toStringTag;
+Y[Wn] = ((e) => (e.children = null, e[Symbol.toStringTag] = "Struct"))(Y.prototype);
+class Vt extends A {
+  constructor(t, n, i) {
+    super(l.Union), this.mode = t, this.children = i, this.typeIds = n = Int32Array.from(n), this.typeIdToChildIndex = n.reduce((r, s, o) => (r[s] = o) && r || r, /* @__PURE__ */ Object.create(null));
+  }
+  toString() {
+    return `${this[Symbol.toStringTag]}<${this.children.map((t) => `${t.type}`).join(" | ")}>`;
+  }
+}
+Hn = Symbol.toStringTag;
+Vt[Hn] = ((e) => (e.mode = null, e.typeIds = null, e.children = null, e.typeIdToChildIndex = null, e.ArrayType = Int8Array, e[Symbol.toStringTag] = "Union"))(Vt.prototype);
+class Ba extends Vt {
+  constructor(t, n) {
+    super(K.Dense, t, n);
+  }
+}
+class Ta extends Vt {
+  constructor(t, n) {
+    super(K.Sparse, t, n);
+  }
+}
+class fn extends A {
+  constructor(t) {
+    super(l.FixedSizeBinary), this.byteWidth = t;
+  }
+  toString() {
+    return `FixedSizeBinary[${this.byteWidth}]`;
+  }
+}
+Kn = Symbol.toStringTag;
+fn[Kn] = ((e) => (e.byteWidth = null, e.ArrayType = Uint8Array, e[Symbol.toStringTag] = "FixedSizeBinary"))(fn.prototype);
+class we extends A {
+  constructor(t, n) {
+    super(l.FixedSizeList), this.listSize = t, this.children = [n];
+  }
+  get valueType() {
+    return this.children[0].type;
+  }
+  get valueField() {
+    return this.children[0];
+  }
+  get ArrayType() {
+    return this.valueType.ArrayType;
+  }
+  toString() {
+    return `FixedSizeList[${this.listSize}]<${this.valueType}>`;
+  }
+}
+Gn = Symbol.toStringTag;
+we[Gn] = ((e) => (e.children = null, e.listSize = null, e[Symbol.toStringTag] = "FixedSizeList"))(we.prototype);
+class Ae extends A {
+  constructor(t, n = !1) {
+    var i, r, s;
+    if (super(l.Map), this.children = [t], this.keysSorted = n, t && (t.name = "entries", !((i = t == null ? void 0 : t.type) === null || i === void 0) && i.children)) {
+      const o = (r = t == null ? void 0 : t.type) === null || r === void 0 ? void 0 : r.children[0];
+      o && (o.name = "key");
+      const a = (s = t == null ? void 0 : t.type) === null || s === void 0 ? void 0 : s.children[1];
+      a && (a.name = "value");
+    }
+  }
+  get keyType() {
+    return this.children[0].type.children[0].type;
+  }
+  get valueType() {
+    return this.children[0].type.children[1].type;
+  }
+  get childType() {
+    return this.children[0].type;
+  }
+  toString() {
+    return `Map<{${this.children[0].type.children.map((t) => `${t.name}:${t.type}`).join(", ")}}>`;
+  }
+}
+Jn = Symbol.toStringTag;
+Ae[Jn] = ((e) => (e.children = null, e.keysSorted = null, e[Symbol.toStringTag] = "Map_"))(Ae.prototype);
+const vs = /* @__PURE__ */ ((e) => () => ++e)(-1);
+class Qt extends A {
+  constructor(t, n, i, r) {
+    super(l.Dictionary), this.indices = n, this.dictionary = t, this.isOrdered = r || !1, this.id = i == null ? vs() : W(i);
+  }
+  get children() {
+    return this.dictionary.children;
+  }
+  get valueType() {
+    return this.dictionary;
+  }
+  get ArrayType() {
+    return this.dictionary.ArrayType;
+  }
+  toString() {
+    return `Dictionary<${this.indices}, ${this.dictionary}>`;
+  }
+}
+qn = Symbol.toStringTag;
+Qt[qn] = ((e) => (e.id = null, e.indices = null, e.isOrdered = null, e.dictionary = null, e[Symbol.toStringTag] = "Dictionary"))(Qt.prototype);
+function X(e) {
+  const t = e;
+  switch (e.typeId) {
+    case l.Decimal:
+      return e.bitWidth / 32;
+    case l.Interval:
+      return t.unit === j.MONTH_DAY_NANO ? 4 : 1 + t.unit;
+    // case Type.Int: return 1 + +((t as Int_).bitWidth > 32);
+    // case Type.Time: return 1 + +((t as Time_).bitWidth > 32);
+    case l.FixedSizeList:
+      return t.listSize;
+    case l.FixedSizeBinary:
+      return t.byteWidth;
+    default:
+      return 1;
+  }
+}
+class _ {
+  visitMany(t, ...n) {
+    return t.map((i, r) => this.visit(i, ...n.map((s) => s[r])));
+  }
+  visit(...t) {
+    return this.getVisitFn(t[0], !1).apply(this, t);
+  }
+  getVisitFn(t, n = !0) {
+    return bs(this, t, n);
+  }
+  getVisitFnByTypeId(t, n = !0) {
+    return ft(this, t, n);
+  }
+  visitNull(t, ...n) {
+    return null;
+  }
+  visitBool(t, ...n) {
+    return null;
+  }
+  visitInt(t, ...n) {
+    return null;
+  }
+  visitFloat(t, ...n) {
+    return null;
+  }
+  visitUtf8(t, ...n) {
+    return null;
+  }
+  visitLargeUtf8(t, ...n) {
+    return null;
+  }
+  visitBinary(t, ...n) {
+    return null;
+  }
+  visitLargeBinary(t, ...n) {
+    return null;
+  }
+  visitFixedSizeBinary(t, ...n) {
+    return null;
+  }
+  visitDate(t, ...n) {
+    return null;
+  }
+  visitTimestamp(t, ...n) {
+    return null;
+  }
+  visitTime(t, ...n) {
+    return null;
+  }
+  visitDecimal(t, ...n) {
+    return null;
+  }
+  visitList(t, ...n) {
+    return null;
+  }
+  visitStruct(t, ...n) {
+    return null;
+  }
+  visitUnion(t, ...n) {
+    return null;
+  }
+  visitDictionary(t, ...n) {
+    return null;
+  }
+  visitInterval(t, ...n) {
+    return null;
+  }
+  visitDuration(t, ...n) {
+    return null;
+  }
+  visitFixedSizeList(t, ...n) {
+    return null;
+  }
+  visitMap(t, ...n) {
+    return null;
+  }
+}
+function bs(e, t, n = !0) {
+  return typeof t == "number" ? ft(e, t, n) : typeof t == "string" && t in l ? ft(e, l[t], n) : t && t instanceof A ? ft(e, gn(t), n) : t != null && t.type && t.type instanceof A ? ft(e, gn(t.type), n) : ft(e, l.NONE, n);
+}
+function ft(e, t, n = !0) {
+  let i = null;
+  switch (t) {
+    case l.Null:
+      i = e.visitNull;
+      break;
+    case l.Bool:
+      i = e.visitBool;
+      break;
+    case l.Int:
+      i = e.visitInt;
+      break;
+    case l.Int8:
+      i = e.visitInt8 || e.visitInt;
+      break;
+    case l.Int16:
+      i = e.visitInt16 || e.visitInt;
+      break;
+    case l.Int32:
+      i = e.visitInt32 || e.visitInt;
+      break;
+    case l.Int64:
+      i = e.visitInt64 || e.visitInt;
+      break;
+    case l.Uint8:
+      i = e.visitUint8 || e.visitInt;
+      break;
+    case l.Uint16:
+      i = e.visitUint16 || e.visitInt;
+      break;
+    case l.Uint32:
+      i = e.visitUint32 || e.visitInt;
+      break;
+    case l.Uint64:
+      i = e.visitUint64 || e.visitInt;
+      break;
+    case l.Float:
+      i = e.visitFloat;
+      break;
+    case l.Float16:
+      i = e.visitFloat16 || e.visitFloat;
+      break;
+    case l.Float32:
+      i = e.visitFloat32 || e.visitFloat;
+      break;
+    case l.Float64:
+      i = e.visitFloat64 || e.visitFloat;
+      break;
+    case l.Utf8:
+      i = e.visitUtf8;
+      break;
+    case l.LargeUtf8:
+      i = e.visitLargeUtf8;
+      break;
+    case l.Binary:
+      i = e.visitBinary;
+      break;
+    case l.LargeBinary:
+      i = e.visitLargeBinary;
+      break;
+    case l.FixedSizeBinary:
+      i = e.visitFixedSizeBinary;
+      break;
+    case l.Date:
+      i = e.visitDate;
+      break;
+    case l.DateDay:
+      i = e.visitDateDay || e.visitDate;
+      break;
+    case l.DateMillisecond:
+      i = e.visitDateMillisecond || e.visitDate;
+      break;
+    case l.Timestamp:
+      i = e.visitTimestamp;
+      break;
+    case l.TimestampSecond:
+      i = e.visitTimestampSecond || e.visitTimestamp;
+      break;
+    case l.TimestampMillisecond:
+      i = e.visitTimestampMillisecond || e.visitTimestamp;
+      break;
+    case l.TimestampMicrosecond:
+      i = e.visitTimestampMicrosecond || e.visitTimestamp;
+      break;
+    case l.TimestampNanosecond:
+      i = e.visitTimestampNanosecond || e.visitTimestamp;
+      break;
+    case l.Time:
+      i = e.visitTime;
+      break;
+    case l.TimeSecond:
+      i = e.visitTimeSecond || e.visitTime;
+      break;
+    case l.TimeMillisecond:
+      i = e.visitTimeMillisecond || e.visitTime;
+      break;
+    case l.TimeMicrosecond:
+      i = e.visitTimeMicrosecond || e.visitTime;
+      break;
+    case l.TimeNanosecond:
+      i = e.visitTimeNanosecond || e.visitTime;
+      break;
+    case l.Decimal:
+      i = e.visitDecimal;
+      break;
+    case l.List:
+      i = e.visitList;
+      break;
+    case l.Struct:
+      i = e.visitStruct;
+      break;
+    case l.Union:
+      i = e.visitUnion;
+      break;
+    case l.DenseUnion:
+      i = e.visitDenseUnion || e.visitUnion;
+      break;
+    case l.SparseUnion:
+      i = e.visitSparseUnion || e.visitUnion;
+      break;
+    case l.Dictionary:
+      i = e.visitDictionary;
+      break;
+    case l.Interval:
+      i = e.visitInterval;
+      break;
+    case l.IntervalDayTime:
+      i = e.visitIntervalDayTime || e.visitInterval;
+      break;
+    case l.IntervalYearMonth:
+      i = e.visitIntervalYearMonth || e.visitInterval;
+      break;
+    case l.IntervalMonthDayNano:
+      i = e.visitIntervalMonthDayNano || e.visitInterval;
+      break;
+    case l.Duration:
+      i = e.visitDuration;
+      break;
+    case l.DurationSecond:
+      i = e.visitDurationSecond || e.visitDuration;
+      break;
+    case l.DurationMillisecond:
+      i = e.visitDurationMillisecond || e.visitDuration;
+      break;
+    case l.DurationMicrosecond:
+      i = e.visitDurationMicrosecond || e.visitDuration;
+      break;
+    case l.DurationNanosecond:
+      i = e.visitDurationNanosecond || e.visitDuration;
+      break;
+    case l.FixedSizeList:
+      i = e.visitFixedSizeList;
+      break;
+    case l.Map:
+      i = e.visitMap;
+      break;
+  }
+  if (typeof i == "function")
+    return i;
+  if (!n)
+    return () => null;
+  throw new Error(`Unrecognized type '${l[t]}'`);
+}
+function gn(e) {
+  switch (e.typeId) {
+    case l.Null:
+      return l.Null;
+    case l.Int: {
+      const { bitWidth: t, isSigned: n } = e;
+      switch (t) {
+        case 8:
+          return n ? l.Int8 : l.Uint8;
+        case 16:
+          return n ? l.Int16 : l.Uint16;
+        case 32:
+          return n ? l.Int32 : l.Uint32;
+        case 64:
+          return n ? l.Int64 : l.Uint64;
+      }
+      return l.Int;
+    }
+    case l.Float:
+      switch (e.precision) {
+        case x.HALF:
+          return l.Float16;
+        case x.SINGLE:
+          return l.Float32;
+        case x.DOUBLE:
+          return l.Float64;
+      }
+      return l.Float;
+    case l.Binary:
+      return l.Binary;
+    case l.LargeBinary:
+      return l.LargeBinary;
+    case l.Utf8:
+      return l.Utf8;
+    case l.LargeUtf8:
+      return l.LargeUtf8;
+    case l.Bool:
+      return l.Bool;
+    case l.Decimal:
+      return l.Decimal;
+    case l.Time:
+      switch (e.unit) {
+        case y.SECOND:
+          return l.TimeSecond;
+        case y.MILLISECOND:
+          return l.TimeMillisecond;
+        case y.MICROSECOND:
+          return l.TimeMicrosecond;
+        case y.NANOSECOND:
+          return l.TimeNanosecond;
+      }
+      return l.Time;
+    case l.Timestamp:
+      switch (e.unit) {
+        case y.SECOND:
+          return l.TimestampSecond;
+        case y.MILLISECOND:
+          return l.TimestampMillisecond;
+        case y.MICROSECOND:
+          return l.TimestampMicrosecond;
+        case y.NANOSECOND:
+          return l.TimestampNanosecond;
+      }
+      return l.Timestamp;
+    case l.Date:
+      switch (e.unit) {
+        case Z.DAY:
+          return l.DateDay;
+        case Z.MILLISECOND:
+          return l.DateMillisecond;
+      }
+      return l.Date;
+    case l.Interval:
+      switch (e.unit) {
+        case j.DAY_TIME:
+          return l.IntervalDayTime;
+        case j.YEAR_MONTH:
+          return l.IntervalYearMonth;
+        case j.MONTH_DAY_NANO:
+          return l.IntervalMonthDayNano;
+      }
+      return l.Interval;
+    case l.Duration:
+      switch (e.unit) {
+        case y.SECOND:
+          return l.DurationSecond;
+        case y.MILLISECOND:
+          return l.DurationMillisecond;
+        case y.MICROSECOND:
+          return l.DurationMicrosecond;
+        case y.NANOSECOND:
+          return l.DurationNanosecond;
+      }
+      return l.Duration;
+    case l.Map:
+      return l.Map;
+    case l.List:
+      return l.List;
+    case l.Struct:
+      return l.Struct;
+    case l.Union:
+      switch (e.mode) {
+        case K.Dense:
+          return l.DenseUnion;
+        case K.Sparse:
+          return l.SparseUnion;
+      }
+      return l.Union;
+    case l.FixedSizeBinary:
+      return l.FixedSizeBinary;
+    case l.FixedSizeList:
+      return l.FixedSizeList;
+    case l.Dictionary:
+      return l.Dictionary;
+  }
+  throw new Error(`Unrecognized type '${l[e.typeId]}'`);
+}
+_.prototype.visitInt8 = null;
+_.prototype.visitInt16 = null;
+_.prototype.visitInt32 = null;
+_.prototype.visitInt64 = null;
+_.prototype.visitUint8 = null;
+_.prototype.visitUint16 = null;
+_.prototype.visitUint32 = null;
+_.prototype.visitUint64 = null;
+_.prototype.visitFloat16 = null;
+_.prototype.visitFloat32 = null;
+_.prototype.visitFloat64 = null;
+_.prototype.visitDateDay = null;
+_.prototype.visitDateMillisecond = null;
+_.prototype.visitTimestampSecond = null;
+_.prototype.visitTimestampMillisecond = null;
+_.prototype.visitTimestampMicrosecond = null;
+_.prototype.visitTimestampNanosecond = null;
+_.prototype.visitTimeSecond = null;
+_.prototype.visitTimeMillisecond = null;
+_.prototype.visitTimeMicrosecond = null;
+_.prototype.visitTimeNanosecond = null;
+_.prototype.visitDenseUnion = null;
+_.prototype.visitSparseUnion = null;
+_.prototype.visitIntervalDayTime = null;
+_.prototype.visitIntervalYearMonth = null;
+_.prototype.visitIntervalMonthDayNano = null;
+_.prototype.visitDuration = null;
+_.prototype.visitDurationSecond = null;
+_.prototype.visitDurationMillisecond = null;
+_.prototype.visitDurationMicrosecond = null;
+_.prototype.visitDurationNanosecond = null;
+const ri = new Float64Array(1), yt = new Uint32Array(ri.buffer);
+function Ce(e) {
+  const t = (e & 31744) >> 10, n = (e & 1023) / 1024, i = Math.pow(-1, (e & 32768) >> 15);
+  switch (t) {
+    case 31:
+      return i * (n ? Number.NaN : 1 / 0);
+    case 0:
+      return i * (n ? 6103515625e-14 * n : 0);
+  }
+  return i * Math.pow(2, t - 15) * (1 + n);
+}
+function Fe(e) {
+  if (e !== e)
+    return 32256;
+  ri[0] = e;
+  const t = (yt[1] & 2147483648) >> 16 & 65535;
+  let n = yt[1] & 2146435072, i = 0;
+  return n >= 1089470464 ? yt[0] > 0 ? n = 31744 : (n = (n & 2080374784) >> 16, i = (yt[1] & 1048575) >> 10) : n <= 1056964608 ? (i = 1048576 + (yt[1] & 1048575), i = 1048576 + (i << (n >> 20) - 998) >> 21, n = 0) : (n = n - 1056964608 >> 10, i = (yt[1] & 1048575) + 512 >> 10), t | n | i & 65535;
+}
+const Oa = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  float64ToUint16: Fe,
+  uint16ToFloat64: Ce
+}, Symbol.toStringTag, { value: "Module" }));
+class v extends _ {
+}
+function S(e) {
+  return (t, n, i) => {
+    if (t.setValid(n, i != null))
+      return e(t, n, i);
+  };
+}
+const Is = (e, t, n) => {
+  e[t] = Math.floor(n / 864e5);
+}, si = (e, t, n, i) => {
+  if (n + 1 < t.length) {
+    const r = W(t[n]), s = W(t[n + 1]);
+    e.set(i.subarray(0, s - r), r);
+  }
+}, Ss = ({ offset: e, values: t }, n, i) => {
+  const r = e + n;
+  i ? t[r >> 3] |= 1 << r % 8 : t[r >> 3] &= ~(1 << r % 8);
+}, rt = ({ values: e }, t, n) => {
+  e[t] = n;
+}, Le = ({ values: e }, t, n) => {
+  e[t] = n;
+}, oi = ({ values: e }, t, n) => {
+  e[t] = Fe(n);
+}, ws = (e, t, n) => {
+  switch (e.type.precision) {
+    case x.HALF:
+      return oi(e, t, n);
+    case x.SINGLE:
+    case x.DOUBLE:
+      return Le(e, t, n);
+  }
+}, Ee = ({ values: e }, t, n) => {
+  Is(e, t, n.valueOf());
+}, Ve = ({ values: e }, t, n) => {
+  e[t] = BigInt(n);
+}, ai = ({ stride: e, values: t }, n, i) => {
+  t.set(i.subarray(0, e), e * n);
+}, li = ({ values: e, valueOffsets: t }, n, i) => si(e, t, n, i), ci = ({ values: e, valueOffsets: t }, n, i) => si(e, t, n, ne(i)), ui = (e, t, n) => {
+  e.type.unit === Z.DAY ? Ee(e, t, n) : Ve(e, t, n);
+}, xe = ({ values: e }, t, n) => {
+  e[t] = BigInt(n / 1e3);
+}, ke = ({ values: e }, t, n) => {
+  e[t] = BigInt(n);
+}, je = ({ values: e }, t, n) => {
+  e[t] = BigInt(n * 1e3);
+}, ze = ({ values: e }, t, n) => {
+  e[t] = BigInt(n * 1e6);
+}, di = (e, t, n) => {
+  switch (e.type.unit) {
+    case y.SECOND:
+      return xe(e, t, n);
+    case y.MILLISECOND:
+      return ke(e, t, n);
+    case y.MICROSECOND:
+      return je(e, t, n);
+    case y.NANOSECOND:
+      return ze(e, t, n);
+  }
+}, $e = ({ values: e }, t, n) => {
+  e[t] = n;
+}, Pe = ({ values: e }, t, n) => {
+  e[t] = n;
+}, Re = ({ values: e }, t, n) => {
+  e[t] = n;
+}, Ye = ({ values: e }, t, n) => {
+  e[t] = n;
+}, hi = (e, t, n) => {
+  switch (e.type.unit) {
+    case y.SECOND:
+      return $e(e, t, n);
+    case y.MILLISECOND:
+      return Pe(e, t, n);
+    case y.MICROSECOND:
+      return Re(e, t, n);
+    case y.NANOSECOND:
+      return Ye(e, t, n);
+  }
+}, yi = ({ values: e, stride: t }, n, i) => {
+  e.set(i.subarray(0, t), t * n);
+}, As = (e, t, n) => {
+  const i = e.children[0], r = e.valueOffsets, s = G.getVisitFn(i);
+  if (Array.isArray(n))
+    for (let o = -1, a = r[t], c = r[t + 1]; a < c; )
+      s(i, a++, n[++o]);
+  else
+    for (let o = -1, a = r[t], c = r[t + 1]; a < c; )
+      s(i, a++, n.get(++o));
+}, Ds = (e, t, n) => {
+  const i = e.children[0], { valueOffsets: r } = e, s = G.getVisitFn(i);
+  let { [t]: o, [t + 1]: a } = r;
+  const c = n instanceof Map ? n.entries() : Object.entries(n);
+  for (const u of c)
+    if (s(i, o, u), ++o >= a)
+      break;
+}, _s = (e, t) => (n, i, r, s) => i && n(i, e, t[s]), Bs = (e, t) => (n, i, r, s) => i && n(i, e, t.get(s)), Ts = (e, t) => (n, i, r, s) => i && n(i, e, t.get(r.name)), Os = (e, t) => (n, i, r, s) => i && n(i, e, t[r.name]), Ms = (e, t, n) => {
+  const i = e.type.children.map((s) => G.getVisitFn(s.type)), r = n instanceof Map ? Ts(t, n) : n instanceof D ? Bs(t, n) : Array.isArray(n) ? _s(t, n) : Os(t, n);
+  e.type.children.forEach((s, o) => r(i[o], e.children[o], s, o));
+}, Ns = (e, t, n) => {
+  e.type.mode === K.Dense ? pi(e, t, n) : fi(e, t, n);
+}, pi = (e, t, n) => {
+  const i = e.type.typeIdToChildIndex[e.typeIds[t]], r = e.children[i];
+  G.visit(r, e.valueOffsets[t], n);
+}, fi = (e, t, n) => {
+  const i = e.type.typeIdToChildIndex[e.typeIds[t]], r = e.children[i];
+  G.visit(r, t, n);
+}, Us = (e, t, n) => {
+  var i;
+  (i = e.dictionary) === null || i === void 0 || i.set(e.values[t], n);
+}, gi = (e, t, n) => {
+  switch (e.type.unit) {
+    case j.YEAR_MONTH:
+      return He(e, t, n);
+    case j.DAY_TIME:
+      return We(e, t, n);
+    case j.MONTH_DAY_NANO:
+      return Ke(e, t, n);
+  }
+}, We = ({ values: e }, t, n) => {
+  e.set(n.subarray(0, 2), 2 * t);
+}, He = ({ values: e }, t, n) => {
+  e[t] = n[0] * 12 + n[1] % 12;
+}, Ke = ({ values: e, stride: t }, n, i) => {
+  e.set(i.subarray(0, t), t * n);
+}, Ge = ({ values: e }, t, n) => {
+  e[t] = n;
+}, Je = ({ values: e }, t, n) => {
+  e[t] = n;
+}, qe = ({ values: e }, t, n) => {
+  e[t] = n;
+}, Qe = ({ values: e }, t, n) => {
+  e[t] = n;
+}, mi = (e, t, n) => {
+  switch (e.type.unit) {
+    case y.SECOND:
+      return Ge(e, t, n);
+    case y.MILLISECOND:
+      return Je(e, t, n);
+    case y.MICROSECOND:
+      return qe(e, t, n);
+    case y.NANOSECOND:
+      return Qe(e, t, n);
+  }
+}, Cs = (e, t, n) => {
+  const { stride: i } = e, r = e.children[0], s = G.getVisitFn(r);
+  if (Array.isArray(n))
+    for (let o = -1, a = t * i; ++o < i; )
+      s(r, a + o, n[o]);
+  else
+    for (let o = -1, a = t * i; ++o < i; )
+      s(r, a + o, n.get(o));
+};
+v.prototype.visitBool = S(Ss);
+v.prototype.visitInt = S(rt);
+v.prototype.visitInt8 = S(rt);
+v.prototype.visitInt16 = S(rt);
+v.prototype.visitInt32 = S(rt);
+v.prototype.visitInt64 = S(rt);
+v.prototype.visitUint8 = S(rt);
+v.prototype.visitUint16 = S(rt);
+v.prototype.visitUint32 = S(rt);
+v.prototype.visitUint64 = S(rt);
+v.prototype.visitFloat = S(ws);
+v.prototype.visitFloat16 = S(oi);
+v.prototype.visitFloat32 = S(Le);
+v.prototype.visitFloat64 = S(Le);
+v.prototype.visitUtf8 = S(ci);
+v.prototype.visitLargeUtf8 = S(ci);
+v.prototype.visitBinary = S(li);
+v.prototype.visitLargeBinary = S(li);
+v.prototype.visitFixedSizeBinary = S(ai);
+v.prototype.visitDate = S(ui);
+v.prototype.visitDateDay = S(Ee);
+v.prototype.visitDateMillisecond = S(Ve);
+v.prototype.visitTimestamp = S(di);
+v.prototype.visitTimestampSecond = S(xe);
+v.prototype.visitTimestampMillisecond = S(ke);
+v.prototype.visitTimestampMicrosecond = S(je);
+v.prototype.visitTimestampNanosecond = S(ze);
+v.prototype.visitTime = S(hi);
+v.prototype.visitTimeSecond = S($e);
+v.prototype.visitTimeMillisecond = S(Pe);
+v.prototype.visitTimeMicrosecond = S(Re);
+v.prototype.visitTimeNanosecond = S(Ye);
+v.prototype.visitDecimal = S(yi);
+v.prototype.visitList = S(As);
+v.prototype.visitStruct = S(Ms);
+v.prototype.visitUnion = S(Ns);
+v.prototype.visitDenseUnion = S(pi);
+v.prototype.visitSparseUnion = S(fi);
+v.prototype.visitDictionary = S(Us);
+v.prototype.visitInterval = S(gi);
+v.prototype.visitIntervalDayTime = S(We);
+v.prototype.visitIntervalYearMonth = S(He);
+v.prototype.visitIntervalMonthDayNano = S(Ke);
+v.prototype.visitDuration = S(mi);
+v.prototype.visitDurationSecond = S(Ge);
+v.prototype.visitDurationMillisecond = S(Je);
+v.prototype.visitDurationMicrosecond = S(qe);
+v.prototype.visitDurationNanosecond = S(Qe);
+v.prototype.visitFixedSizeList = S(Cs);
+v.prototype.visitMap = S(Ds);
+const G = new v(), J = Symbol.for("parent"), bt = Symbol.for("rowIndex");
+class Xe {
+  constructor(t, n) {
+    return this[J] = t, this[bt] = n, new Proxy(this, Es);
+  }
+  toArray() {
+    return Object.values(this.toJSON());
+  }
+  toJSON() {
+    const t = this[bt], n = this[J], i = n.type.children, r = {};
+    for (let s = -1, o = i.length; ++s < o; )
+      r[i[s].name] = $.visit(n.children[s], t);
+    return r;
+  }
+  toString() {
+    return `{${[...this].map(([t, n]) => `${lt(t)}: ${lt(n)}`).join(", ")}}`;
+  }
+  [Symbol.for("nodejs.util.inspect.custom")]() {
+    return this.toString();
+  }
+  [Symbol.iterator]() {
+    return new Fs(this[J], this[bt]);
+  }
+}
+class Fs {
+  constructor(t, n) {
+    this.childIndex = 0, this.children = t.children, this.rowIndex = n, this.childFields = t.type.children, this.numChildren = this.childFields.length;
+  }
+  [Symbol.iterator]() {
+    return this;
+  }
+  next() {
+    const t = this.childIndex;
+    return t < this.numChildren ? (this.childIndex = t + 1, {
+      done: !1,
+      value: [
+        this.childFields[t].name,
+        $.visit(this.children[t], this.rowIndex)
+      ]
+    }) : { done: !0, value: null };
+  }
+}
+Object.defineProperties(Xe.prototype, {
+  [Symbol.toStringTag]: { enumerable: !1, configurable: !1, value: "Row" },
+  [J]: { writable: !0, enumerable: !1, configurable: !1, value: null },
+  [bt]: { writable: !0, enumerable: !1, configurable: !1, value: -1 }
+});
+class Ls {
+  isExtensible() {
+    return !1;
+  }
+  deleteProperty() {
+    return !1;
+  }
+  preventExtensions() {
+    return !0;
+  }
+  ownKeys(t) {
+    return t[J].type.children.map((n) => n.name);
+  }
+  has(t, n) {
+    return t[J].type.children.some((i) => i.name === n);
+  }
+  getOwnPropertyDescriptor(t, n) {
+    if (t[J].type.children.some((i) => i.name === n))
+      return { writable: !0, enumerable: !0, configurable: !0 };
+  }
+  get(t, n) {
+    if (Reflect.has(t, n))
+      return t[n];
+    const i = t[J].type.children.findIndex((r) => r.name === n);
+    if (i !== -1) {
+      const r = $.visit(t[J].children[i], t[bt]);
+      return Reflect.set(t, n, r), r;
+    }
+  }
+  set(t, n, i) {
+    const r = t[J].type.children.findIndex((s) => s.name === n);
+    return r !== -1 ? (G.visit(t[J].children[r], t[bt], i), Reflect.set(t, n, i)) : Reflect.has(t, n) || typeof n == "symbol" ? Reflect.set(t, n, i) : !1;
+  }
+}
+const Es = new Ls();
+class p extends _ {
+}
+function b(e) {
+  return (t, n) => t.getValid(n) ? e(t, n) : null;
+}
+const Vs = (e, t) => 864e5 * e[t], xs = (e, t) => null, vi = (e, t, n) => {
+  if (n + 1 >= t.length)
+    return null;
+  const i = W(t[n]), r = W(t[n + 1]);
+  return e.subarray(i, r);
+}, ks = ({ offset: e, values: t }, n) => {
+  const i = e + n;
+  return (t[i >> 3] & 1 << i % 8) !== 0;
+}, bi = ({ values: e }, t) => Vs(e, t), Ii = ({ values: e }, t) => W(e[t]), ct = ({ stride: e, values: t }, n) => t[e * n], js = ({ stride: e, values: t }, n) => Ce(t[e * n]), Si = ({ values: e }, t) => e[t], zs = ({ stride: e, values: t }, n) => t.subarray(e * n, e * (n + 1)), wi = ({ values: e, valueOffsets: t }, n) => vi(e, t, n), Ai = ({ values: e, valueOffsets: t }, n) => {
+  const i = vi(e, t, n);
+  return i !== null ? Nr(i) : null;
+}, $s = ({ values: e }, t) => e[t], Ps = ({ type: e, values: t }, n) => e.precision !== x.HALF ? t[n] : Ce(t[n]), Rs = (e, t) => e.type.unit === Z.DAY ? bi(e, t) : Ii(e, t), Di = ({ values: e }, t) => 1e3 * W(e[t]), _i = ({ values: e }, t) => W(e[t]), Bi = ({ values: e }, t) => Bn(e[t], BigInt(1e3)), Ti = ({ values: e }, t) => Bn(e[t], BigInt(1e6)), Ys = (e, t) => {
+  switch (e.type.unit) {
+    case y.SECOND:
+      return Di(e, t);
+    case y.MILLISECOND:
+      return _i(e, t);
+    case y.MICROSECOND:
+      return Bi(e, t);
+    case y.NANOSECOND:
+      return Ti(e, t);
+  }
+}, Oi = ({ values: e }, t) => e[t], Mi = ({ values: e }, t) => e[t], Ni = ({ values: e }, t) => e[t], Ui = ({ values: e }, t) => e[t], Ws = (e, t) => {
+  switch (e.type.unit) {
+    case y.SECOND:
+      return Oi(e, t);
+    case y.MILLISECOND:
+      return Mi(e, t);
+    case y.MICROSECOND:
+      return Ni(e, t);
+    case y.NANOSECOND:
+      return Ui(e, t);
+  }
+}, Hs = ({ values: e, stride: t }, n) => re.decimal(e.subarray(t * n, t * (n + 1))), Ks = (e, t) => {
+  const { valueOffsets: n, stride: i, children: r } = e, { [t * i]: s, [t * i + 1]: o } = n, c = r[0].slice(s, o - s);
+  return new D([c]);
+}, Gs = (e, t) => {
+  const { valueOffsets: n, children: i } = e, { [t]: r, [t + 1]: s } = n, o = i[0];
+  return new se(o.slice(r, s - r));
+}, Js = (e, t) => new Xe(e, t), qs = (e, t) => e.type.mode === K.Dense ? Ci(e, t) : Fi(e, t), Ci = (e, t) => {
+  const n = e.type.typeIdToChildIndex[e.typeIds[t]], i = e.children[n];
+  return $.visit(i, e.valueOffsets[t]);
+}, Fi = (e, t) => {
+  const n = e.type.typeIdToChildIndex[e.typeIds[t]], i = e.children[n];
+  return $.visit(i, t);
+}, Qs = (e, t) => {
+  var n;
+  return (n = e.dictionary) === null || n === void 0 ? void 0 : n.get(e.values[t]);
+}, Xs = (e, t) => e.type.unit === j.MONTH_DAY_NANO ? Vi(e, t) : e.type.unit === j.DAY_TIME ? Li(e, t) : Ei(e, t), Li = ({ values: e }, t) => e.subarray(2 * t, 2 * (t + 1)), Ei = ({ values: e }, t) => {
+  const n = e[t], i = new Int32Array(2);
+  return i[0] = Math.trunc(n / 12), i[1] = Math.trunc(n % 12), i;
+}, Vi = ({ values: e }, t) => e.subarray(4 * t, 4 * (t + 1)), xi = ({ values: e }, t) => e[t], ki = ({ values: e }, t) => e[t], ji = ({ values: e }, t) => e[t], zi = ({ values: e }, t) => e[t], Zs = (e, t) => {
+  switch (e.type.unit) {
+    case y.SECOND:
+      return xi(e, t);
+    case y.MILLISECOND:
+      return ki(e, t);
+    case y.MICROSECOND:
+      return ji(e, t);
+    case y.NANOSECOND:
+      return zi(e, t);
+  }
+}, to = (e, t) => {
+  const { stride: n, children: i } = e, s = i[0].slice(t * n, n);
+  return new D([s]);
+};
+p.prototype.visitNull = b(xs);
+p.prototype.visitBool = b(ks);
+p.prototype.visitInt = b($s);
+p.prototype.visitInt8 = b(ct);
+p.prototype.visitInt16 = b(ct);
+p.prototype.visitInt32 = b(ct);
+p.prototype.visitInt64 = b(Si);
+p.prototype.visitUint8 = b(ct);
+p.prototype.visitUint16 = b(ct);
+p.prototype.visitUint32 = b(ct);
+p.prototype.visitUint64 = b(Si);
+p.prototype.visitFloat = b(Ps);
+p.prototype.visitFloat16 = b(js);
+p.prototype.visitFloat32 = b(ct);
+p.prototype.visitFloat64 = b(ct);
+p.prototype.visitUtf8 = b(Ai);
+p.prototype.visitLargeUtf8 = b(Ai);
+p.prototype.visitBinary = b(wi);
+p.prototype.visitLargeBinary = b(wi);
+p.prototype.visitFixedSizeBinary = b(zs);
+p.prototype.visitDate = b(Rs);
+p.prototype.visitDateDay = b(bi);
+p.prototype.visitDateMillisecond = b(Ii);
+p.prototype.visitTimestamp = b(Ys);
+p.prototype.visitTimestampSecond = b(Di);
+p.prototype.visitTimestampMillisecond = b(_i);
+p.prototype.visitTimestampMicrosecond = b(Bi);
+p.prototype.visitTimestampNanosecond = b(Ti);
+p.prototype.visitTime = b(Ws);
+p.prototype.visitTimeSecond = b(Oi);
+p.prototype.visitTimeMillisecond = b(Mi);
+p.prototype.visitTimeMicrosecond = b(Ni);
+p.prototype.visitTimeNanosecond = b(Ui);
+p.prototype.visitDecimal = b(Hs);
+p.prototype.visitList = b(Ks);
+p.prototype.visitStruct = b(Js);
+p.prototype.visitUnion = b(qs);
+p.prototype.visitDenseUnion = b(Ci);
+p.prototype.visitSparseUnion = b(Fi);
+p.prototype.visitDictionary = b(Qs);
+p.prototype.visitInterval = b(Xs);
+p.prototype.visitIntervalDayTime = b(Li);
+p.prototype.visitIntervalYearMonth = b(Ei);
+p.prototype.visitIntervalMonthDayNano = b(Vi);
+p.prototype.visitDuration = b(Zs);
+p.prototype.visitDurationSecond = b(xi);
+p.prototype.visitDurationMillisecond = b(ki);
+p.prototype.visitDurationMicrosecond = b(ji);
+p.prototype.visitDurationNanosecond = b(zi);
+p.prototype.visitFixedSizeList = b(to);
+p.prototype.visitMap = b(Gs);
+const $ = new p(), ut = Symbol.for("keys"), It = Symbol.for("vals"), gt = Symbol.for("kKeysAsStrings"), De = Symbol.for("_kKeysAsStrings");
+class se {
+  constructor(t) {
+    return this[ut] = new D([t.children[0]]).memoize(), this[It] = t.children[1], new Proxy(this, new no());
+  }
+  /** @ignore */
+  get [gt]() {
+    return this[De] || (this[De] = Array.from(this[ut].toArray(), String));
+  }
+  [Symbol.iterator]() {
+    return new eo(this[ut], this[It]);
+  }
+  get size() {
+    return this[ut].length;
+  }
+  toArray() {
+    return Object.values(this.toJSON());
+  }
+  toJSON() {
+    const t = this[ut], n = this[It], i = {};
+    for (let r = -1, s = t.length; ++r < s; )
+      i[t.get(r)] = $.visit(n, r);
+    return i;
+  }
+  toString() {
+    return `{${[...this].map(([t, n]) => `${lt(t)}: ${lt(n)}`).join(", ")}}`;
+  }
+  [Symbol.for("nodejs.util.inspect.custom")]() {
+    return this.toString();
+  }
+}
+class eo {
+  constructor(t, n) {
+    this.keys = t, this.vals = n, this.keyIndex = 0, this.numKeys = t.length;
+  }
+  [Symbol.iterator]() {
+    return this;
+  }
+  next() {
+    const t = this.keyIndex;
+    return t === this.numKeys ? { done: !0, value: null } : (this.keyIndex++, {
+      done: !1,
+      value: [
+        this.keys.get(t),
+        $.visit(this.vals, t)
+      ]
+    });
+  }
+}
+class no {
+  isExtensible() {
+    return !1;
+  }
+  deleteProperty() {
+    return !1;
+  }
+  preventExtensions() {
+    return !0;
+  }
+  ownKeys(t) {
+    return t[gt];
+  }
+  has(t, n) {
+    return t[gt].includes(n);
+  }
+  getOwnPropertyDescriptor(t, n) {
+    if (t[gt].indexOf(n) !== -1)
+      return { writable: !0, enumerable: !0, configurable: !0 };
+  }
+  get(t, n) {
+    if (Reflect.has(t, n))
+      return t[n];
+    const i = t[gt].indexOf(n);
+    if (i !== -1) {
+      const r = $.visit(Reflect.get(t, It), i);
+      return Reflect.set(t, n, r), r;
+    }
+  }
+  set(t, n, i) {
+    const r = t[gt].indexOf(n);
+    return r !== -1 ? (G.visit(Reflect.get(t, It), r, i), Reflect.set(t, n, i)) : Reflect.has(t, n) ? Reflect.set(t, n, i) : !1;
+  }
+}
+Object.defineProperties(se.prototype, {
+  [Symbol.toStringTag]: { enumerable: !1, configurable: !1, value: "Row" },
+  [ut]: { writable: !0, enumerable: !1, configurable: !1, value: null },
+  [It]: { writable: !0, enumerable: !1, configurable: !1, value: null },
+  [De]: { writable: !0, enumerable: !1, configurable: !1, value: null }
+});
+let mn;
+function Ze(e, t, n, i) {
+  const { length: r = 0 } = e;
+  let s = typeof t != "number" ? 0 : t, o = typeof n != "number" ? r : n;
+  return s < 0 && (s = (s % r + r) % r), o < 0 && (o = (o % r + r) % r), o < s && (mn = s, s = o, o = mn), o > r && (o = r), i ? i(e, s, o) : [s, o];
+}
+const oe = (e, t) => e < 0 ? t + e : e, vn = (e) => e !== e;
+function dt(e) {
+  if (typeof e !== "object" || e === null)
+    return vn(e) ? vn : (n) => n === e;
+  if (e instanceof Date) {
+    const n = e.valueOf();
+    return (i) => i instanceof Date ? i.valueOf() === n : !1;
+  }
+  return ArrayBuffer.isView(e) ? (n) => n ? _n(e, n) : !1 : e instanceof Map ? ro(e) : Array.isArray(e) ? io(e) : e instanceof D ? so(e) : oo(e, !0);
+}
+function io(e) {
+  const t = [];
+  for (let n = -1, i = e.length; ++n < i; )
+    t[n] = dt(e[n]);
+  return ae(t);
+}
+function ro(e) {
+  let t = -1;
+  const n = [];
+  for (const i of e.values())
+    n[++t] = dt(i);
+  return ae(n);
+}
+function so(e) {
+  const t = [];
+  for (let n = -1, i = e.length; ++n < i; )
+    t[n] = dt(e.get(n));
+  return ae(t);
+}
+function oo(e, t = !1) {
+  const n = Object.keys(e);
+  if (!t && n.length === 0)
+    return () => !1;
+  const i = [];
+  for (let r = -1, s = n.length; ++r < s; )
+    i[r] = dt(e[n[r]]);
+  return ae(i, n);
+}
+function ae(e, t) {
+  return (n) => {
+    if (!n || typeof n != "object")
+      return !1;
+    switch (n.constructor) {
+      case Array:
+        return ao(e, n);
+      case Map:
+        return bn(e, n, n.keys());
+      case se:
+      case Xe:
+      case Object:
+      case void 0:
+        return bn(e, n, t || Object.keys(n));
+    }
+    return n instanceof D ? lo(e, n) : !1;
+  };
+}
+function ao(e, t) {
+  const n = e.length;
+  if (t.length !== n)
+    return !1;
+  for (let i = -1; ++i < n; )
+    if (!e[i](t[i]))
+      return !1;
+  return !0;
+}
+function lo(e, t) {
+  const n = e.length;
+  if (t.length !== n)
+    return !1;
+  for (let i = -1; ++i < n; )
+    if (!e[i](t.get(i)))
+      return !1;
+  return !0;
+}
+function bn(e, t, n) {
+  const i = n[Symbol.iterator](), r = t instanceof Map ? t.keys() : Object.keys(t)[Symbol.iterator](), s = t instanceof Map ? t.values() : Object.values(t)[Symbol.iterator]();
+  let o = 0;
+  const a = e.length;
+  let c = s.next(), u = i.next(), d = r.next();
+  for (; o < a && !u.done && !d.done && !c.done && !(u.value !== d.value || !e[o](c.value)); ++o, u = i.next(), d = r.next(), c = s.next())
+    ;
+  return o === a && u.done && d.done && c.done ? !0 : (i.return && i.return(), r.return && r.return(), s.return && s.return(), !1);
+}
+const Ma = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  clampRange: Ze,
+  createElementComparator: dt,
+  wrapIndex: oe
+}, Symbol.toStringTag, { value: "Module" }));
+function tn(e, t, n, i) {
+  return (n & 1 << i) !== 0;
+}
+function $i(e, t, n, i) {
+  return (n & 1 << i) >> i;
+}
+function co(e, t, n) {
+  return n ? !!(e[t >> 3] |= 1 << t % 8) || !0 : !(e[t >> 3] &= ~(1 << t % 8)) && !1;
+}
+function _e(e, t, n) {
+  const i = n.byteLength + 7 & -8;
+  if (e > 0 || n.byteLength < i) {
+    const r = new Uint8Array(i);
+    return r.set(e % 8 === 0 ? n.subarray(e >> 3) : (
+      // Otherwise iterate each bit from the offset and return a new one
+      Pi(new le(n, e, t, null, tn)).subarray(0, i)
+    )), r;
+  }
+  return n;
+}
+function Pi(e) {
+  const t = [];
+  let n = 0, i = 0, r = 0;
+  for (const o of e)
+    o && (r |= 1 << i), ++i === 8 && (t[n++] = r, r = i = 0);
+  (n === 0 || i > 0) && (t[n++] = r);
+  const s = new Uint8Array(t.length + 7 & -8);
+  return s.set(t), s;
+}
+class le {
+  constructor(t, n, i, r, s) {
+    this.bytes = t, this.length = i, this.context = r, this.get = s, this.bit = n % 8, this.byteIndex = n >> 3, this.byte = t[this.byteIndex++], this.index = 0;
+  }
+  next() {
+    return this.index < this.length ? (this.bit === 8 && (this.bit = 0, this.byte = this.bytes[this.byteIndex++]), {
+      value: this.get(this.context, this.index++, this.byte, this.bit++)
+    }) : { done: !0, value: null };
+  }
+  [Symbol.iterator]() {
+    return this;
+  }
+}
+function Xt(e, t, n) {
+  if (n - t <= 0)
+    return 0;
+  if (n - t < 8) {
+    let s = 0;
+    for (const o of new le(e, t, n - t, e, $i))
+      s += o;
+    return s;
+  }
+  const i = n >> 3 << 3, r = t + (t % 8 === 0 ? 0 : 8 - t % 8);
+  return (
+    // Get the popcnt of bits between the left hand side, and the next highest multiple of 8
+    Xt(e, t, r) + // Get the popcnt of bits between the right hand side, and the next lowest multiple of 8
+    Xt(e, i, n) + // Get the popcnt of all bits between the left and right hand sides' multiples of 8
+    Ri(e, r >> 3, i - r >> 3)
+  );
+}
+function Ri(e, t, n) {
+  let i = 0, r = Math.trunc(t);
+  const s = new DataView(e.buffer, e.byteOffset, e.byteLength), o = n === void 0 ? e.byteLength : r + n;
+  for (; o - r >= 4; )
+    i += Ht(s.getUint32(r)), r += 4;
+  for (; o - r >= 2; )
+    i += Ht(s.getUint16(r)), r += 2;
+  for (; o - r >= 1; )
+    i += Ht(s.getUint8(r)), r += 1;
+  return i;
+}
+function Ht(e) {
+  let t = Math.trunc(e);
+  return t = t - (t >>> 1 & 1431655765), t = (t & 858993459) + (t >>> 2 & 858993459), (t + (t >>> 4) & 252645135) * 16843009 >>> 24;
+}
+const Na = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  BitIterator: le,
+  getBit: $i,
+  getBool: tn,
+  packBools: Pi,
+  popcnt_array: Ri,
+  popcnt_bit_range: Xt,
+  popcnt_uint32: Ht,
+  setBool: co,
+  truncateBitmap: _e
+}, Symbol.toStringTag, { value: "Module" })), uo = -1;
+class T {
+  get typeId() {
+    return this.type.typeId;
+  }
+  get ArrayType() {
+    return this.type.ArrayType;
+  }
+  get buffers() {
+    return [this.valueOffsets, this.values, this.nullBitmap, this.typeIds];
+  }
+  get nullable() {
+    if (this._nullCount !== 0) {
+      const { type: t } = this;
+      return A.isSparseUnion(t) ? this.children.some((n) => n.nullable) : A.isDenseUnion(t) ? this.children.some((n) => n.nullable) : this.nullBitmap && this.nullBitmap.byteLength > 0;
+    }
+    return !0;
+  }
+  get byteLength() {
+    let t = 0;
+    const { valueOffsets: n, values: i, nullBitmap: r, typeIds: s } = this;
+    return n && (t += n.byteLength), i && (t += i.byteLength), r && (t += r.byteLength), s && (t += s.byteLength), this.children.reduce((o, a) => o + a.byteLength, t);
+  }
+  get nullCount() {
+    if (A.isUnion(this.type))
+      return this.children.reduce((i, r) => i + r.nullCount, 0);
+    let t = this._nullCount, n;
+    return t <= uo && (n = this.nullBitmap) && (this._nullCount = t = n.length === 0 ? (
+      // no null bitmap, so all values are valid
+      0
+    ) : this.length - Xt(n, this.offset, this.offset + this.length)), t;
+  }
+  constructor(t, n, i, r, s, o = [], a) {
+    this.type = t, this.children = o, this.dictionary = a, this.offset = Math.floor(Math.max(n || 0, 0)), this.length = Math.floor(Math.max(i || 0, 0)), this._nullCount = Math.floor(Math.max(r || 0, -1));
+    let c;
+    s instanceof T ? (this.stride = s.stride, this.values = s.values, this.typeIds = s.typeIds, this.nullBitmap = s.nullBitmap, this.valueOffsets = s.valueOffsets) : (this.stride = X(t), s && ((c = s[0]) && (this.valueOffsets = c), (c = s[1]) && (this.values = c), (c = s[2]) && (this.nullBitmap = c), (c = s[3]) && (this.typeIds = c)));
+  }
+  getValid(t) {
+    const { type: n } = this;
+    if (A.isUnion(n)) {
+      const i = n, r = this.children[i.typeIdToChildIndex[this.typeIds[t]]], s = i.mode === K.Dense ? this.valueOffsets[t] : t;
+      return r.getValid(s);
+    }
+    if (this.nullable && this.nullCount > 0) {
+      const i = this.offset + t;
+      return (this.nullBitmap[i >> 3] & 1 << i % 8) !== 0;
+    }
+    return !0;
+  }
+  setValid(t, n) {
+    let i;
+    const { type: r } = this;
+    if (A.isUnion(r)) {
+      const s = r, o = this.children[s.typeIdToChildIndex[this.typeIds[t]]], a = s.mode === K.Dense ? this.valueOffsets[t] : t;
+      i = o.getValid(a), o.setValid(a, n);
+    } else {
+      let { nullBitmap: s } = this;
+      const { offset: o, length: a } = this, c = o + t, u = 1 << c % 8, d = c >> 3;
+      (!s || s.byteLength <= d) && (s = new Uint8Array((o + a + 63 & -64) >> 3).fill(255), this.nullCount > 0 ? (s.set(_e(o, a, this.nullBitmap), 0), Object.assign(this, { nullBitmap: s })) : Object.assign(this, { nullBitmap: s, _nullCount: 0 }));
+      const h = s[d];
+      i = (h & u) !== 0, s[d] = n ? h | u : h & ~u;
+    }
+    return i !== !!n && (this._nullCount = this.nullCount + (n ? -1 : 1)), n;
+  }
+  clone(t = this.type, n = this.offset, i = this.length, r = this._nullCount, s = this, o = this.children) {
+    return new T(t, n, i, r, s, o, this.dictionary);
+  }
+  slice(t, n) {
+    const { stride: i, typeId: r, children: s } = this, o = +(this._nullCount === 0) - 1, a = r === 16 ? i : 1, c = this._sliceBuffers(t, n, i, r);
+    return this.clone(
+      this.type,
+      this.offset + t,
+      n,
+      o,
+      c,
+      // Don't slice children if we have value offsets (the variable-width types)
+      s.length === 0 || this.valueOffsets ? s : this._sliceChildren(s, a * t, a * n)
+    );
+  }
+  _changeLengthAndBackfillNullBitmap(t) {
+    if (this.typeId === l.Null)
+      return this.clone(this.type, 0, t, 0);
+    const { length: n, nullCount: i } = this, r = new Uint8Array((t + 63 & -64) >> 3).fill(255, 0, n >> 3);
+    r[n >> 3] = (1 << n - (n & -8)) - 1, i > 0 && r.set(_e(this.offset, n, this.nullBitmap), 0);
+    const s = this.buffers;
+    return s[it.VALIDITY] = r, this.clone(this.type, 0, t, i + (t - n), s);
+  }
+  _sliceBuffers(t, n, i, r) {
+    let s;
+    const { buffers: o } = this;
+    return (s = o[it.TYPE]) && (o[it.TYPE] = s.subarray(t, t + n)), (s = o[it.OFFSET]) && (o[it.OFFSET] = s.subarray(t, t + n + 1)) || // Otherwise if no offsets, slice the data buffer. Don't slice the data vector for Booleans, since the offset goes by bits not bytes
+    (s = o[it.DATA]) && (o[it.DATA] = r === 6 ? s : s.subarray(i * t, i * (t + n))), o;
+  }
+  _sliceChildren(t, n, i) {
+    return t.map((r) => r.slice(n, i));
+  }
+}
+T.prototype.children = Object.freeze([]);
+class Ut extends _ {
+  visit(t) {
+    return this.getVisitFn(t.type).call(this, t);
+  }
+  visitNull(t) {
+    const { ["type"]: n, ["offset"]: i = 0, ["length"]: r = 0 } = t;
+    return new T(n, i, r, r);
+  }
+  visitBool(t) {
+    const { ["type"]: n, ["offset"]: i = 0 } = t, r = N(t.nullBitmap), s = O(n.ArrayType, t.data), { ["length"]: o = s.length >> 3, ["nullCount"]: a = t.nullBitmap ? -1 : 0 } = t;
+    return new T(n, i, o, a, [void 0, s, r]);
+  }
+  visitInt(t) {
+    const { ["type"]: n, ["offset"]: i = 0 } = t, r = N(t.nullBitmap), s = O(n.ArrayType, t.data), { ["length"]: o = s.length, ["nullCount"]: a = t.nullBitmap ? -1 : 0 } = t;
+    return new T(n, i, o, a, [void 0, s, r]);
+  }
+  visitFloat(t) {
+    const { ["type"]: n, ["offset"]: i = 0 } = t, r = N(t.nullBitmap), s = O(n.ArrayType, t.data), { ["length"]: o = s.length, ["nullCount"]: a = t.nullBitmap ? -1 : 0 } = t;
+    return new T(n, i, o, a, [void 0, s, r]);
+  }
+  visitUtf8(t) {
+    const { ["type"]: n, ["offset"]: i = 0 } = t, r = N(t.data), s = N(t.nullBitmap), o = pt(t.valueOffsets), { ["length"]: a = o.length - 1, ["nullCount"]: c = t.nullBitmap ? -1 : 0 } = t;
+    return new T(n, i, a, c, [o, r, s]);
+  }
+  visitLargeUtf8(t) {
+    const { ["type"]: n, ["offset"]: i = 0 } = t, r = N(t.data), s = N(t.nullBitmap), o = me(t.valueOffsets), { ["length"]: a = o.length - 1, ["nullCount"]: c = t.nullBitmap ? -1 : 0 } = t;
+    return new T(n, i, a, c, [o, r, s]);
+  }
+  visitBinary(t) {
+    const { ["type"]: n, ["offset"]: i = 0 } = t, r = N(t.data), s = N(t.nullBitmap), o = pt(t.valueOffsets), { ["length"]: a = o.length - 1, ["nullCount"]: c = t.nullBitmap ? -1 : 0 } = t;
+    return new T(n, i, a, c, [o, r, s]);
+  }
+  visitLargeBinary(t) {
+    const { ["type"]: n, ["offset"]: i = 0 } = t, r = N(t.data), s = N(t.nullBitmap), o = me(t.valueOffsets), { ["length"]: a = o.length - 1, ["nullCount"]: c = t.nullBitmap ? -1 : 0 } = t;
+    return new T(n, i, a, c, [o, r, s]);
+  }
+  visitFixedSizeBinary(t) {
+    const { ["type"]: n, ["offset"]: i = 0 } = t, r = N(t.nullBitmap), s = O(n.ArrayType, t.data), { ["length"]: o = s.length / X(n), ["nullCount"]: a = t.nullBitmap ? -1 : 0 } = t;
+    return new T(n, i, o, a, [void 0, s, r]);
+  }
+  visitDate(t) {
+    const { ["type"]: n, ["offset"]: i = 0 } = t, r = N(t.nullBitmap), s = O(n.ArrayType, t.data), { ["length"]: o = s.length / X(n), ["nullCount"]: a = t.nullBitmap ? -1 : 0 } = t;
+    return new T(n, i, o, a, [void 0, s, r]);
+  }
+  visitTimestamp(t) {
+    const { ["type"]: n, ["offset"]: i = 0 } = t, r = N(t.nullBitmap), s = O(n.ArrayType, t.data), { ["length"]: o = s.length / X(n), ["nullCount"]: a = t.nullBitmap ? -1 : 0 } = t;
+    return new T(n, i, o, a, [void 0, s, r]);
+  }
+  visitTime(t) {
+    const { ["type"]: n, ["offset"]: i = 0 } = t, r = N(t.nullBitmap), s = O(n.ArrayType, t.data), { ["length"]: o = s.length / X(n), ["nullCount"]: a = t.nullBitmap ? -1 : 0 } = t;
+    return new T(n, i, o, a, [void 0, s, r]);
+  }
+  visitDecimal(t) {
+    const { ["type"]: n, ["offset"]: i = 0 } = t, r = N(t.nullBitmap), s = O(n.ArrayType, t.data), { ["length"]: o = s.length / X(n), ["nullCount"]: a = t.nullBitmap ? -1 : 0 } = t;
+    return new T(n, i, o, a, [void 0, s, r]);
+  }
+  visitList(t) {
+    const { ["type"]: n, ["offset"]: i = 0, ["child"]: r } = t, s = N(t.nullBitmap), o = pt(t.valueOffsets), { ["length"]: a = o.length - 1, ["nullCount"]: c = t.nullBitmap ? -1 : 0 } = t;
+    return new T(n, i, a, c, [o, void 0, s], [r]);
+  }
+  visitStruct(t) {
+    const { ["type"]: n, ["offset"]: i = 0, ["children"]: r = [] } = t, s = N(t.nullBitmap), { length: o = r.reduce((c, { length: u }) => Math.max(c, u), 0), nullCount: a = t.nullBitmap ? -1 : 0 } = t;
+    return new T(n, i, o, a, [void 0, void 0, s], r);
+  }
+  visitUnion(t) {
+    const { ["type"]: n, ["offset"]: i = 0, ["children"]: r = [] } = t, s = O(n.ArrayType, t.typeIds), { ["length"]: o = s.length, ["nullCount"]: a = -1 } = t;
+    if (A.isSparseUnion(n))
+      return new T(n, i, o, a, [void 0, void 0, void 0, s], r);
+    const c = pt(t.valueOffsets);
+    return new T(n, i, o, a, [c, void 0, void 0, s], r);
+  }
+  visitDictionary(t) {
+    const { ["type"]: n, ["offset"]: i = 0 } = t, r = N(t.nullBitmap), s = O(n.indices.ArrayType, t.data), { ["dictionary"]: o = new D([new Ut().visit({ type: n.dictionary })]) } = t, { ["length"]: a = s.length, ["nullCount"]: c = t.nullBitmap ? -1 : 0 } = t;
+    return new T(n, i, a, c, [void 0, s, r], [], o);
+  }
+  visitInterval(t) {
+    const { ["type"]: n, ["offset"]: i = 0 } = t, r = N(t.nullBitmap), s = O(n.ArrayType, t.data), { ["length"]: o = s.length / X(n), ["nullCount"]: a = t.nullBitmap ? -1 : 0 } = t;
+    return new T(n, i, o, a, [void 0, s, r]);
+  }
+  visitDuration(t) {
+    const { ["type"]: n, ["offset"]: i = 0 } = t, r = N(t.nullBitmap), s = O(n.ArrayType, t.data), { ["length"]: o = s.length, ["nullCount"]: a = t.nullBitmap ? -1 : 0 } = t;
+    return new T(n, i, o, a, [void 0, s, r]);
+  }
+  visitFixedSizeList(t) {
+    const { ["type"]: n, ["offset"]: i = 0, ["child"]: r = new Ut().visit({ type: n.valueType }) } = t, s = N(t.nullBitmap), { ["length"]: o = r.length / X(n), ["nullCount"]: a = t.nullBitmap ? -1 : 0 } = t;
+    return new T(n, i, o, a, [void 0, void 0, s], [r]);
+  }
+  visitMap(t) {
+    const { ["type"]: n, ["offset"]: i = 0, ["child"]: r = new Ut().visit({ type: n.childType }) } = t, s = N(t.nullBitmap), o = pt(t.valueOffsets), { ["length"]: a = o.length - 1, ["nullCount"]: c = t.nullBitmap ? -1 : 0 } = t;
+    return new T(n, i, a, c, [o, void 0, s], [r]);
+  }
+}
+const ho = new Ut();
+function M(e) {
+  return ho.visit(e);
+}
+class In {
+  constructor(t = 0, n) {
+    this.numChunks = t, this.getChunkIterator = n, this.chunkIndex = 0, this.chunkIterator = this.getChunkIterator(0);
+  }
+  next() {
+    for (; this.chunkIndex < this.numChunks; ) {
+      const t = this.chunkIterator.next();
+      if (!t.done)
+        return t;
+      ++this.chunkIndex < this.numChunks && (this.chunkIterator = this.getChunkIterator(this.chunkIndex));
+    }
+    return { done: !0, value: null };
+  }
+  [Symbol.iterator]() {
+    return this;
+  }
+}
+function yo(e) {
+  return e.some((t) => t.nullable);
+}
+function Yi(e) {
+  return e.reduce((t, n) => t + n.nullCount, 0);
+}
+function Wi(e) {
+  return e.reduce((t, n, i) => (t[i + 1] = t[i] + n.length, t), new Uint32Array(e.length + 1));
+}
+function Hi(e, t, n, i) {
+  const r = [];
+  for (let s = -1, o = e.length; ++s < o; ) {
+    const a = e[s], c = t[s], { length: u } = a;
+    if (c >= i)
+      break;
+    if (n >= c + u)
+      continue;
+    if (c >= n && c + u <= i) {
+      r.push(a);
+      continue;
+    }
+    const d = Math.max(0, n - c), h = Math.min(i - c, u);
+    r.push(a.slice(d, h - d));
+  }
+  return r.length === 0 && r.push(e[0].slice(0, 0)), r;
+}
+function en(e, t, n, i) {
+  let r = 0, s = 0, o = t.length - 1;
+  do {
+    if (r >= o - 1)
+      return n < t[o] ? i(e, r, n - t[r]) : null;
+    s = r + Math.trunc((o - r) * 0.5), n < t[s] ? o = s : r = s;
+  } while (r < o);
+}
+function nn(e, t) {
+  return e.getValid(t);
+}
+function Zt(e) {
+  function t(n, i, r) {
+    return e(n[i], r);
+  }
+  return function(n) {
+    const i = this.data;
+    return en(i, this._offsets, n, t);
+  };
+}
+function Ki(e) {
+  let t;
+  function n(i, r, s) {
+    return e(i[r], s, t);
+  }
+  return function(i, r) {
+    const s = this.data;
+    t = r;
+    const o = en(s, this._offsets, i, n);
+    return t = void 0, o;
+  };
+}
+function Gi(e) {
+  let t;
+  function n(i, r, s) {
+    let o = s, a = 0, c = 0;
+    for (let u = r - 1, d = i.length; ++u < d; ) {
+      const h = i[u];
+      if (~(a = e(h, t, o)))
+        return c + a;
+      o = 0, c += h.length;
+    }
+    return -1;
+  }
+  return function(i, r) {
+    t = i;
+    const s = this.data, o = typeof r != "number" ? n(s, 0, 0) : en(s, this._offsets, r, n);
+    return t = void 0, o;
+  };
+}
+class f extends _ {
+}
+function po(e, t) {
+  return t === null && e.length > 0 ? 0 : -1;
+}
+function fo(e, t) {
+  const { nullBitmap: n } = e;
+  if (!n || e.nullCount <= 0)
+    return -1;
+  let i = 0;
+  for (const r of new le(n, e.offset + (t || 0), e.length, n, tn)) {
+    if (!r)
+      return i;
+    ++i;
+  }
+  return -1;
+}
+function w(e, t, n) {
+  if (t === void 0)
+    return -1;
+  if (t === null)
+    switch (e.typeId) {
+      // Unions don't have a nullBitmap of its own, so compare the `searchElement` to `get()`.
+      case l.Union:
+        break;
+      // Dictionaries do have a nullBitmap, but their dictionary could also have null elements.
+      case l.Dictionary:
+        break;
+      // All other types can iterate the null bitmap
+      default:
+        return fo(e, n);
+    }
+  const i = $.getVisitFn(e), r = dt(t);
+  for (let s = (n || 0) - 1, o = e.length; ++s < o; )
+    if (r(i(e, s)))
+      return s;
+  return -1;
+}
+function Ji(e, t, n) {
+  const i = $.getVisitFn(e), r = dt(t);
+  for (let s = (n || 0) - 1, o = e.length; ++s < o; )
+    if (r(i(e, s)))
+      return s;
+  return -1;
+}
+f.prototype.visitNull = po;
+f.prototype.visitBool = w;
+f.prototype.visitInt = w;
+f.prototype.visitInt8 = w;
+f.prototype.visitInt16 = w;
+f.prototype.visitInt32 = w;
+f.prototype.visitInt64 = w;
+f.prototype.visitUint8 = w;
+f.prototype.visitUint16 = w;
+f.prototype.visitUint32 = w;
+f.prototype.visitUint64 = w;
+f.prototype.visitFloat = w;
+f.prototype.visitFloat16 = w;
+f.prototype.visitFloat32 = w;
+f.prototype.visitFloat64 = w;
+f.prototype.visitUtf8 = w;
+f.prototype.visitLargeUtf8 = w;
+f.prototype.visitBinary = w;
+f.prototype.visitLargeBinary = w;
+f.prototype.visitFixedSizeBinary = w;
+f.prototype.visitDate = w;
+f.prototype.visitDateDay = w;
+f.prototype.visitDateMillisecond = w;
+f.prototype.visitTimestamp = w;
+f.prototype.visitTimestampSecond = w;
+f.prototype.visitTimestampMillisecond = w;
+f.prototype.visitTimestampMicrosecond = w;
+f.prototype.visitTimestampNanosecond = w;
+f.prototype.visitTime = w;
+f.prototype.visitTimeSecond = w;
+f.prototype.visitTimeMillisecond = w;
+f.prototype.visitTimeMicrosecond = w;
+f.prototype.visitTimeNanosecond = w;
+f.prototype.visitDecimal = w;
+f.prototype.visitList = w;
+f.prototype.visitStruct = w;
+f.prototype.visitUnion = w;
+f.prototype.visitDenseUnion = Ji;
+f.prototype.visitSparseUnion = Ji;
+f.prototype.visitDictionary = w;
+f.prototype.visitInterval = w;
+f.prototype.visitIntervalDayTime = w;
+f.prototype.visitIntervalYearMonth = w;
+f.prototype.visitIntervalMonthDayNano = w;
+f.prototype.visitDuration = w;
+f.prototype.visitDurationSecond = w;
+f.prototype.visitDurationMillisecond = w;
+f.prototype.visitDurationMicrosecond = w;
+f.prototype.visitDurationNanosecond = w;
+f.prototype.visitFixedSizeList = w;
+f.prototype.visitMap = w;
+const te = new f();
+class g extends _ {
+}
+function I(e) {
+  const { type: t } = e;
+  if (e.nullCount === 0 && e.stride === 1 && // Don't defer to native iterator for timestamps since Numbers are expected
+  // (DataType.isTimestamp(type)) && type.unit === TimeUnit.MILLISECOND ||
+  (A.isInt(t) && t.bitWidth !== 64 || A.isTime(t) && t.bitWidth !== 64 || A.isFloat(t) && t.precision !== x.HALF))
+    return new In(e.data.length, (i) => {
+      const r = e.data[i];
+      return r.values.subarray(0, r.length)[Symbol.iterator]();
+    });
+  let n = 0;
+  return new In(e.data.length, (i) => {
+    const s = e.data[i].length, o = e.slice(n, n + s);
+    return n += s, new go(o);
+  });
+}
+class go {
+  constructor(t) {
+    this.vector = t, this.index = 0;
+  }
+  next() {
+    return this.index < this.vector.length ? {
+      value: this.vector.get(this.index++)
+    } : { done: !0, value: null };
+  }
+  [Symbol.iterator]() {
+    return this;
+  }
+}
+g.prototype.visitNull = I;
+g.prototype.visitBool = I;
+g.prototype.visitInt = I;
+g.prototype.visitInt8 = I;
+g.prototype.visitInt16 = I;
+g.prototype.visitInt32 = I;
+g.prototype.visitInt64 = I;
+g.prototype.visitUint8 = I;
+g.prototype.visitUint16 = I;
+g.prototype.visitUint32 = I;
+g.prototype.visitUint64 = I;
+g.prototype.visitFloat = I;
+g.prototype.visitFloat16 = I;
+g.prototype.visitFloat32 = I;
+g.prototype.visitFloat64 = I;
+g.prototype.visitUtf8 = I;
+g.prototype.visitLargeUtf8 = I;
+g.prototype.visitBinary = I;
+g.prototype.visitLargeBinary = I;
+g.prototype.visitFixedSizeBinary = I;
+g.prototype.visitDate = I;
+g.prototype.visitDateDay = I;
+g.prototype.visitDateMillisecond = I;
+g.prototype.visitTimestamp = I;
+g.prototype.visitTimestampSecond = I;
+g.prototype.visitTimestampMillisecond = I;
+g.prototype.visitTimestampMicrosecond = I;
+g.prototype.visitTimestampNanosecond = I;
+g.prototype.visitTime = I;
+g.prototype.visitTimeSecond = I;
+g.prototype.visitTimeMillisecond = I;
+g.prototype.visitTimeMicrosecond = I;
+g.prototype.visitTimeNanosecond = I;
+g.prototype.visitDecimal = I;
+g.prototype.visitList = I;
+g.prototype.visitStruct = I;
+g.prototype.visitUnion = I;
+g.prototype.visitDenseUnion = I;
+g.prototype.visitSparseUnion = I;
+g.prototype.visitDictionary = I;
+g.prototype.visitInterval = I;
+g.prototype.visitIntervalDayTime = I;
+g.prototype.visitIntervalYearMonth = I;
+g.prototype.visitIntervalMonthDayNano = I;
+g.prototype.visitDuration = I;
+g.prototype.visitDurationSecond = I;
+g.prototype.visitDurationMillisecond = I;
+g.prototype.visitDurationMicrosecond = I;
+g.prototype.visitDurationNanosecond = I;
+g.prototype.visitFixedSizeList = I;
+g.prototype.visitMap = I;
+const rn = new g();
+var qi;
+const Qi = {}, Xi = {};
+class D {
+  constructor(t) {
+    var n, i, r;
+    const s = t[0] instanceof D ? t.flatMap((a) => a.data) : t;
+    if (s.length === 0 || s.some((a) => !(a instanceof T)))
+      throw new TypeError("Vector constructor expects an Array of Data instances.");
+    const o = (n = s[0]) === null || n === void 0 ? void 0 : n.type;
+    switch (s.length) {
+      case 0:
+        this._offsets = [0];
+        break;
+      case 1: {
+        const { get: a, set: c, indexOf: u } = Qi[o.typeId], d = s[0];
+        this.isValid = (h) => nn(d, h), this.get = (h) => a(d, h), this.set = (h, U) => c(d, h, U), this.indexOf = (h) => u(d, h), this._offsets = [0, d.length];
+        break;
+      }
+      default:
+        Object.setPrototypeOf(this, Xi[o.typeId]), this._offsets = Wi(s);
+        break;
+    }
+    this.data = s, this.type = o, this.stride = X(o), this.numChildren = (r = (i = o.children) === null || i === void 0 ? void 0 : i.length) !== null && r !== void 0 ? r : 0, this.length = this._offsets.at(-1);
+  }
+  /**
+   * The aggregate size (in bytes) of this Vector's buffers and/or child Vectors.
+   */
+  get byteLength() {
+    return this.data.reduce((t, n) => t + n.byteLength, 0);
+  }
+  /**
+   * Whether this Vector's elements can contain null values.
+   */
+  get nullable() {
+    return yo(this.data);
+  }
+  /**
+   * The number of null elements in this Vector.
+   */
+  get nullCount() {
+    return Yi(this.data);
+  }
+  /**
+   * The Array or TypedArray constructor used for the JS representation
+   *  of the element's values in {@link Vector.prototype.toArray `toArray()`}.
+   */
+  get ArrayType() {
+    return this.type.ArrayType;
+  }
+  /**
+   * The name that should be printed when the Vector is logged in a message.
+   */
+  get [Symbol.toStringTag]() {
+    return `${this.VectorName}<${this.type[Symbol.toStringTag]}>`;
+  }
+  /**
+   * The name of this Vector.
+   */
+  get VectorName() {
+    return `${l[this.type.typeId]}Vector`;
+  }
+  /**
+   * Check whether an element is null.
+   * @param index The index at which to read the validity bitmap.
+   */
+  // @ts-ignore
+  isValid(t) {
+    return !1;
+  }
+  /**
+   * Get an element value by position.
+   * @param index The index of the element to read.
+   */
+  // @ts-ignore
+  get(t) {
+    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(t) {
+    return this.get(oe(t, this.length));
+  }
+  /**
+   * Set an element value by position.
+   * @param index The index of the element to write.
+   * @param value The value to set.
+   */
+  // @ts-ignore
+  set(t, n) {
+  }
+  /**
+   * Retrieve the index of the first occurrence of a value in an Vector.
+   * @param element The value to locate in the Vector.
+   * @param offset The index at which to begin the search. If offset is omitted, the search starts at index 0.
+   */
+  // @ts-ignore
+  indexOf(t, n) {
+    return -1;
+  }
+  includes(t, n) {
+    return this.indexOf(t, n) > -1;
+  }
+  /**
+   * Iterator for the Vector's elements.
+   */
+  [Symbol.iterator]() {
+    return rn.visit(this);
+  }
+  /**
+   * Combines two or more Vectors of the same type.
+   * @param others Additional Vectors to add to the end of this Vector.
+   */
+  concat(...t) {
+    return new D(this.data.concat(t.flatMap((n) => n.data).flat(Number.POSITIVE_INFINITY)));
+  }
+  /**
+   * Return a zero-copy sub-section of this Vector.
+   * @param start The beginning of the specified portion of the Vector.
+   * @param end The end of the specified portion of the Vector. This is exclusive of the element at the index 'end'.
+   */
+  slice(t, n) {
+    return new D(Ze(this, t, n, ({ data: i, _offsets: r }, s, o) => Hi(i, r, s, o)));
+  }
+  toJSON() {
+    return [...this];
+  }
+  /**
+   * Return a JavaScript Array or TypedArray of the Vector's elements.
+   *
+   * @note If this Vector contains a single Data chunk and the Vector's type is a
+   *  primitive numeric type corresponding to one of the JavaScript TypedArrays, this
+   *  method returns a zero-copy slice of the underlying TypedArray values. If there's
+   *  more than one chunk, the resulting TypedArray will be a copy of the data from each
+   *  chunk's underlying TypedArray values.
+   *
+   * @returns An Array or TypedArray of the Vector's elements, based on the Vector's DataType.
+   */
+  toArray() {
+    const { type: t, data: n, length: i, stride: r, ArrayType: s } = this;
+    switch (t.typeId) {
+      case l.Int:
+      case l.Float:
+      case l.Decimal:
+      case l.Time:
+      case l.Timestamp:
+        switch (n.length) {
+          case 0:
+            return new s();
+          case 1:
+            return n[0].values.subarray(0, i * r);
+          default:
+            return n.reduce((o, { values: a, length: c }) => (o.array.set(a.subarray(0, c * r), o.offset), o.offset += c * r, o), { array: new s(i * r), offset: 0 }).array;
+        }
+    }
+    return [...this];
+  }
+  /**
+   * Returns a string representation of the Vector.
+   *
+   * @returns A string representation of the Vector.
+   */
+  toString() {
+    return `[${[...this].join(",")}]`;
+  }
+  /**
+   * Returns a child Vector by name, or null if this Vector has no child with the given name.
+   * @param name The name of the child to retrieve.
+   */
+  getChild(t) {
+    var n;
+    return this.getChildAt((n = this.type.children) === null || n === void 0 ? void 0 : n.findIndex((i) => i.name === t));
+  }
+  /**
+   * Returns a child Vector by index, or null if this Vector has no child at the supplied index.
+   * @param index The index of the child to retrieve.
+   */
+  getChildAt(t) {
+    return t > -1 && t < this.numChildren ? new D(this.data.map(({ children: n }) => n[t])) : null;
+  }
+  get isMemoized() {
+    return A.isDictionary(this.type) ? this.data[0].dictionary.isMemoized : !1;
+  }
+  /**
+   * Adds memoization to the Vector's {@link get} method. For dictionary
+   * vectors, this method return a vector that memoizes only the dictionary
+   * values.
+   *
+   * Memoization is very useful when decoding a value is expensive such as
+   * Utf8. The memoization creates a cache of the size of the Vector and
+   * therefore increases memory usage.
+   *
+   * @returns A new vector that memoizes calls to {@link get}.
+   */
+  memoize() {
+    if (A.isDictionary(this.type)) {
+      const t = new ee(this.data[0].dictionary), n = this.data.map((i) => {
+        const r = i.clone();
+        return r.dictionary = t, r;
+      });
+      return new D(n);
+    }
+    return new ee(this);
+  }
+  /**
+   * Returns a vector without memoization of the {@link get} method. If this
+   * vector is not memoized, this method returns this vector.
+   *
+   * @returns A new vector without memoization.
+   */
+  unmemoize() {
+    if (A.isDictionary(this.type) && this.isMemoized) {
+      const t = this.data[0].dictionary.unmemoize(), n = this.data.map((i) => {
+        const r = i.clone();
+        return r.dictionary = t, r;
+      });
+      return new D(n);
+    }
+    return this;
+  }
+}
+qi = Symbol.toStringTag;
+D[qi] = ((e) => {
+  e.type = A.prototype, e.data = [], e.length = 0, e.stride = 1, e.numChildren = 0, e._offsets = new Uint32Array([0]), e[Symbol.isConcatSpreadable] = !0;
+  const t = Object.keys(l).map((n) => l[n]).filter((n) => typeof n == "number" && n !== l.NONE);
+  for (const n of t) {
+    const i = $.getVisitFnByTypeId(n), r = G.getVisitFnByTypeId(n), s = te.getVisitFnByTypeId(n);
+    Qi[n] = { get: i, set: r, indexOf: s }, Xi[n] = Object.create(e, {
+      isValid: { value: Zt(nn) },
+      get: { value: Zt($.getVisitFnByTypeId(n)) },
+      set: { value: Ki(G.getVisitFnByTypeId(n)) },
+      indexOf: { value: Gi(te.getVisitFnByTypeId(n)) }
+    });
+  }
+  return "Vector";
+})(D.prototype);
+class ee extends D {
+  constructor(t) {
+    super(t.data);
+    const n = this.get, i = this.set, r = this.slice, s = new Array(this.length);
+    Object.defineProperty(this, "get", {
+      value(o) {
+        const a = s[o];
+        if (a !== void 0)
+          return a;
+        const c = n.call(this, o);
+        return s[o] = c, c;
+      }
+    }), Object.defineProperty(this, "set", {
+      value(o, a) {
+        i.call(this, o, a), s[o] = a;
+      }
+    }), Object.defineProperty(this, "slice", {
+      value: (o, a) => new ee(r.call(this, o, a))
+    }), Object.defineProperty(this, "isMemoized", { value: !0 }), Object.defineProperty(this, "unmemoize", {
+      value: () => new D(this.data)
+    }), Object.defineProperty(this, "memoize", {
+      value: () => this
+    });
+  }
+}
+function sn(e) {
+  if (e) {
+    if (e instanceof T)
+      return new D([e]);
+    if (e instanceof D)
+      return new D(e.data);
+    if (e.type instanceof A)
+      return new D([M(e)]);
+    if (Array.isArray(e))
+      return new D(e.flatMap((t) => mo(t)));
+    if (ArrayBuffer.isView(e)) {
+      e instanceof DataView && (e = new Uint8Array(e.buffer));
+      const t = { offset: 0, length: e.length, nullCount: -1, data: e };
+      if (e instanceof Int8Array)
+        return new D([M(Object.assign(Object.assign({}, t), { type: new Qn() }))]);
+      if (e instanceof Int16Array)
+        return new D([M(Object.assign(Object.assign({}, t), { type: new Xn() }))]);
+      if (e instanceof Int32Array)
+        return new D([M(Object.assign(Object.assign({}, t), { type: new Me() }))]);
+      if (e instanceof BigInt64Array)
+        return new D([M(Object.assign(Object.assign({}, t), { type: new Ne() }))]);
+      if (e instanceof Uint8Array || e instanceof Uint8ClampedArray)
+        return new D([M(Object.assign(Object.assign({}, t), { type: new Zn() }))]);
+      if (e instanceof Uint16Array)
+        return new D([M(Object.assign(Object.assign({}, t), { type: new ti() }))]);
+      if (e instanceof Uint32Array)
+        return new D([M(Object.assign(Object.assign({}, t), { type: new ei() }))]);
+      if (e instanceof BigUint64Array)
+        return new D([M(Object.assign(Object.assign({}, t), { type: new ni() }))]);
+      if (e instanceof Float32Array)
+        return new D([M(Object.assign(Object.assign({}, t), { type: new ii() }))]);
+      if (e instanceof Float64Array)
+        return new D([M(Object.assign(Object.assign({}, t), { type: new Ue() }))]);
+      throw new Error("Unrecognized input");
+    }
+  }
+  throw new Error("Unrecognized input");
+}
+function mo(e) {
+  return e instanceof T ? [e] : e instanceof D ? e.data : sn(e).data;
+}
+function vo(e) {
+  if (!e || e.length <= 0)
+    return function(r) {
+      return !0;
+    };
+  let t = "";
+  const n = e.filter((i) => i === i);
+  return n.length > 0 && (t = `
+    switch (x) {${n.map((i) => `
+        case ${bo(i)}:`).join("")}
+            return false;
+    }`), e.length !== n.length && (t = `if (x !== x) return false;
+${t}`), new Function("x", `${t}
+return true;`);
+}
+function bo(e) {
+  return typeof e != "bigint" ? lt(e) : `${lt(e)}n`;
+}
+function fe(e, t) {
+  const n = Math.ceil(e) * t - 1;
+  return (n - n % 64 + 64 || 64) / t;
+}
+function Sn(e, t = 0) {
+  return e.length >= t ? e.subarray(0, t) : Gt(new e.constructor(t), e, 0);
+}
+class kt {
+  constructor(t, n = 0, i = 1) {
+    this.length = Math.ceil(n / i), this.buffer = new t(this.length), this.stride = i, this.BYTES_PER_ELEMENT = t.BYTES_PER_ELEMENT, this.ArrayType = t;
+  }
+  get byteLength() {
+    return Math.ceil(this.length * this.stride) * this.BYTES_PER_ELEMENT;
+  }
+  get reservedLength() {
+    return this.buffer.length / this.stride;
+  }
+  get reservedByteLength() {
+    return this.buffer.byteLength;
+  }
+  // @ts-ignore
+  set(t, n) {
+    return this;
+  }
+  append(t) {
+    return this.set(this.length, t);
+  }
+  reserve(t) {
+    if (t > 0) {
+      this.length += t;
+      const n = this.stride, i = this.length * n, r = this.buffer.length;
+      i >= r && this._resize(r === 0 ? fe(i * 1, this.BYTES_PER_ELEMENT) : fe(i * 2, this.BYTES_PER_ELEMENT));
+    }
+    return this;
+  }
+  flush(t = this.length) {
+    t = fe(t * this.stride, this.BYTES_PER_ELEMENT);
+    const n = Sn(this.buffer, t);
+    return this.clear(), n;
+  }
+  clear() {
+    return this.length = 0, this.buffer = new this.ArrayType(), this;
+  }
+  _resize(t) {
+    return this.buffer = Sn(this.buffer, t);
+  }
+}
+class jt extends kt {
+  last() {
+    return this.get(this.length - 1);
+  }
+  get(t) {
+    return this.buffer[t];
+  }
+  set(t, n) {
+    return this.reserve(t - this.length + 1), this.buffer[t * this.stride] = n, this;
+  }
+}
+class Zi extends jt {
+  constructor() {
+    super(Uint8Array, 0, 1 / 8), this.numValid = 0;
+  }
+  get numInvalid() {
+    return this.length - this.numValid;
+  }
+  get(t) {
+    return this.buffer[t >> 3] >> t % 8 & 1;
+  }
+  set(t, n) {
+    const { buffer: i } = this.reserve(t - this.length + 1), r = t >> 3, s = t % 8, o = i[r] >> s & 1;
+    return n ? o === 0 && (i[r] |= 1 << s, ++this.numValid) : o === 1 && (i[r] &= ~(1 << s), --this.numValid), this;
+  }
+  clear() {
+    return this.numValid = 0, super.clear();
+  }
+}
+class tr extends jt {
+  constructor(t) {
+    super(t.OffsetArrayType, 1, 1);
+  }
+  append(t) {
+    return this.set(this.length - 1, t);
+  }
+  set(t, n) {
+    const i = this.length - 1, r = this.reserve(t - i + 1).buffer;
+    return i < t++ && i >= 0 && r.fill(r[i], i, t), r[t] = r[t - 1] + n, this;
+  }
+  flush(t = this.length - 1) {
+    return t > this.length && this.set(t - 1, this.BYTES_PER_ELEMENT > 4 ? BigInt(0) : 0), super.flush(t + 1);
+  }
+}
+class P {
+  /** @nocollapse */
+  // @ts-ignore
+  static throughNode(t) {
+    throw new Error('"throughNode" not available in this environment');
+  }
+  /** @nocollapse */
+  // @ts-ignore
+  static throughDOM(t) {
+    throw new Error('"throughDOM" not available in this environment');
+  }
+  /**
+   * Construct a builder with the given Arrow DataType with optional null values,
+   * which will be interpreted as "null" when set or appended to the `Builder`.
+   * @param {{ type: T, nullValues?: any[] }} options A `BuilderOptions` object used to create this `Builder`.
+   */
+  constructor({ type: t, nullValues: n }) {
+    this.length = 0, this.finished = !1, this.type = t, this.children = [], this.nullValues = n, this.stride = X(t), this._nulls = new Zi(), n && n.length > 0 && (this._isValid = vo(n));
+  }
+  /**
+   * Flush the `Builder` and return a `Vector<T>`.
+   * @returns {Vector<T>} A `Vector<T>` of the flushed values.
+   */
+  toVector() {
+    return new D([this.flush()]);
+  }
+  get ArrayType() {
+    return this.type.ArrayType;
+  }
+  get nullCount() {
+    return this._nulls.numInvalid;
+  }
+  get numChildren() {
+    return this.children.length;
+  }
+  /**
+   * @returns The aggregate length (in bytes) of the values that have been written.
+   */
+  get byteLength() {
+    let t = 0;
+    const { _offsets: n, _values: i, _nulls: r, _typeIds: s, children: o } = this;
+    return n && (t += n.byteLength), i && (t += i.byteLength), r && (t += r.byteLength), s && (t += s.byteLength), o.reduce((a, c) => a + c.byteLength, t);
+  }
+  /**
+   * @returns The aggregate number of rows that have been reserved to write new values.
+   */
+  get reservedLength() {
+    return this._nulls.reservedLength;
+  }
+  /**
+   * @returns The aggregate length (in bytes) that has been reserved to write new values.
+   */
+  get reservedByteLength() {
+    let t = 0;
+    return this._offsets && (t += this._offsets.reservedByteLength), this._values && (t += this._values.reservedByteLength), this._nulls && (t += this._nulls.reservedByteLength), this._typeIds && (t += this._typeIds.reservedByteLength), this.children.reduce((n, i) => n + i.reservedByteLength, t);
+  }
+  get valueOffsets() {
+    return this._offsets ? this._offsets.buffer : null;
+  }
+  get values() {
+    return this._values ? this._values.buffer : null;
+  }
+  get nullBitmap() {
+    return this._nulls ? this._nulls.buffer : null;
+  }
+  get typeIds() {
+    return this._typeIds ? this._typeIds.buffer : null;
+  }
+  /**
+   * Appends a value (or null) to this `Builder`.
+   * This is equivalent to `builder.set(builder.length, value)`.
+   * @param {T['TValue'] | TNull } value The value to append.
+   */
+  append(t) {
+    return this.set(this.length, t);
+  }
+  /**
+   * Validates whether a value is valid (true), or null (false)
+   * @param {T['TValue'] | TNull } value The value to compare against null the value representations
+   */
+  isValid(t) {
+    return this._isValid(t);
+  }
+  /**
+   * Write a value (or null-value sentinel) at the supplied index.
+   * If the value matches one of the null-value representations, a 1-bit is
+   * written to the null `BitmapBufferBuilder`. Otherwise, a 0 is written to
+   * the null `BitmapBufferBuilder`, and the value is passed to
+   * `Builder.prototype.setValue()`.
+   * @param {number} index The index of the value to write.
+   * @param {T['TValue'] | TNull } value The value to write at the supplied index.
+   * @returns {this} The updated `Builder` instance.
+   */
+  set(t, n) {
+    return this.setValid(t, this.isValid(n)) && this.setValue(t, n), this;
+  }
+  /**
+   * Write a value to the underlying buffers at the supplied index, bypassing
+   * the null-value check. This is a low-level method that
+   * @param {number} index
+   * @param {T['TValue'] | TNull } value
+   */
+  setValue(t, n) {
+    this._setValue(this, t, n);
+  }
+  setValid(t, n) {
+    return this.length = this._nulls.set(t, +n).length, n;
+  }
+  // @ts-ignore
+  addChild(t, n = `${this.numChildren}`) {
+    throw new Error(`Cannot append children to non-nested type "${this.type}"`);
+  }
+  /**
+   * Retrieve the child `Builder` at the supplied `index`, or null if no child
+   * exists at that index.
+   * @param {number} index The index of the child `Builder` to retrieve.
+   * @returns {Builder | null} The child Builder at the supplied index or null.
+   */
+  getChildAt(t) {
+    return this.children[t] || null;
+  }
+  /**
+   * Commit all the values that have been written to their underlying
+   * ArrayBuffers, including any child Builders if applicable, and reset
+   * the internal `Builder` state.
+   * @returns A `Data<T>` of the buffers and children representing the values written.
+   */
+  flush() {
+    let t, n, i, r;
+    const { type: s, length: o, nullCount: a, _typeIds: c, _offsets: u, _values: d, _nulls: h } = this;
+    (n = c == null ? void 0 : c.flush(o)) ? r = u == null ? void 0 : u.flush(o) : (r = u == null ? void 0 : u.flush(o)) ? t = d == null ? void 0 : d.flush(u.last()) : t = d == null ? void 0 : d.flush(o), a > 0 && (i = h == null ? void 0 : h.flush(o));
+    const U = this.children.map((B) => B.flush());
+    return this.clear(), M({
+      type: s,
+      length: o,
+      nullCount: a,
+      children: U,
+      child: U[0],
+      data: t,
+      typeIds: n,
+      nullBitmap: i,
+      valueOffsets: r
+    });
+  }
+  /**
+   * Finalize this `Builder`, and child builders if applicable.
+   * @returns {this} The finalized `Builder` instance.
+   */
+  finish() {
+    this.finished = !0;
+    for (const t of this.children)
+      t.finish();
+    return this;
+  }
+  /**
+   * Clear this Builder's internal state, including child Builders if applicable, and reset the length to 0.
+   * @returns {this} The cleared `Builder` instance.
+   */
+  clear() {
+    var t, n, i, r;
+    this.length = 0, (t = this._nulls) === null || t === void 0 || t.clear(), (n = this._values) === null || n === void 0 || n.clear(), (i = this._offsets) === null || i === void 0 || i.clear(), (r = this._typeIds) === null || r === void 0 || r.clear();
+    for (const s of this.children)
+      s.clear();
+    return this;
+  }
+}
+P.prototype.length = 1;
+P.prototype.stride = 1;
+P.prototype.children = null;
+P.prototype.finished = !1;
+P.prototype.nullValues = null;
+P.prototype._isValid = () => !0;
+class st extends P {
+  constructor(t) {
+    super(t), this._values = new jt(this.ArrayType, 0, this.stride);
+  }
+  setValue(t, n) {
+    const i = this._values;
+    return i.reserve(t - i.length + 1), super.setValue(t, n);
+  }
+}
+class _t extends P {
+  constructor(t) {
+    super(t), this._pendingLength = 0, this._offsets = new tr(t.type);
+  }
+  setValue(t, n) {
+    const i = this._pending || (this._pending = /* @__PURE__ */ new Map()), r = i.get(t);
+    r && (this._pendingLength -= r.length), this._pendingLength += n instanceof se ? n[ut].length : n.length, i.set(t, n);
+  }
+  setValid(t, n) {
+    return super.setValid(t, n) ? !0 : ((this._pending || (this._pending = /* @__PURE__ */ new Map())).set(t, void 0), !1);
+  }
+  clear() {
+    return this._pendingLength = 0, this._pending = void 0, super.clear();
+  }
+  flush() {
+    return this._flush(), super.flush();
+  }
+  finish() {
+    return this._flush(), super.finish();
+  }
+  _flush() {
+    const t = this._pending, n = this._pendingLength;
+    return this._pendingLength = 0, this._pending = void 0, t && t.size > 0 && this._flushPending(t, n), this;
+  }
+}
+class C {
+  constructor(t = [], n, i, r = be.V5) {
+    this.fields = t || [], this.metadata = n || /* @__PURE__ */ new Map(), i || (i = Be(this.fields)), this.dictionaries = i, this.metadataVersion = r;
+  }
+  get [Symbol.toStringTag]() {
+    return "Schema";
+  }
+  get names() {
+    return this.fields.map((t) => t.name);
+  }
+  toString() {
+    return `Schema<{ ${this.fields.map((t, n) => `${n}: ${t}`).join(", ")} }>`;
+  }
+  /**
+   * Construct a new Schema containing only specified fields.
+   *
+   * @param fieldNames Names of fields to keep.
+   * @returns A new Schema of fields matching the specified names.
+   */
+  select(t) {
+    const n = new Set(t), i = this.fields.filter((r) => n.has(r.name));
+    return new C(i, this.metadata);
+  }
+  /**
+   * Construct a new Schema containing only fields at the specified indices.
+   *
+   * @param fieldIndices Indices of fields to keep.
+   * @returns A new Schema of fields at the specified indices.
+   */
+  selectAt(t) {
+    const n = t.map((i) => this.fields[i]).filter(Boolean);
+    return new C(n, this.metadata);
+  }
+  assign(...t) {
+    const n = t[0] instanceof C ? t[0] : Array.isArray(t[0]) ? new C(t[0]) : new C(t), i = [...this.fields], r = Yt(Yt(/* @__PURE__ */ new Map(), this.metadata), n.metadata), s = n.fields.filter((a) => {
+      const c = i.findIndex((u) => u.name === a.name);
+      return ~c ? (i[c] = a.clone({
+        metadata: Yt(Yt(/* @__PURE__ */ new Map(), i[c].metadata), a.metadata)
+      })) && !1 : !0;
+    }), o = Be(s, /* @__PURE__ */ new Map());
+    return new C([...i, ...s], r, new Map([...this.dictionaries, ...o]));
+  }
+}
+C.prototype.fields = null;
+C.prototype.metadata = null;
+C.prototype.dictionaries = null;
+class k {
+  /** @nocollapse */
+  static new(...t) {
+    let [n, i, r, s] = t;
+    return t[0] && typeof t[0] == "object" && ({ name: n } = t[0], i === void 0 && (i = t[0].type), r === void 0 && (r = t[0].nullable), s === void 0 && (s = t[0].metadata)), new k(`${n}`, i, r, s);
+  }
+  constructor(t, n, i = !1, r) {
+    this.name = t, this.type = n, this.nullable = i, this.metadata = r || /* @__PURE__ */ new Map();
+  }
+  get typeId() {
+    return this.type.typeId;
+  }
+  get [Symbol.toStringTag]() {
+    return "Field";
+  }
+  toString() {
+    return `${this.name}: ${this.type}`;
+  }
+  clone(...t) {
+    let [n, i, r, s] = t;
+    return !t[0] || typeof t[0] != "object" ? [n = this.name, i = this.type, r = this.nullable, s = this.metadata] = t : { name: n = this.name, type: i = this.type, nullable: r = this.nullable, metadata: s = this.metadata } = t[0], k.new(n, i, r, s);
+  }
+}
+k.prototype.type = null;
+k.prototype.name = null;
+k.prototype.nullable = null;
+k.prototype.metadata = null;
+function Yt(e, t) {
+  return new Map([...e || /* @__PURE__ */ new Map(), ...t || /* @__PURE__ */ new Map()]);
+}
+function Be(e, t = /* @__PURE__ */ new Map()) {
+  for (let n = -1, i = e.length; ++n < i; ) {
+    const s = e[n].type;
+    if (A.isDictionary(s)) {
+      if (!t.has(s.id))
+        t.set(s.id, s.dictionary);
+      else if (t.get(s.id) !== s.dictionary)
+        throw new Error("Cannot create Schema containing two different dictionaries with the same Id");
+    }
+    s.children && s.children.length > 0 && Be(s.children, t);
+  }
+  return t;
+}
+class er extends _t {
+  constructor(t) {
+    super(t), this._values = new kt(Uint8Array);
+  }
+  get byteLength() {
+    let t = this._pendingLength + this.length * 4;
+    return this._offsets && (t += this._offsets.byteLength), this._values && (t += this._values.byteLength), this._nulls && (t += this._nulls.byteLength), t;
+  }
+  setValue(t, n) {
+    return super.setValue(t, N(n));
+  }
+  _flushPending(t, n) {
+    const i = this._offsets, r = this._values.reserve(n).buffer;
+    let s = 0;
+    for (const [o, a] of t)
+      if (a === void 0)
+        i.set(o, 0);
+      else {
+        const c = a.length;
+        r.set(a, s), i.set(o, c), s += c;
+      }
+  }
+}
+class nr extends _t {
+  constructor(t) {
+    super(t), this._values = new kt(Uint8Array);
+  }
+  get byteLength() {
+    let t = this._pendingLength + this.length * 4;
+    return this._offsets && (t += this._offsets.byteLength), this._values && (t += this._values.byteLength), this._nulls && (t += this._nulls.byteLength), t;
+  }
+  setValue(t, n) {
+    return super.setValue(t, N(n));
+  }
+  _flushPending(t, n) {
+    const i = this._offsets, r = this._values.reserve(n).buffer;
+    let s = 0;
+    for (const [o, a] of t)
+      if (a === void 0)
+        i.set(o, BigInt(0));
+      else {
+        const c = a.length;
+        r.set(a, s), i.set(o, BigInt(c)), s += c;
+      }
+  }
+}
+class Io extends P {
+  constructor(t) {
+    super(t), this._values = new Zi();
+  }
+  setValue(t, n) {
+    this._values.set(t, +n);
+  }
+}
+class ce extends st {
+}
+ce.prototype._setValue = ui;
+class ir extends ce {
+}
+ir.prototype._setValue = Ee;
+class rr extends ce {
+}
+rr.prototype._setValue = Ve;
+class sr extends st {
+}
+sr.prototype._setValue = yi;
+class So extends P {
+  constructor({ type: t, nullValues: n, dictionaryHashFunction: i }) {
+    super({ type: new Qt(t.dictionary, t.indices, t.id, t.isOrdered) }), this._nulls = null, this._dictionaryOffset = 0, this._keysToIndices = /* @__PURE__ */ Object.create(null), this.indices = xt({ type: this.type.indices, nullValues: n }), this.dictionary = xt({ type: this.type.dictionary, nullValues: null }), typeof i == "function" && (this.valueToKey = i);
+  }
+  get values() {
+    return this.indices.values;
+  }
+  get nullCount() {
+    return this.indices.nullCount;
+  }
+  get nullBitmap() {
+    return this.indices.nullBitmap;
+  }
+  get byteLength() {
+    return this.indices.byteLength + this.dictionary.byteLength;
+  }
+  get reservedLength() {
+    return this.indices.reservedLength + this.dictionary.reservedLength;
+  }
+  get reservedByteLength() {
+    return this.indices.reservedByteLength + this.dictionary.reservedByteLength;
+  }
+  isValid(t) {
+    return this.indices.isValid(t);
+  }
+  setValid(t, n) {
+    const i = this.indices;
+    return n = i.setValid(t, n), this.length = i.length, n;
+  }
+  setValue(t, n) {
+    const i = this._keysToIndices, r = this.valueToKey(n);
+    let s = i[r];
+    return s === void 0 && (i[r] = s = this._dictionaryOffset + this.dictionary.append(n).length - 1), this.indices.setValue(t, s);
+  }
+  flush() {
+    const t = this.type, n = this._dictionary, i = this.dictionary.toVector(), r = this.indices.flush().clone(t);
+    return r.dictionary = n ? n.concat(i) : i, this.finished || (this._dictionaryOffset += i.length), this._dictionary = r.dictionary, this.clear(), r;
+  }
+  finish() {
+    return this.indices.finish(), this.dictionary.finish(), this._dictionaryOffset = 0, this._keysToIndices = /* @__PURE__ */ Object.create(null), super.finish();
+  }
+  clear() {
+    return this.indices.clear(), this.dictionary.clear(), super.clear();
+  }
+  valueToKey(t) {
+    return typeof t == "string" ? t : `${t}`;
+  }
+}
+class or extends st {
+}
+or.prototype._setValue = ai;
+class wo extends P {
+  setValue(t, n) {
+    const [i] = this.children, r = t * this.stride;
+    for (let s = -1, o = this.stride; ++s < o; )
+      i.set(r + s, n[s]);
+  }
+  setValid(t, n) {
+    return super.setValid(t, n) || this.children[0].setValid((t + 1) * this.stride - 1, !1), n;
+  }
+  addChild(t, n = "0") {
+    if (this.numChildren > 0)
+      throw new Error("FixedSizeListBuilder can only have one child.");
+    const i = this.children.push(t);
+    return this.type = new we(this.type.listSize, new k(n, t.type, !0)), i;
+  }
+}
+class ue extends st {
+  setValue(t, n) {
+    this._values.set(t, n);
+  }
+}
+class Ao extends ue {
+  setValue(t, n) {
+    super.setValue(t, Fe(n));
+  }
+}
+class Do extends ue {
+}
+class _o extends ue {
+}
+class zt extends st {
+}
+zt.prototype._setValue = gi;
+class ar extends zt {
+}
+ar.prototype._setValue = We;
+class lr extends zt {
+}
+lr.prototype._setValue = He;
+class cr extends zt {
+}
+cr.prototype._setValue = Ke;
+class Bt extends st {
+}
+Bt.prototype._setValue = mi;
+class ur extends Bt {
+}
+ur.prototype._setValue = Ge;
+class dr extends Bt {
+}
+dr.prototype._setValue = Je;
+class hr extends Bt {
+}
+hr.prototype._setValue = qe;
+class yr extends Bt {
+}
+yr.prototype._setValue = Qe;
+class ot extends st {
+  setValue(t, n) {
+    this._values.set(t, n);
+  }
+}
+class Bo extends ot {
+}
+class To extends ot {
+}
+class Oo extends ot {
+}
+class Mo extends ot {
+}
+class No extends ot {
+}
+class Uo extends ot {
+}
+class Co extends ot {
+}
+class Fo extends ot {
+}
+class Lo extends _t {
+  constructor(t) {
+    super(t), this._offsets = new tr(t.type);
+  }
+  addChild(t, n = "0") {
+    if (this.numChildren > 0)
+      throw new Error("ListBuilder can only have one child.");
+    return this.children[this.numChildren] = t, this.type = new qt(new k(n, t.type, !0)), this.numChildren - 1;
+  }
+  _flushPending(t) {
+    const n = this._offsets, [i] = this.children;
+    for (const [r, s] of t)
+      if (typeof s > "u")
+        n.set(r, 0);
+      else {
+        const o = s, a = o.length, c = n.set(r, a).buffer[r];
+        for (let u = -1; ++u < a; )
+          i.set(c + u, o[u]);
+      }
+  }
+}
+class Eo extends _t {
+  set(t, n) {
+    return super.set(t, n);
+  }
+  setValue(t, n) {
+    const i = n instanceof Map ? n : new Map(Object.entries(n)), r = this._pending || (this._pending = /* @__PURE__ */ new Map()), s = r.get(t);
+    s && (this._pendingLength -= s.size), this._pendingLength += i.size, r.set(t, i);
+  }
+  addChild(t, n = `${this.numChildren}`) {
+    if (this.numChildren > 0)
+      throw new Error("ListBuilder can only have one child.");
+    return this.children[this.numChildren] = t, this.type = new Ae(new k(n, t.type, !0), this.type.keysSorted), this.numChildren - 1;
+  }
+  _flushPending(t) {
+    const n = this._offsets, [i] = this.children;
+    for (const [r, s] of t)
+      if (s === void 0)
+        n.set(r, 0);
+      else {
+        let { [r]: o, [r + 1]: a } = n.set(r, s.size).buffer;
+        for (const c of s.entries())
+          if (i.set(o, c), ++o >= a)
+            break;
+      }
+  }
+}
+class Vo extends P {
+  // @ts-ignore
+  setValue(t, n) {
+  }
+  setValid(t, n) {
+    return this.length = Math.max(t + 1, this.length), n;
+  }
+}
+class xo extends P {
+  setValue(t, n) {
+    const { children: i, type: r } = this;
+    switch (Array.isArray(n) || n.constructor) {
+      case !0:
+        return r.children.forEach((s, o) => i[o].set(t, n[o]));
+      case Map:
+        return r.children.forEach((s, o) => i[o].set(t, n.get(s.name)));
+      default:
+        return r.children.forEach((s, o) => i[o].set(t, n[s.name]));
+    }
+  }
+  /** @inheritdoc */
+  setValid(t, n) {
+    return super.setValid(t, n) || this.children.forEach((i) => i.setValid(t, n)), n;
+  }
+  addChild(t, n = `${this.numChildren}`) {
+    const i = this.children.push(t);
+    return this.type = new Y([...this.type.children, new k(n, t.type, !0)]), i;
+  }
+}
+class Tt extends st {
+}
+Tt.prototype._setValue = di;
+class pr extends Tt {
+}
+pr.prototype._setValue = xe;
+class fr extends Tt {
+}
+fr.prototype._setValue = ke;
+class gr extends Tt {
+}
+gr.prototype._setValue = je;
+class mr extends Tt {
+}
+mr.prototype._setValue = ze;
+class Ot extends st {
+}
+Ot.prototype._setValue = hi;
+class vr extends Ot {
+}
+vr.prototype._setValue = $e;
+class br extends Ot {
+}
+br.prototype._setValue = Pe;
+class Ir extends Ot {
+}
+Ir.prototype._setValue = Re;
+class Sr extends Ot {
+}
+Sr.prototype._setValue = Ye;
+class on extends P {
+  constructor(t) {
+    super(t), this._typeIds = new jt(Int8Array, 0, 1), typeof t.valueToChildTypeId == "function" && (this._valueToChildTypeId = t.valueToChildTypeId);
+  }
+  get typeIdToChildIndex() {
+    return this.type.typeIdToChildIndex;
+  }
+  append(t, n) {
+    return this.set(this.length, t, n);
+  }
+  set(t, n, i) {
+    return i === void 0 && (i = this._valueToChildTypeId(this, n, t)), this.setValue(t, n, i), this;
+  }
+  setValue(t, n, i) {
+    this._typeIds.set(t, i);
+    const r = this.type.typeIdToChildIndex[i], s = this.children[r];
+    s == null || s.set(t, n), this.length = Math.max(t + 1, this.length);
+  }
+  addChild(t, n = `${this.children.length}`) {
+    const i = this.children.push(t), { type: { children: r, mode: s, typeIds: o } } = this, a = [...r, new k(n, t.type)];
+    return this.type = new Vt(s, [...o, i], a), i;
+  }
+  /** @ignore */
+  // @ts-ignore
+  _valueToChildTypeId(t, n, i) {
+    throw new Error("Cannot map UnionBuilder value to child typeId. Pass the `childTypeId` as the second argument to unionBuilder.append(), or supply a `valueToChildTypeId` function as part of the UnionBuilder constructor options.");
+  }
+}
+class ko extends on {
+}
+class jo extends on {
+  constructor(t) {
+    super(t), this._offsets = new jt(Int32Array);
+  }
+  /** @ignore */
+  setValue(t, n, i) {
+    const r = this._typeIds.set(t, i).buffer[t], s = this.getChildAt(this.type.typeIdToChildIndex[r]), o = this._offsets.set(t, s.length).buffer[t];
+    s == null || s.set(o, n), this.length = Math.max(t + 1, this.length);
+  }
+}
+class wr extends _t {
+  constructor(t) {
+    super(t), this._values = new kt(Uint8Array);
+  }
+  get byteLength() {
+    let t = this._pendingLength + this.length * 4;
+    return this._offsets && (t += this._offsets.byteLength), this._values && (t += this._values.byteLength), this._nulls && (t += this._nulls.byteLength), t;
+  }
+  setValue(t, n) {
+    return super.setValue(t, ne(n));
+  }
+  // @ts-ignore
+  _flushPending(t, n) {
+  }
+}
+wr.prototype._flushPending = er.prototype._flushPending;
+class Ar extends _t {
+  constructor(t) {
+    super(t), this._values = new kt(Uint8Array);
+  }
+  get byteLength() {
+    let t = this._pendingLength + this.length * 4;
+    return this._offsets && (t += this._offsets.byteLength), this._values && (t += this._values.byteLength), this._nulls && (t += this._nulls.byteLength), t;
+  }
+  setValue(t, n) {
+    return super.setValue(t, ne(n));
+  }
+  // @ts-ignore
+  _flushPending(t, n) {
+  }
+}
+Ar.prototype._flushPending = nr.prototype._flushPending;
+class zo extends _ {
+  visitNull() {
+    return Vo;
+  }
+  visitBool() {
+    return Io;
+  }
+  visitInt() {
+    return ot;
+  }
+  visitInt8() {
+    return Bo;
+  }
+  visitInt16() {
+    return To;
+  }
+  visitInt32() {
+    return Oo;
+  }
+  visitInt64() {
+    return Mo;
+  }
+  visitUint8() {
+    return No;
+  }
+  visitUint16() {
+    return Uo;
+  }
+  visitUint32() {
+    return Co;
+  }
+  visitUint64() {
+    return Fo;
+  }
+  visitFloat() {
+    return ue;
+  }
+  visitFloat16() {
+    return Ao;
+  }
+  visitFloat32() {
+    return Do;
+  }
+  visitFloat64() {
+    return _o;
+  }
+  visitUtf8() {
+    return wr;
+  }
+  visitLargeUtf8() {
+    return Ar;
+  }
+  visitBinary() {
+    return er;
+  }
+  visitLargeBinary() {
+    return nr;
+  }
+  visitFixedSizeBinary() {
+    return or;
+  }
+  visitDate() {
+    return ce;
+  }
+  visitDateDay() {
+    return ir;
+  }
+  visitDateMillisecond() {
+    return rr;
+  }
+  visitTimestamp() {
+    return Tt;
+  }
+  visitTimestampSecond() {
+    return pr;
+  }
+  visitTimestampMillisecond() {
+    return fr;
+  }
+  visitTimestampMicrosecond() {
+    return gr;
+  }
+  visitTimestampNanosecond() {
+    return mr;
+  }
+  visitTime() {
+    return Ot;
+  }
+  visitTimeSecond() {
+    return vr;
+  }
+  visitTimeMillisecond() {
+    return br;
+  }
+  visitTimeMicrosecond() {
+    return Ir;
+  }
+  visitTimeNanosecond() {
+    return Sr;
+  }
+  visitDecimal() {
+    return sr;
+  }
+  visitList() {
+    return Lo;
+  }
+  visitStruct() {
+    return xo;
+  }
+  visitUnion() {
+    return on;
+  }
+  visitDenseUnion() {
+    return jo;
+  }
+  visitSparseUnion() {
+    return ko;
+  }
+  visitDictionary() {
+    return So;
+  }
+  visitInterval() {
+    return zt;
+  }
+  visitIntervalDayTime() {
+    return ar;
+  }
+  visitIntervalYearMonth() {
+    return lr;
+  }
+  visitIntervalMonthDayNano() {
+    return cr;
+  }
+  visitDuration() {
+    return Bt;
+  }
+  visitDurationSecond() {
+    return ur;
+  }
+  visitDurationMillisecond() {
+    return dr;
+  }
+  visitDurationMicrosecond() {
+    return hr;
+  }
+  visitDurationNanosecond() {
+    return yr;
+  }
+  visitFixedSizeList() {
+    return wo;
+  }
+  visitMap() {
+    return Eo;
+  }
+}
+const $o = new zo();
+class m extends _ {
+  compareSchemas(t, n) {
+    return t === n || n instanceof t.constructor && this.compareManyFields(t.fields, n.fields);
+  }
+  compareManyFields(t, n) {
+    return t === n || Array.isArray(t) && Array.isArray(n) && t.length === n.length && t.every((i, r) => this.compareFields(i, n[r]));
+  }
+  compareFields(t, n) {
+    return t === n || n instanceof t.constructor && t.name === n.name && t.nullable === n.nullable && this.visit(t.type, n.type);
+  }
+}
+function z(e, t) {
+  return t instanceof e.constructor;
+}
+function ht(e, t) {
+  return e === t || z(e, t);
+}
+function at(e, t) {
+  return e === t || z(e, t) && e.bitWidth === t.bitWidth && e.isSigned === t.isSigned;
+}
+function de(e, t) {
+  return e === t || z(e, t) && e.precision === t.precision;
+}
+function Po(e, t) {
+  return e === t || z(e, t) && e.byteWidth === t.byteWidth;
+}
+function an(e, t) {
+  return e === t || z(e, t) && e.unit === t.unit;
+}
+function $t(e, t) {
+  return e === t || z(e, t) && e.unit === t.unit && e.timezone === t.timezone;
+}
+function Pt(e, t) {
+  return e === t || z(e, t) && e.unit === t.unit && e.bitWidth === t.bitWidth;
+}
+function Ro(e, t) {
+  return e === t || z(e, t) && e.children.length === t.children.length && et.compareManyFields(e.children, t.children);
+}
+function Yo(e, t) {
+  return e === t || z(e, t) && e.children.length === t.children.length && et.compareManyFields(e.children, t.children);
+}
+function ln(e, t) {
+  return e === t || z(e, t) && e.mode === t.mode && e.typeIds.every((n, i) => n === t.typeIds[i]) && et.compareManyFields(e.children, t.children);
+}
+function Wo(e, t) {
+  return e === t || z(e, t) && e.id === t.id && e.isOrdered === t.isOrdered && et.visit(e.indices, t.indices) && et.visit(e.dictionary, t.dictionary);
+}
+function he(e, t) {
+  return e === t || z(e, t) && e.unit === t.unit;
+}
+function Rt(e, t) {
+  return e === t || z(e, t) && e.unit === t.unit;
+}
+function Ho(e, t) {
+  return e === t || z(e, t) && e.listSize === t.listSize && e.children.length === t.children.length && et.compareManyFields(e.children, t.children);
+}
+function Ko(e, t) {
+  return e === t || z(e, t) && e.keysSorted === t.keysSorted && e.children.length === t.children.length && et.compareManyFields(e.children, t.children);
+}
+m.prototype.visitNull = ht;
+m.prototype.visitBool = ht;
+m.prototype.visitInt = at;
+m.prototype.visitInt8 = at;
+m.prototype.visitInt16 = at;
+m.prototype.visitInt32 = at;
+m.prototype.visitInt64 = at;
+m.prototype.visitUint8 = at;
+m.prototype.visitUint16 = at;
+m.prototype.visitUint32 = at;
+m.prototype.visitUint64 = at;
+m.prototype.visitFloat = de;
+m.prototype.visitFloat16 = de;
+m.prototype.visitFloat32 = de;
+m.prototype.visitFloat64 = de;
+m.prototype.visitUtf8 = ht;
+m.prototype.visitLargeUtf8 = ht;
+m.prototype.visitBinary = ht;
+m.prototype.visitLargeBinary = ht;
+m.prototype.visitFixedSizeBinary = Po;
+m.prototype.visitDate = an;
+m.prototype.visitDateDay = an;
+m.prototype.visitDateMillisecond = an;
+m.prototype.visitTimestamp = $t;
+m.prototype.visitTimestampSecond = $t;
+m.prototype.visitTimestampMillisecond = $t;
+m.prototype.visitTimestampMicrosecond = $t;
+m.prototype.visitTimestampNanosecond = $t;
+m.prototype.visitTime = Pt;
+m.prototype.visitTimeSecond = Pt;
+m.prototype.visitTimeMillisecond = Pt;
+m.prototype.visitTimeMicrosecond = Pt;
+m.prototype.visitTimeNanosecond = Pt;
+m.prototype.visitDecimal = ht;
+m.prototype.visitList = Ro;
+m.prototype.visitStruct = Yo;
+m.prototype.visitUnion = ln;
+m.prototype.visitDenseUnion = ln;
+m.prototype.visitSparseUnion = ln;
+m.prototype.visitDictionary = Wo;
+m.prototype.visitInterval = he;
+m.prototype.visitIntervalDayTime = he;
+m.prototype.visitIntervalYearMonth = he;
+m.prototype.visitIntervalMonthDayNano = he;
+m.prototype.visitDuration = Rt;
+m.prototype.visitDurationSecond = Rt;
+m.prototype.visitDurationMillisecond = Rt;
+m.prototype.visitDurationMicrosecond = Rt;
+m.prototype.visitDurationNanosecond = Rt;
+m.prototype.visitFixedSizeList = Ho;
+m.prototype.visitMap = Ko;
+const et = new m();
+function Go(e, t) {
+  return et.compareSchemas(e, t);
+}
+function Ua(e, t) {
+  return et.compareFields(e, t);
+}
+function Jo(e, t) {
+  return et.visit(e, t);
+}
+function xt(e) {
+  const t = e.type, n = new ($o.getVisitFn(t)())(e);
+  if (t.children && t.children.length > 0) {
+    const i = e.children || [], r = { nullValues: e.nullValues }, s = Array.isArray(i) ? ((o, a) => i[a] || r) : (({ name: o }) => i[o] || r);
+    for (const [o, a] of t.children.entries()) {
+      const { type: c } = a, u = s(a, o);
+      n.children.push(xt(Object.assign(Object.assign({}, u), { type: c })));
+    }
+  }
+  return n;
+}
+function Dr(e, t) {
+  if (e instanceof T || e instanceof D || e.type instanceof A || ArrayBuffer.isView(e))
+    return sn(e);
+  const n = { type: t ?? Kt(e), nullValues: [null] }, i = [...qo(n)(e)], r = i.length === 1 ? i[0] : i.reduce((s, o) => s.concat(o));
+  return A.isDictionary(r.type) ? r.memoize() : r;
+}
+function Ca(e) {
+  const t = Dr(e), n = new V(new C(t.type.children), t.data[0]);
+  return new R(n);
+}
+function Kt(e) {
+  if (e.length === 0)
+    return new Ft();
+  let t = 0, n = 0, i = 0, r = 0, s = 0, o = 0, a = 0, c = 0;
+  for (const u of e) {
+    if (u == null) {
+      ++t;
+      continue;
+    }
+    switch (typeof u) {
+      case "bigint":
+        ++o;
+        continue;
+      case "boolean":
+        ++a;
+        continue;
+      case "number":
+        ++r;
+        continue;
+      case "string":
+        ++s;
+        continue;
+      case "object":
+        Array.isArray(u) ? ++n : Object.prototype.toString.call(u) === "[object Date]" ? ++c : ++i;
+        continue;
+    }
+    throw new TypeError("Unable to infer Vector type from input values, explicit type declaration expected.");
+  }
+  if (r + t === e.length)
+    return new Ue();
+  if (s + t === e.length)
+    return new Qt(new Ie(), new Me());
+  if (o + t === e.length)
+    return new Ne();
+  if (a + t === e.length)
+    return new Se();
+  if (c + t === e.length)
+    return new ms();
+  if (n + t === e.length) {
+    const u = e, d = Kt(u[u.findIndex((h) => h != null)]);
+    if (u.every((h) => h == null || Jo(d, Kt(h))))
+      return new qt(new k("", d, !0));
+  } else if (i + t === e.length) {
+    const u = /* @__PURE__ */ new Map();
+    for (const d of e)
+      for (const h of Object.keys(d))
+        !u.has(h) && d[h] != null && u.set(h, new k(h, Kt([d[h]]), !0));
+    return new Y([...u.values()]);
+  }
+  throw new TypeError("Unable to infer Vector type from input values, explicit type declaration expected.");
+}
+function qo(e) {
+  const { ["queueingStrategy"]: t = "count" } = e, { ["highWaterMark"]: n = t !== "bytes" ? Number.POSITIVE_INFINITY : Math.pow(2, 14) } = e, i = t !== "bytes" ? "length" : "byteLength";
+  return function* (r) {
+    let s = 0;
+    const o = xt(e);
+    for (const a of r)
+      o.append(a)[i] >= n && ++s && (yield o.toVector());
+    (o.finish().length > 0 || s === 0) && (yield o.toVector());
+  };
+}
+function Fa(e) {
+  const { ["queueingStrategy"]: t = "count" } = e, { ["highWaterMark"]: n = t !== "bytes" ? Number.POSITIVE_INFINITY : Math.pow(2, 14) } = e, i = t !== "bytes" ? "length" : "byteLength";
+  return function(r) {
+    return Nt(this, arguments, function* () {
+      var s, o, a, c;
+      let u = 0;
+      const d = xt(e);
+      try {
+        for (var h = !0, U = Wt(r), B; B = yield L(U.next()), s = B.done, !s; h = !0) {
+          c = B.value, h = !1;
+          const E = c;
+          d.append(E)[i] >= n && ++u && (yield yield L(d.toVector()));
+        }
+      } catch (E) {
+        o = { error: E };
+      } finally {
+        try {
+          !h && !s && (a = U.return) && (yield L(a.call(U)));
+        } finally {
+          if (o) throw o.error;
+        }
+      }
+      (d.finish().length > 0 || u === 0) && (yield yield L(d.toVector()));
+    });
+  };
+}
+function ge(e, t) {
+  return Qo(e, t.map((n) => n.data.concat()));
+}
+function Qo(e, t) {
+  const n = [...e.fields], i = [], r = { numBatches: t.reduce((h, U) => Math.max(h, U.length), 0) };
+  let s = 0, o = 0, a = -1;
+  const c = t.length;
+  let u, d = [];
+  for (; r.numBatches-- > 0; ) {
+    for (o = Number.POSITIVE_INFINITY, a = -1; ++a < c; )
+      d[a] = u = t[a].shift(), o = Math.min(o, u ? u.length : o);
+    Number.isFinite(o) && (d = Xo(n, o, d, t, r), o > 0 && (i[s++] = M({
+      type: new Y(n),
+      length: o,
+      nullCount: 0,
+      children: d.slice()
+    })));
+  }
+  return [
+    e = e.assign(n),
+    i.map((h) => new V(e, h))
+  ];
+}
+function Xo(e, t, n, i, r) {
+  var s;
+  const o = (t + 63 & -64) >> 3;
+  for (let a = -1, c = i.length; ++a < c; ) {
+    const u = n[a], d = u == null ? void 0 : u.length;
+    if (d >= t)
+      d === t ? n[a] = u : (n[a] = u.slice(0, t), r.numBatches = Math.max(r.numBatches, i[a].unshift(u.slice(t, d - t))));
+    else {
+      const h = e[a];
+      e[a] = h.clone({ nullable: !0 }), n[a] = (s = u == null ? void 0 : u._changeLengthAndBackfillNullBitmap(t)) !== null && s !== void 0 ? s : M({
+        type: h.type,
+        length: t,
+        nullCount: t,
+        nullBitmap: new Uint8Array(o)
+      });
+    }
+  }
+  return n;
+}
+var _r;
+class R {
+  constructor(...t) {
+    var n, i;
+    if (t.length === 0)
+      return this.batches = [], this.schema = new C([]), this._offsets = [0], this;
+    let r, s;
+    t[0] instanceof C && (r = t.shift()), t.at(-1) instanceof Uint32Array && (s = t.pop());
+    const o = (c) => {
+      if (c) {
+        if (c instanceof V)
+          return [c];
+        if (c instanceof R)
+          return c.batches;
+        if (c instanceof T) {
+          if (c.type instanceof Y)
+            return [new V(new C(c.type.children), c)];
+        } else {
+          if (Array.isArray(c))
+            return c.flatMap((u) => o(u));
+          if (typeof c[Symbol.iterator] == "function")
+            return [...c].flatMap((u) => o(u));
+          if (typeof c == "object") {
+            const u = Object.keys(c), d = u.map((B) => new D([c[B]])), h = r ?? new C(u.map((B, E) => new k(String(B), d[E].type, d[E].nullable))), [, U] = ge(h, d);
+            return U.length === 0 ? [new V(c)] : U;
+          }
+        }
+      }
+      return [];
+    }, a = t.flatMap((c) => o(c));
+    if (r = (i = r ?? ((n = a[0]) === null || n === void 0 ? void 0 : n.schema)) !== null && i !== void 0 ? i : new C([]), !(r instanceof C))
+      throw new TypeError("Table constructor expects a [Schema, RecordBatch[]] pair.");
+    for (const c of a) {
+      if (!(c instanceof V))
+        throw new TypeError("Table constructor expects a [Schema, RecordBatch[]] pair.");
+      if (!Go(r, c.schema))
+        throw new TypeError("Table and inner RecordBatch schemas must be equivalent.");
+    }
+    this.schema = r, this.batches = a, this._offsets = s ?? Wi(this.data);
+  }
+  /**
+   * The contiguous {@link RecordBatch `RecordBatch`} chunks of the Table rows.
+   */
+  get data() {
+    return this.batches.map(({ data: t }) => t);
+  }
+  /**
+   * The number of columns in this Table.
+   */
+  get numCols() {
+    return this.schema.fields.length;
+  }
+  /**
+   * The number of rows in this Table.
+   */
+  get numRows() {
+    return this.data.reduce((t, n) => t + n.length, 0);
+  }
+  /**
+   * The number of null rows in this Table.
+   */
+  get nullCount() {
+    return this._nullCount === -1 && (this._nullCount = Yi(this.data)), this._nullCount;
+  }
+  /**
+   * Check whether an element is null.
+   *
+   * @param index The index at which to read the validity bitmap.
+   */
+  // @ts-ignore
+  isValid(t) {
+    return !1;
+  }
+  /**
+   * Get an element value by position.
+   *
+   * @param index The index of the element to read.
+   */
+  // @ts-ignore
+  get(t) {
+    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(t) {
+    return this.get(oe(t, this.numRows));
+  }
+  /**
+   * Set an element value by position.
+   *
+   * @param index The index of the element to write.
+   * @param value The value to set.
+   */
+  // @ts-ignore
+  set(t, n) {
+  }
+  /**
+   * Retrieve the index of the first occurrence of a value in an Vector.
+   *
+   * @param element The value to locate in the Vector.
+   * @param offset The index at which to begin the search. If offset is omitted, the search starts at index 0.
+   */
+  // @ts-ignore
+  indexOf(t, n) {
+    return -1;
+  }
+  /**
+   * Iterator for rows in this Table.
+   */
+  [Symbol.iterator]() {
+    return this.batches.length > 0 ? rn.visit(new D(this.data)) : new Array(0)[Symbol.iterator]();
+  }
+  /**
+   * Return a JavaScript Array of the Table rows.
+   *
+   * @returns An Array of Table rows.
+   */
+  toArray() {
+    return [...this];
+  }
+  /**
+   * Returns a string representation of the Table rows.
+   *
+   * @returns A string representation of the Table rows.
+   */
+  toString() {
+    return `[
+  ${this.toArray().join(`,
+  `)}
+]`;
+  }
+  /**
+   * Combines two or more Tables of the same schema.
+   *
+   * @param others Additional Tables to add to the end of this Tables.
+   */
+  concat(...t) {
+    const n = this.schema, i = this.data.concat(t.flatMap(({ data: r }) => r));
+    return new R(n, i.map((r) => new V(n, r)));
+  }
+  /**
+   * Return a zero-copy sub-section of this Table.
+   *
+   * @param begin The beginning of the specified portion of the Table.
+   * @param end The end of the specified portion of the Table. This is exclusive of the element at the index 'end'.
+   */
+  slice(t, n) {
+    const i = this.schema;
+    [t, n] = Ze({ length: this.numRows }, t, n);
+    const r = Hi(this.data, this._offsets, t, n);
+    return new R(i, r.map((s) => new V(i, s)));
+  }
+  /**
+   * Returns a child Vector by name, or null if this Vector has no child with the given name.
+   *
+   * @param name The name of the child to retrieve.
+   */
+  getChild(t) {
+    return this.getChildAt(this.schema.fields.findIndex((n) => n.name === t));
+  }
+  /**
+   * Returns a child Vector by index, or null if this Vector has no child at the supplied index.
+   *
+   * @param index The index of the child to retrieve.
+   */
+  getChildAt(t) {
+    if (t > -1 && t < this.schema.fields.length) {
+      const n = this.data.map((i) => i.children[t]);
+      if (n.length === 0) {
+        const { type: i } = this.schema.fields[t], r = M({ type: i, length: 0, nullCount: 0 });
+        n.push(r._changeLengthAndBackfillNullBitmap(this.numRows));
+      }
+      return new D(n);
+    }
+    return null;
+  }
+  /**
+   * Sets a child Vector by name.
+   *
+   * @param name The name of the child to overwrite.
+   * @returns A new Table with the supplied child for the specified name.
+   */
+  setChild(t, n) {
+    var i;
+    return this.setChildAt((i = this.schema.fields) === null || i === void 0 ? void 0 : i.findIndex((r) => r.name === t), n);
+  }
+  setChildAt(t, n) {
+    let i = this.schema, r = [...this.batches];
+    if (t > -1 && t < this.numCols) {
+      n || (n = new D([M({ type: new Ft(), length: this.numRows })]));
+      const s = i.fields.slice(), o = s[t].clone({ type: n.type }), a = this.schema.fields.map((c, u) => this.getChildAt(u));
+      [s[t], a[t]] = [o, n], [i, r] = ge(i, a);
+    }
+    return new R(i, r);
+  }
+  /**
+   * Construct a new Table containing only specified columns.
+   *
+   * @param columnNames Names of columns to keep.
+   * @returns A new Table of columns matching the specified names.
+   */
+  select(t) {
+    const n = this.schema.fields.reduce((i, r, s) => i.set(r.name, s), /* @__PURE__ */ new Map());
+    return this.selectAt(t.map((i) => n.get(i)).filter((i) => i > -1));
+  }
+  /**
+   * Construct a new Table containing only columns at the specified indices.
+   *
+   * @param columnIndices Indices of columns to keep.
+   * @returns A new Table of columns at the specified indices.
+   */
+  selectAt(t) {
+    const n = this.schema.selectAt(t), i = this.batches.map((r) => r.selectAt(t));
+    return new R(n, i);
+  }
+  assign(t) {
+    const n = this.schema.fields, [i, r] = t.schema.fields.reduce((a, c, u) => {
+      const [d, h] = a, U = n.findIndex((B) => B.name === c.name);
+      return ~U ? h[U] = u : d.push(u), a;
+    }, [[], []]), s = this.schema.assign(t.schema), o = [
+      ...n.map((a, c) => [c, r[c]]).map(([a, c]) => c === void 0 ? this.getChildAt(a) : t.getChildAt(c)),
+      ...i.map((a) => t.getChildAt(a))
+    ].filter(Boolean);
+    return new R(...ge(s, o));
+  }
+}
+_r = Symbol.toStringTag;
+R[_r] = ((e) => (e.schema = null, e.batches = [], e._offsets = new Uint32Array([0]), e._nullCount = -1, e[Symbol.isConcatSpreadable] = !0, e.isValid = Zt(nn), e.get = Zt($.getVisitFn(l.Struct)), e.set = Ki(G.getVisitFn(l.Struct)), e.indexOf = Gi(te.getVisitFn(l.Struct)), "Table"))(R.prototype);
+function La(e) {
+  const t = {}, n = Object.entries(e);
+  for (const [i, r] of n)
+    t[i] = sn(r);
+  return new R(t);
+}
+function Ea(e) {
+  const t = {}, n = Object.entries(e);
+  for (const [i, r] of n)
+    t[i] = Dr(r);
+  return new R(t);
+}
+var Br;
+class V {
+  constructor(...t) {
+    switch (t.length) {
+      case 2: {
+        if ([this.schema] = t, !(this.schema instanceof C))
+          throw new TypeError("RecordBatch constructor expects a [Schema, Data] pair.");
+        if ([
+          ,
+          this.data = M({
+            nullCount: 0,
+            type: new Y(this.schema.fields),
+            children: this.schema.fields.map((n) => M({ type: n.type, nullCount: 0 }))
+          })
+        ] = t, !(this.data instanceof T))
+          throw new TypeError("RecordBatch constructor expects a [Schema, Data] pair.");
+        [this.schema, this.data] = wn(this.schema, this.data.children);
+        break;
+      }
+      case 1: {
+        const [n] = t, { fields: i, children: r, length: s } = Object.keys(n).reduce((c, u, d) => (c.children[d] = n[u], c.length = Math.max(c.length, n[u].length), c.fields[d] = k.new({ name: u, type: n[u].type, nullable: !0 }), c), {
+          length: 0,
+          fields: new Array(),
+          children: new Array()
+        }), o = new C(i), a = M({ type: new Y(i), length: s, children: r, nullCount: 0 });
+        [this.schema, this.data] = wn(o, a.children, s);
+        break;
+      }
+      default:
+        throw new TypeError("RecordBatch constructor expects an Object mapping names to child Data, or a [Schema, Data] pair.");
+    }
+  }
+  get dictionaries() {
+    return this._dictionaries || (this._dictionaries = Tr(this.schema.fields, this.data.children));
+  }
+  /**
+   * The number of columns in this RecordBatch.
+   */
+  get numCols() {
+    return this.schema.fields.length;
+  }
+  /**
+   * The number of rows in this RecordBatch.
+   */
+  get numRows() {
+    return this.data.length;
+  }
+  /**
+   * The number of null rows in this RecordBatch.
+   */
+  get nullCount() {
+    return this.data.nullCount;
+  }
+  /**
+   * Check whether an row is null.
+   * @param index The index at which to read the validity bitmap.
+   */
+  isValid(t) {
+    return this.data.getValid(t);
+  }
+  /**
+   * Get a row by position.
+   * @param index The index of the row to read.
+   */
+  get(t) {
+    return $.visit(this.data, t);
+  }
+  /**
+    * 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(t) {
+    return this.get(oe(t, this.numRows));
+  }
+  /**
+   * Set a row by position.
+   * @param index The index of the row to write.
+   * @param value The value to set.
+   */
+  set(t, n) {
+    return G.visit(this.data, t, n);
+  }
+  /**
+   * Retrieve the index of the first occurrence of a row in an RecordBatch.
+   * @param element The row to locate in the RecordBatch.
+   * @param offset The index at which to begin the search. If offset is omitted, the search starts at index 0.
+   */
+  indexOf(t, n) {
+    return te.visit(this.data, t, n);
+  }
+  /**
+   * Iterator for rows in this RecordBatch.
+   */
+  [Symbol.iterator]() {
+    return rn.visit(new D([this.data]));
+  }
+  /**
+   * Return a JavaScript Array of the RecordBatch rows.
+   * @returns An Array of RecordBatch rows.
+   */
+  toArray() {
+    return [...this];
+  }
+  /**
+   * Combines two or more RecordBatch of the same schema.
+   * @param others Additional RecordBatch to add to the end of this RecordBatch.
+   */
+  concat(...t) {
+    return new R(this.schema, [this, ...t]);
+  }
+  /**
+   * 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 row at the index 'end'.
+   */
+  slice(t, n) {
+    const [i] = new D([this.data]).slice(t, n).data;
+    return new V(this.schema, i);
+  }
+  /**
+   * Returns a child Vector by name, or null if this Vector has no child with the given name.
+   * @param name The name of the child to retrieve.
+   */
+  getChild(t) {
+    var n;
+    return this.getChildAt((n = this.schema.fields) === null || n === void 0 ? void 0 : n.findIndex((i) => i.name === t));
+  }
+  /**
+   * Returns a child Vector by index, or null if this Vector has no child at the supplied index.
+   * @param index The index of the child to retrieve.
+   */
+  getChildAt(t) {
+    return t > -1 && t < this.schema.fields.length ? new D([this.data.children[t]]) : null;
+  }
+  /**
+   * Sets a child Vector by name.
+   * @param name The name of the child to overwrite.
+   * @returns A new RecordBatch with the new child for the specified name.
+   */
+  setChild(t, n) {
+    var i;
+    return this.setChildAt((i = this.schema.fields) === null || i === void 0 ? void 0 : i.findIndex((r) => r.name === t), n);
+  }
+  setChildAt(t, n) {
+    let i = this.schema, r = this.data;
+    if (t > -1 && t < this.numCols) {
+      n || (n = new D([M({ type: new Ft(), length: this.numRows })]));
+      const s = i.fields.slice(), o = r.children.slice(), a = s[t].clone({ type: n.type });
+      [s[t], o[t]] = [a, n.data[0]], i = new C(s, new Map(this.schema.metadata)), r = M({ type: new Y(s), children: o });
+    }
+    return new V(i, r);
+  }
+  /**
+   * Construct a new RecordBatch containing only specified columns.
+   *
+   * @param columnNames Names of columns to keep.
+   * @returns A new RecordBatch of columns matching the specified names.
+   */
+  select(t) {
+    const n = this.schema.select(t), i = new Y(n.fields), r = [];
+    for (const s of t) {
+      const o = this.schema.fields.findIndex((a) => a.name === s);
+      ~o && (r[o] = this.data.children[o]);
+    }
+    return new V(n, M({ type: i, length: this.numRows, children: r }));
+  }
+  /**
+   * Construct a new RecordBatch containing only columns at the specified indices.
+   *
+   * @param columnIndices Indices of columns to keep.
+   * @returns A new RecordBatch of columns matching at the specified indices.
+   */
+  selectAt(t) {
+    const n = this.schema.selectAt(t), i = t.map((s) => this.data.children[s]).filter(Boolean), r = M({ type: new Y(n.fields), length: this.numRows, children: i });
+    return new V(n, r);
+  }
+}
+Br = Symbol.toStringTag;
+V[Br] = ((e) => (e._nullCount = -1, e[Symbol.isConcatSpreadable] = !0, "RecordBatch"))(V.prototype);
+function wn(e, t, n = t.reduce((i, r) => Math.max(i, r.length), 0)) {
+  var i;
+  const r = [...e.fields], s = [...t], o = (n + 63 & -64) >> 3;
+  for (const [a, c] of e.fields.entries()) {
+    const u = t[a];
+    (!u || u.length !== n) && (r[a] = c.clone({ nullable: !0 }), s[a] = (i = u == null ? void 0 : u._changeLengthAndBackfillNullBitmap(n)) !== null && i !== void 0 ? i : M({
+      type: c.type,
+      length: n,
+      nullCount: n,
+      nullBitmap: new Uint8Array(o)
+    }));
+  }
+  return [
+    e.assign(r),
+    M({ type: new Y(r), length: n, children: s })
+  ];
+}
+function Tr(e, t, n = /* @__PURE__ */ new Map()) {
+  var i, r;
+  if (((i = e == null ? void 0 : e.length) !== null && i !== void 0 ? i : 0) > 0 && (e == null ? void 0 : e.length) === (t == null ? void 0 : t.length))
+    for (let s = -1, o = e.length; ++s < o; ) {
+      const { type: a } = e[s], c = t[s];
+      for (const u of [c, ...((r = c == null ? void 0 : c.dictionary) === null || r === void 0 ? void 0 : r.data) || []])
+        Tr(a.children, u == null ? void 0 : u.children, n);
+      if (A.isDictionary(a)) {
+        const { id: u } = a;
+        if (!n.has(u))
+          c != null && c.dictionary && n.set(u, c.dictionary);
+        else if (n.get(u) !== c.dictionary)
+          throw new Error("Cannot create Schema containing two different dictionaries with the same Id");
+      }
+    }
+  return n;
+}
+class Va extends V {
+  constructor(t) {
+    const n = t.fields.map((r) => M({ type: r.type })), i = M({ type: new Y(t.fields), nullCount: 0, children: n });
+    super(t, i);
+  }
+}
+export {
+  ea as $,
+  A,
+  Se as B,
+  Nr as C,
+  Z as D,
+  oa as E,
+  k as F,
+  Vr as G,
+  ia as H,
+  j as I,
+  Dn as J,
+  Fr as K,
+  qt as L,
+  be as M,
+  Ft as N,
+  Lr as O,
+  x as P,
+  Wt as Q,
+  Pi as R,
+  C as S,
+  y as T,
+  K as U,
+  _ as V,
+  O as W,
+  ne as X,
+  M as Y,
+  na as Z,
+  Nt as _,
+  L as a,
+  Qn as a$,
+  Er as a0,
+  Va as a1,
+  V as a2,
+  D as a3,
+  ye as a4,
+  _e as a5,
+  hs as a6,
+  it as a7,
+  le as a8,
+  $i as a9,
+  sr as aA,
+  Ba as aB,
+  jo as aC,
+  So as aD,
+  Bt as aE,
+  Da as aF,
+  hr as aG,
+  Aa as aH,
+  dr as aI,
+  _a as aJ,
+  yr as aK,
+  wa as aL,
+  ur as aM,
+  or as aN,
+  wo as aO,
+  gs as aP,
+  Ao as aQ,
+  ii as aR,
+  Do as aS,
+  Ue as aT,
+  _o as aU,
+  ue as aV,
+  Xn as aW,
+  To as aX,
+  Oo as aY,
+  Ne as aZ,
+  Mo as a_,
+  tn as aa,
+  re as ab,
+  ra as ac,
+  sa as ad,
+  Go as ae,
+  R as af,
+  H as ag,
+  Zo as ah,
+  xt as ai,
+  ca as aj,
+  Na as ak,
+  Oa as al,
+  aa as am,
+  Ma as an,
+  la as ao,
+  Jo as ap,
+  Ua as aq,
+  P as ar,
+  er as as,
+  Io as at,
+  T as au,
+  ce as av,
+  ua as aw,
+  ir as ax,
+  da as ay,
+  rr as az,
+  os as b,
+  Bo as b0,
+  ot as b1,
+  zt as b2,
+  ba as b3,
+  ar as b4,
+  Sa as b5,
+  cr as b6,
+  Ia as b7,
+  lr as b8,
+  nr as b9,
+  pr as bA,
+  l as bB,
+  ti as bC,
+  Uo as bD,
+  ei as bE,
+  Co as bF,
+  ni as bG,
+  Fo as bH,
+  Zn as bI,
+  No as bJ,
+  on as bK,
+  wr as bL,
+  Fa as bM,
+  qo as bN,
+  La as bO,
+  sn as bP,
+  Ea as bQ,
+  Ca as bR,
+  Dr as bS,
+  Ar as ba,
+  Lo as bb,
+  Eo as bc,
+  se as bd,
+  Vo as be,
+  Ta as bf,
+  ko as bg,
+  xo as bh,
+  Xe as bi,
+  Ot as bj,
+  pa as bk,
+  Ir as bl,
+  ya as bm,
+  br as bn,
+  fa as bo,
+  Sr as bp,
+  ha as bq,
+  vr as br,
+  Tt as bs,
+  ma as bt,
+  gr as bu,
+  ms as bv,
+  fr as bw,
+  va as bx,
+  mr as by,
+  ga as bz,
+  Qr as c,
+  ta as d,
+  W as e,
+  Me as f,
+  Qt as g,
+  Y as h,
+  yn as i,
+  jr as j,
+  Ie as k,
+  hn as l,
+  dn as m,
+  Ae as n,
+  we as o,
+  fn as p,
+  Vt as q,
+  Dt as r,
+  Et as s,
+  N as t,
+  At as u,
+  wt as v,
+  Jt as w,
+  pn as x,
+  Lt as y,
+  tt as z
+};