@hkyhy/marsun-components-core 0.1.113 → 0.1.115

package/dist/node_modules/@antv/g2/esm/runtime/plot.js

@@ -0,0 +1,675 @@
+import "../../../g/dist/index.esm.js";
+import { mapObject as ct } from "../utils/array.js";
+import { ChartEvent as _t } from "../utils/event.js";
+import { defined as X, compose as gt, maybeSubObject as Ht, subObject as qt, copyAttributes as vt, error as Yt, appendTransform as Zt, isStrictObject as Jt, useMemo as Qt } from "../utils/helper.js";
+import { select as rt, Selection as kt } from "../utils/selection.js";
+import { normalizeComponents as Xt, inferComponent as te, groupComponents as ee, renderComponent as Ot } from "./component.js";
+import { VIEW_CLASS_NAME as At, AREA_CLASS_NAME as St, COMPONENT_CLASS_NAME as wt, PLOT_CLASS_NAME as dt, ELEMENT_CLASS_NAME as ot, MAIN_LAYER_CLASS_NAME as jt, LABEL_LAYER_CLASS_NAME as mt, LABEL_CLASS_NAME as Mt, BREAK_CLASS_NAME as pt, BREAK_GROUP_CLASS_NAME as ne } from "./constant.js";
+import { coordinate2Transform as Ct, createCoordinate as oe } from "./coordinate.js";
+import { computeLayout as se, placeComponents as ae, processAxisZ as re, computeRoughPlotSize as ie } from "./layout.js";
+import { useLibrary as G, documentOf as Ft } from "./library.js";
+import { initializeMark as ce } from "./mark.js";
+import { syncFacetsScales as le, collectScales as ue, useRelationScale as Et, groupTransform as fe, assignScale as Tt, applyScale as pe, inferScale as de } from "./scale.js";
+import { applyDataTransform as me } from "./transform.js";
+import J from "../../../util/esm/lodash/deep-mix.js";
+import $t from "../../../util/esm/lodash/upper-first.js";
+import Dt, { groups as ye } from "../../../../d3-array/src/group.js";
+import { Rect as he } from "../../../g-lite/dist/index.esm.js";
+import ge from "../../../util/esm/lodash/get.js";
+import ve from "../../../util/esm/lodash/is-array.js";
+import { format as be } from "../../../../d3-format/src/defaultLocale.js";
+var tt = function(t, e, n, o) {
+  function s(a) {
+    return a instanceof n ? a : new n(function(i) {
+      i(a);
+    });
+  }
+  return new (n || (n = Promise))(function(a, i) {
+    function p(m) {
+      try {
+        u(o.next(m));
+      } catch (f) {
+        i(f);
+      }
+    }
+    function d(m) {
+      try {
+        u(o.throw(m));
+      } catch (f) {
+        i(f);
+      }
+    }
+    function u(m) {
+      m.done ? a(m.value) : s(m.value).then(p, d);
+    }
+    u((o = o.apply(t, e || [])).next());
+  });
+}, nt = function(t, e) {
+  var n = {};
+  for (var o in t) Object.prototype.hasOwnProperty.call(t, o) && e.indexOf(o) < 0 && (n[o] = t[o]);
+  if (t != null && typeof Object.getOwnPropertySymbols == "function")
+    for (var s = 0, o = Object.getOwnPropertySymbols(t); s < o.length; s++)
+      e.indexOf(o[s]) < 0 && Object.prototype.propertyIsEnumerable.call(t, o[s]) && (n[o[s]] = t[o[s]]);
+  return n;
+};
+function zt(t, e, n) {
+  return tt(this, void 0, void 0, function* () {
+    var o;
+    const { library: s } = n, [a] = G("composition", s), [i] = G("interaction", s), p = new Set(Object.keys(s).map((r) => {
+      var l;
+      return (l = /mark\.(.*)/.exec(r)) === null || l === void 0 ? void 0 : l[1];
+    }).filter(X)), d = new Set(Object.keys(s).map((r) => {
+      var l;
+      return (l = /component\.(.*)/.exec(r)) === null || l === void 0 ? void 0 : l[1];
+    }).filter(X)), u = (r) => {
+      const { type: l } = r;
+      if (typeof l == "function") {
+        const { props: b = {} } = l, { composite: T = !0 } = b;
+        if (T)
+          return "mark";
+      }
+      return typeof l != "string" ? l : p.has(l) || d.has(l) ? "mark" : l;
+    }, m = (r) => u(r) === "mark", f = (r) => u(r) === "standardView", h = (r) => {
+      const { type: l } = r;
+      return typeof l != "string" ? !1 : !!d.has(l);
+    }, _ = (r) => {
+      if (f(r))
+        return [r];
+      const l = u(r);
+      return a({ type: l, static: h(r) })(r);
+    }, v = [], k = /* @__PURE__ */ new Map(), j = /* @__PURE__ */ new Map(), g = [t], O = [];
+    for (; g.length; ) {
+      const r = g.shift();
+      if (f(r)) {
+        const l = j.get(r), [b, T] = l ? Rt(l, r, s) : yield Pt(r, n);
+        k.set(b, r), v.push(b);
+        const L = T.flatMap(_).map((c) => Ct(c, s));
+        if (g.push(...L), L.every(f)) {
+          const c = yield Promise.all(L.map((y) => Bt(y, n)));
+          le(c);
+          for (let y = 0; y < L.length; y++) {
+            const $ = L[y], V = c[y];
+            j.set($, V);
+          }
+        }
+      } else {
+        const l = m(r) ? r : yield Gt(r, n), b = _(l);
+        Array.isArray(b) ? g.push(...b) : typeof b == "function" && O.push(b());
+      }
+    }
+    n.emitter.emit(_t.BEFORE_PAINT);
+    const S = /* @__PURE__ */ new Map(), A = /* @__PURE__ */ new Map(), M = [];
+    e.selectAll(Z(At)).data(v, (r) => r.key).join((r) => r.append("g").attr("className", At).attr("id", (l) => l.key).call(Nt).each(function(l, b, T) {
+      ht(l, rt(T), M, n), S.set(l, T);
+    }), (r) => r.call(Nt).each(function(l, b, T) {
+      ht(l, rt(T), M, n), A.set(l, T);
+    }), (r) => r.each(function(l, b, T) {
+      const L = T.nameInteraction.values();
+      for (const c of L)
+        c.destroy();
+    }).remove());
+    const N = (r, l, b) => Array.from(r.entries()).map(([T, L]) => {
+      const c = b || /* @__PURE__ */ new Map(), y = (P, K = (R) => R) => c.set(P, K), $ = k.get(T), V = ke(rt(L), $, n), q = {
+        view: T,
+        container: L,
+        options: $,
+        setState: y,
+        update: (P, K) => tt(this, void 0, void 0, function* () {
+          const Q = gt(Array.from(c.values()))($);
+          return yield V(Q, P, () => {
+            ve(K) && l(r, K, c);
+          });
+        })
+      };
+      return n.externals.update = q.update, n.externals.setState = y, q;
+    }), E = (r = A, l, b) => {
+      var T;
+      const L = N(r, E, b);
+      for (const c of L) {
+        const { options: y, container: $ } = c, V = $.nameInteraction;
+        let q = ft(y);
+        l && (q = q.filter((P) => l.includes(P[0])));
+        for (const P of q) {
+          const [K, R] = P, Q = V.get(K);
+          if (Q && ((T = Q.destroy) === null || T === void 0 || T.call(Q)), R) {
+            const at = yt(c.view, K, R, i)(c, L, n.emitter);
+            V.set(K, { destroy: at });
+          }
+        }
+      }
+    }, D = N(S, E);
+    for (const r of D) {
+      const { options: l } = r, b = /* @__PURE__ */ new Map();
+      r.container.nameInteraction = b;
+      for (const T of ft(l)) {
+        const [L, c] = T;
+        if (c) {
+          const $ = yt(r.view, L, c, i)(r, D, n.emitter);
+          b.set(L, { destroy: $ });
+        }
+      }
+    }
+    E();
+    const { width: F, height: I } = t, w = [];
+    for (const r of O) {
+      const l = new Promise((b) => tt(this, void 0, void 0, function* () {
+        for (const T of r) {
+          const L = Object.assign({ width: F, height: I }, T);
+          yield zt(L, e, n);
+        }
+        b();
+      }));
+      w.push(l);
+    }
+    n.views = v, (o = n.animations) === null || o === void 0 || o.forEach((r) => r == null ? void 0 : r.cancel()), n.animations = M, n.emitter.emit(_t.AFTER_PAINT);
+    const z = M.filter(X).map(De).map((r) => r.finished);
+    return Promise.all([...z, ...w]);
+  });
+}
+function Nt(t) {
+  t.style("transform", (e) => `translate(${e.layout.x}, ${e.layout.y})`);
+}
+function _e(t) {
+  const [, e] = G("interaction", t);
+  return (n) => {
+    const [o, s] = n;
+    try {
+      return [o, e(o)];
+    } catch {
+      return [o, s.type];
+    }
+  };
+}
+function ke(t, e, n) {
+  const { library: o } = n, s = _e(o), a = (d) => d[1] && d[1].props && d[1].props.reapplyWhenUpdate, p = ft(e).map(s).filter(a).map((d) => d[0]);
+  return (d, u, m) => tt(this, void 0, void 0, function* () {
+    const f = [], [h, _] = yield Pt(d, n);
+    ht(h, t, f, n);
+    for (const v of p.filter((k) => k !== u))
+      Oe(v, t, d, h, n);
+    for (const v of _)
+      zt(v, t, n);
+    return m(), { options: d, view: h };
+  });
+}
+function Oe(t, e, n, o, s) {
+  var a;
+  const { library: i } = s, [p] = G("interaction", i), u = e.node().nameInteraction, m = ft(n).find(([k]) => k === t), f = u.get(t);
+  if (!f || ((a = f.destroy) === null || a === void 0 || a.call(f), !m[1]))
+    return;
+  const h = yt(o, t, m[1], p), _ = {
+    options: n,
+    view: o,
+    container: e.node(),
+    update: (k) => Promise.resolve(k)
+  }, v = h(_, [], s.emitter);
+  u.set(t, { destroy: v });
+}
+function Pt(t, e) {
+  return tt(this, void 0, void 0, function* () {
+    const { library: n } = e, o = yield Se(t, e), s = Ae(o);
+    t.interaction = s.interaction, t.coordinate = s.coordinate, t.marks = [...s.marks, ...s.components];
+    const a = Ct(s, n), i = yield Bt(a, e);
+    return Rt(i, a, n);
+  });
+}
+function Ae(t) {
+  const { coordinate: e = {}, interaction: n = {}, style: o = {}, marks: s } = t, a = nt(t, ["coordinate", "interaction", "style", "marks"]), i = s.map((h) => h.coordinate || {}), p = s.map((h) => h.interaction || {}), d = s.map((h) => h.viewStyle || {}), u = [...i, e].reduceRight((h, _) => J(h, _), {}), m = [n, ...p].reduce((h, _) => J(h, _), {}), f = [...d, o].reduce((h, _) => J(h, _), {});
+  return Object.assign(Object.assign({}, a), { marks: s, coordinate: u, interaction: m, style: f });
+}
+function Se(t, e) {
+  return tt(this, void 0, void 0, function* () {
+    const { library: n } = e, [o, s] = G("mark", n), a = new Set(Object.keys(n).map((_) => {
+      var v;
+      return (v = /component\.(.*)/.exec(_)) === null || v === void 0 ? void 0 : v[1];
+    }).filter(X)), { marks: i } = t, p = [], d = [], u = [...i], { width: m, height: f } = ie(t), h = { options: t, width: m, height: f };
+    for (; u.length; ) {
+      const [_] = u.splice(0, 1), v = yield Gt(_, e), { type: k = Yt("G2Mark type is required."), key: j } = v;
+      if (a.has(k))
+        d.push(v);
+      else {
+        const { props: g = {} } = s(k), { composite: O = !0 } = g;
+        if (!O)
+          p.push(v);
+        else {
+          const { data: S } = v, A = Object.assign(Object.assign({}, v), { data: S && (Array.isArray(S) ? S : S.value) }), M = yield o(A, h), N = Array.isArray(M) ? M : [M];
+          u.unshift(...N.map((E, D) => Object.assign(Object.assign({}, E), { key: `${j}-${D}` })));
+        }
+      }
+    }
+    return Object.assign(Object.assign({}, t), { marks: p, components: d });
+  });
+}
+function Bt(t, e) {
+  return tt(this, void 0, void 0, function* () {
+    const { library: n } = e, [o] = G("theme", n), [, s] = G("mark", n), { theme: a, marks: i, coordinates: p = [] } = t, d = o(Ut(a)), u = /* @__PURE__ */ new Map();
+    for (const f of i) {
+      const { type: h } = f, { props: _ = {} } = s(h), v = yield ce(f, _, e);
+      if (v) {
+        const [k, j] = v;
+        u.set(k, j);
+      }
+    }
+    const m = Dt(Array.from(u.values()).flatMap((f) => f.channels), ({ scaleKey: f }) => f);
+    for (const f of m.values()) {
+      const h = f.reduce((A, { scale: M }) => J(A, M), {}), { scaleKey: _ } = f[0], { values: v } = f[0], k = Array.from(new Set(v.map((A) => A.field).filter(X))), j = J({
+        guide: { title: k.length === 0 ? void 0 : k },
+        field: k[0]
+      }, h), { name: g } = f[0], O = f.flatMap(({ values: A }) => A.map((M) => M.value)), S = Object.assign(Object.assign({}, de(g, O, j, p, d, n)), { uid: Symbol("scale"), key: _ });
+      f.forEach((A) => A.scale = S);
+    }
+    return u;
+  });
+}
+function yt(t, e, n, o) {
+  const s = t.theme, a = typeof e == "string" ? s[e] || {} : {};
+  return o(J(a, Object.assign({ type: e }, n)));
+}
+function Rt(t, e, n) {
+  var o;
+  const [s] = G("mark", n), [a] = G("theme", n), [i] = G("labelTransform", n), { key: p, frame: d = !1, theme: u, clip: m, style: f = {}, labelTransform: h = [] } = e, _ = a(Ut(u)), v = Array.from(t.values()), k = ue(v, e), j = Xt(te(Be(Array.from(k), v, t), e, n)), g = se(j, e, _, n), O = oe(g, e, n), S = d ? J({ mainLineWidth: 1, mainStroke: "#000" }, f) : f;
+  ae(ee(j), O, g), re(j);
+  const A = new Map(Array.from(t.values()).flatMap((F) => {
+    const { channels: I } = F;
+    return I.map(({ scale: w }) => [
+      w.uid,
+      Et(w, n)
+    ]);
+  }));
+  fe(t, A);
+  const M = {};
+  for (const F of j) {
+    const { scales: I = [] } = F, w = [];
+    for (const z of I) {
+      const { name: r, uid: l } = z, b = (o = A.get(l)) !== null && o !== void 0 ? o : Et(z, n);
+      w.push(b), r === "y" && b.update(Object.assign(Object.assign({}, b.getOptions()), { xScale: M.x })), Tt(M, { [r]: b });
+    }
+    F.scaleInstances = w;
+  }
+  const N = [], E = /* @__PURE__ */ new Map();
+  for (const [F, I] of t.entries()) {
+    const {
+      // scale,
+      // Callback to create children options based on this mark.
+      children: w,
+      // The total count of data (both show and hide)for this facet.
+      // This is for unit visualization to sync data domain.
+      dataDomain: z,
+      modifier: r,
+      key: l,
+      data: b
+    } = F;
+    E.set(l, b);
+    const { index: T, channels: L, tooltip: c } = I, y = Object.fromEntries(L.map(({ name: C, scale: B }) => [C, B])), $ = ct(y, ({ uid: C }) => A.get(C));
+    Tt(M, $);
+    const V = pe(L, $), q = s(F), [P, K, R] = Ee(q(T, $, V, O)), Q = z || P.length, st = r ? r(K, Q, g) : [], at = (C) => {
+      var B, x;
+      return (x = (B = c.title) === null || B === void 0 ? void 0 : B[C]) === null || x === void 0 ? void 0 : x.value;
+    }, lt = (C) => c.items.map((B) => B[C]), ut = P.map((C, B) => {
+      const x = Object.assign({ points: K[B], transform: st[B], index: C, markKey: l, viewKey: p, data: b[C] }, c && {
+        title: at(C),
+        items: lt(C)
+      });
+      for (const [U, Y] of Object.entries(V))
+        x[U] = Y[C], R && (x[`series${$t(U)}`] = R[B].map((H) => Y[H]));
+      return R && (x.seriesIndex = R[B]), R && c && (x.seriesItems = R[B].map((U) => lt(U)), x.seriesTitle = R[B].map((U) => at(U))), x;
+    });
+    I.data = ut, I.index = P;
+    const W = w == null ? void 0 : w(ut, $, g);
+    N.push(...W || []);
+  }
+  return [{
+    layout: g,
+    theme: _,
+    coordinate: O,
+    markState: t,
+    key: p,
+    clip: m,
+    scale: M,
+    style: S,
+    components: j,
+    data: E,
+    options: e,
+    labelTransform: gt(h.map(i))
+  }, N];
+}
+function ht(t, e, n, o) {
+  return tt(this, void 0, void 0, function* () {
+    const { library: s } = o, { components: a, theme: i, layout: p, markState: d, coordinate: u, key: m, style: f, clip: h, scale: _ } = t, { x: v, y: k, width: j, height: g } = p, O = nt(p, ["x", "y", "width", "height"]), S = ["view", "plot", "main", "content"], A = S.map((c, y) => y), M = ["a", "margin", "padding", "inset"], N = S.map((c) => Ht(Object.assign({}, i.view, f), c)), E = M.map((c) => qt(O, c)), D = (c) => c.style("x", (y) => r[y].x).style("y", (y) => r[y].y).style("width", (y) => r[y].width).style("height", (y) => r[y].height).each(function(y, $, V) {
+      Re(rt(V), N[y]);
+    });
+    let F = 0, I = 0, w = j, z = g;
+    const r = A.map((c) => {
+      const y = E[c], { left: $ = 0, top: V = 0, bottom: q = 0, right: P = 0 } = y;
+      return F += $, I += V, w -= $ + P, z -= V + q, {
+        x: F,
+        y: I,
+        width: w,
+        height: z
+      };
+    });
+    e.selectAll(Z(St)).data(
+      // Only render area with defined style.
+      A.filter((c) => X(N[c])),
+      (c) => S[c]
+    ).join((c) => c.append("rect").attr("className", St).style("zIndex", -2).call(D), (c) => c.call(D), (c) => c.remove());
+    const l = xe(d), b = l ? { duration: l[1] } : !1;
+    for (const [, c] of ye(a, (y) => `${y.type}-${y.position}`))
+      c.forEach((y, $) => y.index = $);
+    const T = e.selectAll(Z(wt)).data(a, (c) => `${c.type}-${c.position}-${c.index}`).join((c) => c.append("g").style("zIndex", ({ zIndex: y }) => y || -1).attr("className", wt).append((y) => Ot(J({ animate: b, scale: _ }, y), u, i, s, d)), (c) => c.transition(function(y, $, V) {
+      const { preserve: q = !1 } = y;
+      if (q)
+        return;
+      const P = Ot(J({ animate: b, scale: _ }, y), u, i, s, d), { attributes: K } = P, [R] = V.childNodes;
+      return R.update(K, !1);
+    })).transitions();
+    n.push(...T.flat().filter(X));
+    const L = e.selectAll(Z(dt)).data([p], () => m).join((c) => c.append("rect").style("zIndex", 0).style("fill", "transparent").attr("className", dt).call(It).call(xt, Array.from(d.keys())).call(Lt, h), (c) => c.call(xt, Array.from(d.keys())).call(It).call(Lt, h)).transitions();
+    n.push(...L.flat());
+    for (const [c, y] of d.entries()) {
+      const { data: $ } = y, { key: V, class: q, type: P } = c, K = e.select(`#${V}`), R = Fe(c, y, t, o), Q = $e(c, y, t, s), st = ze(c, y, t, s), at = Pe(c, y, t, s), lt = Le(e, K, q, "element"), ut = K.selectAll(Z(ot)).selectFacetAll(lt).data($, (W) => W.key, (W) => W.groupKey).join((W) => W.append(R).attr("className", ot).attr("markType", P).transition(function(C, B, x) {
+        return Q(C, [x]);
+      }), (W) => W.call((C) => {
+        const B = C.parent(), x = Qt((U) => {
+          const [Y, H] = U.getBounds().min;
+          return [Y, H];
+        });
+        C.transition(function(U, Y, H) {
+          Ce(H, B, x);
+          const et = R(U, Y), it = st(U, [H], [et]);
+          return it != null && it.length || (H.nodeName === et.nodeName && et.nodeName !== "g" ? vt(H, et) : (H.parentNode.replaceChild(et, H), et.className = ot, et.markType = P, et.__data__ = H.__data__)), it;
+        }).each(function(U, Y, H) {
+          H.__removed__ && (H.__removed__ = !1);
+        }).attr("markType", P).attr("className", ot);
+      }), (W) => W.each(function(C, B, x) {
+        x.__removed__ = !0;
+      }).transition(function(C, B, x) {
+        return at(C, [x]);
+      }).remove(), (W) => W.append(R).attr("className", ot).attr("markType", P).transition(function(C, B, x) {
+        const { __fromElements__: U } = x, Y = st(C, U, [x]);
+        return new kt(U, null, x.parentNode).transition(Y).remove(), Y;
+      }), (W) => W.transition(function(C, B, x) {
+        const Y = new kt([], x.__toData__, x.parentNode).append(R).attr("className", ot).attr("markType", P).nodes();
+        return st(C, [x], Y);
+      }).remove()).transitions();
+      n.push(...ut.flat());
+    }
+    we(t, e, n, s, o), Me(t, e, s, o);
+  });
+}
+function we(t, e, n, o, s) {
+  const [a] = G("labelTransform", o), { markState: i, labelTransform: p } = t, d = e.select(Z(mt)).node(), u = /* @__PURE__ */ new Map(), m = /* @__PURE__ */ new Map(), f = Array.from(i.entries()).flatMap(([g, O]) => {
+    const { labels: S = [], key: A } = g, M = Ie(g, O, t, o, s), N = e.select(`#${A}`).selectAll(Z(ot)).nodes().filter((E) => {
+      var D;
+      return E.__removed__ ? !1 : !(((D = E.style) === null || D === void 0 ? void 0 : D.visibility) === "hidden" || E.children && E.children.some((I) => {
+        var w;
+        return ((w = I.style) === null || w === void 0 ? void 0 : w.visibility) === "hidden";
+      }));
+    });
+    return S.flatMap((E, D) => {
+      const { transform: F = [] } = E, I = nt(E, ["transform"]);
+      return N.flatMap((w) => {
+        const z = je(I, D, w);
+        return z.forEach((r) => {
+          u.set(r, (l) => M(Object.assign(Object.assign({}, l), { element: w }))), m.set(r, E);
+        }), z;
+      });
+    });
+  }), h = rt(d).selectAll(Z(Mt)).data(f, (g) => g.key).join((g) => g.append((O) => u.get(O)(O)).attr("className", Mt), (g) => g.each(function(O, S, A) {
+    const N = u.get(O)(O);
+    vt(A, N);
+  }), (g) => g.remove()).nodes(), _ = Dt(h, (g) => m.get(g.__data__)), { coordinate: v, layout: k } = t, j = {
+    canvas: s.canvas,
+    coordinate: v,
+    layout: k
+  };
+  for (const [g, O] of _) {
+    const { transform: S = [] } = g;
+    gt(S.map(a))(O, j);
+  }
+  p && p(h, j);
+}
+function je(t, e, n) {
+  const { seriesIndex: o, seriesKey: s, points: a, key: i, index: p } = n.__data__, d = Ne(n);
+  if (!o)
+    return [
+      Object.assign(Object.assign({}, t), {
+        key: `${i}-${e}`,
+        bounds: d,
+        index: p,
+        points: a,
+        dependentElement: n
+      })
+    ];
+  const u = Te(t), m = o.map((f, h) => Object.assign(Object.assign({}, t), {
+    key: `${s[h]}-${e}`,
+    bounds: [a[h]],
+    index: f,
+    points: a,
+    dependentElement: n
+  }));
+  return u ? u(m) : m;
+}
+function Me(t, e, n, o) {
+  const s = t.scale, a = ge(s, "y.options.breaks", []), { document: i } = o.canvas;
+  if ([pt, ne].forEach((m) => {
+    i.getElementsByClassName(m).forEach((f) => {
+      f.remove();
+    });
+  }), !a.length)
+    return;
+  const p = e.select(Z(dt)).node(), [d] = G("shape", n), u = /* @__PURE__ */ new Map();
+  a.forEach((m, f) => {
+    u.set(m, d({
+      type: "break"
+    }, {
+      view: t,
+      selection: e,
+      context: o
+    }));
+  }), rt(p).selectAll(Z(pt)).data(a, (m) => m.key).join((m) => m.append((f, h) => u.get(f)(f, h)).attr("className", pt), (m) => m.each(function(f, h, _) {
+    const k = u.get(f)(f, h);
+    vt(_, k);
+  }), (m) => m.remove()).nodes();
+}
+function Ee([t, e, n]) {
+  if (n)
+    return [t, e, n];
+  const o = [], s = [];
+  for (let a = 0; a < t.length; a++) {
+    const i = t[a], p = e[a];
+    p.every(([d, u]) => X(d) && X(u)) && (o.push(i), s.push(p));
+  }
+  return [o, s];
+}
+function Te(t) {
+  const { selector: e } = t;
+  if (!e)
+    return null;
+  if (typeof e == "function")
+    return e;
+  if (e === "first")
+    return (n) => [n[0]];
+  if (e === "last")
+    return (n) => [n[n.length - 1]];
+  throw new Error(`Unknown selector: ${e}`);
+}
+function Ne(t) {
+  const e = t.cloneNode(!0), n = t.getAnimations();
+  e.style.visibility = "hidden", n.forEach((i) => {
+    const p = i.effect.getKeyframes();
+    e.attr(p[p.length - 1]);
+  }), t.parentNode.appendChild(e);
+  const o = e.getLocalBounds();
+  e.destroy();
+  const { min: s, max: a } = o;
+  return [s, a];
+}
+function Ie(t, e, n, o, s) {
+  const [a] = G("shape", o), { data: i, encode: p } = t, { data: d, defaultLabelShape: u } = e, m = d.map((k) => k.points), f = ct(p, (k) => k.value), { theme: h, coordinate: _ } = n, v = Object.assign(Object.assign({}, s), {
+    document: Ft(s),
+    theme: h,
+    coordinate: _
+  });
+  return (k) => {
+    const { index: j, points: g } = k, O = i[j], { formatter: S = (y) => `${y}`, transform: A, style: M, render: N, selector: E, element: D } = k, F = nt(k, ["formatter", "transform", "style", "render", "selector", "element"]), I = ct(Object.assign(Object.assign({}, F), M), (y) => Vt(y, O, j, i, {
+      channel: f,
+      element: D
+    })), { shape: w = u, text: z } = I, r = nt(I, ["shape", "text"]), l = typeof S == "string" ? be(S) : S, b = Object.assign(Object.assign({}, r), { text: l(z, O, j, i), datum: O }), T = Object.assign({ type: `label.${w}`, render: N }, r), L = a(T, v), c = Kt(h, "label", w, "label");
+    return L(g, b, c, m);
+  };
+}
+function Vt(t, e, n, o, s) {
+  return typeof t == "function" ? t(e, n, o, s) : typeof t != "string" ? t : Jt(e) && e[t] !== void 0 ? e[t] : t;
+}
+function xe(t) {
+  let e = -1 / 0, n = 1 / 0;
+  for (const [o, s] of t) {
+    const { animate: a = {} } = o, { data: i } = s, { enter: p = {}, update: d = {}, exit: u = {} } = a, { type: m, duration: f = 300, delay: h = 0 } = d, { type: _, duration: v = 300, delay: k = 0 } = p, { type: j, duration: g = 300, delay: O = 0 } = u;
+    for (const S of i) {
+      const { updateType: A = m, updateDuration: M = f, updateDelay: N = h, enterType: E = _, enterDuration: D = v, enterDelay: F = k, exitDuration: I = g, exitDelay: w = O, exitType: z = j } = S;
+      (A === void 0 || A) && (e = Math.max(e, M + N), n = Math.min(n, N)), (z === void 0 || z) && (e = Math.max(e, I + w), n = Math.min(n, w)), (E === void 0 || E) && (e = Math.max(e, D + F), n = Math.min(n, F));
+    }
+  }
+  return e === -1 / 0 ? null : [n, e - n];
+}
+function Le(t, e, n, o) {
+  const s = t.node().parentElement;
+  return !s || typeof s.findAll != "function" ? [] : s.findAll((a) => a.style.facet !== void 0 && a.style.facet === n && a !== e.node()).flatMap((a) => a.getElementsByClassName(o));
+}
+function Ce(t, e, n) {
+  if (!t.__facet__)
+    return;
+  const o = t.parentNode.parentNode, s = e.parentNode, [a, i] = n(o), [p, d] = n(s), u = `translate(${a - p}, ${i - d})`;
+  Zt(t, u), e.append(t);
+}
+function Fe(t, e, n, o) {
+  const { library: s } = o, [a] = G("shape", s), { data: i, encode: p } = t, { defaultShape: d, data: u, shape: m } = e, f = ct(p, (O) => O.value), h = u.map((O) => O.points), { theme: _, coordinate: v } = n, { type: k, style: j = {} } = t, g = Object.assign(Object.assign({}, o), {
+    document: Ft(o),
+    coordinate: v,
+    theme: _
+  });
+  return (O) => {
+    const { shape: S = d } = j, { shape: A = S, points: M, seriesIndex: N, index: E } = O, D = nt(O, ["shape", "points", "seriesIndex", "index"]), F = Object.assign(Object.assign({}, D), { index: E }), I = N ? N.map((b) => i[b]) : i[E], w = N || E, z = ct(j, (b) => Vt(b, I, w, i, { channel: f })), r = m[A] ? m[A](z, g) : a(Object.assign(Object.assign({}, z), { type: Wt(t, A) }), g), l = Kt(_, k, A, d);
+    return r(M, F, l, h);
+  };
+}
+function Kt(t, e, n, o) {
+  if (typeof e != "string")
+    return;
+  const { color: s } = t, a = t[e] || {}, i = a[n] || a[o];
+  return Object.assign({ color: s }, i);
+}
+function bt(t, e, n, o, s) {
+  var a, i;
+  const [, p] = G("shape", s), [d] = G("animation", s), { defaultShape: u, shape: m } = n, { theme: f, coordinate: h } = o, v = `default${$t(t)}Animation`, { [v]: k } = ((a = m[u]) === null || a === void 0 ? void 0 : a.props) || p(Wt(e, u)).props, { [t]: j = {} } = f, g = ((i = e.animate) === null || i === void 0 ? void 0 : i[t]) || {}, O = { coordinate: h };
+  return (S, A, M) => {
+    const { [`${t}Type`]: N, [`${t}Delay`]: E, [`${t}Duration`]: D, [`${t}Easing`]: F } = S, I = Object.assign({ type: N || k }, g);
+    if (!I.type)
+      return null;
+    const r = d(I, O)(A, M, J(j, { delay: E, duration: D, easing: F }));
+    let l = [];
+    return Array.isArray(r) ? l = r : l = [r], l.filter(Boolean);
+  };
+}
+function $e(t, e, n, o) {
+  return bt("enter", t, e, n, o);
+}
+function De(t) {
+  return t.finished.then(() => {
+    t.cancel();
+  }), t;
+}
+function ze(t, e, n, o) {
+  return bt("update", t, e, n, o);
+}
+function Pe(t, e, n, o) {
+  return bt("exit", t, e, n, o);
+}
+function Ut(t = {}) {
+  if (typeof t == "string")
+    return { type: t };
+  const { type: e = "light" } = t, n = nt(t, ["type"]);
+  return Object.assign(Object.assign({}, n), { type: e });
+}
+function ft(t) {
+  const e = {
+    event: !0,
+    tooltip: !0,
+    // @todo Inferred by slider self.
+    sliderFilter: !0,
+    legendFilter: !0,
+    scrollbarFilter: !0
+  }, { interaction: n = {} } = t;
+  return Object.entries(J(e, n)).reverse();
+}
+function Gt(t, e) {
+  return tt(this, void 0, void 0, function* () {
+    const { data: n } = t, o = nt(t, ["data"]);
+    if (n == null)
+      return t;
+    const [, { data: s }] = yield me([], { data: n }, e);
+    return Object.assign({ data: s }, o);
+  });
+}
+function It(t) {
+  t.style("transform", (e) => `translate(${e.paddingLeft + e.marginLeft}, ${e.paddingTop + e.marginTop})`).style("width", (e) => e.innerWidth).style("height", (e) => e.innerHeight);
+}
+function Wt(t, e) {
+  const { type: n } = t;
+  return typeof e == "string" ? `${n}.${e}` : e;
+}
+function xt(t, e) {
+  const n = (a) => a.class !== void 0 ? `${a.class}` : "";
+  t.nodes().length === 0 || (t.selectAll(Z(jt)).data(e, (a) => a.key).join((a) => a.append("g").attr("className", jt).attr("id", (i) => i.key).style("facet", n).style("fill", "transparent").style("zIndex", (i) => {
+    var p;
+    return (p = i.zIndex) !== null && p !== void 0 ? p : 0;
+  }), (a) => a.style("facet", n).style("fill", "transparent").style("zIndex", (i) => {
+    var p;
+    return (p = i.zIndex) !== null && p !== void 0 ? p : 0;
+  }), (a) => a.remove()), t.select(Z(mt)).node()) || t.append("g").attr("className", mt).style("zIndex", 0);
+}
+function Z(...t) {
+  return t.map((e) => `.${e}`).join("");
+}
+function Lt(t, e) {
+  t.node() && t.style("clipPath", (n) => {
+    if (!e)
+      return null;
+    const { paddingTop: o, paddingLeft: s, marginLeft: a, marginTop: i, innerWidth: p, innerHeight: d } = n;
+    return new he({ style: { x: s + a, y: o + i, width: p, height: d } });
+  });
+}
+function Be(t, e, n) {
+  var o;
+  for (const [u] of n.entries())
+    if (u.type === "cell")
+      return t.filter((m) => m.name !== "shape");
+  if (e.length !== 1 || t.some((u) => u.name === "shape"))
+    return t;
+  const { defaultShape: s } = e[0];
+  if (!["point", "line", "rect", "hollow"].includes(s))
+    return t;
+  const i = {
+    point: "point",
+    line: "hyphen",
+    rect: "square",
+    hollow: "hollow"
+  }, d = {
+    field: ((o = t.find((u) => u.name === "color")) === null || o === void 0 ? void 0 : o.field) || null,
+    name: "shape",
+    type: "constant",
+    domain: [],
+    range: [i[s]]
+  };
+  return [...t, d];
+}
+function Re(t, e) {
+  for (const [n, o] of Object.entries(e))
+    t.style(n, o);
+}
+export {
+  Re as applyStyle,
+  zt as plot
+};
+//# sourceMappingURL=plot.js.map