@milaboratories/graph-maker 1.1.132 → 1.1.134

package/dist/node_modules/@milaboratories/pf-plots/dist/index.js

@@ -0,0 +1,3244 @@
+import j from "../../../canonicalize/lib/canonicalize.js";
+import { deriveLabels as De, isLabelColumn as Be } from "../../../@platforma-sdk/model/dist/index.js";
+import ce from "../../../lodash/lodash.js";
+var Pe = "pl7.app/axisNature", ge = "pl7.app/label", Oe = "pl7.app/columnAsAxis/name", Fe = "pl7.app/columnAsAxis/domain", K = "pl7.app/isSubset", $ = "pl7.app/isDiscreteFilter", _e = "pl7.app/discreteValues", Le = "pl7.app/graph/axis/highCardinality", Te = "pl7.app/graph/isVirtual", we = "pl7.app/isLinkerColumn", _ = class te {
+  constructor({ type: e, name: o, domain: n }) {
+    this.kind = "axis", this.type = e, this.name = o, this.domain = { ...n };
+  }
+  toCanonicalString() {
+    return j(this);
+  }
+  static fromAxisSpec(e) {
+    return new te({ name: e.name, type: e.type, domain: e.domain });
+  }
+  static fromAxesSpec(e) {
+    return e.map((o) => te.fromAxisSpec(o));
+  }
+  copy() {
+    return new te({ type: this.type, name: this.name, domain: this.domain });
+  }
+  toPFrameId() {
+    return {
+      type: this.type,
+      name: this.name,
+      domain: this.domain
+    };
+  }
+  static fromPojo(e) {
+    return new te(e);
+  }
+}, Y = class xe {
+  constructor({ name: e, type: o }) {
+    this.kind = "column", this.name = e, this.type = o;
+  }
+  toCanonicalString() {
+    return j(this);
+  }
+  static fromPojo(e) {
+    return new xe(e);
+  }
+};
+function B(t) {
+  return t !== null && t.kind === "column";
+}
+function se(t) {
+  return t !== null && t.kind === "axis";
+}
+function C(t) {
+  const e = JSON.parse(t);
+  if (e.kind === "column")
+    return Y.fromPojo(e);
+  if (e.kind === "axis")
+    return _.fromPojo(e);
+  throw Error("wrong column or axis object");
+}
+async function Ee(t, e, o, n, l, s, c = !0) {
+  var a, r, u, p;
+  const m = C(e);
+  if (B(m)) {
+    const d = await t.pFrameProvider.getColumnSpecById(m);
+    if (!d)
+      return;
+    const w = d.axesSpec.map((x) => _.fromAxisSpec(x).toCanonicalString()), h = [], A = {};
+    c && w.forEach((x, b) => {
+      !l.has(x) && !s.has(x) && (h.push(x), A[x] = b);
+    });
+    const v = {
+      kind: "column",
+      name: d.name,
+      label: o ?? await F(t, e, []),
+      type: d.valueType,
+      spec: d,
+      annotations: d.annotations,
+      isSubsetFilter: ((a = d.annotations) == null ? void 0 : a[K]) === "true",
+      isDiscreteFilter: d.valueType === "String" || ((r = d.annotations) == null ? void 0 : r[$]) === "true",
+      axesToBeFixed: h,
+      axesToBeFixedIndexes: A
+    };
+    n.set(m.toCanonicalString(), v);
+    for (const x of d.axesSpec) {
+      const g = _.fromAxisSpec(x).toCanonicalString();
+      if (n.has(g))
+        continue;
+      const i = Ce(x), f = {
+        kind: "axis",
+        name: x.name,
+        label: await F(t, g, [e]),
+        type: x.type,
+        mustBeConsumed: i,
+        dividable: !1,
+        spec: x,
+        annotations: x.annotations,
+        isSubsetFilter: ((u = x.annotations) == null ? void 0 : u[K]) === "true",
+        isDiscreteFilter: x.type === "String" || ((p = x.annotations) == null ? void 0 : p[$]) === "true",
+        parentSources: [e]
+      };
+      n.set(g, f);
+    }
+  }
+}
+function Se(t) {
+  const e = C(t), { name: o, type: n } = e;
+  return B(e) ? {
+    kind: "column",
+    name: "",
+    label: " ",
+    type: e.type,
+    spec: { axesSpec: [], kind: "PColumn", valueType: e.type, name: o },
+    annotations: void 0,
+    isSubsetFilter: !1,
+    isDiscreteFilter: e.type === "String",
+    axesToBeFixed: [],
+    axesToBeFixedIndexes: {}
+  } : {
+    kind: "axis",
+    name: "",
+    label: " ",
+    type: n,
+    spec: { type: n, name: o },
+    mustBeConsumed: !1,
+    dividable: !1,
+    annotations: void 0,
+    isSubsetFilter: !1,
+    isDiscreteFilter: n === "String",
+    parentSources: []
+  };
+}
+function ie(t) {
+  return {
+    type: t.type,
+    components: { ...t.components },
+    dividedAxes: { ...t.dividedAxes }
+  };
+}
+function ke(t) {
+  const { selectedSource: e, type: o, selectedFilterRange: n, selectedFilterValue: l } = t, s = C(e);
+  if (!s)
+    throw Error("Empty source selected");
+  if (o === "range") {
+    const c = [];
+    return (n == null ? void 0 : n.max) !== void 0 && c.push({
+      type: "bySingleColumnV2",
+      column: se(s) ? { type: "axis", id: s.toPFrameId() } : { type: "column", id: s.name },
+      predicate: {
+        operator: "LessOrEqual",
+        reference: n.max
+      }
+    }), (n == null ? void 0 : n.min) !== void 0 && c.push({
+      type: "bySingleColumnV2",
+      column: se(s) ? { type: "axis", id: s.toPFrameId() } : { type: "column", id: s.name },
+      predicate: {
+        operator: "GreaterOrEqual",
+        reference: n == null ? void 0 : n.min
+      }
+    }), c;
+  } else if (o === "subset")
+    return [
+      {
+        type: "bySingleColumnV2",
+        column: se(s) ? { type: "axis", id: s.toPFrameId() } : { type: "column", id: s.name },
+        predicate: {
+          operator: "Not",
+          operand: { operator: "IsNA" }
+        }
+      }
+    ];
+  return typeof l > "u" ? [] : [
+    {
+      type: "bySingleColumnV2",
+      column: se(s) ? { type: "axis", id: s.toPFrameId() } : {
+        type: "column",
+        id: s.name
+      },
+      predicate: {
+        operator: "Equal",
+        reference: s.type === "String" ? String(l) : Number(l)
+      }
+    }
+  ];
+}
+function U(t) {
+  const e = [];
+  for (const o of t)
+    e.push(...ke(o));
+  return e;
+}
+function ye(t) {
+  var e, o, n, l;
+  if ("kind" in t && t.kind === "PColumn") {
+    const a = (o = t.name) != null ? o : (e = t.annotations) == null ? void 0 : e[Oe], r = (l = t.domain) != null ? l : (n = t.annotations) == null ? void 0 : n[Fe];
+    return j({ name: a, domain: r });
+  }
+  const s = t.name, c = t.domain;
+  return j({ name: s, domain: c });
+}
+async function ve(t, e, o) {
+  var n;
+  for (const l of o) {
+    const s = C(l);
+    if (B(s)) {
+      const c = await t.pFrameProvider.getColumnSpecById(s), a = ((n = c == null ? void 0 : c.axesSpec) != null ? n : []).find(
+        (r) => _.fromAxisSpec(r).toCanonicalString() === e.toCanonicalString()
+      );
+      if (a)
+        return a;
+    }
+  }
+  return null;
+}
+var Ne = "pl7.app/label";
+async function E(t, e, o) {
+  const n = C(e);
+  if (B(n))
+    return;
+  async function l(r) {
+    const u = await ve(t, r, o);
+    return u ? ye(u) : null;
+  }
+  const s = await t.pFrameProvider.getColumnsFull([], !1, void 0, [Ne]), c = await l(n), a = s.find(({ spec: r }) => r && r.axesSpec.length === 1 && ye(r.axesSpec[0]) === c);
+  return a ? new Y({ name: a.columnId, type: a.spec.valueType }) : void 0;
+}
+async function F(t, e, o) {
+  var n, l;
+  const s = C(e), c = await E(t, e, o);
+  let a;
+  if (B(s) ? a = await t.pFrameProvider.getColumnSpecById(c ?? s) : a = c ? await t.pFrameProvider.getColumnSpecById(c) : await ve(t, s, o), !a)
+    return "";
+  const r = (l = (n = a.annotations) == null ? void 0 : n[ge]) != null ? l : a.name;
+  return t.labelsModifier(a.name, r);
+}
+function Ce(t) {
+  var e, o;
+  const n = (o = (e = t.annotations) == null ? void 0 : e[Pe]) == null ? void 0 : o.toLowerCase();
+  return !!n && n !== "homogenous" && n !== "homogeneous";
+}
+function H(t) {
+  var e, o;
+  return ((e = t.annotations) == null ? void 0 : e[K]) === "true" || ((o = t.annotations) == null ? void 0 : o[$]) === "true", !0;
+}
+function Ge(t) {
+  var e, o;
+  return !t.name.includes("metadata") && ((e = t.annotations) == null ? void 0 : e[Te]) !== "true" && ((o = t.annotations) == null ? void 0 : o[K]) !== "true";
+}
+async function W(t) {
+  var e;
+  const o = await t.pFrameProvider.getColumns(
+    [],
+    !1,
+    void 0,
+    void 0,
+    { [we]: "true" }
+  ), n = {};
+  for (const l of o) {
+    const s = await t.pFrameProvider.getColumnSpecById(l), c = (e = s == null ? void 0 : s.axesSpec) != null ? e : [];
+    if (s && c.length) {
+      const [a, r] = c, u = _.fromAxisSpec(a).toCanonicalString(), p = _.fromAxisSpec(r).toCanonicalString();
+      n[u] || (n[u] = {}), n[p] || (n[p] = {}), n[u][p] = { id: l, spec: s }, n[p][u] = { id: l, spec: s };
+    }
+  }
+  return n;
+}
+async function X(t, e) {
+  const o = /* @__PURE__ */ new Set();
+  for (const n of e) {
+    const l = C(n);
+    if (B(l)) {
+      const s = await t.pFrameProvider.getColumnSpecById(l);
+      if (!s)
+        continue;
+      s.axesSpec.forEach((c) => {
+        o.add(_.fromAxisSpec(c).toCanonicalString());
+      });
+    }
+  }
+  return o;
+}
+function qe(t, e, o) {
+  const n = {}, l = /* @__PURE__ */ new Set([e]);
+  let s = [e];
+  for (; s.length; ) {
+    const c = /* @__PURE__ */ new Set();
+    for (const a of s)
+      if (t[a]) {
+        const r = Object.keys(t[a]);
+        for (const u of r)
+          if (n[u] = a, u === o) {
+            const p = [];
+            let m = o;
+            for (; n[m] !== e; )
+              p.push(m), m = n[m];
+            return p.push(m), p.map((d) => t[d][n[d]].id);
+          } else l.has(u) || (c.add(u), l.add(u));
+      }
+    s = [...c];
+  }
+  return null;
+}
+function Me(t, e, o) {
+  const n = [...e].map((s) => qe(t, s, o)).filter((s) => s !== null);
+  if (n.length === 0)
+    return [];
+  let l = n[0];
+  for (const s of n)
+    s.length < l.length && (l = s);
+  return l;
+}
+async function M(t, e, o, n, l) {
+  const s = C(n);
+  if (!B(s))
+    return [];
+  const c = await t.pFrameProvider.getColumnSpecById(s);
+  if (!c)
+    return [];
+  const a = c.axesSpec.map((u) => _.fromAxisSpec(u).toCanonicalString()).filter((u) => !o.has(u) && !(l != null && l.some((p) => p.axisSource === u))), r = /* @__PURE__ */ new Set();
+  return a.forEach((u) => {
+    Me(e, o, u).forEach((m) => {
+      r.add(m.toCanonicalString());
+    });
+  }), [...r].map((u) => C(u));
+}
+function he(t, e) {
+  const o = e.columnsData[Object.keys(e.columnsData)[0]].length, n = new Int32Array(o).fill(0);
+  for (let l = 0; l < o; l++) {
+    let s = !1;
+    for (let c = 0; c < t.length; c++) {
+      const { selectedSource: a, selectedFilterValue: r, selectedFilterRange: u, type: p } = t[c], m = C(a), d = (B(m) ? e.columnsData[a] : e.axesData[a])[l];
+      if (r !== void 0 && (s = s || d === r), u !== void 0 && (u.min !== void 0 || u.max !== void 0) && typeof d == "number") {
+        let w = !0;
+        u.min !== void 0 && (w = w && d >= u.min), u.max !== void 0 && (w = w && d <= u.max), s = s || w;
+      }
+      p === "subset" && (s = s || d != null);
+    }
+    s && (n[l] = 1);
+  }
+  return n;
+}
+var R = class {
+  constructor(t, e) {
+    this.simpleComponentControllers = t, this.filterComponentControllers = e, this.ignoredOptionIdNames = [], this.dataInputs = [], this.dontAllowUnfilteredHighCardinality = !1;
+  }
+  get requiredComponents() {
+    const t = [];
+    for (const e of Object.keys(this.simpleComponentControllers))
+      this.simpleComponentControllers[e].isRequired && t.push(e);
+    return t;
+  }
+  get dimensionsConsumerComponents() {
+    const t = [];
+    for (const e of Object.keys(this.simpleComponentControllers))
+      this.simpleComponentControllers[e].isDimensionsConsumer && t.push(e);
+    for (const e of Object.keys(this.filterComponentControllers))
+      this.filterComponentControllers[e].isDimensionsConsumer && t.push(e);
+    return t;
+  }
+  addSelected(t, e, o) {
+    if (t in this.simpleComponentControllers)
+      return this.simpleComponentControllers[t].addSelected(e, o);
+    if (t in this.filterComponentControllers)
+      return this.filterComponentControllers[t].addSelected(e, o);
+    throw Error(`Unknown input name: ${String(t)}`);
+  }
+  deleteSelected(t, e, o, n) {
+    if (t in this.simpleComponentControllers)
+      return this.simpleComponentControllers[t].deleteSelected(o, n.selectedSource);
+    if (t in this.filterComponentControllers)
+      return this.filterComponentControllers[t].deleteSelected(o, n.selectedSource);
+    throw Error(`Unknown input name: ${String(t)}`);
+  }
+  changeSelected(t, e, o, n) {
+    const l = o.components[t].selectorStates, s = l.filter((r) => !n.find((u) => u.selectedSource === r.selectedSource)), c = n.filter((r) => !l.find((u) => u.selectedSource === r.selectedSource));
+    let a = ie(o);
+    return s.forEach((r) => {
+      a = this.deleteSelected(t, e, a, r);
+    }), c.forEach((r) => {
+      a = this.addSelected(t, a, r);
+    }), o.components[t].selectorStates = n.map(
+      (r) => o.components[t].selectorStates.find(
+        (u) => u.selectedSource === r.selectedSource
+      )
+    ).filter(Boolean), a;
+  }
+  switchDividableAxis(t, e) {
+    return ie(t);
+  }
+  async getMustBeConsumedAxes(t, e) {
+    return Promise.resolve(/* @__PURE__ */ new Set());
+  }
+  createEmptyComponentsGuide(t) {
+    return Object.fromEntries(
+      Object.entries(t.components).map(
+        ([e, o]) => [
+          e,
+          {
+            options: [],
+            optionsInfo: /* @__PURE__ */ new Map(),
+            stateConsistency: {},
+            required: !1,
+            multipleSelectors: !1
+          }
+        ]
+      )
+    );
+  }
+  async getSelectedSourcesInfo(t, e, o, n) {
+    var l;
+    const s = /* @__PURE__ */ new Map(), c = /* @__PURE__ */ new Set();
+    for (const u of this.dataInputs)
+      for (const p of e.components[u].selectorStates) {
+        const m = C(p.selectedSource);
+        if (B(m)) {
+          const d = await t.pFrameProvider.getColumnSpecById(m);
+          d && d.axesSpec.forEach(
+            (w) => c.add(_.fromAxisSpec(w).toCanonicalString())
+          );
+        }
+      }
+    const a = /* @__PURE__ */ new Set();
+    let r = [...c];
+    for (; r.length; ) {
+      const u = [];
+      for (const p of r)
+        if (n[p]) {
+          const m = Object.keys(n[p]);
+          for (const d of m)
+            !a.has(d) && !c.has(d) && (u.push(d), a.add(d));
+        }
+      r = u;
+    }
+    for (const [u, { selectorStates: p }] of Object.entries(e.components)) {
+      const d = ((l = this.simpleComponentControllers[u]) != null ? l : this.filterComponentControllers[u]).settings.columnsWithExtraAxesAllowed;
+      for (const { selectedSource: w } of p)
+        await Ee(t, w, o[w], s, c, a, d);
+    }
+    return s;
+  }
+  getEmptyInputGuide(t) {
+    return {
+      components: this.createEmptyComponentsGuide(t),
+      getSourceInfo: (e) => Se(e),
+      freeOptionsSet: /* @__PURE__ */ new Set(),
+      axesToBeFixedSet: /* @__PURE__ */ new Set(),
+      readyData: !1,
+      ready: !1,
+      consistent: !0
+    };
+  }
+  getConsumedOptionsSet(t) {
+    const e = /* @__PURE__ */ new Set();
+    for (const o of this.dimensionsConsumerComponents)
+      for (const { selectedSource: n } of t.components[o].selectorStates)
+        e.add(n);
+    return e;
+  }
+  async getLabelsMap(t, e) {
+    const o = await t.pFrameProvider.getColumnsFull(
+      this.dataInputs.reduce((n, l) => {
+        const c = e.components[l].selectorStates.map((a) => C(a.selectedSource));
+        return n.concat(c);
+      }, []),
+      !1
+    );
+    return De(o, (n) => n.spec).reduce((n, l) => {
+      const s = new Y({ name: l.value.columnId, type: l.value.spec.valueType }).toCanonicalString();
+      return n[s] = l.label, n;
+    }, {});
+  }
+  async calculateOptions(t, e, o = [], n = Ge) {
+    var l, s;
+    const c = this.createEmptyComponentsGuide(e), a = this.getConsumedOptionsSet(e), r = new Set(this.ignoredOptionIdNames), u = new Set(o), p = await W(t), m = await this.getLabelsMap(t, e), d = await this.getSelectedSourcesInfo(t, e, m, p), w = /* @__PURE__ */ new Map(), h = { ...this.simpleComponentControllers, ...this.filterComponentControllers }, A = /* @__PURE__ */ new Set();
+    for (const [f, y] of Object.entries(h)) {
+      const S = await y.getOptions(
+        t,
+        e,
+        m,
+        a,
+        p,
+        n,
+        r,
+        u
+      );
+      this.dataInputs.includes(f) || S.options.forEach((I) => {
+        A.add(I.value);
+      });
+      for (const [I, P] of S.optionsInfo)
+        w.set(I, P);
+      c[f] = S;
+    }
+    const v = (f) => {
+      const y = w.get(f);
+      y && y.kind === "axis" && (y.mustBeConsumed = !0);
+      const S = d.get(f);
+      S && S.kind === "axis" && (S.mustBeConsumed = !0);
+    }, x = await this.getMustBeConsumedAxes(t, e);
+    for (const f of x)
+      v(f);
+    if (this.dontAllowUnfilteredHighCardinality) {
+      const f = (S) => {
+        var I;
+        return ((I = S == null ? void 0 : S.annotations) == null ? void 0 : I[Le]) === "true";
+      }, y = (s = (l = e.components.filters) == null ? void 0 : l.selectorStates.reduce((S, I) => {
+        const P = d.get(I.selectedSource);
+        return (P == null ? void 0 : P.kind) === "column" && P.spec.axesSpec.filter(f).forEach((L) => S.add(_.fromAxisSpec(L).toCanonicalString())), (P == null ? void 0 : P.kind) === "axis" && f(P.spec) && S.add(_.fromAxisSpec(P.spec).toCanonicalString()), S;
+      }, /* @__PURE__ */ new Set())) != null ? s : /* @__PURE__ */ new Set();
+      this.dataInputs.forEach((S) => {
+        for (const { selectedSource: I } of e.components[S].selectorStates) {
+          const P = d.get(I);
+          if ((P == null ? void 0 : P.kind) === "column" && P.spec.axesSpec.filter(f).forEach((L) => {
+            const O = _.fromAxisSpec(L).toCanonicalString();
+            !A.has(O) && !y.has(O) && A.add(O), y.has(O) || v(O);
+          }), (P == null ? void 0 : P.kind) === "axis" && f(P.spec)) {
+            const N = _.fromAxisSpec(P.spec).toCanonicalString();
+            A.has(N) || A.add(N), y.has(N) || v(N);
+          }
+        }
+      });
+    }
+    const b = /* @__PURE__ */ new Set();
+    for (const { selectorStates: f } of Object.values(e.components))
+      for (const { selectedSource: y } of f) {
+        const S = d.get(y);
+        S && S.kind === "column" && S.axesToBeFixed.forEach((I) => {
+          b.add(I);
+        });
+      }
+    const g = await this.isConsistent(t, e, p), i = (f) => {
+      var y, S, I;
+      const P = (y = C(f).toCanonicalString()) != null ? y : f;
+      return (I = (S = w.get(P)) != null ? S : d.get(P)) != null ? I : Se(f);
+    };
+    return {
+      components: c,
+      getSourceInfo: i,
+      freeOptionsSet: A,
+      axesToBeFixedSet: b,
+      readyData: this.readyDataInputs(e),
+      ready: this.readyForPlotBuilding(t, e, g, A, i),
+      consistent: g
+    };
+  }
+  async getUniqueSourceValuesWithLabels(t, e, o, n, l, s) {
+    var c;
+    const a = (p) => p.sort((m, d) => m.label.localeCompare(d.label, "en", { numeric: !0 })), r = e.getSourceInfo(o), u = (c = r.annotations) == null ? void 0 : c[_e];
+    try {
+      const p = u ? JSON.parse(u).map((m) => String(m)) : null;
+      if (p) {
+        const m = p.map((d) => ({ value: d, label: d }));
+        return a(m), { values: m, overflow: !1 };
+      }
+    } catch {
+      console.error(`Parsing error: discrete values annotation ${u} in ${o}`);
+    }
+    if (r.kind === "axis") {
+      const p = C(o), m = r.parentSources.map(C), d = await E(t, o, r.parentSources);
+      let w = [];
+      if (d) {
+        l && (w = [{
+          type: "bySingleColumnV2",
+          column: {
+            type: "column",
+            id: d.name
+          },
+          predicate: {
+            operator: "StringIContains",
+            substring: l
+          }
+        }]), s && (w = [{
+          type: "bySingleColumnV2",
+          column: {
+            type: "axis",
+            id: p.toPFrameId()
+          },
+          predicate: {
+            operator: "StringIContains",
+            substring: s
+          }
+        }]);
+        const { data: x, axesData: b } = await t.pFrameProvider.getSingleColumnData(d, w), g = b[p.toCanonicalString()], i = [];
+        for (let f = 0; f < Math.min(g.length, n ?? g.length); f++)
+          i.push({ value: String(g[f]), label: String(x[f]) });
+        return a(i), { values: i, overflow: !(n === void 0 || g.length < n) };
+      }
+      const h = l ?? s;
+      h && (w = [{
+        type: "bySingleColumnV2",
+        column: {
+          type: "axis",
+          id: p.toPFrameId()
+        },
+        predicate: {
+          operator: "StringIContains",
+          substring: h
+        }
+      }]);
+      const A = await t.pFrameProvider.getAxisUniqueValues(p, [m[0]], n, w), v = A.values.map((x) => ({ value: String(x), label: String(x) }));
+      return a(v), { values: v, overflow: A.overflow };
+    }
+    if (r.kind === "column") {
+      const p = l ?? s, m = C(o), d = p ? [{
+        type: "bySingleColumnV2",
+        column: {
+          type: "column",
+          id: m.name
+        },
+        predicate: {
+          operator: "StringIContains",
+          substring: p
+        }
+      }] : [], w = await t.pFrameProvider.getColumnUniqueValues(m, n, d), h = w.values.map((A) => ({ value: String(A), label: String(A) }));
+      return a(h), { values: h, overflow: w.overflow };
+    }
+    return { values: [], overflow: !1 };
+  }
+  async checkStateConsistency(t, e, o) {
+    const n = /* @__PURE__ */ new Map();
+    for (const l of Object.keys(this.simpleComponentControllers))
+      n.set(
+        l,
+        await this.simpleComponentControllers[l].checkStateConsistency(t, e, o)
+      );
+    for (const l of Object.keys(this.filterComponentControllers))
+      n.set(
+        l,
+        await this.filterComponentControllers[l].checkStateConsistency(t, e, o)
+      );
+    return n;
+  }
+  async isConsistent(t, e, o) {
+    const n = await this.checkStateConsistency(t, e, o);
+    for (const l of n.values())
+      if (Object.values(l).some((s) => !s))
+        return !1;
+    return !0;
+  }
+  readyDataInputs(t) {
+    return this.dataInputs.every((e) => t.components[e].selectorStates.length > 0);
+  }
+  readyForPlotBuilding(t, e, o, n, l) {
+    if (!o || !this.readyDataInputs(e))
+      return !1;
+    let s = !1;
+    for (const a of n) {
+      const r = l(a);
+      if (r && r.kind === "axis" && r.mustBeConsumed) {
+        s = !0;
+        break;
+      }
+    }
+    let c = !1;
+    for (const { selectorStates: a } of Object.values(e.components)) {
+      for (const { selectedSource: r, fixedAxes: u } of a) {
+        const p = l(r);
+        if (p && p.kind === "column" && p.axesToBeFixed.some(
+          (m) => {
+            var d;
+            return ((d = (u ?? []).find((w) => w.axisSource === m)) == null ? void 0 : d.axisValue) === void 0;
+          }
+        )) {
+          c = !0;
+          break;
+        }
+      }
+      if (c)
+        break;
+    }
+    return this.requiredComponents.every((a) => e.components[a].selectorStates.length > 0) && !s && !c;
+  }
+  async createDataForPlot(t, e) {
+    return {
+      data: await this.createDataByColumns(t, e),
+      settings: await this.createChartSettings(t, e)
+    };
+  }
+}, Ae = class be {
+  constructor({
+    componentName: e,
+    allowedTypes: o,
+    settings: n,
+    strictlyDependsOnParents: l,
+    dependsOn: s = [],
+    parentComponents: c = [],
+    annotations: a = {},
+    checkSourceBySpec: r
+  }) {
+    this.componentName = e, this.allowedTypes = [...o], this.settings = { ...be.DefaultSettings, ...n }, this.dependsOn = [...s], this.parentComponents = [...c], this.strictlyDependsOnParents = l ?? !0, this.annotations = { ...a }, r && (this.checkSourceBySpec = r);
+  }
+  get isRequired() {
+    return this.settings.required;
+  }
+  get isDimensionsConsumer() {
+    return this.settings.dimensionConsumer;
+  }
+  addSelected(e, o) {
+    const n = ie(e);
+    return n.components[this.componentName].selectorStates.push(o), n;
+  }
+  deleteSelected(e, o) {
+    const n = ie(e);
+    return n.components[this.componentName].selectorStates = n.components[this.componentName].selectorStates.filter((l) => l.selectedSource !== o), n;
+  }
+  async checkStateConsistency(e, o, n) {
+    const l = o.components[this.componentName], { allowedAxes: s } = await this.getAllowedAxes(e, o, n);
+    function c(r) {
+      const u = _.fromAxisSpec(r);
+      return s.has(u.toCanonicalString());
+    }
+    const a = await Promise.all(
+      l.selectorStates.map(async ({ selectedSource: r }) => {
+        const u = C(r);
+        if (B(u)) {
+          const p = await e.pFrameProvider.getColumnSpecById(u);
+          return p ? this.parentComponents.length === 0 ? !0 : this.strictlyDependsOnParents && !this.settings.columnsWithExtraAxesAllowed && !this.settings.isDataComponent ? p.axesSpec.every((d) => c(d)) : this.settings.columnsWithExtraAxesAllowed && !this.settings.isDataComponent ? p.axesSpec.some((d) => c(d)) : s.size === 0 || p.axesSpec.some((d) => c(d)) : !1;
+        }
+        return s.has(r);
+      })
+    );
+    return l.selectorStates.reduce(
+      (r, u, p) => (r[u.selectedSource] = a[p], r),
+      {}
+    );
+  }
+  async getProducingAxes(e, o) {
+    const s = o.components[this.componentName].selectorStates.map((r) => C(r.selectedSource)).filter((r) => B(r)), c = /* @__PURE__ */ new Set();
+    return (await Promise.all(
+      s.map((r) => e.pFrameProvider.getColumnSpecById(r))
+    )).forEach((r) => {
+      r && r.axesSpec.forEach((u) => {
+        c.add(_.fromAxisSpec(u).toCanonicalString());
+      });
+    }), c;
+  }
+  getParentSelectedSources(e, o) {
+    return this.parentComponents.reduce((l, s) => {
+      const c = o.components[s].selectorStates.map(
+        (a) => C(a.selectedSource)
+      );
+      return l.push(...c), l;
+    }, []);
+  }
+  async getParentAxes(e, o) {
+    var n;
+    const l = this.getParentSelectedSources(e, o), s = /* @__PURE__ */ new Set();
+    for (const c of l)
+      if (B(c)) {
+        const a = await e.pFrameProvider.getColumnSpecById(c);
+        (n = a == null ? void 0 : a.axesSpec) == null || n.forEach((r) => {
+          const u = _.fromAxisSpec(r);
+          s.add(u.toCanonicalString());
+        });
+      }
+    return s;
+  }
+  async getAllowedAxes(e, o, n) {
+    var l, s, c, a, r, u, p;
+    const m = this.getParentSelectedSources(e, o), d = /* @__PURE__ */ new Set(), w = /* @__PURE__ */ new Set(), h = /* @__PURE__ */ new Set(), A = /* @__PURE__ */ new Map();
+    for (const x of m)
+      if (B(x)) {
+        const b = await e.pFrameProvider.getColumnSpecById(x);
+        for (const g of (l = b == null ? void 0 : b.axesSpec) != null ? l : []) {
+          const f = _.fromAxisSpec(g).toCanonicalString();
+          if (d.has(f))
+            continue;
+          d.add(f), w.add(f);
+          const y = Ce(g);
+          A.set(f, {
+            kind: "axis",
+            name: g.name,
+            label: await F(e, f, [
+              x.toCanonicalString()
+            ]),
+            type: g.type,
+            mustBeConsumed: y,
+            dividable: !1,
+            spec: g,
+            annotations: g.annotations,
+            isSubsetFilter: ((s = g.annotations) == null ? void 0 : s[K]) === "true",
+            isDiscreteFilter: g.type === "String" || ((c = g.annotations) == null ? void 0 : c[$]) === "true",
+            parentSources: [x.toCanonicalString()]
+          });
+        }
+      }
+    let v = [...d];
+    for (; v.length; ) {
+      const x = [];
+      for (const b of v)
+        if (n[b]) {
+          const g = Object.keys(n[b]);
+          for (const i of g)
+            if (!d.has(i)) {
+              x.push(i), d.add(i), h.add(i);
+              const { spec: f, id: y } = n[b][i];
+              for (const S of f.axesSpec) {
+                const I = _.fromAxisSpec(S).toCanonicalString();
+                A.has(I) || A.set(I, {
+                  kind: "axis",
+                  name: S.name,
+                  label: (r = (a = S.annotations) == null ? void 0 : a[ge]) != null ? r : "",
+                  type: S.type,
+                  mustBeConsumed: !1,
+                  dividable: !1,
+                  spec: S,
+                  annotations: S.annotations,
+                  isSubsetFilter: ((u = S.annotations) == null ? void 0 : u[K]) === "true",
+                  isDiscreteFilter: S.type === "String" || ((p = S.annotations) == null ? void 0 : p[$]) === "true",
+                  parentSources: [y.toCanonicalString()]
+                });
+              }
+            }
+        }
+      v = x;
+    }
+    return { allowedAxes: d, parentAxes: w, linkerAxes: h, optionsInfo: A };
+  }
+  async getOptions(e, o, n, l, s, c, a = /* @__PURE__ */ new Set(), r = /* @__PURE__ */ new Set()) {
+    var u, p, m, d, w, h, A, v;
+    const x = this.settings.multipleSelectors, b = this.settings.required, g = await this.checkStateConsistency(e, o, s);
+    if (this.dependsOn.length && this.dependsOn.some((O) => o.components[O].selectorStates.length === 0))
+      return { multipleSelectors: x, required: b, stateConsistency: g, options: [], optionsInfo: /* @__PURE__ */ new Map() };
+    if (this.strictlyDependsOnParents && !this.settings.isDataComponent && this.parentComponents.some((O) => o.components[O].selectorStates.length === 0))
+      return { multipleSelectors: x, required: b, stateConsistency: g, options: [], optionsInfo: /* @__PURE__ */ new Map() };
+    const i = this.getParentSelectedSources(e, o), f = (await e.pFrameProvider.getColumns([], !1, this.allowedTypes, void 0, this.annotations)).filter((O) => !l.has(O.toCanonicalString())), { allowedAxes: y, parentAxes: S, linkerAxes: I, optionsInfo: P } = await this.getAllowedAxes(e, o, s), N = o.components[this.componentName], L = [];
+    if (this.settings.axesAllowed)
+      for (const O of S) {
+        const T = C(O), k = P.get(T.toCanonicalString()), q = this.allowedTypes.includes(k.spec.type), G = Object.entries(this.annotations).every(
+          ([ee, V]) => {
+            var J;
+            return ((J = k.spec.annotations) == null ? void 0 : J[ee]) === V;
+          }
+        ), Z = this.checkSourceBySpec ? this.checkSourceBySpec(k.spec, o) : !0, Q = !this.settings.homogeneous || !(k != null && k.mustBeConsumed), ne = !l.has(O), oe = a.has(T.name) || r.has(T.toCanonicalString()), ue = N.selectorStates.some((ee) => ee.selectedSource === O);
+        q && G && Z && Q && ne && !oe && !ue && L.push({ value: O });
+      }
+    if (this.settings.columnsAllowed) {
+      const O = !this.settings.columnsWithExtraAxesAllowed && this.strictlyDependsOnParents;
+      for (const T of f) {
+        const k = T.toCanonicalString(), q = C(k), G = await e.pFrameProvider.getColumnSpecById(q), Z = ((u = G == null ? void 0 : G.annotations) == null ? void 0 : u[we]) === "true";
+        if (
+          // do not add to available options label columns, or columns that are not fit by custom spec condition, or columns that are not fit by condition for data inputs
+          !G || Be(G) || Z || this.checkSourceBySpec && !this.checkSourceBySpec(G, o) || this.settings.isDataComponent && !c(G) || O && ((p = G.axesSpec) != null && p.some((V) => !y.has(_.fromAxisSpec(V).toCanonicalString()))) || i.length && !((m = G.axesSpec) != null && m.some((V) => y.has(_.fromAxisSpec(V).toCanonicalString())))
+        )
+          continue;
+        const Q = (w = (d = G == null ? void 0 : G.axesSpec) == null ? void 0 : d.map((V) => _.fromAxisSpec(V).toCanonicalString())) != null ? w : [], ne = [], oe = {};
+        if (this.settings.columnsWithExtraAxesAllowed && Q.forEach((V, J) => {
+          y.has(V) || (ne.push(V), oe[V] = J);
+        }), G) {
+          const V = (h = n[k]) != null ? h : await F(e, T.toCanonicalString(), []), J = {
+            kind: "column",
+            name: G.name,
+            label: V,
+            type: G.valueType,
+            spec: G,
+            annotations: G.annotations,
+            isSubsetFilter: ((A = G.annotations) == null ? void 0 : A[K]) === "true",
+            isDiscreteFilter: G.valueType === "String" || ((v = G.annotations) == null ? void 0 : v[$]) === "true",
+            axesToBeFixed: ne,
+            axesToBeFixedIndexes: oe
+          };
+          P.set(q.toCanonicalString(), J);
+        }
+        const ue = a.has(q.name) || r.has(q.toCanonicalString()), ee = o.components[this.componentName].selectorStates.some(
+          (V) => V.selectedSource === k
+        );
+        !ue && !ee && L.push({ value: k });
+      }
+    }
+    return { multipleSelectors: x, required: b, stateConsistency: g, options: L, optionsInfo: P };
+  }
+};
+Ae.DefaultSettings = {
+  isDataComponent: !1,
+  multipleSelectors: !1,
+  required: !1,
+  homogeneous: !1,
+  axesAllowed: !1,
+  columnsAllowed: !0,
+  columnsWithExtraAxesAllowed: !0,
+  dimensionConsumer: !1
+};
+var D = Ae, Ve = {
+  type: "bubble",
+  components: {
+    valueSize: { type: "simple", selectorStates: [] },
+    valueColor: { type: "simple", selectorStates: [] },
+    x: { type: "simple", selectorStates: [] },
+    y: { type: "simple", selectorStates: [] },
+    filters: { type: "filter", selectorStates: [] },
+    tabBy: { type: "filter", selectorStates: [] },
+    facetBy: { type: "simple", selectorStates: [] },
+    tooltipContent: { type: "simple", selectorStates: [] }
+  },
+  dividedAxes: {}
+};
+function le(t, e) {
+  if (!e.length)
+    return [];
+  const o = e.map((s) => C(s)), n = Object.values(t.columnsData)[0].length, l = [];
+  for (let s = 0; s < n; s++) {
+    const c = o.map((a) => {
+      const r = a.toCanonicalString();
+      return B(a) ? t.columnsData[r][s] : t.axesData[r][s];
+    }).join(", ");
+    l.push(c);
+  }
+  return l;
+}
+var je = class extends R {
+  constructor() {
+    super({
+      valueSize: new D({
+        componentName: "valueSize",
+        allowedTypes: ["Int", "Long", "Double", "Float"],
+        strictlyDependsOnParents: !0,
+        parentComponents: ["valueColor"],
+        settings: {
+          isDataComponent: !0,
+          columnsAllowed: !0,
+          axesAllowed: !1,
+          required: !0
+        }
+      }),
+      valueColor: new D({
+        componentName: "valueColor",
+        allowedTypes: ["Int", "Long", "Double", "Float"],
+        strictlyDependsOnParents: !0,
+        parentComponents: ["valueSize"],
+        settings: {
+          isDataComponent: !0,
+          columnsAllowed: !0,
+          axesAllowed: !1,
+          required: !0
+        }
+      }),
+      x: new D({
+        componentName: "x",
+        allowedTypes: ["Int", "String", "Long"],
+        strictlyDependsOnParents: !0,
+        parentComponents: ["valueSize", "valueColor"],
+        settings: {
+          required: !0,
+          dimensionConsumer: !0,
+          multipleSelectors: !0,
+          axesAllowed: !0,
+          columnsAllowed: !1
+        }
+      }),
+      y: new D({
+        componentName: "y",
+        allowedTypes: ["Int", "String", "Long"],
+        strictlyDependsOnParents: !0,
+        parentComponents: ["valueSize", "valueColor"],
+        settings: {
+          required: !0,
+          dimensionConsumer: !0,
+          multipleSelectors: !0,
+          axesAllowed: !0,
+          columnsAllowed: !1
+        }
+      }),
+      tooltipContent: new D({
+        componentName: "tooltipContent",
+        allowedTypes: ["String", "Int", "Long", "Float", "Double"],
+        strictlyDependsOnParents: !0,
+        parentComponents: ["valueSize", "valueColor"],
+        settings: {
+          columnsAllowed: !0,
+          axesAllowed: !0,
+          multipleSelectors: !0
+        }
+      }),
+      facetBy: new D({
+        componentName: "facetBy",
+        allowedTypes: ["String", "Int", "Long"],
+        strictlyDependsOnParents: !0,
+        parentComponents: ["valueSize", "valueColor"],
+        settings: {
+          axesAllowed: !0,
+          dimensionConsumer: !0,
+          multipleSelectors: !0
+        }
+      })
+    }, {
+      filters: new D({
+        componentName: "filters",
+        allowedTypes: ["String", "Int", "Long", "Double", "Long"],
+        strictlyDependsOnParents: !0,
+        parentComponents: ["valueSize", "valueColor"],
+        settings: {
+          columnsAllowed: !0,
+          axesAllowed: !0,
+          dimensionConsumer: !0,
+          multipleSelectors: !0
+        },
+        checkSourceBySpec: H
+      }),
+      tabBy: new D({
+        componentName: "tabBy",
+        allowedTypes: ["String", "Int"],
+        strictlyDependsOnParents: !0,
+        parentComponents: ["valueSize", "valueColor"],
+        settings: {
+          columnsAllowed: !0,
+          axesAllowed: !0,
+          dimensionConsumer: !0
+        }
+      })
+    }), this.dataInputs = ["valueSize", "valueColor"], this.dontAllowUnfilteredHighCardinality = !0;
+  }
+  async getMustBeConsumedAxes(t, e) {
+    if (!e.components.valueColor.selectorStates.length)
+      return /* @__PURE__ */ new Set();
+    const o = e.components.valueColor.selectorStates[0].selectedSource, n = await t.pFrameProvider.getColumnSpecById(C(o));
+    return n ? new Set(n.axesSpec.map((l) => _.fromAxisSpec(l).toCanonicalString())) : /* @__PURE__ */ new Set();
+  }
+  async createDataByColumns(t, e) {
+    var o, n, l;
+    const s = (o = e.components.valueColor.selectorStates[0]) == null ? void 0 : o.selectedSource, c = (n = e.components.valueSize.selectorStates[0]) == null ? void 0 : n.selectedSource;
+    if (!s || !c)
+      throw Error("Value column is not valid");
+    const a = C(s), r = C(c);
+    if (!a || !r || !B(a) && !B(r))
+      throw Error("Value column is not valid");
+    const u = {
+      type: "columns",
+      id: (l = j(e.components)) != null ? l : "",
+      values: {}
+    }, p = await W(t), m = [
+      ...e.components.filters.selectorStates,
+      ...e.components.tabBy.selectorStates
+    ], d = U(m), w = m.map((T) => C(T.selectedSource)).filter(B), h = [a, r].filter(B), A = h.map((T) => T.toCanonicalString()), v = await X(t, A), x = [
+      e.components.facetBy,
+      e.components.x,
+      e.components.y,
+      e.components.tooltipContent
+    ], b = [], g = h.map(() => []), i = [], f = [];
+    for (const { selectedSource: T, fixedAxes: k } of m)
+      f.push(...await M(
+        t,
+        p,
+        v,
+        T,
+        k
+      )), g.push(
+        (k ?? []).map(({ axisIdx: q, axisValue: G }) => ({ idx: q, value: G }))
+      );
+    for (const T of x)
+      for (const { selectedSource: k, fixedAxes: q } of T.selectorStates) {
+        b.push(C(k)), i.push(
+          (q ?? []).map(({ axisIdx: Z, axisValue: Q }) => ({ idx: Z, value: Q }))
+        ), f.push(...await M(
+          t,
+          p,
+          v,
+          k,
+          q
+        ));
+        const G = await E(t, k, A);
+        G && b.push(G);
+      }
+    const y = await t.pFrameProvider.getTableOuterJoin(
+      [...h, ...f, ...w],
+      b,
+      d,
+      !0,
+      g,
+      i
+    );
+    b.forEach((T) => {
+      const k = T.toCanonicalString();
+      u.values[k] = B(T) ? y.columnsData[k] : y.axesData[k];
+    }), u.values[s] = B(a) ? y.columnsData[s] : y.axesData[s], u.values[c] = B(r) ? y.columnsData[c] : y.axesData[c];
+    const S = e.components.x.selectorStates.map((T) => T.selectedSource), I = S.join(", "), P = await Promise.all(S.map(
+      async (T) => {
+        var k, q;
+        return (q = (k = await E(t, T, A)) == null ? void 0 : k.toCanonicalString()) != null ? q : T;
+      }
+    ));
+    u.values[I] = le(y, S), u.values.xLabels = le(y, P);
+    const N = e.components.y.selectorStates.map((T) => T.selectedSource), L = N.join(", "), O = await Promise.all(N.map(
+      async (T) => {
+        var k, q;
+        return (q = (k = await E(t, T, A)) == null ? void 0 : k.toCanonicalString()) != null ? q : T;
+      }
+    ));
+    return u.values[L] = le(y, N), u.values.yLabels = le(y, O), { byColumns: u };
+  }
+  async createChartSettings(t, e) {
+    var o, n;
+    const l = (o = e.components.valueColor.selectorStates[0]) == null ? void 0 : o.selectedSource, s = (n = e.components.valueSize.selectorStates[0]) == null ? void 0 : n.selectedSource;
+    if (!l || !s)
+      throw Error("Value column is not valid");
+    const c = C(l), a = C(s);
+    if (!B(c) && !B(a))
+      throw Error("Value column is not valid");
+    const r = [c, a].filter(B).map((g) => g.toCanonicalString()), u = {
+      type: "column",
+      value: l,
+      label: await F(t, l, [])
+    }, p = {
+      type: "column",
+      value: s,
+      label: await F(t, s, [])
+    }, d = e.components.x.selectorStates.map(({ selectedSource: g }) => g).join(", "), h = e.components.y.selectorStates.map(({ selectedSource: g }) => g).join(", "), A = await Promise.all(e.components.facetBy.selectorStates.map(async (g) => {
+      var i, f;
+      return {
+        type: "column",
+        value: (f = (i = await E(t, g.selectedSource, r)) == null ? void 0 : i.toCanonicalString()) != null ? f : g.selectedSource
+      };
+    })), v = (await Promise.all(e.components.x.selectorStates.map((g) => F(t, g.selectedSource, r)))).join(", "), x = (await Promise.all(e.components.y.selectorStates.map((g) => F(t, g.selectedSource, r)))).join(", "), b = await Promise.all(
+      e.components.tooltipContent.selectorStates.map(async (g) => {
+        var i, f;
+        const y = g.selectedSource;
+        return {
+          type: "column",
+          label: await F(t, y, r) || y,
+          value: y,
+          valueLabels: (f = (i = await E(t, y, r)) == null ? void 0 : i.toCanonicalString()) != null ? f : y
+        };
+      })
+    );
+    return {
+      type: "bubble",
+      valueColor: u,
+      valueSize: p,
+      xColumn: {
+        type: "column",
+        value: d,
+        label: v,
+        valueLabels: "xLabels"
+      },
+      yColumn: {
+        type: "column",
+        value: h,
+        label: x,
+        valueLabels: "yLabels"
+      },
+      facetBy: A,
+      tooltips: {
+        show: !0,
+        content: b
+      }
+    };
+  }
+}, ze = {
+  type: "histogram",
+  components: {
+    value: { type: "simple", selectorStates: [] },
+    grouping: { type: "simple", selectorStates: [] },
+    filters: { type: "filter", selectorStates: [] },
+    tabBy: { type: "filter", selectorStates: [] },
+    facetBy: { type: "simple", selectorStates: [] }
+  },
+  dividedAxes: {}
+}, Ue = class extends R {
+  constructor() {
+    super(
+      {
+        value: new D({
+          componentName: "value",
+          allowedTypes: ["Int", "Long", "Double", "Float"],
+          settings: {
+            isDataComponent: !0,
+            columnsAllowed: !0,
+            axesAllowed: !1,
+            required: !0
+          }
+        }),
+        grouping: new D({
+          componentName: "grouping",
+          allowedTypes: ["String", "Int", "Long"],
+          parentComponents: ["value"],
+          dependsOn: ["value"],
+          settings: {
+            axesAllowed: !0,
+            multipleSelectors: !1
+          }
+        }),
+        facetBy: new D({
+          componentName: "facetBy",
+          allowedTypes: ["String", "Int", "Long"],
+          parentComponents: ["value"],
+          dependsOn: ["value"],
+          settings: {
+            axesAllowed: !0,
+            dimensionConsumer: !0,
+            multipleSelectors: !0
+          }
+        })
+      },
+      {
+        filters: new D({
+          componentName: "filters",
+          allowedTypes: ["String", "Int", "Long", "Double", "Float"],
+          parentComponents: ["value"],
+          dependsOn: ["value"],
+          settings: {
+            columnsAllowed: !0,
+            axesAllowed: !0,
+            dimensionConsumer: !0,
+            multipleSelectors: !0
+          },
+          checkSourceBySpec: H
+        }),
+        tabBy: new D({
+          componentName: "tabBy",
+          allowedTypes: ["String", "Int"],
+          parentComponents: ["value"],
+          dependsOn: ["value"],
+          settings: {
+            columnsAllowed: !0,
+            axesAllowed: !0,
+            dimensionConsumer: !0
+          }
+        })
+      }
+    ), this.dataInputs = ["value"];
+  }
+  async createDataByColumns(t, e) {
+    var o, n;
+    const l = (o = e.components.value.selectorStates[0]) == null ? void 0 : o.selectedSource;
+    if (!l)
+      throw Error("Value column is not valid");
+    const s = C(l);
+    if (!B(s))
+      throw Error("Value column is not valid");
+    const c = {
+      type: "columns",
+      id: (n = j(e.components)) != null ? n : "",
+      values: {}
+    }, a = await W(t), r = [
+      ...e.components.filters.selectorStates,
+      ...e.components.tabBy.selectorStates
+    ], u = U(r), p = r.map((g) => C(g.selectedSource)).filter(B), m = [l], d = await X(t, m), w = [e.components.facetBy, e.components.grouping], h = [], A = [[]], v = [], x = [];
+    for (const { selectedSource: g, fixedAxes: i } of r)
+      x.push(
+        ...await M(t, a, d, g, i)
+      ), x.push(
+        ...await M(t, a, d, g, i)
+      ), A.push(
+        (i ?? []).map(({ axisIdx: f, axisValue: y }) => ({ idx: f, value: y }))
+      );
+    for (const g of w)
+      for (const { selectedSource: i, fixedAxes: f } of g.selectorStates) {
+        h.push(C(i)), v.push(
+          (f ?? []).map(({ axisIdx: S, axisValue: I }) => ({ idx: S, value: I }))
+        ), x.push(
+          ...await M(t, a, d, i, f)
+        );
+        const y = await E(t, i, m);
+        y && h.push(y);
+      }
+    const b = await t.pFrameProvider.getTableOuterJoin(
+      [s, ...x, ...p],
+      h,
+      u,
+      !0,
+      A,
+      v
+    );
+    return h.forEach((g) => {
+      const i = g.toCanonicalString();
+      c.values[i] = B(g) ? b.columnsData[i] : b.axesData[i];
+    }), c.values[s.toCanonicalString()] = b.columnsData[s.toCanonicalString()], { byColumns: c };
+  }
+  async createChartSettings(t, e) {
+    var o, n;
+    const l = (o = e.components.value.selectorStates[0]) == null ? void 0 : o.selectedSource;
+    if (!l)
+      throw Error("Value column is not valid");
+    const s = C(l);
+    if (!B(s))
+      throw Error("Value column is not valid");
+    const c = [l], a = {
+      type: "column",
+      value: l,
+      label: await F(t, l, [])
+    }, r = await Promise.all(
+      e.components.facetBy.selectorStates.map(async (p) => {
+        var m, d;
+        return {
+          type: "column",
+          value: (d = (m = await E(t, p.selectedSource, c)) == null ? void 0 : m.toCanonicalString()) != null ? d : p.selectedSource
+        };
+      })
+    );
+    let u;
+    if (e.components.grouping.selectorStates.length) {
+      const { selectedSource: p } = e.components.grouping.selectorStates[0];
+      u = {
+        type: "column",
+        value: p,
+        label: await F(t, p, c),
+        valueLabels: (n = await E(t, p, c)) == null ? void 0 : n.toCanonicalString()
+      };
+    }
+    return {
+      type: "histogram",
+      valueColumn: a,
+      facetBy: r,
+      grouping: u
+    };
+  }
+}, He = {
+  type: "discrete",
+  components: {
+    y: { type: "simple", selectorStates: [] },
+    filters: { type: "filter", selectorStates: [] },
+    tabBy: { type: "filter", selectorStates: [] },
+    facetBy: { type: "simple", selectorStates: [] },
+    primaryGrouping: { type: "simple", selectorStates: [] },
+    secondaryGrouping: { type: "simple", selectorStates: [] }
+  },
+  dividedAxes: {}
+}, We = class extends R {
+  constructor() {
+    super(
+      {
+        y: new D({
+          componentName: "y",
+          allowedTypes: ["Int", "Double", "Long", "Float"],
+          settings: { isDataComponent: !0 }
+        }),
+        primaryGrouping: new D({
+          componentName: "primaryGrouping",
+          allowedTypes: ["String", "Int", "Long"],
+          strictlyDependsOnParents: !0,
+          parentComponents: ["y"],
+          dependsOn: ["y"],
+          settings: {
+            axesAllowed: !0,
+            homogeneous: !0
+          }
+        }),
+        secondaryGrouping: new D({
+          componentName: "secondaryGrouping",
+          allowedTypes: ["String", "Int", "Long"],
+          strictlyDependsOnParents: !0,
+          parentComponents: ["y"],
+          dependsOn: ["primaryGrouping"],
+          settings: {
+            axesAllowed: !0,
+            homogeneous: !0
+          }
+        }),
+        facetBy: new D({
+          componentName: "facetBy",
+          allowedTypes: ["String", "Int", "Long"],
+          strictlyDependsOnParents: !0,
+          parentComponents: ["y"],
+          dependsOn: ["y"],
+          settings: {
+            axesAllowed: !0,
+            dimensionConsumer: !0,
+            multipleSelectors: !0
+          }
+        })
+      },
+      {
+        filters: new D({
+          componentName: "filters",
+          allowedTypes: ["String", "Int", "Long", "Double", "Float"],
+          strictlyDependsOnParents: !0,
+          parentComponents: ["y"],
+          dependsOn: ["y"],
+          settings: {
+            axesAllowed: !0,
+            dimensionConsumer: !0,
+            multipleSelectors: !0
+          },
+          checkSourceBySpec: H
+        }),
+        tabBy: new D({
+          componentName: "tabBy",
+          allowedTypes: ["String", "Int"],
+          strictlyDependsOnParents: !0,
+          parentComponents: ["y"],
+          dependsOn: ["y"],
+          settings: {
+            axesAllowed: !0,
+            dimensionConsumer: !0
+          }
+        })
+      }
+    ), this.dataInputs = ["y"], this.dontAllowUnfilteredHighCardinality = !0;
+  }
+  async createDataByColumns(t, e) {
+    var o;
+    const n = e.components.y.selectorStates[0].selectedSource, l = C(n);
+    if (!n || !B(l))
+      throw Error("Y column is not valid");
+    const s = {
+      type: "columns",
+      id: (o = j(e.components)) != null ? o : "",
+      values: {}
+    }, c = await W(t), a = [
+      ...e.components.filters.selectorStates,
+      ...e.components.tabBy.selectorStates
+    ], r = U(a), u = a.map((b) => C(b.selectedSource)).filter(B), p = [n], m = await X(t, p), d = [e.components.primaryGrouping, e.components.secondaryGrouping, e.components.facetBy], w = [], h = [[]], A = [], v = [];
+    for (const { selectedSource: b, fixedAxes: g } of a)
+      v.push(...await M(
+        t,
+        c,
+        m,
+        b,
+        g
+      )), h.push(
+        (g ?? []).map(({ axisIdx: i, axisValue: f }) => ({ idx: i, value: f }))
+      );
+    for (const b of d)
+      for (const { selectedSource: g, fixedAxes: i } of b.selectorStates) {
+        w.push(C(g)), A.push(
+          (i ?? []).map(({ axisIdx: y, axisValue: S }) => ({ idx: y, value: S }))
+        ), v.push(...await M(
+          t,
+          c,
+          m,
+          g,
+          i
+        ));
+        const f = await E(t, g, p);
+        f && w.push(f);
+      }
+    const x = await t.pFrameProvider.getTableOuterJoin(
+      [l, ...v, ...u],
+      w,
+      r,
+      !0,
+      h,
+      A
+    );
+    return w.forEach((b) => {
+      const g = b.toCanonicalString();
+      s.values[g] = B(b) ? x.columnsData[g] : x.axesData[g];
+    }), s.values[l.toCanonicalString()] = x.columnsData[l.toCanonicalString()], { byColumns: s };
+  }
+  async createChartSettings(t, e) {
+    var o, n;
+    const l = e.components.y.selectorStates[0].selectedSource, s = C(l);
+    if (!l || !B(s))
+      throw Error("Y column is not valid");
+    const c = {
+      type: "column",
+      value: l,
+      label: await F(t, l, [])
+    }, a = [l];
+    let r;
+    if (e.components.primaryGrouping.selectorStates.length) {
+      const { selectedSource: m } = e.components.primaryGrouping.selectorStates[0];
+      r = {
+        columnName: {
+          type: "column",
+          value: m,
+          label: await F(t, m, a),
+          valueLabels: (o = await E(
+            t,
+            m,
+            a
+          )) == null ? void 0 : o.toCanonicalString()
+        }
+      };
+    }
+    let u;
+    if (e.components.secondaryGrouping.selectorStates.length) {
+      const { selectedSource: m } = e.components.secondaryGrouping.selectorStates[0];
+      u = {
+        columnName: {
+          type: "column",
+          value: m,
+          label: await F(t, m, a),
+          valueLabels: (n = await E(
+            t,
+            m,
+            a
+          )) == null ? void 0 : n.toCanonicalString()
+        }
+      };
+    }
+    const p = await Promise.all(e.components.facetBy.selectorStates.map(async (m) => {
+      var d, w;
+      return {
+        type: "column",
+        value: (w = (d = await E(t, m.selectedSource, a)) == null ? void 0 : d.toCanonicalString()) != null ? w : m.selectedSource,
+        label: await F(t, m.selectedSource, a)
+      };
+    }));
+    return {
+      type: "discrete",
+      y: c,
+      primaryGrouping: r,
+      secondaryGrouping: u,
+      facetBy: p
+    };
+  }
+}, Ye = {
+  type: "heatmap",
+  components: {
+    value: { type: "simple", selectorStates: [] },
+    x: { type: "simple", selectorStates: [] },
+    y: { type: "simple", selectorStates: [] },
+    xGroupBy: { type: "simple", selectorStates: [] },
+    yGroupBy: { type: "simple", selectorStates: [] },
+    filters: { type: "filter", selectorStates: [] },
+    tabBy: { type: "filter", selectorStates: [] },
+    facetBy: { type: "simple", selectorStates: [] },
+    annotationsX: { type: "simple", selectorStates: [] },
+    annotationsY: { type: "simple", selectorStates: [] },
+    tooltipContent: { type: "simple", selectorStates: [] }
+  },
+  dividedAxes: {}
+};
+function pe(t) {
+  return t ? "kind" in t && t.kind === "PColumn" ? t.valueType === "String" : t.type === "String" : !0;
+}
+function ae(t, e) {
+  if (!e.length)
+    return [];
+  const o = e.map((s) => C(s)), n = Object.values(t.columnsData)[0].length, l = [];
+  for (let s = 0; s < n; s++) {
+    const c = o.map((a) => {
+      const r = a.toCanonicalString();
+      return B(a) ? t.columnsData[r][s] : t.axesData[r][s];
+    }).join(", ");
+    l.push(c);
+  }
+  return l;
+}
+var Ke = class extends R {
+  constructor() {
+    super(
+      {
+        value: new D({
+          componentName: "value",
+          allowedTypes: ["Int", "Long", "Double", "Float", "String"],
+          settings: {
+            isDataComponent: !0,
+            columnsAllowed: !0,
+            axesAllowed: !1,
+            required: !0
+          }
+        }),
+        x: new D({
+          componentName: "x",
+          allowedTypes: ["Int", "String", "Long"],
+          strictlyDependsOnParents: !0,
+          parentComponents: ["value"],
+          settings: {
+            required: !0,
+            dimensionConsumer: !0,
+            multipleSelectors: !0,
+            axesAllowed: !0,
+            columnsAllowed: !1
+          }
+        }),
+        xGroupBy: new D({
+          componentName: "xGroupBy",
+          allowedTypes: ["Int", "String", "Long"],
+          strictlyDependsOnParents: !0,
+          parentComponents: ["value"],
+          settings: {
+            dimensionConsumer: !0,
+            multipleSelectors: !0,
+            axesAllowed: !0,
+            columnsAllowed: !0
+          },
+          dependsOn: ["x"],
+          checkSourceBySpec: (t, e) => {
+            const o = /* @__PURE__ */ new Set([
+              ...e.components.x.selectorStates.map((n) => n.selectedSource),
+              ...e.components.xGroupBy.selectorStates.map((n) => n.selectedSource)
+            ]);
+            return "kind" in t && t.kind === "PColumn" ? _.fromAxesSpec(t.axesSpec).every(
+              (n) => o.has(n.toCanonicalString())
+            ) : !0;
+          }
+        }),
+        y: new D({
+          componentName: "y",
+          allowedTypes: ["Int", "String", "Long"],
+          strictlyDependsOnParents: !0,
+          parentComponents: ["value"],
+          settings: {
+            required: !0,
+            dimensionConsumer: !0,
+            multipleSelectors: !0,
+            axesAllowed: !0,
+            columnsAllowed: !0
+          }
+        }),
+        yGroupBy: new D({
+          componentName: "yGroupBy",
+          allowedTypes: ["Int", "String", "Long"],
+          strictlyDependsOnParents: !0,
+          parentComponents: ["value"],
+          settings: {
+            dimensionConsumer: !0,
+            multipleSelectors: !0,
+            axesAllowed: !0,
+            columnsAllowed: !1
+          },
+          dependsOn: ["y"],
+          checkSourceBySpec: (t, e) => {
+            const o = /* @__PURE__ */ new Set([
+              ...e.components.y.selectorStates.map((n) => n.selectedSource),
+              ...e.components.yGroupBy.selectorStates.map((n) => n.selectedSource)
+            ]);
+            return "kind" in t && t.kind === "PColumn" ? _.fromAxesSpec(t.axesSpec).every(
+              (n) => o.has(n.toCanonicalString())
+            ) : !0;
+          }
+        }),
+        tooltipContent: new D({
+          componentName: "tooltipContent",
+          allowedTypes: ["String", "Int", "Long", "Float", "Double"],
+          strictlyDependsOnParents: !0,
+          parentComponents: ["value"],
+          dependsOn: ["value"],
+          settings: {
+            columnsAllowed: !0,
+            axesAllowed: !0,
+            multipleSelectors: !0
+          }
+        }),
+        facetBy: new D({
+          componentName: "facetBy",
+          allowedTypes: ["String", "Int", "Long"],
+          strictlyDependsOnParents: !0,
+          parentComponents: ["value"],
+          dependsOn: ["value"],
+          settings: {
+            axesAllowed: !0,
+            dimensionConsumer: !0,
+            multipleSelectors: !0
+          }
+        }),
+        annotationsX: new D({
+          componentName: "annotationsX",
+          allowedTypes: ["Int", "Long", "Double", "Float", "String"],
+          parentComponents: ["value"],
+          settings: {
+            axesAllowed: !0,
+            multipleSelectors: !0
+          },
+          dependsOn: ["x"],
+          checkSourceBySpec: (t, e) => {
+            const o = /* @__PURE__ */ new Set([
+              ...e.components.x.selectorStates.map((n) => n.selectedSource),
+              ...e.components.xGroupBy.selectorStates.map((n) => n.selectedSource)
+            ]);
+            return "kind" in t && t.kind === "PColumn" ? _.fromAxesSpec(t.axesSpec).every(
+              (n) => o.has(n.toCanonicalString())
+            ) : o.has(_.fromAxisSpec(t).toCanonicalString());
+          }
+        }),
+        annotationsY: new D({
+          componentName: "annotationsY",
+          allowedTypes: ["Int", "Long", "Double", "Float", "String"],
+          parentComponents: ["value"],
+          settings: {
+            axesAllowed: !0,
+            multipleSelectors: !0
+          },
+          dependsOn: ["y"],
+          checkSourceBySpec: (t, e) => {
+            const o = /* @__PURE__ */ new Set([
+              ...e.components.y.selectorStates.map((n) => n.selectedSource),
+              ...e.components.yGroupBy.selectorStates.map((n) => n.selectedSource)
+            ]);
+            return "kind" in t && t.kind === "PColumn" ? _.fromAxesSpec(t.axesSpec).every(
+              (n) => o.has(n.toCanonicalString())
+            ) : o.has(_.fromAxisSpec(t).toCanonicalString());
+          }
+        })
+      },
+      {
+        filters: new D({
+          componentName: "filters",
+          allowedTypes: ["String", "Int", "Long", "Double", "Long"],
+          strictlyDependsOnParents: !0,
+          parentComponents: ["value"],
+          dependsOn: ["value"],
+          settings: {
+            columnsAllowed: !0,
+            axesAllowed: !0,
+            dimensionConsumer: !0,
+            multipleSelectors: !0
+          },
+          checkSourceBySpec: H
+        }),
+        tabBy: new D({
+          componentName: "tabBy",
+          allowedTypes: ["String", "Int"],
+          strictlyDependsOnParents: !0,
+          parentComponents: ["value"],
+          dependsOn: ["value"],
+          settings: {
+            columnsAllowed: !0,
+            axesAllowed: !0,
+            dimensionConsumer: !0
+          }
+        })
+      }
+    ), this.dataInputs = ["value"], this.dontAllowUnfilteredHighCardinality = !0;
+  }
+  async getMustBeConsumedAxes(t, e) {
+    if (!e.components.value.selectorStates.length)
+      return /* @__PURE__ */ new Set();
+    const o = e.components.value.selectorStates[0].selectedSource, n = await t.pFrameProvider.getColumnSpecById(C(o));
+    return n ? new Set(n.axesSpec.map((l) => _.fromAxisSpec(l).toCanonicalString())) : /* @__PURE__ */ new Set();
+  }
+  async createDataByColumns(t, e) {
+    var o, n;
+    const l = (o = e.components.value.selectorStates[0]) == null ? void 0 : o.selectedSource;
+    if (!l)
+      throw Error("Value column is not valid");
+    const s = C(l);
+    if (!B(s))
+      throw Error("Value column is not valid");
+    const c = {
+      type: "columns",
+      id: (n = j(e.components)) != null ? n : "",
+      values: {}
+    }, a = await W(t), r = [
+      ...e.components.filters.selectorStates,
+      ...e.components.tabBy.selectorStates
+    ], u = U(r), p = r.map((L) => C(L.selectedSource)).filter(B), m = [l], d = await X(t, m), w = [
+      e.components.facetBy,
+      e.components.annotationsX,
+      e.components.annotationsY,
+      e.components.x,
+      e.components.y,
+      e.components.xGroupBy,
+      e.components.yGroupBy,
+      e.components.tooltipContent
+    ], h = [], A = [[]], v = [], x = [];
+    for (const { selectedSource: L, fixedAxes: O } of r)
+      x.push(...await M(
+        t,
+        a,
+        d,
+        L,
+        O
+      )), A.push(
+        (O ?? []).map(({ axisIdx: T, axisValue: k }) => ({ idx: T, value: k }))
+      );
+    for (const L of w)
+      for (const { selectedSource: O, fixedAxes: T } of L.selectorStates) {
+        h.push(C(O)), v.push(
+          (T ?? []).map(({ axisIdx: q, axisValue: G }) => ({ idx: q, value: G }))
+        ), x.push(...await M(
+          t,
+          a,
+          d,
+          O,
+          T
+        ));
+        const k = await E(t, O, m);
+        k && h.push(k);
+      }
+    const b = await t.pFrameProvider.getTableOuterJoin(
+      [s, ...x, ...p],
+      h,
+      u,
+      !0,
+      A,
+      v
+    );
+    h.forEach((L) => {
+      const O = L.toCanonicalString();
+      c.values[O] = B(L) ? b.columnsData[O] : b.axesData[O];
+    }), c.values[s.toCanonicalString()] = b.columnsData[s.toCanonicalString()];
+    const g = e.components.x.selectorStates.concat(e.components.xGroupBy.selectorStates).map((L) => L.selectedSource), i = g.join(", ");
+    c.values[i] = ae(b, g);
+    const f = e.components.x.selectorStates.map((L) => L.selectedSource), y = await Promise.all(
+      f.map(
+        async (L) => {
+          var O, T;
+          return (T = (O = await E(t, L, m)) == null ? void 0 : O.toCanonicalString()) != null ? T : L;
+        }
+      )
+    );
+    c.values.xLabelsKey = ae(b, y);
+    const S = e.components.y.selectorStates.concat(e.components.yGroupBy.selectorStates).map((L) => L.selectedSource), I = S.join(", ");
+    c.values[I] = ae(b, S);
+    const P = e.components.y.selectorStates.map((L) => L.selectedSource), N = await Promise.all(
+      P.map(
+        async (L) => {
+          var O, T;
+          return (T = (O = await E(t, L, m)) == null ? void 0 : O.toCanonicalString()) != null ? T : L;
+        }
+      )
+    );
+    return c.values.yLabelsKey = ae(b, N), { byColumns: c };
+  }
+  async createChartSettings(t, e) {
+    var o;
+    const n = (o = e.components.value.selectorStates[0]) == null ? void 0 : o.selectedSource;
+    if (!n)
+      throw Error("Value column is not valid");
+    const l = C(n);
+    if (!B(l))
+      throw Error("Value column is not valid");
+    const s = [n], c = {
+      type: "column",
+      value: n,
+      label: await F(t, n, [])
+    }, r = e.components.x.selectorStates.concat(e.components.xGroupBy.selectorStates).map(({ selectedSource: i }) => C(i)).map((i) => i.toCanonicalString()).join(", "), p = e.components.y.selectorStates.concat(e.components.yGroupBy.selectorStates).map(({ selectedSource: i }) => C(i)).map((i) => i.toCanonicalString()).join(", "), m = await Promise.all(
+      e.components.facetBy.selectorStates.map(async (i) => {
+        var f, y;
+        return {
+          type: "column",
+          value: (y = (f = await E(t, i.selectedSource, s)) == null ? void 0 : f.toCanonicalString()) != null ? y : i.selectedSource
+        };
+      })
+    ), d = await Promise.all(
+      e.components.xGroupBy.selectorStates.map(async (i) => {
+        var f, y;
+        return {
+          type: "column",
+          label: await F(t, i.selectedSource, s),
+          value: i.selectedSource,
+          valueLabels: (y = (f = await E(t, i.selectedSource, s)) == null ? void 0 : f.toCanonicalString()) != null ? y : i.selectedSource
+        };
+      })
+    ), w = await Promise.all(
+      e.components.yGroupBy.selectorStates.map(async (i) => {
+        var f, y;
+        return {
+          type: "column",
+          label: await F(t, i.selectedSource, s),
+          value: i.selectedSource,
+          valueLabels: (y = (f = await E(t, i.selectedSource, s)) == null ? void 0 : f.toCanonicalString()) != null ? y : i.selectedSource
+        };
+      })
+    ), h = await t.pFrameProvider.getColumnSpecById(l), A = await Promise.all(
+      e.components.annotationsX.selectorStates.map(async (i) => {
+        var f, y;
+        const S = i.selectedSource, I = C(S), P = B(I) ? await t.pFrameProvider.getColumnSpecById(I) : (y = (f = h == null ? void 0 : h.axesSpec) == null ? void 0 : f.find(
+          (N) => _.fromAxisSpec(N).toCanonicalString() === S
+        )) != null ? y : null;
+        return {
+          axis: "x",
+          valueColumn: {
+            type: "column",
+            value: S,
+            label: await F(t, S, s)
+          },
+          type: pe(P) ? "discrete" : "continuous"
+        };
+      })
+    ), v = await Promise.all(
+      e.components.annotationsY.selectorStates.map(async (i) => {
+        var f, y;
+        const S = i.selectedSource, I = C(S), P = B(I) ? await t.pFrameProvider.getColumnSpecById(I) : (y = (f = h == null ? void 0 : h.axesSpec) == null ? void 0 : f.find(
+          (N) => _.fromAxisSpec(N).toCanonicalString() === S
+        )) != null ? y : null;
+        return {
+          axis: "y",
+          valueColumn: {
+            type: "column",
+            value: S,
+            label: await F(t, S, s)
+          },
+          type: pe(P) ? "discrete" : "continuous"
+        };
+      })
+    ), x = (await Promise.all(
+      e.components.x.selectorStates.map(
+        (i) => F(t, i.selectedSource, s)
+      )
+    )).join(", "), b = (await Promise.all(
+      e.components.y.selectorStates.map(
+        (i) => F(t, i.selectedSource, s)
+      )
+    )).join(", "), g = await Promise.all(
+      e.components.tooltipContent.selectorStates.map(async (i) => {
+        var f, y;
+        const S = i.selectedSource;
+        return {
+          type: "column",
+          label: await F(t, S, s) || S,
+          value: S,
+          valueLabels: (y = (f = await E(t, S, s)) == null ? void 0 : f.toCanonicalString()) != null ? y : S
+        };
+      })
+    );
+    return {
+      type: "heatmap",
+      valueColumn: c,
+      valueType: pe(h) ? "discrete" : "continuous",
+      xColumn: {
+        type: "column",
+        value: r,
+        label: x,
+        valueLabels: "xLabelsKey"
+      },
+      yColumn: {
+        type: "column",
+        value: p,
+        label: b,
+        valueLabels: "yLabelsKey"
+      },
+      facetBy: m,
+      xGroupBy: d,
+      yGroupBy: w,
+      annotations: [...A, ...v],
+      tooltips: {
+        show: !0,
+        content: g
+      }
+    };
+  }
+}, Xe = {
+  type: "scatterplot",
+  components: {
+    x: { type: "simple", selectorStates: [] },
+    y: { type: "simple", selectorStates: [] },
+    filters: { type: "filter", selectorStates: [] },
+    highlight: { type: "filter", selectorStates: [] },
+    tabBy: { type: "filter", selectorStates: [] },
+    facetBy: { type: "simple", selectorStates: [] },
+    grouping: { type: "simple", selectorStates: [] },
+    shape: { type: "simple", selectorStates: [] },
+    size: { type: "simple", selectorStates: [] },
+    label: { type: "simple", selectorStates: [] },
+    tooltipContent: { type: "simple", selectorStates: [] }
+  },
+  dividedAxes: {}
+}, Re = class extends R {
+  constructor() {
+    super(
+      {
+        x: new D({
+          componentName: "x",
+          allowedTypes: ["Int", "Long", "Double", "Float"],
+          parentComponents: ["y"],
+          strictlyDependsOnParents: !1,
+          settings: {
+            isDataComponent: !0,
+            required: !0,
+            axesAllowed: !0,
+            columnsAllowed: !0
+          }
+        }),
+        y: new D({
+          componentName: "y",
+          allowedTypes: ["Int", "Long", "Double", "Float"],
+          parentComponents: ["x"],
+          strictlyDependsOnParents: !1,
+          settings: {
+            isDataComponent: !0,
+            required: !0,
+            axesAllowed: !0,
+            columnsAllowed: !0
+          }
+        }),
+        facetBy: new D({
+          componentName: "facetBy",
+          allowedTypes: ["String", "Int", "Long"],
+          strictlyDependsOnParents: !0,
+          parentComponents: ["x", "y"],
+          dependsOn: ["x", "y"],
+          settings: {
+            axesAllowed: !0,
+            dimensionConsumer: !0,
+            multipleSelectors: !0
+          }
+        }),
+        grouping: new D({
+          componentName: "grouping",
+          allowedTypes: ["String", "Int", "Long", "Double", "Float"],
+          strictlyDependsOnParents: !0,
+          parentComponents: ["x", "y"],
+          dependsOn: ["x", "y"],
+          settings: {
+            axesAllowed: !0,
+            multipleSelectors: !0
+          }
+        }),
+        shape: new D({
+          componentName: "shape",
+          allowedTypes: ["String", "Int", "Long"],
+          strictlyDependsOnParents: !0,
+          parentComponents: ["x", "y"],
+          dependsOn: ["x", "y"],
+          settings: {
+            axesAllowed: !0
+          }
+        }),
+        size: new D({
+          componentName: "size",
+          allowedTypes: ["Int", "Long", "Double", "Float"],
+          strictlyDependsOnParents: !0,
+          parentComponents: ["x", "y"],
+          dependsOn: ["x", "y"],
+          settings: {
+            axesAllowed: !0
+          }
+        }),
+        tooltipContent: new D({
+          componentName: "tooltipContent",
+          allowedTypes: ["String", "Int", "Long", "Float", "Double"],
+          strictlyDependsOnParents: !0,
+          parentComponents: ["x", "y"],
+          dependsOn: ["x", "y"],
+          settings: {
+            columnsAllowed: !0,
+            axesAllowed: !0,
+            multipleSelectors: !0
+          }
+        }),
+        label: new D({
+          componentName: "label",
+          allowedTypes: ["String", "Int", "Long"],
+          strictlyDependsOnParents: !0,
+          parentComponents: ["x", "y"],
+          dependsOn: ["x", "y"],
+          settings: {
+            axesAllowed: !0,
+            columnsAllowed: !0,
+            multipleSelectors: !1
+          }
+        })
+      },
+      {
+        filters: new D({
+          componentName: "filters",
+          allowedTypes: ["String", "Int", "Long", "Double", "Float"],
+          strictlyDependsOnParents: !0,
+          parentComponents: ["x", "y"],
+          dependsOn: ["x", "y"],
+          settings: {
+            axesAllowed: !0,
+            columnsAllowed: !0,
+            dimensionConsumer: !0,
+            multipleSelectors: !0
+          },
+          checkSourceBySpec: H
+        }),
+        tabBy: new D({
+          componentName: "tabBy",
+          allowedTypes: ["String", "Int"],
+          strictlyDependsOnParents: !0,
+          parentComponents: ["x", "y"],
+          dependsOn: ["x", "y"],
+          settings: {
+            axesAllowed: !0,
+            dimensionConsumer: !0
+          }
+        }),
+        highlight: new D({
+          componentName: "highlight",
+          allowedTypes: ["String", "Int", "Long", "Double", "Float"],
+          strictlyDependsOnParents: !0,
+          parentComponents: ["x", "y"],
+          dependsOn: ["x", "y"],
+          settings: {
+            axesAllowed: !0,
+            columnsAllowed: !0,
+            multipleSelectors: !0
+          },
+          checkSourceBySpec: H
+        })
+      }
+    ), this.dataInputs = ["x", "y"];
+  }
+  async getMustBeConsumedAxes(t, e) {
+    if (!e.components.x.selectorStates.length || !e.components.y.selectorStates.length)
+      return /* @__PURE__ */ new Set();
+    const o = e.components.x.selectorStates[0].selectedSource, n = e.components.y.selectorStates[0].selectedSource, l = await t.pFrameProvider.getColumnSpecById(C(o)), s = await t.pFrameProvider.getColumnSpecById(C(n));
+    if (!l || !s)
+      return /* @__PURE__ */ new Set();
+    const c = l.axesSpec.map((p) => _.fromAxisSpec(p).toCanonicalString()), a = s.axesSpec.map((p) => _.fromAxisSpec(p).toCanonicalString()), r = c.filter((p) => !a.some((m) => m === p)), u = a.filter((p) => !c.some((m) => m === p));
+    return /* @__PURE__ */ new Set([...r, ...u]);
+  }
+  async createDataByColumns(t, e) {
+    var o, n, l;
+    const s = (o = e.components.x.selectorStates[0]) == null ? void 0 : o.selectedSource, c = (n = e.components.y.selectorStates[0]) == null ? void 0 : n.selectedSource;
+    if (!s || !c)
+      throw Error("X or Y column is not valid");
+    const a = C(s), r = C(c), u = {
+      type: "columns",
+      id: (l = j(e.components)) != null ? l : "",
+      values: {}
+    }, p = await W(t), m = [
+      ...e.components.filters.selectorStates,
+      ...e.components.tabBy.selectorStates
+    ], d = U(m), w = m.map((S) => C(S.selectedSource)).filter(B), h = [a, r].filter(B).map((S) => S.toCanonicalString());
+    if (h.length === 0)
+      throw Error("One of X and Y should be a column");
+    const A = await X(t, h), v = [a, r, ...w], x = [], b = [[], []], g = [], i = [];
+    for (const { selectedSource: S, fixedAxes: I } of m)
+      i.push(...await M(
+        t,
+        p,
+        A,
+        S,
+        I
+      )), b.push(
+        (I ?? []).map(({ axisIdx: P, axisValue: N }) => ({ idx: P, value: N }))
+      );
+    const f = [
+      e.components.grouping,
+      e.components.size,
+      e.components.shape,
+      e.components.tooltipContent,
+      e.components.facetBy,
+      e.components.label,
+      e.components.highlight
+    ];
+    for (const S of f)
+      for (const { selectedSource: I, fixedAxes: P } of S.selectorStates) {
+        x.push(C(I)), g.push(
+          (P ?? []).map(({ axisIdx: L, axisValue: O }) => ({ idx: L, value: O }))
+        ), i.push(...await M(
+          t,
+          p,
+          A,
+          I,
+          P
+        ));
+        const N = await E(t, I, h);
+        N && x.push(N);
+      }
+    const y = await t.pFrameProvider.getTableOuterJoin(
+      [a, r, ...i, ...w],
+      x,
+      d,
+      !1,
+      b,
+      g
+    );
+    return [...v, ...x].forEach((S) => {
+      const I = S.toCanonicalString();
+      u.values[I] = B(S) ? y.columnsData[I] : y.axesData[I];
+    }), u.values.key = new Array(u.values[Object.keys(u.values)[0]].length).fill(0).map((S, I) => I), e.components.highlight.selectorStates.length && (u.values.highlight = he(e.components.highlight.selectorStates, y)), { byColumns: u };
+  }
+  async createChartSettings(t, e) {
+    var o, n, l, s;
+    const c = (o = e.components.x.selectorStates[0]) == null ? void 0 : o.selectedSource, a = (n = e.components.y.selectorStates[0]) == null ? void 0 : n.selectedSource, r = c ? C(c) : null, u = a ? C(a) : null;
+    if (!c || !a || !r || !u || !B(r) && !B(u))
+      throw Error("Empty or invalid required data");
+    const p = [r, u].filter(B).map((i) => i.toCanonicalString()), m = {
+      type: "column",
+      value: c,
+      label: await F(t, c, p)
+    }, d = {
+      type: "column",
+      value: a,
+      label: await F(t, a, p)
+    }, w = {
+      type: "column",
+      value: "key"
+    }, h = await Promise.all(
+      e.components.facetBy.selectorStates.map(async (i) => {
+        var f, y;
+        return {
+          type: "column",
+          value: (y = (f = await E(t, i.selectedSource, p)) == null ? void 0 : f.toCanonicalString()) != null ? y : i.selectedSource
+        };
+      })
+    ), A = ce.uniq([
+      ...e.components.grouping.selectorStates.map((i) => i.selectedSource),
+      ...e.components.size.selectorStates.map((i) => i.selectedSource),
+      ...e.components.shape.selectorStates.map((i) => i.selectedSource)
+    ]), v = await Promise.all(
+      A.map(async (i) => {
+        var f, y;
+        return {
+          type: "column",
+          label: await F(t, i, p) || i,
+          value: i,
+          valueLabels: (y = (f = await E(t, i, p)) == null ? void 0 : f.toCanonicalString()) != null ? y : i
+        };
+      })
+    ), x = await Promise.all(
+      e.components.tooltipContent.selectorStates.map(async (i) => {
+        var f, y;
+        const S = i.selectedSource;
+        return {
+          type: "column",
+          label: await F(t, S, p) || S,
+          value: S,
+          valueLabels: (y = (f = await E(t, S, p)) == null ? void 0 : f.toCanonicalString()) != null ? y : S
+        };
+      })
+    );
+    let b;
+    if (e.components.label.selectorStates.length) {
+      const i = e.components.label.selectorStates[0].selectedSource;
+      b = {
+        type: "column",
+        value: i,
+        label: await F(t, i, p),
+        valueLabels: (s = (l = await E(t, i, p)) == null ? void 0 : l.toCanonicalString()) != null ? s : i
+      };
+    }
+    let g;
+    return e.components.highlight.selectorStates.length && (g = {
+      type: "column",
+      value: "highlight"
+    }), {
+      type: "scatterplot",
+      x: m,
+      y: d,
+      keyColumn: w,
+      facetBy: h,
+      grouping: v,
+      label: b,
+      highlight: g,
+      tooltips: {
+        show: !0,
+        content: x
+      }
+    };
+  }
+}, Je = {
+  type: "scatterplot-umap",
+  components: {
+    x: { type: "simple", selectorStates: [] },
+    y: { type: "simple", selectorStates: [] },
+    filters: { type: "filter", selectorStates: [] },
+    highlight: { type: "filter", selectorStates: [] },
+    tabBy: { type: "filter", selectorStates: [] },
+    facetBy: { type: "simple", selectorStates: [] },
+    grouping: { type: "simple", selectorStates: [] },
+    label: { type: "simple", selectorStates: [] },
+    tooltipContent: { type: "simple", selectorStates: [] },
+    size: { type: "simple", selectorStates: [] }
+  },
+  dividedAxes: {}
+}, $e = class extends R {
+  constructor() {
+    super(
+      {
+        x: new D({
+          componentName: "x",
+          allowedTypes: ["Int", "Long", "Double", "Float"],
+          parentComponents: ["y"],
+          strictlyDependsOnParents: !1,
+          settings: {
+            isDataComponent: !0,
+            required: !0,
+            axesAllowed: !0,
+            columnsAllowed: !0
+          }
+        }),
+        y: new D({
+          componentName: "y",
+          allowedTypes: ["Int", "Long", "Double", "Float"],
+          parentComponents: ["x"],
+          strictlyDependsOnParents: !1,
+          settings: {
+            isDataComponent: !0,
+            required: !0,
+            axesAllowed: !0,
+            columnsAllowed: !0
+          }
+        }),
+        facetBy: new D({
+          componentName: "facetBy",
+          allowedTypes: ["String", "Int", "Long"],
+          strictlyDependsOnParents: !0,
+          parentComponents: ["x", "y"],
+          dependsOn: ["x", "y"],
+          settings: {
+            axesAllowed: !0,
+            dimensionConsumer: !0,
+            multipleSelectors: !0
+          }
+        }),
+        grouping: new D({
+          componentName: "grouping",
+          allowedTypes: ["String", "Int", "Long", "Float", "Double"],
+          strictlyDependsOnParents: !0,
+          parentComponents: ["x", "y"],
+          dependsOn: ["x", "y"],
+          settings: {
+            axesAllowed: !0,
+            multipleSelectors: !0
+          }
+        }),
+        tooltipContent: new D({
+          componentName: "tooltipContent",
+          allowedTypes: ["String", "Int", "Long", "Float", "Double"],
+          strictlyDependsOnParents: !0,
+          parentComponents: ["x", "y"],
+          dependsOn: ["x", "y"],
+          settings: {
+            columnsAllowed: !0,
+            axesAllowed: !0,
+            multipleSelectors: !0
+          }
+        }),
+        label: new D({
+          componentName: "label",
+          allowedTypes: ["String", "Int", "Long"],
+          strictlyDependsOnParents: !0,
+          parentComponents: ["x", "y"],
+          dependsOn: ["x", "y"],
+          settings: {
+            axesAllowed: !0,
+            columnsAllowed: !0,
+            multipleSelectors: !1
+          }
+        }),
+        size: new D({
+          componentName: "size",
+          allowedTypes: ["Int", "Long", "Double", "Float"],
+          strictlyDependsOnParents: !0,
+          parentComponents: ["x", "y"],
+          dependsOn: ["x", "y"],
+          settings: {
+            axesAllowed: !0
+          }
+        })
+      },
+      {
+        filters: new D({
+          componentName: "filters",
+          allowedTypes: ["String", "Int", "Long", "Double", "Float"],
+          strictlyDependsOnParents: !0,
+          parentComponents: ["x", "y"],
+          dependsOn: ["x", "y"],
+          settings: {
+            axesAllowed: !0,
+            dimensionConsumer: !0,
+            multipleSelectors: !0
+          },
+          checkSourceBySpec: H
+        }),
+        tabBy: new D({
+          componentName: "tabBy",
+          allowedTypes: ["String", "Int"],
+          strictlyDependsOnParents: !0,
+          parentComponents: ["x", "y"],
+          dependsOn: ["x", "y"],
+          settings: {
+            axesAllowed: !0,
+            dimensionConsumer: !0
+          }
+        }),
+        highlight: new D({
+          componentName: "highlight",
+          allowedTypes: ["String", "Int", "Long", "Double", "Float"],
+          strictlyDependsOnParents: !0,
+          parentComponents: ["x", "y"],
+          dependsOn: ["x", "y"],
+          settings: {
+            axesAllowed: !0,
+            columnsAllowed: !0,
+            multipleSelectors: !0
+          },
+          checkSourceBySpec: H
+        })
+      }
+    ), this.dataInputs = ["x", "y"];
+  }
+  async getMustBeConsumedAxes(t, e) {
+    if (!e.components.x.selectorStates.length || !e.components.y.selectorStates.length)
+      return /* @__PURE__ */ new Set();
+    const o = e.components.x.selectorStates[0].selectedSource, n = e.components.y.selectorStates[0].selectedSource, l = await t.pFrameProvider.getColumnSpecById(C(o)), s = await t.pFrameProvider.getColumnSpecById(C(n));
+    if (!l || !s)
+      return /* @__PURE__ */ new Set();
+    const c = l.axesSpec.map((p) => _.fromAxisSpec(p).toCanonicalString()), a = s.axesSpec.map((p) => _.fromAxisSpec(p).toCanonicalString()), r = c.filter((p) => !a.some((m) => m === p)), u = a.filter((p) => !c.some((m) => m === p));
+    return /* @__PURE__ */ new Set([...r, ...u]);
+  }
+  async createDataByColumns(t, e) {
+    var o, n, l;
+    const s = (o = e.components.x.selectorStates[0]) == null ? void 0 : o.selectedSource, c = (n = e.components.y.selectorStates[0]) == null ? void 0 : n.selectedSource;
+    if (!s || !c)
+      throw Error("X or Y column is not valid");
+    const a = C(s), r = C(c);
+    if (!a || !r)
+      throw Error("X or Y column is not valid");
+    const u = {
+      type: "columns",
+      id: (l = j(e.components)) != null ? l : "",
+      values: {}
+    }, p = await W(t), m = [
+      ...e.components.filters.selectorStates,
+      ...e.components.tabBy.selectorStates
+    ], d = U(m), w = m.map((S) => C(S.selectedSource)).filter(B), h = [a, r].filter(B).map((S) => S.toCanonicalString());
+    if (h.length === 0)
+      throw Error("One of X and Y should be a column");
+    const A = await X(t, h), v = [a, r, ...w], x = [], b = [[], []], g = [], i = [];
+    for (const { selectedSource: S, fixedAxes: I } of m)
+      i.push(...await M(
+        t,
+        p,
+        A,
+        S,
+        I
+      )), i.push(...await M(
+        t,
+        p,
+        A,
+        S,
+        I
+      )), b.push(
+        (I ?? []).map(({ axisIdx: P, axisValue: N }) => ({ idx: P, value: N }))
+      );
+    const f = [
+      e.components.grouping,
+      e.components.facetBy,
+      e.components.tooltipContent,
+      e.components.label,
+      e.components.highlight,
+      e.components.size
+    ];
+    for (const S of f)
+      for (const { selectedSource: I, fixedAxes: P } of S.selectorStates) {
+        x.push(C(I)), g.push(
+          (P ?? []).map(({ axisIdx: L, axisValue: O }) => ({ idx: L, value: O }))
+        ), i.push(...await M(
+          t,
+          p,
+          A,
+          I,
+          P
+        ));
+        const N = await E(t, I, h);
+        N && x.push(N);
+      }
+    const y = await t.pFrameProvider.getTableOuterJoin(
+      [a, r, ...i, ...w],
+      x,
+      d,
+      !1,
+      b,
+      g
+    );
+    return [...v, ...x].forEach((S) => {
+      const I = S.toCanonicalString();
+      u.values[I] = B(S) ? y.columnsData[I] : y.axesData[I];
+    }), e.components.highlight.selectorStates.length && (u.values.highlight = he(e.components.highlight.selectorStates, y)), {
+      byColumns: u,
+      axesData: y.axesData
+    };
+  }
+  async createChartSettings(t, e) {
+    var o, n, l, s;
+    const c = (o = e.components.x.selectorStates[0]) == null ? void 0 : o.selectedSource, a = (n = e.components.y.selectorStates[0]) == null ? void 0 : n.selectedSource, r = c ? C(c) : null, u = a ? C(a) : null;
+    if (!c || !a || !r || !u || !B(r) && !B(u))
+      throw Error("Empty or invalid required data");
+    const p = [r, u].filter(B).map((i) => i.toCanonicalString()), m = {
+      type: "column",
+      value: c,
+      label: await F(t, c, p)
+    }, d = {
+      type: "column",
+      value: a,
+      label: await F(t, a, p)
+    }, w = {
+      type: "column",
+      value: "key"
+    }, h = await Promise.all(
+      e.components.facetBy.selectorStates.map(async (i) => {
+        var f, y;
+        return {
+          type: "column",
+          value: (y = (f = await E(t, i.selectedSource, p)) == null ? void 0 : f.toCanonicalString()) != null ? y : i.selectedSource
+        };
+      })
+    ), A = ce.uniq([
+      ...e.components.grouping.selectorStates.map((i) => i.selectedSource),
+      ...e.components.size.selectorStates.map((i) => i.selectedSource)
+    ]), v = await Promise.all(
+      A.map(async (i) => {
+        var f, y;
+        return {
+          type: "column",
+          label: await F(t, i, p) || i,
+          value: i,
+          valueLabels: (y = (f = await E(t, i, p)) == null ? void 0 : f.toCanonicalString()) != null ? y : i
+        };
+      })
+    ), x = await Promise.all(
+      e.components.tooltipContent.selectorStates.map(async (i) => {
+        var f, y;
+        const S = i.selectedSource;
+        return {
+          type: "column",
+          label: await F(t, S, p) || S,
+          value: S,
+          valueLabels: (y = (f = await E(t, S, p)) == null ? void 0 : f.toCanonicalString()) != null ? y : S
+        };
+      })
+    );
+    let b;
+    if (e.components.label.selectorStates.length) {
+      const i = e.components.label.selectorStates[0].selectedSource;
+      b = {
+        type: "column",
+        value: i,
+        label: await F(t, i, p),
+        valueLabels: (s = (l = await E(t, i, p)) == null ? void 0 : l.toCanonicalString()) != null ? s : i
+      };
+    }
+    let g;
+    return e.components.highlight.selectorStates.length && (g = {
+      type: "column",
+      value: "highlight"
+    }), {
+      type: "scatterplot-umap",
+      x: m,
+      y: d,
+      keyColumn: w,
+      facetBy: h,
+      grouping: v,
+      label: b,
+      highlight: g,
+      tooltips: {
+        show: !0,
+        content: x
+      }
+    };
+  }
+}, me = "pl7.app/dendrogram/nodeId", de = "id", Ze = {
+  type: "dendro",
+  components: {
+    value: { type: "simple", selectorStates: [] },
+    height: { type: "simple", selectorStates: [] },
+    labels: { type: "simple", selectorStates: [] },
+    tableContent: { type: "simple", selectorStates: [] },
+    nodeColor: { type: "simple", selectorStates: [] },
+    nodeShape: { type: "simple", selectorStates: [] },
+    nodeSize: { type: "simple", selectorStates: [] },
+    lineColor: { type: "simple", selectorStates: [] },
+    heatmapAnnotation: { type: "simple", selectorStates: [] },
+    heatmapForSequence: { type: "simple", selectorStates: [] },
+    filters: { type: "filter", selectorStates: [] },
+    tabBy: { type: "filter", selectorStates: [] },
+    facetBy: { type: "simple", selectorStates: [] },
+    heatmapAxis: { type: "simple", selectorStates: [] },
+    heatmapGroup: { type: "simple", selectorStates: [] }
+  },
+  dividedAxes: {}
+}, Qe = class extends R {
+  constructor() {
+    super(
+      {
+        value: new D({
+          componentName: "value",
+          allowedTypes: ["Int", "Long"],
+          annotations: { "pl7.app/dendrogram/isTopology": "true" },
+          settings: {
+            isDataComponent: !0,
+            columnsAllowed: !0,
+            required: !0,
+            dimensionConsumer: !0,
+            columnsWithExtraAxesAllowed: !1
+          }
+        }),
+        height: new D({
+          componentName: "height",
+          allowedTypes: ["Int", "Long", "Double", "Float"],
+          annotations: { "pl7.app/dendrogram/isDistance": "true" },
+          parentComponents: ["value"],
+          strictlyDependsOnParents: !0,
+          settings: {
+            columnsAllowed: !0,
+            axesAllowed: !1,
+            dimensionConsumer: !0,
+            columnsWithExtraAxesAllowed: !1
+          }
+        }),
+        labels: new D({
+          componentName: "labels",
+          allowedTypes: ["Int", "String", "Long"],
+          parentComponents: ["value"],
+          strictlyDependsOnParents: !1,
+          settings: {
+            columnsAllowed: !0,
+            axesAllowed: !1,
+            columnsWithExtraAxesAllowed: !1
+          }
+        }),
+        tableContent: new D({
+          componentName: "tableContent",
+          allowedTypes: ["Int", "String", "Long", "Double", "Float"],
+          parentComponents: ["value"],
+          strictlyDependsOnParents: !1,
+          settings: {
+            columnsAllowed: !0,
+            axesAllowed: !0,
+            multipleSelectors: !0,
+            columnsWithExtraAxesAllowed: !1
+          }
+        }),
+        nodeShape: new D({
+          componentName: "nodeShape",
+          allowedTypes: ["Int", "String", "Long"],
+          parentComponents: ["value"],
+          strictlyDependsOnParents: !1,
+          settings: {
+            columnsAllowed: !0,
+            axesAllowed: !0,
+            columnsWithExtraAxesAllowed: !1
+          }
+        }),
+        nodeSize: new D({
+          componentName: "nodeSize",
+          allowedTypes: ["Double", "Int", "String", "Long"],
+          parentComponents: ["value"],
+          strictlyDependsOnParents: !1,
+          settings: {
+            columnsAllowed: !0,
+            axesAllowed: !0,
+            columnsWithExtraAxesAllowed: !1
+          }
+        }),
+        nodeColor: new D({
+          componentName: "nodeColor",
+          allowedTypes: ["Double", "Int", "String", "Long"],
+          parentComponents: ["value"],
+          strictlyDependsOnParents: !1,
+          settings: {
+            columnsAllowed: !0,
+            axesAllowed: !0,
+            columnsWithExtraAxesAllowed: !1
+          }
+        }),
+        lineColor: new D({
+          componentName: "lineColor",
+          allowedTypes: ["Double", "Int", "String", "Long"],
+          parentComponents: ["value"],
+          strictlyDependsOnParents: !1,
+          settings: {
+            columnsAllowed: !0,
+            axesAllowed: !1,
+            columnsWithExtraAxesAllowed: !1
+          }
+        }),
+        heatmapForSequence: new D({
+          componentName: "heatmapForSequence",
+          allowedTypes: ["String"],
+          annotations: { "pl7.app/type": "sequence" },
+          parentComponents: ["value"],
+          strictlyDependsOnParents: !1,
+          settings: {
+            columnsAllowed: !0,
+            axesAllowed: !0,
+            columnsWithExtraAxesAllowed: !1
+          }
+        }),
+        heatmapAnnotation: new D({
+          componentName: "heatmapAnnotation",
+          allowedTypes: ["Double", "Int", "Long", "Float", "String"],
+          parentComponents: ["value"],
+          strictlyDependsOnParents: !1,
+          settings: {
+            isDataComponent: !0,
+            columnsAllowed: !0,
+            axesAllowed: !1,
+            columnsWithExtraAxesAllowed: !1
+          }
+        }),
+        facetBy: new D({
+          componentName: "facetBy",
+          allowedTypes: ["String", "Int", "Long"],
+          parentComponents: ["value"],
+          strictlyDependsOnParents: !0,
+          settings: {
+            dimensionConsumer: !0,
+            multipleSelectors: !0,
+            axesAllowed: !0,
+            columnsAllowed: !1,
+            columnsWithExtraAxesAllowed: !1
+          }
+        }),
+        heatmapAxis: new D({
+          componentName: "heatmapAxis",
+          allowedTypes: ["String", "Int", "Long"],
+          parentComponents: ["heatmapAnnotation"],
+          settings: {
+            dimensionConsumer: !0,
+            axesAllowed: !0,
+            columnsAllowed: !1,
+            columnsWithExtraAxesAllowed: !1
+          }
+        }),
+        heatmapGroup: new D({
+          componentName: "heatmapGroup",
+          allowedTypes: ["String", "Int", "Long"],
+          parentComponents: ["heatmapAnnotation"],
+          settings: {
+            dimensionConsumer: !0,
+            multipleSelectors: !0,
+            axesAllowed: !0,
+            columnsAllowed: !1,
+            columnsWithExtraAxesAllowed: !1
+          }
+        })
+      },
+      {
+        filters: new D({
+          componentName: "filters",
+          allowedTypes: ["String", "Int", "Long"],
+          parentComponents: ["value", "heatmapAnnotation"],
+          strictlyDependsOnParents: !1,
+          settings: {
+            dimensionConsumer: !0,
+            multipleSelectors: !0,
+            axesAllowed: !0,
+            columnsAllowed: !1,
+            columnsWithExtraAxesAllowed: !1
+          }
+        }),
+        tabBy: new D({
+          componentName: "tabBy",
+          allowedTypes: ["String", "Int", "Long"],
+          parentComponents: ["value", "heatmapAnnotation"],
+          strictlyDependsOnParents: !1,
+          settings: {
+            dimensionConsumer: !0,
+            axesAllowed: !0,
+            columnsAllowed: !1,
+            columnsWithExtraAxesAllowed: !1
+          }
+        })
+      }
+    ), this.ignoredOptionIdNames = [me];
+  }
+  readyDataInputs(t) {
+    return t.components.value.selectorStates.length > 0;
+  }
+  async createTableData(t, e) {
+    var o;
+    const n = {}, l = (o = e.components.value.selectorStates[0]) == null ? void 0 : o.selectedSource, s = C(l);
+    if (!l || !B(s))
+      throw Error("Value column is not valid");
+    const c = await W(t), a = U([
+      ...e.components.filters.selectorStates,
+      ...e.components.tabBy.selectorStates
+    ]), r = [
+      ...e.components.filters.selectorStates.map((g) => C(g.selectedSource)),
+      ...e.components.tabBy.selectorStates.map((g) => C(g.selectedSource))
+    ].filter(B), u = [l], p = await X(t, u), m = [], d = [], w = [], h = [e.components.value], A = [
+      e.components.tableContent,
+      // next components can content data mapped on tree
+      e.components.labels,
+      e.components.nodeColor,
+      e.components.nodeSize,
+      e.components.nodeShape,
+      e.components.lineColor
+    ], v = {};
+    for (const g of h)
+      for (const { selectedSource: i, fixedAxes: f } of g.selectorStates) {
+        w.push(...await M(
+          t,
+          c,
+          p,
+          i,
+          f
+        ));
+        const y = await E(t, i, u), S = y ?? C(i);
+        v[S.toCanonicalString()] = i, m.push(S);
+      }
+    for (const g of A)
+      for (const { selectedSource: i, fixedAxes: f } of g.selectorStates) {
+        w.push(...await M(
+          t,
+          c,
+          p,
+          i,
+          f
+        ));
+        const y = await E(t, i, u), S = y ?? C(i);
+        v[i] = S.toCanonicalString(), d.push(S);
+      }
+    const x = await t.pFrameProvider.getTableOuterJoin(
+      [...m, ...r, ...w],
+      d,
+      a,
+      !1
+    );
+    for (const g of [...m, ...d]) {
+      const i = g.toCanonicalString(), f = v[g.toCanonicalString()];
+      n[f] = {
+        data: B(g) ? x.columnsData[i] : x.axesData[i],
+        spec: B(g) ? x.columnSpecs[i] : x.axesSpecs[i],
+        label: await F(t, f, u)
+      };
+    }
+    const b = Object.keys(x.axesData).find(
+      (g) => {
+        var i;
+        return ((i = C(g)) == null ? void 0 : i.name) === me;
+      }
+    );
+    return b ? n[de] = {
+      data: x.axesData[b],
+      spec: { kind: "PColumn", valueType: "Int", name: "Node id" },
+      label: "Node id"
+    } : console.warn("Missed node id axis in data column"), n;
+  }
+  async createDataByColumns(t, e) {
+    var o, n, l;
+    const s = (o = e.components.value.selectorStates[0]) == null ? void 0 : o.selectedSource, c = (n = e.components.heatmapAnnotation.selectorStates[0]) == null ? void 0 : n.selectedSource, a = C(s), r = c ? C(c) : null;
+    if (!s || !B(a))
+      throw Error("Value column is not valid");
+    const u = {
+      type: "columns",
+      id: (l = j(e.components)) != null ? l : "",
+      values: {}
+    }, p = [
+      ...e.components.filters.selectorStates,
+      ...e.components.tabBy.selectorStates
+    ], m = U(p), d = p.map((y) => C(y.selectedSource)).filter(B), w = [a, r].filter(B).map((y) => y.toCanonicalString()), h = [], A = [], v = [], x = [], b = [
+      e.components.value,
+      e.components.height,
+      e.components.labels,
+      e.components.nodeColor,
+      e.components.nodeSize,
+      e.components.nodeShape,
+      e.components.lineColor,
+      e.components.heatmapAnnotation,
+      e.components.heatmapForSequence
+    ], g = [
+      e.components.facetBy,
+      e.components.heatmapAxis,
+      e.components.heatmapGroup,
+      e.components.tableContent
+    ];
+    for (const y of b)
+      for (const { selectedSource: S, fixedAxes: I } of y.selectorStates) {
+        h.push(C(S)), v.push(
+          (I ?? []).map(({ axisIdx: N, axisValue: L }) => ({ idx: N, value: L }))
+        );
+        const P = await E(t, S, w);
+        P && h.push(P);
+      }
+    p.forEach(({ fixedAxes: y }) => {
+      v.push(
+        (y ?? []).map(({ axisIdx: S, axisValue: I }) => ({ idx: S, value: I }))
+      );
+    });
+    for (const y of g)
+      for (const { selectedSource: S, fixedAxes: I } of y.selectorStates) {
+        A.push(C(S)), x.push(
+          (I ?? []).map(({ axisIdx: N, axisValue: L }) => ({ idx: N, value: L }))
+        );
+        const P = await E(t, S, w);
+        P && A.push(P);
+      }
+    const i = await t.pFrameProvider.getTableOuterJoin(
+      [...h, ...d],
+      A,
+      m,
+      !1,
+      v,
+      x
+    );
+    [...h, ...A].forEach((y) => {
+      const S = y.toCanonicalString(), I = B(y) ? i.columnsData[S] : i.axesData[S];
+      u.values[S] = [], u.values[S] = I;
+    });
+    const f = Object.keys(i.axesData).find(
+      (y) => {
+        var S;
+        return ((S = C(y)) == null ? void 0 : S.name) === me;
+      }
+    );
+    return f ? u.values[de] = i.axesData[f] : console.warn("Missed node id axis in data column"), { byColumns: u };
+  }
+  async createChartSettings(t, e) {
+    var o, n, l;
+    const s = (o = e.components.value.selectorStates[0]) == null ? void 0 : o.selectedSource, c = C(s);
+    if (!s || !B(c))
+      throw Error("Data column is not valid");
+    const a = [s], r = { type: "column", value: de }, u = { type: "column", value: s }, p = e.components.height.selectorStates.length ? { type: "column", value: e.components.height.selectorStates[0].selectedSource } : void 0, m = e.components.labels.selectorStates.length ? { type: "column", value: e.components.labels.selectorStates[0].selectedSource } : void 0, d = {};
+    if (e.components.nodeColor.selectorStates.length) {
+      const v = e.components.nodeColor.selectorStates[0].selectedSource;
+      d.nodeColor = {
+        columnName: {
+          type: "column",
+          value: v,
+          label: await F(t, v, a)
+        }
+      };
+    }
+    if (e.components.nodeShape.selectorStates.length) {
+      const v = e.components.nodeShape.selectorStates[0].selectedSource;
+      d.nodeShape = {
+        columnName: {
+          type: "column",
+          value: v,
+          label: await F(t, v, a)
+        }
+      };
+    }
+    if (e.components.nodeSize.selectorStates.length) {
+      const v = e.components.nodeSize.selectorStates[0].selectedSource;
+      d.nodeSize = {
+        columnName: {
+          type: "column",
+          value: v,
+          label: await F(t, v, a)
+        }
+      };
+    }
+    if (e.components.lineColor.selectorStates.length) {
+      const v = e.components.lineColor.selectorStates[0].selectedSource;
+      d.lineColor = {
+        columnName: {
+          type: "column",
+          value: v,
+          label: await F(t, v, a)
+        }
+      };
+    }
+    let w, h, A;
+    if (e.components.heatmapAnnotation.selectorStates.length && e.components.heatmapAxis.selectorStates.length) {
+      const v = e.components.heatmapAnnotation.selectorStates[0].selectedSource;
+      w = {
+        type: "column",
+        value: v,
+        label: await F(t, v, []),
+        valueLabels: (n = await E(t, v, [])) == null ? void 0 : n.toCanonicalString()
+      };
+      const x = e.components.heatmapAxis.selectorStates[0].selectedSource;
+      h = {
+        type: "column",
+        value: x,
+        label: await F(t, x, [v]),
+        valueLabels: (l = await E(t, x, [v])) == null ? void 0 : l.toCanonicalString()
+      }, A = await Promise.all(
+        e.components.heatmapGroup.selectorStates.map(async (b) => {
+          var g;
+          return {
+            type: "column",
+            value: b.selectedSource,
+            label: await F(t, b.selectedSource, [v]),
+            valueLabels: (g = await E(t, b.selectedSource, [v])) == null ? void 0 : g.toCanonicalString()
+          };
+        })
+      );
+    } else if (e.components.heatmapForSequence.selectorStates.length) {
+      const v = e.components.heatmapForSequence.selectorStates[0].selectedSource;
+      w = {
+        type: "column",
+        value: v,
+        label: await F(t, v, [])
+      };
+    }
+    return {
+      type: "dendro",
+      id: r,
+      parentId: u,
+      height: p,
+      labels: m,
+      aes: d,
+      heatmapAnnotation: w,
+      heatmapAxis: h,
+      heatmapGroup: A
+    };
+  }
+}, fe = 1e6;
+function re(t, e) {
+  if (t === "String")
+    return e.data;
+  if (typeof e.data[0] == "bigint") {
+    const o = new Array(e.data.length);
+    for (let n = 0; n < e.data.length; n++)
+      o[n] = e.data[n] === BigInt(-9007199254740991) ? null : Number(e.data[n]);
+    return o;
+  }
+  for (let o = 0; o < e.data.length; o++) {
+    const n = e.data[o];
+    t === "Int" && n === -2147483648 || (t === "Double" || t === "Float") && isNaN(n) ? e.data[o] = null : e.data[o] = Number(e.data[o]);
+  }
+  return e.data;
+}
+var z = !1;
+var et = class {
+  constructor(t, e) {
+    this.pframeHandle = t, this.pframeDriver = e;
+  }
+  async isColumnExisted(t) {
+    return !!await this.getColumnSpecById(t);
+  }
+  async getSingleColumnData(t, e = []) {
+    if (!await this.isColumnExisted(t))
+      return {
+        axesData: {},
+        data: []
+      };
+    try {
+      const o = Date.now(), n = await this.pframeDriver.calculateTableData(this.pframeHandle, {
+        src: {
+          type: "column",
+          column: t.name
+        },
+        filters: e,
+        sorting: []
+      }), l = n.filter((c) => c.spec.type === "axis"), s = n.filter((c) => c.spec.type === "column");
+      return {
+        axesData: l.reduce((c, a) => {
+          const r = _.fromAxisSpec(a.spec.spec);
+          return c[r.toCanonicalString()] = re(r.type, a.data), c;
+        }, {}),
+        data: s.length ? re(t.type, s[0].data) : []
+      };
+    } catch (o) {
+      throw console.error("PFrame: calculateTableData error"), o;
+    }
+  }
+  async getColumnUniqueValues(t, e = fe, o = []) {
+    if (!await this.isColumnExisted(t))
+      return { values: [], overflow: !1 };
+    const n = {
+      columnId: t.name,
+      filters: o,
+      limit: e
+    };
+    try {
+      const l = Date.now(), s = await this.pframeDriver.getUniqueValues(this.pframeHandle, n);
+      let c = !1;
+      return s.overflow && (c = !0, console.warn(`More than ${e} values for ${t.name} column`)), {
+        values: Array.from(s.values.data).map(String),
+        overflow: c
+      };
+    } catch (l) {
+      throw console.error("PFrame: getUniqueValues for column error"), l;
+    }
+  }
+  async getAxisUniqueValues(t, e, o = fe, n = []) {
+    const l = e.filter(B), s = await Promise.all(l.map((r) => this.getColumnSpecById(r))), c = t.toCanonicalString(), a = l.filter((r, u) => {
+      const p = s[u];
+      return p !== null && p.axesSpec.some((m) => _.fromAxisSpec(m).toCanonicalString() === c);
+    });
+    if (a.length === 0)
+      return { values: [], overflow: !1 };
+    try {
+      const r = Date.now(), u = await Promise.all(
+        a.map(
+          (m) => this.pframeDriver.getUniqueValues(this.pframeHandle, {
+            columnId: m.name,
+            axis: t.toPFrameId(),
+            filters: n,
+            limit: o
+          })
+        )
+      );
+      let p = !1;
+      return u.forEach((m, d) => {
+        m.overflow && (p = !0, console.warn(`More than ${o} values for ${a[d].name} column`));
+      }), {
+        values: ce.uniq(
+          ce.flatten(u.map((m) => Array.from(m.values.data).map(String)))
+        ),
+        overflow: p
+      };
+    } catch (r) {
+      throw console.error("PFrame: getUniqueValues for axis error", r), r;
+    }
+  }
+  async getTableOuterJoin(t, e, o = [], n = !0, l = [], s = []) {
+    const c = t.filter(B), a = e.filter(B), r = {
+      src: {
+        type: "outer",
+        primary: {
+          type: n ? "inner" : "full",
+          entries: c.map((u, p) => {
+            var m;
+            const d = (m = l[p]) == null ? void 0 : m.map((w) => ({
+              type: "constant",
+              axisIndex: w.idx,
+              constant: w.value
+            })).filter((w) => w.constant !== void 0);
+            return d != null && d.length ? {
+              type: "slicedColumn",
+              newId: u.name,
+              column: u.name,
+              axisFilters: d
+            } : {
+              type: "column",
+              column: u.name
+            };
+          })
+        },
+        secondary: a.map((u, p) => {
+          var m;
+          const d = (m = s[p]) == null ? void 0 : m.map((w) => ({
+            type: "constant",
+            axisIndex: w.idx,
+            constant: w.value
+          })).filter((w) => w.constant !== void 0);
+          return d != null && d.length ? {
+            type: "slicedColumn",
+            newId: u.name,
+            column: u.name,
+            axisFilters: d
+          } : {
+            type: "column",
+            column: u.name
+          };
+        })
+      },
+      filters: o,
+      sorting: []
+    };
+    try {
+      const u = Date.now(), p = await this.pframeDriver.calculateTableData(this.pframeHandle, r), m = p.filter((w) => w.spec.type === "axis"), d = p.filter((w) => w.spec.type === "column");
+      return {
+        axesData: m.reduce((w, h) => {
+          const A = _.fromAxisSpec(h.spec.spec);
+          return w[A.toCanonicalString()] = re(A.type, h.data), w;
+        }, {}),
+        columnsData: d.reduce((w, h) => {
+          const A = h.spec.spec, v = new Y({
+            name: h.spec.id,
+            type: A.valueType
+          });
+          return w[v.toCanonicalString()] = re(v.type, h.data), w;
+        }, {}),
+        columnSpecs: d.reduce((w, h) => {
+          const A = h.spec.spec, v = new Y({
+            name: h.spec.id,
+            type: A.valueType
+          });
+          return w[v.toCanonicalString()] = A, w;
+        }, {}),
+        axesSpecs: m.reduce((w, h) => {
+          const A = h.spec.spec, v = _.fromAxisSpec(A);
+          return w[v.toCanonicalString()] = A, w;
+        }, {})
+      };
+    } catch (u) {
+      throw console.error("PFrame: table outer join error"), console.info("error with request: ", r), u;
+    }
+  }
+  async getColumnSpecById(t) {
+    try {
+      const e = Date.now(), o = await this.pframeDriver.getColumnSpec(this.pframeHandle, t.name);
+      return o ?? null;
+    } catch {
+      return console.error("PFrame: get single column error"), null;
+    }
+  }
+  async getColumnAxesIds(t) {
+    var e, o;
+    return (o = (e = await this.getColumnSpecById(t)) == null ? void 0 : e.axesSpec.map((n) => _.fromAxisSpec(n))) != null ? o : [];
+  }
+  async getRequestColumnsFromSelectedSources(t) {
+    var e, o;
+    const n = [];
+    for (const l of t)
+      if (B(l)) {
+        const s = (o = (e = await this.getColumnSpecById(l)) == null ? void 0 : e.axesSpec) != null ? o : [];
+        n.push(...s.map((c) => _.fromAxisSpec(c).toPFrameId()));
+      }
+    return n;
+  }
+  async getColumnsList() {
+    return this.pframeDriver.listColumns(this.pframeHandle);
+  }
+  async getColumnsFull(t, e, o, n, l) {
+    try {
+      const s = {
+        columnFilter: {
+          type: o,
+          name: n,
+          annotationValue: l
+        },
+        compatibleWith: await this.getRequestColumnsFromSelectedSources(t),
+        strictlyCompatible: e
+        // should be true if we want to get meta and false if X/Y
+      }, c = Date.now(), a = await this.pframeDriver.findColumns(this.pframeHandle, s), r = [];
+      return a.hits.forEach((u) => {
+        r.push(u);
+      }), r;
+    } catch (s) {
+      throw console.error("PFrame: findColumns error"), s;
+    }
+  }
+  async getColumns(t, e, o, n, l) {
+    return (await this.getColumnsFull(t, e, o, n, l)).map(
+      (s) => new Y({
+        name: s.columnId,
+        type: s.spec.valueType
+      })
+    );
+  }
+  async findColumnBy(t, e, o, n) {
+    try {
+      const l = {
+        columnFilter: {
+          name: [t],
+          ...e ? { type: [e] } : {},
+          ...o ? { annotationValue: o } : {},
+          ...n ? { domainValue: n } : {}
+        },
+        compatibleWith: [],
+        strictlyCompatible: !1
+      }, s = Date.now(), c = await this.pframeDriver.findColumns(this.pframeHandle, l), a = [];
+      return c.hits.forEach(({ columnId: r, spec: u }) => {
+        a.push(new Y({ name: r, type: u.valueType }));
+      }), a.length > 1 && console.warn(`More than 1 column found for ${t}}`), a.length === 0 ? (console.warn(`No columns found for ${t}}`), null) : a[0];
+    } catch (l) {
+      throw console.error("PFrame: findColumns error"), l;
+    }
+  }
+}, st = class {
+  constructor(t, e, o = (n, l) => l ?? n) {
+    this.labelsModifier = o, this.pFrameProvider = new et(t, e);
+  }
+}, Ie = {
+  controllers: {
+    discrete: new We(),
+    scatterplot: new Re(),
+    "scatterplot-umap": new $e(),
+    heatmap: new Ke(),
+    dendro: new Qe(),
+    histogram: new Ue(),
+    bubble: new je()
+  },
+  initialStates: {
+    discrete: He,
+    scatterplot: Xe,
+    "scatterplot-umap": Je,
+    heatmap: Ye,
+    dendro: Ze,
+    histogram: ze,
+    bubble: Ve
+  }
+};
+function lt(t) {
+  return Ie.controllers[t];
+}
+function at(t) {
+  return Ie.initialStates[t];
+}
+export {
+  _ as AxisId,
+  je as BubbleStateController,
+  Y as ColumnId,
+  st as DemoDataStore,
+  Qe as DendroStateController,
+  We as DiscreteStateController,
+  Ke as HeatmapStateController,
+  Re as ScatterplotStateController,
+  C as columnOrAxisIdFromString,
+  lt as getControllerByType,
+  at as getInitialStateByType,
+  B as isColumnId
+};
+//# sourceMappingURL=index.js.map