mixdashboards 1.0.32 → 1.0.39

package/dist/install-Cx1i_m0k.js

@@ -0,0 +1,1168 @@
+import { W as xe, X as _e, u as K } from "./installCanvasRenderer-CLT2hquJ.js";
+import { l as E, S as X, t as ue, _ as Z, m as J, h as y, eI as Me, b9 as U, C as Se, b as we, P as Ae, cl as S, o as be, ck as Re, d5 as V, K as pe, bm as ce, U as De, E as q, O as _, bn as Ie, G as Q, J as Ee, a as Te, R as B, eJ as Ze, eK as Le, H as j, ak as ee, A as Ce, Z as Pe, c as Oe, eh as Ve, eg as ze, bp as te, B as We, j as Be, bl as ae, d3 as ke, cF as Ne, d2 as Ge } from "./echarts-BVht3HHb.js";
+import { s as N } from "./install-B0x4IqQr.js";
+import { R as Fe } from "./RoamController-DmBIwcAZ.js";
+var re = ["x", "y", "radius", "angle", "single"], He = ["cartesian2d", "polar", "singleAxis"];
+function Ye(s) {
+  var o = s.get("coordinateSystem");
+  return ue(He, o) >= 0;
+}
+function D(s) {
+  return process.env.NODE_ENV !== "production" && X(s), s + "Axis";
+}
+function Xe(s, o) {
+  var e = E(), t = [], i = E();
+  s.eachComponent({
+    mainType: "dataZoom",
+    query: o
+  }, function(d) {
+    i.get(d.uid) || n(d);
+  });
+  var r;
+  do
+    r = !1, s.eachComponent("dataZoom", a);
+  while (r);
+  function a(d) {
+    !i.get(d.uid) && l(d) && (n(d), r = !0);
+  }
+  function n(d) {
+    i.set(d.uid, !0), t.push(d), h(d);
+  }
+  function l(d) {
+    var u = !1;
+    return d.eachTargetAxis(function(v, p) {
+      var c = e.get(v);
+      c && c[p] && (u = !0);
+    }), u;
+  }
+  function h(d) {
+    d.eachTargetAxis(function(u, v) {
+      (e.get(u) || e.set(u, []))[v] = !0;
+    });
+  }
+  return t;
+}
+function fe(s) {
+  var o = s.ecModel, e = {
+    infoList: [],
+    infoMap: E()
+  };
+  return s.eachTargetAxis(function(t, i) {
+    var r = o.getComponent(D(t), i);
+    if (r) {
+      var a = r.getCoordSysModel();
+      if (a) {
+        var n = a.uid, l = e.infoMap.get(n);
+        l || (l = {
+          model: a,
+          axisModels: []
+        }, e.infoList.push(l), e.infoMap.set(n, l)), l.axisModels.push(r);
+      }
+    }
+  }), e;
+}
+var G = (
+  /** @class */
+  (function() {
+    function s() {
+      this.indexList = [], this.indexMap = [];
+    }
+    return s.prototype.add = function(o) {
+      this.indexMap[o] || (this.indexList.push(o), this.indexMap[o] = !0);
+    }, s;
+  })()
+), k = (
+  /** @class */
+  (function(s) {
+    Z(o, s);
+    function o() {
+      var e = s !== null && s.apply(this, arguments) || this;
+      return e.type = o.type, e._autoThrottle = !0, e._noTarget = !0, e._rangePropMode = ["percent", "percent"], e;
+    }
+    return o.prototype.init = function(e, t, i) {
+      var r = ie(e);
+      this.settledOption = r, this.mergeDefaultAndTheme(e, i), this._doInit(r);
+    }, o.prototype.mergeOption = function(e) {
+      var t = ie(e);
+      J(this.option, e, !0), J(this.settledOption, t, !0), this._doInit(t);
+    }, o.prototype._doInit = function(e) {
+      var t = this.option;
+      this._setDefaultThrottle(e), this._updateRangeUse(e);
+      var i = this.settledOption;
+      y([["start", "startValue"], ["end", "endValue"]], function(r, a) {
+        this._rangePropMode[a] === "value" && (t[r[0]] = i[r[0]] = null);
+      }, this), this._resetTarget();
+    }, o.prototype._resetTarget = function() {
+      var e = this.get("orient", !0), t = this._targetAxisInfoMap = E(), i = this._fillSpecifiedTargetAxis(t);
+      i ? this._orient = e || this._makeAutoOrientByTargetAxis() : (this._orient = e || "horizontal", this._fillAutoTargetAxisByOrient(t, this._orient)), this._noTarget = !0, t.each(function(r) {
+        r.indexList.length && (this._noTarget = !1);
+      }, this);
+    }, o.prototype._fillSpecifiedTargetAxis = function(e) {
+      var t = !1;
+      return y(re, function(i) {
+        var r = this.getReferringComponents(D(i), Me);
+        if (r.specified) {
+          t = !0;
+          var a = new G();
+          y(r.models, function(n) {
+            a.add(n.componentIndex);
+          }), e.set(i, a);
+        }
+      }, this), t;
+    }, o.prototype._fillAutoTargetAxisByOrient = function(e, t) {
+      var i = this.ecModel, r = !0;
+      if (r) {
+        var a = t === "vertical" ? "y" : "x", n = i.findComponents({
+          mainType: a + "Axis"
+        });
+        l(n, a);
+      }
+      if (r) {
+        var n = i.findComponents({
+          mainType: "singleAxis",
+          filter: function(d) {
+            return d.get("orient", !0) === t;
+          }
+        });
+        l(n, "single");
+      }
+      function l(h, d) {
+        var u = h[0];
+        if (u) {
+          var v = new G();
+          if (v.add(u.componentIndex), e.set(d, v), r = !1, d === "x" || d === "y") {
+            var p = u.getReferringComponents("grid", U).models[0];
+            p && y(h, function(c) {
+              u.componentIndex !== c.componentIndex && p === c.getReferringComponents("grid", U).models[0] && v.add(c.componentIndex);
+            });
+          }
+        }
+      }
+      r && y(re, function(h) {
+        if (r) {
+          var d = i.findComponents({
+            mainType: D(h),
+            filter: function(v) {
+              return v.get("type", !0) === "category";
+            }
+          });
+          if (d[0]) {
+            var u = new G();
+            u.add(d[0].componentIndex), e.set(h, u), r = !1;
+          }
+        }
+      }, this);
+    }, o.prototype._makeAutoOrientByTargetAxis = function() {
+      var e;
+      return this.eachTargetAxis(function(t) {
+        !e && (e = t);
+      }, this), e === "y" ? "vertical" : "horizontal";
+    }, o.prototype._setDefaultThrottle = function(e) {
+      if (e.hasOwnProperty("throttle") && (this._autoThrottle = !1), this._autoThrottle) {
+        var t = this.ecModel.option;
+        this.option.throttle = t.animation && t.animationDurationUpdate > 0 ? 100 : 20;
+      }
+    }, o.prototype._updateRangeUse = function(e) {
+      var t = this._rangePropMode, i = this.get("rangeMode");
+      y([["start", "startValue"], ["end", "endValue"]], function(r, a) {
+        var n = e[r[0]] != null, l = e[r[1]] != null;
+        n && !l ? t[a] = "percent" : !n && l ? t[a] = "value" : i ? t[a] = i[a] : n && (t[a] = "percent");
+      });
+    }, o.prototype.noTarget = function() {
+      return this._noTarget;
+    }, o.prototype.getFirstTargetAxisModel = function() {
+      var e;
+      return this.eachTargetAxis(function(t, i) {
+        e == null && (e = this.ecModel.getComponent(D(t), i));
+      }, this), e;
+    }, o.prototype.eachTargetAxis = function(e, t) {
+      this._targetAxisInfoMap.each(function(i, r) {
+        y(i.indexList, function(a) {
+          e.call(t, r, a);
+        });
+      });
+    }, o.prototype.getAxisProxy = function(e, t) {
+      var i = this.getAxisModel(e, t);
+      if (i)
+        return i.__dzAxisProxy;
+    }, o.prototype.getAxisModel = function(e, t) {
+      process.env.NODE_ENV !== "production" && X(e && t != null);
+      var i = this._targetAxisInfoMap.get(e);
+      if (i && i.indexMap[t])
+        return this.ecModel.getComponent(D(e), t);
+    }, o.prototype.setRawRange = function(e) {
+      var t = this.option, i = this.settledOption;
+      y([["start", "startValue"], ["end", "endValue"]], function(r) {
+        (e[r[0]] != null || e[r[1]] != null) && (t[r[0]] = i[r[0]] = e[r[0]], t[r[1]] = i[r[1]] = e[r[1]]);
+      }, this), this._updateRangeUse(e);
+    }, o.prototype.setCalculatedRange = function(e) {
+      var t = this.option;
+      y(["start", "startValue", "end", "endValue"], function(i) {
+        t[i] = e[i];
+      });
+    }, o.prototype.getPercentRange = function() {
+      var e = this.findRepresentativeAxisProxy();
+      if (e)
+        return e.getDataPercentWindow();
+    }, o.prototype.getValueRange = function(e, t) {
+      if (e == null && t == null) {
+        var i = this.findRepresentativeAxisProxy();
+        if (i)
+          return i.getDataValueWindow();
+      } else
+        return this.getAxisProxy(e, t).getDataValueWindow();
+    }, o.prototype.findRepresentativeAxisProxy = function(e) {
+      if (e)
+        return e.__dzAxisProxy;
+      for (var t, i = this._targetAxisInfoMap.keys(), r = 0; r < i.length; r++)
+        for (var a = i[r], n = this._targetAxisInfoMap.get(a), l = 0; l < n.indexList.length; l++) {
+          var h = this.getAxisProxy(a, n.indexList[l]);
+          if (h.hostedBy(this))
+            return h;
+          t || (t = h);
+        }
+      return t;
+    }, o.prototype.getRangePropMode = function() {
+      return this._rangePropMode.slice();
+    }, o.prototype.getOrient = function() {
+      return process.env.NODE_ENV !== "production" && X(this._orient), this._orient;
+    }, o.type = "dataZoom", o.dependencies = ["xAxis", "yAxis", "radiusAxis", "angleAxis", "singleAxis", "series", "toolbox"], o.defaultOption = {
+      // zlevel: 0,
+      z: 4,
+      filterMode: "filter",
+      start: 0,
+      end: 100
+    }, o;
+  })(Se)
+);
+function ie(s) {
+  var o = {};
+  return y(["start", "end", "startValue", "endValue", "throttle"], function(e) {
+    s.hasOwnProperty(e) && (o[e] = s[e]);
+  }), o;
+}
+var ve = (
+  /** @class */
+  (function(s) {
+    Z(o, s);
+    function o() {
+      var e = s !== null && s.apply(this, arguments) || this;
+      return e.type = o.type, e;
+    }
+    return o.prototype.render = function(e, t, i, r) {
+      this.dataZoomModel = e, this.ecModel = t, this.api = i;
+    }, o.type = "dataZoom", o;
+  })(we)
+), T = y, oe = V, Ue = (
+  /** @class */
+  (function() {
+    function s(o, e, t, i) {
+      this._dimName = o, this._axisIndex = e, this.ecModel = i, this._dataZoomModel = t;
+    }
+    return s.prototype.hostedBy = function(o) {
+      return this._dataZoomModel === o;
+    }, s.prototype.getDataValueWindow = function() {
+      return this._valueWindow.slice();
+    }, s.prototype.getDataPercentWindow = function() {
+      return this._percentWindow.slice();
+    }, s.prototype.getTargetSeriesModels = function() {
+      var o = [];
+      return this.ecModel.eachSeries(function(e) {
+        if (Ye(e)) {
+          var t = D(this._dimName), i = e.getReferringComponents(t, U).models[0];
+          i && this._axisIndex === i.componentIndex && o.push(e);
+        }
+      }, this), o;
+    }, s.prototype.getAxisModel = function() {
+      return this.ecModel.getComponent(this._dimName + "Axis", this._axisIndex);
+    }, s.prototype.getMinMaxSpan = function() {
+      return Ae(this._minMaxSpan);
+    }, s.prototype.calculateDataWindow = function(o) {
+      var e = this._dataExtent, t = this.getAxisModel(), i = t.axis.scale, r = this._dataZoomModel.getRangePropMode(), a = [0, 100], n = [], l = [], h;
+      T(["start", "end"], function(v, p) {
+        var c = o[v], f = o[v + "Value"];
+        r[p] === "percent" ? (c == null && (c = a[p]), f = i.parse(S(c, a, e))) : (h = !0, f = f == null ? e[p] : i.parse(f), c = S(f, e, a)), l[p] = f == null || isNaN(f) ? e[p] : f, n[p] = c == null || isNaN(c) ? a[p] : c;
+      }), oe(l), oe(n);
+      var d = this._minMaxSpan;
+      h ? u(l, n, e, a, !1) : u(n, l, a, e, !0);
+      function u(v, p, c, f, m) {
+        var x = m ? "Span" : "ValueSpan";
+        N(0, v, c, "all", d["min" + x], d["max" + x]);
+        for (var g = 0; g < 2; g++)
+          p[g] = S(v[g], c, f, !0), m && (p[g] = i.parse(p[g]));
+      }
+      return {
+        valueWindow: l,
+        percentWindow: n
+      };
+    }, s.prototype.reset = function(o) {
+      if (o === this._dataZoomModel) {
+        var e = this.getTargetSeriesModels();
+        this._dataExtent = $e(this, this._dimName, e), this._updateMinMaxSpan();
+        var t = this.calculateDataWindow(o.settledOption);
+        this._valueWindow = t.valueWindow, this._percentWindow = t.percentWindow, this._setAxisModel();
+      }
+    }, s.prototype.filterData = function(o, e) {
+      if (o !== this._dataZoomModel)
+        return;
+      var t = this._dimName, i = this.getTargetSeriesModels(), r = o.get("filterMode"), a = this._valueWindow;
+      if (r === "none")
+        return;
+      T(i, function(l) {
+        var h = l.getData(), d = h.mapDimensionsAll(t);
+        if (d.length) {
+          if (r === "weakFilter") {
+            var u = h.getStore(), v = be(d, function(p) {
+              return h.getDimensionIndex(p);
+            }, h);
+            h.filterSelf(function(p) {
+              for (var c, f, m, x = 0; x < d.length; x++) {
+                var g = u.get(v[x], p), R = !isNaN(g), w = g < a[0], M = g > a[1];
+                if (R && !w && !M)
+                  return !0;
+                R && (m = !0), w && (c = !0), M && (f = !0);
+              }
+              return m && c && f;
+            });
+          } else
+            T(d, function(p) {
+              if (r === "empty")
+                l.setData(h = h.map(p, function(f) {
+                  return n(f) ? f : NaN;
+                }));
+              else {
+                var c = {};
+                c[p] = a, h.selectRange(c);
+              }
+            });
+          T(d, function(p) {
+            h.setApproximateExtent(a, p);
+          });
+        }
+      });
+      function n(l) {
+        return l >= a[0] && l <= a[1];
+      }
+    }, s.prototype._updateMinMaxSpan = function() {
+      var o = this._minMaxSpan = {}, e = this._dataZoomModel, t = this._dataExtent;
+      T(["min", "max"], function(i) {
+        var r = e.get(i + "Span"), a = e.get(i + "ValueSpan");
+        a != null && (a = this.getAxisModel().axis.scale.parse(a)), a != null ? r = S(t[0] + a, t, [0, 100], !0) : r != null && (a = S(r, [0, 100], t, !0) - t[0]), o[i + "Span"] = r, o[i + "ValueSpan"] = a;
+      }, this);
+    }, s.prototype._setAxisModel = function() {
+      var o = this.getAxisModel(), e = this._percentWindow, t = this._valueWindow;
+      if (e) {
+        var i = Re(t, [0, 500]);
+        i = Math.min(i, 20);
+        var r = o.axis.scale.rawExtentInfo;
+        e[0] !== 0 && r.setDeterminedMinMax("min", +t[0].toFixed(i)), e[1] !== 100 && r.setDeterminedMinMax("max", +t[1].toFixed(i)), r.freeze();
+      }
+    }, s;
+  })()
+);
+function $e(s, o, e) {
+  var t = [1 / 0, -1 / 0];
+  T(e, function(a) {
+    xe(t, a.getData(), o);
+  });
+  var i = s.getAxisModel(), r = _e(i.axis.scale, i, t).calculate();
+  return [r.min, r.max];
+}
+var Ke = {
+  // `dataZoomProcessor` will only be performed in needed series. Consider if
+  // there is a line series and a pie series, it is better not to update the
+  // line series if only pie series is needed to be updated.
+  getTargetSeries: function(s) {
+    function o(i) {
+      s.eachComponent("dataZoom", function(r) {
+        r.eachTargetAxis(function(a, n) {
+          var l = s.getComponent(D(a), n);
+          i(a, n, l, r);
+        });
+      });
+    }
+    o(function(i, r, a, n) {
+      a.__dzAxisProxy = null;
+    });
+    var e = [];
+    o(function(i, r, a, n) {
+      a.__dzAxisProxy || (a.__dzAxisProxy = new Ue(i, r, n, s), e.push(a.__dzAxisProxy));
+    });
+    var t = E();
+    return y(e, function(i) {
+      y(i.getTargetSeriesModels(), function(r) {
+        t.set(r.uid, r);
+      });
+    }), t;
+  },
+  // Consider appendData, where filter should be performed. Because data process is
+  // in block mode currently, it is not need to worry about that the overallProgress
+  // execute every frame.
+  overallReset: function(s, o) {
+    s.eachComponent("dataZoom", function(e) {
+      e.eachTargetAxis(function(t, i) {
+        e.getAxisProxy(t, i).reset(e);
+      }), e.eachTargetAxis(function(t, i) {
+        e.getAxisProxy(t, i).filterData(e, o);
+      });
+    }), s.eachComponent("dataZoom", function(e) {
+      var t = e.findRepresentativeAxisProxy();
+      if (t) {
+        var i = t.getDataPercentWindow(), r = t.getDataValueWindow();
+        e.setCalculatedRange({
+          start: i[0],
+          end: i[1],
+          startValue: r[0],
+          endValue: r[1]
+        });
+      }
+    });
+  }
+};
+function Je(s) {
+  s.registerAction("dataZoom", function(o, e) {
+    var t = Xe(e, o);
+    y(t, function(i) {
+      i.setRawRange({
+        start: o.start,
+        end: o.end,
+        startValue: o.startValue,
+        endValue: o.endValue
+      });
+    });
+  });
+}
+var ne = !1;
+function ge(s) {
+  ne || (ne = !0, s.registerProcessor(s.PRIORITY.PROCESSOR.FILTER, Ke), Je(s), s.registerSubTypeDefaulter("dataZoom", function() {
+    return "slider";
+  }));
+}
+var qe = (
+  /** @class */
+  (function(s) {
+    Z(o, s);
+    function o() {
+      var e = s !== null && s.apply(this, arguments) || this;
+      return e.type = o.type, e;
+    }
+    return o.type = "dataZoom.inside", o.defaultOption = pe(k.defaultOption, {
+      disabled: !1,
+      zoomLock: !1,
+      zoomOnMouseWheel: !0,
+      moveOnMouseMove: !0,
+      moveOnMouseWheel: !1,
+      preventDefaultMouseMove: !0
+    }), o;
+  })(k)
+), $ = De();
+function Qe(s, o, e) {
+  $(s).coordSysRecordMap.each(function(t) {
+    var i = t.dataZoomInfoMap.get(o.uid);
+    i && (i.getRange = e);
+  });
+}
+function je(s, o) {
+  for (var e = $(s).coordSysRecordMap, t = e.keys(), i = 0; i < t.length; i++) {
+    var r = t[i], a = e.get(r), n = a.dataZoomInfoMap;
+    if (n) {
+      var l = o.uid, h = n.get(l);
+      h && (n.removeKey(l), n.keys().length || me(e, a));
+    }
+  }
+}
+function me(s, o) {
+  if (o) {
+    s.removeKey(o.model.uid);
+    var e = o.controller;
+    e && e.dispose();
+  }
+}
+function et(s, o) {
+  var e = {
+    model: o,
+    containsPoint: q(at, o),
+    dispatchAction: q(tt, s),
+    dataZoomInfoMap: null,
+    controller: null
+  }, t = e.controller = new Fe(s.getZr());
+  return y(["pan", "zoom", "scrollMove"], function(i) {
+    t.on(i, function(r) {
+      var a = [];
+      e.dataZoomInfoMap.each(function(n) {
+        if (r.isAvailableBehavior(n.model.option)) {
+          var l = (n.getRange || {})[i], h = l && l(n.dzReferCoordSysInfo, e.model.mainType, e.controller, r);
+          !n.model.get("disabled", !0) && h && a.push({
+            dataZoomId: n.model.id,
+            start: h[0],
+            end: h[1]
+          });
+        }
+      }), a.length && e.dispatchAction(a);
+    });
+  }), e;
+}
+function tt(s, o) {
+  s.isDisposed() || s.dispatchAction({
+    type: "dataZoom",
+    animation: {
+      easing: "cubicOut",
+      duration: 100
+    },
+    batch: o
+  });
+}
+function at(s, o, e, t) {
+  return s.coordinateSystem.containPoint([e, t]);
+}
+function rt(s) {
+  var o, e = "type_", t = {
+    type_true: 2,
+    type_move: 1,
+    type_false: 0,
+    type_undefined: -1
+  }, i = !0;
+  return s.each(function(r) {
+    var a = r.model, n = a.get("disabled", !0) ? !1 : a.get("zoomLock", !0) ? "move" : !0;
+    t[e + n] > t[e + o] && (o = n), i = i && a.get("preventDefaultMouseMove", !0);
+  }), {
+    controlType: o,
+    opt: {
+      // RoamController will enable all of these functionalities,
+      // and the final behavior is determined by its event listener
+      // provided by each inside zoom.
+      zoomOnMouseWheel: !0,
+      moveOnMouseMove: !0,
+      moveOnMouseWheel: !0,
+      preventDefaultMouseMove: !!i
+    }
+  };
+}
+function it(s) {
+  s.registerProcessor(s.PRIORITY.PROCESSOR.FILTER, function(o, e) {
+    var t = $(e), i = t.coordSysRecordMap || (t.coordSysRecordMap = E());
+    i.each(function(r) {
+      r.dataZoomInfoMap = null;
+    }), o.eachComponent({
+      mainType: "dataZoom",
+      subType: "inside"
+    }, function(r) {
+      var a = fe(r);
+      y(a.infoList, function(n) {
+        var l = n.model.uid, h = i.get(l) || i.set(l, et(e, n.model)), d = h.dataZoomInfoMap || (h.dataZoomInfoMap = E());
+        d.set(r.uid, {
+          dzReferCoordSysInfo: n,
+          model: r,
+          getRange: null
+        });
+      });
+    }), i.each(function(r) {
+      var a = r.controller, n, l = r.dataZoomInfoMap;
+      if (l) {
+        var h = l.keys()[0];
+        h != null && (n = l.get(h));
+      }
+      if (!n) {
+        me(i, r);
+        return;
+      }
+      var d = rt(l);
+      a.enable(d.controlType, d.opt), a.setPointerChecker(r.containsPoint), ce(r, "dispatchAction", n.model.get("throttle", !0), "fixRate");
+    });
+  });
+}
+var ot = (
+  /** @class */
+  (function(s) {
+    Z(o, s);
+    function o() {
+      var e = s !== null && s.apply(this, arguments) || this;
+      return e.type = "dataZoom.inside", e;
+    }
+    return o.prototype.render = function(e, t, i) {
+      if (s.prototype.render.apply(this, arguments), e.noTarget()) {
+        this._clear();
+        return;
+      }
+      this.range = e.getPercentRange(), Qe(i, e, {
+        pan: _(F.pan, this),
+        zoom: _(F.zoom, this),
+        scrollMove: _(F.scrollMove, this)
+      });
+    }, o.prototype.dispose = function() {
+      this._clear(), s.prototype.dispose.apply(this, arguments);
+    }, o.prototype._clear = function() {
+      je(this.api, this.dataZoomModel), this.range = null;
+    }, o.type = "dataZoom.inside", o;
+  })(ve)
+), F = {
+  zoom: function(s, o, e, t) {
+    var i = this.range, r = i.slice(), a = s.axisModels[0];
+    if (a) {
+      var n = H[o](null, [t.originX, t.originY], a, e, s), l = (n.signal > 0 ? n.pixelStart + n.pixelLength - n.pixel : n.pixel - n.pixelStart) / n.pixelLength * (r[1] - r[0]) + r[0], h = Math.max(1 / t.scale, 0);
+      r[0] = (r[0] - l) * h + l, r[1] = (r[1] - l) * h + l;
+      var d = this.dataZoomModel.findRepresentativeAxisProxy().getMinMaxSpan();
+      if (N(0, r, [0, 100], 0, d.minSpan, d.maxSpan), this.range = r, i[0] !== r[0] || i[1] !== r[1])
+        return r;
+    }
+  },
+  pan: se(function(s, o, e, t, i, r) {
+    var a = H[t]([r.oldX, r.oldY], [r.newX, r.newY], o, i, e);
+    return a.signal * (s[1] - s[0]) * a.pixel / a.pixelLength;
+  }),
+  scrollMove: se(function(s, o, e, t, i, r) {
+    var a = H[t]([0, 0], [r.scrollDelta, r.scrollDelta], o, i, e);
+    return a.signal * (s[1] - s[0]) * r.scrollDelta;
+  })
+};
+function se(s) {
+  return function(o, e, t, i) {
+    var r = this.range, a = r.slice(), n = o.axisModels[0];
+    if (n) {
+      var l = s(a, n, o, e, t, i);
+      if (N(l, a, [0, 100], "all"), this.range = a, r[0] !== a[0] || r[1] !== a[1])
+        return a;
+    }
+  };
+}
+var H = {
+  grid: function(s, o, e, t, i) {
+    var r = e.axis, a = {}, n = i.model.coordinateSystem.getRect();
+    return s = s || [0, 0], r.dim === "x" ? (a.pixel = o[0] - s[0], a.pixelLength = n.width, a.pixelStart = n.x, a.signal = r.inverse ? 1 : -1) : (a.pixel = o[1] - s[1], a.pixelLength = n.height, a.pixelStart = n.y, a.signal = r.inverse ? -1 : 1), a;
+  },
+  polar: function(s, o, e, t, i) {
+    var r = e.axis, a = {}, n = i.model.coordinateSystem, l = n.getRadiusAxis().getExtent(), h = n.getAngleAxis().getExtent();
+    return s = s ? n.pointToCoord(s) : [0, 0], o = n.pointToCoord(o), e.mainType === "radiusAxis" ? (a.pixel = o[0] - s[0], a.pixelLength = l[1] - l[0], a.pixelStart = l[0], a.signal = r.inverse ? 1 : -1) : (a.pixel = o[1] - s[1], a.pixelLength = h[1] - h[0], a.pixelStart = h[0], a.signal = r.inverse ? -1 : 1), a;
+  },
+  singleAxis: function(s, o, e, t, i) {
+    var r = e.axis, a = i.model.coordinateSystem.getRect(), n = {};
+    return s = s || [0, 0], r.orient === "horizontal" ? (n.pixel = o[0] - s[0], n.pixelLength = a.width, n.pixelStart = a.x, n.signal = r.inverse ? 1 : -1) : (n.pixel = o[1] - s[1], n.pixelLength = a.height, n.pixelStart = a.y, n.signal = r.inverse ? -1 : 1), n;
+  }
+};
+function nt(s) {
+  ge(s), s.registerComponentModel(qe), s.registerComponentView(ot), it(s);
+}
+var st = (
+  /** @class */
+  (function(s) {
+    Z(o, s);
+    function o() {
+      var e = s !== null && s.apply(this, arguments) || this;
+      return e.type = o.type, e;
+    }
+    return o.type = "dataZoom.slider", o.layoutMode = "box", o.defaultOption = pe(k.defaultOption, {
+      show: !0,
+      // deault value can only be drived in view stage.
+      right: "ph",
+      top: "ph",
+      width: "ph",
+      height: "ph",
+      left: null,
+      bottom: null,
+      borderColor: "#d2dbee",
+      borderRadius: 3,
+      backgroundColor: "rgba(47,69,84,0)",
+      // dataBackgroundColor: '#ddd',
+      dataBackground: {
+        lineStyle: {
+          color: "#d2dbee",
+          width: 0.5
+        },
+        areaStyle: {
+          color: "#d2dbee",
+          opacity: 0.2
+        }
+      },
+      selectedDataBackground: {
+        lineStyle: {
+          color: "#8fb0f7",
+          width: 0.5
+        },
+        areaStyle: {
+          color: "#8fb0f7",
+          opacity: 0.2
+        }
+      },
+      // Color of selected window.
+      fillerColor: "rgba(135,175,274,0.2)",
+      handleIcon: "path://M-9.35,34.56V42m0-40V9.5m-2,0h4a2,2,0,0,1,2,2v21a2,2,0,0,1-2,2h-4a2,2,0,0,1-2-2v-21A2,2,0,0,1-11.35,9.5Z",
+      // Percent of the slider height
+      handleSize: "100%",
+      handleStyle: {
+        color: "#fff",
+        borderColor: "#ACB8D1"
+      },
+      moveHandleSize: 7,
+      moveHandleIcon: "path://M-320.9-50L-320.9-50c18.1,0,27.1,9,27.1,27.1V85.7c0,18.1-9,27.1-27.1,27.1l0,0c-18.1,0-27.1-9-27.1-27.1V-22.9C-348-41-339-50-320.9-50z M-212.3-50L-212.3-50c18.1,0,27.1,9,27.1,27.1V85.7c0,18.1-9,27.1-27.1,27.1l0,0c-18.1,0-27.1-9-27.1-27.1V-22.9C-239.4-41-230.4-50-212.3-50z M-103.7-50L-103.7-50c18.1,0,27.1,9,27.1,27.1V85.7c0,18.1-9,27.1-27.1,27.1l0,0c-18.1,0-27.1-9-27.1-27.1V-22.9C-130.9-41-121.8-50-103.7-50z",
+      moveHandleStyle: {
+        color: "#D2DBEE",
+        opacity: 0.7
+      },
+      showDetail: !0,
+      showDataShadow: "auto",
+      realtime: !0,
+      zoomLock: !1,
+      textStyle: {
+        color: "#6E7079"
+      },
+      brushSelect: !0,
+      brushStyle: {
+        color: "rgba(135,175,274,0.15)"
+      },
+      emphasis: {
+        handleLabel: {
+          show: !0
+        },
+        handleStyle: {
+          borderColor: "#8FB0F7"
+        },
+        moveHandleStyle: {
+          color: "#8FB0F7"
+        }
+      }
+    }), o;
+  })(k)
+), P = B, le = 7, lt = 1, Y = 30, ht = 7, O = "horizontal", he = "vertical", dt = 5, ut = ["line", "bar", "candlestick", "scatter"], pt = {
+  easing: "cubicOut",
+  duration: 100,
+  delay: 0
+}, ct = (
+  /** @class */
+  (function(s) {
+    Z(o, s);
+    function o() {
+      var e = s !== null && s.apply(this, arguments) || this;
+      return e.type = o.type, e._displayables = {}, e;
+    }
+    return o.prototype.init = function(e, t) {
+      this.api = t, this._onBrush = _(this._onBrush, this), this._onBrushEnd = _(this._onBrushEnd, this);
+    }, o.prototype.render = function(e, t, i, r) {
+      if (s.prototype.render.apply(this, arguments), ce(this, "_dispatchZoomAction", e.get("throttle"), "fixRate"), this._orient = e.getOrient(), e.get("show") === !1) {
+        this.group.removeAll();
+        return;
+      }
+      if (e.noTarget()) {
+        this._clear(), this.group.removeAll();
+        return;
+      }
+      (!r || r.type !== "dataZoom" || r.from !== this.uid) && this._buildView(), this._updateView();
+    }, o.prototype.dispose = function() {
+      this._clear(), s.prototype.dispose.apply(this, arguments);
+    }, o.prototype._clear = function() {
+      Ie(this, "_dispatchZoomAction");
+      var e = this.api.getZr();
+      e.off("mousemove", this._onBrush), e.off("mouseup", this._onBrushEnd);
+    }, o.prototype._buildView = function() {
+      var e = this.group;
+      e.removeAll(), this._brushing = !1, this._displayables.brushRect = null, this._resetLocation(), this._resetInterval();
+      var t = this._displayables.sliderGroup = new Q();
+      this._renderBackground(), this._renderHandle(), this._renderDataShadow(), e.add(t), this._positionGroup();
+    }, o.prototype._resetLocation = function() {
+      var e = this.dataZoomModel, t = this.api, i = e.get("brushSelect"), r = i ? ht : 0, a = this._findCoordRect(), n = {
+        width: t.getWidth(),
+        height: t.getHeight()
+      }, l = this._orient === O ? {
+        // Why using 'right', because right should be used in vertical,
+        // and it is better to be consistent for dealing with position param merge.
+        right: n.width - a.x - a.width,
+        top: n.height - Y - le - r,
+        width: a.width,
+        height: Y
+      } : {
+        right: le,
+        top: a.y,
+        width: Y,
+        height: a.height
+      }, h = Ee(e.option);
+      y(["right", "top", "width", "height"], function(u) {
+        h[u] === "ph" && (h[u] = l[u]);
+      });
+      var d = Te(h, n);
+      this._location = {
+        x: d.x,
+        y: d.y
+      }, this._size = [d.width, d.height], this._orient === he && this._size.reverse();
+    }, o.prototype._positionGroup = function() {
+      var e = this.group, t = this._location, i = this._orient, r = this.dataZoomModel.getFirstTargetAxisModel(), a = r && r.get("inverse"), n = this._displayables.sliderGroup, l = (this._dataShadowInfo || {}).otherAxisInverse;
+      n.attr(i === O && !a ? {
+        scaleY: l ? 1 : -1,
+        scaleX: 1
+      } : i === O && a ? {
+        scaleY: l ? 1 : -1,
+        scaleX: -1
+      } : i === he && !a ? {
+        scaleY: l ? -1 : 1,
+        scaleX: 1,
+        rotation: Math.PI / 2
+      } : {
+        scaleY: l ? -1 : 1,
+        scaleX: -1,
+        rotation: Math.PI / 2
+      });
+      var h = e.getBoundingRect([n]);
+      e.x = t.x - h.x, e.y = t.y - h.y, e.markRedraw();
+    }, o.prototype._getViewExtent = function() {
+      return [0, this._size[0]];
+    }, o.prototype._renderBackground = function() {
+      var e = this.dataZoomModel, t = this._size, i = this._displayables.sliderGroup, r = e.get("brushSelect");
+      i.add(new P({
+        silent: !0,
+        shape: {
+          x: 0,
+          y: 0,
+          width: t[0],
+          height: t[1]
+        },
+        style: {
+          fill: e.get("backgroundColor")
+        },
+        z2: -40
+      }));
+      var a = new P({
+        shape: {
+          x: 0,
+          y: 0,
+          width: t[0],
+          height: t[1]
+        },
+        style: {
+          fill: "transparent"
+        },
+        z2: 0,
+        onclick: _(this._onClickPanel, this)
+      }), n = this.api.getZr();
+      r ? (a.on("mousedown", this._onBrushStart, this), a.cursor = "crosshair", n.on("mousemove", this._onBrush), n.on("mouseup", this._onBrushEnd)) : (n.off("mousemove", this._onBrush), n.off("mouseup", this._onBrushEnd)), i.add(a);
+    }, o.prototype._renderDataShadow = function() {
+      var e = this._dataShadowInfo = this._prepareDataShadowInfo();
+      if (this._displayables.dataShadowSegs = [], !e)
+        return;
+      var t = this._size, i = this._shadowSize || [], r = e.series, a = r.getRawData(), n = r.getShadowDim && r.getShadowDim(), l = n && a.getDimensionInfo(n) ? r.getShadowDim() : e.otherDim;
+      if (l == null)
+        return;
+      var h = this._shadowPolygonPts, d = this._shadowPolylinePts;
+      if (a !== this._shadowData || l !== this._shadowDim || t[0] !== i[0] || t[1] !== i[1]) {
+        var u = a.getDataExtent(l), v = (u[1] - u[0]) * 0.3;
+        u = [u[0] - v, u[1] + v];
+        var p = [0, t[1]], c = [0, t[0]], f = [[t[0], 0], [0, 0]], m = [], x = c[1] / (a.count() - 1), g = 0, R = Math.round(a.count() / t[0]), w;
+        a.each([l], function(A, I) {
+          if (R > 0 && I % R) {
+            g += x;
+            return;
+          }
+          var b = A == null || isNaN(A) || A === "", W = b ? 0 : S(A, u, p, !0);
+          b && !w && I ? (f.push([f[f.length - 1][0], 0]), m.push([m[m.length - 1][0], 0])) : !b && w && (f.push([g, 0]), m.push([g, 0])), f.push([g, W]), m.push([g, W]), g += x, w = b;
+        }), h = this._shadowPolygonPts = f, d = this._shadowPolylinePts = m;
+      }
+      this._shadowData = a, this._shadowDim = l, this._shadowSize = [t[0], t[1]];
+      var M = this.dataZoomModel;
+      function z(A) {
+        var I = M.getModel(A ? "selectedDataBackground" : "dataBackground"), b = new Q(), W = new Ne({
+          shape: {
+            points: h
+          },
+          segmentIgnoreThreshold: 1,
+          style: I.getModel("areaStyle").getAreaStyle(),
+          silent: !0,
+          z2: -20
+        }), ye = new Ge({
+          shape: {
+            points: d
+          },
+          segmentIgnoreThreshold: 1,
+          style: I.getModel("lineStyle").getLineStyle(),
+          silent: !0,
+          z2: -19
+        });
+        return b.add(W), b.add(ye), b;
+      }
+      for (var L = 0; L < 3; L++) {
+        var C = z(L === 1);
+        this._displayables.sliderGroup.add(C), this._displayables.dataShadowSegs.push(C);
+      }
+    }, o.prototype._prepareDataShadowInfo = function() {
+      var e = this.dataZoomModel, t = e.get("showDataShadow");
+      if (t !== !1) {
+        var i, r = this.ecModel;
+        return e.eachTargetAxis(function(a, n) {
+          var l = e.getAxisProxy(a, n).getTargetSeriesModels();
+          y(l, function(h) {
+            if (!i && !(t !== !0 && ue(ut, h.get("type")) < 0)) {
+              var d = r.getComponent(D(a), n).axis, u = ft(a), v, p = h.coordinateSystem;
+              u != null && p.getOtherAxis && (v = p.getOtherAxis(d).inverse), u = h.getData().mapDimension(u), i = {
+                thisAxis: d,
+                series: h,
+                thisDim: a,
+                otherDim: u,
+                otherAxisInverse: v
+              };
+            }
+          }, this);
+        }, this), i;
+      }
+    }, o.prototype._renderHandle = function() {
+      var e = this.group, t = this._displayables, i = t.handles = [null, null], r = t.handleLabels = [null, null], a = this._displayables.sliderGroup, n = this._size, l = this.dataZoomModel, h = this.api, d = l.get("borderRadius") || 0, u = l.get("brushSelect"), v = t.filler = new P({
+        silent: u,
+        style: {
+          fill: l.get("fillerColor")
+        },
+        textConfig: {
+          position: "inside"
+        }
+      });
+      a.add(v), a.add(new P({
+        silent: !0,
+        subPixelOptimize: !0,
+        shape: {
+          x: 0,
+          y: 0,
+          width: n[0],
+          height: n[1],
+          r: d
+        },
+        style: {
+          // deprecated option
+          stroke: l.get("dataBackgroundColor") || l.get("borderColor"),
+          lineWidth: lt,
+          fill: "rgba(0,0,0,0)"
+        }
+      })), y([0, 1], function(R) {
+        var w = l.get("handleIcon");
+        !Ze[w] && w.indexOf("path://") < 0 && w.indexOf("image://") < 0 && (w = "path://" + w, process.env.NODE_ENV !== "production" && Le("handleIcon now needs 'path://' prefix when using a path string"));
+        var M = j(w, -1, 0, 2, 2, null, !0);
+        M.attr({
+          cursor: de(this._orient),
+          draggable: !0,
+          drift: _(this._onDragMove, this, R),
+          ondragend: _(this._onDragEnd, this),
+          onmouseover: _(this._showDataInfo, this, !0),
+          onmouseout: _(this._showDataInfo, this, !1),
+          z2: 5
+        });
+        var z = M.getBoundingRect(), L = l.get("handleSize");
+        this._handleHeight = ee(L, this._size[1]), this._handleWidth = z.width / z.height * this._handleHeight, M.setStyle(l.getModel("handleStyle").getItemStyle()), M.style.strokeNoScale = !0, M.rectHover = !0, M.ensureState("emphasis").style = l.getModel(["emphasis", "handleStyle"]).getItemStyle(), Ce(M);
+        var C = l.get("handleColor");
+        C != null && (M.style.fill = C), a.add(i[R] = M);
+        var A = l.getModel("textStyle"), I = l.get("handleLabel") || {}, b = I.show || !1;
+        e.add(r[R] = new Pe({
+          silent: !0,
+          invisible: !b,
+          style: Oe(A, {
+            x: 0,
+            y: 0,
+            text: "",
+            verticalAlign: "middle",
+            align: "center",
+            fill: A.getTextColor(),
+            font: A.getFont()
+          }),
+          z2: 10
+        }));
+      }, this);
+      var p = v;
+      if (u) {
+        var c = ee(l.get("moveHandleSize"), n[1]), f = t.moveHandle = new B({
+          style: l.getModel("moveHandleStyle").getItemStyle(),
+          silent: !0,
+          shape: {
+            r: [0, 0, 2, 2],
+            y: n[1] - 0.5,
+            height: c
+          }
+        }), m = c * 0.8, x = t.moveHandleIcon = j(l.get("moveHandleIcon"), -m / 2, -m / 2, m, m, "#fff", !0);
+        x.silent = !0, x.y = n[1] + c / 2 - 0.5, f.ensureState("emphasis").style = l.getModel(["emphasis", "moveHandleStyle"]).getItemStyle();
+        var g = Math.min(n[1] / 2, Math.max(c, 10));
+        p = t.moveZone = new B({
+          invisible: !0,
+          shape: {
+            y: n[1] - g,
+            height: c + g
+          }
+        }), p.on("mouseover", function() {
+          h.enterEmphasis(f);
+        }).on("mouseout", function() {
+          h.leaveEmphasis(f);
+        }), a.add(f), a.add(x), a.add(p);
+      }
+      p.attr({
+        draggable: !0,
+        cursor: de(this._orient),
+        drift: _(this._onDragMove, this, "all"),
+        ondragstart: _(this._showDataInfo, this, !0),
+        ondragend: _(this._onDragEnd, this),
+        onmouseover: _(this._showDataInfo, this, !0),
+        onmouseout: _(this._showDataInfo, this, !1)
+      });
+    }, o.prototype._resetInterval = function() {
+      var e = this._range = this.dataZoomModel.getPercentRange(), t = this._getViewExtent();
+      this._handleEnds = [S(e[0], [0, 100], t, !0), S(e[1], [0, 100], t, !0)];
+    }, o.prototype._updateInterval = function(e, t) {
+      var i = this.dataZoomModel, r = this._handleEnds, a = this._getViewExtent(), n = i.findRepresentativeAxisProxy().getMinMaxSpan(), l = [0, 100];
+      N(t, r, a, i.get("zoomLock") ? "all" : e, n.minSpan != null ? S(n.minSpan, l, a, !0) : null, n.maxSpan != null ? S(n.maxSpan, l, a, !0) : null);
+      var h = this._range, d = this._range = V([S(r[0], a, l, !0), S(r[1], a, l, !0)]);
+      return !h || h[0] !== d[0] || h[1] !== d[1];
+    }, o.prototype._updateView = function(e) {
+      var t = this._displayables, i = this._handleEnds, r = V(i.slice()), a = this._size;
+      y([0, 1], function(p) {
+        var c = t.handles[p], f = this._handleHeight;
+        c.attr({
+          scaleX: f / 2,
+          scaleY: f / 2,
+          // This is a trick, by adding an extra tiny offset to let the default handle's end point align to the drag window.
+          // NOTE: It may affect some custom shapes a bit. But we prefer to have better result by default.
+          x: i[p] + (p ? -1 : 1),
+          y: a[1] / 2 - f / 2
+        });
+      }, this), t.filler.setShape({
+        x: r[0],
+        y: 0,
+        width: r[1] - r[0],
+        height: a[1]
+      });
+      var n = {
+        x: r[0],
+        width: r[1] - r[0]
+      };
+      t.moveHandle && (t.moveHandle.setShape(n), t.moveZone.setShape(n), t.moveZone.getBoundingRect(), t.moveHandleIcon && t.moveHandleIcon.attr("x", n.x + n.width / 2));
+      for (var l = t.dataShadowSegs, h = [0, r[0], r[1], a[0]], d = 0; d < l.length; d++) {
+        var u = l[d], v = u.getClipPath();
+        v || (v = new B(), u.setClipPath(v)), v.setShape({
+          x: h[d],
+          y: 0,
+          width: h[d + 1] - h[d],
+          height: a[1]
+        });
+      }
+      this._updateDataInfo(e);
+    }, o.prototype._updateDataInfo = function(e) {
+      var t = this.dataZoomModel, i = this._displayables, r = i.handleLabels, a = this._orient, n = ["", ""];
+      if (t.get("showDetail")) {
+        var l = t.findRepresentativeAxisProxy();
+        if (l) {
+          var h = l.getAxisModel().axis, d = this._range, u = e ? l.calculateDataWindow({
+            start: d[0],
+            end: d[1]
+          }).valueWindow : l.getDataValueWindow();
+          n = [this._formatLabel(u[0], h), this._formatLabel(u[1], h)];
+        }
+      }
+      var v = V(this._handleEnds.slice());
+      p.call(this, 0), p.call(this, 1);
+      function p(c) {
+        var f = Ve(i.handles[c].parent, this.group), m = ze(c === 0 ? "right" : "left", f), x = this._handleWidth / 2 + dt, g = te([v[c] + (c === 0 ? -x : x), this._size[1] / 2], f);
+        r[c].setStyle({
+          x: g[0],
+          y: g[1],
+          verticalAlign: a === O ? "middle" : m,
+          align: a === O ? m : "center",
+          text: n[c]
+        });
+      }
+    }, o.prototype._formatLabel = function(e, t) {
+      var i = this.dataZoomModel, r = i.get("labelFormatter"), a = i.get("labelPrecision");
+      (a == null || a === "auto") && (a = t.getPixelPrecision());
+      var n = e == null || isNaN(e) ? "" : t.type === "category" || t.type === "time" ? t.scale.getLabel({
+        value: Math.round(e)
+      }) : e.toFixed(Math.min(a, 20));
+      return We(r) ? r(e, n) : Be(r) ? r.replace("{value}", n) : n;
+    }, o.prototype._showDataInfo = function(e) {
+      var t = this.dataZoomModel.get("handleLabel") || {}, i = t.show || !1, r = this.dataZoomModel.getModel(["emphasis", "handleLabel"]), a = r.get("show") || !1, n = e || this._dragging ? a : i, l = this._displayables, h = l.handleLabels;
+      h[0].attr("invisible", !n), h[1].attr("invisible", !n), l.moveHandle && this.api[n ? "enterEmphasis" : "leaveEmphasis"](l.moveHandle, 1);
+    }, o.prototype._onDragMove = function(e, t, i, r) {
+      this._dragging = !0, ae(r.event);
+      var a = this._displayables.sliderGroup.getLocalTransform(), n = te([t, i], a, !0), l = this._updateInterval(e, n[0]), h = this.dataZoomModel.get("realtime");
+      this._updateView(!h), l && h && this._dispatchZoomAction(!0);
+    }, o.prototype._onDragEnd = function() {
+      this._dragging = !1, this._showDataInfo(!1);
+      var e = this.dataZoomModel.get("realtime");
+      !e && this._dispatchZoomAction(!1);
+    }, o.prototype._onClickPanel = function(e) {
+      var t = this._size, i = this._displayables.sliderGroup.transformCoordToLocal(e.offsetX, e.offsetY);
+      if (!(i[0] < 0 || i[0] > t[0] || i[1] < 0 || i[1] > t[1])) {
+        var r = this._handleEnds, a = (r[0] + r[1]) / 2, n = this._updateInterval("all", i[0] - a);
+        this._updateView(), n && this._dispatchZoomAction(!1);
+      }
+    }, o.prototype._onBrushStart = function(e) {
+      var t = e.offsetX, i = e.offsetY;
+      this._brushStart = new ke(t, i), this._brushing = !0, this._brushStartTime = +/* @__PURE__ */ new Date();
+    }, o.prototype._onBrushEnd = function(e) {
+      if (this._brushing) {
+        var t = this._displayables.brushRect;
+        if (this._brushing = !1, !!t) {
+          t.attr("ignore", !0);
+          var i = t.shape, r = +/* @__PURE__ */ new Date();
+          if (!(r - this._brushStartTime < 200 && Math.abs(i.width) < 5)) {
+            var a = this._getViewExtent(), n = [0, 100];
+            this._range = V([S(i.x, a, n, !0), S(i.x + i.width, a, n, !0)]), this._handleEnds = [i.x, i.x + i.width], this._updateView(), this._dispatchZoomAction(!1);
+          }
+        }
+      }
+    }, o.prototype._onBrush = function(e) {
+      this._brushing && (ae(e.event), this._updateBrushRect(e.offsetX, e.offsetY));
+    }, o.prototype._updateBrushRect = function(e, t) {
+      var i = this._displayables, r = this.dataZoomModel, a = i.brushRect;
+      a || (a = i.brushRect = new P({
+        silent: !0,
+        style: r.getModel("brushStyle").getItemStyle()
+      }), i.sliderGroup.add(a)), a.attr("ignore", !1);
+      var n = this._brushStart, l = this._displayables.sliderGroup, h = l.transformCoordToLocal(e, t), d = l.transformCoordToLocal(n.x, n.y), u = this._size;
+      h[0] = Math.max(Math.min(u[0], h[0]), 0), a.setShape({
+        x: d[0],
+        y: 0,
+        width: h[0] - d[0],
+        height: u[1]
+      });
+    }, o.prototype._dispatchZoomAction = function(e) {
+      var t = this._range;
+      this.api.dispatchAction({
+        type: "dataZoom",
+        from: this.uid,
+        dataZoomId: this.dataZoomModel.id,
+        animation: e ? pt : null,
+        start: t[0],
+        end: t[1]
+      });
+    }, o.prototype._findCoordRect = function() {
+      var e, t = fe(this.dataZoomModel).infoList;
+      if (!e && t.length) {
+        var i = t[0].model.coordinateSystem;
+        e = i.getRect && i.getRect();
+      }
+      if (!e) {
+        var r = this.api.getWidth(), a = this.api.getHeight();
+        e = {
+          x: r * 0.2,
+          y: a * 0.2,
+          width: r * 0.6,
+          height: a * 0.6
+        };
+      }
+      return e;
+    }, o.type = "dataZoom.slider", o;
+  })(ve)
+);
+function ft(s) {
+  var o = {
+    x: "y",
+    y: "x",
+    radius: "angle",
+    angle: "radius"
+  };
+  return o[s];
+}
+function de(s) {
+  return s === "vertical" ? "ns-resize" : "ew-resize";
+}
+function vt(s) {
+  s.registerComponentModel(st), s.registerComponentView(ct), ge(s);
+}
+function _t(s) {
+  K(nt), K(vt);
+}
+export {
+  k as D,
+  nt as a,
+  vt as b,
+  ve as c,
+  ge as d,
+  _t as i
+};