@genome-spy/core 0.70.0 → 0.72.0

package/dist/bundle/parquetRead-BnAGCa4_.js

@@ -0,0 +1,1663 @@
+const fe = [
+  "BOOLEAN",
+  "INT32",
+  "INT64",
+  "INT96",
+  // deprecated
+  "FLOAT",
+  "DOUBLE",
+  "BYTE_ARRAY",
+  "FIXED_LEN_BYTE_ARRAY"
+], b = [
+  "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"
+], xe = [
+  "REQUIRED",
+  "OPTIONAL",
+  "REPEATED"
+], Me = [
+  "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"
+], Fe = [
+  "UNCOMPRESSED",
+  "SNAPPY",
+  "GZIP",
+  "LZO",
+  "BROTLI",
+  "LZ4",
+  "ZSTD",
+  "LZ4_RAW"
+], pe = [
+  "DATA_PAGE",
+  "INDEX_PAGE",
+  "DICTIONARY_PAGE",
+  "DATA_PAGE_V2"
+], Ce = [
+  "SPHERICAL",
+  "VINCENTY",
+  "THOMAS",
+  "ANDOYER",
+  "KARNEY"
+];
+function W(e) {
+  const t = F(e);
+  if (t.type === 1)
+    return { type: "Point", coordinates: H(e, t) };
+  if (t.type === 2)
+    return { type: "LineString", coordinates: K(e, t) };
+  if (t.type === 3)
+    return { type: "Polygon", coordinates: oe(e, t) };
+  if (t.type === 4) {
+    const n = [];
+    for (let i = 0; i < t.count; i++)
+      n.push(H(e, F(e)));
+    return { type: "MultiPoint", coordinates: n };
+  } else if (t.type === 5) {
+    const n = [];
+    for (let i = 0; i < t.count; i++)
+      n.push(K(e, F(e)));
+    return { type: "MultiLineString", coordinates: n };
+  } else if (t.type === 6) {
+    const n = [];
+    for (let i = 0; i < t.count; i++)
+      n.push(oe(e, F(e)));
+    return { type: "MultiPolygon", coordinates: n };
+  } else if (t.type === 7) {
+    const n = [];
+    for (let i = 0; i < t.count; i++)
+      n.push(W(e));
+    return { type: "GeometryCollection", geometries: n };
+  } else
+    throw new Error(`Unsupported geometry type: ${t.type}`);
+}
+function F(e) {
+  const { view: t } = e, n = t.getUint8(e.offset++) === 1, i = t.getUint32(e.offset, n);
+  e.offset += 4;
+  const f = i % 1e3, o = Math.floor(i / 1e3);
+  let r = 0;
+  f > 1 && f <= 7 && (r = t.getUint32(e.offset, n), e.offset += 4);
+  let s = 2;
+  return o && s++, o === 3 && s++, { littleEndian: n, type: f, dim: s, count: r };
+}
+function H(e, t) {
+  const n = [];
+  for (let i = 0; i < t.dim; i++) {
+    const f = e.view.getFloat64(e.offset, t.littleEndian);
+    e.offset += 8, n.push(f);
+  }
+  return n;
+}
+function K(e, t) {
+  const n = [];
+  for (let i = 0; i < t.count; i++)
+    n.push(H(e, t));
+  return n;
+}
+function oe(e, t) {
+  const { view: n } = e, i = [];
+  for (let f = 0; f < t.count; f++) {
+    const o = n.getUint32(e.offset, t.littleEndian);
+    e.offset += 4, i.push(K(e, { ...t, count: o }));
+  }
+  return i;
+}
+const we = new TextDecoder(), j = {
+  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 && we.decode(e);
+  },
+  geometryFromBytes(e) {
+    return e && W({ view: new DataView(e.buffer, e.byteOffset, e.byteLength), offset: 0 });
+  },
+  geographyFromBytes(e) {
+    return e && W({ view: new DataView(e.buffer, e.byteOffset, e.byteLength), offset: 0 });
+  }
+};
+function se(e, t, n, i) {
+  if (t && n.endsWith("_DICTIONARY")) {
+    let f = e;
+    e instanceof Uint8Array && !(t instanceof Uint8Array) && (f = new t.constructor(e.length));
+    for (let o = 0; o < e.length; o++)
+      f[o] = t[e[o]];
+    return f;
+  } else
+    return ye(e, i);
+}
+function ye(e, t) {
+  const { element: n, parsers: i, utf8: f = !0, schemaPath: o } = t, { type: r, converted_type: s, logical_type: l } = n;
+  if (o?.some((u) => u.element.logical_type?.type === "VARIANT") && r === "BYTE_ARRAY" && s !== "UTF8" && l?.type !== "STRING")
+    return e;
+  if (s === "DECIMAL") {
+    const c = 10 ** -(n.scale || 0), d = new Array(e.length);
+    for (let g = 0; g < d.length; g++)
+      e[g] instanceof Uint8Array ? d[g] = me(e[g]) * c : d[g] = Number(e[g]) * c;
+    return d;
+  }
+  if (!s && r === "INT96")
+    return Array.from(e).map((u) => i.timestampFromNanoseconds(ke(u)));
+  if (s === "DATE")
+    return Array.from(e).map((u) => i.dateFromDays(u));
+  if (s === "TIMESTAMP_MILLIS")
+    return Array.from(e).map((u) => i.timestampFromMilliseconds(u));
+  if (s === "TIMESTAMP_MICROS")
+    return Array.from(e).map((u) => i.timestampFromMicroseconds(u));
+  if (s === "JSON")
+    return e.map((u) => JSON.parse(we.decode(u)));
+  if (s === "BSON")
+    throw new Error("parquet bson not supported");
+  if (s === "INTERVAL")
+    throw new Error("parquet interval not supported");
+  if (l?.type === "GEOMETRY")
+    return e.map((u) => i.geometryFromBytes(u));
+  if (l?.type === "GEOGRAPHY")
+    return e.map((u) => i.geographyFromBytes(u));
+  if (s === "UTF8" || l?.type === "STRING" || f && r === "BYTE_ARRAY")
+    return e.map((u) => i.stringFromBytes(u));
+  if (s === "UINT_64" || l?.type === "INTEGER" && l.bitWidth === 64 && !l.isSigned) {
+    if (e instanceof BigInt64Array)
+      return new BigUint64Array(e.buffer, e.byteOffset, e.length);
+    const u = new BigUint64Array(e.length);
+    for (let c = 0; c < u.length; c++) u[c] = BigInt(e[c]);
+    return u;
+  }
+  if (s === "UINT_32" || l?.type === "INTEGER" && l.bitWidth === 32 && !l.isSigned) {
+    if (e instanceof Int32Array)
+      return new Uint32Array(e.buffer, e.byteOffset, e.length);
+    const u = new Uint32Array(e.length);
+    for (let c = 0; c < u.length; c++) u[c] = e[c];
+    return u;
+  }
+  if (l?.type === "FLOAT16")
+    return Array.from(e).map(Ae);
+  if (l?.type === "TIMESTAMP") {
+    const { unit: u } = l;
+    let c = i.timestampFromMilliseconds;
+    u === "MICROS" && (c = i.timestampFromMicroseconds), u === "NANOS" && (c = i.timestampFromNanoseconds);
+    const d = new Array(e.length);
+    for (let g = 0; g < d.length; g++)
+      d[g] = c(e[g]);
+    return d;
+  }
+  return e;
+}
+function me(e) {
+  if (!e.length) return 0;
+  let t = 0n;
+  for (const i of e)
+    t = t * 256n + BigInt(i);
+  const n = e.length * 8;
+  return t >= 2n ** BigInt(n - 1) && (t -= 2n ** BigInt(n)), Number(t);
+}
+function ke(e) {
+  const t = (e >> 64n) - 2440588n, n = e & 0xffffffffffffffffn;
+  return t * 86400000000000n + n;
+}
+function Ae(e) {
+  if (!e) return;
+  const t = e[1] << 8 | e[0], n = t >> 15 ? -1 : 1, i = t >> 10 & 31, f = t & 1023;
+  return i === 0 ? n * 2 ** -14 * (f / 1024) : i === 31 ? f ? NaN : n * (1 / 0) : n * 2 ** (i - 15) * (1 + f / 1024);
+}
+function Ee(e, t, n) {
+  const i = e[t], f = [];
+  let o = 1;
+  if (i.num_children)
+    for (; f.length < i.num_children; ) {
+      const r = e[t + o], s = Ee(e, t + o, [...n, r.name]);
+      o += s.count, f.push(s);
+    }
+  return { count: o, element: i, children: f, path: n };
+}
+function Ie(e, t) {
+  let n = Ee(e, 0, []);
+  const i = [n];
+  for (const f of t) {
+    const o = n.children.find((r) => r.element.name === f);
+    if (!o) throw new Error(`parquet schema element not found: ${t}`);
+    i.push(o), n = o;
+  }
+  return i;
+}
+function Ye(e) {
+  const t = [];
+  function n(i) {
+    if (i.children.length)
+      for (const f of i.children)
+        n(f);
+    else
+      t.push(i.path.join("."));
+  }
+  return n(e), t;
+}
+function ve(e) {
+  let t = 0;
+  for (const { element: n } of e)
+    n.repetition_type === "REPEATED" && t++;
+  return t;
+}
+function J(e) {
+  let t = 0;
+  for (const { element: n } of e.slice(1))
+    n.repetition_type !== "REQUIRED" && t++;
+  return t;
+}
+function $e(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 qe(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((f) => f.element.name === "key")?.element.repetition_type === "REPEATED" || t.children.find((f) => f.element.name === "value")?.element.repetition_type === "REPEATED");
+}
+function be(e) {
+  if (e.length !== 2) return !1;
+  const [, t] = e;
+  return !(t.element.repetition_type === "REPEATED" || t.children.length);
+}
+const A = {
+  STOP: 0,
+  TRUE: 1,
+  FALSE: 2,
+  BYTE: 3,
+  I16: 4,
+  I32: 5,
+  I64: 6,
+  DOUBLE: 7,
+  BINARY: 8,
+  LIST: 9,
+  STRUCT: 12
+};
+function ee(e) {
+  let t = 0;
+  const n = {};
+  for (; e.offset < e.view.byteLength; ) {
+    const [i, f, o] = Le(e, t);
+    if (t = o, i === A.STOP)
+      break;
+    n[`field_${f}`] = k(e, i);
+  }
+  return n;
+}
+function k(e, t) {
+  switch (t) {
+    case A.TRUE:
+      return !0;
+    case A.FALSE:
+      return !1;
+    case A.BYTE:
+      return e.view.getInt8(e.offset++);
+    case A.I16:
+    case A.I32:
+      return Te(e);
+    case A.I64:
+      return Z(e);
+    case A.DOUBLE: {
+      const n = e.view.getFloat64(e.offset, !0);
+      return e.offset += 8, n;
+    }
+    case A.BINARY: {
+      const n = T(e), i = new Uint8Array(e.view.buffer, e.view.byteOffset + e.offset, n);
+      return e.offset += n, i;
+    }
+    case A.LIST: {
+      const n = e.view.getUint8(e.offset++), i = n & 15;
+      let f = n >> 4;
+      f === 15 && (f = T(e));
+      const o = i === A.TRUE || i === A.FALSE, r = new Array(f);
+      for (let s = 0; s < f; s++)
+        r[s] = o ? k(e, A.BYTE) === 1 : k(e, i);
+      return r;
+    }
+    case A.STRUCT: {
+      const n = {};
+      let i = 0;
+      for (; ; ) {
+        const [f, o, r] = Le(e, i);
+        if (i = r, f === A.STOP)
+          break;
+        n[`field_${o}`] = k(e, f);
+      }
+      return n;
+    }
+    // TODO: MAP, SET, UUID
+    default:
+      throw new Error(`thrift unhandled type: ${t}`);
+  }
+}
+function T(e) {
+  let t = 0, n = 0;
+  for (; ; ) {
+    const i = e.view.getUint8(e.offset++);
+    if (t |= (i & 127) << n, !(i & 128))
+      return t;
+    n += 7;
+  }
+}
+function je(e) {
+  let t = 0n, n = 0n;
+  for (; ; ) {
+    const i = e.view.getUint8(e.offset++);
+    if (t |= BigInt(i & 127) << n, !(i & 128))
+      return t;
+    n += 7n;
+  }
+}
+function Te(e) {
+  const t = T(e);
+  return t >>> 1 ^ -(t & 1);
+}
+function Z(e) {
+  const t = je(e);
+  return t >> 1n ^ -(t & 1n);
+}
+function Le(e, t) {
+  const n = e.view.getUint8(e.offset++), i = n & 15;
+  if (i === A.STOP)
+    return [0, 0, t];
+  const f = n >> 4, o = f ? t + f : Te(e);
+  return [i, o, o];
+}
+function Ve(e, t) {
+  const n = /* @__PURE__ */ new Map(), i = t?.find(({ key: o }) => o === "geo")?.value, f = (i && JSON.parse(i)?.columns) ?? {};
+  for (const [o, r] of Object.entries(f)) {
+    if (r.encoding !== "WKB")
+      continue;
+    const s = r.edges === "spherical" ? "GEOGRAPHY" : "GEOMETRY", l = r.crs?.id ?? r.crs?.ids?.[0], a = l ? `${l.authority}:${l.code.toString()}` : void 0;
+    n.set(o, { type: s, crs: a });
+  }
+  for (let o = 1; o < e.length; o++) {
+    const r = e[o], { logical_type: s, name: l, num_children: a, repetition_type: u, type: c } = r;
+    if (a) {
+      o += a;
+      continue;
+    }
+    c === "BYTE_ARRAY" && s === void 0 && u !== "REPEATED" && (r.logical_type = n.get(l));
+  }
+}
+const Ge = 1 << 19, ze = new TextDecoder();
+function I(e) {
+  return e && ze.decode(e);
+}
+async function We(e, { parsers: t, initialFetchSize: n = Ge, geoparquet: i = !0 } = {}) {
+  if (!e || !(e.byteLength >= 0)) throw new Error("parquet expected AsyncBuffer");
+  const f = Math.max(0, e.byteLength - n), o = await e.slice(f, e.byteLength), r = new DataView(o);
+  if (r.getUint32(o.byteLength - 4, !0) !== 827474256)
+    throw new Error("parquet file invalid (footer != PAR1)");
+  const s = r.getUint32(o.byteLength - 8, !0);
+  if (s > e.byteLength - 8)
+    throw new Error(`parquet metadata length ${s} exceeds available buffer ${e.byteLength - 8}`);
+  if (s + 8 > n) {
+    const l = e.byteLength - s - 8, a = await e.slice(l, f), u = new ArrayBuffer(s + 8), c = new Uint8Array(u);
+    return c.set(new Uint8Array(a)), c.set(new Uint8Array(o), f - l), re(u, { parsers: t, geoparquet: i });
+  } else
+    return re(o, { parsers: t, geoparquet: i });
+}
+function re(e, { parsers: t, geoparquet: n = !0 } = {}) {
+  if (!(e instanceof ArrayBuffer)) throw new Error("parquet expected ArrayBuffer");
+  const i = new DataView(e);
+  if (t = { ...j, ...t }, i.byteLength < 8)
+    throw new Error("parquet file is too short");
+  if (i.getUint32(i.byteLength - 4, !0) !== 827474256)
+    throw new Error("parquet file invalid (footer != PAR1)");
+  const f = i.byteLength - 8, o = i.getUint32(f, !0);
+  if (o > i.byteLength - 8)
+    throw new Error(`parquet metadata length ${o} exceeds available buffer ${i.byteLength - 8}`);
+  const r = f - o, l = ee({ view: i, offset: r }), a = l.field_1, u = l.field_2.map((h) => ({
+    type: fe[h.field_1],
+    type_length: h.field_2,
+    repetition_type: xe[h.field_3],
+    name: I(h.field_4),
+    num_children: h.field_5,
+    converted_type: Me[h.field_6],
+    scale: h.field_7,
+    precision: h.field_8,
+    field_id: h.field_9,
+    logical_type: He(h.field_10)
+  })), c = u.filter((h) => h.type), d = l.field_3, g = l.field_4.map((h) => ({
+    columns: h.field_1.map((_, m) => ({
+      file_path: I(_.field_1),
+      file_offset: _.field_2,
+      meta_data: _.field_3 && {
+        type: fe[_.field_3.field_1],
+        encodings: _.field_3.field_2?.map((y) => b[y]),
+        path_in_schema: _.field_3.field_3.map(I),
+        codec: Fe[_.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((y) => ({
+          key: I(y.field_1),
+          value: I(y.field_2)
+        })),
+        data_page_offset: _.field_3.field_9,
+        index_page_offset: _.field_3.field_10,
+        dictionary_page_offset: _.field_3.field_11,
+        statistics: Ke(_.field_3.field_12, c[m], t),
+        encoding_stats: _.field_3.field_13?.map((y) => ({
+          page_type: pe[y.field_1],
+          encoding: b[y.field_2],
+          count: y.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: h.field_2,
+    num_rows: h.field_3,
+    sorting_columns: h.field_4?.map((_) => ({
+      column_idx: _.field_1,
+      descending: _.field_2,
+      nulls_first: _.field_3
+    })),
+    file_offset: h.field_5,
+    total_compressed_size: h.field_6,
+    ordinal: h.field_7
+  })), p = l.field_5?.map((h) => ({
+    key: I(h.field_1),
+    value: I(h.field_2)
+  })), w = I(l.field_6);
+  return n && Ve(u, p), {
+    version: a,
+    schema: u,
+    num_rows: d,
+    row_groups: g,
+    key_value_metadata: p,
+    created_by: w,
+    metadata_length: o
+  };
+}
+function Re({ schema: e }) {
+  return Ie(e, [])[0];
+}
+function He(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: le(e.field_7.field_2)
+  } : e?.field_8 ? {
+    type: "TIMESTAMP",
+    isAdjustedToUTC: e.field_8.field_1,
+    unit: le(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: I(e.field_17.field_1)
+  } : e?.field_18 ? {
+    type: "GEOGRAPHY",
+    crs: I(e.field_18.field_1),
+    algorithm: Ce[e.field_18.field_2]
+  } : e;
+}
+function le(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 Ke(e, t, n) {
+  return e && {
+    max: C(e.field_1, t, n),
+    min: C(e.field_2, t, n),
+    null_count: e.field_3,
+    distinct_count: e.field_4,
+    max_value: C(e.field_5, t, n),
+    min_value: C(e.field_6, t, n),
+    is_max_value_exact: e.field_7,
+    is_min_value_exact: e.field_8
+  };
+}
+function C(e, t, n) {
+  const { type: i, converted_type: f, logical_type: o } = t;
+  if (e === void 0) return e;
+  if (i === "BOOLEAN") return e[0] === 1;
+  if (i === "BYTE_ARRAY") return n.stringFromBytes(e);
+  const r = new DataView(e.buffer, e.byteOffset, e.byteLength);
+  return i === "FLOAT" && r.byteLength === 4 ? r.getFloat32(0, !0) : i === "DOUBLE" && r.byteLength === 8 ? r.getFloat64(0, !0) : i === "INT32" && f === "DATE" ? n.dateFromDays(r.getInt32(0, !0)) : i === "INT64" && f === "TIMESTAMP_MILLIS" ? n.timestampFromMilliseconds(r.getBigInt64(0, !0)) : i === "INT64" && f === "TIMESTAMP_MICROS" ? n.timestampFromMicroseconds(r.getBigInt64(0, !0)) : i === "INT64" && o?.type === "TIMESTAMP" && o?.unit === "NANOS" ? n.timestampFromNanoseconds(r.getBigInt64(0, !0)) : i === "INT64" && o?.type === "TIMESTAMP" && o?.unit === "MICROS" ? n.timestampFromMicroseconds(r.getBigInt64(0, !0)) : i === "INT64" && o?.type === "TIMESTAMP" ? n.timestampFromMilliseconds(r.getBigInt64(0, !0)) : i === "INT32" && r.byteLength === 4 ? r.getInt32(0, !0) : i === "INT64" && r.byteLength === 8 ? r.getBigInt64(0, !0) : f === "DECIMAL" ? me(e) * 10 ** -(t.scale || 0) : o?.type === "FLOAT16" ? Ae(e) : e;
+}
+function Ne(e, t) {
+  for (let i = 0; i < t.length; i += 1e4)
+    e.push(...t.slice(i, i + 1e4));
+}
+function R(e, t, n = !0) {
+  if (n ? e === t : e == t) return !0;
+  if (e instanceof Uint8Array && t instanceof Uint8Array) return R(Array.from(e), Array.from(t), n);
+  if (!e || !t || typeof e != typeof t) return !1;
+  if (Array.isArray(e) && Array.isArray(t)) {
+    if (e.length !== t.length) return !1;
+    for (let f = 0; f < e.length; f++)
+      if (!R(e[f], t[f], n)) return !1;
+    return !0;
+  }
+  if (typeof e != "object") return !1;
+  const i = Object.keys(e);
+  if (i.length !== Object.keys(t).length) return !1;
+  for (const f of i)
+    if (!R(e[f], t[f], n)) return !1;
+  return !0;
+}
+function Ze(e) {
+  if (!e) return [];
+  if (e.length === 1) return e[0];
+  const t = [];
+  for (const n of e)
+    Ne(t, n);
+  return t;
+}
+function Q({ rowGroup: e, physicalColumns: t, filter: n, strict: i = !0 }) {
+  if (!n) return !1;
+  if ("$and" in n && Array.isArray(n.$and))
+    return n.$and.some((f) => Q({ rowGroup: e, physicalColumns: t, filter: f, strict: i }));
+  if ("$or" in n && Array.isArray(n.$or))
+    return n.$or.every((f) => Q({ rowGroup: e, physicalColumns: t, filter: f, strict: i }));
+  if ("$nor" in n && Array.isArray(n.$nor))
+    return !1;
+  for (const [f, o] of Object.entries(n)) {
+    const r = t.indexOf(f);
+    if (r === -1) continue;
+    const s = e.columns[r].meta_data?.statistics;
+    if (!s) continue;
+    const { min: l, max: a, min_value: u, max_value: c } = s, d = u !== void 0 ? u : l, g = c !== void 0 ? c : a;
+    if (!(d === void 0 || g === void 0)) {
+      for (const [p, w] of Object.entries(o || {}))
+        if (p === "$gt" && g <= w || p === "$gte" && g < w || p === "$lt" && d >= w || p === "$lte" && d > w || p === "$eq" && (w < d || w > g) || p === "$ne" && R(d, g, i) && R(d, w, i) || p === "$in" && Array.isArray(w) && w.every((h) => h < d || h > g) || p === "$nin" && Array.isArray(w) && R(d, g, i) && w.includes(d)) return !0;
+    }
+  }
+  return !1;
+}
+const Qe = 1 << 21;
+function Xe({ metadata: e, rowStart: t = 0, rowEnd: n = 1 / 0, columns: i, filter: f, filterStrict: o = !0, useOffsetIndex: r = !1 }) {
+  if (!e) throw new Error("parquetPlan requires metadata");
+  const s = [], l = [], a = [], u = Ye(Re(e));
+  let c = 0;
+  for (const d of e.row_groups) {
+    const g = Number(d.num_rows), p = c + g;
+    if (g > 0 && p > t && c < n && !Q({ rowGroup: d, physicalColumns: u, filter: f, strict: o })) {
+      const w = [];
+      for (const y of d.columns) {
+        const E = y.meta_data;
+        if (y.file_path) throw new Error("parquet file_path not supported");
+        if (!E) throw new Error("parquet column metadata is undefined");
+        if (!i || i.includes(E.path_in_schema[0])) {
+          const D = E.dictionary_page_offset || E.data_page_offset, P = Number(D), U = Number(D + E.total_compressed_size);
+          if (r && y.offset_index_offset && y.offset_index_length) {
+            const x = Number(y.offset_index_offset);
+            w.push({
+              columnMetadata: E,
+              offsetIndex: {
+                startByte: x,
+                endByte: x + y.offset_index_length
+              },
+              bounds: { startByte: P, endByte: U }
+            });
+          } else
+            w.push({
+              columnMetadata: E,
+              range: { startByte: P, endByte: U }
+            });
+        }
+      }
+      const h = Math.max(t - c, 0), _ = Math.min(n - c, g);
+      s.push({ chunks: w, rowGroup: d, groupStart: c, groupRows: g, selectStart: h, selectEnd: _ });
+      let m;
+      for (const y of w)
+        if ("offsetIndex" in y)
+          a.push(y.offsetIndex);
+        else {
+          const { range: E } = y;
+          i ? l.push(E) : m && E.endByte - m.startByte <= Qe ? m.endByte = E.endByte : (m && l.push(m), m = { ...E });
+        }
+      m && l.push(m);
+    }
+    c = p;
+  }
+  return isFinite(n) || (n = c), l.push(...a), { metadata: e, rowStart: t, rowEnd: n, columns: i, fetches: l, groups: s };
+}
+function Je(e, { fetches: t }) {
+  const n = t.map(({ startByte: i, endByte: f }) => e.slice(i, f));
+  return {
+    byteLength: e.byteLength,
+    slice(i, f = e.byteLength) {
+      const o = t.findIndex(({ startByte: r, endByte: s }) => r <= i && f <= s);
+      if (o < 0)
+        return e.slice(i, f);
+      if (t[o].startByte !== i || t[o].endByte !== f) {
+        const r = i - t[o].startByte, s = f - t[o].startByte;
+        return n[o] instanceof Promise ? n[o].then((l) => l.slice(r, s)) : n[o].slice(r, s);
+      } else
+        return n[o];
+    }
+  };
+}
+const te = new TextDecoder(), ce = /* @__PURE__ */ new WeakMap();
+function Oe(e, t = j) {
+  if (Array.isArray(e))
+    return e.map((n) => Oe(n, t));
+  if (typeof e != "object") return e;
+  if ("metadata" in e) {
+    const n = et(e.metadata), i = e.typed_value && Y(e.typed_value, n, t), f = e.value && S(q(e.value), n, t);
+    return i && f ? { ...f, ...i } : i ?? f;
+  }
+  return e;
+}
+function Y(e, t, n) {
+  if (e && typeof e == "object" && !Array.isArray(e) && !(e instanceof Uint8Array)) {
+    if ("typed_value" in e)
+      return Y(e.typed_value, t, n);
+    if ("value" in e && e.value instanceof Uint8Array)
+      return S(q(e.value), t, n);
+    const i = {};
+    for (const [f, o] of Object.entries(e))
+      i[f] = Y(o, t, n);
+    return i;
+  }
+  return e instanceof Uint8Array ? S(q(e), t, n) : Array.isArray(e) ? e.map((i) => Y(i, t, n)) : e;
+}
+function q(e) {
+  return { view: new DataView(e.buffer, e.byteOffset, e.byteLength), offset: 0 };
+}
+function et(e) {
+  let t = ce.get(e.buffer);
+  t || (t = /* @__PURE__ */ new Map(), ce.set(e.buffer, t));
+  const n = `${e.byteOffset}:${e.byteLength}`, i = t.get(n);
+  if (i) return i;
+  const f = q(e), o = f.view.getUint8(f.offset++), r = o & 15;
+  if (r !== 1) throw new Error(`parquet unsupported variant metadata version: ${r}`);
+  const s = (o >> 4 & 1) === 1, l = (o >> 6 & 3) + 1, a = L(f, l), u = new Array(a + 1);
+  for (let p = 0; p < u.length; p++)
+    u[p] = L(f, l);
+  const c = f.offset, d = new Array(a);
+  for (let p = 0; p < a; p++) {
+    const w = u[p], h = u[p + 1], _ = new Uint8Array(e.buffer, e.byteOffset + c + w, h - w);
+    d[p] = te.decode(_);
+  }
+  const g = { dictionary: d, sorted: s };
+  return t.set(n, g), g;
+}
+function L(e, t) {
+  let n = 0;
+  for (let i = 0; i < t; i++)
+    n |= e.view.getUint8(e.offset + i) << i * 8;
+  return e.offset += t, n;
+}
+function S(e, t, n) {
+  const i = e.view.getUint8(e.offset++), f = i & 3, o = i >> 2;
+  if (f === 0) return tt(e, o, n);
+  if (f === 2) return nt(e, o, t, n);
+  if (f === 3) return it(e, o, t, n);
+  const r = new Uint8Array(e.view.buffer, e.view.byteOffset + e.offset, o);
+  return e.offset += o, te.decode(r);
+}
+function tt(e, t, n) {
+  switch (t) {
+    case 0:
+      return null;
+    case 1:
+      return !0;
+    case 2:
+      return !1;
+    case 3: {
+      const i = e.view.getInt8(e.offset);
+      return e.offset += 1, i;
+    }
+    case 4: {
+      const i = e.view.getInt16(e.offset, !0);
+      return e.offset += 2, i;
+    }
+    case 5: {
+      const i = e.view.getInt32(e.offset, !0);
+      return e.offset += 4, i;
+    }
+    case 6: {
+      const i = e.view.getBigInt64(e.offset, !0);
+      return e.offset += 8, i;
+    }
+    case 7: {
+      const i = e.view.getFloat64(e.offset, !0);
+      return e.offset += 8, i;
+    }
+    case 8:
+      return z(e, 4);
+    case 9:
+      return z(e, 8);
+    case 10:
+      return z(e, 16);
+    case 11: {
+      const i = e.view.getInt32(e.offset, !0);
+      return e.offset += 4, n.dateFromDays(i);
+    }
+    case 12:
+    // timestamp_micros (utc)
+    case 13: {
+      const i = e.view.getBigInt64(e.offset, !0);
+      return e.offset += 8, n.timestampFromMicroseconds(i);
+    }
+    case 14: {
+      const i = e.view.getFloat32(e.offset, !0);
+      return e.offset += 4, i;
+    }
+    case 15:
+      return ue(e);
+    case 16: {
+      const i = ue(e);
+      return te.decode(i);
+    }
+    case 17: {
+      const i = e.view.getBigInt64(e.offset, !0);
+      return e.offset += 8, i;
+    }
+    case 18:
+    // timestamp_nanos (utc)
+    case 19: {
+      const i = e.view.getBigInt64(e.offset, !0);
+      return e.offset += 8, n.timestampFromNanoseconds(i);
+    }
+    case 20: {
+      const i = new Uint8Array(e.view.buffer, e.view.byteOffset + e.offset, 16);
+      e.offset += 16;
+      const f = Array.from(i, (o) => o.toString(16).padStart(2, "0")).join("");
+      return `${f.slice(0, 8)}-${f.slice(8, 12)}-${f.slice(12, 16)}-${f.slice(16, 20)}-${f.slice(20)}`;
+    }
+    default:
+      throw new Error(`parquet unsupported variant primitive type: ${t}`);
+  }
+}
+function nt(e, t, n, i) {
+  const f = (t & 3) + 1, o = (t >> 2 & 3) + 1, s = t >> 4 & 1 ? L(e, 4) : e.view.getUint8(e.offset++), l = new Array(s);
+  for (let c = 0; c < s; c++)
+    l[c] = L(e, o);
+  const a = new Array(s + 1);
+  for (let c = 0; c < a.length; c++)
+    a[c] = L(e, f);
+  const u = {};
+  for (let c = 0; c < s; c++) {
+    const d = n.dictionary[l[c]], g = {
+      view: e.view,
+      offset: e.offset + a[c]
+    };
+    u[d] = S(g, n, i);
+  }
+  return e.offset += a[a.length - 1], u;
+}
+function it(e, t, n, i) {
+  const f = t & 3, o = t >> 2 & 1, r = f + 1, s = L(e, o ? 4 : 1), l = new Array(s + 1);
+  for (let c = 0; c < l.length; c++)
+    l[c] = L(e, r);
+  const a = e.offset, u = new Array(s);
+  for (let c = 0; c < s; c++) {
+    const d = {
+      view: e.view,
+      offset: a + l[c]
+    };
+    u[c] = S(d, n, i);
+  }
+  return e.offset = a + l[l.length - 1], u;
+}
+function z(e, t) {
+  const n = e.view.getUint8(e.offset);
+  e.offset += 1;
+  let i;
+  if (t === 4)
+    i = BigInt(e.view.getInt32(e.offset, !0)), e.offset += 4;
+  else if (t === 8)
+    i = e.view.getBigInt64(e.offset, !0), e.offset += 8;
+  else {
+    const f = e.view.getBigUint64(e.offset, !0);
+    i = e.view.getBigInt64(e.offset + 8, !0) << 64n | f, e.offset += 16;
+  }
+  return Number(i) * 10 ** -n;
+}
+function ue(e) {
+  const t = e.view.getUint32(e.offset, !0);
+  e.offset += 4;
+  const n = new Uint8Array(e.view.buffer, e.view.byteOffset + e.offset, t);
+  return e.offset += t, n;
+}
+function ae(e, t, n, i, f) {
+  const o = J(f);
+  if (!t?.length && !n.length) {
+    if (!o || !i.length) return i;
+    t = new Array(i.length).fill(o);
+  }
+  const r = t?.length || n.length, s = f.map(({ element: p }) => p.repetition_type);
+  let l = 0;
+  const a = [e];
+  let u = e, c = 0, d = 0, g = 0;
+  if (n[0])
+    for (; c < s.length - 2 && g < n[0]; )
+      c++, s[c] !== "REQUIRED" && (u = u.at(-1), a.push(u), d++), s[c] === "REPEATED" && g++;
+  for (let p = 0; p < r; p++) {
+    const w = t?.length ? t[p] : o, h = n[p];
+    for (; c && (h < g || s[c] !== "REPEATED"); )
+      s[c] !== "REQUIRED" && (a.pop(), d--), s[c] === "REPEATED" && g--, c--;
+    for (u = a.at(-1); (c < s.length - 2 || s[c + 1] === "REPEATED") && (d < w || s[c + 1] === "REQUIRED"); ) {
+      if (c++, s[c] !== "REQUIRED") {
+        const _ = [];
+        u.push(_), u = _, a.push(_), d++;
+      }
+      s[c] === "REPEATED" && g++;
+    }
+    w === o ? u.push(i[l++]) : c === s.length - 2 ? u.push(null) : u.push([]);
+  }
+  if (!e.length)
+    for (let p = 0; p < o; p++) {
+      const w = [];
+      u.push(w), u = w;
+    }
+  return e;
+}
+function O(e, t, n, i = 0) {
+  const f = t.path.join("."), o = t.element.repetition_type === "OPTIONAL", r = o ? i + 1 : i;
+  if ($e(t)) {
+    let s = t.children[0], l = r;
+    s.children.length === 1 && (s = s.children[0], l++), O(e, s, n, l);
+    const a = s.path.join("."), u = e.get(a);
+    if (!u) throw new Error("parquet list column missing values");
+    o && $(u, i), e.set(f, u), e.delete(a);
+    return;
+  }
+  if (qe(t)) {
+    const s = t.children[0].element.name;
+    O(e, t.children[0].children[0], n, r + 1), O(e, t.children[0].children[1], n, r + 1);
+    const l = e.get(`${f}.${s}.key`), a = e.get(`${f}.${s}.value`);
+    if (!l) throw new Error("parquet map column missing keys");
+    if (!a) throw new Error("parquet map column missing values");
+    if (l.length !== a.length)
+      throw new Error("parquet map column key/value length mismatch");
+    const u = Se(l, a, r);
+    o && $(u, i), e.delete(`${f}.${s}.key`), e.delete(`${f}.${s}.value`), e.set(f, u);
+    return;
+  }
+  if (t.children.length) {
+    const s = t.element.repetition_type === "REQUIRED" ? i : i + 1, l = {};
+    for (const u of t.children) {
+      O(e, u, n, s);
+      const c = e.get(u.path.join("."));
+      if (!c) throw new Error("parquet struct missing child data");
+      l[u.element.name] = c;
+    }
+    for (const u of t.children)
+      e.delete(u.path.join("."));
+    let a = Be(l, s);
+    t.element.logical_type?.type === "VARIANT" && (a = Oe(a, n)), o && $(a, i), e.set(f, a);
+  }
+}
+function $(e, t) {
+  for (let n = 0; n < e.length; n++)
+    t ? $(e[n], t - 1) : e[n] = e[n][0];
+}
+function Se(e, t, n) {
+  const i = [];
+  for (let f = 0; f < e.length; f++)
+    if (n)
+      i.push(Se(e[f], t[f], n - 1));
+    else if (e[f]) {
+      const o = {};
+      for (let r = 0; r < e[f].length; r++) {
+        const s = t[f][r];
+        o[e[f][r]] = s === void 0 ? null : s;
+      }
+      i.push(o);
+    } else
+      i.push(void 0);
+  return i;
+}
+function Be(e, t) {
+  const n = Object.keys(e), i = e[n[0]]?.length, f = [];
+  for (let o = 0; o < i; o++) {
+    const r = {};
+    for (const s of n) {
+      if (e[s].length !== i) throw new Error("parquet struct parsing error");
+      r[s] = e[s][o];
+    }
+    t ? f.push(Be(r, t - 1)) : f.push(r);
+  }
+  return f;
+}
+function B(e, t, n) {
+  const i = n instanceof Int32Array, f = T(e), o = T(e);
+  T(e);
+  let r = Z(e), s = 0;
+  n[s++] = i ? Number(r) : r;
+  const l = f / o;
+  for (; s < t; ) {
+    const a = Z(e), u = new Uint8Array(o);
+    for (let c = 0; c < o; c++)
+      u[c] = e.view.getUint8(e.offset++);
+    for (let c = 0; c < o && s < t; c++) {
+      const d = BigInt(u[c]);
+      if (d) {
+        let g = 0n, p = l;
+        const w = (1n << d) - 1n;
+        for (; p && s < t; ) {
+          let h = BigInt(e.view.getUint8(e.offset)) >> g & w;
+          for (g += d; g >= 8; )
+            g -= 8n, e.offset++, g && (h |= BigInt(e.view.getUint8(e.offset)) << d - g & w);
+          const _ = a + h;
+          r += _, n[s++] = i ? Number(r) : r, p--;
+        }
+        p && (e.offset += Math.ceil((p * Number(d) + Number(g)) / 8));
+      } else
+        for (let g = 0; g < l && s < t; g++)
+          r += a, n[s++] = i ? Number(r) : r;
+    }
+  }
+}
+function De(e, t, n) {
+  const i = new Int32Array(t);
+  B(e, t, i);
+  for (let f = 0; f < t; f++)
+    n[f] = new Uint8Array(e.view.buffer, e.view.byteOffset + e.offset, i[f]), e.offset += i[f];
+}
+function ft(e, t, n) {
+  const i = new Int32Array(t);
+  B(e, t, i);
+  const f = new Int32Array(t);
+  B(e, t, f);
+  for (let o = 0; o < t; o++) {
+    const r = new Uint8Array(e.view.buffer, e.view.byteOffset + e.offset, f[o]);
+    i[o] ? (n[o] = new Uint8Array(i[o] + f[o]), n[o].set(n[o - 1].subarray(0, i[o])), n[o].set(r, i[o])) : n[o] = r, e.offset += f[o];
+  }
+}
+function V(e) {
+  return 32 - Math.clz32(e);
+}
+function v(e, t, n, i) {
+  i === void 0 && (i = e.view.getUint32(e.offset, !0), e.offset += 4);
+  const f = e.offset;
+  let o = 0;
+  for (; o < n.length; ) {
+    const r = T(e);
+    if (r & 1)
+      o = st(e, r, t, n, o);
+    else {
+      const s = r >>> 1;
+      ot(e, s, t, n, o), o += s;
+    }
+  }
+  e.offset = f + i;
+}
+function ot(e, t, n, i, f) {
+  const o = n + 7 >> 3;
+  let r = 0;
+  for (let s = 0; s < o; s++)
+    r |= e.view.getUint8(e.offset++) << (s << 3);
+  for (let s = 0; s < t; s++)
+    i[f + s] = r;
+}
+function st(e, t, n, i, f) {
+  let o = t >> 1 << 3;
+  const r = (1 << n) - 1;
+  let s = 0;
+  if (e.offset < e.view.byteLength)
+    s = e.view.getUint8(e.offset++);
+  else if (r)
+    throw new Error(`parquet bitpack offset ${e.offset} out of range`);
+  let l = 8, a = 0;
+  for (; o; )
+    a > 8 ? (a -= 8, l -= 8, s >>>= 8) : l - a < n ? (s |= e.view.getUint8(e.offset) << l, e.offset++, l += 8) : (f < i.length && (i[f++] = s >> a & r), o--, a += n);
+  return f;
+}
+function Pe(e, t, n, i) {
+  const f = rt(n, i), o = new Uint8Array(t * f);
+  for (let r = 0; r < f; r++)
+    for (let s = 0; s < t; s++)
+      o[s * f + r] = e.view.getUint8(e.offset++);
+  if (n === "FLOAT") return new Float32Array(o.buffer);
+  if (n === "DOUBLE") return new Float64Array(o.buffer);
+  if (n === "INT32") return new Int32Array(o.buffer);
+  if (n === "INT64") return new BigInt64Array(o.buffer);
+  if (n === "FIXED_LEN_BYTE_ARRAY") {
+    const r = new Array(t);
+    for (let s = 0; s < t; s++)
+      r[s] = o.subarray(s * f, (s + 1) * f);
+    return r;
+  }
+  throw new Error(`parquet byte_stream_split unsupported type: ${n}`);
+}
+function rt(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 ne(e, t, n, i) {
+  if (n === 0) return [];
+  if (t === "BOOLEAN")
+    return lt(e, n);
+  if (t === "INT32")
+    return ct(e, n);
+  if (t === "INT64")
+    return ut(e, n);
+  if (t === "INT96")
+    return at(e, n);
+  if (t === "FLOAT")
+    return _t(e, n);
+  if (t === "DOUBLE")
+    return dt(e, n);
+  if (t === "BYTE_ARRAY")
+    return gt(e, n);
+  if (t === "FIXED_LEN_BYTE_ARRAY") {
+    if (!i) throw new Error("parquet missing fixed length");
+    return ht(e, n, i);
+  } else
+    throw new Error(`parquet unhandled type: ${t}`);
+}
+function lt(e, t) {
+  const n = new Array(t);
+  for (let i = 0; i < t; i++) {
+    const f = e.offset + (i / 8 | 0), o = i % 8, r = e.view.getUint8(f);
+    n[i] = (r & 1 << o) !== 0;
+  }
+  return e.offset += Math.ceil(t / 8), n;
+}
+function ct(e, t) {
+  const n = (e.view.byteOffset + e.offset) % 4 ? new Int32Array(G(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, n;
+}
+function ut(e, t) {
+  const n = (e.view.byteOffset + e.offset) % 8 ? new BigInt64Array(G(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, n;
+}
+function at(e, t) {
+  const n = new Array(t);
+  for (let i = 0; i < t; i++) {
+    const f = e.view.getBigInt64(e.offset + i * 12, !0), o = e.view.getInt32(e.offset + i * 12 + 8, !0);
+    n[i] = BigInt(o) << 64n | f;
+  }
+  return e.offset += t * 12, n;
+}
+function _t(e, t) {
+  const n = (e.view.byteOffset + e.offset) % 4 ? new Float32Array(G(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, n;
+}
+function dt(e, t) {
+  const n = (e.view.byteOffset + e.offset) % 8 ? new Float64Array(G(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, n;
+}
+function gt(e, t) {
+  const n = new Array(t);
+  for (let i = 0; i < t; i++) {
+    const f = e.view.getUint32(e.offset, !0);
+    e.offset += 4, n[i] = new Uint8Array(e.view.buffer, e.view.byteOffset + e.offset, f), e.offset += f;
+  }
+  return n;
+}
+function ht(e, t, n) {
+  const i = new Array(t);
+  for (let f = 0; f < t; f++)
+    i[f] = new Uint8Array(e.view.buffer, e.view.byteOffset + e.offset, n), e.offset += n;
+  return i;
+}
+function G(e, t, n) {
+  const i = new ArrayBuffer(n);
+  return new Uint8Array(i).set(new Uint8Array(e, t, n)), i;
+}
+const pt = [0, 255, 65535, 16777215, 4294967295];
+function _e(e, t, n, i, f) {
+  for (let o = 0; o < f; o++)
+    n[i + o] = e[t + o];
+}
+function wt(e, t) {
+  const n = e.byteLength, i = t.byteLength;
+  let f = 0, o = 0;
+  for (; f < n; ) {
+    const r = e[f];
+    if (f++, r < 128)
+      break;
+  }
+  if (i && f >= n)
+    throw new Error("invalid snappy length header");
+  for (; f < n; ) {
+    const r = e[f];
+    let s = 0;
+    if (f++, f >= n)
+      throw new Error("missing eof marker");
+    if ((r & 3) === 0) {
+      let l = (r >>> 2) + 1;
+      if (l > 60) {
+        if (f + 3 >= n)
+          throw new Error("snappy error literal pos + 3 >= inputLength");
+        const a = l - 60;
+        l = e[f] + (e[f + 1] << 8) + (e[f + 2] << 16) + (e[f + 3] << 24), l = (l & pt[a]) + 1, f += a;
+      }
+      if (f + l > n)
+        throw new Error("snappy error literal exceeds input length");
+      _e(e, f, t, o, l), f += l, o += l;
+    } else {
+      let l = 0;
+      switch (r & 3) {
+        case 1:
+          s = (r >>> 2 & 7) + 4, l = e[f] + (r >>> 5 << 8), f++;
+          break;
+        case 2:
+          if (n <= f + 1)
+            throw new Error("snappy error end of input");
+          s = (r >>> 2) + 1, l = e[f] + (e[f + 1] << 8), f += 2;
+          break;
+        case 3:
+          if (n <= f + 3)
+            throw new Error("snappy error end of input");
+          s = (r >>> 2) + 1, l = e[f] + (e[f + 1] << 8) + (e[f + 2] << 16) + (e[f + 3] << 24), f += 4;
+          break;
+      }
+      if (l === 0 || isNaN(l))
+        throw new Error(`invalid offset ${l} pos ${f} inputLength ${n}`);
+      if (l > o)
+        throw new Error("cannot copy from before start of buffer");
+      _e(t, o - l, t, o, s), o += s;
+    }
+  }
+  if (o !== i) throw new Error("premature end of input");
+}
+function yt(e, t, { type: n, element: i, schemaPath: f }) {
+  const o = new DataView(e.buffer, e.byteOffset, e.byteLength), r = { view: o, offset: 0 };
+  let s;
+  const l = mt(r, t, f), { definitionLevels: a, numNulls: u } = At(r, t, f), c = t.num_values - u;
+  if (t.encoding === "PLAIN")
+    s = ne(r, n, c, i.type_length);
+  else if (t.encoding === "PLAIN_DICTIONARY" || t.encoding === "RLE_DICTIONARY" || t.encoding === "RLE") {
+    const d = n === "BOOLEAN" ? 1 : o.getUint8(r.offset++);
+    d ? (s = new Array(c), n === "BOOLEAN" ? (v(r, d, s), s = s.map((g) => !!g)) : v(r, d, s, o.byteLength - r.offset)) : s = new Uint8Array(c);
+  } else if (t.encoding === "BYTE_STREAM_SPLIT")
+    s = Pe(r, c, n, i.type_length);
+  else if (t.encoding === "DELTA_BINARY_PACKED")
+    s = n === "INT32" ? new Int32Array(c) : new BigInt64Array(c), B(r, c, s);
+  else if (t.encoding === "DELTA_LENGTH_BYTE_ARRAY")
+    s = new Array(c), De(r, c, s);
+  else
+    throw new Error(`parquet unsupported encoding: ${t.encoding}`);
+  return { definitionLevels: a, repetitionLevels: l, dataPage: s };
+}
+function mt(e, t, n) {
+  if (n.length > 1) {
+    const i = ve(n);
+    if (i) {
+      const f = new Array(t.num_values);
+      return v(e, V(i), f), f;
+    }
+  }
+  return [];
+}
+function At(e, t, n) {
+  const i = J(n);
+  if (!i) return { definitionLevels: [], numNulls: 0 };
+  const f = new Array(t.num_values);
+  v(e, V(i), f);
+  let o = t.num_values;
+  for (const r of f)
+    r === i && o--;
+  return o === 0 && (f.length = 0), { definitionLevels: f, numNulls: o };
+}
+function X(e, t, n, i) {
+  let f;
+  const o = i?.[n];
+  if (n === "UNCOMPRESSED")
+    f = e;
+  else if (o)
+    f = o(e, t);
+  else if (n === "SNAPPY")
+    f = new Uint8Array(t), wt(e, f);
+  else
+    throw new Error(`parquet unsupported compression codec: ${n}`);
+  if (f?.length !== t)
+    throw new Error(`parquet decompressed page length ${f?.length} does not match header ${t}`);
+  return f;
+}
+function Et(e, t, n) {
+  const f = { view: new DataView(e.buffer, e.byteOffset, e.byteLength), offset: 0 }, { type: o, element: r, schemaPath: s, codec: l, compressors: a } = n, u = t.data_page_header_v2;
+  if (!u) throw new Error("parquet data page header v2 is undefined");
+  const c = It(f, u, s);
+  f.offset = u.repetition_levels_byte_length;
+  const d = vt(f, u, s), g = t.uncompressed_page_size - u.definition_levels_byte_length - u.repetition_levels_byte_length;
+  let p = e.subarray(f.offset);
+  u.is_compressed !== !1 && (p = X(p, g, l, a));
+  const w = new DataView(p.buffer, p.byteOffset, p.byteLength), h = { view: w, offset: 0 };
+  let _;
+  const m = u.num_values - u.num_nulls;
+  if (u.encoding === "PLAIN")
+    _ = ne(h, o, m, r.type_length);
+  else if (u.encoding === "RLE")
+    _ = new Array(m), v(h, 1, _), _ = _.map((y) => !!y);
+  else if (u.encoding === "PLAIN_DICTIONARY" || u.encoding === "RLE_DICTIONARY") {
+    const y = w.getUint8(h.offset++);
+    _ = new Array(m), v(h, y, _, g - 1);
+  } else if (u.encoding === "DELTA_BINARY_PACKED")
+    _ = o === "INT32" ? new Int32Array(m) : new BigInt64Array(m), B(h, m, _);
+  else if (u.encoding === "DELTA_LENGTH_BYTE_ARRAY")
+    _ = new Array(m), De(h, m, _);
+  else if (u.encoding === "DELTA_BYTE_ARRAY")
+    _ = new Array(m), ft(h, m, _);
+  else if (u.encoding === "BYTE_STREAM_SPLIT")
+    _ = Pe(h, m, o, r.type_length);
+  else
+    throw new Error(`parquet unsupported encoding: ${u.encoding}`);
+  return { definitionLevels: d, repetitionLevels: c, dataPage: _ };
+}
+function It(e, t, n) {
+  const i = ve(n);
+  if (!i) return [];
+  const f = new Array(t.num_values);
+  return v(e, V(i), f, t.repetition_levels_byte_length), f;
+}
+function vt(e, t, n) {
+  const i = J(n);
+  if (i) {
+    const f = new Array(t.num_values);
+    return v(e, V(i), f, t.definition_levels_byte_length), f;
+  }
+}
+function de(e, { groupStart: t, selectStart: n, selectEnd: i }, f, o) {
+  const { pathInSchema: r, schemaPath: s } = f, l = be(s), a = [];
+  let u, c, d = 0, g = 0;
+  const p = o && (() => {
+    c && o({
+      pathInSchema: r,
+      columnData: c,
+      rowStart: t + d - c.length,
+      rowEnd: t + d
+    });
+  });
+  for (; (l ? d < i : e.offset < e.view.byteLength - 1) && !(e.offset >= e.view.byteLength - 1); ) {
+    const w = bt(e);
+    if (w.type === "DICTIONARY_PAGE") {
+      const { data: h } = ge(e, w, f, u, void 0, 0);
+      h && (u = ye(h, f));
+    } else {
+      const h = c?.length || 0, _ = ge(e, w, f, u, c, n - d);
+      _.skipped ? (a.length || (g += _.skipped), d += _.skipped) : _.data && c === _.data ? d += _.data.length - h : _.data && _.data.length && (p?.(), a.push(_.data), d += _.data.length, c = _.data);
+    }
+  }
+  return p?.(), { data: a, skipped: g };
+}
+function ge(e, t, n, i, f, o) {
+  const { type: r, element: s, schemaPath: l, codec: a, compressors: u } = n, c = 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 d = t.data_page_header;
+    if (!d) throw new Error("parquet data page header is undefined");
+    if (o > d.num_values && be(l))
+      return { skipped: d.num_values };
+    const g = X(c, Number(t.uncompressed_page_size), a, u), { definitionLevels: p, repetitionLevels: w, dataPage: h } = yt(g, d, n), _ = se(h, i, d.encoding, n), m = Array.isArray(f) ? f : [];
+    return { skipped: 0, data: ae(m, p, w, _, l) };
+  } else if (t.type === "DATA_PAGE_V2") {
+    const d = t.data_page_header_v2;
+    if (!d) throw new Error("parquet data page header v2 is undefined");
+    if (o > d.num_rows)
+      return { skipped: d.num_values };
+    const { definitionLevels: g, repetitionLevels: p, dataPage: w } = Et(c, t, n), h = se(w, i, d.encoding, n), _ = Array.isArray(f) ? f : [];
+    return { skipped: 0, data: ae(_, g, p, h, l) };
+  } else if (t.type === "DICTIONARY_PAGE") {
+    const d = t.dictionary_page_header;
+    if (!d) throw new Error("parquet dictionary page header is undefined");
+    const g = X(
+      c,
+      Number(t.uncompressed_page_size),
+      a,
+      u
+    ), p = { view: new DataView(g.buffer, g.byteOffset, g.byteLength), offset: 0 };
+    return { skipped: 0, data: ne(p, r, d.num_values, s.type_length) };
+  } else
+    throw new Error(`parquet unsupported page type: ${t.type}`);
+}
+function bt(e) {
+  const t = ee(e), n = pe[t.field_1], i = t.field_2, f = t.field_3, o = t.field_4, r = t.field_5 && {
+    num_values: t.field_5.field_1,
+    encoding: b[t.field_5.field_2],
+    definition_level_encoding: b[t.field_5.field_3],
+    repetition_level_encoding: b[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
+    }
+  }, s = t.field_6, l = t.field_7 && {
+    num_values: t.field_7.field_1,
+    encoding: b[t.field_7.field_2],
+    is_sorted: t.field_7.field_3
+  }, a = 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: b[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: n,
+    uncompressed_page_size: i,
+    compressed_page_size: f,
+    crc: o,
+    data_page_header: r,
+    index_page_header: s,
+    dictionary_page_header: l,
+    data_page_header_v2: a
+  };
+}
+function Tt(e) {
+  const t = ee(e);
+  return {
+    page_locations: t.field_1.map(Lt),
+    unencoded_byte_array_data_bytes: t.field_2
+  };
+}
+function Lt(e) {
+  return {
+    offset: e.field_1,
+    compressed_page_size: e.field_2,
+    first_row_index: e.field_3
+  };
+}
+function Rt(e, { metadata: t }, n) {
+  const { file: i, compressors: f, utf8: o } = e, r = [], s = { ...j, ...e.parsers };
+  for (const l of n.chunks) {
+    const { columnMetadata: a } = l, u = Ie(t.schema, a.path_in_schema), c = {
+      pathInSchema: a.path_in_schema,
+      type: a.type,
+      element: u[u.length - 1].element,
+      schemaPath: u,
+      codec: a.codec,
+      parsers: s,
+      compressors: f,
+      utf8: o
+    };
+    if (!("offsetIndex" in l)) {
+      r.push({
+        pathInSchema: a.path_in_schema,
+        data: Promise.resolve(i.slice(l.range.startByte, l.range.endByte)).then((d) => {
+          const g = { view: new DataView(d), offset: 0 };
+          return de(g, n, c, e.onPage);
+        })
+      });
+      continue;
+    }
+    r.push({
+      pathInSchema: a.path_in_schema,
+      // fetch offset index
+      data: Promise.resolve(i.slice(l.offsetIndex.startByte, l.offsetIndex.endByte)).then(async (d) => {
+        const g = Tt({ view: new DataView(d), offset: 0 }), { selectStart: p, selectEnd: w } = n, h = g.page_locations;
+        let _ = NaN, m = NaN, y = 0;
+        for (let N = 0; N < h.length; N++) {
+          const M = h[N], ie = Number(M.first_row_index), Ue = N + 1 < h.length ? Number(h[N + 1].first_row_index) : n.groupRows;
+          ie < w && Ue > p && (Number.isNaN(_) && (_ = Number(M.offset), y = ie), m = Number(M.offset) + M.compressed_page_size);
+        }
+        const E = await i.slice(_, m), D = { view: new DataView(E), offset: 0 }, P = y ? {
+          ...n,
+          groupStart: n.groupStart + y,
+          selectStart: n.selectStart - y,
+          selectEnd: n.selectEnd - y
+        } : n, { data: U, skipped: x } = de(D, P, c, e.onPage);
+        return {
+          data: U,
+          skipped: y + x
+        };
+      })
+    });
+  }
+  return { groupStart: n.groupStart, groupRows: n.groupRows, asyncColumns: r };
+}
+function Nt(e, t, n) {
+  const { asyncColumns: i } = e;
+  n = { ...j, ...n };
+  const f = [];
+  for (const o of t.children)
+    if (o.children.length) {
+      const r = i.filter((a) => a.pathInSchema[0] === o.element.name);
+      if (!r.length) continue;
+      const s = /* @__PURE__ */ new Map(), l = Promise.all(r.map((a) => a.data.then(({ data: u }) => {
+        s.set(a.pathInSchema.join("."), Ze(u));
+      }))).then(() => {
+        O(s, o, n);
+        const a = s.get(o.path.join("."));
+        if (!a) throw new Error("parquet column data not assembled");
+        return { data: [a], skipped: 0 };
+      });
+      f.push({ pathInSchema: o.path, data: l });
+    } else {
+      const r = i.find((s) => s.pathInSchema[0] === o.element.name);
+      r && f.push(r);
+    }
+  return { ...e, asyncColumns: f };
+}
+const he = /* @__PURE__ */ new Map(), Ot = 200;
+function St(e) {
+  if (!e.metadata)
+    throw new Error("parquet requires metadata");
+  const t = Xe(e);
+  return e.file = Je(e.file, t), t.groups.map(
+    (n) => Rt(e, t, n)
+  );
+}
+function Bt(e) {
+  if (!e)
+    return [];
+  if (e.length === 1)
+    return e[0];
+  let t = 0;
+  for (const f of e)
+    t += f.length;
+  const n = Array(t);
+  let i = 0;
+  for (const f of e) {
+    for (let o = 0; o < f.length; o++)
+      n[i + o] = f[o];
+    i += f.length;
+  }
+  return n;
+}
+function Dt(e) {
+  const t = e.join(""), n = he.get(t);
+  if (n)
+    return n;
+  const i = e.map(
+    (o, r) => JSON.stringify(o) + ": columnData[" + r + "][row - columnSkipped[" + r + "]]"
+  ).join(`,
+`), f = (
+    /** @type {RowGroupObjectBuilder} */
+    new Function(
+      "groupData",
+      "selectStart",
+      "selectCount",
+      "columnData",
+      "columnSkipped",
+      // Keep generated code focused on the tight row loop only.
+      `for (let selectRow = 0; selectRow < selectCount; selectRow++) {
+    const row = selectStart + selectRow;
+    groupData[selectRow] = {
+` + i + `
+    };
+}
+return groupData;`
+    )
+  );
+  return he.set(t, f), f;
+}
+function Pt(e, t, n, i, f, o) {
+  for (let r = 0; r < n; r++) {
+    const s = t + r, l = {};
+    for (let a = 0; a < i.length; a++)
+      l[i[a]] = f[a][s - o[a]];
+    e[r] = l;
+  }
+  return e;
+}
+async function Ut({ asyncColumns: e }, t, n) {
+  const i = await Promise.all(e.map((c) => c.data)), f = e.length, o = Array(f), r = Array(f), s = Array(f);
+  for (let c = 0; c < f; c++)
+    o[c] = e[c].pathInSchema[0], r[c] = Bt(i[c].data), s[c] = i[c].skipped;
+  const l = n - t, a = Array(l);
+  return f > Ot ? Pt(
+    a,
+    t,
+    l,
+    o,
+    r,
+    s
+  ) : Dt(o)(
+    a,
+    t,
+    l,
+    r,
+    s
+  );
+}
+async function xt(e) {
+  if ("rowFormat" in e)
+    throw new Error(
+      'parquetRead supports only object rows; use rowFormat: "object" implicitly'
+    );
+  if ("filter" in e || "filterStrict" in e)
+    throw new Error("parquetRead does not support filtering");
+  e.metadata ??= await We(e.file, e);
+  const { rowStart: t = 0, rowEnd: n, onChunk: i, onComplete: f } = e, o = St(e);
+  if (!f && !i) {
+    for (const { asyncColumns: l } of o)
+      for (const { data: a } of l)
+        await a;
+    return;
+  }
+  const r = Re(e.metadata), s = o.map(
+    (l) => Nt(l, r, e.parsers)
+  );
+  if (i)
+    for (const l of s)
+      for (const a of l.asyncColumns)
+        a.data.then(
+          /**
+           * @param {{ data: import("hyparquet").DecodedArray[]; skipped: number }} chunk
+           */
+          (u) => {
+            let c = l.groupStart + u.skipped;
+            for (const d of u.data)
+              i({
+                columnName: a.pathInSchema[0],
+                columnData: d,
+                rowStart: c,
+                rowEnd: c + d.length
+              }), c += d.length;
+          }
+        );
+  if (f) {
+    const l = [];
+    for (const a of s) {
+      const u = Math.max(t - a.groupStart, 0), c = Math.min(
+        (n ?? 1 / 0) - a.groupStart,
+        a.groupRows
+      ), d = await Ut(
+        a,
+        u,
+        c
+      );
+      Ne(l, d);
+    }
+    f(l);
+  } else
+    for (const { asyncColumns: l } of s)
+      for (const { data: a } of l)
+        await a;
+}
+function Mt(e) {
+  return new Promise((t, n) => {
+    xt({
+      ...e,
+      onComplete: t
+    }).catch(n);
+  });
+}
+export {
+  xt as parquetRead,
+  Mt as parquetReadObjects
+};