mixdashboards 1.0.32 → 1.0.39

package/dist/installCanvasRenderer-CLT2hquJ.js

@@ -0,0 +1,4260 @@
+import { l as vt, h as S, S as Vt, V as fe, o as at, x as F, T as V, U as Ut, r as ct, W as yr, j as R, q as we, X as bi, Y as xr, $ as wr, a0 as Oe, a1 as br, a2 as Sr, a3 as jt, f as H, O as X, a4 as be, M as ut, a5 as Mr, B as W, a6 as Cr, P as Ct, a7 as Dr, a8 as Tr, a9 as Ir, aa as Pe, u as nt, ab as Lr, ac as Ar, ad as Or, ae as Se, af as Si, ag as it, ah as Mi, _ as K, ai as Pr, aj as Er, ak as ht, al as Ci, am as Ee, an as kr, ao as bt, ap as Nr, aq as Z, ar as Di, as as Ti, at as Ft, au as ke, av as ve, aw as Rr, ax as Br, ay as Hr, s as Ne, az as Ii, aA as Li, aB as Ai, aC as Oi, aD as Pi, aE as Ei, aF as Re, aG as Fr, aH as zr, aI as Wr, aJ as Vr, aK as Gr, aL as Yr, aM as Xr, aN as Ur, aO as Zr, aP as Be, aQ as de, aR as pt, t as Zt, aS as He, aT as Fe, b as Dt, C as St, aU as Kr, aV as $r, aW as qr, aX as Qr, aY as Jr, aZ as jr, a_ as tn, a$ as en, b0 as rn, b1 as nn, b2 as an, b3 as on, b4 as sn, b5 as ln, b6 as un, b7 as ce, b8 as Tt, b9 as hn, ba as fn, G as pe, Z as Kt, c as Me, D as ki, g as Q, bb as Gt, bc as Ni, bd as Ri, be as vn, H as dn, bf as Bi, bg as cn, bh as Hi, bi as ze, bj as Yt, E as rt, bk as pn, N as gn, bl as mn, bm as Fi, bn as ge, Q as _n, bo as yn, bp as xn, n as zi, bq as wn, br as bn, bs as z, bt as Sn, bu as Wi, bv as We, bw as Mn, bx as Cn, by as Xt, bz as Vi, bA as Dn, bB as Tn, R as In, bC as Ln, bD as Ve, bE as An, bF as te, bG as Ge, bH as Ye, bI as On, bJ as Pn, a as En, bK as kn, bL as Nn, bM as Xe, bN as Gi, bO as me, bP as Rn, bQ as Yi, bR as Bn, bS as Hn, bT as Fn, bU as zn, bV as Wn, bW as At, bX as Vn, bY as Gn, m as Ot, bZ as ee, b_ as Pt } from "./echarts-BVht3HHb.js";
+function mt(r) {
+  return r == null ? 0 : r.length || 1;
+}
+function Ue(r) {
+  return r;
+}
+var Yn = (
+  /** @class */
+  (function() {
+    function r(t, e, i, n, a, o) {
+      this._old = t, this._new = e, this._oldKeyGetter = i || Ue, this._newKeyGetter = n || Ue, this.context = a, this._diffModeMultiple = o === "multiple";
+    }
+    return r.prototype.add = function(t) {
+      return this._add = t, this;
+    }, r.prototype.update = function(t) {
+      return this._update = t, this;
+    }, r.prototype.updateManyToOne = function(t) {
+      return this._updateManyToOne = t, this;
+    }, r.prototype.updateOneToMany = function(t) {
+      return this._updateOneToMany = t, this;
+    }, r.prototype.updateManyToMany = function(t) {
+      return this._updateManyToMany = t, this;
+    }, r.prototype.remove = function(t) {
+      return this._remove = t, this;
+    }, r.prototype.execute = function() {
+      this[this._diffModeMultiple ? "_executeMultiple" : "_executeOneToOne"]();
+    }, r.prototype._executeOneToOne = function() {
+      var t = this._old, e = this._new, i = {}, n = new Array(t.length), a = new Array(e.length);
+      this._initIndexMap(t, null, n, "_oldKeyGetter"), this._initIndexMap(e, i, a, "_newKeyGetter");
+      for (var o = 0; o < t.length; o++) {
+        var s = n[o], l = i[s], u = mt(l);
+        if (u > 1) {
+          var h = l.shift();
+          l.length === 1 && (i[s] = l[0]), this._update && this._update(h, o);
+        } else u === 1 ? (i[s] = null, this._update && this._update(l, o)) : this._remove && this._remove(o);
+      }
+      this._performRestAdd(a, i);
+    }, r.prototype._executeMultiple = function() {
+      var t = this._old, e = this._new, i = {}, n = {}, a = [], o = [];
+      this._initIndexMap(t, i, a, "_oldKeyGetter"), this._initIndexMap(e, n, o, "_newKeyGetter");
+      for (var s = 0; s < a.length; s++) {
+        var l = a[s], u = i[l], h = n[l], f = mt(u), v = mt(h);
+        if (f > 1 && v === 1)
+          this._updateManyToOne && this._updateManyToOne(h, u), n[l] = null;
+        else if (f === 1 && v > 1)
+          this._updateOneToMany && this._updateOneToMany(h, u), n[l] = null;
+        else if (f === 1 && v === 1)
+          this._update && this._update(h, u), n[l] = null;
+        else if (f > 1 && v > 1)
+          this._updateManyToMany && this._updateManyToMany(h, u), n[l] = null;
+        else if (f > 1)
+          for (var d = 0; d < f; d++)
+            this._remove && this._remove(u[d]);
+        else
+          this._remove && this._remove(u);
+      }
+      this._performRestAdd(o, n);
+    }, r.prototype._performRestAdd = function(t, e) {
+      for (var i = 0; i < t.length; i++) {
+        var n = t[i], a = e[n], o = mt(a);
+        if (o > 1)
+          for (var s = 0; s < o; s++)
+            this._add && this._add(a[s]);
+        else o === 1 && this._add && this._add(a);
+        e[n] = null;
+      }
+    }, r.prototype._initIndexMap = function(t, e, i, n) {
+      for (var a = this._diffModeMultiple, o = 0; o < t.length; o++) {
+        var s = "_ec_" + this[n](t[o], o);
+        if (a || (i[o] = s), !!e) {
+          var l = e[s], u = mt(l);
+          u === 0 ? (e[s] = o, a && i.push(s)) : u === 1 ? e[s] = [l, o] : l.push(o);
+        }
+      }
+    }, r;
+  })()
+), Xn = (
+  /** @class */
+  (function() {
+    function r(t, e) {
+      this._encode = t, this._schema = e;
+    }
+    return r.prototype.get = function() {
+      return {
+        // Do not generate full dimension name until fist used.
+        fullDimensions: this._getFullDimensionNames(),
+        encode: this._encode
+      };
+    }, r.prototype._getFullDimensionNames = function() {
+      return this._cachedDimNames || (this._cachedDimNames = this._schema ? this._schema.makeOutputDimensionNames() : []), this._cachedDimNames;
+    }, r;
+  })()
+);
+function Un(r, t) {
+  var e = {}, i = e.encode = {}, n = vt(), a = [], o = [], s = {};
+  S(r.dimensions, function(v) {
+    var d = r.getDimensionInfo(v), c = d.coordDim;
+    if (c) {
+      process.env.NODE_ENV !== "production" && Vt(fe.get(c) == null);
+      var g = d.coordDimIndex;
+      ie(i, c)[g] = v, d.isExtraCoord || (n.set(c, 1), Zn(d.type) && (a[0] = v), ie(s, c)[g] = r.getDimensionIndex(d.name)), d.defaultTooltip && o.push(v);
+    }
+    fe.each(function(m, p) {
+      var _ = ie(i, p), y = d.otherDims[p];
+      y != null && y !== !1 && (_[y] = d.name);
+    });
+  });
+  var l = [], u = {};
+  n.each(function(v, d) {
+    var c = i[d];
+    u[d] = c[0], l = l.concat(c);
+  }), e.dataDimsOnCoord = l, e.dataDimIndicesOnCoord = at(l, function(v) {
+    return r.getDimensionInfo(v).storeDimIndex;
+  }), e.encodeFirstDimNotExtra = u;
+  var h = i.label;
+  h && h.length && (a = h.slice());
+  var f = i.tooltip;
+  return f && f.length ? o = f.slice() : o.length || (o = a.slice()), i.defaultedLabel = a, i.defaultedTooltip = o, e.userOutput = new Xn(s, t), e;
+}
+function ie(r, t) {
+  return r.hasOwnProperty(t) || (r[t] = []), r[t];
+}
+function Zo(r) {
+  return r === "category" ? "ordinal" : r === "time" ? "time" : "float";
+}
+function Zn(r) {
+  return !(r === "ordinal" || r === "time");
+}
+var zt = (
+  /** @class */
+  /* @__PURE__ */ (function() {
+    function r(t) {
+      this.otherDims = {}, t != null && F(this, t);
+    }
+    return r;
+  })()
+), Kn = Ut(), $n = {
+  float: "f",
+  int: "i",
+  ordinal: "o",
+  number: "n",
+  time: "t"
+}, Xi = (
+  /** @class */
+  (function() {
+    function r(t) {
+      this.dimensions = t.dimensions, this._dimOmitted = t.dimensionOmitted, this.source = t.source, this._fullDimCount = t.fullDimensionCount, this._updateDimOmitted(t.dimensionOmitted);
+    }
+    return r.prototype.isDimensionOmitted = function() {
+      return this._dimOmitted;
+    }, r.prototype._updateDimOmitted = function(t) {
+      this._dimOmitted = t, t && (this._dimNameMap || (this._dimNameMap = Ki(this.source)));
+    }, r.prototype.getSourceDimensionIndex = function(t) {
+      return ct(this._dimNameMap.get(t), -1);
+    }, r.prototype.getSourceDimension = function(t) {
+      var e = this.source.dimensionsDefine;
+      if (e)
+        return e[t];
+    }, r.prototype.makeStoreSchema = function() {
+      for (var t = this._fullDimCount, e = yr(this.source), i = !$i(t), n = "", a = [], o = 0, s = 0; o < t; o++) {
+        var l = void 0, u = void 0, h = void 0, f = this.dimensions[s];
+        if (f && f.storeDimIndex === o)
+          l = e ? f.name : null, u = f.type, h = f.ordinalMeta, s++;
+        else {
+          var v = this.getSourceDimension(o);
+          v && (l = e ? v.name : null, u = v.type);
+        }
+        a.push({
+          property: l,
+          type: u,
+          ordinalMeta: h
+        }), e && l != null && (!f || !f.isCalculationCoord) && (n += i ? l.replace(/\`/g, "`1").replace(/\$/g, "`2") : l), n += "$", n += $n[u] || "f", h && (n += h.uid), n += "$";
+      }
+      var d = this.source, c = [d.seriesLayoutBy, d.startIndex, n].join("$$");
+      return {
+        dimensions: a,
+        hash: c
+      };
+    }, r.prototype.makeOutputDimensionNames = function() {
+      for (var t = [], e = 0, i = 0; e < this._fullDimCount; e++) {
+        var n = void 0, a = this.dimensions[i];
+        if (a && a.storeDimIndex === e)
+          a.isCalculationCoord || (n = a.name), i++;
+        else {
+          var o = this.getSourceDimension(e);
+          o && (n = o.name);
+        }
+        t.push(n);
+      }
+      return t;
+    }, r.prototype.appendCalculationDimension = function(t) {
+      this.dimensions.push(t), t.isCalculationCoord = !0, this._fullDimCount++, this._updateDimOmitted(!0);
+    }, r;
+  })()
+);
+function Ui(r) {
+  return r instanceof Xi;
+}
+function Zi(r) {
+  for (var t = vt(), e = 0; e < (r || []).length; e++) {
+    var i = r[e], n = V(i) ? i.name : i;
+    n != null && t.get(n) == null && t.set(n, e);
+  }
+  return t;
+}
+function Ki(r) {
+  var t = Kn(r);
+  return t.dimNameMap || (t.dimNameMap = Zi(r.dimensionsDefine));
+}
+function $i(r) {
+  return r > 30;
+}
+var _t = V, j = at, qn = typeof Int32Array == "undefined" ? Array : Int32Array, Qn = "e\0\0", Ze = -1, Jn = ["hasItemOption", "_nameList", "_idList", "_invertedIndicesMap", "_dimSummary", "userOutput", "_rawData", "_dimValueGetter", "_nameDimIdx", "_idDimIdx", "_nameRepeatCount"], jn = ["_approximateExtent"], Ke, Et, yt, dt, re, xt, ne, Ko = (
+  /** @class */
+  (function() {
+    function r(t, e) {
+      this.type = "list", this._dimOmitted = !1, this._nameList = [], this._idList = [], this._visual = {}, this._layout = {}, this._itemVisuals = [], this._itemLayouts = [], this._graphicEls = [], this._approximateExtent = {}, this._calculationInfo = {}, this.hasItemOption = !1, this.TRANSFERABLE_METHODS = ["cloneShallow", "downSample", "minmaxDownSample", "lttbDownSample", "map"], this.CHANGABLE_METHODS = ["filterSelf", "selectRange"], this.DOWNSAMPLE_METHODS = ["downSample", "minmaxDownSample", "lttbDownSample"];
+      var i, n = !1;
+      Ui(t) ? (i = t.dimensions, this._dimOmitted = t.isDimensionOmitted(), this._schema = t) : (n = !0, i = t), i = i || ["x", "y"];
+      for (var a = {}, o = [], s = {}, l = !1, u = {}, h = 0; h < i.length; h++) {
+        var f = i[h], v = R(f) ? new zt({
+          name: f
+        }) : f instanceof zt ? f : new zt(f), d = v.name;
+        v.type = v.type || "float", v.coordDim || (v.coordDim = d, v.coordDimIndex = 0);
+        var c = v.otherDims = v.otherDims || {};
+        o.push(d), a[d] = v, u[d] != null && (l = !0), v.createInvertedIndices && (s[d] = []), c.itemName === 0 && (this._nameDimIdx = h), c.itemId === 0 && (this._idDimIdx = h), process.env.NODE_ENV !== "production" && Vt(n || v.storeDimIndex >= 0), n && (v.storeDimIndex = h);
+      }
+      if (this.dimensions = o, this._dimInfos = a, this._initGetDimensionInfo(l), this.hostModel = e, this._invertedIndicesMap = s, this._dimOmitted) {
+        var g = this._dimIdxToName = vt();
+        S(o, function(m) {
+          g.set(a[m].storeDimIndex, m);
+        });
+      }
+    }
+    return r.prototype.getDimension = function(t) {
+      var e = this._recognizeDimIndex(t);
+      if (e == null)
+        return t;
+      if (e = t, !this._dimOmitted)
+        return this.dimensions[e];
+      var i = this._dimIdxToName.get(e);
+      if (i != null)
+        return i;
+      var n = this._schema.getSourceDimension(e);
+      if (n)
+        return n.name;
+    }, r.prototype.getDimensionIndex = function(t) {
+      var e = this._recognizeDimIndex(t);
+      if (e != null)
+        return e;
+      if (t == null)
+        return -1;
+      var i = this._getDimInfo(t);
+      return i ? i.storeDimIndex : this._dimOmitted ? this._schema.getSourceDimensionIndex(t) : -1;
+    }, r.prototype._recognizeDimIndex = function(t) {
+      if (we(t) || t != null && !isNaN(t) && !this._getDimInfo(t) && (!this._dimOmitted || this._schema.getSourceDimensionIndex(t) < 0))
+        return +t;
+    }, r.prototype._getStoreDimIndex = function(t) {
+      var e = this.getDimensionIndex(t);
+      if (process.env.NODE_ENV !== "production" && e == null)
+        throw new Error("Unknown dimension " + t);
+      return e;
+    }, r.prototype.getDimensionInfo = function(t) {
+      return this._getDimInfo(this.getDimension(t));
+    }, r.prototype._initGetDimensionInfo = function(t) {
+      var e = this._dimInfos;
+      this._getDimInfo = t ? function(i) {
+        return e.hasOwnProperty(i) ? e[i] : void 0;
+      } : function(i) {
+        return e[i];
+      };
+    }, r.prototype.getDimensionsOnCoord = function() {
+      return this._dimSummary.dataDimsOnCoord.slice();
+    }, r.prototype.mapDimension = function(t, e) {
+      var i = this._dimSummary;
+      if (e == null)
+        return i.encodeFirstDimNotExtra[t];
+      var n = i.encode[t];
+      return n ? n[e] : null;
+    }, r.prototype.mapDimensionsAll = function(t) {
+      var e = this._dimSummary, i = e.encode[t];
+      return (i || []).slice();
+    }, r.prototype.getStore = function() {
+      return this._store;
+    }, r.prototype.initData = function(t, e, i) {
+      var n = this, a;
+      if (t instanceof Oe && (a = t), !a) {
+        var o = this.dimensions, s = bi(t) || xr(t) ? new wr(t, o.length) : t;
+        a = new Oe();
+        var l = j(o, function(u) {
+          return {
+            type: n._dimInfos[u].type,
+            property: u
+          };
+        });
+        a.initData(s, l, i);
+      }
+      this._store = a, this._nameList = (e || []).slice(), this._idList = [], this._nameRepeatCount = {}, this._doInit(0, a.count()), this._dimSummary = Un(this, this._schema), this.userOutput = this._dimSummary.userOutput;
+    }, r.prototype.appendData = function(t) {
+      var e = this._store.appendData(t);
+      this._doInit(e[0], e[1]);
+    }, r.prototype.appendValues = function(t, e) {
+      var i = this._store.appendValues(t, e && e.length), n = i.start, a = i.end, o = this._shouldMakeIdFromName();
+      if (this._updateOrdinalMeta(), e)
+        for (var s = n; s < a; s++) {
+          var l = s - n;
+          this._nameList[s] = e[l], o && ne(this, s);
+        }
+    }, r.prototype._updateOrdinalMeta = function() {
+      for (var t = this._store, e = this.dimensions, i = 0; i < e.length; i++) {
+        var n = this._dimInfos[e[i]];
+        n.ordinalMeta && t.collectOrdinalMeta(n.storeDimIndex, n.ordinalMeta);
+      }
+    }, r.prototype._shouldMakeIdFromName = function() {
+      var t = this._store.getProvider();
+      return this._idDimIdx == null && t.getSource().sourceFormat !== br && !t.fillStorage;
+    }, r.prototype._doInit = function(t, e) {
+      if (!(t >= e)) {
+        var i = this._store, n = i.getProvider();
+        this._updateOrdinalMeta();
+        var a = this._nameList, o = this._idList, s = n.getSource().sourceFormat, l = s === Dr;
+        if (l && !n.pure)
+          for (var u = [], h = t; h < e; h++) {
+            var f = n.getItem(h, u);
+            if (!this.hasItemOption && Sr(f) && (this.hasItemOption = !0), f) {
+              var v = f.name;
+              a[h] == null && v != null && (a[h] = jt(v, null));
+              var d = f.id;
+              o[h] == null && d != null && (o[h] = jt(d, null));
+            }
+          }
+        if (this._shouldMakeIdFromName())
+          for (var h = t; h < e; h++)
+            ne(this, h);
+        Ke(this);
+      }
+    }, r.prototype.getApproximateExtent = function(t) {
+      return this._approximateExtent[t] || this._store.getDataExtent(this._getStoreDimIndex(t));
+    }, r.prototype.setApproximateExtent = function(t, e) {
+      e = this.getDimension(e), this._approximateExtent[e] = t.slice();
+    }, r.prototype.getCalculationInfo = function(t) {
+      return this._calculationInfo[t];
+    }, r.prototype.setCalculationInfo = function(t, e) {
+      _t(t) ? F(this._calculationInfo, t) : this._calculationInfo[t] = e;
+    }, r.prototype.getName = function(t) {
+      var e = this.getRawIndex(t), i = this._nameList[e];
+      return i == null && this._nameDimIdx != null && (i = yt(this, this._nameDimIdx, e)), i == null && (i = ""), i;
+    }, r.prototype._getCategory = function(t, e) {
+      var i = this._store.get(t, e), n = this._store.getOrdinalMeta(t);
+      return n ? n.categories[i] : i;
+    }, r.prototype.getId = function(t) {
+      return Et(this, this.getRawIndex(t));
+    }, r.prototype.count = function() {
+      return this._store.count();
+    }, r.prototype.get = function(t, e) {
+      var i = this._store, n = this._dimInfos[t];
+      if (n)
+        return i.get(n.storeDimIndex, e);
+    }, r.prototype.getByRawIndex = function(t, e) {
+      var i = this._store, n = this._dimInfos[t];
+      if (n)
+        return i.getByRawIndex(n.storeDimIndex, e);
+    }, r.prototype.getIndices = function() {
+      return this._store.getIndices();
+    }, r.prototype.getDataExtent = function(t) {
+      return this._store.getDataExtent(this._getStoreDimIndex(t));
+    }, r.prototype.getSum = function(t) {
+      return this._store.getSum(this._getStoreDimIndex(t));
+    }, r.prototype.getMedian = function(t) {
+      return this._store.getMedian(this._getStoreDimIndex(t));
+    }, r.prototype.getValues = function(t, e) {
+      var i = this, n = this._store;
+      return H(t) ? n.getValues(j(t, function(a) {
+        return i._getStoreDimIndex(a);
+      }), e) : n.getValues(t);
+    }, r.prototype.hasValue = function(t) {
+      for (var e = this._dimSummary.dataDimIndicesOnCoord, i = 0, n = e.length; i < n; i++)
+        if (isNaN(this._store.get(e[i], t)))
+          return !1;
+      return !0;
+    }, r.prototype.indexOfName = function(t) {
+      for (var e = 0, i = this._store.count(); e < i; e++)
+        if (this.getName(e) === t)
+          return e;
+      return -1;
+    }, r.prototype.getRawIndex = function(t) {
+      return this._store.getRawIndex(t);
+    }, r.prototype.indexOfRawIndex = function(t) {
+      return this._store.indexOfRawIndex(t);
+    }, r.prototype.rawIndexOf = function(t, e) {
+      var i = t && this._invertedIndicesMap[t];
+      if (process.env.NODE_ENV !== "production" && !i)
+        throw new Error("Do not supported yet");
+      var n = i && i[e];
+      return n == null || isNaN(n) ? Ze : n;
+    }, r.prototype.indicesOfNearest = function(t, e, i) {
+      return this._store.indicesOfNearest(this._getStoreDimIndex(t), e, i);
+    }, r.prototype.each = function(t, e, i) {
+      W(t) && (i = e, e = t, t = []);
+      var n = i || this, a = j(dt(t), this._getStoreDimIndex, this);
+      this._store.each(a, n ? X(e, n) : e);
+    }, r.prototype.filterSelf = function(t, e, i) {
+      W(t) && (i = e, e = t, t = []);
+      var n = i || this, a = j(dt(t), this._getStoreDimIndex, this);
+      return this._store = this._store.filter(a, n ? X(e, n) : e), this;
+    }, r.prototype.selectRange = function(t) {
+      var e = this, i = {}, n = be(t);
+      return S(n, function(a) {
+        var o = e._getStoreDimIndex(a);
+        i[o] = t[a];
+      }), this._store = this._store.selectRange(i), this;
+    }, r.prototype.mapArray = function(t, e, i) {
+      W(t) && (i = e, e = t, t = []), i = i || this;
+      var n = [];
+      return this.each(t, function() {
+        n.push(e && e.apply(this, arguments));
+      }, i), n;
+    }, r.prototype.map = function(t, e, i, n) {
+      var a = i || n || this, o = j(dt(t), this._getStoreDimIndex, this), s = xt(this);
+      return s._store = this._store.map(o, a ? X(e, a) : e), s;
+    }, r.prototype.modify = function(t, e, i, n) {
+      var a = this, o = i || n || this;
+      process.env.NODE_ENV !== "production" && S(dt(t), function(l) {
+        var u = a.getDimensionInfo(l);
+        u.isCalculationCoord || console.error("Danger: only stack dimension can be modified");
+      });
+      var s = j(dt(t), this._getStoreDimIndex, this);
+      this._store.modify(s, o ? X(e, o) : e);
+    }, r.prototype.downSample = function(t, e, i, n) {
+      var a = xt(this);
+      return a._store = this._store.downSample(this._getStoreDimIndex(t), e, i, n), a;
+    }, r.prototype.minmaxDownSample = function(t, e) {
+      var i = xt(this);
+      return i._store = this._store.minmaxDownSample(this._getStoreDimIndex(t), e), i;
+    }, r.prototype.lttbDownSample = function(t, e) {
+      var i = xt(this);
+      return i._store = this._store.lttbDownSample(this._getStoreDimIndex(t), e), i;
+    }, r.prototype.getRawDataItem = function(t) {
+      return this._store.getRawDataItem(t);
+    }, r.prototype.getItemModel = function(t) {
+      var e = this.hostModel, i = this.getRawDataItem(t);
+      return new ut(i, e, e && e.ecModel);
+    }, r.prototype.diff = function(t) {
+      var e = this;
+      return new Yn(t ? t.getStore().getIndices() : [], this.getStore().getIndices(), function(i) {
+        return Et(t, i);
+      }, function(i) {
+        return Et(e, i);
+      });
+    }, r.prototype.getVisual = function(t) {
+      var e = this._visual;
+      return e && e[t];
+    }, r.prototype.setVisual = function(t, e) {
+      this._visual = this._visual || {}, _t(t) ? F(this._visual, t) : this._visual[t] = e;
+    }, r.prototype.getItemVisual = function(t, e) {
+      var i = this._itemVisuals[t], n = i && i[e];
+      return n == null ? this.getVisual(e) : n;
+    }, r.prototype.hasItemVisual = function() {
+      return this._itemVisuals.length > 0;
+    }, r.prototype.ensureUniqueItemVisual = function(t, e) {
+      var i = this._itemVisuals, n = i[t];
+      n || (n = i[t] = {});
+      var a = n[e];
+      return a == null && (a = this.getVisual(e), H(a) ? a = a.slice() : _t(a) && (a = F({}, a)), n[e] = a), a;
+    }, r.prototype.setItemVisual = function(t, e, i) {
+      var n = this._itemVisuals[t] || {};
+      this._itemVisuals[t] = n, _t(e) ? F(n, e) : n[e] = i;
+    }, r.prototype.clearAllVisual = function() {
+      this._visual = {}, this._itemVisuals = [];
+    }, r.prototype.setLayout = function(t, e) {
+      _t(t) ? F(this._layout, t) : this._layout[t] = e;
+    }, r.prototype.getLayout = function(t) {
+      return this._layout[t];
+    }, r.prototype.getItemLayout = function(t) {
+      return this._itemLayouts[t];
+    }, r.prototype.setItemLayout = function(t, e, i) {
+      this._itemLayouts[t] = i ? F(this._itemLayouts[t] || {}, e) : e;
+    }, r.prototype.clearItemLayouts = function() {
+      this._itemLayouts.length = 0;
+    }, r.prototype.setItemGraphicEl = function(t, e) {
+      var i = this.hostModel && this.hostModel.seriesIndex;
+      Mr(i, this.dataType, t, e), this._graphicEls[t] = e;
+    }, r.prototype.getItemGraphicEl = function(t) {
+      return this._graphicEls[t];
+    }, r.prototype.eachItemGraphicEl = function(t, e) {
+      S(this._graphicEls, function(i, n) {
+        i && t && t.call(e, i, n);
+      });
+    }, r.prototype.cloneShallow = function(t) {
+      return t || (t = new r(this._schema ? this._schema : j(this.dimensions, this._getDimInfo, this), this.hostModel)), re(t, this), t._store = this._store, t;
+    }, r.prototype.wrapMethod = function(t, e) {
+      var i = this[t];
+      W(i) && (this.__wrappedMethods = this.__wrappedMethods || [], this.__wrappedMethods.push(t), this[t] = function() {
+        var n = i.apply(this, arguments);
+        return e.apply(this, [n].concat(Cr(arguments)));
+      });
+    }, r.internalField = (function() {
+      Ke = function(t) {
+        var e = t._invertedIndicesMap;
+        S(e, function(i, n) {
+          var a = t._dimInfos[n], o = a.ordinalMeta, s = t._store;
+          if (o) {
+            i = e[n] = new qn(o.categories.length);
+            for (var l = 0; l < i.length; l++)
+              i[l] = Ze;
+            for (var l = 0; l < s.count(); l++)
+              i[s.get(a.storeDimIndex, l)] = l;
+          }
+        });
+      }, yt = function(t, e, i) {
+        return jt(t._getCategory(e, i), null);
+      }, Et = function(t, e) {
+        var i = t._idList[e];
+        return i == null && t._idDimIdx != null && (i = yt(t, t._idDimIdx, e)), i == null && (i = Qn + e), i;
+      }, dt = function(t) {
+        return H(t) || (t = t != null ? [t] : []), t;
+      }, xt = function(t) {
+        var e = new r(t._schema ? t._schema : j(t.dimensions, t._getDimInfo, t), t.hostModel);
+        return re(e, t), e;
+      }, re = function(t, e) {
+        S(Jn.concat(e.__wrappedMethods || []), function(i) {
+          e.hasOwnProperty(i) && (t[i] = e[i]);
+        }), t.__wrappedMethods = e.__wrappedMethods, S(jn, function(i) {
+          t[i] = Ct(e[i]);
+        }), t._calculationInfo = F({}, e._calculationInfo);
+      }, ne = function(t, e) {
+        var i = t._nameList, n = t._idList, a = t._nameDimIdx, o = t._idDimIdx, s = i[e], l = n[e];
+        if (s == null && a != null && (i[e] = s = yt(t, a, e)), l == null && o != null && (n[e] = l = yt(t, o, e)), l == null && s != null) {
+          var u = t._nameRepeatCount, h = u[s] = (u[s] || 0) + 1;
+          l = s, h > 1 && (l += "__ec__" + h), n[e] = l;
+        }
+      };
+    })(), r;
+  })()
+);
+function $o(r, t) {
+  return ta(r, t).dimensions;
+}
+function ta(r, t) {
+  bi(r) || (r = Tr(r)), t = t || {};
+  var e = t.coordDimensions || [], i = t.dimensionsDefine || r.dimensionsDefine || [], n = vt(), a = [], o = ia(r, e, i, t.dimensionsCount), s = t.canOmitUnusedDimensions && $i(o), l = i === r.dimensionsDefine, u = l ? Ki(r) : Zi(i), h = t.encodeDefine;
+  !h && t.encodeDefaulter && (h = t.encodeDefaulter(r, o));
+  for (var f = vt(h), v = new Ir(o), d = 0; d < v.length; d++)
+    v[d] = -1;
+  function c(M) {
+    var w = v[M];
+    if (w < 0) {
+      var b = i[M], A = V(b) ? b : {
+        name: b
+      }, C = new zt(), P = A.name;
+      P != null && u.get(P) != null && (C.name = C.displayName = P), A.type != null && (C.type = A.type), A.displayName != null && (C.displayName = A.displayName);
+      var O = a.length;
+      return v[M] = O, C.storeDimIndex = M, a.push(C), C;
+    }
+    return a[w];
+  }
+  if (!s)
+    for (var d = 0; d < o; d++)
+      c(d);
+  f.each(function(M, w) {
+    var b = Pe(M).slice();
+    if (b.length === 1 && !R(b[0]) && b[0] < 0) {
+      f.set(w, !1);
+      return;
+    }
+    var A = f.set(w, []);
+    S(b, function(C, P) {
+      var O = R(C) ? u.get(C) : C;
+      O != null && O < o && (A[P] = O, m(c(O), w, P));
+    });
+  });
+  var g = 0;
+  S(e, function(M) {
+    var w, b, A, C;
+    if (R(M))
+      w = M, C = {};
+    else {
+      C = M, w = C.name;
+      var P = C.ordinalMeta;
+      C.ordinalMeta = null, C = F({}, C), C.ordinalMeta = P, b = C.dimsDef, A = C.otherDims, C.name = C.coordDim = C.coordDimIndex = C.dimsDef = C.otherDims = null;
+    }
+    var O = f.get(w);
+    if (O !== !1) {
+      if (O = Pe(O), !O.length)
+        for (var B = 0; B < (b && b.length || 1); B++) {
+          for (; g < o && c(g).coordDim != null; )
+            g++;
+          g < o && O.push(g++);
+        }
+      S(O, function(G, k) {
+        var E = c(G);
+        if (l && C.type != null && (E.type = C.type), m(nt(E, C), w, k), E.name == null && b) {
+          var N = b[k];
+          !V(N) && (N = {
+            name: N
+          }), E.name = E.displayName = N.name, E.defaultTooltip = N.defaultTooltip;
+        }
+        A && nt(E.otherDims, A);
+      });
+    }
+  });
+  function m(M, w, b) {
+    fe.get(w) != null ? M.otherDims[w] = b : (M.coordDim = w, M.coordDimIndex = b, n.set(w, !0));
+  }
+  var p = t.generateCoord, _ = t.generateCoordCount, y = _ != null;
+  _ = p ? _ || 1 : 0;
+  var x = p || "value";
+  function L(M) {
+    M.name == null && (M.name = M.coordDim);
+  }
+  if (s)
+    S(a, function(M) {
+      L(M);
+    }), a.sort(function(M, w) {
+      return M.storeDimIndex - w.storeDimIndex;
+    });
+  else
+    for (var T = 0; T < o; T++) {
+      var D = c(T), I = D.coordDim;
+      I == null && (D.coordDim = ra(x, n, y), D.coordDimIndex = 0, (!p || _ <= 0) && (D.isExtraCoord = !0), _--), L(D), D.type == null && (Lr(r, T) === Ar.Must || D.isExtraCoord && (D.otherDims.itemName != null || D.otherDims.seriesName != null)) && (D.type = "ordinal");
+    }
+  return ea(a), new Xi({
+    source: r,
+    dimensions: a,
+    fullDimensionCount: o,
+    dimensionOmitted: s
+  });
+}
+function ea(r) {
+  for (var t = vt(), e = 0; e < r.length; e++) {
+    var i = r[e], n = i.name, a = t.get(n) || 0;
+    a > 0 && (i.name = n + (a - 1)), a++, t.set(n, a);
+  }
+}
+function ia(r, t, e, i) {
+  var n = Math.max(r.dimensionsDetectedCount || 1, t.length, e.length, i || 0);
+  return S(t, function(a) {
+    var o;
+    V(a) && (o = a.dimsDef) && (n = Math.max(n, o.length));
+  }), n;
+}
+function ra(r, t, e) {
+  if (e || t.hasKey(r)) {
+    for (var i = 0; t.hasKey(r + i); )
+      i++;
+    r += i;
+  }
+  return t.set(r, !0), r;
+}
+function qo(r, t, e) {
+  e = e || {};
+  var i = e.byIndex, n = e.stackedCoordDimension, a, o, s;
+  na(t) ? a = t : (o = t.schema, a = o.dimensions, s = t.store);
+  var l = !!(r && r.get("stack")), u, h, f, v;
+  if (S(a, function(_, y) {
+    R(_) && (a[y] = _ = {
+      name: _
+    }), l && !_.isExtraCoord && (!i && !u && _.ordinalMeta && (u = _), !h && _.type !== "ordinal" && _.type !== "time" && (!n || n === _.coordDim) && (h = _));
+  }), h && !i && !u && (i = !0), h) {
+    f = "__\0ecstackresult_" + r.id, v = "__\0ecstackedover_" + r.id, u && (u.createInvertedIndices = !0);
+    var d = h.coordDim, c = h.type, g = 0;
+    S(a, function(_) {
+      _.coordDim === d && g++;
+    });
+    var m = {
+      name: f,
+      coordDim: d,
+      coordDimIndex: g,
+      type: c,
+      isExtraCoord: !0,
+      isCalculationCoord: !0,
+      storeDimIndex: a.length
+    }, p = {
+      name: v,
+      // This dimension contains stack base (generally, 0), so do not set it as
+      // `stackedDimCoordDim` to avoid extent calculation, consider log scale.
+      coordDim: v,
+      coordDimIndex: g + 1,
+      type: c,
+      isExtraCoord: !0,
+      isCalculationCoord: !0,
+      storeDimIndex: a.length + 1
+    };
+    o ? (s && (m.storeDimIndex = s.ensureCalculationDimension(v, c), p.storeDimIndex = s.ensureCalculationDimension(f, c)), o.appendCalculationDimension(m), o.appendCalculationDimension(p)) : (a.push(m), a.push(p));
+  }
+  return {
+    stackedDimension: h && h.name,
+    stackedByDimension: u && u.name,
+    isStackedByIndex: i,
+    stackedOverDimension: v,
+    stackResultDimension: f
+  };
+}
+function na(r) {
+  return !Ui(r.schema);
+}
+function qi(r, t) {
+  return !!t && t === r.getCalculationInfo("stackedDimension");
+}
+function aa(r, t) {
+  return qi(r, t) ? r.getCalculationInfo("stackResultDimension") : t;
+}
+var q = (
+  /** @class */
+  (function() {
+    function r(t) {
+      this._setting = t || {}, this._extent = [1 / 0, -1 / 0];
+    }
+    return r.prototype.getSetting = function(t) {
+      return this._setting[t];
+    }, r.prototype.unionExtent = function(t) {
+      var e = this._extent;
+      t[0] < e[0] && (e[0] = t[0]), t[1] > e[1] && (e[1] = t[1]);
+    }, r.prototype.unionExtentFromData = function(t, e) {
+      this.unionExtent(t.getApproximateExtent(e));
+    }, r.prototype.getExtent = function() {
+      return this._extent.slice();
+    }, r.prototype.setExtent = function(t, e) {
+      var i = this._extent;
+      isNaN(t) || (i[0] = t), isNaN(e) || (i[1] = e);
+    }, r.prototype.isInExtentRange = function(t) {
+      return this._extent[0] <= t && this._extent[1] >= t;
+    }, r.prototype.isBlank = function() {
+      return this._isBlank;
+    }, r.prototype.setBlank = function(t) {
+      this._isBlank = t;
+    }, r;
+  })()
+);
+Or(q);
+var oa = 0, $e = (
+  /** @class */
+  (function() {
+    function r(t) {
+      this.categories = t.categories || [], this._needCollect = t.needCollect, this._deduplication = t.deduplication, this.uid = ++oa;
+    }
+    return r.createByAxisModel = function(t) {
+      var e = t.option, i = e.data, n = i && at(i, sa);
+      return new r({
+        categories: n,
+        needCollect: !n,
+        // deduplication is default in axis.
+        deduplication: e.dedplication !== !1
+      });
+    }, r.prototype.getOrdinal = function(t) {
+      return this._getOrCreateMap().get(t);
+    }, r.prototype.parseAndCollect = function(t) {
+      var e, i = this._needCollect;
+      if (!R(t) && !i)
+        return t;
+      if (i && !this._deduplication)
+        return e = this.categories.length, this.categories[e] = t, e;
+      var n = this._getOrCreateMap();
+      return e = n.get(t), e == null && (i ? (e = this.categories.length, this.categories[e] = t, n.set(t, e)) : e = NaN), e;
+    }, r.prototype._getOrCreateMap = function() {
+      return this._map || (this._map = vt(this.categories));
+    }, r;
+  })()
+);
+function sa(r) {
+  return V(r) && r.value != null ? r.value : r + "";
+}
+function Qo(r) {
+  var t = Math.pow(10, Mi(Math.abs(r))), e = Math.abs(r / t);
+  return e === 0 || e === 1 || e === 2 || e === 3 || e === 5;
+}
+function Jo(r) {
+  return r.type === "interval" || r.type === "log";
+}
+function la(r, t, e, i) {
+  var n = {}, a = r[1] - r[0], o = n.interval = Si(a / t);
+  e != null && o < e && (o = n.interval = e), i != null && o > i && (o = n.interval = i);
+  var s = n.intervalPrecision = Qi(o), l = n.niceTickExtent = [it(Math.ceil(r[0] / o) * o, s), it(Math.floor(r[1] / o) * o, s)];
+  return ua(l, r), n;
+}
+function jo(r) {
+  var t = Math.pow(10, Mi(r)), e = r / t;
+  return e ? e === 2 ? e = 3 : e === 3 ? e = 5 : e *= 2 : e = 1, it(e * t);
+}
+function Qi(r) {
+  return Se(r) + 2;
+}
+function qe(r, t, e) {
+  r[t] = Math.max(Math.min(r[t], e[1]), e[0]);
+}
+function ua(r, t) {
+  !isFinite(r[0]) && (r[0] = t[0]), !isFinite(r[1]) && (r[1] = t[1]), qe(r, 0, t), qe(r, 1, t), r[0] > r[1] && (r[0] = r[1]);
+}
+function $t(r, t) {
+  return r >= t[0] && r <= t[1];
+}
+function qt(r, t) {
+  return t[1] === t[0] ? 0.5 : (r - t[0]) / (t[1] - t[0]);
+}
+function Qt(r, t) {
+  return r * (t[1] - t[0]) + t[0];
+}
+var Ce = (
+  /** @class */
+  (function(r) {
+    K(t, r);
+    function t(e) {
+      var i = r.call(this, e) || this;
+      i.type = "ordinal";
+      var n = i.getSetting("ordinalMeta");
+      return n || (n = new $e({})), H(n) && (n = new $e({
+        categories: at(n, function(a) {
+          return V(a) ? a.value : a;
+        })
+      })), i._ordinalMeta = n, i._extent = i.getSetting("extent") || [0, n.categories.length - 1], i;
+    }
+    return t.prototype.parse = function(e) {
+      return e == null ? NaN : R(e) ? this._ordinalMeta.getOrdinal(e) : Math.round(e);
+    }, t.prototype.contain = function(e) {
+      return e = this.parse(e), $t(e, this._extent) && this._ordinalMeta.categories[e] != null;
+    }, t.prototype.normalize = function(e) {
+      return e = this._getTickNumber(this.parse(e)), qt(e, this._extent);
+    }, t.prototype.scale = function(e) {
+      return e = Math.round(Qt(e, this._extent)), this.getRawOrdinalNumber(e);
+    }, t.prototype.getTicks = function() {
+      for (var e = [], i = this._extent, n = i[0]; n <= i[1]; )
+        e.push({
+          value: n
+        }), n++;
+      return e;
+    }, t.prototype.getMinorTicks = function(e) {
+    }, t.prototype.setSortInfo = function(e) {
+      if (e == null) {
+        this._ordinalNumbersByTick = this._ticksByOrdinalNumber = null;
+        return;
+      }
+      for (var i = e.ordinalNumbers, n = this._ordinalNumbersByTick = [], a = this._ticksByOrdinalNumber = [], o = 0, s = this._ordinalMeta.categories.length, l = Math.min(s, i.length); o < l; ++o) {
+        var u = i[o];
+        n[o] = u, a[u] = o;
+      }
+      for (var h = 0; o < s; ++o) {
+        for (; a[h] != null; )
+          h++;
+        n.push(h), a[h] = o;
+      }
+    }, t.prototype._getTickNumber = function(e) {
+      var i = this._ticksByOrdinalNumber;
+      return i && e >= 0 && e < i.length ? i[e] : e;
+    }, t.prototype.getRawOrdinalNumber = function(e) {
+      var i = this._ordinalNumbersByTick;
+      return i && e >= 0 && e < i.length ? i[e] : e;
+    }, t.prototype.getLabel = function(e) {
+      if (!this.isBlank()) {
+        var i = this.getRawOrdinalNumber(e.value), n = this._ordinalMeta.categories[i];
+        return n == null ? "" : n + "";
+      }
+    }, t.prototype.count = function() {
+      return this._extent[1] - this._extent[0] + 1;
+    }, t.prototype.unionExtentFromData = function(e, i) {
+      this.unionExtent(e.getApproximateExtent(i));
+    }, t.prototype.isInExtentRange = function(e) {
+      return e = this._getTickNumber(e), this._extent[0] <= e && this._extent[1] >= e;
+    }, t.prototype.getOrdinalMeta = function() {
+      return this._ordinalMeta;
+    }, t.prototype.calcNiceTicks = function() {
+    }, t.prototype.calcNiceExtent = function() {
+    }, t.type = "ordinal", t;
+  })(q)
+);
+q.registerClass(Ce);
+var ot = it, Lt = (
+  /** @class */
+  (function(r) {
+    K(t, r);
+    function t() {
+      var e = r !== null && r.apply(this, arguments) || this;
+      return e.type = "interval", e._interval = 0, e._intervalPrecision = 2, e;
+    }
+    return t.prototype.parse = function(e) {
+      return e;
+    }, t.prototype.contain = function(e) {
+      return $t(e, this._extent);
+    }, t.prototype.normalize = function(e) {
+      return qt(e, this._extent);
+    }, t.prototype.scale = function(e) {
+      return Qt(e, this._extent);
+    }, t.prototype.setExtent = function(e, i) {
+      var n = this._extent;
+      isNaN(e) || (n[0] = parseFloat(e)), isNaN(i) || (n[1] = parseFloat(i));
+    }, t.prototype.unionExtent = function(e) {
+      var i = this._extent;
+      e[0] < i[0] && (i[0] = e[0]), e[1] > i[1] && (i[1] = e[1]), this.setExtent(i[0], i[1]);
+    }, t.prototype.getInterval = function() {
+      return this._interval;
+    }, t.prototype.setInterval = function(e) {
+      this._interval = e, this._niceExtent = this._extent.slice(), this._intervalPrecision = Qi(e);
+    }, t.prototype.getTicks = function(e) {
+      var i = this._interval, n = this._extent, a = this._niceExtent, o = this._intervalPrecision, s = [];
+      if (!i)
+        return s;
+      var l = 1e4;
+      n[0] < a[0] && (e ? s.push({
+        value: ot(a[0] - i, o)
+      }) : s.push({
+        value: n[0]
+      }));
+      for (var u = a[0]; u <= a[1] && (s.push({
+        value: u
+      }), u = ot(u + i, o), u !== s[s.length - 1].value); )
+        if (s.length > l)
+          return [];
+      var h = s.length ? s[s.length - 1].value : a[1];
+      return n[1] > h && (e ? s.push({
+        value: ot(h + i, o)
+      }) : s.push({
+        value: n[1]
+      })), s;
+    }, t.prototype.getMinorTicks = function(e) {
+      for (var i = this.getTicks(!0), n = [], a = this.getExtent(), o = 1; o < i.length; o++) {
+        for (var s = i[o], l = i[o - 1], u = 0, h = [], f = s.value - l.value, v = f / e; u < e - 1; ) {
+          var d = ot(l.value + (u + 1) * v);
+          d > a[0] && d < a[1] && h.push(d), u++;
+        }
+        n.push(h);
+      }
+      return n;
+    }, t.prototype.getLabel = function(e, i) {
+      if (e == null)
+        return "";
+      var n = i && i.precision;
+      n == null ? n = Se(e.value) || 0 : n === "auto" && (n = this._intervalPrecision);
+      var a = ot(e.value, n, !0);
+      return Pr(a);
+    }, t.prototype.calcNiceTicks = function(e, i, n) {
+      e = e || 5;
+      var a = this._extent, o = a[1] - a[0];
+      if (isFinite(o)) {
+        o < 0 && (o = -o, a.reverse());
+        var s = la(a, e, i, n);
+        this._intervalPrecision = s.intervalPrecision, this._interval = s.interval, this._niceExtent = s.niceTickExtent;
+      }
+    }, t.prototype.calcNiceExtent = function(e) {
+      var i = this._extent;
+      if (i[0] === i[1])
+        if (i[0] !== 0) {
+          var n = Math.abs(i[0]);
+          e.fixMax || (i[1] += n / 2), i[0] -= n / 2;
+        } else
+          i[1] = 1;
+      var a = i[1] - i[0];
+      isFinite(a) || (i[0] = 0, i[1] = 1), this.calcNiceTicks(e.splitNumber, e.minInterval, e.maxInterval);
+      var o = this._interval;
+      e.fixMin || (i[0] = ot(Math.floor(i[0] / o) * o)), e.fixMax || (i[1] = ot(Math.ceil(i[1] / o) * o));
+    }, t.prototype.setNiceExtent = function(e, i) {
+      this._niceExtent = [e, i];
+    }, t.type = "interval", t;
+  })(q)
+);
+q.registerClass(Lt);
+var Ji = typeof Float32Array != "undefined", ha = Ji ? Float32Array : Array;
+function ae(r) {
+  return H(r) ? Ji ? new Float32Array(r) : r : new ha(r);
+}
+var _e = "__ec_stack_";
+function ji(r) {
+  return r.get("stack") || _e + r.seriesIndex;
+}
+function De(r) {
+  return r.dim + r.index;
+}
+function ts(r) {
+  var t = [], e = r.axis, i = "axis0";
+  if (e.type === "category") {
+    for (var n = e.getBandWidth(), a = 0; a < r.count; a++)
+      t.push(nt({
+        bandWidth: n,
+        axisKey: i,
+        stackId: _e + a
+      }, r));
+    for (var o = ir(t), s = [], a = 0; a < r.count; a++) {
+      var l = o[i][_e + a];
+      l.offsetCenter = l.offset + l.width / 2, s.push(l);
+    }
+    return s;
+  }
+}
+function tr(r, t) {
+  var e = [];
+  return t.eachSeriesByType(r, function(i) {
+    rr(i) && e.push(i);
+  }), e;
+}
+function fa(r) {
+  var t = {};
+  S(r, function(l) {
+    var u = l.coordinateSystem, h = u.getBaseAxis();
+    if (!(h.type !== "time" && h.type !== "value"))
+      for (var f = l.getData(), v = h.dim + "_" + h.index, d = f.getDimensionIndex(f.mapDimension(h.dim)), c = f.getStore(), g = 0, m = c.count(); g < m; ++g) {
+        var p = c.get(d, g);
+        t[v] ? t[v].push(p) : t[v] = [p];
+      }
+  });
+  var e = {};
+  for (var i in t)
+    if (t.hasOwnProperty(i)) {
+      var n = t[i];
+      if (n) {
+        n.sort(function(l, u) {
+          return l - u;
+        });
+        for (var a = null, o = 1; o < n.length; ++o) {
+          var s = n[o] - n[o - 1];
+          s > 0 && (a = a === null ? s : Math.min(a, s));
+        }
+        e[i] = a;
+      }
+    }
+  return e;
+}
+function er(r) {
+  var t = fa(r), e = [];
+  return S(r, function(i) {
+    var n = i.coordinateSystem, a = n.getBaseAxis(), o = a.getExtent(), s;
+    if (a.type === "category")
+      s = a.getBandWidth();
+    else if (a.type === "value" || a.type === "time") {
+      var l = a.dim + "_" + a.index, u = t[l], h = Math.abs(o[1] - o[0]), f = a.scale.getExtent(), v = Math.abs(f[1] - f[0]);
+      s = u ? h / v * u : h;
+    } else {
+      var d = i.getData();
+      s = Math.abs(o[1] - o[0]) / d.count();
+    }
+    var c = ht(i.get("barWidth"), s), g = ht(i.get("barMaxWidth"), s), m = ht(
+      // barMinWidth by default is 0.5 / 1 in cartesian. Because in value axis,
+      // the auto-calculated bar width might be less than 0.5 / 1.
+      i.get("barMinWidth") || (nr(i) ? 0.5 : 1),
+      s
+    ), p = i.get("barGap"), _ = i.get("barCategoryGap");
+    e.push({
+      bandWidth: s,
+      barWidth: c,
+      barMaxWidth: g,
+      barMinWidth: m,
+      barGap: p,
+      barCategoryGap: _,
+      axisKey: De(a),
+      stackId: ji(i)
+    });
+  }), ir(e);
+}
+function ir(r) {
+  var t = {};
+  S(r, function(i, n) {
+    var a = i.axisKey, o = i.bandWidth, s = t[a] || {
+      bandWidth: o,
+      remainedWidth: o,
+      autoWidthCount: 0,
+      categoryGap: null,
+      gap: "20%",
+      stacks: {}
+    }, l = s.stacks;
+    t[a] = s;
+    var u = i.stackId;
+    l[u] || s.autoWidthCount++, l[u] = l[u] || {
+      width: 0,
+      maxWidth: 0
+    };
+    var h = i.barWidth;
+    h && !l[u].width && (l[u].width = h, h = Math.min(s.remainedWidth, h), s.remainedWidth -= h);
+    var f = i.barMaxWidth;
+    f && (l[u].maxWidth = f);
+    var v = i.barMinWidth;
+    v && (l[u].minWidth = v);
+    var d = i.barGap;
+    d != null && (s.gap = d);
+    var c = i.barCategoryGap;
+    c != null && (s.categoryGap = c);
+  });
+  var e = {};
+  return S(t, function(i, n) {
+    e[n] = {};
+    var a = i.stacks, o = i.bandWidth, s = i.categoryGap;
+    if (s == null) {
+      var l = be(a).length;
+      s = Math.max(35 - l * 4, 15) + "%";
+    }
+    var u = ht(s, o), h = ht(i.gap, 1), f = i.remainedWidth, v = i.autoWidthCount, d = (f - u) / (v + (v - 1) * h);
+    d = Math.max(d, 0), S(a, function(p) {
+      var _ = p.maxWidth, y = p.minWidth;
+      if (p.width) {
+        var x = p.width;
+        _ && (x = Math.min(x, _)), y && (x = Math.max(x, y)), p.width = x, f -= x + h * x, v--;
+      } else {
+        var x = d;
+        _ && _ < x && (x = Math.min(_, f)), y && y > x && (x = y), x !== d && (p.width = x, f -= x + h * x, v--);
+      }
+    }), d = (f - u) / (v + (v - 1) * h), d = Math.max(d, 0);
+    var c = 0, g;
+    S(a, function(p, _) {
+      p.width || (p.width = d), g = p, c += p.width * (1 + h);
+    }), g && (c -= g.width * h);
+    var m = -c / 2;
+    S(a, function(p, _) {
+      e[n][_] = e[n][_] || {
+        bandWidth: o,
+        offset: m,
+        width: p.width
+      }, m += p.width * (1 + h);
+    });
+  }), e;
+}
+function va(r, t, e) {
+  if (r && t) {
+    var i = r[De(t)];
+    return i;
+  }
+}
+function es(r, t) {
+  var e = tr(r, t), i = er(e);
+  S(e, function(n) {
+    var a = n.getData(), o = n.coordinateSystem, s = o.getBaseAxis(), l = ji(n), u = i[De(s)][l], h = u.offset, f = u.width;
+    a.setLayout({
+      bandWidth: u.bandWidth,
+      offset: h,
+      size: f
+    });
+  });
+}
+function is(r) {
+  return {
+    seriesType: r,
+    plan: Er(),
+    reset: function(t) {
+      if (rr(t)) {
+        var e = t.getData(), i = t.coordinateSystem, n = i.getBaseAxis(), a = i.getOtherAxis(n), o = e.getDimensionIndex(e.mapDimension(a.dim)), s = e.getDimensionIndex(e.mapDimension(n.dim)), l = t.get("showBackground", !0), u = e.mapDimension(a.dim), h = e.getCalculationInfo("stackResultDimension"), f = qi(e, u) && !!e.getCalculationInfo("stackedOnSeries"), v = a.isHorizontal(), d = da(n, a), c = nr(t), g = t.get("barMinHeight") || 0, m = h && e.getDimensionIndex(h), p = e.getLayout("size"), _ = e.getLayout("offset");
+        return {
+          progress: function(y, x) {
+            for (var L = y.count, T = c && ae(L * 3), D = c && l && ae(L * 3), I = c && ae(L), M = i.master.getRect(), w = v ? M.width : M.height, b, A = x.getStore(), C = 0; (b = y.next()) != null; ) {
+              var P = A.get(f ? m : o, b), O = A.get(s, b), B = d, G = void 0;
+              f && (G = +P - A.get(o, b));
+              var k = void 0, E = void 0, N = void 0, $ = void 0;
+              if (v) {
+                var gt = i.dataToPoint([P, O]);
+                if (f) {
+                  var Jt = i.dataToPoint([G, O]);
+                  B = Jt[0];
+                }
+                k = B, E = gt[1] + _, N = gt[0] - B, $ = p, Math.abs(N) < g && (N = (N < 0 ? -1 : 1) * g);
+              } else {
+                var gt = i.dataToPoint([O, P]);
+                if (f) {
+                  var Jt = i.dataToPoint([O, G]);
+                  B = Jt[1];
+                }
+                k = gt[0] + _, E = B, N = p, $ = gt[1] - B, Math.abs($) < g && ($ = ($ <= 0 ? -1 : 1) * g);
+              }
+              c ? (T[C] = k, T[C + 1] = E, T[C + 2] = v ? N : $, D && (D[C] = v ? M.x : k, D[C + 1] = v ? E : M.y, D[C + 2] = w), I[b] = b) : x.setItemLayout(b, {
+                x: k,
+                y: E,
+                width: N,
+                height: $
+              }), C += 3;
+            }
+            c && x.setLayout({
+              largePoints: T,
+              largeDataIndices: I,
+              largeBackgroundPoints: D,
+              valueAxisHorizontal: v
+            });
+          }
+        };
+      }
+    }
+  };
+}
+function rr(r) {
+  return r.coordinateSystem && r.coordinateSystem.type === "cartesian2d";
+}
+function nr(r) {
+  return r.pipelineContext && r.pipelineContext.large;
+}
+function da(r, t) {
+  var e = t.model.get("startValue");
+  return e || (e = 0), t.toGlobalCoord(t.dataToCoord(t.type === "log" ? e > 0 ? e : 1 : e));
+}
+var ca = function(r, t, e, i) {
+  for (; e < i; ) {
+    var n = e + i >>> 1;
+    r[n][1] < t ? e = n + 1 : i = n;
+  }
+  return e;
+}, ar = (
+  /** @class */
+  (function(r) {
+    K(t, r);
+    function t(e) {
+      var i = r.call(this, e) || this;
+      return i.type = "time", i;
+    }
+    return t.prototype.getLabel = function(e) {
+      var i = this.getSetting("useUTC");
+      return Ci(e.value, Ee[kr(bt(this._minLevelUnit))] || Ee.second, i, this.getSetting("locale"));
+    }, t.prototype.getFormattedLabel = function(e, i, n) {
+      var a = this.getSetting("useUTC"), o = this.getSetting("locale");
+      return Nr(e, i, n, o, a);
+    }, t.prototype.getTicks = function() {
+      var e = this._interval, i = this._extent, n = [];
+      if (!e)
+        return n;
+      n.push({
+        value: i[0],
+        level: 0
+      });
+      var a = this.getSetting("useUTC"), o = wa(this._minLevelUnit, this._approxInterval, a, i);
+      return n = n.concat(o), n.push({
+        value: i[1],
+        level: 0
+      }), n;
+    }, t.prototype.calcNiceExtent = function(e) {
+      var i = this._extent;
+      if (i[0] === i[1] && (i[0] -= Z, i[1] += Z), i[1] === -1 / 0 && i[0] === 1 / 0) {
+        var n = /* @__PURE__ */ new Date();
+        i[1] = +new Date(n.getFullYear(), n.getMonth(), n.getDate()), i[0] = i[1] - Z;
+      }
+      this.calcNiceTicks(e.splitNumber, e.minInterval, e.maxInterval);
+    }, t.prototype.calcNiceTicks = function(e, i, n) {
+      e = e || 10;
+      var a = this._extent, o = a[1] - a[0];
+      this._approxInterval = o / e, i != null && this._approxInterval < i && (this._approxInterval = i), n != null && this._approxInterval > n && (this._approxInterval = n);
+      var s = kt.length, l = Math.min(ca(kt, this._approxInterval, 0, s), s - 1);
+      this._interval = kt[l][1], this._minLevelUnit = kt[Math.max(l - 1, 0)][0];
+    }, t.prototype.parse = function(e) {
+      return we(e) ? e : +ve(e);
+    }, t.prototype.contain = function(e) {
+      return $t(this.parse(e), this._extent);
+    }, t.prototype.normalize = function(e) {
+      return qt(this.parse(e), this._extent);
+    }, t.prototype.scale = function(e) {
+      return Qt(e, this._extent);
+    }, t.type = "time", t;
+  })(Lt)
+), kt = [
+  // Format                           interval
+  ["second", Di],
+  ["minute", Ti],
+  ["hour", Ft],
+  ["quarter-day", Ft * 6],
+  ["half-day", Ft * 12],
+  ["day", Z * 1.2],
+  ["half-week", Z * 3.5],
+  ["week", Z * 7],
+  ["month", Z * 31],
+  ["quarter", Z * 95],
+  ["half-year", ke / 2],
+  ["year", ke]
+  // 1Y
+];
+function pa(r, t, e, i) {
+  var n = ve(t), a = ve(e), o = function(c) {
+    return Re(n, c, i) === Re(a, c, i);
+  }, s = function() {
+    return o("year");
+  }, l = function() {
+    return s() && o("month");
+  }, u = function() {
+    return l() && o("day");
+  }, h = function() {
+    return u() && o("hour");
+  }, f = function() {
+    return h() && o("minute");
+  }, v = function() {
+    return f() && o("second");
+  }, d = function() {
+    return v() && o("millisecond");
+  };
+  switch (r) {
+    case "year":
+      return s();
+    case "month":
+      return l();
+    case "day":
+      return u();
+    case "hour":
+      return h();
+    case "minute":
+      return f();
+    case "second":
+      return v();
+    case "millisecond":
+      return d();
+  }
+}
+function ga(r, t) {
+  return r /= Z, r > 16 ? 16 : r > 7.5 ? 7 : r > 3.5 ? 4 : r > 1.5 ? 2 : 1;
+}
+function ma(r) {
+  var t = 30 * Z;
+  return r /= t, r > 6 ? 6 : r > 3 ? 3 : r > 2 ? 2 : 1;
+}
+function _a(r) {
+  return r /= Ft, r > 12 ? 12 : r > 6 ? 6 : r > 3.5 ? 4 : r > 2 ? 2 : 1;
+}
+function Qe(r, t) {
+  return r /= t ? Ti : Di, r > 30 ? 30 : r > 20 ? 20 : r > 15 ? 15 : r > 10 ? 10 : r > 5 ? 5 : r > 2 ? 2 : 1;
+}
+function ya(r) {
+  return Si(r);
+}
+function xa(r, t, e) {
+  var i = new Date(r);
+  switch (bt(t)) {
+    case "year":
+    case "month":
+      i[Ei(e)](0);
+    case "day":
+      i[Pi(e)](1);
+    case "hour":
+      i[Oi(e)](0);
+    case "minute":
+      i[Ai(e)](0);
+    case "second":
+      i[Ii(e)](0), i[Li(e)](0);
+  }
+  return i.getTime();
+}
+function wa(r, t, e, i) {
+  var n = 1e4, a = Rr, o = 0;
+  function s(w, b, A, C, P, O, B) {
+    for (var G = new Date(b), k = b, E = G[C](); k < A && k <= i[1]; )
+      B.push({
+        value: k
+      }), E += w, G[P](E), k = G.getTime();
+    B.push({
+      value: k,
+      notAdd: !0
+    });
+  }
+  function l(w, b, A) {
+    var C = [], P = !b.length;
+    if (!pa(bt(w), i[0], i[1], e)) {
+      P && (b = [{
+        // TODO Optimize. Not include so may ticks.
+        value: xa(new Date(i[0]), w, e)
+      }, {
+        value: i[1]
+      }]);
+      for (var O = 0; O < b.length - 1; O++) {
+        var B = b[O].value, G = b[O + 1].value;
+        if (B !== G) {
+          var k = void 0, E = void 0, N = void 0, $ = !1;
+          switch (w) {
+            case "year":
+              k = Math.max(1, Math.round(t / Z / 365)), E = Xr(e), N = Ur(e);
+              break;
+            case "half-year":
+            case "quarter":
+            case "month":
+              k = ma(t), E = Yr(e), N = Ei(e);
+              break;
+            case "week":
+            // PENDING If week is added. Ignore day.
+            case "half-week":
+            case "day":
+              k = ga(t), E = Gr(e), N = Pi(e), $ = !0;
+              break;
+            case "half-day":
+            case "quarter-day":
+            case "hour":
+              k = _a(t), E = Vr(e), N = Oi(e);
+              break;
+            case "minute":
+              k = Qe(t, !0), E = Wr(e), N = Ai(e);
+              break;
+            case "second":
+              k = Qe(t, !1), E = zr(e), N = Ii(e);
+              break;
+            case "millisecond":
+              k = ya(t), E = Fr(e), N = Li(e);
+              break;
+          }
+          s(k, B, G, E, N, $, C), w === "year" && A.length > 1 && O === 0 && A.unshift({
+            value: A[0].value - k
+          });
+        }
+      }
+      for (var O = 0; O < C.length; O++)
+        A.push(C[O]);
+      return C;
+    }
+  }
+  for (var u = [], h = [], f = 0, v = 0, d = 0; d < a.length && o++ < n; ++d) {
+    var c = bt(a[d]);
+    if (Br(a[d])) {
+      l(a[d], u[u.length - 1] || [], h);
+      var g = a[d + 1] ? bt(a[d + 1]) : null;
+      if (c !== g) {
+        if (h.length) {
+          v = f, h.sort(function(w, b) {
+            return w.value - b.value;
+          });
+          for (var m = [], p = 0; p < h.length; ++p) {
+            var _ = h[p].value;
+            (p === 0 || h[p - 1].value !== _) && (m.push(h[p]), _ >= i[0] && _ <= i[1] && f++);
+          }
+          var y = (i[1] - i[0]) / t;
+          if (f > y * 1.5 && v > y / 1.5 || (u.push(m), f > y || r === a[d]))
+            break;
+        }
+        h = [];
+      }
+    }
+  }
+  process.env.NODE_ENV !== "production" && o >= n && Hr("Exceed safe limit.");
+  for (var x = Ne(at(u, function(w) {
+    return Ne(w, function(b) {
+      return b.value >= i[0] && b.value <= i[1] && !b.notAdd;
+    });
+  }), function(w) {
+    return w.length > 0;
+  }), L = [], T = x.length - 1, d = 0; d < x.length; ++d)
+    for (var D = x[d], I = 0; I < D.length; ++I)
+      L.push({
+        value: D[I].value,
+        level: T - d
+      });
+  L.sort(function(w, b) {
+    return w.value - b.value;
+  });
+  for (var M = [], d = 0; d < L.length; ++d)
+    (d === 0 || L[d].value !== L[d - 1].value) && M.push(L[d]);
+  return M;
+}
+q.registerClass(ar);
+var Je = q.prototype, Mt = Lt.prototype, ba = it, Sa = Math.floor, Ma = Math.ceil, Nt = Math.pow, U = Math.log, Te = (
+  /** @class */
+  (function(r) {
+    K(t, r);
+    function t() {
+      var e = r !== null && r.apply(this, arguments) || this;
+      return e.type = "log", e.base = 10, e._originalScale = new Lt(), e._interval = 0, e;
+    }
+    return t.prototype.getTicks = function(e) {
+      var i = this._originalScale, n = this._extent, a = i.getExtent(), o = Mt.getTicks.call(this, e);
+      return at(o, function(s) {
+        var l = s.value, u = it(Nt(this.base, l));
+        return u = l === n[0] && this._fixMin ? Rt(u, a[0]) : u, u = l === n[1] && this._fixMax ? Rt(u, a[1]) : u, {
+          value: u
+        };
+      }, this);
+    }, t.prototype.setExtent = function(e, i) {
+      var n = U(this.base);
+      e = U(Math.max(0, e)) / n, i = U(Math.max(0, i)) / n, Mt.setExtent.call(this, e, i);
+    }, t.prototype.getExtent = function() {
+      var e = this.base, i = Je.getExtent.call(this);
+      i[0] = Nt(e, i[0]), i[1] = Nt(e, i[1]);
+      var n = this._originalScale, a = n.getExtent();
+      return this._fixMin && (i[0] = Rt(i[0], a[0])), this._fixMax && (i[1] = Rt(i[1], a[1])), i;
+    }, t.prototype.unionExtent = function(e) {
+      this._originalScale.unionExtent(e);
+      var i = this.base;
+      e[0] = U(e[0]) / U(i), e[1] = U(e[1]) / U(i), Je.unionExtent.call(this, e);
+    }, t.prototype.unionExtentFromData = function(e, i) {
+      this.unionExtent(e.getApproximateExtent(i));
+    }, t.prototype.calcNiceTicks = function(e) {
+      e = e || 10;
+      var i = this._extent, n = i[1] - i[0];
+      if (!(n === 1 / 0 || n <= 0)) {
+        var a = Zr(n), o = e / n * a;
+        for (o <= 0.5 && (a *= 10); !isNaN(a) && Math.abs(a) < 1 && Math.abs(a) > 0; )
+          a *= 10;
+        var s = [it(Ma(i[0] / a) * a), it(Sa(i[1] / a) * a)];
+        this._interval = a, this._niceExtent = s;
+      }
+    }, t.prototype.calcNiceExtent = function(e) {
+      Mt.calcNiceExtent.call(this, e), this._fixMin = e.fixMin, this._fixMax = e.fixMax;
+    }, t.prototype.parse = function(e) {
+      return e;
+    }, t.prototype.contain = function(e) {
+      return e = U(e) / U(this.base), $t(e, this._extent);
+    }, t.prototype.normalize = function(e) {
+      return e = U(e) / U(this.base), qt(e, this._extent);
+    }, t.prototype.scale = function(e) {
+      return e = Qt(e, this._extent), Nt(this.base, e);
+    }, t.type = "log", t;
+  })(q)
+), or = Te.prototype;
+or.getMinorTicks = Mt.getMinorTicks;
+or.getLabel = Mt.getLabel;
+function Rt(r, t) {
+  return ba(r, Se(t));
+}
+q.registerClass(Te);
+var Ca = (
+  /** @class */
+  (function() {
+    function r(t, e, i) {
+      this._prepareParams(t, e, i);
+    }
+    return r.prototype._prepareParams = function(t, e, i) {
+      i[1] < i[0] && (i = [NaN, NaN]), this._dataMin = i[0], this._dataMax = i[1];
+      var n = this._isOrdinal = t.type === "ordinal";
+      this._needCrossZero = t.type === "interval" && e.getNeedCrossZero && e.getNeedCrossZero();
+      var a = e.get("min", !0);
+      a == null && (a = e.get("startValue", !0));
+      var o = this._modelMinRaw = a;
+      W(o) ? this._modelMinNum = Bt(t, o({
+        min: i[0],
+        max: i[1]
+      })) : o !== "dataMin" && (this._modelMinNum = Bt(t, o));
+      var s = this._modelMaxRaw = e.get("max", !0);
+      if (W(s) ? this._modelMaxNum = Bt(t, s({
+        min: i[0],
+        max: i[1]
+      })) : s !== "dataMax" && (this._modelMaxNum = Bt(t, s)), n)
+        this._axisDataLen = e.getCategories().length;
+      else {
+        var l = e.get("boundaryGap"), u = H(l) ? l : [l || 0, l || 0];
+        typeof u[0] == "boolean" || typeof u[1] == "boolean" ? (process.env.NODE_ENV !== "production" && console.warn('Boolean type for boundaryGap is only allowed for ordinal axis. Please use string in percentage instead, e.g., "20%". Currently, boundaryGap is set to be 0.'), this._boundaryGapInner = [0, 0]) : this._boundaryGapInner = [Be(u[0], 1), Be(u[1], 1)];
+      }
+    }, r.prototype.calculate = function() {
+      var t = this._isOrdinal, e = this._dataMin, i = this._dataMax, n = this._axisDataLen, a = this._boundaryGapInner, o = t ? null : i - e || Math.abs(e), s = this._modelMinRaw === "dataMin" ? e : this._modelMinNum, l = this._modelMaxRaw === "dataMax" ? i : this._modelMaxNum, u = s != null, h = l != null;
+      s == null && (s = t ? n ? 0 : NaN : e - a[0] * o), l == null && (l = t ? n ? n - 1 : NaN : i + a[1] * o), (s == null || !isFinite(s)) && (s = NaN), (l == null || !isFinite(l)) && (l = NaN);
+      var f = de(s) || de(l) || t && !n;
+      this._needCrossZero && (s > 0 && l > 0 && !u && (s = 0), s < 0 && l < 0 && !h && (l = 0));
+      var v = this._determinedMin, d = this._determinedMax;
+      return v != null && (s = v, u = !0), d != null && (l = d, h = !0), {
+        min: s,
+        max: l,
+        minFixed: u,
+        maxFixed: h,
+        isBlank: f
+      };
+    }, r.prototype.modifyDataMinMax = function(t, e) {
+      process.env.NODE_ENV !== "production" && Vt(!this.frozen), this[Ta[t]] = e;
+    }, r.prototype.setDeterminedMinMax = function(t, e) {
+      var i = Da[t];
+      process.env.NODE_ENV !== "production" && Vt(!this.frozen && this[i] == null), this[i] = e;
+    }, r.prototype.freeze = function() {
+      this.frozen = !0;
+    }, r;
+  })()
+), Da = {
+  min: "_determinedMin",
+  max: "_determinedMax"
+}, Ta = {
+  min: "_dataMin",
+  max: "_dataMax"
+};
+function Ia(r, t, e) {
+  var i = r.rawExtentInfo;
+  return i || (i = new Ca(r, t, e), r.rawExtentInfo = i, i);
+}
+function Bt(r, t) {
+  return t == null ? null : de(t) ? NaN : r.parse(t);
+}
+function La(r, t) {
+  var e = r.type, i = Ia(r, t, r.getExtent()).calculate();
+  r.setBlank(i.isBlank);
+  var n = i.min, a = i.max, o = t.ecModel;
+  if (o && e === "time") {
+    var s = tr("bar", o), l = !1;
+    if (S(s, function(f) {
+      l = l || f.getBaseAxis() === t.axis;
+    }), l) {
+      var u = er(s), h = Aa(n, a, t, u);
+      n = h.min, a = h.max;
+    }
+  }
+  return {
+    extent: [n, a],
+    // "fix" means "fixed", the value should not be
+    // changed in the subsequent steps.
+    fixMin: i.minFixed,
+    fixMax: i.maxFixed
+  };
+}
+function Aa(r, t, e, i) {
+  var n = e.axis.getExtent(), a = Math.abs(n[1] - n[0]), o = va(i, e.axis);
+  if (o === void 0)
+    return {
+      min: r,
+      max: t
+    };
+  var s = 1 / 0;
+  S(o, function(d) {
+    s = Math.min(d.offset, s);
+  });
+  var l = -1 / 0;
+  S(o, function(d) {
+    l = Math.max(d.offset + d.width, l);
+  }), s = Math.abs(s), l = Math.abs(l);
+  var u = s + l, h = t - r, f = 1 - (s + l) / a, v = h / f - h;
+  return t += v * (l / u), r -= v * (s / u), {
+    min: r,
+    max: t
+  };
+}
+function rs(r, t) {
+  var e = t, i = La(r, e), n = i.extent, a = e.get("splitNumber");
+  r instanceof Te && (r.base = e.get("logBase"));
+  var o = r.type, s = e.get("interval"), l = o === "interval" || o === "time";
+  r.setExtent(n[0], n[1]), r.calcNiceExtent({
+    splitNumber: a,
+    fixMin: i.fixMin,
+    fixMax: i.fixMax,
+    minInterval: l ? e.get("minInterval") : null,
+    maxInterval: l ? e.get("maxInterval") : null
+  }), s != null && r.setInterval && r.setInterval(s);
+}
+function ns(r, t) {
+  if (t = t || r.get("type"), t)
+    switch (t) {
+      // Buildin scale
+      case "category":
+        return new Ce({
+          ordinalMeta: r.getOrdinalMeta ? r.getOrdinalMeta() : r.getCategories(),
+          extent: [1 / 0, -1 / 0]
+        });
+      case "time":
+        return new ar({
+          locale: r.ecModel.getLocaleModel(),
+          useUTC: r.ecModel.get("useUTC")
+        });
+      default:
+        return new (q.getClass(t) || Lt)();
+    }
+}
+function as(r) {
+  var t = r.scale.getExtent(), e = t[0], i = t[1];
+  return !(e > 0 && i > 0 || e < 0 && i < 0);
+}
+function Oa(r) {
+  var t = r.getLabelModel().get("formatter"), e = r.type === "category" ? r.scale.getExtent()[0] : null;
+  return r.scale.type === "time" ? /* @__PURE__ */ (function(i) {
+    return function(n, a) {
+      return r.scale.getFormattedLabel(n, a, i);
+    };
+  })(t) : R(t) ? /* @__PURE__ */ (function(i) {
+    return function(n) {
+      var a = r.scale.getLabel(n), o = i.replace("{value}", a != null ? a : "");
+      return o;
+    };
+  })(t) : W(t) ? /* @__PURE__ */ (function(i) {
+    return function(n, a) {
+      return e != null && (a = n.value - e), i(Ie(r, n), a, n.level != null ? {
+        level: n.level
+      } : null);
+    };
+  })(t) : function(i) {
+    return r.scale.getLabel(i);
+  };
+}
+function Ie(r, t) {
+  return r.type === "category" ? r.scale.getLabel(t) : t.value;
+}
+function os(r) {
+  var t = r.model, e = r.scale;
+  if (!(!t.get(["axisLabel", "show"]) || e.isBlank())) {
+    var i, n, a = e.getExtent();
+    e instanceof Ce ? n = e.count() : (i = e.getTicks(), n = i.length);
+    var o = r.getLabelModel(), s = Oa(r), l, u = 1;
+    n > 40 && (u = Math.ceil(n / 40));
+    for (var h = 0; h < n; h += u) {
+      var f = i ? i[h] : {
+        value: a[0] + h
+      }, v = s(f, h), d = o.getTextRect(v), c = Pa(d, o.get("rotate") || 0);
+      l ? l.union(c) : l = c;
+    }
+    return l;
+  }
+}
+function Pa(r, t) {
+  var e = t * Math.PI / 180, i = r.width, n = r.height, a = i * Math.abs(Math.cos(e)) + Math.abs(n * Math.sin(e)), o = i * Math.abs(Math.sin(e)) + Math.abs(n * Math.cos(e)), s = new pt(r.x, r.y, a, o);
+  return s;
+}
+function Ea(r) {
+  var t = r.get("interval");
+  return t == null ? "auto" : t;
+}
+function ka(r) {
+  return r.type === "category" && Ea(r.getLabelModel()) === 0;
+}
+function Na(r, t) {
+  var e = {};
+  return S(r.mapDimensionsAll(t), function(i) {
+    e[aa(r, i)] = !0;
+  }), be(e);
+}
+function ss(r, t, e) {
+  t && S(Na(t, e), function(i) {
+    var n = t.getApproximateExtent(i);
+    n[0] < r[0] && (r[0] = n[0]), n[1] > r[1] && (r[1] = n[1]);
+  });
+}
+var je = [], Ra = {
+  registerPreprocessor: ln,
+  registerProcessor: sn,
+  registerPostInit: on,
+  registerPostUpdate: an,
+  registerUpdateLifecycle: nn,
+  registerAction: rn,
+  registerCoordinateSystem: en,
+  registerLayout: tn,
+  registerVisual: jr,
+  registerTransform: Jr,
+  registerLoading: Qr,
+  registerMap: qr,
+  registerImpl: $r,
+  PRIORITY: Kr,
+  ComponentModel: St,
+  ComponentView: Dt,
+  SeriesModel: Fe,
+  ChartView: He,
+  // TODO Use ComponentModel and SeriesModel instead of Constructor
+  registerComponentModel: function(r) {
+    St.registerClass(r);
+  },
+  registerComponentView: function(r) {
+    Dt.registerClass(r);
+  },
+  registerSeriesModel: function(r) {
+    Fe.registerClass(r);
+  },
+  registerChartView: function(r) {
+    He.registerClass(r);
+  },
+  registerSubTypeDefaulter: function(r, t) {
+    St.registerSubTypeDefaulter(r, t);
+  },
+  registerPainter: function(r, t) {
+    un(r, t);
+  }
+};
+function sr(r) {
+  if (H(r)) {
+    S(r, function(t) {
+      sr(t);
+    });
+    return;
+  }
+  Zt(je, r) >= 0 || (je.push(r), W(r) && (r = {
+    install: r
+  }), r.install(Ra));
+}
+function Ba(r) {
+  for (var t = [], e = 0; e < r.length; e++) {
+    var i = r[e];
+    if (!i.defaultAttr.ignore) {
+      var n = i.label, a = n.getComputedTransform(), o = n.getBoundingRect(), s = !a || a[1] < 1e-5 && a[2] < 1e-5, l = n.style.margin || 0, u = o.clone();
+      u.applyTransform(a), u.x -= l / 2, u.y -= l / 2, u.width += l, u.height += l;
+      var h = s ? new ce(o, a) : null;
+      t.push({
+        label: n,
+        labelLine: i.labelLine,
+        rect: u,
+        localRect: o,
+        obb: h,
+        priority: i.priority,
+        defaultAttr: i.defaultAttr,
+        layoutOption: i.computedLayoutOption,
+        axisAligned: s,
+        transform: a
+      });
+    }
+  }
+  return t;
+}
+function lr(r, t, e, i, n, a) {
+  var o = r.length;
+  if (o < 2)
+    return;
+  r.sort(function(T, D) {
+    return T.rect[t] - D.rect[t];
+  });
+  for (var s = 0, l, u = !1, h = 0; h < o; h++) {
+    var f = r[h], v = f.rect;
+    l = v[t] - s, l < 0 && (v[t] -= l, f.label[t] -= l, u = !0), s = v[t] + v[e];
+  }
+  var d = r[0], c = r[o - 1], g, m;
+  p(), g < 0 && x(-g, 0.8), m < 0 && x(m, 0.8), p(), _(g, m, 1), _(m, g, -1), p(), g < 0 && L(-g), m < 0 && L(m);
+  function p() {
+    g = d.rect[t] - i, m = n - c.rect[t] - c.rect[e];
+  }
+  function _(T, D, I) {
+    if (T < 0) {
+      var M = Math.min(D, -T);
+      if (M > 0) {
+        y(M * I, 0, o);
+        var w = M + T;
+        w < 0 && x(-w * I, 1);
+      } else
+        x(-T * I, 1);
+    }
+  }
+  function y(T, D, I) {
+    T !== 0 && (u = !0);
+    for (var M = D; M < I; M++) {
+      var w = r[M], b = w.rect;
+      b[t] += T, w.label[t] += T;
+    }
+  }
+  function x(T, D) {
+    for (var I = [], M = 0, w = 1; w < o; w++) {
+      var b = r[w - 1].rect, A = Math.max(r[w].rect[t] - b[t] - b[e], 0);
+      I.push(A), M += A;
+    }
+    if (M) {
+      var C = Math.min(Math.abs(T) / M, D);
+      if (T > 0)
+        for (var w = 0; w < o - 1; w++) {
+          var P = I[w] * C;
+          y(P, 0, w + 1);
+        }
+      else
+        for (var w = o - 1; w > 0; w--) {
+          var P = I[w - 1] * C;
+          y(-P, w, o);
+        }
+    }
+  }
+  function L(T) {
+    var D = T < 0 ? -1 : 1;
+    T = Math.abs(T);
+    for (var I = Math.ceil(T / (o - 1)), M = 0; M < o - 1; M++)
+      if (D > 0 ? y(I, 0, M + 1) : y(-I, o - M - 1, o), T -= I, T <= 0)
+        return;
+  }
+  return u;
+}
+function ls(r, t, e, i) {
+  return lr(r, "x", "width", t, e);
+}
+function us(r, t, e, i) {
+  return lr(r, "y", "height", t, e);
+}
+function Ha(r) {
+  var t = [];
+  r.sort(function(g, m) {
+    return m.priority - g.priority;
+  });
+  var e = new pt(0, 0, 0, 0);
+  function i(g) {
+    if (!g.ignore) {
+      var m = g.ensureState("emphasis");
+      m.ignore == null && (m.ignore = !1);
+    }
+    g.ignore = !0;
+  }
+  for (var n = 0; n < r.length; n++) {
+    var a = r[n], o = a.axisAligned, s = a.localRect, l = a.transform, u = a.label, h = a.labelLine;
+    e.copy(a.rect), e.width -= 0.1, e.height -= 0.1, e.x += 0.05, e.y += 0.05;
+    for (var f = a.obb, v = !1, d = 0; d < t.length; d++) {
+      var c = t[d];
+      if (e.intersect(c.rect)) {
+        if (o && c.axisAligned) {
+          v = !0;
+          break;
+        }
+        if (c.obb || (c.obb = new ce(c.localRect, c.transform)), f || (f = new ce(s, l)), f.intersect(c.obb)) {
+          v = !0;
+          break;
+        }
+      }
+    }
+    v ? (i(u), h && i(h)) : (u.attr("ignore", a.defaultAttr.ignore), h && h.attr("ignore", a.defaultAttr.labelGuideIgnore), t.push(a));
+  }
+}
+function ti(r, t, e) {
+  e = e || {};
+  var i = r.coordinateSystem, n = t.axis, a = {}, o = n.getAxesOnZeroOf()[0], s = n.position, l = o ? "onZero" : s, u = n.dim, h = i.getRect(), f = [h.x, h.x + h.width, h.y, h.y + h.height], v = {
+    left: 0,
+    right: 1,
+    top: 0,
+    bottom: 1,
+    onZero: 2
+  }, d = t.get("offset") || 0, c = u === "x" ? [f[2] - d, f[3] + d] : [f[0] - d, f[1] + d];
+  if (o) {
+    var g = o.toGlobalCoord(o.dataToCoord(0));
+    c[v.onZero] = Math.max(Math.min(g, c[1]), c[0]);
+  }
+  a.position = [u === "y" ? c[v[l]] : f[0], u === "x" ? c[v[l]] : f[3]], a.rotation = Math.PI / 2 * (u === "x" ? 0 : 1);
+  var m = {
+    top: -1,
+    bottom: 1,
+    left: -1,
+    right: 1
+  };
+  a.labelDirection = a.tickDirection = a.nameDirection = m[s], a.labelOffset = o ? c[v[s]] - c[v.onZero] : 0, t.get(["axisTick", "inside"]) && (a.tickDirection = -a.tickDirection), Tt(e.labelInside, t.get(["axisLabel", "inside"])) && (a.labelDirection = -a.labelDirection);
+  var p = t.get(["axisLabel", "rotate"]);
+  return a.labelRotate = l === "top" ? -p : p, a.z2 = 1, a;
+}
+function hs(r) {
+  return r.get("coordinateSystem") === "cartesian2d";
+}
+function fs(r) {
+  var t = {
+    xAxisModel: null,
+    yAxisModel: null
+  };
+  return S(t, function(e, i) {
+    var n = i.replace(/Model$/, ""), a = r.getReferringComponents(n, hn).models[0];
+    if (process.env.NODE_ENV !== "production" && !a)
+      throw new Error(n + ' "' + fn(r.get(n + "Index"), r.get(n + "Id"), 0) + '" not found');
+    t[i] = a;
+  }), t;
+}
+var et = Math.PI, ft = (
+  /** @class */
+  (function() {
+    function r(t, e) {
+      this.group = new pe(), this.opt = e, this.axisModel = t, nt(e, {
+        labelOffset: 0,
+        nameDirection: 1,
+        tickDirection: 1,
+        labelDirection: 1,
+        silent: !0,
+        handleAutoShown: function() {
+          return !0;
+        }
+      });
+      var i = new pe({
+        x: e.position[0],
+        y: e.position[1],
+        rotation: e.rotation
+      });
+      i.updateTransform(), this._transformGroup = i;
+    }
+    return r.prototype.hasBuilder = function(t) {
+      return !!ei[t];
+    }, r.prototype.add = function(t) {
+      ei[t](this.opt, this.axisModel, this.group, this._transformGroup);
+    }, r.prototype.getGroup = function() {
+      return this.group;
+    }, r.innerTextLayout = function(t, e, i) {
+      var n = Bi(e - t), a, o;
+      return Yt(n) ? (o = i > 0 ? "top" : "bottom", a = "center") : Yt(n - et) ? (o = i > 0 ? "bottom" : "top", a = "center") : (o = "middle", n > 0 && n < et ? a = i > 0 ? "right" : "left" : a = i > 0 ? "left" : "right"), {
+        rotation: n,
+        textAlign: a,
+        textVerticalAlign: o
+      };
+    }, r.makeAxisEventDataBase = function(t) {
+      var e = {
+        componentType: t.mainType,
+        componentIndex: t.componentIndex
+      };
+      return e[t.mainType + "Index"] = t.componentIndex, e;
+    }, r.isLabelSilent = function(t) {
+      var e = t.get("tooltip");
+      return t.get("silent") || !(t.get("triggerEvent") || e && e.show);
+    }, r;
+  })()
+), ei = {
+  axisLine: function(r, t, e, i) {
+    var n = t.get(["axisLine", "show"]);
+    if (n === "auto" && r.handleAutoShown && (n = r.handleAutoShown("axisLine")), !!n) {
+      var a = t.axis.getExtent(), o = i.transform, s = [a[0], 0], l = [a[1], 0], u = s[0] > l[0];
+      o && (Gt(s, s, o), Gt(l, l, o));
+      var h = F({
+        lineCap: "round"
+      }, t.getModel(["axisLine", "lineStyle"]).getLineStyle()), f = new Ni({
+        shape: {
+          x1: s[0],
+          y1: s[1],
+          x2: l[0],
+          y2: l[1]
+        },
+        style: h,
+        strokeContainThreshold: r.strokeContainThreshold || 5,
+        silent: !0,
+        z2: 1
+      });
+      Ri(f.shape, f.style.lineWidth), f.anid = "line", e.add(f);
+      var v = t.get(["axisLine", "symbol"]);
+      if (v != null) {
+        var d = t.get(["axisLine", "symbolSize"]);
+        R(v) && (v = [v, v]), (R(d) || we(d)) && (d = [d, d]);
+        var c = vn(t.get(["axisLine", "symbolOffset"]) || 0, d), g = d[0], m = d[1];
+        S([{
+          rotate: r.rotation + Math.PI / 2,
+          offset: c[0],
+          r: 0
+        }, {
+          rotate: r.rotation - Math.PI / 2,
+          offset: c[1],
+          r: Math.sqrt((s[0] - l[0]) * (s[0] - l[0]) + (s[1] - l[1]) * (s[1] - l[1]))
+        }], function(p, _) {
+          if (v[_] !== "none" && v[_] != null) {
+            var y = dn(v[_], -g / 2, -m / 2, g, m, h.stroke, !0), x = p.r + p.offset, L = u ? l : s;
+            y.attr({
+              rotation: p.rotate,
+              x: L[0] + x * Math.cos(r.rotation),
+              y: L[1] - x * Math.sin(r.rotation),
+              silent: !0,
+              z2: 11
+            }), e.add(y);
+          }
+        });
+      }
+    }
+  },
+  axisTickLabel: function(r, t, e, i) {
+    var n = Wa(e, i, t, r), a = Ga(e, i, t, r);
+    if (za(t, a, n), Va(e, i, t, r.tickDirection), t.get(["axisLabel", "hideOverlap"])) {
+      var o = Ba(at(a, function(s) {
+        return {
+          label: s,
+          priority: s.z2,
+          defaultAttr: {
+            ignore: s.ignore
+          }
+        };
+      }));
+      Ha(o);
+    }
+  },
+  axisName: function(r, t, e, i) {
+    var n = Tt(r.axisName, t.get("name"));
+    if (n) {
+      var a = t.get("nameLocation"), o = r.nameDirection, s = t.getModel("nameTextStyle"), l = t.get("nameGap") || 0, u = t.axis.getExtent(), h = u[0] > u[1] ? -1 : 1, f = [
+        a === "start" ? u[0] - h * l : a === "end" ? u[1] + h * l : (u[0] + u[1]) / 2,
+        // Reuse labelOffset.
+        ri(a) ? r.labelOffset + o * l : 0
+      ], v, d = t.get("nameRotate");
+      d != null && (d = d * et / 180);
+      var c;
+      ri(a) ? v = ft.innerTextLayout(
+        r.rotation,
+        d != null ? d : r.rotation,
+        // Adapt to axis.
+        o
+      ) : (v = Fa(r.rotation, a, d || 0, u), c = r.axisNameAvailableWidth, c != null && (c = Math.abs(c / Math.sin(v.rotation)), !isFinite(c) && (c = null)));
+      var g = s.getFont(), m = t.get("nameTruncate", !0) || {}, p = m.ellipsis, _ = Tt(r.nameTruncateMaxWidth, m.maxWidth, c), y = new Kt({
+        x: f[0],
+        y: f[1],
+        rotation: v.rotation,
+        silent: ft.isLabelSilent(t),
+        style: Me(s, {
+          text: n,
+          font: g,
+          overflow: "truncate",
+          width: _,
+          ellipsis: p,
+          fill: s.getTextColor() || t.get(["axisLine", "lineStyle", "color"]),
+          align: s.get("align") || v.textAlign,
+          verticalAlign: s.get("verticalAlign") || v.textVerticalAlign
+        }),
+        z2: 1
+      });
+      if (ki({
+        el: y,
+        componentModel: t,
+        itemName: n
+      }), y.__fullText = n, y.anid = "name", t.get("triggerEvent")) {
+        var x = ft.makeAxisEventDataBase(t);
+        x.targetType = "axisName", x.name = n, Q(y).eventData = x;
+      }
+      i.add(y), y.updateTransform(), e.add(y), y.decomposeTransform();
+    }
+  }
+};
+function Fa(r, t, e, i) {
+  var n = Bi(e - r), a, o, s = i[0] > i[1], l = t === "start" && !s || t !== "start" && s;
+  return Yt(n - et / 2) ? (o = l ? "bottom" : "top", a = "center") : Yt(n - et * 1.5) ? (o = l ? "top" : "bottom", a = "center") : (o = "middle", n < et * 1.5 && n > et / 2 ? a = l ? "left" : "right" : a = l ? "right" : "left"), {
+    rotation: n,
+    textAlign: a,
+    textVerticalAlign: o
+  };
+}
+function za(r, t, e) {
+  if (!ka(r.axis)) {
+    var i = r.get(["axisLabel", "showMinLabel"]), n = r.get(["axisLabel", "showMaxLabel"]);
+    t = t || [], e = e || [];
+    var a = t[0], o = t[1], s = t[t.length - 1], l = t[t.length - 2], u = e[0], h = e[1], f = e[e.length - 1], v = e[e.length - 2];
+    i === !1 ? (Y(a), Y(u)) : ii(a, o) && (i ? (Y(o), Y(h)) : (Y(a), Y(u))), n === !1 ? (Y(s), Y(f)) : ii(l, s) && (n ? (Y(l), Y(v)) : (Y(s), Y(f)));
+  }
+}
+function Y(r) {
+  r && (r.ignore = !0);
+}
+function ii(r, t) {
+  var e = r && r.getBoundingRect().clone(), i = t && t.getBoundingRect().clone();
+  if (!(!e || !i)) {
+    var n = cn([]);
+    return Hi(n, n, -r.rotation), e.applyTransform(ze([], n, r.getLocalTransform())), i.applyTransform(ze([], n, t.getLocalTransform())), e.intersect(i);
+  }
+}
+function ri(r) {
+  return r === "middle" || r === "center";
+}
+function ur(r, t, e, i, n) {
+  for (var a = [], o = [], s = [], l = 0; l < r.length; l++) {
+    var u = r[l].coord;
+    o[0] = u, o[1] = 0, s[0] = u, s[1] = e, t && (Gt(o, o, t), Gt(s, s, t));
+    var h = new Ni({
+      shape: {
+        x1: o[0],
+        y1: o[1],
+        x2: s[0],
+        y2: s[1]
+      },
+      style: i,
+      z2: 2,
+      autoBatch: !0,
+      silent: !0
+    });
+    Ri(h.shape, h.style.lineWidth), h.anid = n + "_" + r[l].tickValue, a.push(h);
+  }
+  return a;
+}
+function Wa(r, t, e, i) {
+  var n = e.axis, a = e.getModel("axisTick"), o = a.get("show");
+  if (o === "auto" && i.handleAutoShown && (o = i.handleAutoShown("axisTick")), !(!o || n.scale.isBlank())) {
+    for (var s = a.getModel("lineStyle"), l = i.tickDirection * a.get("length"), u = n.getTicksCoords(), h = ur(u, t.transform, l, nt(s.getLineStyle(), {
+      stroke: e.get(["axisLine", "lineStyle", "color"])
+    }), "ticks"), f = 0; f < h.length; f++)
+      r.add(h[f]);
+    return h;
+  }
+}
+function Va(r, t, e, i) {
+  var n = e.axis, a = e.getModel("minorTick");
+  if (!(!a.get("show") || n.scale.isBlank())) {
+    var o = n.getMinorTicksCoords();
+    if (o.length)
+      for (var s = a.getModel("lineStyle"), l = i * a.get("length"), u = nt(s.getLineStyle(), nt(e.getModel("axisTick").getLineStyle(), {
+        stroke: e.get(["axisLine", "lineStyle", "color"])
+      })), h = 0; h < o.length; h++)
+        for (var f = ur(o[h], t.transform, l, u, "minorticks_" + h), v = 0; v < f.length; v++)
+          r.add(f[v]);
+  }
+}
+function Ga(r, t, e, i) {
+  var n = e.axis, a = Tt(i.axisLabelShow, e.get(["axisLabel", "show"]));
+  if (!(!a || n.scale.isBlank())) {
+    var o = e.getModel("axisLabel"), s = o.get("margin"), l = n.getViewLabels(), u = (Tt(i.labelRotate, o.get("rotate")) || 0) * et / 180, h = ft.innerTextLayout(i.rotation, u, i.labelDirection), f = e.getCategories && e.getCategories(!0), v = [], d = ft.isLabelSilent(e), c = e.get("triggerEvent");
+    return S(l, function(g, m) {
+      var p = n.scale.type === "ordinal" ? n.scale.getRawOrdinalNumber(g.tickValue) : g.tickValue, _ = g.formattedLabel, y = g.rawLabel, x = o;
+      if (f && f[p]) {
+        var L = f[p];
+        V(L) && L.textStyle && (x = new ut(L.textStyle, o, e.ecModel));
+      }
+      var T = x.getTextColor() || e.get(["axisLine", "lineStyle", "color"]), D = n.dataToCoord(p), I = x.getShallow("align", !0) || h.textAlign, M = ct(x.getShallow("alignMinLabel", !0), I), w = ct(x.getShallow("alignMaxLabel", !0), I), b = x.getShallow("verticalAlign", !0) || x.getShallow("baseline", !0) || h.textVerticalAlign, A = ct(x.getShallow("verticalAlignMinLabel", !0), b), C = ct(x.getShallow("verticalAlignMaxLabel", !0), b), P = new Kt({
+        x: D,
+        y: i.labelOffset + i.labelDirection * s,
+        rotation: h.rotation,
+        silent: d,
+        z2: 10 + (g.level || 0),
+        style: Me(x, {
+          text: _,
+          align: m === 0 ? M : m === l.length - 1 ? w : I,
+          verticalAlign: m === 0 ? A : m === l.length - 1 ? C : b,
+          fill: W(T) ? T(
+            // (1) In category axis with data zoom, tick is not the original
+            // index of axis.data. So tick should not be exposed to user
+            // in category axis.
+            // (2) Compatible with previous version, which always use formatted label as
+            // input. But in interval scale the formatted label is like '223,445', which
+            // maked user replace ','. So we modify it to return original val but remain
+            // it as 'string' to avoid error in replacing.
+            n.type === "category" ? y : n.type === "value" ? p + "" : p,
+            m
+          ) : T
+        })
+      });
+      if (P.anid = "label_" + p, ki({
+        el: P,
+        componentModel: e,
+        itemName: _,
+        formatterParamsExtra: {
+          isTruncated: function() {
+            return P.isTruncated;
+          },
+          value: y,
+          tickIndex: m
+        }
+      }), c) {
+        var O = ft.makeAxisEventDataBase(e);
+        O.targetType = "axisLabel", O.value = y, O.tickIndex = m, n.type === "category" && (O.dataIndex = p), Q(P).eventData = O;
+      }
+      t.add(P), P.updateTransform(), v.push(P), r.add(P), P.decomposeTransform();
+    }), v;
+  }
+}
+function Ya(r, t) {
+  var e = {
+    /**
+     * key: makeKey(axis.model)
+     * value: {
+     *      axis,
+     *      coordSys,
+     *      axisPointerModel,
+     *      triggerTooltip,
+     *      triggerEmphasis,
+     *      involveSeries,
+     *      snap,
+     *      seriesModels,
+     *      seriesDataCount
+     * }
+     */
+    axesInfo: {},
+    seriesInvolved: !1,
+    /**
+     * key: makeKey(coordSys.model)
+     * value: Object: key makeKey(axis.model), value: axisInfo
+     */
+    coordSysAxesInfo: {},
+    coordSysMap: {}
+  };
+  return Xa(e, r, t), e.seriesInvolved && Za(e, r), e;
+}
+function Xa(r, t, e) {
+  var i = t.getComponent("tooltip"), n = t.getComponent("axisPointer"), a = n.get("link", !0) || [], o = [];
+  S(e.getCoordinateSystems(), function(s) {
+    if (!s.axisPointerEnabled)
+      return;
+    var l = It(s.model), u = r.coordSysAxesInfo[l] = {};
+    r.coordSysMap[l] = s;
+    var h = s.model, f = h.getModel("tooltip", i);
+    if (S(s.getAxes(), rt(g, !1, null)), s.getTooltipAxes && i && f.get("show")) {
+      var v = f.get("trigger") === "axis", d = f.get(["axisPointer", "type"]) === "cross", c = s.getTooltipAxes(f.get(["axisPointer", "axis"]));
+      (v || d) && S(c.baseAxes, rt(g, d ? "cross" : !0, v)), d && S(c.otherAxes, rt(g, "cross", !1));
+    }
+    function g(m, p, _) {
+      var y = _.model.getModel("axisPointer", n), x = y.get("show");
+      if (!(!x || x === "auto" && !m && !ye(y))) {
+        p == null && (p = y.get("triggerTooltip")), y = m ? Ua(_, f, n, t, m, p) : y;
+        var L = y.get("snap"), T = y.get("triggerEmphasis"), D = It(_.model), I = p || L || _.type === "category", M = r.axesInfo[D] = {
+          key: D,
+          axis: _,
+          coordSys: s,
+          axisPointerModel: y,
+          triggerTooltip: p,
+          triggerEmphasis: T,
+          involveSeries: I,
+          snap: L,
+          useHandle: ye(y),
+          seriesModels: [],
+          linkGroup: null
+        };
+        u[D] = M, r.seriesInvolved = r.seriesInvolved || I;
+        var w = Ka(a, _);
+        if (w != null) {
+          var b = o[w] || (o[w] = {
+            axesInfo: {}
+          });
+          b.axesInfo[D] = M, b.mapper = a[w].mapper, M.linkGroup = b;
+        }
+      }
+    }
+  });
+}
+function Ua(r, t, e, i, n, a) {
+  var o = t.getModel("axisPointer"), s = ["type", "snap", "lineStyle", "shadowStyle", "label", "animation", "animationDurationUpdate", "animationEasingUpdate", "z"], l = {};
+  S(s, function(v) {
+    l[v] = Ct(o.get(v));
+  }), l.snap = r.type !== "category" && !!a, o.get("type") === "cross" && (l.type = "line");
+  var u = l.label || (l.label = {});
+  if (u.show == null && (u.show = !1), n === "cross") {
+    var h = o.get(["label", "show"]);
+    if (u.show = h != null ? h : !0, !a) {
+      var f = l.lineStyle = o.get("crossStyle");
+      f && nt(u, f.textStyle);
+    }
+  }
+  return r.model.getModel("axisPointer", new ut(l, e, i));
+}
+function Za(r, t) {
+  t.eachSeries(function(e) {
+    var i = e.coordinateSystem, n = e.get(["tooltip", "trigger"], !0), a = e.get(["tooltip", "show"], !0);
+    !i || n === "none" || n === !1 || n === "item" || a === !1 || e.get(["axisPointer", "show"], !0) === !1 || S(r.coordSysAxesInfo[It(i.model)], function(o) {
+      var s = o.axis;
+      i.getAxis(s.dim) === s && (o.seriesModels.push(e), o.seriesDataCount == null && (o.seriesDataCount = 0), o.seriesDataCount += e.getData().count());
+    });
+  });
+}
+function Ka(r, t) {
+  for (var e = t.model, i = t.dim, n = 0; n < r.length; n++) {
+    var a = r[n] || {};
+    if (oe(a[i + "AxisId"], e.id) || oe(a[i + "AxisIndex"], e.componentIndex) || oe(a[i + "AxisName"], e.name))
+      return n;
+  }
+}
+function oe(r, t) {
+  return r === "all" || H(r) && Zt(r, t) >= 0 || r === t;
+}
+function $a(r) {
+  var t = Le(r);
+  if (t) {
+    var e = t.axisPointerModel, i = t.axis.scale, n = e.option, a = e.get("status"), o = e.get("value");
+    o != null && (o = i.parse(o));
+    var s = ye(e);
+    a == null && (n.status = s ? "show" : "hide");
+    var l = i.getExtent().slice();
+    l[0] > l[1] && l.reverse(), // Pick a value on axis when initializing.
+    (o == null || o > l[1]) && (o = l[1]), o < l[0] && (o = l[0]), n.value = o, s && (n.status = t.axis.scale.isBlank() ? "hide" : "show");
+  }
+}
+function Le(r) {
+  var t = (r.ecModel.getComponent("axisPointer") || {}).coordSysAxesInfo;
+  return t && t.axesInfo[It(r)];
+}
+function qa(r) {
+  var t = Le(r);
+  return t && t.axisPointerModel;
+}
+function ye(r) {
+  return !!r.get(["handle", "show"]);
+}
+function It(r) {
+  return r.type + "||" + r.id;
+}
+var se = {}, Qa = (
+  /** @class */
+  (function(r) {
+    K(t, r);
+    function t() {
+      var e = r !== null && r.apply(this, arguments) || this;
+      return e.type = t.type, e;
+    }
+    return t.prototype.render = function(e, i, n, a) {
+      this.axisPointerClass && $a(e), r.prototype.render.apply(this, arguments), this._doUpdateAxisPointerClass(e, n, !0);
+    }, t.prototype.updateAxisPointer = function(e, i, n, a) {
+      this._doUpdateAxisPointerClass(e, n, !1);
+    }, t.prototype.remove = function(e, i) {
+      var n = this._axisPointer;
+      n && n.remove(i);
+    }, t.prototype.dispose = function(e, i) {
+      this._disposeAxisPointer(i), r.prototype.dispose.apply(this, arguments);
+    }, t.prototype._doUpdateAxisPointerClass = function(e, i, n) {
+      var a = t.getAxisPointerClass(this.axisPointerClass);
+      if (a) {
+        var o = qa(e);
+        o ? (this._axisPointer || (this._axisPointer = new a())).render(e, o, i, n) : this._disposeAxisPointer(i);
+      }
+    }, t.prototype._disposeAxisPointer = function(e) {
+      this._axisPointer && this._axisPointer.dispose(e), this._axisPointer = null;
+    }, t.registerAxisPointerClass = function(e, i) {
+      if (process.env.NODE_ENV !== "production" && se[e])
+        throw new Error("axisPointer " + e + " exists");
+      se[e] = i;
+    }, t.getAxisPointerClass = function(e) {
+      return e && se[e];
+    }, t.type = "axis", t;
+  })(Dt)
+), lt = Ut(), ni = Ct, le = X, Ja = (
+  /** @class */
+  (function() {
+    function r() {
+      this._dragging = !1, this.animationThreshold = 15;
+    }
+    return r.prototype.render = function(t, e, i, n) {
+      var a = e.get("value"), o = e.get("status");
+      if (this._axisModel = t, this._axisPointerModel = e, this._api = i, !(!n && this._lastValue === a && this._lastStatus === o)) {
+        this._lastValue = a, this._lastStatus = o;
+        var s = this._group, l = this._handle;
+        if (!o || o === "hide") {
+          s && s.hide(), l && l.hide();
+          return;
+        }
+        s && s.show(), l && l.show();
+        var u = {};
+        this.makeElOption(u, a, t, e, i);
+        var h = u.graphicKey;
+        h !== this._lastGraphicKey && this.clear(i), this._lastGraphicKey = h;
+        var f = this._moveAnimation = this.determineAnimation(t, e);
+        if (!s)
+          s = this._group = new pe(), this.createPointerEl(s, u, t, e), this.createLabelEl(s, u, t, e), i.getZr().add(s);
+        else {
+          var v = rt(ai, e, f);
+          this.updatePointerEl(s, u, v), this.updateLabelEl(s, u, v, e);
+        }
+        si(s, e, !0), this._renderHandle(a);
+      }
+    }, r.prototype.remove = function(t) {
+      this.clear(t);
+    }, r.prototype.dispose = function(t) {
+      this.clear(t);
+    }, r.prototype.determineAnimation = function(t, e) {
+      var i = e.get("animation"), n = t.axis, a = n.type === "category", o = e.get("snap");
+      if (!o && !a)
+        return !1;
+      if (i === "auto" || i == null) {
+        var s = this.animationThreshold;
+        if (a && n.getBandWidth() > s)
+          return !0;
+        if (o) {
+          var l = Le(t).seriesDataCount, u = n.getExtent();
+          return Math.abs(u[0] - u[1]) / l > s;
+        }
+        return !1;
+      }
+      return i === !0;
+    }, r.prototype.makeElOption = function(t, e, i, n, a) {
+    }, r.prototype.createPointerEl = function(t, e, i, n) {
+      var a = e.pointer;
+      if (a) {
+        var o = lt(t).pointerEl = new pn[a.type](ni(e.pointer));
+        t.add(o);
+      }
+    }, r.prototype.createLabelEl = function(t, e, i, n) {
+      if (e.label) {
+        var a = lt(t).labelEl = new Kt(ni(e.label));
+        t.add(a), oi(a, n);
+      }
+    }, r.prototype.updatePointerEl = function(t, e, i) {
+      var n = lt(t).pointerEl;
+      n && e.pointer && (n.setStyle(e.pointer.style), i(n, {
+        shape: e.pointer.shape
+      }));
+    }, r.prototype.updateLabelEl = function(t, e, i, n) {
+      var a = lt(t).labelEl;
+      a && (a.setStyle(e.label.style), i(a, {
+        // Consider text length change in vertical axis, animation should
+        // be used on shape, otherwise the effect will be weird.
+        // TODOTODO
+        // shape: elOption.label.shape,
+        x: e.label.x,
+        y: e.label.y
+      }), oi(a, n));
+    }, r.prototype._renderHandle = function(t) {
+      if (!(this._dragging || !this.updateHandleTransform)) {
+        var e = this._axisPointerModel, i = this._api.getZr(), n = this._handle, a = e.getModel("handle"), o = e.get("status");
+        if (!a.get("show") || !o || o === "hide") {
+          n && i.remove(n), this._handle = null;
+          return;
+        }
+        var s;
+        this._handle || (s = !0, n = this._handle = gn(a.get("icon"), {
+          cursor: "move",
+          draggable: !0,
+          onmousemove: function(u) {
+            mn(u.event);
+          },
+          onmousedown: le(this._onHandleDragMove, this, 0, 0),
+          drift: le(this._onHandleDragMove, this),
+          ondragend: le(this._onHandleDragEnd, this)
+        }), i.add(n)), si(n, e, !1), n.setStyle(a.getItemStyle(null, ["color", "borderColor", "borderWidth", "opacity", "shadowColor", "shadowBlur", "shadowOffsetX", "shadowOffsetY"]));
+        var l = a.get("size");
+        H(l) || (l = [l, l]), n.scaleX = l[0] / 2, n.scaleY = l[1] / 2, Fi(this, "_doDispatchAxisPointer", a.get("throttle") || 0, "fixRate"), this._moveHandleToValue(t, s);
+      }
+    }, r.prototype._moveHandleToValue = function(t, e) {
+      ai(this._axisPointerModel, !e && this._moveAnimation, this._handle, ue(this.getHandleTransform(t, this._axisModel, this._axisPointerModel)));
+    }, r.prototype._onHandleDragMove = function(t, e) {
+      var i = this._handle;
+      if (i) {
+        this._dragging = !0;
+        var n = this.updateHandleTransform(ue(i), [t, e], this._axisModel, this._axisPointerModel);
+        this._payloadInfo = n, i.stopAnimation(), i.attr(ue(n)), lt(i).lastProp = null, this._doDispatchAxisPointer();
+      }
+    }, r.prototype._doDispatchAxisPointer = function() {
+      var t = this._handle;
+      if (t) {
+        var e = this._payloadInfo, i = this._axisModel;
+        this._api.dispatchAction({
+          type: "updateAxisPointer",
+          x: e.cursorPoint[0],
+          y: e.cursorPoint[1],
+          tooltipOption: e.tooltipOption,
+          axesInfo: [{
+            axisDim: i.axis.dim,
+            axisIndex: i.componentIndex
+          }]
+        });
+      }
+    }, r.prototype._onHandleDragEnd = function() {
+      this._dragging = !1;
+      var t = this._handle;
+      if (t) {
+        var e = this._axisPointerModel.get("value");
+        this._moveHandleToValue(e), this._api.dispatchAction({
+          type: "hideTip"
+        });
+      }
+    }, r.prototype.clear = function(t) {
+      this._lastValue = null, this._lastStatus = null;
+      var e = t.getZr(), i = this._group, n = this._handle;
+      e && i && (this._lastGraphicKey = null, i && e.remove(i), n && e.remove(n), this._group = null, this._handle = null, this._payloadInfo = null), ge(this, "_doDispatchAxisPointer");
+    }, r.prototype.doClear = function() {
+    }, r.prototype.buildLabel = function(t, e, i) {
+      return i = i || 0, {
+        x: t[i],
+        y: t[1 - i],
+        width: e[i],
+        height: e[1 - i]
+      };
+    }, r;
+  })()
+);
+function ai(r, t, e, i) {
+  hr(lt(e).lastProp, i) || (lt(e).lastProp = i, t ? _n(e, i, r) : (e.stopAnimation(), e.attr(i)));
+}
+function hr(r, t) {
+  if (V(r) && V(t)) {
+    var e = !0;
+    return S(t, function(i, n) {
+      e = e && hr(r[n], i);
+    }), !!e;
+  } else
+    return r === t;
+}
+function oi(r, t) {
+  r[t.get(["label", "show"]) ? "show" : "hide"]();
+}
+function ue(r) {
+  return {
+    x: r.x || 0,
+    y: r.y || 0,
+    rotation: r.rotation || 0
+  };
+}
+function si(r, t, e) {
+  var i = t.get("z"), n = t.get("zlevel");
+  r && r.traverse(function(a) {
+    a.type !== "group" && (i != null && (a.z = i), n != null && (a.zlevel = n), a.silent = e);
+  });
+}
+function ja(r) {
+  var t = r.get("type"), e = r.getModel(t + "Style"), i;
+  return t === "line" ? (i = e.getLineStyle(), i.fill = null) : t === "shadow" && (i = e.getAreaStyle(), i.stroke = null), i;
+}
+function to(r, t, e, i, n) {
+  var a = e.get("value"), o = fr(a, t.axis, t.ecModel, e.get("seriesDataIndices"), {
+    precision: e.get(["label", "precision"]),
+    formatter: e.get(["label", "formatter"])
+  }), s = e.getModel("label"), l = zi(s.get("padding") || 0), u = s.getFont(), h = wn(o, u), f = n.position, v = h.width + l[1] + l[3], d = h.height + l[0] + l[2], c = n.align;
+  c === "right" && (f[0] -= v), c === "center" && (f[0] -= v / 2);
+  var g = n.verticalAlign;
+  g === "bottom" && (f[1] -= d), g === "middle" && (f[1] -= d / 2), eo(f, v, d, i);
+  var m = s.get("backgroundColor");
+  (!m || m === "auto") && (m = t.get(["axisLine", "lineStyle", "color"])), r.label = {
+    // shape: {x: 0, y: 0, width: width, height: height, r: labelModel.get('borderRadius')},
+    x: f[0],
+    y: f[1],
+    style: Me(s, {
+      text: o,
+      font: u,
+      fill: s.getTextColor(),
+      padding: l,
+      backgroundColor: m
+    }),
+    // Label should be over axisPointer.
+    z2: 10
+  };
+}
+function eo(r, t, e, i) {
+  var n = i.getWidth(), a = i.getHeight();
+  r[0] = Math.min(r[0] + t, n) - t, r[1] = Math.min(r[1] + e, a) - e, r[0] = Math.max(r[0], 0), r[1] = Math.max(r[1], 0);
+}
+function fr(r, t, e, i, n) {
+  r = t.scale.parse(r);
+  var a = t.scale.getLabel({
+    value: r
+  }, {
+    // If `precision` is set, width can be fixed (like '12.00500'), which
+    // helps to debounce when when moving label.
+    precision: n.precision
+  }), o = n.formatter;
+  if (o) {
+    var s = {
+      value: Ie(t, {
+        value: r
+      }),
+      axisDimension: t.dim,
+      axisIndex: t.index,
+      seriesData: []
+    };
+    S(i, function(l) {
+      var u = e.getSeriesByIndex(l.seriesIndex), h = l.dataIndexInside, f = u && u.getDataParams(h);
+      f && s.seriesData.push(f);
+    }), R(o) ? a = o.replace("{value}", a) : W(o) && (a = o(s));
+  }
+  return a;
+}
+function vr(r, t, e) {
+  var i = bn();
+  return Hi(i, i, e.rotation), yn(i, i, e.position), xn([r.dataToCoord(t), (e.labelOffset || 0) + (e.labelDirection || 1) * (e.labelMargin || 0)], i);
+}
+function io(r, t, e, i, n, a) {
+  var o = ft.innerTextLayout(e.rotation, 0, e.labelDirection);
+  e.labelMargin = n.get(["label", "margin"]), to(t, i, n, a, {
+    position: vr(i.axis, r, e),
+    align: o.textAlign,
+    verticalAlign: o.textVerticalAlign
+  });
+}
+function ro(r, t, e) {
+  return e = e || 0, {
+    x1: r[e],
+    y1: r[1 - e],
+    x2: t[e],
+    y2: t[1 - e]
+  };
+}
+function no(r, t, e) {
+  return e = e || 0, {
+    x: r[e],
+    y: r[1 - e],
+    width: t[e],
+    height: t[1 - e]
+  };
+}
+function vs(r, t, e, i, n, a) {
+  return {
+    cx: r,
+    cy: t,
+    r0: e,
+    r: i,
+    startAngle: n,
+    endAngle: a,
+    clockwise: !0
+  };
+}
+var ao = (
+  /** @class */
+  (function(r) {
+    K(t, r);
+    function t() {
+      return r !== null && r.apply(this, arguments) || this;
+    }
+    return t.prototype.makeElOption = function(e, i, n, a, o) {
+      var s = n.axis, l = s.grid, u = a.get("type"), h = li(l, s).getOtherAxis(s).getGlobalExtent(), f = s.toGlobalCoord(s.dataToCoord(i, !0));
+      if (u && u !== "none") {
+        var v = ja(a), d = oo[u](s, f, h);
+        d.style = v, e.graphicKey = d.type, e.pointer = d;
+      }
+      var c = ti(l.model, n);
+      io(
+        // @ts-ignore
+        i,
+        e,
+        c,
+        n,
+        a,
+        o
+      );
+    }, t.prototype.getHandleTransform = function(e, i, n) {
+      var a = ti(i.axis.grid.model, i, {
+        labelInside: !1
+      });
+      a.labelMargin = n.get(["handle", "margin"]);
+      var o = vr(i.axis, e, a);
+      return {
+        x: o[0],
+        y: o[1],
+        rotation: a.rotation + (a.labelDirection < 0 ? Math.PI : 0)
+      };
+    }, t.prototype.updateHandleTransform = function(e, i, n, a) {
+      var o = n.axis, s = o.grid, l = o.getGlobalExtent(!0), u = li(s, o).getOtherAxis(o).getGlobalExtent(), h = o.dim === "x" ? 0 : 1, f = [e.x, e.y];
+      f[h] += i[h], f[h] = Math.min(l[1], f[h]), f[h] = Math.max(l[0], f[h]);
+      var v = (u[1] + u[0]) / 2, d = [v, v];
+      d[h] = f[h];
+      var c = [{
+        verticalAlign: "middle"
+      }, {
+        align: "center"
+      }];
+      return {
+        x: f[0],
+        y: f[1],
+        rotation: e.rotation,
+        cursorPoint: d,
+        tooltipOption: c[h]
+      };
+    }, t;
+  })(Ja)
+);
+function li(r, t) {
+  var e = {};
+  return e[t.dim + "AxisIndex"] = t.index, r.getCartesian(e);
+}
+var oo = {
+  line: function(r, t, e) {
+    var i = ro([t, e[0]], [t, e[1]], ui(r));
+    return {
+      type: "Line",
+      subPixelOptimize: !0,
+      shape: i
+    };
+  },
+  shadow: function(r, t, e) {
+    var i = Math.max(1, r.getBandWidth()), n = e[1] - e[0];
+    return {
+      type: "Rect",
+      shape: no([t - i / 2, e[0]], [i, n], ui(r))
+    };
+  }
+};
+function ui(r) {
+  return r.dim === "x" ? 0 : 1;
+}
+var so = (
+  /** @class */
+  (function(r) {
+    K(t, r);
+    function t() {
+      var e = r !== null && r.apply(this, arguments) || this;
+      return e.type = t.type, e;
+    }
+    return t.type = "axisPointer", t.defaultOption = {
+      // 'auto' means that show when triggered by tooltip or handle.
+      show: "auto",
+      // zlevel: 0,
+      z: 50,
+      type: "line",
+      // axispointer triggered by tootip determine snap automatically,
+      // see `modelHelper`.
+      snap: !1,
+      triggerTooltip: !0,
+      triggerEmphasis: !0,
+      value: null,
+      status: null,
+      link: [],
+      // Do not set 'auto' here, otherwise global animation: false
+      // will not effect at this axispointer.
+      animation: null,
+      animationDurationUpdate: 200,
+      lineStyle: {
+        color: "#B9BEC9",
+        width: 1,
+        type: "dashed"
+      },
+      shadowStyle: {
+        color: "rgba(210,219,238,0.2)"
+      },
+      label: {
+        show: !0,
+        formatter: null,
+        precision: "auto",
+        margin: 3,
+        color: "#fff",
+        padding: [5, 7, 5, 7],
+        backgroundColor: "auto",
+        borderColor: null,
+        borderWidth: 0,
+        borderRadius: 3
+      },
+      handle: {
+        show: !1,
+        // eslint-disable-next-line
+        icon: "M10.7,11.9v-1.3H9.3v1.3c-4.9,0.3-8.8,4.4-8.8,9.4c0,5,3.9,9.1,8.8,9.4h1.3c4.9-0.3,8.8-4.4,8.8-9.4C19.5,16.3,15.6,12.2,10.7,11.9z M13.3,24.4H6.7v-1.2h6.6z M13.3,22H6.7v-1.2h6.6z M13.3,19.6H6.7v-1.2h6.6z",
+        size: 45,
+        // handle margin is from symbol center to axis, which is stable when circular move.
+        margin: 50,
+        // color: '#1b8bbd'
+        // color: '#2f4554'
+        color: "#333",
+        shadowBlur: 3,
+        shadowColor: "#aaa",
+        shadowOffsetX: 0,
+        shadowOffsetY: 2,
+        // For mobile performance
+        throttle: 40
+      }
+    }, t;
+  })(St)
+), J = Ut(), lo = S;
+function dr(r, t, e) {
+  if (!z.node) {
+    var i = t.getZr();
+    J(i).records || (J(i).records = {}), uo(i, t);
+    var n = J(i).records[r] || (J(i).records[r] = {});
+    n.handler = e;
+  }
+}
+function uo(r, t) {
+  if (J(r).initialized)
+    return;
+  J(r).initialized = !0, e("click", rt(hi, "click")), e("mousemove", rt(hi, "mousemove")), e("globalout", fo);
+  function e(i, n) {
+    r.on(i, function(a) {
+      var o = vo(t);
+      lo(J(r).records, function(s) {
+        s && n(s, a, o.dispatchAction);
+      }), ho(o.pendings, t);
+    });
+  }
+}
+function ho(r, t) {
+  var e = r.showTip.length, i = r.hideTip.length, n;
+  e ? n = r.showTip[e - 1] : i && (n = r.hideTip[i - 1]), n && (n.dispatchAction = null, t.dispatchAction(n));
+}
+function fo(r, t, e) {
+  r.handler("leave", null, e);
+}
+function hi(r, t, e, i) {
+  t.handler(r, e, i);
+}
+function vo(r) {
+  var t = {
+    showTip: [],
+    hideTip: []
+  }, e = function(i) {
+    var n = t[i.type];
+    n ? n.push(i) : (i.dispatchAction = e, r.dispatchAction(i));
+  };
+  return {
+    dispatchAction: e,
+    pendings: t
+  };
+}
+function xe(r, t) {
+  if (!z.node) {
+    var e = t.getZr(), i = (J(e).records || {})[r];
+    i && (J(e).records[r] = null);
+  }
+}
+var co = (
+  /** @class */
+  (function(r) {
+    K(t, r);
+    function t() {
+      var e = r !== null && r.apply(this, arguments) || this;
+      return e.type = t.type, e;
+    }
+    return t.prototype.render = function(e, i, n) {
+      var a = i.getComponent("tooltip"), o = e.get("triggerOn") || a && a.get("triggerOn") || "mousemove|click";
+      dr("axisPointer", n, function(s, l, u) {
+        o !== "none" && (s === "leave" || o.indexOf(s) >= 0) && u({
+          type: "updateAxisPointer",
+          currTrigger: s,
+          x: l && l.offsetX,
+          y: l && l.offsetY
+        });
+      });
+    }, t.prototype.remove = function(e, i) {
+      xe("axisPointer", i);
+    }, t.prototype.dispose = function(e, i) {
+      xe("axisPointer", i);
+    }, t.type = "axisPointer", t;
+  })(Dt)
+);
+function cr(r, t) {
+  var e = [], i = r.seriesIndex, n;
+  if (i == null || !(n = t.getSeriesByIndex(i)))
+    return {
+      point: []
+    };
+  var a = n.getData(), o = Sn(a, r);
+  if (o == null || o < 0 || H(o))
+    return {
+      point: []
+    };
+  var s = a.getItemGraphicEl(o), l = n.coordinateSystem;
+  if (n.getTooltipPosition)
+    e = n.getTooltipPosition(o) || [];
+  else if (l && l.dataToPoint)
+    if (r.isStacked) {
+      var u = l.getBaseAxis(), h = l.getOtherAxis(u), f = h.dim, v = u.dim, d = f === "x" || f === "radius" ? 1 : 0, c = a.mapDimension(v), g = [];
+      g[d] = a.get(c, o), g[1 - d] = a.get(a.getCalculationInfo("stackResultDimension"), o), e = l.dataToPoint(g) || [];
+    } else
+      e = l.dataToPoint(a.getValues(at(l.dimensions, function(p) {
+        return a.mapDimension(p);
+      }), o)) || [];
+  else if (s) {
+    var m = s.getBoundingRect().clone();
+    m.applyTransform(s.transform), e = [m.x + m.width / 2, m.y + m.height / 2];
+  }
+  return {
+    point: e,
+    el: s
+  };
+}
+var fi = Ut();
+function po(r, t, e) {
+  var i = r.currTrigger, n = [r.x, r.y], a = r, o = r.dispatchAction || X(e.dispatchAction, e), s = t.getComponent("axisPointer").coordSysAxesInfo;
+  if (s) {
+    Wt(n) && (n = cr({
+      seriesIndex: a.seriesIndex,
+      // Do not use dataIndexInside from other ec instance.
+      // FIXME: auto detect it?
+      dataIndex: a.dataIndex
+    }, t).point);
+    var l = Wt(n), u = a.axesInfo, h = s.axesInfo, f = i === "leave" || Wt(n), v = {}, d = {}, c = {
+      list: [],
+      map: {}
+    }, g = {
+      showPointer: rt(mo, d),
+      showTooltip: rt(_o, c)
+    };
+    S(s.coordSysMap, function(p, _) {
+      var y = l || p.containPoint(n);
+      S(s.coordSysAxesInfo[_], function(x, L) {
+        var T = x.axis, D = bo(u, x);
+        if (!f && y && (!u || D)) {
+          var I = D && D.value;
+          I == null && !l && (I = T.pointToData(n)), I != null && vi(x, I, g, !1, v);
+        }
+      });
+    });
+    var m = {};
+    return S(h, function(p, _) {
+      var y = p.linkGroup;
+      y && !d[_] && S(y.axesInfo, function(x, L) {
+        var T = d[L];
+        if (x !== p && T) {
+          var D = T.value;
+          y.mapper && (D = p.axis.scale.parse(y.mapper(D, di(x), di(p)))), m[p.key] = D;
+        }
+      });
+    }), S(m, function(p, _) {
+      vi(h[_], p, g, !0, v);
+    }), yo(d, h, v), xo(c, n, r, o), wo(h, o, e), v;
+  }
+}
+function vi(r, t, e, i, n) {
+  var a = r.axis;
+  if (!(a.scale.isBlank() || !a.containData(t))) {
+    if (!r.involveSeries) {
+      e.showPointer(r, t);
+      return;
+    }
+    var o = go(t, r), s = o.payloadBatch, l = o.snapToValue;
+    s[0] && n.seriesIndex == null && F(n, s[0]), !i && r.snap && a.containData(l) && l != null && (t = l), e.showPointer(r, t, s), e.showTooltip(r, o, l);
+  }
+}
+function go(r, t) {
+  var e = t.axis, i = e.dim, n = r, a = [], o = Number.MAX_VALUE, s = -1;
+  return S(t.seriesModels, function(l, u) {
+    var h = l.getData().mapDimensionsAll(i), f, v;
+    if (l.getAxisTooltipData) {
+      var d = l.getAxisTooltipData(h, r, e);
+      v = d.dataIndices, f = d.nestestValue;
+    } else {
+      if (v = l.getData().indicesOfNearest(
+        h[0],
+        r,
+        // Add a threshold to avoid find the wrong dataIndex
+        // when data length is not same.
+        // false,
+        e.type === "category" ? 0.5 : null
+      ), !v.length)
+        return;
+      f = l.getData().get(h[0], v[0]);
+    }
+    if (!(f == null || !isFinite(f))) {
+      var c = r - f, g = Math.abs(c);
+      g <= o && ((g < o || c >= 0 && s < 0) && (o = g, s = c, n = f, a.length = 0), S(v, function(m) {
+        a.push({
+          seriesIndex: l.seriesIndex,
+          dataIndexInside: m,
+          dataIndex: l.getData().getRawIndex(m)
+        });
+      }));
+    }
+  }), {
+    payloadBatch: a,
+    snapToValue: n
+  };
+}
+function mo(r, t, e, i) {
+  r[t.key] = {
+    value: e,
+    payloadBatch: i
+  };
+}
+function _o(r, t, e, i) {
+  var n = e.payloadBatch, a = t.axis, o = a.model, s = t.axisPointerModel;
+  if (!(!t.triggerTooltip || !n.length)) {
+    var l = t.coordSys.model, u = It(l), h = r.map[u];
+    h || (h = r.map[u] = {
+      coordSysId: l.id,
+      coordSysIndex: l.componentIndex,
+      coordSysType: l.type,
+      coordSysMainType: l.mainType,
+      dataByAxis: []
+    }, r.list.push(h)), h.dataByAxis.push({
+      axisDim: a.dim,
+      axisIndex: o.componentIndex,
+      axisType: o.type,
+      axisId: o.id,
+      value: i,
+      // Caustion: viewHelper.getValueLabel is actually on "view stage", which
+      // depends that all models have been updated. So it should not be performed
+      // here. Considering axisPointerModel used here is volatile, which is hard
+      // to be retrieve in TooltipView, we prepare parameters here.
+      valueLabelOpt: {
+        precision: s.get(["label", "precision"]),
+        formatter: s.get(["label", "formatter"])
+      },
+      seriesDataIndices: n.slice()
+    });
+  }
+}
+function yo(r, t, e) {
+  var i = e.axesInfo = [];
+  S(t, function(n, a) {
+    var o = n.axisPointerModel.option, s = r[a];
+    s ? (!n.useHandle && (o.status = "show"), o.value = s.value, o.seriesDataIndices = (s.payloadBatch || []).slice()) : !n.useHandle && (o.status = "hide"), o.status === "show" && i.push({
+      axisDim: n.axis.dim,
+      axisIndex: n.axis.model.componentIndex,
+      value: o.value
+    });
+  });
+}
+function xo(r, t, e, i) {
+  if (Wt(t) || !r.list.length) {
+    i({
+      type: "hideTip"
+    });
+    return;
+  }
+  var n = ((r.list[0].dataByAxis[0] || {}).seriesDataIndices || [])[0] || {};
+  i({
+    type: "showTip",
+    escapeConnect: !0,
+    x: t[0],
+    y: t[1],
+    tooltipOption: e.tooltipOption,
+    position: e.position,
+    dataIndexInside: n.dataIndexInside,
+    dataIndex: n.dataIndex,
+    seriesIndex: n.seriesIndex,
+    dataByCoordSys: r.list
+  });
+}
+function wo(r, t, e) {
+  var i = e.getZr(), n = "axisPointerLastHighlights", a = fi(i)[n] || {}, o = fi(i)[n] = {};
+  S(r, function(u, h) {
+    var f = u.axisPointerModel.option;
+    f.status === "show" && u.triggerEmphasis && S(f.seriesDataIndices, function(v) {
+      var d = v.seriesIndex + " | " + v.dataIndex;
+      o[d] = v;
+    });
+  });
+  var s = [], l = [];
+  S(a, function(u, h) {
+    !o[h] && l.push(u);
+  }), S(o, function(u, h) {
+    !a[h] && s.push(u);
+  }), l.length && e.dispatchAction({
+    type: "downplay",
+    escapeConnect: !0,
+    // Not blur others when highlight in axisPointer.
+    notBlur: !0,
+    batch: l
+  }), s.length && e.dispatchAction({
+    type: "highlight",
+    escapeConnect: !0,
+    // Not blur others when highlight in axisPointer.
+    notBlur: !0,
+    batch: s
+  });
+}
+function bo(r, t) {
+  for (var e = 0; e < (r || []).length; e++) {
+    var i = r[e];
+    if (t.axis.dim === i.axisDim && t.axis.model.componentIndex === i.axisIndex)
+      return i;
+  }
+}
+function di(r) {
+  var t = r.axis.model, e = {}, i = e.axisDim = r.axis.dim;
+  return e.axisIndex = e[i + "AxisIndex"] = t.componentIndex, e.axisName = e[i + "AxisName"] = t.name, e.axisId = e[i + "AxisId"] = t.id, e;
+}
+function Wt(r) {
+  return !r || r[0] == null || isNaN(r[0]) || r[1] == null || isNaN(r[1]);
+}
+function So(r) {
+  Qa.registerAxisPointerClass("CartesianAxisPointer", ao), r.registerComponentModel(so), r.registerComponentView(co), r.registerPreprocessor(function(t) {
+    if (t) {
+      (!t.axisPointer || t.axisPointer.length === 0) && (t.axisPointer = {});
+      var e = t.axisPointer.link;
+      e && !H(e) && (t.axisPointer.link = [e]);
+    }
+  }), r.registerProcessor(r.PRIORITY.PROCESSOR.STATISTIC, function(t, e) {
+    t.getComponent("axisPointer").coordSysAxesInfo = Ya(t, e);
+  }), r.registerAction({
+    type: "updateAxisPointer",
+    event: "updateAxisPointer",
+    update: ":updateAxisPointer"
+  }, po);
+}
+var Mo = (
+  /** @class */
+  (function(r) {
+    K(t, r);
+    function t() {
+      var e = r !== null && r.apply(this, arguments) || this;
+      return e.type = t.type, e;
+    }
+    return t.type = "tooltip", t.dependencies = ["axisPointer"], t.defaultOption = {
+      // zlevel: 0,
+      z: 60,
+      show: !0,
+      // tooltip main content
+      showContent: !0,
+      // 'trigger' only works on coordinate system.
+      // 'item' | 'axis' | 'none'
+      trigger: "item",
+      // 'click' | 'mousemove' | 'none'
+      triggerOn: "mousemove|click",
+      alwaysShowContent: !1,
+      displayMode: "single",
+      renderMode: "auto",
+      // whether restraint content inside viewRect.
+      // If renderMode: 'richText', default true.
+      // If renderMode: 'html', defaut false (for backward compat).
+      confine: null,
+      showDelay: 0,
+      hideDelay: 100,
+      // Animation transition time, unit is second
+      transitionDuration: 0.4,
+      enterable: !1,
+      backgroundColor: "#fff",
+      // box shadow
+      shadowBlur: 10,
+      shadowColor: "rgba(0, 0, 0, .2)",
+      shadowOffsetX: 1,
+      shadowOffsetY: 2,
+      // tooltip border radius, unit is px, default is 4
+      borderRadius: 4,
+      // tooltip border width, unit is px, default is 0 (no border)
+      borderWidth: 1,
+      // Tooltip inside padding, default is 5 for all direction
+      // Array is allowed to set up, right, bottom, left, same with css
+      // The default value: See `tooltip/tooltipMarkup.ts#getPaddingFromTooltipModel`.
+      padding: null,
+      // Extra css text
+      extraCssText: "",
+      // axis indicator, trigger by axis
+      axisPointer: {
+        // default is line
+        // legal values: 'line' | 'shadow' | 'cross'
+        type: "line",
+        // Valid when type is line, appoint tooltip line locate on which line. Optional
+        // legal values: 'x' | 'y' | 'angle' | 'radius' | 'auto'
+        // default is 'auto', chose the axis which type is category.
+        // for multiply y axis, cartesian coord chose x axis, polar chose angle axis
+        axis: "auto",
+        animation: "auto",
+        animationDurationUpdate: 200,
+        animationEasingUpdate: "exponentialOut",
+        crossStyle: {
+          color: "#999",
+          width: 1,
+          type: "dashed",
+          // TODO formatter
+          textStyle: {}
+        }
+        // lineStyle and shadowStyle should not be specified here,
+        // otherwise it will always override those styles on option.axisPointer.
+      },
+      textStyle: {
+        color: "#666",
+        fontSize: 14
+      }
+    }, t;
+  })(St)
+);
+function pr(r) {
+  var t = r.get("confine");
+  return t != null ? !!t : r.get("renderMode") === "richText";
+}
+function gr(r) {
+  if (z.domSupported) {
+    for (var t = document.documentElement.style, e = 0, i = r.length; e < i; e++)
+      if (r[e] in t)
+        return r[e];
+  }
+}
+var mr = gr(["transform", "webkitTransform", "OTransform", "MozTransform", "msTransform"]), Co = gr(["webkitTransition", "transition", "OTransition", "MozTransition", "msTransition"]);
+function _r(r, t) {
+  if (!r)
+    return t;
+  t = Wi(t, !0);
+  var e = r.indexOf(t);
+  return r = e === -1 ? t : "-" + r.slice(0, e) + "-" + t, r.toLowerCase();
+}
+function Do(r, t) {
+  var e = r.currentStyle || document.defaultView && document.defaultView.getComputedStyle(r);
+  return e ? e[t] : null;
+}
+var To = _r(Co, "transition"), Ae = _r(mr, "transform"), Io = "position:absolute;display:block;border-style:solid;white-space:nowrap;z-index:9999999;" + (z.transform3dSupported ? "will-change:transform;" : "");
+function Lo(r) {
+  return r = r === "left" ? "right" : r === "right" ? "left" : r === "top" ? "bottom" : "top", r;
+}
+function Ao(r, t, e) {
+  if (!R(e) || e === "inside")
+    return "";
+  var i = r.get("backgroundColor"), n = r.get("borderWidth");
+  t = Xt(t);
+  var a = Lo(e), o = Math.max(Math.round(n) * 1.5, 6), s = "", l = Ae + ":", u;
+  Zt(["left", "right"], a) > -1 ? (s += "top:50%", l += "translateY(-50%) rotate(" + (u = a === "left" ? -225 : -45) + "deg)") : (s += "left:50%", l += "translateX(-50%) rotate(" + (u = a === "top" ? 225 : 45) + "deg)");
+  var h = u * Math.PI / 180, f = o + n, v = f * Math.abs(Math.cos(h)) + f * Math.abs(Math.sin(h)), d = Math.round(((v - Math.SQRT2 * n) / 2 + Math.SQRT2 * n - (v - f) / 2) * 100) / 100;
+  s += ";" + a + ":-" + d + "px";
+  var c = t + " solid " + n + "px;", g = ["position:absolute;width:" + o + "px;height:" + o + "px;z-index:-1;", s + ";" + l + ";", "border-bottom:" + c, "border-right:" + c, "background-color:" + i + ";"];
+  return '<div style="' + g.join("") + '"></div>';
+}
+function Oo(r, t) {
+  var e = "cubic-bezier(0.23,1,0.32,1)", i = " " + r / 2 + "s " + e, n = "opacity" + i + ",visibility" + i;
+  return t || (i = " " + r + "s " + e, n += z.transformSupported ? "," + Ae + i : ",left" + i + ",top" + i), To + ":" + n;
+}
+function ci(r, t, e) {
+  var i = r.toFixed(0) + "px", n = t.toFixed(0) + "px";
+  if (!z.transformSupported)
+    return e ? "top:" + n + ";left:" + i + ";" : [["top", n], ["left", i]];
+  var a = z.transform3dSupported, o = "translate" + (a ? "3d" : "") + "(" + i + "," + n + (a ? ",0" : "") + ")";
+  return e ? "top:0;left:0;" + Ae + ":" + o + ";" : [["top", 0], ["left", 0], [mr, o]];
+}
+function Po(r) {
+  var t = [], e = r.get("fontSize"), i = r.getTextColor();
+  i && t.push("color:" + i), t.push("font:" + r.getFont());
+  var n = ct(r.get("lineHeight"), Math.round(e * 3 / 2));
+  e && t.push("line-height:" + n + "px");
+  var a = r.get("textShadowColor"), o = r.get("textShadowBlur") || 0, s = r.get("textShadowOffsetX") || 0, l = r.get("textShadowOffsetY") || 0;
+  return a && o && t.push("text-shadow:" + s + "px " + l + "px " + o + "px " + a), S(["decoration", "align"], function(u) {
+    var h = r.get(u);
+    h && t.push("text-" + u + ":" + h);
+  }), t.join(";");
+}
+function Eo(r, t, e) {
+  var i = [], n = r.get("transitionDuration"), a = r.get("backgroundColor"), o = r.get("shadowBlur"), s = r.get("shadowColor"), l = r.get("shadowOffsetX"), u = r.get("shadowOffsetY"), h = r.getModel("textStyle"), f = Vi(r, "html"), v = l + "px " + u + "px " + o + "px " + s;
+  return i.push("box-shadow:" + v), t && n && i.push(Oo(n, e)), a && i.push("background-color:" + a), S(["width", "color", "radius"], function(d) {
+    var c = "border-" + d, g = Wi(c), m = r.get(g);
+    m != null && i.push(c + ":" + m + (d === "color" ? "" : "px"));
+  }), i.push(Po(h)), f != null && i.push("padding:" + zi(f).join("px ") + "px"), i.join(";") + ";";
+}
+function pi(r, t, e, i, n) {
+  var a = t && t.painter;
+  if (e) {
+    var o = a && a.getViewportRoot();
+    o && Cn(r, o, e, i, n);
+  } else {
+    r[0] = i, r[1] = n;
+    var s = a && a.getViewportRootOffset();
+    s && (r[0] += s.offsetLeft, r[1] += s.offsetTop);
+  }
+  r[2] = r[0] / t.getWidth(), r[3] = r[1] / t.getHeight();
+}
+var ko = (
+  /** @class */
+  (function() {
+    function r(t, e) {
+      if (this._show = !1, this._styleCoord = [0, 0, 0, 0], this._enterable = !0, this._alwaysShowContent = !1, this._firstShow = !0, this._longHide = !0, z.wxa)
+        return null;
+      var i = document.createElement("div");
+      i.domBelongToZr = !0, this.el = i;
+      var n = this._zr = t.getZr(), a = e.appendTo, o = a && (R(a) ? document.querySelector(a) : We(a) ? a : W(a) && a(t.getDom()));
+      pi(this._styleCoord, n, o, t.getWidth() / 2, t.getHeight() / 2), (o || t.getDom()).appendChild(i), this._api = t, this._container = o;
+      var s = this;
+      i.onmouseenter = function() {
+        s._enterable && (clearTimeout(s._hideTimeout), s._show = !0), s._inContent = !0;
+      }, i.onmousemove = function(l) {
+        if (l = l || window.event, !s._enterable) {
+          var u = n.handler, h = n.painter.getViewportRoot();
+          Mn(h, l, !0), u.dispatch("mousemove", l);
+        }
+      }, i.onmouseleave = function() {
+        s._inContent = !1, s._enterable && s._show && s.hideLater(s._hideDelay);
+      };
+    }
+    return r.prototype.update = function(t) {
+      if (!this._container) {
+        var e = this._api.getDom(), i = Do(e, "position"), n = e.style;
+        n.position !== "absolute" && i !== "absolute" && (n.position = "relative");
+      }
+      var a = t.get("alwaysShowContent");
+      a && this._moveIfResized(), this._alwaysShowContent = a, this.el.className = t.get("className") || "";
+    }, r.prototype.show = function(t, e) {
+      clearTimeout(this._hideTimeout), clearTimeout(this._longHideTimeout);
+      var i = this.el, n = i.style, a = this._styleCoord;
+      i.innerHTML ? n.cssText = Io + Eo(t, !this._firstShow, this._longHide) + ci(a[0], a[1], !0) + ("border-color:" + Xt(e) + ";") + (t.get("extraCssText") || "") + (";pointer-events:" + (this._enterable ? "auto" : "none")) : n.display = "none", this._show = !0, this._firstShow = !1, this._longHide = !1;
+    }, r.prototype.setContent = function(t, e, i, n, a) {
+      var o = this.el;
+      if (t == null) {
+        o.innerHTML = "";
+        return;
+      }
+      var s = "";
+      if (R(a) && i.get("trigger") === "item" && !pr(i) && (s = Ao(i, n, a)), R(t))
+        o.innerHTML = t + s;
+      else if (t) {
+        o.innerHTML = "", H(t) || (t = [t]);
+        for (var l = 0; l < t.length; l++)
+          We(t[l]) && t[l].parentNode !== o && o.appendChild(t[l]);
+        if (s && o.childNodes.length) {
+          var u = document.createElement("div");
+          u.innerHTML = s, o.appendChild(u);
+        }
+      }
+    }, r.prototype.setEnterable = function(t) {
+      this._enterable = t;
+    }, r.prototype.getSize = function() {
+      var t = this.el;
+      return t ? [t.offsetWidth, t.offsetHeight] : [0, 0];
+    }, r.prototype.moveTo = function(t, e) {
+      if (this.el) {
+        var i = this._styleCoord;
+        if (pi(i, this._zr, this._container, t, e), i[0] != null && i[1] != null) {
+          var n = this.el.style, a = ci(i[0], i[1]);
+          S(a, function(o) {
+            n[o[0]] = o[1];
+          });
+        }
+      }
+    }, r.prototype._moveIfResized = function() {
+      var t = this._styleCoord[2], e = this._styleCoord[3];
+      this.moveTo(t * this._zr.getWidth(), e * this._zr.getHeight());
+    }, r.prototype.hide = function() {
+      var t = this, e = this.el.style;
+      e.visibility = "hidden", e.opacity = "0", z.transform3dSupported && (e.willChange = ""), this._show = !1, this._longHideTimeout = setTimeout(function() {
+        return t._longHide = !0;
+      }, 500);
+    }, r.prototype.hideLater = function(t) {
+      this._show && !(this._inContent && this._enterable) && !this._alwaysShowContent && (t ? (this._hideDelay = t, this._show = !1, this._hideTimeout = setTimeout(X(this.hide, this), t)) : this.hide());
+    }, r.prototype.isShow = function() {
+      return this._show;
+    }, r.prototype.dispose = function() {
+      clearTimeout(this._hideTimeout), clearTimeout(this._longHideTimeout);
+      var t = this.el.parentNode;
+      t && t.removeChild(this.el), this.el = this._container = null;
+    }, r;
+  })()
+), No = (
+  /** @class */
+  (function() {
+    function r(t) {
+      this._show = !1, this._styleCoord = [0, 0, 0, 0], this._alwaysShowContent = !1, this._enterable = !0, this._zr = t.getZr(), mi(this._styleCoord, this._zr, t.getWidth() / 2, t.getHeight() / 2);
+    }
+    return r.prototype.update = function(t) {
+      var e = t.get("alwaysShowContent");
+      e && this._moveIfResized(), this._alwaysShowContent = e;
+    }, r.prototype.show = function() {
+      this._hideTimeout && clearTimeout(this._hideTimeout), this.el.show(), this._show = !0;
+    }, r.prototype.setContent = function(t, e, i, n, a) {
+      var o = this;
+      V(t) && Dn(process.env.NODE_ENV !== "production" ? "Passing DOM nodes as content is not supported in richText tooltip!" : ""), this.el && this._zr.remove(this.el);
+      var s = i.getModel("textStyle");
+      this.el = new Kt({
+        style: {
+          rich: e.richTextStyles,
+          text: t,
+          lineHeight: 22,
+          borderWidth: 1,
+          borderColor: n,
+          textShadowColor: s.get("textShadowColor"),
+          fill: i.get(["textStyle", "color"]),
+          padding: Vi(i, "richText"),
+          verticalAlign: "top",
+          align: "left"
+        },
+        z: i.get("z")
+      }), S(["backgroundColor", "borderRadius", "shadowColor", "shadowBlur", "shadowOffsetX", "shadowOffsetY"], function(u) {
+        o.el.style[u] = i.get(u);
+      }), S(["textShadowBlur", "textShadowOffsetX", "textShadowOffsetY"], function(u) {
+        o.el.style[u] = s.get(u) || 0;
+      }), this._zr.add(this.el);
+      var l = this;
+      this.el.on("mouseover", function() {
+        l._enterable && (clearTimeout(l._hideTimeout), l._show = !0), l._inContent = !0;
+      }), this.el.on("mouseout", function() {
+        l._enterable && l._show && l.hideLater(l._hideDelay), l._inContent = !1;
+      });
+    }, r.prototype.setEnterable = function(t) {
+      this._enterable = t;
+    }, r.prototype.getSize = function() {
+      var t = this.el, e = this.el.getBoundingRect(), i = gi(t.style);
+      return [e.width + i.left + i.right, e.height + i.top + i.bottom];
+    }, r.prototype.moveTo = function(t, e) {
+      var i = this.el;
+      if (i) {
+        var n = this._styleCoord;
+        mi(n, this._zr, t, e), t = n[0], e = n[1];
+        var a = i.style, o = tt(a.borderWidth || 0), s = gi(a);
+        i.x = t + o + s.left, i.y = e + o + s.top, i.markRedraw();
+      }
+    }, r.prototype._moveIfResized = function() {
+      var t = this._styleCoord[2], e = this._styleCoord[3];
+      this.moveTo(t * this._zr.getWidth(), e * this._zr.getHeight());
+    }, r.prototype.hide = function() {
+      this.el && this.el.hide(), this._show = !1;
+    }, r.prototype.hideLater = function(t) {
+      this._show && !(this._inContent && this._enterable) && !this._alwaysShowContent && (t ? (this._hideDelay = t, this._show = !1, this._hideTimeout = setTimeout(X(this.hide, this), t)) : this.hide());
+    }, r.prototype.isShow = function() {
+      return this._show;
+    }, r.prototype.dispose = function() {
+      this._zr.remove(this.el);
+    }, r;
+  })()
+);
+function tt(r) {
+  return Math.max(0, r);
+}
+function gi(r) {
+  var t = tt(r.shadowBlur || 0), e = tt(r.shadowOffsetX || 0), i = tt(r.shadowOffsetY || 0);
+  return {
+    left: tt(t - e),
+    right: tt(t + e),
+    top: tt(t - i),
+    bottom: tt(t + i)
+  };
+}
+function mi(r, t, e, i) {
+  r[0] = e, r[1] = i, r[2] = r[0] / t.getWidth(), r[3] = r[1] / t.getHeight();
+}
+var Ro = new In({
+  shape: {
+    x: -1,
+    y: -1,
+    width: 2,
+    height: 2
+  }
+}), Bo = (
+  /** @class */
+  (function(r) {
+    K(t, r);
+    function t() {
+      var e = r !== null && r.apply(this, arguments) || this;
+      return e.type = t.type, e;
+    }
+    return t.prototype.init = function(e, i) {
+      if (!(z.node || !i.getDom())) {
+        var n = e.getComponent("tooltip"), a = this._renderMode = Tn(n.get("renderMode"));
+        this._tooltipContent = a === "richText" ? new No(i) : new ko(i, {
+          appendTo: n.get("appendToBody", !0) ? "body" : n.get("appendTo", !0)
+        });
+      }
+    }, t.prototype.render = function(e, i, n) {
+      if (!(z.node || !n.getDom())) {
+        this.group.removeAll(), this._tooltipModel = e, this._ecModel = i, this._api = n;
+        var a = this._tooltipContent;
+        a.update(e), a.setEnterable(e.get("enterable")), this._initGlobalListener(), this._keepShow(), this._renderMode !== "richText" && e.get("transitionDuration") ? Fi(this, "_updatePosition", 50, "fixRate") : ge(this, "_updatePosition");
+      }
+    }, t.prototype._initGlobalListener = function() {
+      var e = this._tooltipModel, i = e.get("triggerOn");
+      dr("itemTooltip", this._api, X(function(n, a, o) {
+        i !== "none" && (i.indexOf(n) >= 0 ? this._tryShow(a, o) : n === "leave" && this._hide(o));
+      }, this));
+    }, t.prototype._keepShow = function() {
+      var e = this._tooltipModel, i = this._ecModel, n = this._api, a = e.get("triggerOn");
+      if (this._lastX != null && this._lastY != null && a !== "none" && a !== "click") {
+        var o = this;
+        clearTimeout(this._refreshUpdateTimeout), this._refreshUpdateTimeout = setTimeout(function() {
+          !n.isDisposed() && o.manuallyShowTip(e, i, n, {
+            x: o._lastX,
+            y: o._lastY,
+            dataByCoordSys: o._lastDataByCoordSys
+          });
+        });
+      }
+    }, t.prototype.manuallyShowTip = function(e, i, n, a) {
+      if (!(a.from === this.uid || z.node || !n.getDom())) {
+        var o = _i(a, n);
+        this._ticket = "";
+        var s = a.dataByCoordSys, l = Wo(a, i, n);
+        if (l) {
+          var u = l.el.getBoundingRect().clone();
+          u.applyTransform(l.el.transform), this._tryShow({
+            offsetX: u.x + u.width / 2,
+            offsetY: u.y + u.height / 2,
+            target: l.el,
+            position: a.position,
+            // When manully trigger, the mouse is not on the el, so we'd better to
+            // position tooltip on the bottom of the el and display arrow is possible.
+            positionDefault: "bottom"
+          }, o);
+        } else if (a.tooltip && a.x != null && a.y != null) {
+          var h = Ro;
+          h.x = a.x, h.y = a.y, h.update(), Q(h).tooltipConfig = {
+            name: null,
+            option: a.tooltip
+          }, this._tryShow({
+            offsetX: a.x,
+            offsetY: a.y,
+            target: h
+          }, o);
+        } else if (s)
+          this._tryShow({
+            offsetX: a.x,
+            offsetY: a.y,
+            position: a.position,
+            dataByCoordSys: s,
+            tooltipOption: a.tooltipOption
+          }, o);
+        else if (a.seriesIndex != null) {
+          if (this._manuallyAxisShowTip(e, i, n, a))
+            return;
+          var f = cr(a, i), v = f.point[0], d = f.point[1];
+          v != null && d != null && this._tryShow({
+            offsetX: v,
+            offsetY: d,
+            target: f.el,
+            position: a.position,
+            // When manully trigger, the mouse is not on the el, so we'd better to
+            // position tooltip on the bottom of the el and display arrow is possible.
+            positionDefault: "bottom"
+          }, o);
+        } else a.x != null && a.y != null && (n.dispatchAction({
+          type: "updateAxisPointer",
+          x: a.x,
+          y: a.y
+        }), this._tryShow({
+          offsetX: a.x,
+          offsetY: a.y,
+          position: a.position,
+          target: n.getZr().findHover(a.x, a.y).target
+        }, o));
+      }
+    }, t.prototype.manuallyHideTip = function(e, i, n, a) {
+      var o = this._tooltipContent;
+      this._tooltipModel && o.hideLater(this._tooltipModel.get("hideDelay")), this._lastX = this._lastY = this._lastDataByCoordSys = null, a.from !== this.uid && this._hide(_i(a, n));
+    }, t.prototype._manuallyAxisShowTip = function(e, i, n, a) {
+      var o = a.seriesIndex, s = a.dataIndex, l = i.getComponent("axisPointer").coordSysAxesInfo;
+      if (!(o == null || s == null || l == null)) {
+        var u = i.getSeriesByIndex(o);
+        if (u) {
+          var h = u.getData(), f = wt([h.getItemModel(s), u, (u.coordinateSystem || {}).model], this._tooltipModel);
+          if (f.get("trigger") === "axis")
+            return n.dispatchAction({
+              type: "updateAxisPointer",
+              seriesIndex: o,
+              dataIndex: s,
+              position: a.position
+            }), !0;
+        }
+      }
+    }, t.prototype._tryShow = function(e, i) {
+      var n = e.target, a = this._tooltipModel;
+      if (a) {
+        this._lastX = e.offsetX, this._lastY = e.offsetY;
+        var o = e.dataByCoordSys;
+        if (o && o.length)
+          this._showAxisTooltip(o, e);
+        else if (n) {
+          var s = Q(n);
+          if (s.ssrType === "legend")
+            return;
+          this._lastDataByCoordSys = null;
+          var l, u;
+          Ln(n, function(h) {
+            if (Q(h).dataIndex != null)
+              return l = h, !0;
+            if (Q(h).tooltipConfig != null)
+              return u = h, !0;
+          }, !0), l ? this._showSeriesItemTooltip(e, l, i) : u ? this._showComponentItemTooltip(e, u, i) : this._hide(i);
+        } else
+          this._lastDataByCoordSys = null, this._hide(i);
+      }
+    }, t.prototype._showOrMove = function(e, i) {
+      var n = e.get("showDelay");
+      i = X(i, this), clearTimeout(this._showTimout), n > 0 ? this._showTimout = setTimeout(i, n) : i();
+    }, t.prototype._showAxisTooltip = function(e, i) {
+      var n = this._ecModel, a = this._tooltipModel, o = [i.offsetX, i.offsetY], s = wt([i.tooltipOption], a), l = this._renderMode, u = [], h = Ve("section", {
+        blocks: [],
+        noHeader: !0
+      }), f = [], v = new te();
+      S(e, function(_) {
+        S(_.dataByAxis, function(y) {
+          var x = n.getComponent(y.axisDim + "Axis", y.axisIndex), L = y.value;
+          if (!(!x || L == null)) {
+            var T = fr(L, x.axis, n, y.seriesDataIndices, y.valueLabelOpt), D = Ve("section", {
+              header: T,
+              noHeader: !An(T),
+              sortBlocks: !0,
+              blocks: []
+            });
+            h.blocks.push(D), S(y.seriesDataIndices, function(I) {
+              var M = n.getSeriesByIndex(I.seriesIndex), w = I.dataIndexInside, b = M.getDataParams(w);
+              if (!(b.dataIndex < 0)) {
+                b.axisDim = y.axisDim, b.axisIndex = y.axisIndex, b.axisType = y.axisType, b.axisId = y.axisId, b.axisValue = Ie(x.axis, {
+                  value: L
+                }), b.axisValueLabel = T, b.marker = v.makeTooltipMarker("item", Xt(b.color), l);
+                var A = Ge(M.formatTooltip(w, !0, null)), C = A.frag;
+                if (C) {
+                  var P = wt([M], a).get("valueFormatter");
+                  D.blocks.push(P ? F({
+                    valueFormatter: P
+                  }, C) : C);
+                }
+                A.text && f.push(A.text), u.push(b);
+              }
+            });
+          }
+        });
+      }), h.blocks.reverse(), f.reverse();
+      var d = i.position, c = s.get("order"), g = Ye(h, v, l, c, n.get("useUTC"), s.get("textStyle"));
+      g && f.unshift(g);
+      var m = l === "richText" ? `
+
+` : "<br/>", p = f.join(m);
+      this._showOrMove(s, function() {
+        this._updateContentNotChangedOnAxis(e, u) ? this._updatePosition(s, d, o[0], o[1], this._tooltipContent, u) : this._showTooltipContent(s, p, u, Math.random() + "", o[0], o[1], d, null, v);
+      });
+    }, t.prototype._showSeriesItemTooltip = function(e, i, n) {
+      var a = this._ecModel, o = Q(i), s = o.seriesIndex, l = a.getSeriesByIndex(s), u = o.dataModel || l, h = o.dataIndex, f = o.dataType, v = u.getData(f), d = this._renderMode, c = e.positionDefault, g = wt([v.getItemModel(h), u, l && (l.coordinateSystem || {}).model], this._tooltipModel, c ? {
+        position: c
+      } : null), m = g.get("trigger");
+      if (!(m != null && m !== "item")) {
+        var p = u.getDataParams(h, f), _ = new te();
+        p.marker = _.makeTooltipMarker("item", Xt(p.color), d);
+        var y = Ge(u.formatTooltip(h, !1, f)), x = g.get("order"), L = g.get("valueFormatter"), T = y.frag, D = T ? Ye(L ? F({
+          valueFormatter: L
+        }, T) : T, _, d, x, a.get("useUTC"), g.get("textStyle")) : y.text, I = "item_" + u.name + "_" + h;
+        this._showOrMove(g, function() {
+          this._showTooltipContent(g, D, p, I, e.offsetX, e.offsetY, e.position, e.target, _);
+        }), n({
+          type: "showTip",
+          dataIndexInside: h,
+          dataIndex: v.getRawIndex(h),
+          seriesIndex: s,
+          from: this.uid
+        });
+      }
+    }, t.prototype._showComponentItemTooltip = function(e, i, n) {
+      var a = this._renderMode === "html", o = Q(i), s = o.tooltipConfig, l = s.option || {}, u = l.encodeHTMLContent;
+      if (R(l)) {
+        var h = l;
+        l = {
+          content: h,
+          // Fixed formatter
+          formatter: h
+        }, u = !0;
+      }
+      u && a && l.content && (l = Ct(l), l.content = On(l.content));
+      var f = [l], v = this._ecModel.getComponent(o.componentMainType, o.componentIndex);
+      v && f.push(v), f.push({
+        formatter: l.content
+      });
+      var d = e.positionDefault, c = wt(f, this._tooltipModel, d ? {
+        position: d
+      } : null), g = c.get("content"), m = Math.random() + "", p = new te();
+      this._showOrMove(c, function() {
+        var _ = Ct(c.get("formatterParams") || {});
+        this._showTooltipContent(c, g, _, m, e.offsetX, e.offsetY, e.position, i, p);
+      }), n({
+        type: "showTip",
+        from: this.uid
+      });
+    }, t.prototype._showTooltipContent = function(e, i, n, a, o, s, l, u, h) {
+      if (this._ticket = "", !(!e.get("showContent") || !e.get("show"))) {
+        var f = this._tooltipContent;
+        f.setEnterable(e.get("enterable"));
+        var v = e.get("formatter");
+        l = l || e.get("position");
+        var d = i, c = this._getNearestPoint([o, s], n, e.get("trigger"), e.get("borderColor")), g = c.color;
+        if (v)
+          if (R(v)) {
+            var m = e.ecModel.get("useUTC"), p = H(n) ? n[0] : n, _ = p && p.axisType && p.axisType.indexOf("time") >= 0;
+            d = v, _ && (d = Ci(p.axisValue, d, m)), d = Pn(d, n, !0);
+          } else if (W(v)) {
+            var y = X(function(x, L) {
+              x === this._ticket && (f.setContent(L, h, e, g, l), this._updatePosition(e, l, o, s, f, n, u));
+            }, this);
+            this._ticket = a, d = v(n, a, y);
+          } else
+            d = v;
+        f.setContent(d, h, e, g, l), f.show(e, g), this._updatePosition(e, l, o, s, f, n, u);
+      }
+    }, t.prototype._getNearestPoint = function(e, i, n, a) {
+      if (n === "axis" || H(i))
+        return {
+          color: a || (this._renderMode === "html" ? "#fff" : "none")
+        };
+      if (!H(i))
+        return {
+          color: a || i.color || i.borderColor
+        };
+    }, t.prototype._updatePosition = function(e, i, n, a, o, s, l) {
+      var u = this._api.getWidth(), h = this._api.getHeight();
+      i = i || e.get("position");
+      var f = o.getSize(), v = e.get("align"), d = e.get("verticalAlign"), c = l && l.getBoundingRect().clone();
+      if (l && c.applyTransform(l.transform), W(i) && (i = i([n, a], s, o.el, c, {
+        viewSize: [u, h],
+        contentSize: f.slice()
+      })), H(i))
+        n = ht(i[0], u), a = ht(i[1], h);
+      else if (V(i)) {
+        var g = i;
+        g.width = f[0], g.height = f[1];
+        var m = En(g, {
+          width: u,
+          height: h
+        });
+        n = m.x, a = m.y, v = null, d = null;
+      } else if (R(i) && l) {
+        var p = zo(i, c, f, e.get("borderWidth"));
+        n = p[0], a = p[1];
+      } else {
+        var p = Ho(n, a, o, u, h, v ? null : 20, d ? null : 20);
+        n = p[0], a = p[1];
+      }
+      if (v && (n -= yi(v) ? f[0] / 2 : v === "right" ? f[0] : 0), d && (a -= yi(d) ? f[1] / 2 : d === "bottom" ? f[1] : 0), pr(e)) {
+        var p = Fo(n, a, o, u, h);
+        n = p[0], a = p[1];
+      }
+      o.moveTo(n, a);
+    }, t.prototype._updateContentNotChangedOnAxis = function(e, i) {
+      var n = this._lastDataByCoordSys, a = this._cbParamsList, o = !!n && n.length === e.length;
+      return o && S(n, function(s, l) {
+        var u = s.dataByAxis || [], h = e[l] || {}, f = h.dataByAxis || [];
+        o = o && u.length === f.length, o && S(u, function(v, d) {
+          var c = f[d] || {}, g = v.seriesDataIndices || [], m = c.seriesDataIndices || [];
+          o = o && v.value === c.value && v.axisType === c.axisType && v.axisId === c.axisId && g.length === m.length, o && S(g, function(p, _) {
+            var y = m[_];
+            o = o && p.seriesIndex === y.seriesIndex && p.dataIndex === y.dataIndex;
+          }), a && S(v.seriesDataIndices, function(p) {
+            var _ = p.seriesIndex, y = i[_], x = a[_];
+            y && x && x.data !== y.data && (o = !1);
+          });
+        });
+      }), this._lastDataByCoordSys = e, this._cbParamsList = i, !!o;
+    }, t.prototype._hide = function(e) {
+      this._lastDataByCoordSys = null, e({
+        type: "hideTip",
+        from: this.uid
+      });
+    }, t.prototype.dispose = function(e, i) {
+      z.node || !i.getDom() || (ge(this, "_updatePosition"), this._tooltipContent.dispose(), xe("itemTooltip", i));
+    }, t.type = "tooltip", t;
+  })(Dt)
+);
+function wt(r, t, e) {
+  var i = t.ecModel, n;
+  e ? (n = new ut(e, i, i), n = new ut(t.option, n, i)) : n = t;
+  for (var a = r.length - 1; a >= 0; a--) {
+    var o = r[a];
+    o && (o instanceof ut && (o = o.get("tooltip", !0)), R(o) && (o = {
+      formatter: o
+    }), o && (n = new ut(o, n, i)));
+  }
+  return n;
+}
+function _i(r, t) {
+  return r.dispatchAction || X(t.dispatchAction, t);
+}
+function Ho(r, t, e, i, n, a, o) {
+  var s = e.getSize(), l = s[0], u = s[1];
+  return a != null && (r + l + a + 2 > i ? r -= l + a : r += a), o != null && (t + u + o > n ? t -= u + o : t += o), [r, t];
+}
+function Fo(r, t, e, i, n) {
+  var a = e.getSize(), o = a[0], s = a[1];
+  return r = Math.min(r + o, i) - o, t = Math.min(t + s, n) - s, r = Math.max(r, 0), t = Math.max(t, 0), [r, t];
+}
+function zo(r, t, e, i) {
+  var n = e[0], a = e[1], o = Math.ceil(Math.SQRT2 * i) + 8, s = 0, l = 0, u = t.width, h = t.height;
+  switch (r) {
+    case "inside":
+      s = t.x + u / 2 - n / 2, l = t.y + h / 2 - a / 2;
+      break;
+    case "top":
+      s = t.x + u / 2 - n / 2, l = t.y - a - o;
+      break;
+    case "bottom":
+      s = t.x + u / 2 - n / 2, l = t.y + h + o;
+      break;
+    case "left":
+      s = t.x - n - o, l = t.y + h / 2 - a / 2;
+      break;
+    case "right":
+      s = t.x + u + o, l = t.y + h / 2 - a / 2;
+  }
+  return [s, l];
+}
+function yi(r) {
+  return r === "center" || r === "middle";
+}
+function Wo(r, t, e) {
+  var i = kn(r).queryOptionMap, n = i.keys()[0];
+  if (!(!n || n === "series")) {
+    var a = Nn(t, n, i.get(n), {
+      useDefault: !1,
+      enableAll: !1,
+      enableNone: !1
+    }), o = a.models[0];
+    if (o) {
+      var s = e.getViewOfComponentModel(o), l;
+      if (s.group.traverse(function(u) {
+        var h = Q(u).tooltipConfig;
+        if (h && h.name === r.name)
+          return l = u, !0;
+      }), l)
+        return {
+          componentMainType: n,
+          componentIndex: o.componentIndex,
+          el: l
+        };
+    }
+  }
+}
+function ds(r) {
+  sr(So), r.registerComponentModel(Mo), r.registerComponentView(Bo), r.registerAction({
+    type: "showTip",
+    event: "showTip",
+    update: "tooltip:manuallyShowTip"
+  }, Xe), r.registerAction({
+    type: "hideTip",
+    event: "hideTip",
+    update: "tooltip:manuallyHideTip"
+  }, Xe);
+}
+function xi(r, t, e) {
+  var i = Bn.createCanvas(), n = t.getWidth(), a = t.getHeight(), o = i.style;
+  return o && (o.position = "absolute", o.left = "0", o.top = "0", o.width = n + "px", o.height = a + "px", i.setAttribute("data-zr-dom-id", r)), i.width = n * e, i.height = a * e, i;
+}
+var he = (function(r) {
+  K(t, r);
+  function t(e, i, n) {
+    var a = r.call(this) || this;
+    a.motionBlur = !1, a.lastFrameAlpha = 0.7, a.dpr = 1, a.virtual = !1, a.config = {}, a.incremental = !1, a.zlevel = 0, a.maxRepaintRectCount = 5, a.__dirty = !0, a.__firstTimePaint = !0, a.__used = !1, a.__drawIndex = 0, a.__startIndex = 0, a.__endIndex = 0, a.__prevStartIndex = null, a.__prevEndIndex = null;
+    var o;
+    n = n || Yi, typeof e == "string" ? o = xi(e, i, n) : V(e) && (o = e, e = o.id), a.id = e, a.dom = o;
+    var s = o.style;
+    return s && (Gi(o), o.onselectstart = function() {
+      return !1;
+    }, s.padding = "0", s.margin = "0", s.borderWidth = "0"), a.painter = i, a.dpr = n, a;
+  }
+  return t.prototype.getElementCount = function() {
+    return this.__endIndex - this.__startIndex;
+  }, t.prototype.afterBrush = function() {
+    this.__prevStartIndex = this.__startIndex, this.__prevEndIndex = this.__endIndex;
+  }, t.prototype.initContext = function() {
+    this.ctx = this.dom.getContext("2d"), this.ctx.dpr = this.dpr;
+  }, t.prototype.setUnpainted = function() {
+    this.__firstTimePaint = !0;
+  }, t.prototype.createBackBuffer = function() {
+    var e = this.dpr;
+    this.domBack = xi("back-" + this.id, this.painter, e), this.ctxBack = this.domBack.getContext("2d"), e !== 1 && this.ctxBack.scale(e, e);
+  }, t.prototype.createRepaintRects = function(e, i, n, a) {
+    if (this.__firstTimePaint)
+      return this.__firstTimePaint = !1, null;
+    var o = [], s = this.maxRepaintRectCount, l = !1, u = new pt(0, 0, 0, 0);
+    function h(_) {
+      if (!(!_.isFinite() || _.isZero()))
+        if (o.length === 0) {
+          var y = new pt(0, 0, 0, 0);
+          y.copy(_), o.push(y);
+        } else {
+          for (var x = !1, L = 1 / 0, T = 0, D = 0; D < o.length; ++D) {
+            var I = o[D];
+            if (I.intersect(_)) {
+              var M = new pt(0, 0, 0, 0);
+              M.copy(I), M.union(_), o[D] = M, x = !0;
+              break;
+            } else if (l) {
+              u.copy(_), u.union(I);
+              var w = _.width * _.height, b = I.width * I.height, A = u.width * u.height, C = A - w - b;
+              C < L && (L = C, T = D);
+            }
+          }
+          if (l && (o[T].union(_), x = !0), !x) {
+            var y = new pt(0, 0, 0, 0);
+            y.copy(_), o.push(y);
+          }
+          l || (l = o.length >= s);
+        }
+    }
+    for (var f = this.__startIndex; f < this.__endIndex; ++f) {
+      var v = e[f];
+      if (v) {
+        var d = v.shouldBePainted(n, a, !0, !0), c = v.__isRendered && (v.__dirty & me || !d) ? v.getPrevPaintRect() : null;
+        c && h(c);
+        var g = d && (v.__dirty & me || !v.__isRendered) ? v.getPaintRect() : null;
+        g && h(g);
+      }
+    }
+    for (var f = this.__prevStartIndex; f < this.__prevEndIndex; ++f) {
+      var v = i[f], d = v && v.shouldBePainted(n, a, !0, !0);
+      if (v && (!d || !v.__zr) && v.__isRendered) {
+        var c = v.getPrevPaintRect();
+        c && h(c);
+      }
+    }
+    var m;
+    do {
+      m = !1;
+      for (var f = 0; f < o.length; ) {
+        if (o[f].isZero()) {
+          o.splice(f, 1);
+          continue;
+        }
+        for (var p = f + 1; p < o.length; )
+          o[f].intersect(o[p]) ? (m = !0, o[f].union(o[p]), o.splice(p, 1)) : p++;
+        f++;
+      }
+    } while (m);
+    return this._paintRects = o, o;
+  }, t.prototype.debugGetPaintRects = function() {
+    return (this._paintRects || []).slice();
+  }, t.prototype.resize = function(e, i) {
+    var n = this.dpr, a = this.dom, o = a.style, s = this.domBack;
+    o && (o.width = e + "px", o.height = i + "px"), a.width = e * n, a.height = i * n, s && (s.width = e * n, s.height = i * n, n !== 1 && this.ctxBack.scale(n, n));
+  }, t.prototype.clear = function(e, i, n) {
+    var a = this.dom, o = this.ctx, s = a.width, l = a.height;
+    i = i || this.clearColor;
+    var u = this.motionBlur && !e, h = this.lastFrameAlpha, f = this.dpr, v = this;
+    u && (this.domBack || this.createBackBuffer(), this.ctxBack.globalCompositeOperation = "copy", this.ctxBack.drawImage(a, 0, 0, s / f, l / f));
+    var d = this.domBack;
+    function c(g, m, p, _) {
+      if (o.clearRect(g, m, p, _), i && i !== "transparent") {
+        var y = void 0;
+        if (Hn(i)) {
+          var x = i.global || i.__width === p && i.__height === _;
+          y = x && i.__canvasGradient || Fn(o, i, {
+            x: 0,
+            y: 0,
+            width: p,
+            height: _
+          }), i.__canvasGradient = y, i.__width = p, i.__height = _;
+        } else zn(i) && (i.scaleX = i.scaleX || f, i.scaleY = i.scaleY || f, y = Wn(o, i, {
+          dirty: function() {
+            v.setUnpainted(), v.painter.refresh();
+          }
+        }));
+        o.save(), o.fillStyle = y || i, o.fillRect(g, m, p, _), o.restore();
+      }
+      u && (o.save(), o.globalAlpha = h, o.drawImage(d, g, m, p, _), o.restore());
+    }
+    !n || u ? c(0, 0, s, l) : n.length && S(n, function(g) {
+      c(g.x * f, g.y * f, g.width * f, g.height * f);
+    });
+  }, t;
+})(Rn), wi = 1e5, st = 314159, Ht = 0.01, Vo = 1e-3;
+function Go(r) {
+  return r ? r.__builtin__ ? !0 : !(typeof r.resize != "function" || typeof r.refresh != "function") : !1;
+}
+function Yo(r, t) {
+  var e = document.createElement("div");
+  return e.style.cssText = [
+    "position:relative",
+    "width:" + r + "px",
+    "height:" + t + "px",
+    "padding:0",
+    "margin:0",
+    "border-width:0"
+  ].join(";") + ";", e;
+}
+var Xo = (function() {
+  function r(t, e, i, n) {
+    this.type = "canvas", this._zlevelList = [], this._prevDisplayList = [], this._layers = {}, this._layerConfig = {}, this._needsManuallyCompositing = !1, this.type = "canvas";
+    var a = !t.nodeName || t.nodeName.toUpperCase() === "CANVAS";
+    this._opts = i = F({}, i || {}), this.dpr = i.devicePixelRatio || Yi, this._singleCanvas = a, this.root = t;
+    var o = t.style;
+    o && (Gi(t), t.innerHTML = ""), this.storage = e;
+    var s = this._zlevelList;
+    this._prevDisplayList = [];
+    var l = this._layers;
+    if (a) {
+      var h = t, f = h.width, v = h.height;
+      i.width != null && (f = i.width), i.height != null && (v = i.height), this.dpr = i.devicePixelRatio || 1, h.width = f * this.dpr, h.height = v * this.dpr, this._width = f, this._height = v;
+      var d = new he(h, this, this.dpr);
+      d.__builtin__ = !0, d.initContext(), l[st] = d, d.zlevel = st, s.push(st), this._domRoot = t;
+    } else {
+      this._width = Pt(t, 0, i), this._height = Pt(t, 1, i);
+      var u = this._domRoot = Yo(this._width, this._height);
+      t.appendChild(u);
+    }
+  }
+  return r.prototype.getType = function() {
+    return "canvas";
+  }, r.prototype.isSingleCanvas = function() {
+    return this._singleCanvas;
+  }, r.prototype.getViewportRoot = function() {
+    return this._domRoot;
+  }, r.prototype.getViewportRootOffset = function() {
+    var t = this.getViewportRoot();
+    if (t)
+      return {
+        offsetLeft: t.offsetLeft || 0,
+        offsetTop: t.offsetTop || 0
+      };
+  }, r.prototype.refresh = function(t) {
+    var e = this.storage.getDisplayList(!0), i = this._prevDisplayList, n = this._zlevelList;
+    this._redrawId = Math.random(), this._paintList(e, i, t, this._redrawId);
+    for (var a = 0; a < n.length; a++) {
+      var o = n[a], s = this._layers[o];
+      if (!s.__builtin__ && s.refresh) {
+        var l = a === 0 ? this._backgroundColor : null;
+        s.refresh(l);
+      }
+    }
+    return this._opts.useDirtyRect && (this._prevDisplayList = e.slice()), this;
+  }, r.prototype.refreshHover = function() {
+    this._paintHoverList(this.storage.getDisplayList(!1));
+  }, r.prototype._paintHoverList = function(t) {
+    var e = t.length, i = this._hoverlayer;
+    if (i && i.clear(), !!e) {
+      for (var n = {
+        inHover: !0,
+        viewWidth: this._width,
+        viewHeight: this._height
+      }, a, o = 0; o < e; o++) {
+        var s = t[o];
+        s.__inHover && (i || (i = this._hoverlayer = this.getLayer(wi)), a || (a = i.ctx, a.save()), At(a, s, n, o === e - 1));
+      }
+      a && a.restore();
+    }
+  }, r.prototype.getHoverLayer = function() {
+    return this.getLayer(wi);
+  }, r.prototype.paintOne = function(t, e) {
+    Vn(t, e);
+  }, r.prototype._paintList = function(t, e, i, n) {
+    if (this._redrawId === n) {
+      i = i || !1, this._updateLayerStatus(t);
+      var a = this._doPaintList(t, e, i), o = a.finished, s = a.needsRefreshHover;
+      if (this._needsManuallyCompositing && this._compositeManually(), s && this._paintHoverList(t), o)
+        this.eachLayer(function(u) {
+          u.afterBrush && u.afterBrush();
+        });
+      else {
+        var l = this;
+        Gn(function() {
+          l._paintList(t, e, i, n);
+        });
+      }
+    }
+  }, r.prototype._compositeManually = function() {
+    var t = this.getLayer(st).ctx, e = this._domRoot.width, i = this._domRoot.height;
+    t.clearRect(0, 0, e, i), this.eachBuiltinLayer(function(n) {
+      n.virtual && t.drawImage(n.dom, 0, 0, e, i);
+    });
+  }, r.prototype._doPaintList = function(t, e, i) {
+    for (var n = this, a = [], o = this._opts.useDirtyRect, s = 0; s < this._zlevelList.length; s++) {
+      var l = this._zlevelList[s], u = this._layers[l];
+      u.__builtin__ && u !== this._hoverlayer && (u.__dirty || i) && a.push(u);
+    }
+    for (var h = !0, f = !1, v = function(g) {
+      var m = a[g], p = m.ctx, _ = o && m.createRepaintRects(t, e, d._width, d._height), y = i ? m.__startIndex : m.__drawIndex, x = !i && m.incremental && Date.now, L = x && Date.now(), T = m.zlevel === d._zlevelList[0] ? d._backgroundColor : null;
+      if (m.__startIndex === m.__endIndex)
+        m.clear(!1, T, _);
+      else if (y === m.__startIndex) {
+        var D = t[y];
+        (!D.incremental || !D.notClear || i) && m.clear(!1, T, _);
+      }
+      y === -1 && (console.error("For some unknown reason. drawIndex is -1"), y = m.__startIndex);
+      var I, M = function(C) {
+        var P = {
+          inHover: !1,
+          allClipped: !1,
+          prevEl: null,
+          viewWidth: n._width,
+          viewHeight: n._height
+        };
+        for (I = y; I < m.__endIndex; I++) {
+          var O = t[I];
+          if (O.__inHover && (f = !0), n._doPaintEl(O, m, o, C, P, I === m.__endIndex - 1), x) {
+            var B = Date.now() - L;
+            if (B > 15)
+              break;
+          }
+        }
+        P.prevElClipPaths && p.restore();
+      };
+      if (_)
+        if (_.length === 0)
+          I = m.__endIndex;
+        else
+          for (var w = d.dpr, b = 0; b < _.length; ++b) {
+            var A = _[b];
+            p.save(), p.beginPath(), p.rect(A.x * w, A.y * w, A.width * w, A.height * w), p.clip(), M(A), p.restore();
+          }
+      else
+        p.save(), M(), p.restore();
+      m.__drawIndex = I, m.__drawIndex < m.__endIndex && (h = !1);
+    }, d = this, c = 0; c < a.length; c++)
+      v(c);
+    return z.wxa && S(this._layers, function(g) {
+      g && g.ctx && g.ctx.draw && g.ctx.draw();
+    }), {
+      finished: h,
+      needsRefreshHover: f
+    };
+  }, r.prototype._doPaintEl = function(t, e, i, n, a, o) {
+    var s = e.ctx;
+    if (i) {
+      var l = t.getPaintRect();
+      (!n || l && l.intersect(n)) && (At(s, t, a, o), t.setPrevPaintRect(l));
+    } else
+      At(s, t, a, o);
+  }, r.prototype.getLayer = function(t, e) {
+    this._singleCanvas && !this._needsManuallyCompositing && (t = st);
+    var i = this._layers[t];
+    return i || (i = new he("zr_" + t, this, this.dpr), i.zlevel = t, i.__builtin__ = !0, this._layerConfig[t] ? Ot(i, this._layerConfig[t], !0) : this._layerConfig[t - Ht] && Ot(i, this._layerConfig[t - Ht], !0), e && (i.virtual = e), this.insertLayer(t, i), i.initContext()), i;
+  }, r.prototype.insertLayer = function(t, e) {
+    var i = this._layers, n = this._zlevelList, a = n.length, o = this._domRoot, s = null, l = -1;
+    if (i[t]) {
+      process.env.NODE_ENV !== "production" && ee("ZLevel " + t + " has been used already");
+      return;
+    }
+    if (!Go(e)) {
+      process.env.NODE_ENV !== "production" && ee("Layer of zlevel " + t + " is not valid");
+      return;
+    }
+    if (a > 0 && t > n[0]) {
+      for (l = 0; l < a - 1 && !(n[l] < t && n[l + 1] > t); l++)
+        ;
+      s = i[n[l]];
+    }
+    if (n.splice(l + 1, 0, t), i[t] = e, !e.virtual)
+      if (s) {
+        var u = s.dom;
+        u.nextSibling ? o.insertBefore(e.dom, u.nextSibling) : o.appendChild(e.dom);
+      } else
+        o.firstChild ? o.insertBefore(e.dom, o.firstChild) : o.appendChild(e.dom);
+    e.painter || (e.painter = this);
+  }, r.prototype.eachLayer = function(t, e) {
+    for (var i = this._zlevelList, n = 0; n < i.length; n++) {
+      var a = i[n];
+      t.call(e, this._layers[a], a);
+    }
+  }, r.prototype.eachBuiltinLayer = function(t, e) {
+    for (var i = this._zlevelList, n = 0; n < i.length; n++) {
+      var a = i[n], o = this._layers[a];
+      o.__builtin__ && t.call(e, o, a);
+    }
+  }, r.prototype.eachOtherLayer = function(t, e) {
+    for (var i = this._zlevelList, n = 0; n < i.length; n++) {
+      var a = i[n], o = this._layers[a];
+      o.__builtin__ || t.call(e, o, a);
+    }
+  }, r.prototype.getLayers = function() {
+    return this._layers;
+  }, r.prototype._updateLayerStatus = function(t) {
+    this.eachBuiltinLayer(function(f, v) {
+      f.__dirty = f.__used = !1;
+    });
+    function e(f) {
+      a && (a.__endIndex !== f && (a.__dirty = !0), a.__endIndex = f);
+    }
+    if (this._singleCanvas)
+      for (var i = 1; i < t.length; i++) {
+        var n = t[i];
+        if (n.zlevel !== t[i - 1].zlevel || n.incremental) {
+          this._needsManuallyCompositing = !0;
+          break;
+        }
+      }
+    var a = null, o = 0, s, l;
+    for (l = 0; l < t.length; l++) {
+      var n = t[l], u = n.zlevel, h = void 0;
+      s !== u && (s = u, o = 0), n.incremental ? (h = this.getLayer(u + Vo, this._needsManuallyCompositing), h.incremental = !0, o = 1) : h = this.getLayer(u + (o > 0 ? Ht : 0), this._needsManuallyCompositing), h.__builtin__ || ee("ZLevel " + u + " has been used by unkown layer " + h.id), h !== a && (h.__used = !0, h.__startIndex !== l && (h.__dirty = !0), h.__startIndex = l, h.incremental ? h.__drawIndex = -1 : h.__drawIndex = l, e(l), a = h), n.__dirty & me && !n.__inHover && (h.__dirty = !0, h.incremental && h.__drawIndex < 0 && (h.__drawIndex = l));
+    }
+    e(l), this.eachBuiltinLayer(function(f, v) {
+      !f.__used && f.getElementCount() > 0 && (f.__dirty = !0, f.__startIndex = f.__endIndex = f.__drawIndex = 0), f.__dirty && f.__drawIndex < 0 && (f.__drawIndex = f.__startIndex);
+    });
+  }, r.prototype.clear = function() {
+    return this.eachBuiltinLayer(this._clearLayer), this;
+  }, r.prototype._clearLayer = function(t) {
+    t.clear();
+  }, r.prototype.setBackgroundColor = function(t) {
+    this._backgroundColor = t, S(this._layers, function(e) {
+      e.setUnpainted();
+    });
+  }, r.prototype.configLayer = function(t, e) {
+    if (e) {
+      var i = this._layerConfig;
+      i[t] ? Ot(i[t], e, !0) : i[t] = e;
+      for (var n = 0; n < this._zlevelList.length; n++) {
+        var a = this._zlevelList[n];
+        if (a === t || a === t + Ht) {
+          var o = this._layers[a];
+          Ot(o, i[t], !0);
+        }
+      }
+    }
+  }, r.prototype.delLayer = function(t) {
+    var e = this._layers, i = this._zlevelList, n = e[t];
+    n && (n.dom.parentNode.removeChild(n.dom), delete e[t], i.splice(Zt(i, t), 1));
+  }, r.prototype.resize = function(t, e) {
+    if (this._domRoot.style) {
+      var i = this._domRoot;
+      i.style.display = "none";
+      var n = this._opts, a = this.root;
+      if (t != null && (n.width = t), e != null && (n.height = e), t = Pt(a, 0, n), e = Pt(a, 1, n), i.style.display = "", this._width !== t || e !== this._height) {
+        i.style.width = t + "px", i.style.height = e + "px";
+        for (var o in this._layers)
+          this._layers.hasOwnProperty(o) && this._layers[o].resize(t, e);
+        this.refresh(!0);
+      }
+      this._width = t, this._height = e;
+    } else {
+      if (t == null || e == null)
+        return;
+      this._width = t, this._height = e, this.getLayer(st).resize(t, e);
+    }
+    return this;
+  }, r.prototype.clearLayer = function(t) {
+    var e = this._layers[t];
+    e && e.clear();
+  }, r.prototype.dispose = function() {
+    this.root.innerHTML = "", this.root = this.storage = this._domRoot = this._layers = null;
+  }, r.prototype.getRenderedCanvas = function(t) {
+    if (t = t || {}, this._singleCanvas && !this._compositeManually)
+      return this._layers[st].dom;
+    var e = new he("image", this, t.pixelRatio || this.dpr);
+    e.initContext(), e.clear(!1, t.backgroundColor || this._backgroundColor);
+    var i = e.ctx;
+    if (t.pixelRatio <= this.dpr) {
+      this.refresh();
+      var n = e.dom.width, a = e.dom.height;
+      this.eachLayer(function(f) {
+        f.__builtin__ ? i.drawImage(f.dom, 0, 0, n, a) : f.renderToCanvas && (i.save(), f.renderToCanvas(i), i.restore());
+      });
+    } else
+      for (var o = {
+        inHover: !1,
+        viewWidth: this._width,
+        viewHeight: this._height
+      }, s = this.storage.getDisplayList(!0), l = 0, u = s.length; l < u; l++) {
+        var h = s[l];
+        At(i, h, o, l === u - 1);
+      }
+    return e.dom;
+  }, r.prototype.getWidth = function() {
+    return this._width;
+  }, r.prototype.getHeight = function() {
+    return this._height;
+  }, r;
+})();
+function cs(r) {
+  r.registerPainter("canvas", Xo);
+}
+export {
+  ft as A,
+  ls as B,
+  us as C,
+  Ha as D,
+  Yn as E,
+  ja as F,
+  to as G,
+  Ja as H,
+  Lt as I,
+  vs as J,
+  ro as K,
+  qi as L,
+  io as M,
+  vr as N,
+  $e as O,
+  no as P,
+  ae as Q,
+  ts as R,
+  Ko as S,
+  ar as T,
+  Ce as U,
+  aa as V,
+  ss as W,
+  Ia as X,
+  $o as Y,
+  cs as a,
+  So as b,
+  is as c,
+  ns as d,
+  os as e,
+  hs as f,
+  fs as g,
+  Na as h,
+  ds as i,
+  Jo as j,
+  as as k,
+  es as l,
+  ti as m,
+  rs as n,
+  Qa as o,
+  ta as p,
+  qo as q,
+  Zo as r,
+  Oa as s,
+  Ea as t,
+  sr as u,
+  ka as v,
+  La as w,
+  jo as x,
+  Qo as y,
+  Ba as z
+};