web-core-tcm 0.0.54 → 0.0.61

package/dist/node_modules/echarts/lib/chart/helper/LargeLineDraw.js

@@ -0,0 +1,157 @@
+import { __extends as _ } from "../../../../tslib/tslib.es6.js";
+import { containStroke as g } from "../../../../zrender/lib/contain/line.js";
+import { containStroke as I } from "../../../../zrender/lib/contain/quadratic.js";
+import { getECData as S } from "../../util/innerStore.js";
+import L from "../../../../zrender/lib/graphic/Group.js";
+import D from "../../../../zrender/lib/core/BoundingRect.js";
+import P from "../../../../zrender/lib/graphic/Path.js";
+var w = (
+  /** @class */
+  /* @__PURE__ */ (function() {
+    function f() {
+      this.polyline = !1, this.curveness = 0, this.segs = [];
+    }
+    return f;
+  })()
+), A = (
+  /** @class */
+  (function(f) {
+    _(e, f);
+    function e(n) {
+      var o = f.call(this, n) || this;
+      return o._off = 0, o.hoverDataIdx = -1, o;
+    }
+    return e.prototype.reset = function() {
+      this.notClear = !1, this._off = 0;
+    }, e.prototype.getDefaultStyle = function() {
+      return {
+        stroke: "#000",
+        fill: null
+      };
+    }, e.prototype.getDefaultShape = function() {
+      return new w();
+    }, e.prototype.buildPath = function(n, o) {
+      var t = o.segs, a = o.curveness, r;
+      if (o.polyline)
+        for (r = this._off; r < t.length; ) {
+          var v = t[r++];
+          if (v > 0) {
+            n.moveTo(t[r++], t[r++]);
+            for (var s = 1; s < v; s++)
+              n.lineTo(t[r++], t[r++]);
+          }
+        }
+      else
+        for (r = this._off; r < t.length; ) {
+          var i = t[r++], u = t[r++], h = t[r++], l = t[r++];
+          if (n.moveTo(i, u), a > 0) {
+            var c = (i + h) / 2 - (u - l) * a, p = (u + l) / 2 - (h - i) * a;
+            n.quadraticCurveTo(c, p, h, l);
+          } else
+            n.lineTo(h, l);
+        }
+      this.incremental && (this._off = r, this.notClear = !0);
+    }, e.prototype.findDataIndex = function(n, o) {
+      var t = this.shape, a = t.segs, r = t.curveness, v = this.style.lineWidth;
+      if (t.polyline)
+        for (var s = 0, i = 0; i < a.length; ) {
+          var u = a[i++];
+          if (u > 0)
+            for (var h = a[i++], l = a[i++], c = 1; c < u; c++) {
+              var p = a[i++], d = a[i++];
+              if (g(h, l, p, d, v, n, o))
+                return s;
+            }
+          s++;
+        }
+      else
+        for (var s = 0, i = 0; i < a.length; ) {
+          var h = a[i++], l = a[i++], p = a[i++], d = a[i++];
+          if (r > 0) {
+            var m = (h + p) / 2 - (l - d) * r, y = (l + d) / 2 - (p - h) * r;
+            if (I(h, l, m, y, p, d, v, n, o))
+              return s;
+          } else if (g(h, l, p, d, v, n, o))
+            return s;
+          s++;
+        }
+      return -1;
+    }, e.prototype.contain = function(n, o) {
+      var t = this.transformCoordToLocal(n, o), a = this.getBoundingRect();
+      if (n = t[0], o = t[1], a.contain(n, o)) {
+        var r = this.hoverDataIdx = this.findDataIndex(n, o);
+        return r >= 0;
+      }
+      return this.hoverDataIdx = -1, !1;
+    }, e.prototype.getBoundingRect = function() {
+      var n = this._rect;
+      if (!n) {
+        for (var o = this.shape, t = o.segs, a = 1 / 0, r = 1 / 0, v = -1 / 0, s = -1 / 0, i = 0; i < t.length; ) {
+          var u = t[i++], h = t[i++];
+          a = Math.min(u, a), v = Math.max(u, v), r = Math.min(h, r), s = Math.max(h, s);
+        }
+        n = this._rect = new D(a, r, v, s);
+      }
+      return n;
+    }, e;
+  })(P)
+), W = (
+  /** @class */
+  (function() {
+    function f() {
+      this.group = new L();
+    }
+    return f.prototype.updateData = function(e) {
+      this._clear();
+      var n = this._create();
+      n.setShape({
+        segs: e.getLayout("linesPoints")
+      }), this._setCommon(n, e);
+    }, f.prototype.incrementalPrepareUpdate = function(e) {
+      this.group.removeAll(), this._clear();
+    }, f.prototype.incrementalUpdate = function(e, n) {
+      var o = this._newAdded[0], t = n.getLayout("linesPoints"), a = o && o.shape.segs;
+      if (a && a.length < 2e4) {
+        var r = a.length, v = new Float32Array(r + t.length);
+        v.set(a), v.set(t, r), o.setShape({
+          segs: v
+        });
+      } else {
+        this._newAdded = [];
+        var s = this._create();
+        s.incremental = !0, s.setShape({
+          segs: t
+        }), this._setCommon(s, n), s.__startIndex = e.start;
+      }
+    }, f.prototype.remove = function() {
+      this._clear();
+    }, f.prototype.eachRendered = function(e) {
+      this._newAdded[0] && e(this._newAdded[0]);
+    }, f.prototype._create = function() {
+      var e = new A({
+        cursor: "default",
+        ignoreCoarsePointer: !0
+      });
+      return this._newAdded.push(e), this.group.add(e), e;
+    }, f.prototype._setCommon = function(e, n, o) {
+      var t = n.hostModel;
+      e.setShape({
+        polyline: t.get("polyline"),
+        curveness: t.get(["lineStyle", "curveness"])
+      }), e.useStyle(t.getModel("lineStyle").getLineStyle()), e.style.strokeNoScale = !0;
+      var a = n.getVisual("style");
+      a && a.stroke && e.setStyle("stroke", a.stroke), e.setStyle("fill", null);
+      var r = S(e);
+      r.seriesIndex = t.seriesIndex, e.on("mousemove", function(v) {
+        r.dataIndex = null;
+        var s = e.hoverDataIdx;
+        s > 0 && (r.dataIndex = s + e.__startIndex);
+      });
+    }, f.prototype._clear = function() {
+      this._newAdded = [], this.group.removeAll();
+    }, f;
+  })()
+);
+export {
+  W as default
+};

package/dist/node_modules/echarts/lib/chart/helper/LargeSymbolDraw.js

@@ -0,0 +1,143 @@
+import { __extends as g } from "../../../../tslib/tslib.es6.js";
+import { createSymbol as S } from "../../util/symbol.js";
+import { getECData as _ } from "../../util/innerStore.js";
+import y from "../../../../zrender/lib/graphic/Group.js";
+import m from "../../../../zrender/lib/core/BoundingRect.js";
+import I from "../../../../zrender/lib/graphic/Path.js";
+var l = 4, x = (
+  /** @class */
+  /* @__PURE__ */ (function() {
+    function p() {
+    }
+    return p;
+  })()
+), C = (
+  /** @class */
+  (function(p) {
+    g(t, p);
+    function t(r) {
+      var e = p.call(this, r) || this;
+      return e._off = 0, e.hoverDataIdx = -1, e;
+    }
+    return t.prototype.getDefaultShape = function() {
+      return new x();
+    }, t.prototype.reset = function() {
+      this.notClear = !1, this._off = 0;
+    }, t.prototype.buildPath = function(r, e) {
+      var a = e.points, o = e.size, h = this.symbolProxy, i = h.shape, s = r.getContext ? r.getContext() : r, n = s && o[0] < l, u = this.softClipShape, f;
+      if (n) {
+        this._ctx = s;
+        return;
+      }
+      for (this._ctx = null, f = this._off; f < a.length; ) {
+        var v = a[f++], c = a[f++];
+        isNaN(v) || isNaN(c) || u && !u.contain(v, c) || (i.x = v - o[0] / 2, i.y = c - o[1] / 2, i.width = o[0], i.height = o[1], h.buildPath(r, i, !0));
+      }
+      this.incremental && (this._off = f, this.notClear = !0);
+    }, t.prototype.afterBrush = function() {
+      var r = this.shape, e = r.points, a = r.size, o = this._ctx, h = this.softClipShape, i;
+      if (o) {
+        for (i = this._off; i < e.length; ) {
+          var s = e[i++], n = e[i++];
+          isNaN(s) || isNaN(n) || h && !h.contain(s, n) || o.fillRect(s - a[0] / 2, n - a[1] / 2, a[0], a[1]);
+        }
+        this.incremental && (this._off = i, this.notClear = !0);
+      }
+    }, t.prototype.findDataIndex = function(r, e) {
+      for (var a = this.shape, o = a.points, h = a.size, i = Math.max(h[0], 4), s = Math.max(h[1], 4), n = o.length / 2 - 1; n >= 0; n--) {
+        var u = n * 2, f = o[u] - i / 2, v = o[u + 1] - s / 2;
+        if (r >= f && e >= v && r <= f + i && e <= v + s)
+          return n;
+      }
+      return -1;
+    }, t.prototype.contain = function(r, e) {
+      var a = this.transformCoordToLocal(r, e), o = this.getBoundingRect();
+      if (r = a[0], e = a[1], o.contain(r, e)) {
+        var h = this.hoverDataIdx = this.findDataIndex(r, e);
+        return h >= 0;
+      }
+      return this.hoverDataIdx = -1, !1;
+    }, t.prototype.getBoundingRect = function() {
+      var r = this._rect;
+      if (!r) {
+        for (var e = this.shape, a = e.points, o = e.size, h = o[0], i = o[1], s = 1 / 0, n = 1 / 0, u = -1 / 0, f = -1 / 0, v = 0; v < a.length; ) {
+          var c = a[v++], d = a[v++];
+          s = Math.min(c, s), u = Math.max(c, u), n = Math.min(d, n), f = Math.max(d, f);
+        }
+        r = this._rect = new m(s - h / 2, n - i / 2, u - s + h, f - n + i);
+      }
+      return r;
+    }, t;
+  })(I)
+), M = (
+  /** @class */
+  (function() {
+    function p() {
+      this.group = new y();
+    }
+    return p.prototype.updateData = function(t, r) {
+      this._clear();
+      var e = this._create();
+      e.setShape({
+        points: t.getLayout("points")
+      }), this._setCommon(e, t, r);
+    }, p.prototype.updateLayout = function(t) {
+      var r = t.getLayout("points");
+      this.group.eachChild(function(e) {
+        if (e.startIndex != null) {
+          var a = (e.endIndex - e.startIndex) * 2, o = e.startIndex * 4 * 2;
+          r = new Float32Array(r.buffer, o, a);
+        }
+        e.setShape("points", r), e.reset();
+      });
+    }, p.prototype.incrementalPrepareUpdate = function(t) {
+      this._clear();
+    }, p.prototype.incrementalUpdate = function(t, r, e) {
+      var a = this._newAdded[0], o = r.getLayout("points"), h = a && a.shape.points;
+      if (h && h.length < 2e4) {
+        var i = h.length, s = new Float32Array(i + o.length);
+        s.set(h), s.set(o, i), a.endIndex = t.end, a.setShape({
+          points: s
+        });
+      } else {
+        this._newAdded = [];
+        var n = this._create();
+        n.startIndex = t.start, n.endIndex = t.end, n.incremental = !0, n.setShape({
+          points: o
+        }), this._setCommon(n, r, e);
+      }
+    }, p.prototype.eachRendered = function(t) {
+      this._newAdded[0] && t(this._newAdded[0]);
+    }, p.prototype._create = function() {
+      var t = new C({
+        cursor: "default"
+      });
+      return t.ignoreCoarsePointer = !0, this.group.add(t), this._newAdded.push(t), t;
+    }, p.prototype._setCommon = function(t, r, e) {
+      var a = r.hostModel;
+      e = e || {};
+      var o = r.getVisual("symbolSize");
+      t.setShape("size", o instanceof Array ? o : [o, o]), t.softClipShape = e.clipShape || null, t.symbolProxy = S(r.getVisual("symbol"), 0, 0, 0, 0), t.setColor = t.symbolProxy.setColor;
+      var h = t.shape.size[0] < l;
+      t.useStyle(
+        // Draw shadow when doing fillRect is extremely slow.
+        a.getModel("itemStyle").getItemStyle(h ? ["color", "shadowBlur", "shadowColor"] : ["color"])
+      );
+      var i = r.getVisual("style"), s = i && i.fill;
+      s && t.setColor(s);
+      var n = _(t);
+      n.seriesIndex = a.seriesIndex, t.on("mousemove", function(u) {
+        n.dataIndex = null;
+        var f = t.hoverDataIdx;
+        f >= 0 && (n.dataIndex = f + (t.startIndex || 0));
+      });
+    }, p.prototype.remove = function() {
+      this._clear();
+    }, p.prototype._clear = function() {
+      this._newAdded = [], this.group.removeAll();
+    }, p;
+  })()
+);
+export {
+  M as default
+};

package/dist/node_modules/echarts/lib/chart/helper/Line.js

@@ -0,0 +1,208 @@
+import { __extends as K } from "../../../../tslib/tslib.es6.js";
+import { each as E, isArray as Y } from "../../../../zrender/lib/core/util.js";
+import { sub as G, normalize as X } from "../../../../zrender/lib/core/vector.js";
+import { normalizeSymbolSize as C, normalizeSymbolOffset as F, createSymbol as H } from "../../util/symbol.js";
+import U from "./LinePath.js";
+import { SPECIAL_STATES as z, toggleHoverEmphasis as $, enterEmphasis as j, leaveEmphasis as q } from "../../util/states.js";
+import { getLabelStatesModels as J, setLabelStyle as Q } from "../../label/labelStyle.js";
+import { round as W } from "../../util/number.js";
+import Z from "../../../../zrender/lib/graphic/Group.js";
+import { initProps as x, updateProps as D } from "../../animation/basicTransition.js";
+var R = ["fromSymbol", "toSymbol"];
+function w(a) {
+  return "_" + a + "Type";
+}
+function V(a, r, t) {
+  var o = r.getItemVisual(t, a);
+  if (!o || o === "none")
+    return o;
+  var i = r.getItemVisual(t, a + "Size"), e = r.getItemVisual(t, a + "Rotate"), l = r.getItemVisual(t, a + "Offset"), f = r.getItemVisual(t, a + "KeepAspect"), s = C(i), n = F(l || 0, s);
+  return o + s + n + (e || "") + (f || "");
+}
+function B(a, r, t) {
+  var o = r.getItemVisual(t, a);
+  if (!(!o || o === "none")) {
+    var i = r.getItemVisual(t, a + "Size"), e = r.getItemVisual(t, a + "Rotate"), l = r.getItemVisual(t, a + "Offset"), f = r.getItemVisual(t, a + "KeepAspect"), s = C(i), n = F(l || 0, s), v = H(o, -s[0] / 2 + n[0], -s[1] / 2 + n[1], s[0], s[1], null, f);
+    return v.__specifiedRotation = e == null || isNaN(e) ? void 0 : +e * Math.PI / 180 || 0, v.name = a, v;
+  }
+}
+function ee(a) {
+  var r = new U({
+    name: "line",
+    subPixelOptimize: !0
+  });
+  return A(r.shape, a), r;
+}
+function A(a, r) {
+  a.x1 = r[0][0], a.y1 = r[0][1], a.x2 = r[1][0], a.y2 = r[1][1], a.percent = 1;
+  var t = r[2];
+  t ? (a.cpx1 = t[0], a.cpy1 = t[1]) : (a.cpx1 = NaN, a.cpy1 = NaN);
+}
+var ve = (
+  /** @class */
+  (function(a) {
+    K(r, a);
+    function r(t, o, i) {
+      var e = a.call(this) || this;
+      return e._createLine(t, o, i), e;
+    }
+    return r.prototype._createLine = function(t, o, i) {
+      var e = t.hostModel, l = t.getItemLayout(o), f = ee(l);
+      f.shape.percent = 0, x(f, {
+        shape: {
+          percent: 1
+        }
+      }, e, o), this.add(f), E(R, function(s) {
+        var n = B(s, t, o);
+        this.add(n), this[w(s)] = V(s, t, o);
+      }, this), this._updateCommonStl(t, o, i);
+    }, r.prototype.updateData = function(t, o, i) {
+      var e = t.hostModel, l = this.childOfName("line"), f = t.getItemLayout(o), s = {
+        shape: {}
+      };
+      A(s.shape, f), D(l, s, e, o), E(R, function(n) {
+        var v = V(n, t, o), u = w(n);
+        if (this[u] !== v) {
+          this.remove(this.childOfName(n));
+          var m = B(n, t, o);
+          this.add(m);
+        }
+        this[u] = v;
+      }, this), this._updateCommonStl(t, o, i);
+    }, r.prototype.getLinePath = function() {
+      return this.childAt(0);
+    }, r.prototype._updateCommonStl = function(t, o, i) {
+      var e = t.hostModel, l = this.childOfName("line"), f = i && i.emphasisLineStyle, s = i && i.blurLineStyle, n = i && i.selectLineStyle, v = i && i.labelStatesModels, u = i && i.emphasisDisabled, m = i && i.focus, k = i && i.blurScope;
+      if (!i || t.hasItemOption) {
+        var c = t.getItemModel(o), h = c.getModel("emphasis");
+        f = h.getModel("lineStyle").getLineStyle(), s = c.getModel(["blur", "lineStyle"]).getLineStyle(), n = c.getModel(["select", "lineStyle"]).getLineStyle(), u = h.get("disabled"), m = h.get("focus"), k = h.get("blurScope"), v = J(c);
+      }
+      var L = t.getItemVisual(o, "style"), g = L.stroke;
+      l.useStyle(L), l.style.fill = null, l.style.strokeNoScale = !0, l.ensureState("emphasis").style = f, l.ensureState("blur").style = s, l.ensureState("select").style = n, E(R, function(O) {
+        var p = this.childOfName(O);
+        if (p) {
+          p.setColor(g), p.style.opacity = L.opacity;
+          for (var I = 0; I < z.length; I++) {
+            var y = z[I], P = l.getState(y);
+            if (P) {
+              var T = P.style || {}, M = p.ensureState(y), N = M.style || (M.style = {});
+              T.stroke != null && (N[p.__isEmptyBrush ? "stroke" : "fill"] = T.stroke), T.opacity != null && (N.opacity = T.opacity);
+            }
+          }
+          p.markRedraw();
+        }
+      }, this);
+      var S = e.getRawValue(o);
+      Q(this, v, {
+        labelDataIndex: o,
+        labelFetcher: {
+          getFormattedLabel: function(O, p) {
+            return e.getFormattedLabel(O, p, t.dataType);
+          }
+        },
+        inheritColor: g || "#000",
+        defaultOpacity: L.opacity,
+        defaultText: (S == null ? t.getName(o) : isFinite(S) ? W(S) : S) + ""
+      });
+      var b = this.getTextContent();
+      if (b) {
+        var _ = v.normal;
+        b.__align = b.style.align, b.__verticalAlign = b.style.verticalAlign, b.__position = _.get("position") || "middle";
+        var d = _.get("distance");
+        Y(d) || (d = [d, d]), b.__labelDistance = d;
+      }
+      this.setTextConfig({
+        position: null,
+        local: !0,
+        inside: !1
+        // Can't be inside for stroke element.
+      }), $(this, m, k, u);
+    }, r.prototype.highlight = function() {
+      j(this);
+    }, r.prototype.downplay = function() {
+      q(this);
+    }, r.prototype.updateLayout = function(t, o) {
+      this.setLinePoints(t.getItemLayout(o));
+    }, r.prototype.setLinePoints = function(t) {
+      var o = this.childOfName("line");
+      A(o.shape, t), o.dirty();
+    }, r.prototype.beforeUpdate = function() {
+      var t = this, o = t.childOfName("fromSymbol"), i = t.childOfName("toSymbol"), e = t.getTextContent();
+      if (!o && !i && (!e || e.ignore))
+        return;
+      for (var l = 1, f = this.parent; f; )
+        f.scaleX && (l /= f.scaleX), f = f.parent;
+      var s = t.childOfName("line");
+      if (!this.__dirty && !s.__dirty)
+        return;
+      var n = s.shape.percent, v = s.pointAt(0), u = s.pointAt(n), m = G([], u, v);
+      X(m, m);
+      function k(P, T) {
+        var M = P.__specifiedRotation;
+        if (M == null) {
+          var N = s.tangentAt(T);
+          P.attr("rotation", (T === 1 ? -1 : 1) * Math.PI / 2 - Math.atan2(N[1], N[0]));
+        } else
+          P.attr("rotation", M);
+      }
+      if (o && (o.setPosition(v), k(o, 0), o.scaleX = o.scaleY = l * n, o.markRedraw()), i && (i.setPosition(u), k(i, 1), i.scaleX = i.scaleY = l * n, i.markRedraw()), e && !e.ignore) {
+        e.x = e.y = 0, e.originX = e.originY = 0;
+        var c = void 0, h = void 0, L = e.__labelDistance, g = L[0] * l, S = L[1] * l, b = n / 2, _ = s.tangentAt(b), d = [_[1], -_[0]], O = s.pointAt(b);
+        d[1] > 0 && (d[0] = -d[0], d[1] = -d[1]);
+        var p = _[0] < 0 ? -1 : 1;
+        if (e.__position !== "start" && e.__position !== "end") {
+          var I = -Math.atan2(_[1], _[0]);
+          u[0] < v[0] && (I = Math.PI + I), e.rotation = I;
+        }
+        var y = void 0;
+        switch (e.__position) {
+          case "insideStartTop":
+          case "insideMiddleTop":
+          case "insideEndTop":
+          case "middle":
+            y = -S, h = "bottom";
+            break;
+          case "insideStartBottom":
+          case "insideMiddleBottom":
+          case "insideEndBottom":
+            y = S, h = "top";
+            break;
+          default:
+            y = 0, h = "middle";
+        }
+        switch (e.__position) {
+          case "end":
+            e.x = m[0] * g + u[0], e.y = m[1] * S + u[1], c = m[0] > 0.8 ? "left" : m[0] < -0.8 ? "right" : "center", h = m[1] > 0.8 ? "top" : m[1] < -0.8 ? "bottom" : "middle";
+            break;
+          case "start":
+            e.x = -m[0] * g + v[0], e.y = -m[1] * S + v[1], c = m[0] > 0.8 ? "right" : m[0] < -0.8 ? "left" : "center", h = m[1] > 0.8 ? "bottom" : m[1] < -0.8 ? "top" : "middle";
+            break;
+          case "insideStartTop":
+          case "insideStart":
+          case "insideStartBottom":
+            e.x = g * p + v[0], e.y = v[1] + y, c = _[0] < 0 ? "right" : "left", e.originX = -g * p, e.originY = -y;
+            break;
+          case "insideMiddleTop":
+          case "insideMiddle":
+          case "insideMiddleBottom":
+          case "middle":
+            e.x = O[0], e.y = O[1] + y, c = "center", e.originY = -y;
+            break;
+          case "insideEndTop":
+          case "insideEnd":
+          case "insideEndBottom":
+            e.x = -g * p + u[0], e.y = u[1] + y, c = _[0] >= 0 ? "right" : "left", e.originX = g * p, e.originY = -y;
+            break;
+        }
+        e.scaleX = e.scaleY = l, e.setStyle({
+          // Use the user specified text align and baseline first
+          verticalAlign: e.__verticalAlign || h,
+          align: e.__align || c
+        });
+      }
+    }, r;
+  })(Z)
+);
+export {
+  ve as default
+};

package/dist/node_modules/echarts/lib/chart/helper/LineDraw.js

@@ -0,0 +1,87 @@
+import { traverseElements as h } from "../../util/graphic.js";
+import d from "./Line.js";
+import { getLabelStatesModels as f } from "../../label/labelStyle.js";
+import m from "../../../../zrender/lib/graphic/Group.js";
+var _ = (
+  /** @class */
+  (function() {
+    function r(e) {
+      this.group = new m(), this._LineCtor = e || d;
+    }
+    return r.prototype.updateData = function(e) {
+      var t = this;
+      this._progressiveEls = null;
+      var s = this, o = s.group, n = s._lineData;
+      s._lineData = e, n || o.removeAll();
+      var i = p(e);
+      e.diff(n).add(function(a) {
+        t._doAdd(e, a, i);
+      }).update(function(a, c) {
+        t._doUpdate(n, e, c, a, i);
+      }).remove(function(a) {
+        o.remove(n.getItemGraphicEl(a));
+      }).execute();
+    }, r.prototype.updateLayout = function() {
+      var e = this._lineData;
+      e && e.eachItemGraphicEl(function(t, s) {
+        t.updateLayout(e, s);
+      }, this);
+    }, r.prototype.incrementalPrepareUpdate = function(e) {
+      this._seriesScope = p(e), this._lineData = null, this.group.removeAll();
+    }, r.prototype.incrementalUpdate = function(e, t) {
+      this._progressiveEls = [];
+      function s(a) {
+        !a.isGroup && !g(a) && (a.incremental = !0, a.ensureState("emphasis").hoverLayer = !0);
+      }
+      for (var o = e.start; o < e.end; o++) {
+        var n = t.getItemLayout(o);
+        if (u(n)) {
+          var i = new this._LineCtor(t, o, this._seriesScope);
+          i.traverse(s), this.group.add(i), t.setItemGraphicEl(o, i), this._progressiveEls.push(i);
+        }
+      }
+    }, r.prototype.remove = function() {
+      this.group.removeAll();
+    }, r.prototype.eachRendered = function(e) {
+      h(this._progressiveEls || this.group, e);
+    }, r.prototype._doAdd = function(e, t, s) {
+      var o = e.getItemLayout(t);
+      if (u(o)) {
+        var n = new this._LineCtor(e, t, s);
+        e.setItemGraphicEl(t, n), this.group.add(n);
+      }
+    }, r.prototype._doUpdate = function(e, t, s, o, n) {
+      var i = e.getItemGraphicEl(s);
+      if (!u(t.getItemLayout(o))) {
+        this.group.remove(i);
+        return;
+      }
+      i ? i.updateData(t, o, n) : i = new this._LineCtor(t, o, n), t.setItemGraphicEl(o, i), this.group.add(i);
+    }, r;
+  })()
+);
+function g(r) {
+  return r.animators && r.animators.length > 0;
+}
+function p(r) {
+  var e = r.hostModel, t = e.getModel("emphasis");
+  return {
+    lineStyle: e.getModel("lineStyle").getLineStyle(),
+    emphasisLineStyle: t.getModel(["lineStyle"]).getLineStyle(),
+    blurLineStyle: e.getModel(["blur", "lineStyle"]).getLineStyle(),
+    selectLineStyle: e.getModel(["select", "lineStyle"]).getLineStyle(),
+    emphasisDisabled: t.get("disabled"),
+    blurScope: t.get("blurScope"),
+    focus: t.get("focus"),
+    labelStatesModels: f(e)
+  };
+}
+function l(r) {
+  return isNaN(r[0]) || isNaN(r[1]);
+}
+function u(r) {
+  return r && !l(r[0]) && !l(r[1]);
+}
+export {
+  _ as default
+};

package/dist/node_modules/echarts/lib/chart/helper/LinePath.js

@@ -0,0 +1,52 @@
+import { __extends as h } from "../../../../tslib/tslib.es6.js";
+import { normalize as l } from "../../../../zrender/lib/core/vector.js";
+import s from "../../../../zrender/lib/graphic/shape/Line.js";
+import f from "../../../../zrender/lib/graphic/shape/BezierCurve.js";
+import c from "../../../../zrender/lib/graphic/Path.js";
+var u = s.prototype, n = f.prototype, p = (
+  /** @class */
+  /* @__PURE__ */ (function() {
+    function i() {
+      this.x1 = 0, this.y1 = 0, this.x2 = 0, this.y2 = 0, this.percent = 1;
+    }
+    return i;
+  })()
+);
+(function(i) {
+  h(r, i);
+  function r() {
+    return i !== null && i.apply(this, arguments) || this;
+  }
+  return r;
+})(p);
+function o(i) {
+  return isNaN(+i.cpx1) || isNaN(+i.cpy1);
+}
+var S = (
+  /** @class */
+  (function(i) {
+    h(r, i);
+    function r(e) {
+      var t = i.call(this, e) || this;
+      return t.type = "ec-line", t;
+    }
+    return r.prototype.getDefaultStyle = function() {
+      return {
+        stroke: "#000",
+        fill: null
+      };
+    }, r.prototype.getDefaultShape = function() {
+      return new p();
+    }, r.prototype.buildPath = function(e, t) {
+      o(t) ? u.buildPath.call(this, e, t) : n.buildPath.call(this, e, t);
+    }, r.prototype.pointAt = function(e) {
+      return o(this.shape) ? u.pointAt.call(this, e) : n.pointAt.call(this, e);
+    }, r.prototype.tangentAt = function(e) {
+      var t = this.shape, a = o(t) ? [t.x2 - t.x1, t.y2 - t.y1] : n.tangentAt.call(this, e);
+      return l(a, a);
+    }, r;
+  })(c)
+);
+export {
+  S as default
+};