yahee-components 0.0.70 → 0.0.71

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/component/axis/axisBreakHelperImpl.js

@@ -0,0 +1,262 @@
+import { makeInner as pr } from "../../util/model.js";
+import { each as lr, find as $, assert as mr, map as J, extend as kr } from "../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js";
+import { getScaleBreakHelper as C } from "../../scale/break.js";
+import { subPixelOptimizeLine as dr } from "../../../../../../zrender@6.0.0/node_modules/zrender/lib/graphic/helper/subPixelOptimize.js";
+import { applyTransform as ar } from "../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/vector.js";
+import { rotate as xr, create as ir, mul as br } from "../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/matrix.js";
+import { AXIS_BREAK_EXPAND_ACTION_TYPE as vr, AXIS_BREAK_COLLAPSE_ACTION_TYPE as gr, AXIS_BREAK_TOGGLE_ACTION_TYPE as hr } from "./axisAction.js";
+import { labelIntersect as Ar, labelLayoutApplyTranslation as nr } from "../../label/labelLayoutHelper.js";
+import { registerAxisBreakHelperImpl as zr } from "./axisBreakHelper.js";
+import { warn as yr } from "../../util/log.js";
+import { WH as Q, XY as G } from "../../util/graphic.js";
+import tr from "../../../../../../zrender@6.0.0/node_modules/zrender/lib/graphic/Group.js";
+import _r from "../../../../../../zrender@6.0.0/node_modules/zrender/lib/graphic/shape/Line.js";
+import M from "../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/Point.js";
+import or from "../../../../../../zrender@6.0.0/node_modules/zrender/lib/graphic/shape/Polyline.js";
+import Tr from "../../../../../../zrender@6.0.0/node_modules/zrender/lib/graphic/shape/Polygon.js";
+var sr = pr();
+function Br(l, a) {
+  var r = $(l, function(i) {
+    return C().identifyAxisBreak(i.parsedBreak.breakOption, a.breakOption);
+  });
+  return r || l.push(r = {
+    zigzagRandomList: [],
+    parsedBreak: a,
+    shouldRemove: !1
+  }), r;
+}
+function Er(l) {
+  lr(l, function(a) {
+    return a.shouldRemove = !0;
+  });
+}
+function Ir(l) {
+  for (var a = l.length - 1; a >= 0; a--)
+    l[a].shouldRemove && l.splice(a, 1);
+}
+function Or(l, a, r, i, e) {
+  var n = r.axis;
+  if (n.scale.isBlank() || !C())
+    return;
+  var s = C().retrieveAxisBreakPairs(n.scale.getTicks({
+    breakTicks: "only_break"
+  }), function(A) {
+    return A.break;
+  }, !1);
+  if (!s.length)
+    return;
+  var v = r.getModel("breakArea"), u = v.get("zigzagAmplitude"), d = v.get("zigzagMinSpan"), p = v.get("zigzagMaxSpan");
+  d = Math.max(2, d || 0), p = Math.max(d, p || 0);
+  var T = v.get("expandOnClick"), f = v.get("zigzagZ"), E = v.getModel("itemStyle"), g = E.getItemStyle(), w = g.stroke, m = g.lineWidth, k = g.lineDash, t = g.fill, h = new tr({
+    ignoreModelZ: !0
+  }), z = n.isHorizontal(), I = sr(a).visualList || (sr(a).visualList = []);
+  Er(I);
+  for (var O = function(A) {
+    var x = s[A][0].break.parsedBreak, o = [];
+    o[0] = n.toGlobalCoord(n.dataToCoord(x.vmin, !0)), o[1] = n.toGlobalCoord(n.dataToCoord(x.vmax, !0)), o[1] < o[0] && o.reverse();
+    var c = Br(I, x);
+    c.shouldRemove = !1;
+    var b = new tr();
+    H(c.zigzagRandomList, b, o[0], o[1], z, x), T && b.on("click", function() {
+      var S = {
+        type: vr,
+        breaks: [{
+          start: x.breakOption.start,
+          end: x.breakOption.end
+        }]
+      };
+      S[n.dim + "AxisIndex"] = r.componentIndex, e.dispatchAction(S);
+    }), b.silent = !T, h.add(b);
+  }, y = 0; y < s.length; y++)
+    O(y);
+  l.add(h), Ir(I);
+  function H(A, x, o, c, b, S) {
+    var q = {
+      stroke: w,
+      lineWidth: m,
+      lineDash: k,
+      fill: "none"
+    }, B = b ? 0 : 1, _ = 1 - B, Y = i[G[_]] + i[Q[_]];
+    function rr(ur) {
+      var P = [], Z = [];
+      P[B] = Z[B] = ur, P[_] = i[G[_]], Z[_] = Y;
+      var D = {
+        x1: P[0],
+        y1: P[1],
+        x2: Z[0],
+        y2: Z[1]
+      };
+      return dr(D, D, {
+        lineWidth: 1
+      }), P[0] = D.x1, P[1] = D.y1, P[B];
+    }
+    o = rr(o), c = rr(c);
+    for (var K = [], V = [], N = !0, L = i[G[_]], j = 0; ; j++) {
+      var fr = L === i[G[_]], F = L >= Y;
+      F && (L = Y);
+      var R = [], W = [];
+      R[B] = o, W[B] = c, !fr && !F && (R[B] += N ? -u : u, W[B] -= N ? u : -u), R[_] = L, W[_] = L, K.push(R), V.push(W);
+      var X = void 0;
+      if (j < A.length ? X = A[j] : (X = Math.random(), A.push(X)), L += X * (p - d) + d, N = !N, F)
+        break;
+    }
+    var U = C().serializeAxisBreakIdentifier(S.breakOption);
+    if (x.add(new or({
+      anid: "break_a_" + U,
+      shape: {
+        points: K
+      },
+      style: q,
+      z: f
+    })), S.gapReal !== 0) {
+      x.add(new or({
+        anid: "break_b_" + U,
+        shape: {
+          // Not reverse to keep the dash stable when dragging resizing.
+          points: V
+        },
+        style: q,
+        z: f
+      }));
+      var er = V.slice();
+      er.reverse();
+      var cr = K.concat(er);
+      x.add(new Tr({
+        anid: "break_c_" + U,
+        shape: {
+          points: cr
+        },
+        style: {
+          fill: t,
+          opacity: g.opacity
+        },
+        z: f
+      }));
+    }
+  }
+}
+function Pr(l, a, r, i) {
+  var e = l.axis, n = r.transform;
+  mr(i.style);
+  var s = e.getExtent();
+  e.inverse && (s = s.slice(), s.reverse());
+  var v = C().retrieveAxisBreakPairs(e.scale.getTicks({
+    breakTicks: "only_break"
+  }), function(m) {
+    return m.break;
+  }, !1), u = J(v, function(m) {
+    var k = m[0].break.parsedBreak, t = [e.dataToCoord(k.vmin, !0), e.dataToCoord(k.vmax, !0)];
+    return t[0] > t[1] && t.reverse(), {
+      coordPair: t,
+      brkId: C().serializeAxisBreakIdentifier(k.breakOption)
+    };
+  });
+  u.sort(function(m, k) {
+    return m.coordPair[0] - k.coordPair[0];
+  });
+  for (var d = s[0], p = null, T = 0; T < u.length; T++) {
+    var f = u[T], E = Math.max(f.coordPair[0], s[0]), g = Math.min(f.coordPair[1], s[1]);
+    d <= E && w(d, E, p, f), d = g, p = f;
+  }
+  d <= s[1] && w(d, s[1], p, null);
+  function w(m, k, t, h) {
+    function z(o, c) {
+      n && (ar(o, o, n), ar(c, c, n));
+    }
+    function I(o, c) {
+      var b = {
+        x1: o[0],
+        y1: o[1],
+        x2: c[0],
+        y2: c[1]
+      };
+      dr(b, b, i.style), o[0] = b.x1, o[1] = b.y1, c[0] = b.x2, c[1] = b.y2;
+    }
+    var O = [m, 0], y = [k, 0], H = [m, 5], A = [k, 5];
+    z(O, H), I(O, H), z(y, A), I(y, A), I(O, y);
+    var x = new _r(kr({
+      shape: {
+        x1: O[0],
+        y1: O[1],
+        x2: y[0],
+        y2: y[1]
+      }
+    }, i));
+    a.add(x), x.anid = "breakLine_" + (t ? t.brkId : "\0") + "_\0_" + (h ? h.brkId : "\0");
+  }
+}
+function Mr(l, a, r) {
+  if ($(r, function(t) {
+    return !t;
+  }))
+    return;
+  var i = new M();
+  if (!Ar(r[0], r[1], i, {
+    // Assert `labelPair` is `[break_min, break_max]`.
+    // `axis.inverse: true` means a smaller scale value corresponds to a bigger value in axis.extent.
+    // The axisRotation indicates mtv direction of OBB intersecting.
+    direction: -(l ? a + Math.PI : a),
+    touchThreshold: 0,
+    // If need to resovle intersection align axis by moving labels according to MTV,
+    // the direction must not be opposite, otherwise cause misleading.
+    bidirectional: !1
+  }))
+    return;
+  var e = ir();
+  xr(e, e, -a);
+  var n = J(r, function(t) {
+    return t.transform ? br(ir(), e, t.transform) : e;
+  });
+  function s(t) {
+    var h = r[0].localRect, z = new M(h[Q[t]] * n[0][0], h[Q[t]] * n[0][1]);
+    return Math.abs(z.y) < 1e-5;
+  }
+  var v = 0.5;
+  if (s(0) || s(1)) {
+    var u = J(r, function(t, h) {
+      var z = t.localRect.clone();
+      return z.applyTransform(n[h]), z;
+    }), d = new M();
+    d.copy(r[0].label).add(r[1].label).scale(0.5), d.transform(e);
+    var p = i.clone().transform(e), T = u[0].x + u[1].x + (p.x >= 0 ? u[0].width : u[1].width), f = (T + p.x) / 2 - d.x, E = Math.min(f, f - p.x), g = Math.max(f, f - p.x), w = g < 0 ? g : E > 0 ? E : 0;
+    v = (f - w) / p.x;
+  }
+  var m = new M(), k = new M();
+  M.scale(m, i, -v), M.scale(k, i, 1 - v), nr(r[0], m), nr(r[1], k);
+}
+function Cr(l, a) {
+  var r = {
+    breaks: []
+  };
+  return lr(a.breaks, function(i) {
+    if (i) {
+      var e = $(l.get("breaks", !0), function(v) {
+        return C().identifyAxisBreak(v, i);
+      });
+      if (!e) {
+        process.env.NODE_ENV !== "production" && yr("Can not find axis break by start: " + i.start + ", end: " + i.end);
+        return;
+      }
+      var n = a.type, s = {
+        isExpanded: !!e.isExpanded
+      };
+      e.isExpanded = n === vr ? !0 : n === gr ? !1 : n === hr ? !e.isExpanded : e.isExpanded, r.breaks.push({
+        start: e.start,
+        end: e.end,
+        isExpanded: !!e.isExpanded,
+        old: s
+      });
+    }
+  }), r;
+}
+function Ur() {
+  zr({
+    adjustBreakLabelPair: Mr,
+    buildAxisBreakLine: Pr,
+    rectCoordBuildBreakAxis: Or,
+    updateModelAxisBreak: Cr
+  });
+}
+export {
+  Ur as installAxisBreakHelper
+};

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/component/axis/axisSplitHelper.js

@@ -0,0 +1,55 @@
+import { createHashMap as h, isArray as R, defaults as H } from "../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js";
+import { makeInner as _ } from "../../util/model.js";
+import x from "../../../../../../zrender@6.0.0/node_modules/zrender/lib/graphic/shape/Rect.js";
+var f = _();
+function I(s, b, A, B) {
+  var o = A.axis;
+  if (!o.scale.isBlank()) {
+    var C = A.getModel("splitArea"), g = C.getModel("areaStyle"), a = g.get("color"), i = B.coordinateSystem.getRect(), e = o.getTicksCoords({
+      tickModel: C,
+      clamp: !0,
+      breakTicks: "none",
+      pruneByBreak: "preserve_extent_bound"
+    });
+    if (e.length) {
+      var u = a.length, m = f(s).splitAreaColors, S = h(), l = 0;
+      if (m)
+        for (var r = 0; r < e.length; r++) {
+          var k = m.get(e[r].tickValue);
+          if (k != null) {
+            l = (k + (u - 1) * r) % u;
+            break;
+          }
+        }
+      var v = o.toGlobalCoord(e[0].coord), M = g.getAreaStyle();
+      a = R(a) ? a : [a];
+      for (var r = 1; r < e.length; r++) {
+        var y = o.toGlobalCoord(e[r].coord), t = void 0, n = void 0, d = void 0, p = void 0;
+        o.isHorizontal() ? (t = v, n = i.y, d = y - t, p = i.height, v = t + d) : (t = i.x, n = v, d = i.width, p = y - n, v = n + p);
+        var c = e[r - 1].tickValue;
+        c != null && S.set(c, l), b.add(new x({
+          anid: c != null ? "area_" + c : null,
+          shape: {
+            x: t,
+            y: n,
+            width: d,
+            height: p
+          },
+          style: H({
+            fill: a[l]
+          }, M),
+          autoBatch: !0,
+          silent: !0
+        })), l = (l + 1) % u;
+      }
+      f(s).splitAreaColors = S;
+    }
+  }
+}
+function L(s) {
+  f(s).splitAreaColors = null;
+}
+export {
+  I as rectCoordAxisBuildSplitArea,
+  L as rectCoordAxisHandleRemove
+};

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/component/axis/installBreak.js

@@ -0,0 +1,9 @@
+import { installScaleBreakHelper as e } from "../../scale/breakImpl.js";
+import { registerAction as i } from "./axisAction.js";
+import { installAxisBreakHelper as t } from "./axisBreakHelperImpl.js";
+function m(r) {
+  i(r), e(), t();
+}
+export {
+  m as installAxisBreak
+};

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/component/axis/parallelAxisAction.js

@@ -0,0 +1,25 @@
+var a = {
+  type: "axisAreaSelect",
+  event: "axisAreaSelected"
+  // update: 'updateVisual'
+};
+function l(i) {
+  i.registerAction(a, function(e, n) {
+    n.eachComponent({
+      mainType: "parallelAxis",
+      query: e
+    }, function(t) {
+      t.axis.model.setActiveIntervals(e.intervals);
+    });
+  }), i.registerAction("parallelAxisExpand", function(e, n) {
+    n.eachComponent({
+      mainType: "parallel",
+      query: e
+    }, function(t) {
+      t.setAxisExpand(e);
+    });
+  });
+}
+export {
+  l as installParallelActions
+};

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/component/axisPointer/AxisPointerModel.js

@@ -0,0 +1,68 @@
+import { __extends as l } from "../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.js";
+import n from "../../model/Component.js";
+import t from "../../visual/tokens.js";
+var d = (
+  /** @class */
+  function(r) {
+    l(o, r);
+    function o() {
+      var e = r !== null && r.apply(this, arguments) || this;
+      return e.type = o.type, e;
+    }
+    return o.type = "axisPointer", o.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: t.color.border,
+        width: 1,
+        type: "dashed"
+      },
+      shadowStyle: {
+        color: t.color.shadowTint
+      },
+      label: {
+        show: !0,
+        formatter: null,
+        precision: "auto",
+        margin: 3,
+        color: t.color.neutral00,
+        padding: [5, 7, 5, 7],
+        backgroundColor: t.color.accent60,
+        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: t.color.accent40,
+        // For mobile performance
+        throttle: 40
+      }
+    }, o;
+  }(n)
+);
+export {
+  d as default
+};

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/component/axisPointer/AxisPointerView.js

@@ -0,0 +1,31 @@
+import { __extends as m } from "../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.js";
+import { register as g, unregister as f } from "./globalListener.js";
+import u from "../../view/Component.js";
+var y = (
+  /** @class */
+  function(n) {
+    m(t, n);
+    function t() {
+      var e = n !== null && n.apply(this, arguments) || this;
+      return e.type = t.type, e;
+    }
+    return t.prototype.render = function(e, o, a) {
+      var p = o.getComponent("tooltip"), s = e.get("triggerOn") || p && p.get("triggerOn") || "mousemove|click";
+      g("axisPointer", a, function(r, i, l) {
+        s !== "none" && (r === "leave" || s.indexOf(r) >= 0) && l({
+          type: "updateAxisPointer",
+          currTrigger: r,
+          x: i && i.offsetX,
+          y: i && i.offsetY
+        });
+      });
+    }, t.prototype.remove = function(e, o) {
+      f("axisPointer", o);
+    }, t.prototype.dispose = function(e, o) {
+      f("axisPointer", o);
+    }, t.type = "axisPointer", t;
+  }(u)
+);
+export {
+  y as default
+};

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/component/axisPointer/BaseAxisPointer.js

@@ -0,0 +1,185 @@
+import { curry as E, clone as x, bind as H, isArray as P, isObject as v, each as w } from "../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js";
+import * as z from "../../util/graphic.js";
+import { createIcon as S } from "../../util/graphic.js";
+import { getAxisInfo as T } from "./modelHelper.js";
+import { stop as M } from "../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/event.js";
+import { createOrUpdate as I, clear as D } from "../../util/throttle.js";
+import { makeInner as L } from "../../util/model.js";
+import V from "../../../../../../zrender@6.0.0/node_modules/zrender/lib/graphic/Group.js";
+import C from "../../../../../../zrender@6.0.0/node_modules/zrender/lib/graphic/Text.js";
+import { updateProps as K } from "../../animation/basicTransition.js";
+var u = L(), _ = x, p = H, Y = (
+  /** @class */
+  function() {
+    function r() {
+      this._dragging = !1, this.animationThreshold = 15;
+    }
+    return r.prototype.render = function(e, t, a, i) {
+      var o = t.get("value"), l = t.get("status");
+      if (this._axisModel = e, this._axisPointerModel = t, this._api = a, !(!i && this._lastValue === o && this._lastStatus === l)) {
+        this._lastValue = o, this._lastStatus = l;
+        var n = this._group, s = this._handle;
+        if (!l || l === "hide") {
+          n && n.hide(), s && s.hide();
+          return;
+        }
+        n && n.show(), s && s.show();
+        var h = {};
+        this.makeElOption(h, o, e, t, a);
+        var f = h.graphicKey;
+        f !== this._lastGraphicKey && this.clear(a), this._lastGraphicKey = f;
+        var A = this._moveAnimation = this.determineAnimation(e, t);
+        if (!n)
+          n = this._group = new V(), this.createPointerEl(n, h, e, t), this.createLabelEl(n, h, e, t), a.getZr().add(n);
+        else {
+          var c = E(g, t, A);
+          this.updatePointerEl(n, h, c), this.updateLabelEl(n, h, c, t);
+        }
+        y(n, t, !0), this._renderHandle(o);
+      }
+    }, r.prototype.remove = function(e) {
+      this.clear(e);
+    }, r.prototype.dispose = function(e) {
+      this.clear(e);
+    }, r.prototype.determineAnimation = function(e, t) {
+      var a = t.get("animation"), i = e.axis, o = i.type === "category", l = t.get("snap");
+      if (!l && !o)
+        return !1;
+      if (a === "auto" || a == null) {
+        var n = this.animationThreshold;
+        if (o && i.getBandWidth() > n)
+          return !0;
+        if (l) {
+          var s = T(e).seriesDataCount, h = i.getExtent();
+          return Math.abs(h[0] - h[1]) / s > n;
+        }
+        return !1;
+      }
+      return a === !0;
+    }, r.prototype.makeElOption = function(e, t, a, i, o) {
+    }, r.prototype.createPointerEl = function(e, t, a, i) {
+      var o = t.pointer;
+      if (o) {
+        var l = u(e).pointerEl = new z[o.type](_(t.pointer));
+        e.add(l);
+      }
+    }, r.prototype.createLabelEl = function(e, t, a, i) {
+      if (t.label) {
+        var o = u(e).labelEl = new C(_(t.label));
+        e.add(o), m(o, i);
+      }
+    }, r.prototype.updatePointerEl = function(e, t, a) {
+      var i = u(e).pointerEl;
+      i && t.pointer && (i.setStyle(t.pointer.style), a(i, {
+        shape: t.pointer.shape
+      }));
+    }, r.prototype.updateLabelEl = function(e, t, a, i) {
+      var o = u(e).labelEl;
+      o && (o.setStyle(t.label.style), a(o, {
+        // 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: t.label.x,
+        y: t.label.y
+      }), m(o, i));
+    }, r.prototype._renderHandle = function(e) {
+      if (!(this._dragging || !this.updateHandleTransform)) {
+        var t = this._axisPointerModel, a = this._api.getZr(), i = this._handle, o = t.getModel("handle"), l = t.get("status");
+        if (!o.get("show") || !l || l === "hide") {
+          i && a.remove(i), this._handle = null;
+          return;
+        }
+        var n;
+        this._handle || (n = !0, i = this._handle = S(o.get("icon"), {
+          cursor: "move",
+          draggable: !0,
+          onmousemove: function(h) {
+            M(h.event);
+          },
+          onmousedown: p(this._onHandleDragMove, this, 0, 0),
+          drift: p(this._onHandleDragMove, this),
+          ondragend: p(this._onHandleDragEnd, this)
+        }), a.add(i)), y(i, t, !1), i.setStyle(o.getItemStyle(null, ["color", "borderColor", "borderWidth", "opacity", "shadowColor", "shadowBlur", "shadowOffsetX", "shadowOffsetY"]));
+        var s = o.get("size");
+        P(s) || (s = [s, s]), i.scaleX = s[0] / 2, i.scaleY = s[1] / 2, I(this, "_doDispatchAxisPointer", o.get("throttle") || 0, "fixRate"), this._moveHandleToValue(e, n);
+      }
+    }, r.prototype._moveHandleToValue = function(e, t) {
+      g(this._axisPointerModel, !t && this._moveAnimation, this._handle, d(this.getHandleTransform(e, this._axisModel, this._axisPointerModel)));
+    }, r.prototype._onHandleDragMove = function(e, t) {
+      var a = this._handle;
+      if (a) {
+        this._dragging = !0;
+        var i = this.updateHandleTransform(d(a), [e, t], this._axisModel, this._axisPointerModel);
+        this._payloadInfo = i, a.stopAnimation(), a.attr(d(i)), u(a).lastProp = null, this._doDispatchAxisPointer();
+      }
+    }, r.prototype._doDispatchAxisPointer = function() {
+      var e = this._handle;
+      if (e) {
+        var t = this._payloadInfo, a = this._axisModel;
+        this._api.dispatchAction({
+          type: "updateAxisPointer",
+          x: t.cursorPoint[0],
+          y: t.cursorPoint[1],
+          tooltipOption: t.tooltipOption,
+          axesInfo: [{
+            axisDim: a.axis.dim,
+            axisIndex: a.componentIndex
+          }]
+        });
+      }
+    }, r.prototype._onHandleDragEnd = function() {
+      this._dragging = !1;
+      var e = this._handle;
+      if (e) {
+        var t = this._axisPointerModel.get("value");
+        this._moveHandleToValue(t), this._api.dispatchAction({
+          type: "hideTip"
+        });
+      }
+    }, r.prototype.clear = function(e) {
+      this._lastValue = null, this._lastStatus = null;
+      var t = e.getZr(), a = this._group, i = this._handle;
+      t && a && (this._lastGraphicKey = null, a && t.remove(a), i && t.remove(i), this._group = null, this._handle = null, this._payloadInfo = null), D(this, "_doDispatchAxisPointer");
+    }, r.prototype.doClear = function() {
+    }, r.prototype.buildLabel = function(e, t, a) {
+      return a = a || 0, {
+        x: e[a],
+        y: e[1 - a],
+        width: t[a],
+        height: t[1 - a]
+      };
+    }, r;
+  }()
+);
+function g(r, e, t, a) {
+  b(u(t).lastProp, a) || (u(t).lastProp = a, e ? K(t, a, r) : (t.stopAnimation(), t.attr(a)));
+}
+function b(r, e) {
+  if (v(r) && v(e)) {
+    var t = !0;
+    return w(e, function(a, i) {
+      t = t && b(r[i], a);
+    }), !!t;
+  } else
+    return r === e;
+}
+function m(r, e) {
+  r[e.get(["label", "show"]) ? "show" : "hide"]();
+}
+function d(r) {
+  return {
+    x: r.x || 0,
+    y: r.y || 0,
+    rotation: r.rotation || 0
+  };
+}
+function y(r, e, t) {
+  var a = e.get("z"), i = e.get("zlevel");
+  r && r.traverse(function(o) {
+    o.type !== "group" && (a != null && (o.z = a), i != null && (o.zlevel = i), o.silent = t);
+  });
+}
+export {
+  Y as default
+};