@nika-js/onlymap 0.5.2 → 0.5.6

package/dist/index-BYbMtNVH.js

@@ -0,0 +1,2301 @@
+const Ue = [
+  "BOOLEAN",
+  "INT32",
+  "INT64",
+  "INT96",
+  // deprecated
+  "FLOAT",
+  "DOUBLE",
+  "BYTE_ARRAY",
+  "FIXED_LEN_BYTE_ARRAY"
+], G = [
+  "PLAIN",
+  "GROUP_VAR_INT",
+  // deprecated
+  "PLAIN_DICTIONARY",
+  "RLE",
+  "BIT_PACKED",
+  // deprecated
+  "DELTA_BINARY_PACKED",
+  "DELTA_LENGTH_BYTE_ARRAY",
+  "DELTA_BYTE_ARRAY",
+  "RLE_DICTIONARY",
+  "BYTE_STREAM_SPLIT"
+], Ut = [
+  "REQUIRED",
+  "OPTIONAL",
+  "REPEATED"
+], Pt = [
+  "UTF8",
+  "MAP",
+  "MAP_KEY_VALUE",
+  "LIST",
+  "ENUM",
+  "DECIMAL",
+  "DATE",
+  "TIME_MILLIS",
+  "TIME_MICROS",
+  "TIMESTAMP_MILLIS",
+  "TIMESTAMP_MICROS",
+  "UINT_8",
+  "UINT_16",
+  "UINT_32",
+  "UINT_64",
+  "INT_8",
+  "INT_16",
+  "INT_32",
+  "INT_64",
+  "JSON",
+  "BSON",
+  "INTERVAL"
+], $t = [
+  "UNCOMPRESSED",
+  "SNAPPY",
+  "GZIP",
+  "LZO",
+  "BROTLI",
+  "LZ4",
+  "ZSTD",
+  "LZ4_RAW"
+], lt = [
+  "DATA_PAGE",
+  "INDEX_PAGE",
+  "DICTIONARY_PAGE",
+  "DATA_PAGE_V2"
+], Ct = [
+  "UNORDERED",
+  "ASCENDING",
+  "DESCENDING"
+], Ft = [
+  "SPHERICAL",
+  "VINCENTY",
+  "THOMAS",
+  "ANDOYER",
+  "KARNEY"
+];
+function pe(e) {
+  const t = ce(e);
+  if (t.type === 1)
+    return { type: "Point", coordinates: Ae(e, t) };
+  if (t.type === 2)
+    return { type: "LineString", coordinates: Ee(e, t) };
+  if (t.type === 3)
+    return { type: "Polygon", coordinates: Pe(e, t) };
+  if (t.type === 4) {
+    const i = [];
+    for (let n = 0; n < t.count; n++)
+      i.push(Ae(e, ce(e)));
+    return { type: "MultiPoint", coordinates: i };
+  } else if (t.type === 5) {
+    const i = [];
+    for (let n = 0; n < t.count; n++)
+      i.push(Ee(e, ce(e)));
+    return { type: "MultiLineString", coordinates: i };
+  } else if (t.type === 6) {
+    const i = [];
+    for (let n = 0; n < t.count; n++)
+      i.push(Pe(e, ce(e)));
+    return { type: "MultiPolygon", coordinates: i };
+  } else if (t.type === 7) {
+    const i = [];
+    for (let n = 0; n < t.count; n++)
+      i.push(pe(e));
+    return { type: "GeometryCollection", geometries: i };
+  } else
+    throw new Error(`Unsupported geometry type: ${t.type}`);
+}
+function ce(e) {
+  const { view: t } = e, i = t.getUint8(e.offset++) === 1, n = t.getUint32(e.offset, i);
+  e.offset += 4;
+  const r = n % 1e3, f = Math.floor(n / 1e3);
+  let s = 0;
+  r > 1 && r <= 7 && (s = t.getUint32(e.offset, i), e.offset += 4);
+  let o = 2;
+  return f && o++, f === 3 && o++, { littleEndian: i, type: r, dim: o, count: s };
+}
+function Ae(e, t) {
+  const i = [];
+  for (let n = 0; n < t.dim; n++) {
+    const r = e.view.getFloat64(e.offset, t.littleEndian);
+    e.offset += 8, i.push(r);
+  }
+  return i;
+}
+function Ee(e, t) {
+  const i = [];
+  for (let n = 0; n < t.count; n++)
+    i.push(Ae(e, t));
+  return i;
+}
+function Pe(e, t) {
+  const { view: i } = e, n = [];
+  for (let r = 0; r < t.count; r++) {
+    const f = i.getUint32(e.offset, t.littleEndian);
+    e.offset += 4, n.push(Ee(e, { ...t, count: f }));
+  }
+  return n;
+}
+const $e = new TextDecoder(), oe = {
+  timestampFromMilliseconds(e) {
+    return new Date(Number(e));
+  },
+  timestampFromMicroseconds(e) {
+    return new Date(Number(e / 1000n));
+  },
+  timestampFromNanoseconds(e) {
+    return new Date(Number(e / 1000000n));
+  },
+  dateFromDays(e) {
+    return new Date(e * 864e5);
+  },
+  stringFromBytes(e) {
+    return e && $e.decode(e);
+  },
+  jsonFromBytes(e) {
+    return e && JSON.parse($e.decode(e));
+  },
+  geometryFromBytes(e) {
+    return e && pe({ view: new DataView(e.buffer, e.byteOffset, e.byteLength), offset: 0 });
+  },
+  geographyFromBytes(e) {
+    return e && pe({ view: new DataView(e.buffer, e.byteOffset, e.byteLength), offset: 0 });
+  },
+  uuidFromBytes(e) {
+    if (!e) return;
+    const t = Array.from(e, (i) => i.toString(16).padStart(2, "0")).join("");
+    return t.slice(0, 8) + "-" + t.slice(8, 12) + "-" + t.slice(12, 16) + "-" + t.slice(16, 20) + "-" + t.slice(20, 32);
+  }
+};
+function Ce(e, t, i, n) {
+  if (t && i.endsWith("_DICTIONARY")) {
+    let r = e;
+    e instanceof Uint8Array && !(t instanceof Uint8Array) && (r = new t.constructor(e.length));
+    for (let f = 0; f < e.length; f++)
+      r[f] = t[e[f]];
+    return r;
+  } else
+    return ct(e, n);
+}
+function ct(e, t) {
+  const { element: i, parsers: n, utf8: r = !0, schemaPath: f } = t, { type: s, converted_type: o, logical_type: c } = i, d = i.repetition_type !== "REQUIRED";
+  if (f?.some((l) => l.element.logical_type?.type === "VARIANT") && s === "BYTE_ARRAY" && o !== "UTF8" && c?.type !== "STRING")
+    return e;
+  if (o === "DECIMAL") {
+    const u = 10 ** -(i.scale || 0), g = new Array(e.length);
+    for (let h = 0; h < g.length; h++)
+      e[h] instanceof Uint8Array ? g[h] = at(e[h]) * u : g[h] = Number(e[h]) * u;
+    return g;
+  }
+  if (!o && s === "INT96")
+    return Array.from(e).map((l) => n.timestampFromNanoseconds(kt(l)));
+  if (o === "DATE")
+    return Array.from(e).map((l) => n.dateFromDays(l));
+  if (o === "TIMESTAMP_MILLIS")
+    return Array.from(e).map((l) => n.timestampFromMilliseconds(l));
+  if (o === "TIMESTAMP_MICROS")
+    return Array.from(e).map((l) => n.timestampFromMicroseconds(l));
+  if (o === "JSON")
+    return e.map((l) => n.jsonFromBytes(l));
+  if (o === "BSON")
+    throw new Error("parquet bson not supported");
+  if (o === "INTERVAL")
+    throw new Error("parquet interval not supported");
+  if (c?.type === "GEOMETRY")
+    return e.map((l) => n.geometryFromBytes(l));
+  if (c?.type === "GEOGRAPHY")
+    return e.map((l) => n.geographyFromBytes(l));
+  if (c?.type === "UUID")
+    return e.map((l) => n.uuidFromBytes(l));
+  if (o === "UTF8" || c?.type === "STRING" || r && s === "BYTE_ARRAY")
+    return e.map((l) => n.stringFromBytes(l));
+  if (o === "UINT_64" || c?.type === "INTEGER" && c.bitWidth === 64 && !c.isSigned) {
+    if (e instanceof BigInt64Array) return new BigUint64Array(e.buffer, e.byteOffset, e.length);
+    const l = d ? new Array(e.length) : new BigUint64Array(e.length);
+    for (let u = 0; u < l.length; u++) l[u] = e[u];
+    return l;
+  }
+  if (o === "UINT_32" || c?.type === "INTEGER" && c.bitWidth === 32 && !c.isSigned) {
+    if (e instanceof Int32Array) return new Uint32Array(e.buffer, e.byteOffset, e.length);
+    const l = d ? new Array(e.length) : new Uint32Array(e.length);
+    for (let u = 0; u < l.length; u++)
+      l[u] = e[u] < 0 ? 4294967296 + e[u] : e[u];
+    return l;
+  }
+  if (c?.type === "FLOAT16")
+    return Array.from(e).map(ut);
+  if (c?.type === "TIMESTAMP") {
+    const { unit: l } = c;
+    let u = n.timestampFromMilliseconds;
+    l === "MICROS" && (u = n.timestampFromMicroseconds), l === "NANOS" && (u = n.timestampFromNanoseconds);
+    const g = new Array(e.length);
+    for (let h = 0; h < g.length; h++)
+      g[h] = u(e[h]);
+    return g;
+  }
+  return e;
+}
+function at(e) {
+  if (!e.length) return 0;
+  let t = 0n;
+  for (const n of e)
+    t = t * 256n + BigInt(n);
+  const i = e.length * 8;
+  return t >= 2n ** BigInt(i - 1) && (t -= 2n ** BigInt(i)), Number(t);
+}
+function kt(e) {
+  const t = (e >> 64n) - 2440588n, i = e & 0xffffffffffffffffn;
+  return t * 86400000000000n + i;
+}
+function ut(e) {
+  if (!e) return;
+  const t = e[1] << 8 | e[0], i = t >> 15 ? -1 : 1, n = t >> 10 & 31, r = t & 1023;
+  return n === 0 ? i * 2 ** -14 * (r / 1024) : n === 31 ? r ? NaN : i * (1 / 0) : i * 2 ** (n - 15) * (1 + r / 1024);
+}
+function dt(e, t, i) {
+  const n = e[t], r = [];
+  let f = 1;
+  if (n.num_children)
+    for (; r.length < n.num_children; ) {
+      const s = e[t + f], o = dt(e, t + f, [...i, s.name]);
+      f += o.count, r.push(o);
+    }
+  return { count: f, element: n, children: r, path: i };
+}
+function _t(e, t) {
+  let i = dt(e, 0, []);
+  const n = [i];
+  for (const r of t) {
+    const f = i.children.find((s) => s.element.name === r);
+    if (!f) throw new Error(`parquet schema element not found: ${t}`);
+    n.push(f), i = f;
+  }
+  return n;
+}
+function Re(e) {
+  const t = [];
+  function i(n) {
+    if (n.children.length)
+      for (const r of n.children)
+        i(r);
+    else
+      t.push(n.path.join("."));
+  }
+  return i(e), t;
+}
+function gt(e) {
+  let t = 0;
+  for (const { element: i } of e)
+    i.repetition_type === "REPEATED" && t++;
+  return t;
+}
+function Be(e) {
+  let t = 0;
+  for (const { element: i } of e.slice(1))
+    i.repetition_type !== "REQUIRED" && t++;
+  return t;
+}
+function Yt(e) {
+  if (!e || e.element.converted_type !== "LIST" || e.children.length > 1) return !1;
+  const t = e.children[0];
+  return !(t.children.length > 1 || t.element.repetition_type !== "REPEATED");
+}
+function qt(e) {
+  if (!e || e.element.converted_type !== "MAP" || e.children.length > 1) return !1;
+  const t = e.children[0];
+  return !(t.children.length !== 2 || t.element.repetition_type !== "REPEATED" || t.children.find((r) => r.element.name === "key")?.element.repetition_type === "REPEATED" || t.children.find((r) => r.element.name === "value")?.element.repetition_type === "REPEATED");
+}
+function ht(e) {
+  if (e.length !== 2) return !1;
+  const [, t] = e;
+  return !(t.element.repetition_type === "REPEATED" || t.children.length);
+}
+const jt = 0, Fe = 1, ke = 2, Ye = 3, Gt = 4, Vt = 5, zt = 6, Wt = 7, Ht = 8, Kt = 9, Qt = 12;
+function X(e) {
+  const t = {};
+  let i = 0;
+  for (; e.offset < e.view.byteLength; ) {
+    const n = e.view.getUint8(e.offset++), r = n & 15;
+    if (r === jt) break;
+    const f = n >> 4;
+    i = f ? i + f : yt(e), t[`field_${i}`] = Ie(e, r);
+  }
+  return t;
+}
+function Ie(e, t) {
+  switch (t) {
+    case Fe:
+      return !0;
+    case ke:
+      return !1;
+    case Ye:
+      return e.view.getInt8(e.offset++);
+    case Gt:
+    case Vt:
+      return yt(e);
+    case zt:
+      return be(e);
+    case Wt: {
+      const i = e.view.getFloat64(e.offset, !0);
+      return e.offset += 8, i;
+    }
+    case Ht: {
+      const i = W(e), n = new Uint8Array(e.view.buffer, e.view.byteOffset + e.offset, i);
+      return e.offset += i, n;
+    }
+    case Kt: {
+      const i = e.view.getUint8(e.offset++), n = i & 15;
+      let r = i >> 4;
+      r === 15 && (r = W(e));
+      const f = n === Fe || n === ke, s = new Array(r);
+      for (let o = 0; o < r; o++)
+        s[o] = f ? Ie(e, Ye) === 1 : Ie(e, n);
+      return s;
+    }
+    case Qt:
+      return X(e);
+    default:
+      throw new Error(`thrift unhandled type: ${t}`);
+  }
+}
+function W(e) {
+  let t = 0, i = 0;
+  for (; ; ) {
+    const n = e.view.getUint8(e.offset++);
+    if (t |= (n & 127) << i, !(n & 128))
+      return t;
+    i += 7;
+  }
+}
+function Zt(e) {
+  let t = 0n, i = 0n;
+  for (; ; ) {
+    const n = e.view.getUint8(e.offset++);
+    if (t |= BigInt(n & 127) << i, !(n & 128))
+      return t;
+    i += 7n;
+  }
+}
+function yt(e) {
+  const t = W(e);
+  return t >>> 1 ^ -(t & 1);
+}
+function be(e) {
+  const t = Zt(e);
+  return t >> 1n ^ -(t & 1n);
+}
+function Jt(e, t) {
+  const i = /* @__PURE__ */ new Map(), n = t?.find(({ key: f }) => f === "geo")?.value, r = (n && JSON.parse(n)?.columns) ?? {};
+  for (const [f, s] of Object.entries(r)) {
+    if (s.encoding !== "WKB") continue;
+    const o = s.edges === "spherical" ? "GEOGRAPHY" : "GEOMETRY", c = s.crs?.id ?? s.crs?.ids?.[0], d = c ? `${c.authority}:${c.code.toString()}` : void 0;
+    i.set(f, { type: o, crs: d });
+  }
+  for (let f = 1; f < e.length; f++) {
+    const { logical_type: s, name: o, num_children: c, type: d } = e[f];
+    if (c) {
+      f += c;
+      continue;
+    }
+    d === "BYTE_ARRAY" && !s && (e[f].logical_type = i.get(o));
+  }
+}
+const mt = 1 << 19, Xt = new TextDecoder();
+function D(e) {
+  return e && Xt.decode(e);
+}
+async function he(e, { parsers: t, initialFetchSize: i = mt, geoparquet: n = !0 } = {}) {
+  if (!e || !(e.byteLength >= 0)) throw new Error("parquet expected AsyncBuffer");
+  const r = Math.max(0, e.byteLength - i), f = await e.slice(r, e.byteLength), s = new DataView(f);
+  if (s.getUint32(f.byteLength - 4, !0) !== 827474256)
+    throw new Error("parquet file invalid (footer != PAR1)");
+  const o = s.getUint32(f.byteLength - 8, !0);
+  if (o > e.byteLength - 8)
+    throw new Error(`parquet metadata length ${o} exceeds available buffer ${e.byteLength - 8}`);
+  if (o + 8 > i) {
+    const c = e.byteLength - o - 8, d = await e.slice(c, r), a = new ArrayBuffer(o + 8), l = new Uint8Array(a);
+    return l.set(new Uint8Array(d)), l.set(new Uint8Array(f), r - c), qe(a, { parsers: t, geoparquet: n });
+  } else
+    return qe(f, { parsers: t, geoparquet: n });
+}
+function qe(e, { parsers: t, geoparquet: i = !0 } = {}) {
+  if (!(e instanceof ArrayBuffer)) throw new Error("parquet expected ArrayBuffer");
+  const n = new DataView(e);
+  if (t = { ...oe, ...t }, n.byteLength < 8)
+    throw new Error("parquet file is too short");
+  if (n.getUint32(n.byteLength - 4, !0) !== 827474256)
+    throw new Error("parquet file invalid (footer != PAR1)");
+  const r = n.byteLength - 8, f = n.getUint32(r, !0);
+  if (f > n.byteLength - 8)
+    throw new Error(`parquet metadata length ${f} exceeds available buffer ${n.byteLength - 8}`);
+  const s = r - f, c = X({ view: n, offset: s }), d = c.field_1, a = c.field_2.map((y) => ({
+    type: Ue[y.field_1],
+    type_length: y.field_2,
+    repetition_type: Ut[y.field_3],
+    name: D(y.field_4),
+    num_children: y.field_5,
+    converted_type: Pt[y.field_6],
+    scale: y.field_7,
+    precision: y.field_8,
+    field_id: y.field_9,
+    logical_type: en(y.field_10)
+  })), l = a.filter((y) => y.type), u = c.field_3, g = c.field_4.map((y) => ({
+    columns: y.field_1.map((_, w) => ({
+      file_path: D(_.field_1),
+      file_offset: _.field_2,
+      meta_data: _.field_3 && {
+        type: Ue[_.field_3.field_1],
+        encodings: _.field_3.field_2?.map((p) => G[p]),
+        path_in_schema: _.field_3.field_3.map(D),
+        codec: $t[_.field_3.field_4],
+        num_values: _.field_3.field_5,
+        total_uncompressed_size: _.field_3.field_6,
+        total_compressed_size: _.field_3.field_7,
+        key_value_metadata: _.field_3.field_8?.map((p) => ({
+          key: D(p.field_1),
+          value: D(p.field_2)
+        })),
+        data_page_offset: _.field_3.field_9,
+        index_page_offset: _.field_3.field_10,
+        dictionary_page_offset: _.field_3.field_11,
+        statistics: tn(_.field_3.field_12, l[w], t),
+        encoding_stats: _.field_3.field_13?.map((p) => ({
+          page_type: lt[p.field_1],
+          encoding: G[p.field_2],
+          count: p.field_3
+        })),
+        bloom_filter_offset: _.field_3.field_14,
+        bloom_filter_length: _.field_3.field_15,
+        size_statistics: _.field_3.field_16 && {
+          unencoded_byte_array_data_bytes: _.field_3.field_16.field_1,
+          repetition_level_histogram: _.field_3.field_16.field_2,
+          definition_level_histogram: _.field_3.field_16.field_3
+        },
+        geospatial_statistics: _.field_3.field_17 && {
+          bbox: _.field_3.field_17.field_1 && {
+            xmin: _.field_3.field_17.field_1.field_1,
+            xmax: _.field_3.field_17.field_1.field_2,
+            ymin: _.field_3.field_17.field_1.field_3,
+            ymax: _.field_3.field_17.field_1.field_4,
+            zmin: _.field_3.field_17.field_1.field_5,
+            zmax: _.field_3.field_17.field_1.field_6,
+            mmin: _.field_3.field_17.field_1.field_7,
+            mmax: _.field_3.field_17.field_1.field_8
+          },
+          geospatial_types: _.field_3.field_17.field_2
+        }
+      },
+      offset_index_offset: _.field_4,
+      offset_index_length: _.field_5,
+      column_index_offset: _.field_6,
+      column_index_length: _.field_7,
+      crypto_metadata: _.field_8,
+      encrypted_column_metadata: _.field_9
+    })),
+    total_byte_size: y.field_2,
+    num_rows: y.field_3,
+    sorting_columns: y.field_4?.map((_) => ({
+      column_idx: _.field_1,
+      descending: _.field_2,
+      nulls_first: _.field_3
+    })),
+    file_offset: y.field_5,
+    total_compressed_size: y.field_6,
+    ordinal: y.field_7
+  })), h = c.field_5?.map((y) => ({
+    key: D(y.field_1),
+    value: D(y.field_2)
+  })), m = D(c.field_6);
+  return i && Jt(a, h), {
+    version: d,
+    schema: a,
+    num_rows: u,
+    row_groups: g,
+    key_value_metadata: h,
+    created_by: m,
+    metadata_length: f
+  };
+}
+function F({ schema: e }) {
+  return _t(e, [])[0];
+}
+function en(e) {
+  return e?.field_1 ? { type: "STRING" } : e?.field_2 ? { type: "MAP" } : e?.field_3 ? { type: "LIST" } : e?.field_4 ? { type: "ENUM" } : e?.field_5 ? {
+    type: "DECIMAL",
+    scale: e.field_5.field_1,
+    precision: e.field_5.field_2
+  } : e?.field_6 ? { type: "DATE" } : e?.field_7 ? {
+    type: "TIME",
+    isAdjustedToUTC: e.field_7.field_1,
+    unit: je(e.field_7.field_2)
+  } : e?.field_8 ? {
+    type: "TIMESTAMP",
+    isAdjustedToUTC: e.field_8.field_1,
+    unit: je(e.field_8.field_2)
+  } : e?.field_10 ? {
+    type: "INTEGER",
+    bitWidth: e.field_10.field_1,
+    isSigned: e.field_10.field_2
+  } : e?.field_11 ? { type: "NULL" } : e?.field_12 ? { type: "JSON" } : e?.field_13 ? { type: "BSON" } : e?.field_14 ? { type: "UUID" } : e?.field_15 ? { type: "FLOAT16" } : e?.field_16 ? {
+    type: "VARIANT",
+    specification_version: e.field_16.field_1
+  } : e?.field_17 ? {
+    type: "GEOMETRY",
+    crs: D(e.field_17.field_1)
+  } : e?.field_18 ? {
+    type: "GEOGRAPHY",
+    crs: D(e.field_18.field_1),
+    algorithm: Ft[e.field_18.field_2]
+  } : e;
+}
+function je(e) {
+  if (e.field_1) return "MILLIS";
+  if (e.field_2) return "MICROS";
+  if (e.field_3) return "NANOS";
+  throw new Error("parquet time unit required");
+}
+function tn(e, t, i) {
+  return e && {
+    max: J(e.field_1, t, i),
+    min: J(e.field_2, t, i),
+    null_count: e.field_3,
+    distinct_count: e.field_4,
+    max_value: J(e.field_5, t, i),
+    min_value: J(e.field_6, t, i),
+    is_max_value_exact: e.field_7,
+    is_min_value_exact: e.field_8
+  };
+}
+function J(e, t, i) {
+  const { type: n, converted_type: r, logical_type: f } = t;
+  if (e === void 0) return e;
+  if (n === "BOOLEAN") return e[0] === 1;
+  if (n === "BYTE_ARRAY") return i.stringFromBytes(e);
+  const s = new DataView(e.buffer, e.byteOffset, e.byteLength);
+  if (n === "FLOAT" && s.byteLength === 4) return s.getFloat32(0, !0);
+  if (n === "DOUBLE" && s.byteLength === 8) return s.getFloat64(0, !0);
+  if (n === "INT32" && r === "DECIMAL" && s.byteLength === 4)
+    return s.getInt32(0, !0) * 10 ** -(t.scale || 0);
+  if (n === "INT64" && r === "DECIMAL" && s.byteLength === 8)
+    return Number(s.getBigInt64(0, !0)) * 10 ** -(t.scale || 0);
+  if (n === "INT32" && r === "DATE") return i.dateFromDays(s.getInt32(0, !0));
+  if (n === "INT64" && r === "TIMESTAMP_MILLIS") return i.timestampFromMilliseconds(s.getBigInt64(0, !0));
+  if (n === "INT64" && r === "TIMESTAMP_MICROS") return i.timestampFromMicroseconds(s.getBigInt64(0, !0));
+  if (n === "INT64" && f?.type === "TIMESTAMP" && f?.unit === "NANOS") return i.timestampFromNanoseconds(s.getBigInt64(0, !0));
+  if (n === "INT64" && f?.type === "TIMESTAMP" && f?.unit === "MICROS") return i.timestampFromMicroseconds(s.getBigInt64(0, !0));
+  if (n === "INT64" && f?.type === "TIMESTAMP") return i.timestampFromMilliseconds(s.getBigInt64(0, !0));
+  const o = r?.startsWith("UINT_") || f?.type === "INTEGER" && !f.isSigned;
+  return n === "INT32" && o && s.byteLength === 4 ? s.getUint32(0, !0) : n === "INT64" && o && s.byteLength === 8 ? s.getBigUint64(0, !0) : n === "INT32" && s.byteLength === 4 ? s.getInt32(0, !0) : n === "INT64" && s.byteLength === 8 ? s.getBigInt64(0, !0) : r === "DECIMAL" ? at(e) * 10 ** -(t.scale || 0) : f?.type === "FLOAT16" ? ut(e) : f?.type === "UUID" ? i.uuidFromBytes(e) : e;
+}
+function nn(e, t, i = void 0) {
+  i = { ...oe, ...i };
+  const n = X(e);
+  return {
+    null_pages: n.field_1,
+    min_values: n.field_2.map((r) => J(r, t, i)),
+    max_values: n.field_3.map((r) => J(r, t, i)),
+    boundary_order: Ct[n.field_4],
+    null_counts: n.field_5,
+    repetition_level_histograms: n.field_6,
+    definition_level_histograms: n.field_7
+  };
+}
+function ve(e) {
+  const t = X(e);
+  return {
+    // @ts-ignore
+    page_locations: t.field_1.map((i) => ({
+      offset: i.field_1,
+      compressed_page_size: i.field_2,
+      first_row_index: i.field_3
+    })),
+    unencoded_byte_array_data_bytes: t.field_2
+  };
+}
+const L = 0xffffffffffffffffn, V = 0x9e3779b185ebca87n, ee = 0xc2b2ae3d27d4eb4fn, Ge = 0x165667b19e3779f9n, wt = 0x85ebca77c2b2ae63n, Ve = 0x27d4eb2f165667c5n;
+function C(e, t) {
+  return (e << t | e >> 64n - t) & L;
+}
+function Z(e, t) {
+  return e = e + t * ee & L, e = C(e, 31n), e * V & L;
+}
+function ae(e, t) {
+  return e ^= Z(0n, t), e * V + wt & L;
+}
+function $(e, t = 0n) {
+  const i = new DataView(e.buffer, e.byteOffset, e.byteLength), n = e.byteLength;
+  let r = 0, f;
+  if (n >= 32) {
+    let s = t + V + ee & L, o = t + ee & L, c = t, d = t - V & L;
+    for (; r + 32 <= n; )
+      s = Z(s, i.getBigUint64(r, !0)), r += 8, o = Z(o, i.getBigUint64(r, !0)), r += 8, c = Z(c, i.getBigUint64(r, !0)), r += 8, d = Z(d, i.getBigUint64(r, !0)), r += 8;
+    f = C(s, 1n) + C(o, 7n) + C(c, 12n) + C(d, 18n) & L, f = ae(f, s), f = ae(f, o), f = ae(f, c), f = ae(f, d);
+  } else
+    f = t + Ve & L;
+  for (f = f + BigInt(n) & L; r + 8 <= n; )
+    f ^= Z(0n, i.getBigUint64(r, !0)), f = C(f, 27n) * V + wt & L, r += 8;
+  for (r + 4 <= n && (f ^= BigInt(i.getUint32(r, !0)) * V & L, f = C(f, 23n) * ee + Ge & L, r += 4); r < n; )
+    f ^= BigInt(i.getUint8(r)) * Ve & L, f = C(f, 11n) * V & L, r += 1;
+  return f ^= f >> 33n, f = f * ee & L, f ^= f >> 29n, f = f * Ge & L, f ^= f >> 32n, f;
+}
+const rn = new TextEncoder(), fn = new Uint32Array([
+  1203114875,
+  1150766481,
+  2284105051,
+  2729912477,
+  1884591559,
+  770785867,
+  2667333959,
+  1550580529
+]);
+function sn(e, t) {
+  return Number((e >> 32n) * BigInt(t) >> 32n);
+}
+function on(e) {
+  const t = new Uint32Array(8), i = Number(e & 0xffffffffn) | 0;
+  for (let n = 0; n < 8; n++)
+    t[n] = 1 << (Math.imul(i, fn[n]) >>> 27);
+  return t;
+}
+function ze(e, t) {
+  const i = sn(t, e.length >> 3) << 3, n = on(t);
+  for (let r = 0; r < 8; r++)
+    if ((e[i + r] & n[r]) === 0) return !1;
+  return !0;
+}
+function ln(e) {
+  const t = X(e), i = t.field_1;
+  if (typeof i != "number" || i <= 0 || i % 32 !== 0 || !t.field_2?.field_1 || !t.field_3?.field_1 || !t.field_4?.field_1) return;
+  const { view: n, offset: r } = e;
+  if (r + i > n.byteLength)
+    throw new Error(`parquet bloom filter truncated: need ${i} bytes, have ${n.byteLength - r}`);
+  const f = new Uint32Array(i >> 2);
+  for (let s = 0; s < f.length; s++)
+    f[s] = n.getUint32(r + s * 4, !0);
+  return e.offset = r + i, { numBytes: i, blocks: f };
+}
+function We(e, t) {
+  if (e == null) return;
+  const { type: i, converted_type: n, logical_type: r } = t;
+  if (i === "BOOLEAN")
+    return typeof e != "boolean" ? void 0 : $(new Uint8Array([e ? 1 : 0]));
+  if (i === "FLOAT") {
+    if (typeof e != "number") return;
+    const f = new ArrayBuffer(4);
+    return new DataView(f).setFloat32(0, e, !0), $(new Uint8Array(f));
+  }
+  if (i === "DOUBLE") {
+    if (typeof e != "number") return;
+    const f = new ArrayBuffer(8);
+    return new DataView(f).setFloat64(0, e, !0), $(new Uint8Array(f));
+  }
+  if (i === "INT32") {
+    if (n === "DATE" || n === "DECIMAL" || n === "TIME_MILLIS" || r?.type === "DATE" || r?.type === "TIME" || r?.type === "DECIMAL" || typeof e != "number" || !Number.isInteger(e)) return;
+    const f = new ArrayBuffer(4);
+    return new DataView(f).setInt32(0, e | 0, !0), $(new Uint8Array(f));
+  }
+  if (i === "INT64") {
+    if (n === "TIMESTAMP_MILLIS" || n === "TIMESTAMP_MICROS" || n === "TIME_MICROS" || n === "DECIMAL" || r?.type === "TIMESTAMP" || r?.type === "TIME" || r?.type === "DECIMAL") return;
+    let f;
+    if (typeof e == "bigint") f = e;
+    else if (typeof e == "number" && Number.isSafeInteger(e)) f = BigInt(e);
+    else return;
+    const s = new ArrayBuffer(8);
+    return new DataView(s).setBigUint64(0, BigInt.asUintN(64, f), !0), $(new Uint8Array(s));
+  }
+  if (i === "BYTE_ARRAY")
+    return n === "JSON" || n === "BSON" || n === "DECIMAL" || r?.type === "JSON" || r?.type === "BSON" || r?.type === "VARIANT" || r?.type === "GEOMETRY" || r?.type === "GEOGRAPHY" ? void 0 : typeof e == "string" ? $(rn.encode(e)) : e instanceof Uint8Array ? $(e) : void 0;
+  if (i === "FIXED_LEN_BYTE_ARRAY")
+    return n === "DECIMAL" || n === "INTERVAL" || r?.type === "DECIMAL" || r?.type === "UUID" || r?.type === "FLOAT16" || r?.type === "GEOMETRY" || r?.type === "GEOGRAPHY" ? void 0 : e instanceof Uint8Array ? $(e) : void 0;
+}
+function cn(e) {
+  const t = /* @__PURE__ */ new Set();
+  return Te(e, t), t;
+}
+function Te(e, t) {
+  if (e) {
+    if ("$and" in e && Array.isArray(e.$and)) {
+      for (const i of e.$and) Te(i, t);
+      return;
+    }
+    if ("$or" in e && Array.isArray(e.$or)) {
+      for (const i of e.$or) Te(i, t);
+      return;
+    }
+    if (!("$nor" in e))
+      for (const [i, n] of Object.entries(e))
+        i.startsWith("$") || (typeof n == "object" && n !== null && !Array.isArray(n) ? ("$eq" in n || "$in" in n) && t.add(i) : t.add(i));
+  }
+}
+function He(e) {
+  if (e === void 0) return null;
+  if (typeof e == "bigint") return Number(e);
+  if (Object.is(e, -0)) return 0;
+  if (Array.isArray(e)) return e.map(He);
+  if (e instanceof Uint8Array) return Array.from(e);
+  if (e instanceof Date) return e.toISOString();
+  if (e instanceof Object) {
+    const t = {};
+    for (const i of Object.keys(e))
+      e[i] !== void 0 && (t[i] = He(e[i]));
+    return t;
+  }
+  return e;
+}
+function xe(e, t) {
+  for (let n = 0; n < t.length; n += 1e4)
+    e.push(...t.slice(n, n + 1e4));
+}
+function P(e, t, i = !0) {
+  if (i ? e === t : e == t) return !0;
+  if (!e || !t || typeof e != "object" || typeof t != "object") return !1;
+  if (e instanceof Uint8Array && t instanceof Uint8Array) {
+    if (e.length !== t.length) return !1;
+    for (let r = 0; r < e.length; r++)
+      if (e[r] !== t[r]) return !1;
+    return !0;
+  }
+  if (e instanceof Date || t instanceof Date)
+    return e instanceof Date && t instanceof Date && e.getTime() === t.getTime();
+  if (Array.isArray(e) && Array.isArray(t)) {
+    if (e.length !== t.length) return !1;
+    for (let r = 0; r < e.length; r++)
+      if (!P(e[r], t[r], i)) return !1;
+    return !0;
+  }
+  const n = Object.keys(e);
+  if (n.length !== Object.keys(t).length) return !1;
+  for (const r of n)
+    if (!P(e[r], t[r], i)) return !1;
+  return !0;
+}
+async function Ke(e, t = {}, i = globalThis.fetch) {
+  const n = new AbortController(), r = new Headers(t.headers);
+  r.set("Range", "bytes=0-0");
+  const f = await i(e, {
+    ...t,
+    headers: r,
+    signal: n.signal
+  });
+  if (!f.ok) throw new Error(`fetch with range failed ${f.status}`);
+  if (f.status === 206) {
+    const s = f.headers.get("Content-Range");
+    if (!s) throw new Error("missing content-range header");
+    const o = s.match(/bytes \d+-\d+\/(\d+)/);
+    if (!o) throw new Error(`invalid content-range header: ${s}`);
+    return parseInt(o[1]);
+  }
+  if (f.status === 200) {
+    const s = f.headers.get("Content-Length");
+    if (n.abort(), s) return parseInt(s);
+  }
+  throw new Error("server does not support range requests and missing content-length");
+}
+async function an(e, t, i) {
+  const n = i ?? globalThis.fetch, r = await n(e, { ...t, method: "HEAD" });
+  if (r.status === 403)
+    return Ke(e, t, n);
+  if (!r.ok) throw new Error(`fetch head failed ${r.status}`);
+  const f = r.headers.get("Content-Length");
+  return f ? parseInt(f) : Ke(e, t, n);
+}
+async function Jn({ url: e, byteLength: t, requestInit: i, fetch: n }) {
+  if (!e) throw new Error("missing url");
+  const r = n ?? globalThis.fetch;
+  t ??= await an(e, i, r);
+  let f;
+  const s = i || {};
+  return {
+    byteLength: t,
+    async slice(o, c) {
+      if (f)
+        return f.then((u) => u.slice(o, c));
+      const d = new Headers(s.headers), a = c === void 0 ? "" : c - 1;
+      d.set("Range", `bytes=${o}-${a}`);
+      const l = await r(e, { ...s, headers: d });
+      if (!l.ok || !l.body) throw new Error(`fetch failed ${l.status}`);
+      if (l.status === 200)
+        return f = l.arrayBuffer(), f.then((u) => u.slice(o, c));
+      if (l.status === 206)
+        return l.arrayBuffer();
+      throw new Error(`fetch received unexpected status code ${l.status}`);
+    }
+  };
+}
+function Xn({ byteLength: e, slice: t }, { minSize: i = mt } = {}) {
+  if (e < i) {
+    const r = t(0, e);
+    return {
+      byteLength: e,
+      async slice(f, s) {
+        return (await r).slice(f, s);
+      }
+    };
+  }
+  const n = /* @__PURE__ */ new Map();
+  return {
+    byteLength: e,
+    /**
+     * @param {number} start
+     * @param {number} [end]
+     * @returns {Awaitable<ArrayBuffer>}
+     */
+    slice(r, f) {
+      const s = un(r, f, e), o = n.get(s);
+      if (o) return o;
+      const c = t(r, f);
+      return n.set(s, c), c;
+    }
+  };
+}
+function un(e, t, i) {
+  if (e < 0) {
+    if (t !== void 0) throw new Error(`invalid suffix range [${e}, ${t}]`);
+    return i === void 0 ? `${e},` : `${i + e},${i}`;
+  } else if (t !== void 0) {
+    if (e > t) throw new Error(`invalid empty range [${e}, ${t}]`);
+    return `${e},${t}`;
+  } else return i === void 0 ? `${e},` : `${e},${i}`;
+}
+function pt(e) {
+  if (!e) return [];
+  if (e.length === 1) return e[0];
+  const t = [];
+  for (const i of e)
+    xe(t, i);
+  return t;
+}
+const Qe = new TextEncoder();
+function ie(e) {
+  if (!e) return [];
+  const t = [];
+  return "$and" in e && Array.isArray(e.$and) ? t.push(...e.$and.flatMap(ie)) : "$or" in e && Array.isArray(e.$or) ? t.push(...e.$or.flatMap(ie)) : "$nor" in e && Array.isArray(e.$nor) ? t.push(...e.$nor.flatMap(ie)) : t.push(...Object.keys(e)), [...new Set(t)];
+}
+function dn(e) {
+  return [...new Set(ie(e).map((t) => t.split(".")[0]))];
+}
+function z(e, t, i = !0) {
+  return "$and" in t && Array.isArray(t.$and) ? t.$and.every((n) => z(e, n, i)) : "$or" in t && Array.isArray(t.$or) ? t.$or.some((n) => z(e, n, i)) : "$nor" in t && Array.isArray(t.$nor) ? !t.$nor.some((n) => z(e, n, i)) : Object.entries(t).every(([n, r]) => {
+    const f = hn(e, n);
+    return typeof r != "object" || r === null || Array.isArray(r) ? P(f, r, i) : Object.entries(r || {}).every(([s, o]) => s === "$gt" ? f > o : s === "$gte" ? f >= o : s === "$lt" ? f < o : s === "$lte" ? f <= o : s === "$eq" ? P(f, o, i) : s === "$ne" ? !P(f, o, i) : s === "$in" ? Array.isArray(o) && o.includes(f) : s === "$nin" ? Array.isArray(o) && !o.includes(f) : s === "$not" ? !z({ [n]: f }, { [n]: o }, i) : !0);
+  });
+}
+function re({ rowGroup: e, physicalColumns: t, filter: i, strict: n = !0, bloomFilters: r, schemaElements: f }) {
+  if (!i) return !1;
+  if ("$and" in i && Array.isArray(i.$and))
+    return i.$and.some((s) => re({ rowGroup: e, physicalColumns: t, filter: s, strict: n, bloomFilters: r, schemaElements: f }));
+  if ("$or" in i && Array.isArray(i.$or))
+    return i.$or.every((s) => re({ rowGroup: e, physicalColumns: t, filter: s, strict: n, bloomFilters: r, schemaElements: f }));
+  if ("$nor" in i && Array.isArray(i.$nor))
+    return !1;
+  for (const [s, o] of Object.entries(i)) {
+    const c = t.indexOf(s);
+    if (c === -1) continue;
+    const d = e.columns[c].meta_data?.statistics, { min: a, max: l, min_value: u, max_value: g, null_count: h } = d || {}, m = u !== void 0 ? u : a, y = g !== void 0 ? g : l, _ = m !== void 0 && y !== void 0, w = r?.[s], p = f?.[s], I = z({ value: null }, { value: o }, n) && (h === void 0 || h > 0);
+    if (_ && !I && At(o, m, y, n, p))
+      return !0;
+    for (const [A, R] of Object.entries(o || {}))
+      if (w && p) {
+        if (A === "$eq") {
+          const B = We(R, p);
+          if (B !== void 0 && !ze(w.blocks, B)) return !0;
+        }
+        if (A === "$in" && Array.isArray(R) && R.length > 0) {
+          let B = !0;
+          for (const K of R) {
+            const M = We(K, p);
+            if (M === void 0 || ze(w.blocks, M)) {
+              B = !1;
+              break;
+            }
+          }
+          if (B) return !0;
+        }
+      }
+  }
+  return !1;
+}
+function At(e, t, i, n, r) {
+  if (t === void 0 || i === void 0) return !1;
+  const f = r?.type === "FLOAT" || r?.type === "DOUBLE" || r?.logical_type?.type === "FLOAT16";
+  for (const [s, o] of Object.entries(e || {})) {
+    const c = Q(t, o, n, r), d = Q(i, o, n, r), l = !(t instanceof Uint8Array || i instanceof Uint8Array) && (r?.type !== "BYTE_ARRAY" || typeof o == "string" && [...o].every((u) => u.charCodeAt(0) <= 127));
+    if (s === "$gt" && l && d !== void 0 && d <= 0 || s === "$gte" && l && d !== void 0 && d < 0 || s === "$lt" && l && c !== void 0 && c >= 0 || s === "$lte" && l && c !== void 0 && c > 0) return !0;
+    if (s === "$eq") {
+      const u = Q(o, t, n, r), g = Q(o, i, n, r);
+      if (u !== void 0 && u < 0 || g !== void 0 && g > 0) return !0;
+    }
+    if (s === "$ne" && !f && P(t, i, n) && P(t, o, n) || s === "$in" && Array.isArray(o) && o.every((u) => {
+      const g = Q(u, t, n, r), h = Q(u, i, n, r);
+      return g !== void 0 && g < 0 || h !== void 0 && h > 0;
+    }) || s === "$nin" && !f && Array.isArray(o) && P(t, i, n) && o.includes(t)) return !0;
+  }
+  return !1;
+}
+function Q(e, t, i, n) {
+  if (n?.type === "BYTE_ARRAY")
+    return typeof e != "string" || typeof t != "string" ? void 0 : Ze(Qe.encode(e), Qe.encode(t));
+  if (e instanceof Uint8Array || t instanceof Uint8Array)
+    return !(e instanceof Uint8Array) || !(t instanceof Uint8Array) ? void 0 : Ze(e, t);
+  if (e < t) return -1;
+  if (e > t) return 1;
+  if (P(e, t, i)) return 0;
+}
+function Ze(e, t) {
+  const i = Math.min(e.length, t.length);
+  for (let n = 0; n < i; n++) {
+    if (e[n] < t[n]) return -1;
+    if (e[n] > t[n]) return 1;
+  }
+  return e.length < t.length ? -1 : e.length > t.length ? 1 : 0;
+}
+function _n(e, t) {
+  return z({ value: null }, { value: e }, t);
+}
+function Le(e, t, i, n = !0) {
+  if (!e) return;
+  if ("$and" in e && Array.isArray(e.$and)) {
+    let f;
+    for (const s of e.$and)
+      f = Je(f, Le(s, t, i, n));
+    return f;
+  }
+  if ("$or" in e && Array.isArray(e.$or)) {
+    let f = [];
+    for (const s of e.$or) {
+      const o = Le(s, t, i, n);
+      if (!o) return;
+      f = gn(f, o);
+    }
+    return f;
+  }
+  if ("$nor" in e && Array.isArray(e.$nor))
+    return;
+  let r;
+  for (const [f, s] of Object.entries(e)) {
+    const o = t[f];
+    if (!o) continue;
+    const c = _n(s, n), d = [];
+    for (let a = 0; a < o.pageStarts.length; a++) {
+      const l = o.pageStarts[a], u = a + 1 < o.pageStarts.length ? o.pageStarts[a + 1] : i, g = o.nullCounts?.[a], h = c && (g === void 0 || g > 0);
+      if (!(!o.nullPages[a] && !h && At(s, o.minValues[a], o.maxValues[a], n, o.element))) {
+        const y = d[d.length - 1];
+        y && y[1] === l ? y[1] = u : d.push([l, u]);
+      }
+    }
+    r = Je(r, d);
+  }
+  return r;
+}
+function Je(e, t) {
+  if (!e) return t;
+  if (!t) return e;
+  const i = [];
+  let n = 0, r = 0;
+  for (; n < e.length && r < t.length; ) {
+    const f = Math.max(e[n][0], t[r][0]), s = Math.min(e[n][1], t[r][1]);
+    f < s && i.push([f, s]), e[n][1] < t[r][1] ? n++ : r++;
+  }
+  return i;
+}
+function gn(e, t) {
+  const i = [];
+  let n = 0, r = 0;
+  for (; n < e.length || r < t.length; ) {
+    const f = r >= t.length || n < e.length && e[n][0] <= t[r][0] ? e[n++] : t[r++], s = i[i.length - 1];
+    s && f[0] <= s[1] ? s[1] = Math.max(s[1], f[1]) : i.push([f[0], f[1]]);
+  }
+  return i;
+}
+function hn(e, t) {
+  let i = e;
+  for (const n of t.split("."))
+    i = i?.[n];
+  return i;
+}
+const yn = 1 << 21;
+function mn({ metadata: e, rowStart: t = 0, rowEnd: i = 1 / 0, columns: n, filter: r, filterStrict: f = !0, useOffsetIndex: s = !1, bloomFiltersByGroup: o, schemaElements: c, pageRangesByGroup: d, pageLocationsByGroup: a }) {
+  if (!e) throw new Error("parquetPlan requires metadata");
+  const l = [], u = [], g = [], h = F(e), m = Re(h), y = r ? {
+    ...Et(h),
+    ...c
+  } : c;
+  let _ = 0, w = 0;
+  for (const p of e.row_groups) {
+    const I = Number(p.num_rows), A = _ + I, R = o?.[w];
+    if (I > 0 && A > t && _ < i && !re({ rowGroup: p, physicalColumns: m, filter: r, strict: f, bloomFilters: R, schemaElements: y })) {
+      const B = Math.max(t - _, 0), K = Math.min(i - _, I), M = d?.[w], Y = a?.[w];
+      let N = M ? M.map(([x, b]) => [Math.max(x, B), Math.min(b, K)]).filter(([x, b]) => x < b) : [[B, K]];
+      if (N.length > 1 && (p.columns.every((b) => {
+        const T = b.meta_data?.path_in_schema[0], E = b.meta_data?.path_in_schema.join(".");
+        return n && T && !n.includes(T) ? !0 : !!(b.offset_index_offset && b.offset_index_length) || !!(E && Y?.[E]);
+      }) ? N = wn(N, p, n, Y) : N = [[N[0][0], N[N.length - 1][1]]]), N.length) {
+        const x = [], b = N.length > 1 || N[0][0] > 0 || N[0][1] < I;
+        for (const E of p.columns) {
+          const v = E.meta_data;
+          if (E.file_path) throw new Error("parquet file_path not supported");
+          if (!v) throw new Error("parquet column metadata is undefined");
+          if (!n || n.includes(v.path_in_schema[0])) {
+            const S = v.dictionary_page_offset || v.data_page_offset, O = Number(S), U = Number(S + v.total_compressed_size), q = Y?.[v.path_in_schema.join(".")];
+            if (q && b)
+              x.push({
+                columnMetadata: v,
+                pageLocations: q,
+                range: { startByte: O, endByte: U }
+              });
+            else if ((s || M) && E.offset_index_offset && E.offset_index_length && b) {
+              const j = Number(E.offset_index_offset);
+              x.push({
+                columnMetadata: v,
+                offsetIndex: {
+                  startByte: j,
+                  endByte: j + E.offset_index_length
+                },
+                range: { startByte: O, endByte: U }
+              });
+            } else
+              x.push({
+                columnMetadata: v,
+                range: { startByte: O, endByte: U }
+              });
+          }
+        }
+        for (const [E, v] of N)
+          l.push({ chunks: x, rowGroup: p, groupStart: _, groupRows: I, selectStart: E, selectEnd: v });
+        let T;
+        for (const E of x)
+          if (!("pageLocations" in E)) if ("offsetIndex" in E)
+            g.push(E.offsetIndex);
+          else {
+            const { range: v } = E;
+            n ? u.push(v) : T && v.endByte - T.startByte <= yn ? T.endByte = v.endByte : (T && u.push(T), T = { ...v });
+          }
+        T && u.push(T);
+      }
+    }
+    _ = A, w++;
+  }
+  return isFinite(i) || (i = _), u.push(...g), { metadata: e, rowStart: t, rowEnd: i, columns: n, fetches: u, groups: l };
+}
+function wn(e, t, i, n) {
+  const r = t.columns.filter((s) => !i || i.includes(s.meta_data?.path_in_schema[0] || "")).map((s) => n?.[s.meta_data?.path_in_schema.join(".") || ""]), f = [];
+  for (const s of e) {
+    const o = f[f.length - 1], c = o && r.some((d) => {
+      if (!d) return !0;
+      const a = Xe(o, d, Number(t.num_rows)), l = Xe(s, d, Number(t.num_rows));
+      return a[0] <= l[1] && l[0] <= a[1];
+    });
+    o && c ? o[1] = s[1] : f.push([...s]);
+  }
+  return f;
+}
+function Xe([e, t], i, n) {
+  let r = 1 / 0, f = -1 / 0;
+  for (let s = 0; s < i.length; s++) {
+    const o = Number(i[s].first_row_index);
+    (s + 1 < i.length ? Number(i[s + 1].first_row_index) : n) > e && o < t && (r = Math.min(r, s), f = s);
+  }
+  return [r, f];
+}
+async function pn({ file: e, metadata: t, filter: i, filterStrict: n = !0 }) {
+  const r = t.row_groups.map(() => (
+    /** @type {Record<string, BloomFilter>} */
+    {}
+  )), f = cn(i);
+  if (f.size === 0) return r;
+  const s = Re(F(t)), o = [];
+  return t.row_groups.forEach((c, d) => {
+    if (!re({ rowGroup: c, physicalColumns: s, filter: i, strict: n }))
+      for (const a of f) {
+        const l = s.indexOf(a);
+        if (l === -1) continue;
+        const u = c.columns[l]?.meta_data;
+        if (!u?.bloom_filter_offset || !u.bloom_filter_length) continue;
+        const g = Number(u.bloom_filter_offset), h = g + u.bloom_filter_length;
+        o.push((async () => {
+          const m = await e.slice(g, h), y = ln({ view: new DataView(m), offset: 0 });
+          y && (r[d][a] = y);
+        })());
+      }
+  }), o.length && await Promise.all(o), r;
+}
+async function An({ file: e, metadata: t, filter: i, filterStrict: n = !0, rowStart: r = 0, rowEnd: f = 1 / 0, columns: s, bloomFiltersByGroup: o, schemaElements: c, parsers: d }) {
+  const a = t.row_groups.map(() => {
+  }), l = t.row_groups.map(() => (
+    /** @type {Record<string, PageLocation[]>} */
+    {}
+  ));
+  if (i && "$nor" in i && Array.isArray(i.$nor))
+    return { pageRangesByGroup: a, pageLocationsByGroup: l };
+  const u = ie(i);
+  if (!u.length) return { pageRangesByGroup: a, pageLocationsByGroup: l };
+  const g = F(t), h = Re(g), m = {
+    ...Et(g),
+    ...c
+  }, y = [], _ = [], w = [];
+  let p = 0;
+  if (t.row_groups.forEach((I, A) => {
+    const R = Number(I.num_rows), B = p + R, K = R > 0 && B > r && p < f;
+    if (p = B, !K || re({ rowGroup: I, physicalColumns: h, filter: i, strict: n, bloomFilters: o?.[A], schemaElements: m })) return;
+    const M = {};
+    let Y = 0;
+    const N = /* @__PURE__ */ new Set();
+    let x = !1;
+    for (const b of u) {
+      const T = h.indexOf(b);
+      if (T === -1) continue;
+      const E = I.columns[T];
+      if (!E?.meta_data || !E.column_index_offset || !E.column_index_length || !E.offset_index_offset || !E.offset_index_length) continue;
+      const S = m[b];
+      if (!S) continue;
+      x = !0, N.add(b);
+      const O = Number(E.column_index_offset), U = Number(E.offset_index_offset), q = O + E.column_index_length, j = U + E.offset_index_length;
+      y.push(
+        { startByte: O, endByte: q },
+        { startByte: U, endByte: j }
+      ), Y++, _.push(async (De) => {
+        const [Ot, Dt] = await Promise.all([
+          De.slice(O, q),
+          De.slice(U, j)
+        ]), le = nn({ view: new DataView(Ot), offset: 0 }, S, d), Me = ve({ view: new DataView(Dt), offset: 0 });
+        l[A][b] = Me.page_locations, M[b] = {
+          minValues: le.min_values,
+          maxValues: le.max_values,
+          nullPages: le.null_pages,
+          nullCounts: le.null_counts,
+          pageStarts: Me.page_locations.map((Mt) => Number(Mt.first_row_index)),
+          element: S
+        };
+      });
+    }
+    if (x)
+      for (const b of I.columns) {
+        const T = b.meta_data;
+        if (!T) continue;
+        const E = T.path_in_schema[0], v = T.path_in_schema.join(".");
+        if (s && !s.includes(E) || N.has(v) || !b.offset_index_offset || !b.offset_index_length) continue;
+        N.add(v);
+        const S = Number(b.offset_index_offset), O = S + b.offset_index_length;
+        y.push({ startByte: S, endByte: O }), Y++, _.push(async (U) => {
+          const q = await U.slice(S, O), j = ve({ view: new DataView(q), offset: 0 });
+          l[A][v] = j.page_locations;
+        });
+      }
+    Y && w.push({ rgIdx: A, groupRows: R, columnPages: M });
+  }), _.length) {
+    const I = It(e, { fetches: En(y) });
+    await Promise.all(_.map((A) => A(I)));
+    for (const { rgIdx: A, groupRows: R, columnPages: B } of w)
+      a[A] = Le(i, B, R, n);
+  }
+  return { pageRangesByGroup: a, pageLocationsByGroup: l };
+}
+function En(e) {
+  const t = e.map((n) => ({ ...n })).sort((n, r) => n.startByte - r.startByte || n.endByte - r.endByte), i = [];
+  for (const n of t) {
+    const r = i[i.length - 1];
+    r && n.startByte <= r.endByte ? r.endByte = Math.max(r.endByte, n.endByte) : i.push(n);
+  }
+  return i;
+}
+function Et(e) {
+  const t = {};
+  function i(n) {
+    if (n.children.length)
+      for (const r of n.children) i(r);
+    else
+      t[n.path.join(".")] = n.element;
+  }
+  return i(e), t;
+}
+function It(e, { fetches: t }) {
+  const i = t.map(({ startByte: n, endByte: r }) => e.slice(n, r));
+  return {
+    byteLength: e.byteLength,
+    slice(n, r = e.byteLength) {
+      const f = t.findIndex(({ startByte: s, endByte: o }) => s <= n && r <= o);
+      if (f < 0)
+        return e.slice(n, r);
+      if (t[f].startByte !== n || t[f].endByte !== r) {
+        const s = n - t[f].startByte, o = r - t[f].startByte;
+        return i[f] instanceof Promise ? i[f].then((c) => c.slice(s, o)) : i[f].slice(s, o);
+      } else
+        return i[f];
+    }
+  };
+}
+const Se = new TextDecoder(), et = /* @__PURE__ */ new WeakMap();
+function bt(e, t = oe) {
+  if (Array.isArray(e))
+    return e.map((i) => bt(i, t));
+  if (typeof e != "object") return e;
+  if ("metadata" in e) {
+    const i = In(e.metadata), n = e.typed_value && ue(e.typed_value, i, t), r = e.value && fe(ge(e.value), i, t);
+    return n && r ? { ...r, ...n } : n ?? r;
+  }
+  return e;
+}
+function ue(e, t, i) {
+  if (e instanceof Date) return e;
+  if (e && typeof e == "object" && !Array.isArray(e) && !(e instanceof Uint8Array)) {
+    if ("typed_value" in e && e.typed_value !== null && e.typed_value !== void 0)
+      return ue(e.typed_value, t, i);
+    if ("value" in e && e.value instanceof Uint8Array)
+      return fe(ge(e.value), t, i);
+    if ("typed_value" in e || "value" in e)
+      return null;
+    const n = {};
+    for (const [r, f] of Object.entries(e))
+      t.dictionary.includes(r) && (n[r] = ue(f, t, i));
+    return n;
+  }
+  return e instanceof Uint8Array ? fe(ge(e), t, i) : Array.isArray(e) ? e.map((n) => ue(n, t, i)) : e;
+}
+function ge(e) {
+  return { view: new DataView(e.buffer, e.byteOffset, e.byteLength), offset: 0 };
+}
+function In(e) {
+  let t = et.get(e.buffer);
+  t || (t = /* @__PURE__ */ new Map(), et.set(e.buffer, t));
+  const i = `${e.byteOffset}:${e.byteLength}`, n = t.get(i);
+  if (n) return n;
+  const r = ge(e), f = r.view.getUint8(r.offset++), s = f & 15;
+  if (s !== 1) throw new Error(`parquet unsupported variant metadata version: ${s}`);
+  const o = (f >> 4 & 1) === 1, c = (f >> 6 & 3) + 1, d = H(r, c), a = new Array(d + 1);
+  for (let h = 0; h < a.length; h++)
+    a[h] = H(r, c);
+  const l = r.offset, u = new Array(d);
+  for (let h = 0; h < d; h++) {
+    const m = a[h], y = a[h + 1], _ = new Uint8Array(e.buffer, e.byteOffset + l + m, y - m);
+    u[h] = Se.decode(_);
+  }
+  const g = { dictionary: u, sorted: o };
+  return t.set(i, g), g;
+}
+function H(e, t) {
+  let i = 0;
+  for (let n = 0; n < t; n++)
+    i |= e.view.getUint8(e.offset + n) << n * 8;
+  return e.offset += t, i;
+}
+function fe(e, t, i) {
+  const n = e.view.getUint8(e.offset++), r = n & 3, f = n >> 2;
+  if (r === 0) return bn(e, f, i);
+  if (r === 2) return vn(e, f, t, i);
+  if (r === 3) return Tn(e, f, t, i);
+  const s = new Uint8Array(e.view.buffer, e.view.byteOffset + e.offset, f);
+  return e.offset += f, Se.decode(s);
+}
+function bn(e, t, i) {
+  switch (t) {
+    case 0:
+      return null;
+    case 1:
+      return !0;
+    case 2:
+      return !1;
+    case 3: {
+      const n = e.view.getInt8(e.offset);
+      return e.offset += 1, n;
+    }
+    case 4: {
+      const n = e.view.getInt16(e.offset, !0);
+      return e.offset += 2, n;
+    }
+    case 5: {
+      const n = e.view.getInt32(e.offset, !0);
+      return e.offset += 4, n;
+    }
+    case 6: {
+      const n = e.view.getBigInt64(e.offset, !0);
+      return e.offset += 8, n;
+    }
+    case 7: {
+      const n = e.view.getFloat64(e.offset, !0);
+      return e.offset += 8, n;
+    }
+    case 8:
+      return we(e, 4);
+    case 9:
+      return we(e, 8);
+    case 10:
+      return we(e, 16);
+    case 11: {
+      const n = e.view.getInt32(e.offset, !0);
+      return e.offset += 4, i.dateFromDays(n);
+    }
+    case 12:
+    // timestamp_micros (utc)
+    case 13: {
+      const n = e.view.getBigInt64(e.offset, !0);
+      return e.offset += 8, i.timestampFromMicroseconds(n);
+    }
+    case 14: {
+      const n = e.view.getFloat32(e.offset, !0);
+      return e.offset += 4, n;
+    }
+    case 15:
+      return tt(e);
+    case 16: {
+      const n = tt(e);
+      return Se.decode(n);
+    }
+    case 17: {
+      const n = e.view.getBigInt64(e.offset, !0);
+      return e.offset += 8, n;
+    }
+    case 18:
+    // timestamp_nanos (utc)
+    case 19: {
+      const n = e.view.getBigInt64(e.offset, !0);
+      return e.offset += 8, i.timestampFromNanoseconds(n);
+    }
+    case 20: {
+      const n = new Uint8Array(e.view.buffer, e.view.byteOffset + e.offset, 16);
+      e.offset += 16;
+      const r = Array.from(n, (f) => f.toString(16).padStart(2, "0")).join("");
+      return `${r.slice(0, 8)}-${r.slice(8, 12)}-${r.slice(12, 16)}-${r.slice(16, 20)}-${r.slice(20)}`;
+    }
+    default:
+      throw new Error(`parquet unsupported variant primitive type: ${t}`);
+  }
+}
+function vn(e, t, i, n) {
+  const r = (t & 3) + 1, f = (t >> 2 & 3) + 1, o = t >> 4 & 1 ? H(e, 4) : e.view.getUint8(e.offset++), c = new Array(o);
+  for (let l = 0; l < o; l++)
+    c[l] = H(e, f);
+  const d = new Array(o + 1);
+  for (let l = 0; l < d.length; l++)
+    d[l] = H(e, r);
+  const a = {};
+  for (let l = 0; l < o; l++) {
+    const u = i.dictionary[c[l]], g = {
+      view: e.view,
+      offset: e.offset + d[l]
+    };
+    a[u] = fe(g, i, n);
+  }
+  return e.offset += d[d.length - 1], a;
+}
+function Tn(e, t, i, n) {
+  const r = t & 3, f = t >> 2 & 1, s = r + 1, o = H(e, f ? 4 : 1), c = new Array(o + 1);
+  for (let l = 0; l < c.length; l++)
+    c[l] = H(e, s);
+  const d = e.offset, a = new Array(o);
+  for (let l = 0; l < o; l++) {
+    const u = {
+      view: e.view,
+      offset: d + c[l]
+    };
+    a[l] = fe(u, i, n);
+  }
+  return e.offset = d + c[c.length - 1], a;
+}
+function we(e, t) {
+  const i = e.view.getUint8(e.offset);
+  e.offset += 1;
+  let n;
+  if (t === 4)
+    n = BigInt(e.view.getInt32(e.offset, !0)), e.offset += 4;
+  else if (t === 8)
+    n = e.view.getBigInt64(e.offset, !0), e.offset += 8;
+  else {
+    const r = e.view.getBigUint64(e.offset, !0);
+    n = e.view.getBigInt64(e.offset + 8, !0) << 64n | r, e.offset += 16;
+  }
+  return Number(n) * 10 ** -i;
+}
+function tt(e) {
+  const t = e.view.getUint32(e.offset, !0);
+  e.offset += 4;
+  const i = new Uint8Array(e.view.buffer, e.view.byteOffset + e.offset, t);
+  return e.offset += t, i;
+}
+function nt(e, t, i, n, r) {
+  const f = Be(r);
+  if (!t?.length && !i.length) {
+    if (!f || !n.length) return n;
+    t = new Array(n.length).fill(f);
+  }
+  const s = t?.length || i.length, o = r.map(({ element: h }) => h.repetition_type);
+  let c = 0;
+  const d = [e];
+  let a = e, l = 0, u = 0, g = 0;
+  if (i[0])
+    for (; l < o.length - 2 && g < i[0]; )
+      l++, o[l] !== "REQUIRED" && (a = a.at(-1), d.push(a), u++), o[l] === "REPEATED" && g++;
+  for (let h = 0; h < s; h++) {
+    const m = t?.length ? t[h] : f, y = i[h];
+    for (; l && (y < g || o[l] !== "REPEATED"); )
+      o[l] !== "REQUIRED" && (d.pop(), u--), o[l] === "REPEATED" && g--, l--;
+    for (a = d.at(-1); (l < o.length - 2 || o[l + 1] === "REPEATED") && (u < m || o[l + 1] === "REQUIRED"); ) {
+      if (l++, o[l] !== "REQUIRED") {
+        const _ = [];
+        a.push(_), a = _, d.push(_), u++;
+      }
+      o[l] === "REPEATED" && g++;
+    }
+    m === f ? a.push(n[c++]) : l === o.length - 2 ? a.push(null) : a.push([]);
+  }
+  if (!e.length)
+    for (let h = 0; h < f; h++) {
+      const m = [];
+      a.push(m), a = m;
+    }
+  return e;
+}
+function te(e, t, i, n = 0) {
+  const r = t.path.join("."), f = t.element.repetition_type === "OPTIONAL", s = f ? n + 1 : n;
+  if (Yt(t)) {
+    let o = t.children[0], c = s;
+    o.children.length === 1 && (o = o.children[0], c++), te(e, o, i, c);
+    const d = o.path.join("."), a = e.get(d);
+    if (!a) throw new Error("parquet list column missing values");
+    f && de(a, n), e.set(r, a), e.delete(d);
+    return;
+  }
+  if (qt(t)) {
+    const o = t.children[0].element.name;
+    te(e, t.children[0].children[0], i, s + 1), te(e, t.children[0].children[1], i, s + 1);
+    const c = e.get(`${r}.${o}.key`), d = e.get(`${r}.${o}.value`);
+    if (!c) throw new Error("parquet map column missing keys");
+    if (!d) throw new Error("parquet map column missing values");
+    if (c.length !== d.length)
+      throw new Error("parquet map column key/value length mismatch");
+    const a = vt(c, d, s);
+    f && de(a, n), e.delete(`${r}.${o}.key`), e.delete(`${r}.${o}.value`), e.set(r, a);
+    return;
+  }
+  if (t.children.length) {
+    const o = t.element.repetition_type === "REQUIRED" ? n : n + 1, c = {};
+    for (const a of t.children) {
+      te(e, a, i, o);
+      const l = e.get(a.path.join("."));
+      if (!l) throw new Error("parquet struct missing child data");
+      c[a.element.name] = l;
+    }
+    for (const a of t.children)
+      e.delete(a.path.join("."));
+    let d = Tt(c, o);
+    t.element.logical_type?.type === "VARIANT" && (d = bt(d, i)), f && de(d, n), e.set(r, d);
+  }
+}
+function de(e, t) {
+  for (let i = 0; i < e.length; i++)
+    t ? de(e[i], t - 1) : e[i] = e[i][0];
+}
+function vt(e, t, i) {
+  const n = [];
+  for (let r = 0; r < e.length; r++)
+    if (i)
+      n.push(vt(e[r], t[r], i - 1));
+    else if (e[r]) {
+      const f = {};
+      for (let s = 0; s < e[r].length; s++) {
+        const o = t[r][s];
+        f[e[r][s]] = o === void 0 ? null : o;
+      }
+      n.push(f);
+    } else
+      n.push(void 0);
+  return n;
+}
+function Tt(e, t) {
+  const i = Object.keys(e), n = e[i[0]]?.length, r = [];
+  for (let f = 0; f < n; f++) {
+    const s = {};
+    for (const o of i) {
+      if (e[o].length !== n) throw new Error("parquet struct parsing error");
+      s[o] = e[o][f];
+    }
+    t ? r.push(Tt(s, t - 1)) : r.push(s);
+  }
+  return r;
+}
+function se(e, t, i) {
+  const n = i instanceof Int32Array, r = W(e), f = W(e);
+  W(e);
+  let s = be(e), o = 0;
+  i[o++] = n ? Number(s) : s;
+  const c = r / f;
+  for (; o < t; ) {
+    const d = be(e), a = new Uint8Array(f);
+    for (let l = 0; l < f; l++)
+      a[l] = e.view.getUint8(e.offset++);
+    for (let l = 0; l < f && o < t; l++) {
+      const u = BigInt(a[l]);
+      if (u) {
+        let g = 0n, h = c;
+        const m = (1n << u) - 1n;
+        for (; h && o < t; ) {
+          let y = BigInt(e.view.getUint8(e.offset)) >> g & m;
+          for (g += u; g >= 8; )
+            g -= 8n, e.offset++, g && (y |= BigInt(e.view.getUint8(e.offset)) << u - g & m);
+          const _ = d + y;
+          s += _, i[o++] = n ? Number(s) : s, h--;
+        }
+        h && (e.offset += Math.ceil((h * Number(u) + Number(g)) / 8));
+      } else
+        for (let g = 0; g < c && o < t; g++)
+          s += d, i[o++] = n ? Number(s) : s;
+    }
+  }
+}
+function Lt(e, t, i) {
+  const n = new Int32Array(t);
+  se(e, t, n);
+  for (let r = 0; r < t; r++)
+    i[r] = new Uint8Array(e.view.buffer, e.view.byteOffset + e.offset, n[r]), e.offset += n[r];
+}
+function Ln(e, t, i) {
+  const n = new Int32Array(t);
+  se(e, t, n);
+  const r = new Int32Array(t);
+  se(e, t, r);
+  for (let f = 0; f < t; f++) {
+    const s = new Uint8Array(e.view.buffer, e.view.byteOffset + e.offset, r[f]);
+    n[f] ? (i[f] = new Uint8Array(n[f] + r[f]), i[f].set(i[f - 1].subarray(0, n[f])), i[f].set(s, n[f])) : i[f] = s, e.offset += r[f];
+  }
+}
+function k(e, t, i, n) {
+  n === void 0 && (n = e.view.getUint32(e.offset, !0), e.offset += 4);
+  const r = e.offset;
+  let f = 0;
+  for (; f < i.length; ) {
+    const s = W(e);
+    if (s & 1)
+      f = Rn(e, s, t, i, f);
+    else {
+      const o = s >>> 1;
+      Nn(e, o, t, i, f), f += o;
+    }
+  }
+  e.offset = r + n;
+}
+function Nn(e, t, i, n, r) {
+  const f = i + 7 >> 3;
+  let s = 0;
+  for (let o = 0; o < f; o++)
+    s |= e.view.getUint8(e.offset++) << (o << 3);
+  for (let o = 0; o < t; o++)
+    n[r + o] = s;
+}
+function Rn(e, t, i, n, r) {
+  let f = t >> 1 << 3;
+  const s = (1 << i) - 1;
+  let o = 0;
+  if (e.offset < e.view.byteLength)
+    o = e.view.getUint8(e.offset++);
+  else if (s)
+    throw new Error(`parquet bitpack offset ${e.offset} out of range`);
+  let c = 8, d = 0;
+  for (; f; )
+    d > 8 ? (d -= 8, c -= 8, o >>>= 8) : c - d < i ? (o |= e.view.getUint8(e.offset) << c, e.offset++, c += 8) : (r < n.length && (n[r++] = o >> d & s), f--, d += i);
+  return r;
+}
+function Nt(e, t, i, n) {
+  const r = Bn(i, n), f = new Uint8Array(t * r);
+  for (let s = 0; s < r; s++)
+    for (let o = 0; o < t; o++)
+      f[o * r + s] = e.view.getUint8(e.offset++);
+  if (i === "FLOAT") return new Float32Array(f.buffer);
+  if (i === "DOUBLE") return new Float64Array(f.buffer);
+  if (i === "INT32") return new Int32Array(f.buffer);
+  if (i === "INT64") return new BigInt64Array(f.buffer);
+  if (i === "FIXED_LEN_BYTE_ARRAY") {
+    const s = new Array(t);
+    for (let o = 0; o < t; o++)
+      s[o] = f.subarray(o * r, (o + 1) * r);
+    return s;
+  }
+  throw new Error(`parquet byte_stream_split unsupported type: ${i}`);
+}
+function Bn(e, t) {
+  switch (e) {
+    case "INT32":
+    case "FLOAT":
+      return 4;
+    case "INT64":
+    case "DOUBLE":
+      return 8;
+    case "FIXED_LEN_BYTE_ARRAY":
+      if (!t) throw new Error("parquet byteWidth missing type_length");
+      return t;
+    default:
+      throw new Error(`parquet unsupported type: ${e}`);
+  }
+}
+function Oe(e, t, i, n) {
+  if (i === 0) return [];
+  if (t === "BOOLEAN")
+    return xn(e, i);
+  if (t === "INT32")
+    return Sn(e, i);
+  if (t === "INT64")
+    return On(e, i);
+  if (t === "INT96")
+    return Dn(e, i);
+  if (t === "FLOAT")
+    return Mn(e, i);
+  if (t === "DOUBLE")
+    return Un(e, i);
+  if (t === "BYTE_ARRAY")
+    return Pn(e, i);
+  if (t === "FIXED_LEN_BYTE_ARRAY") {
+    if (!n) throw new Error("parquet missing fixed length");
+    return $n(e, i, n);
+  } else
+    throw new Error(`parquet unhandled type: ${t}`);
+}
+function xn(e, t) {
+  const i = new Array(t);
+  for (let n = 0; n < t; n++) {
+    const r = e.offset + (n / 8 | 0), f = n % 8, s = e.view.getUint8(r);
+    i[n] = (s & 1 << f) !== 0;
+  }
+  return e.offset += Math.ceil(t / 8), i;
+}
+function Sn(e, t) {
+  const i = (e.view.byteOffset + e.offset) % 4 ? new Int32Array(ye(e.view.buffer, e.view.byteOffset + e.offset, t * 4)) : new Int32Array(e.view.buffer, e.view.byteOffset + e.offset, t);
+  return e.offset += t * 4, i;
+}
+function On(e, t) {
+  const i = (e.view.byteOffset + e.offset) % 8 ? new BigInt64Array(ye(e.view.buffer, e.view.byteOffset + e.offset, t * 8)) : new BigInt64Array(e.view.buffer, e.view.byteOffset + e.offset, t);
+  return e.offset += t * 8, i;
+}
+function Dn(e, t) {
+  const i = new Array(t);
+  for (let n = 0; n < t; n++) {
+    const r = e.view.getBigInt64(e.offset + n * 12, !0), f = e.view.getInt32(e.offset + n * 12 + 8, !0);
+    i[n] = BigInt(f) << 64n | r;
+  }
+  return e.offset += t * 12, i;
+}
+function Mn(e, t) {
+  const i = (e.view.byteOffset + e.offset) % 4 ? new Float32Array(ye(e.view.buffer, e.view.byteOffset + e.offset, t * 4)) : new Float32Array(e.view.buffer, e.view.byteOffset + e.offset, t);
+  return e.offset += t * 4, i;
+}
+function Un(e, t) {
+  const i = (e.view.byteOffset + e.offset) % 8 ? new Float64Array(ye(e.view.buffer, e.view.byteOffset + e.offset, t * 8)) : new Float64Array(e.view.buffer, e.view.byteOffset + e.offset, t);
+  return e.offset += t * 8, i;
+}
+function Pn(e, t) {
+  const i = new Array(t);
+  for (let n = 0; n < t; n++) {
+    const r = e.view.getUint32(e.offset, !0);
+    e.offset += 4, i[n] = new Uint8Array(e.view.buffer, e.view.byteOffset + e.offset, r), e.offset += r;
+  }
+  return i;
+}
+function $n(e, t, i) {
+  const n = new Array(t);
+  for (let r = 0; r < t; r++)
+    n[r] = new Uint8Array(e.view.buffer, e.view.byteOffset + e.offset, i), e.offset += i;
+  return n;
+}
+function ye(e, t, i) {
+  const n = new ArrayBuffer(i);
+  return new Uint8Array(n).set(new Uint8Array(e, t, i)), n;
+}
+const Cn = [0, 255, 65535, 16777215, 4294967295];
+function it(e, t, i, n, r) {
+  for (let f = 0; f < r; f++)
+    i[n + f] = e[t + f];
+}
+function Fn(e, t) {
+  const i = e.byteLength, n = t.byteLength;
+  let r = 0, f = 0;
+  for (; r < i; ) {
+    const s = e[r];
+    if (r++, s < 128)
+      break;
+  }
+  if (n && r >= i)
+    throw new Error("invalid snappy length header");
+  for (; r < i; ) {
+    const s = e[r];
+    let o = 0;
+    if (r++, r >= i)
+      throw new Error("missing eof marker");
+    if ((s & 3) === 0) {
+      let c = (s >>> 2) + 1;
+      if (c > 60) {
+        if (r + 3 >= i)
+          throw new Error("snappy error literal pos + 3 >= inputLength");
+        const d = c - 60;
+        c = e[r] + (e[r + 1] << 8) + (e[r + 2] << 16) + (e[r + 3] << 24), c = (c & Cn[d]) + 1, r += d;
+      }
+      if (r + c > i)
+        throw new Error("snappy error literal exceeds input length");
+      it(e, r, t, f, c), r += c, f += c;
+    } else {
+      let c = 0;
+      switch (s & 3) {
+        case 1:
+          o = (s >>> 2 & 7) + 4, c = e[r] + (s >>> 5 << 8), r++;
+          break;
+        case 2:
+          if (i <= r + 1)
+            throw new Error("snappy error end of input");
+          o = (s >>> 2) + 1, c = e[r] + (e[r + 1] << 8), r += 2;
+          break;
+        case 3:
+          if (i <= r + 3)
+            throw new Error("snappy error end of input");
+          o = (s >>> 2) + 1, c = e[r] + (e[r + 1] << 8) + (e[r + 2] << 16) + (e[r + 3] << 24), r += 4;
+          break;
+      }
+      if (c === 0 || isNaN(c))
+        throw new Error(`invalid offset ${c} pos ${r} inputLength ${i}`);
+      if (c > f)
+        throw new Error("cannot copy from before start of buffer");
+      it(t, f - c, t, f, o), f += o;
+    }
+  }
+  if (f !== n) throw new Error("premature end of input");
+}
+function kn(e, t, { type: i, element: n, schemaPath: r }) {
+  const f = new DataView(e.buffer, e.byteOffset, e.byteLength), s = { view: f, offset: 0 };
+  let o;
+  const c = Yn(s, t, r), { definitionLevels: d, numNulls: a } = qn(s, t, r), l = t.num_values - a;
+  if (t.encoding === "PLAIN")
+    o = Oe(s, i, l, n.type_length);
+  else if (t.encoding === "PLAIN_DICTIONARY" || t.encoding === "RLE_DICTIONARY" || t.encoding === "RLE") {
+    const u = i === "BOOLEAN" ? 1 : f.getUint8(s.offset++);
+    u ? (o = new Array(l), i === "BOOLEAN" ? (k(s, u, o), o = o.map((g) => !!g)) : k(s, u, o, f.byteLength - s.offset)) : o = new Uint8Array(l);
+  } else if (t.encoding === "BYTE_STREAM_SPLIT")
+    o = Nt(s, l, i, n.type_length);
+  else if (t.encoding === "DELTA_BINARY_PACKED")
+    o = i === "INT32" ? new Int32Array(l) : new BigInt64Array(l), se(s, l, o);
+  else if (t.encoding === "DELTA_LENGTH_BYTE_ARRAY")
+    o = new Array(l), Lt(s, l, o);
+  else
+    throw new Error(`parquet unsupported encoding: ${t.encoding}`);
+  return { definitionLevels: d, repetitionLevels: c, dataPage: o };
+}
+function Yn(e, t, i) {
+  if (i.length > 1) {
+    const n = gt(i);
+    if (n) {
+      const r = new Array(t.num_values);
+      return k(e, me(n), r), r;
+    }
+  }
+  return [];
+}
+function qn(e, t, i) {
+  const n = Be(i);
+  if (!n) return { definitionLevels: [], numNulls: 0 };
+  const r = new Array(t.num_values);
+  k(e, me(n), r);
+  let f = t.num_values;
+  for (const s of r)
+    s === n && f--;
+  return f === 0 && (r.length = 0), { definitionLevels: r, numNulls: f };
+}
+function Ne(e, t, i, n) {
+  let r;
+  const f = n?.[i];
+  if (i === "UNCOMPRESSED")
+    r = e;
+  else if (f)
+    r = f(e, t);
+  else if (i === "SNAPPY")
+    r = new Uint8Array(t), Fn(e, r);
+  else
+    throw new Error(`parquet unsupported compression codec: ${i}`);
+  if (r?.length !== t)
+    throw new Error(`parquet decompressed page length ${r?.length} does not match header ${t}`);
+  return r;
+}
+function jn(e, t, i) {
+  const r = { view: new DataView(e.buffer, e.byteOffset, e.byteLength), offset: 0 }, { type: f, element: s, schemaPath: o, codec: c, compressors: d } = i, a = t.data_page_header_v2;
+  if (!a) throw new Error("parquet data page header v2 is undefined");
+  const l = Gn(r, a, o);
+  r.offset = a.repetition_levels_byte_length;
+  const u = Vn(r, a, o), g = t.uncompressed_page_size - a.definition_levels_byte_length - a.repetition_levels_byte_length;
+  let h = e.subarray(r.offset);
+  a.is_compressed !== !1 && (h = Ne(h, g, c, d));
+  const m = new DataView(h.buffer, h.byteOffset, h.byteLength), y = { view: m, offset: 0 };
+  let _;
+  const w = a.num_values - a.num_nulls;
+  if (a.encoding === "PLAIN")
+    _ = Oe(y, f, w, s.type_length);
+  else if (a.encoding === "RLE")
+    _ = new Array(w), k(y, 1, _), _ = _.map((p) => !!p);
+  else if (a.encoding === "PLAIN_DICTIONARY" || a.encoding === "RLE_DICTIONARY") {
+    const p = m.getUint8(y.offset++);
+    _ = new Array(w), k(y, p, _, g - 1);
+  } else if (a.encoding === "DELTA_BINARY_PACKED")
+    _ = f === "INT32" ? new Int32Array(w) : new BigInt64Array(w), se(y, w, _);
+  else if (a.encoding === "DELTA_LENGTH_BYTE_ARRAY")
+    _ = new Array(w), Lt(y, w, _);
+  else if (a.encoding === "DELTA_BYTE_ARRAY")
+    _ = new Array(w), Ln(y, w, _);
+  else if (a.encoding === "BYTE_STREAM_SPLIT")
+    _ = Nt(y, w, f, s.type_length);
+  else
+    throw new Error(`parquet unsupported encoding: ${a.encoding}`);
+  return { definitionLevels: u, repetitionLevels: l, dataPage: _ };
+}
+function Gn(e, t, i) {
+  const n = gt(i);
+  if (!n) return [];
+  const r = new Array(t.num_values);
+  return k(e, me(n), r, t.repetition_levels_byte_length), r;
+}
+function Vn(e, t, i) {
+  const n = Be(i);
+  if (n) {
+    const r = new Array(t.num_values);
+    return k(e, me(n), r, t.definition_levels_byte_length), r;
+  }
+}
+function me(e) {
+  return 32 - Math.clz32(e);
+}
+function Rt(e, { groupStart: t, selectStart: i, selectEnd: n }, r, f) {
+  const { pathInSchema: s, schemaPath: o } = r, c = ht(o), d = [];
+  let a, l, u = 0, g = 0;
+  const h = f && (() => {
+    l && f({
+      pathInSchema: s,
+      columnData: l,
+      rowStart: t + u - l.length,
+      rowEnd: t + u
+    });
+  });
+  for (; (c ? u < n : e.offset < e.view.byteLength - 1) && !(e.offset >= e.view.byteLength - 1); ) {
+    const m = zn(e);
+    if (m.type === "DICTIONARY_PAGE") {
+      const { data: y } = rt(e, m, r, a, void 0, 0);
+      y && (a = ct(y, r));
+    } else {
+      const y = l?.length || 0, _ = rt(e, m, r, a, l, i - u);
+      _.skipped ? (d.length || (g += _.skipped), u += _.skipped) : _.data && l === _.data ? u += _.data.length - y : _.data && _.data.length && (h?.(), d.push(_.data), u += _.data.length, l = _.data);
+    }
+  }
+  return h?.(), { data: d, skipped: g };
+}
+function rt(e, t, i, n, r, f) {
+  const { type: s, element: o, schemaPath: c, codec: d, compressors: a } = i, l = new Uint8Array(
+    e.view.buffer,
+    e.view.byteOffset + e.offset,
+    t.compressed_page_size
+  );
+  if (e.offset += t.compressed_page_size, t.type === "DATA_PAGE") {
+    const u = t.data_page_header;
+    if (!u) throw new Error("parquet data page header is undefined");
+    if (f > u.num_values && ht(c))
+      return { skipped: u.num_values };
+    const g = Ne(l, Number(t.uncompressed_page_size), d, a), { definitionLevels: h, repetitionLevels: m, dataPage: y } = kn(g, u, i), _ = Ce(y, n, u.encoding, i), w = Array.isArray(r) ? r : [];
+    return { skipped: 0, data: nt(w, h, m, _, c) };
+  } else if (t.type === "DATA_PAGE_V2") {
+    const u = t.data_page_header_v2;
+    if (!u) throw new Error("parquet data page header v2 is undefined");
+    if (f > u.num_rows)
+      return { skipped: u.num_values };
+    const { definitionLevels: g, repetitionLevels: h, dataPage: m } = jn(l, t, i), y = Ce(m, n, u.encoding, i), _ = Array.isArray(r) ? r : [];
+    return { skipped: 0, data: nt(_, g, h, y, c) };
+  } else if (t.type === "DICTIONARY_PAGE") {
+    const u = t.dictionary_page_header;
+    if (!u) throw new Error("parquet dictionary page header is undefined");
+    const g = Ne(
+      l,
+      Number(t.uncompressed_page_size),
+      d,
+      a
+    ), h = { view: new DataView(g.buffer, g.byteOffset, g.byteLength), offset: 0 };
+    return { skipped: 0, data: Oe(h, s, u.num_values, o.type_length) };
+  } else
+    throw new Error(`parquet unsupported page type: ${t.type}`);
+}
+function zn(e) {
+  const t = X(e), i = lt[t.field_1], n = t.field_2, r = t.field_3, f = t.field_4, s = t.field_5 && {
+    num_values: t.field_5.field_1,
+    encoding: G[t.field_5.field_2],
+    definition_level_encoding: G[t.field_5.field_3],
+    repetition_level_encoding: G[t.field_5.field_4],
+    statistics: t.field_5.field_5 && {
+      max: t.field_5.field_5.field_1,
+      min: t.field_5.field_5.field_2,
+      null_count: t.field_5.field_5.field_3,
+      distinct_count: t.field_5.field_5.field_4,
+      max_value: t.field_5.field_5.field_5,
+      min_value: t.field_5.field_5.field_6
+    }
+  }, o = t.field_6, c = t.field_7 && {
+    num_values: t.field_7.field_1,
+    encoding: G[t.field_7.field_2],
+    is_sorted: t.field_7.field_3
+  }, d = t.field_8 && {
+    num_values: t.field_8.field_1,
+    num_nulls: t.field_8.field_2,
+    num_rows: t.field_8.field_3,
+    encoding: G[t.field_8.field_4],
+    definition_levels_byte_length: t.field_8.field_5,
+    repetition_levels_byte_length: t.field_8.field_6,
+    is_compressed: t.field_8.field_7 === void 0 ? !0 : t.field_8.field_7,
+    // default true
+    statistics: t.field_8.field_8
+  };
+  return {
+    type: i,
+    uncompressed_page_size: n,
+    compressed_page_size: r,
+    crc: f,
+    data_page_header: s,
+    index_page_header: o,
+    dictionary_page_header: c,
+    data_page_header_v2: d
+  };
+}
+function Wn(e, { metadata: t }, i) {
+  const n = [];
+  for (const r of i.chunks) {
+    const { path_in_schema: f } = r.columnMetadata, s = _t(t.schema, f), o = {
+      pathInSchema: f,
+      element: s[s.length - 1].element,
+      schemaPath: s,
+      parsers: { ...oe, ...e.parsers },
+      ...e,
+      ...r.columnMetadata
+    }, { startByte: c, endByte: d } = r.range;
+    "pageLocations" in r ? n.push({
+      pathInSchema: f,
+      data: ft(e, i, r, r.pageLocations, o)
+    }) : "offsetIndex" in r ? n.push({
+      pathInSchema: f,
+      // fetch offset index
+      data: Promise.resolve(e.file.slice(r.offsetIndex.startByte, r.offsetIndex.endByte)).then((a) => {
+        const l = ve({ view: new DataView(a), offset: 0 }).page_locations;
+        return ft(e, i, r, l, o);
+      })
+    }) : n.push({
+      pathInSchema: f,
+      data: Promise.resolve(e.file.slice(c, d)).then((a) => {
+        const l = { view: new DataView(a), offset: 0 };
+        return Rt(l, i, o, e.onPage);
+      })
+    });
+  }
+  return {
+    groupStart: i.groupStart,
+    groupRows: i.groupRows,
+    selectStart: i.selectStart,
+    selectEnd: i.selectEnd,
+    asyncColumns: n
+  };
+}
+async function ft(e, t, i, n, r) {
+  const { data_page_offset: f, dictionary_page_offset: s } = i.columnMetadata, { selectStart: o, selectEnd: c } = t;
+  let { startByte: d, endByte: a } = i.range, l = -1;
+  const u = s || f < n[0].offset;
+  for (let w = 0; w < n.length; w++) {
+    const p = n[w], I = Number(p.first_row_index), A = w + 1 < n.length ? Number(n[w + 1].first_row_index) : t.groupRows;
+    l < 0 && A > o && (d = Number(p.offset), l = I), I < c && (a = Number(p.offset) + p.compressed_page_size);
+  }
+  l < 0 && (l = 0);
+  let g;
+  if (u && l) {
+    const w = Number(n[0].offset) - i.range.startByte, [p, I] = await Promise.all([
+      e.file.slice(i.range.startByte, Number(n[0].offset)),
+      e.file.slice(d, a)
+    ]), A = new Uint8Array(w + I.byteLength);
+    A.set(new Uint8Array(p, 0, w)), A.set(new Uint8Array(I), w), g = new DataView(A.buffer);
+  } else u ? g = new DataView(await e.file.slice(i.range.startByte, a)) : g = new DataView(await e.file.slice(d, a));
+  const h = { view: g, offset: 0 }, m = l ? {
+    ...t,
+    groupStart: t.groupStart + l,
+    selectStart: t.selectStart - l,
+    selectEnd: t.selectEnd - l
+  } : t, { data: y, skipped: _ } = Rt(h, m, r, e.onPage);
+  return {
+    data: y,
+    skipped: l + _
+  };
+}
+async function st({ asyncColumns: e }, t, i, n, r) {
+  const f = await Promise.all(e.map(
+    (l) => l.data.then(({ skipped: u, data: g }) => ({ skipped: u, data: pt(g) }))
+  )), s = i - t;
+  if (r === "object") {
+    const l = Array(s);
+    for (let u = 0; u < s; u++) {
+      const g = {};
+      for (let h = 0; h < e.length; h++) {
+        const { data: m, skipped: y } = f[h];
+        g[e[h].pathInSchema[0]] = m[t + u - y];
+      }
+      l[u] = g;
+    }
+    return l;
+  }
+  const o = e.map((l) => l.pathInSchema[0]).filter((l) => !n || n.includes(l)), c = n ?? o, d = c.map((l) => e.findIndex((u) => u.pathInSchema[0] === l)), a = Array(s);
+  for (let l = 0; l < s; l++) {
+    const u = Array(e.length);
+    for (let g = 0; g < c.length; g++) {
+      const h = d[g];
+      if (h < 0) throw new Error(`parquet column not found: ${c[g]}`);
+      const { data: m, skipped: y } = f[h];
+      u[g] = m[t + l - y];
+    }
+    a[l] = u;
+  }
+  return a;
+}
+function Bt(e, t, i) {
+  const { asyncColumns: n } = e;
+  i = { ...oe, ...i };
+  const r = [];
+  for (const f of t.children)
+    if (f.children.length) {
+      const s = n.filter((o) => o.pathInSchema[0] === f.element.name);
+      if (!s.length) continue;
+      r.push({
+        pathInSchema: f.path,
+        data: (async () => {
+          const o = await Promise.all(s.map((g) => g.data)), c = /* @__PURE__ */ new Map(), d = o.map(({ data: g }) => pt(g)), a = Math.max(...o.map((g) => g.skipped)), l = Math.min(...o.map((g, h) => g.skipped + d[h].length));
+          for (let g = 0; g < s.length; g++) {
+            const h = a - o[g].skipped, m = Math.max(0, l - a);
+            c.set(
+              s[g].pathInSchema.join("."),
+              d[g].slice(h, h + m)
+            );
+          }
+          te(c, f, i);
+          const u = c.get(f.element.name);
+          if (!u) throw new Error("parquet column data not assembled");
+          return { data: [u], skipped: a };
+        })()
+      });
+    } else {
+      const s = n.find((o) => o.pathInSchema[0] === f.element.name);
+      s && r.push(s);
+    }
+  return { ...e, asyncColumns: r };
+}
+async function Hn(e) {
+  e.metadata ??= await he(e.file, e);
+  const { rowStart: t = 0, rowEnd: i, columns: n, onChunk: r, onComplete: f, rowFormat: s, filter: o, filterStrict: c = !0 } = e;
+  if (o && s !== "object")
+    throw new Error('parquet filter requires rowFormat: "object"');
+  const d = dn(o);
+  if (d.length) {
+    const y = F(e.metadata).children.map((w) => w.element.name), _ = d.filter((w) => !y.includes(w));
+    if (_.length)
+      throw new Error(`parquet filter columns not found: ${_.join(", ")}`);
+  }
+  let a = n, l = !1;
+  if (n && o) {
+    const y = d.filter((_) => !n.includes(_));
+    y.length && (a = [...n, ...y], l = !0);
+  }
+  let u = a !== n ? { ...e, columns: a } : e;
+  u = await St(u), u = await Qn(u);
+  const g = xt(u);
+  if (!f && !r) {
+    await _e(g);
+    return;
+  }
+  const h = F(e.metadata), m = g.map((y) => Bt(y, h, e.parsers));
+  if (r)
+    for (const y of m)
+      for (const _ of y.asyncColumns)
+        _.data.then(({ data: w, skipped: p }) => {
+          let I = y.groupStart + p;
+          for (const A of w)
+            r({
+              columnName: _.pathInSchema[0],
+              columnData: A,
+              rowStart: I,
+              rowEnd: I + A.length
+            }), I += A.length;
+        }, () => {
+        });
+  if (f) {
+    await _e(m);
+    const y = [];
+    for (const _ of m) {
+      const w = _.selectStart ?? Math.max(t - _.groupStart, 0), p = _.selectEnd ?? Math.min((i ?? 1 / 0) - _.groupStart, _.groupRows), I = s === "object" ? await st(_, w, p, a, "object") : await st(_, w, p, n, "array");
+      if (o) {
+        for (
+          const A of
+          /** @type {Record<string, any>[]} */
+          I
+        )
+          if (z(A, o, c)) {
+            if (l && n)
+              for (const R of d)
+                n.includes(R) || delete A[R];
+            y.push(A);
+          }
+      } else
+        xe(y, I);
+    }
+    f(y);
+  } else
+    await _e(m);
+}
+async function _e(e) {
+  const t = e.flatMap((r) => r.asyncColumns.map((f) => f.data)), n = (await Promise.allSettled(t)).find((r) => r.status === "rejected");
+  if (n) throw n.reason;
+}
+function xt(e) {
+  if (!e.metadata) throw new Error("parquet requires metadata");
+  const t = mn(e);
+  return e.file = It(e.file, t), t.groups.map((i) => Wn(e, t, i));
+}
+async function Kn(e) {
+  if (e.columns?.length !== 1)
+    throw new Error("parquetReadColumn expected columns: [columnName]");
+  e.metadata ??= await he(e.file, e);
+  const t = xt(await St(e)), i = F(e.metadata), n = t.map((f) => Bt(f, i, e.parsers));
+  await _e(n);
+  const r = [];
+  for (const f of n) {
+    const { data: s } = await f.asyncColumns[0].data;
+    for (const o of s)
+      xe(r, o);
+  }
+  return r;
+}
+async function St(e) {
+  if (!e.useBloomFilters || !e.filter || !e.metadata) return e;
+  const t = F(e.metadata), i = {};
+  for (const r of t.children) i[r.element.name] = r.element;
+  const n = await pn({
+    file: e.file,
+    metadata: e.metadata,
+    filter: e.filter,
+    filterStrict: e.filterStrict
+  });
+  return (
+    /** @type {BaseParquetReadOptions} */
+    { ...e, bloomFiltersByGroup: n, schemaElements: i }
+  );
+}
+async function Qn(e) {
+  if (!e.usePageIndex || !e.filter || !e.metadata) return e;
+  const { pageRangesByGroup: t, pageLocationsByGroup: i } = await An({
+    file: e.file,
+    metadata: e.metadata,
+    filter: e.filter,
+    filterStrict: e.filterStrict,
+    rowStart: e.rowStart,
+    rowEnd: e.rowEnd,
+    columns: e.columns,
+    // @ts-expect-error bloomFiltersByGroup/schemaElements are attached by withBloomFilters
+    bloomFiltersByGroup: e.bloomFiltersByGroup,
+    // @ts-expect-error bloomFiltersByGroup/schemaElements are attached by withBloomFilters
+    schemaElements: e.schemaElements,
+    parsers: e.parsers
+  });
+  return { ...e, pageRangesByGroup: t, pageLocationsByGroup: i };
+}
+function ne(e) {
+  return new Promise((t, i) => {
+    Hn({
+      ...e,
+      rowFormat: "object",
+      // force object output
+      onComplete: t
+    }).catch(i);
+  });
+}
+async function ei(e) {
+  if (!e.file || !(e.file.byteLength >= 0))
+    throw new Error("parquet expected AsyncBuffer");
+  e.metadata ??= await he(e.file, e);
+  const { metadata: t, rowStart: i = 0, columns: n, orderBy: r, filter: f } = e;
+  if (i < 0) throw new Error("parquet rowStart must be positive");
+  const s = e.rowEnd ?? Number(t.num_rows);
+  if (r && !F(e.metadata).children.map((c) => c.element.name).includes(r))
+    throw new Error(`parquet orderBy column not found: ${r}`);
+  if (f && !r && s < t.num_rows) {
+    const o = [];
+    let c = 0;
+    for (const d of t.row_groups) {
+      const a = c + Number(d.num_rows), l = await ne({
+        ...e,
+        rowStart: c,
+        rowEnd: a
+      });
+      if (o.push(...l), o.length >= s) break;
+      c = a;
+    }
+    return o.slice(i, s);
+  } else if (f && r) {
+    const o = n && !n.includes(r) ? [...n, r] : n, c = await ne({
+      ...e,
+      rowStart: void 0,
+      rowEnd: void 0,
+      columns: o
+    });
+    if (c.sort((d, a) => ot(d[r], a[r])), o !== n)
+      for (const d of c)
+        delete d[r];
+    return c.slice(i, s);
+  } else {
+    if (f)
+      return (await ne({
+        ...e,
+        rowStart: void 0,
+        rowEnd: void 0
+      })).slice(i, s);
+    if (typeof r == "string") {
+      const o = await Kn({
+        ...e,
+        rowStart: void 0,
+        rowEnd: void 0,
+        columns: [r]
+      }), c = Array.from(o, (l, u) => u).sort((l, u) => ot(o[l], o[u])).slice(i, s), d = await Zn({ ...e, rows: c });
+      return c.map((l) => d[l]);
+    } else
+      return await ne(e);
+  }
+}
+async function Zn(e) {
+  const { file: t, rows: i } = e;
+  e.metadata ??= await he(t, e);
+  const { row_groups: n } = e.metadata, r = Array(n.length).fill(!1);
+  let f = 0;
+  const s = n.map((a) => f += Number(a.num_rows));
+  for (const a of i) {
+    const l = s.findIndex((u) => a < u);
+    r[l] = !0;
+  }
+  const o = [];
+  let c;
+  f = 0;
+  for (let a = 0; a < r.length; a++) {
+    const l = f + Number(n[a].num_rows);
+    r[a] ? c === void 0 && (c = f) : c !== void 0 && (o.push([c, l]), c = void 0), f = l;
+  }
+  c !== void 0 && o.push([c, f]);
+  const d = Array(Number(e.metadata.num_rows));
+  for (const [a, l] of o) {
+    const u = await ne({ ...e, rowStart: a, rowEnd: l });
+    for (let g = a; g < l; g++)
+      d[g] = { __index__: g, ...u[g - a] };
+  }
+  return d;
+}
+function ot(e, t) {
+  return e < t ? -1 : e > t ? 1 : 0;
+}
+export {
+  Jn as asyncBufferFromUrl,
+  an as byteLengthFromUrl,
+  Xn as cachedAsyncBuffer,
+  pt as flatten,
+  qe as parquetMetadata,
+  he as parquetMetadataAsync,
+  ei as parquetQuery,
+  Hn as parquetRead,
+  ne as parquetReadObjects,
+  F as parquetSchema,
+  nn as readColumnIndex,
+  ve as readOffsetIndex,
+  Fn as snappyUncompress,
+  He as toJson
+};