@fecp/mobile 1.0.79 → 1.1.0

package/lib/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/component/dataZoom/DataZoomModel.js

@@ -0,0 +1,293 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const tslib_es6 = require("../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.js");
+const util = require("../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.js");
+const Component = require("../../model/Component.js");
+const helper = require("./helper.js");
+const model = require("../../util/model.js");
+var DataZoomAxisInfo = (
+  /** @class */
+  function() {
+    function DataZoomAxisInfo2() {
+      this.indexList = [];
+      this.indexMap = [];
+    }
+    DataZoomAxisInfo2.prototype.add = function(axisCmptIdx) {
+      if (!this.indexMap[axisCmptIdx]) {
+        this.indexList.push(axisCmptIdx);
+        this.indexMap[axisCmptIdx] = true;
+      }
+    };
+    return DataZoomAxisInfo2;
+  }()
+);
+var DataZoomModel = (
+  /** @class */
+  function(_super) {
+    tslib_es6.__extends(DataZoomModel2, _super);
+    function DataZoomModel2() {
+      var _this = _super !== null && _super.apply(this, arguments) || this;
+      _this.type = DataZoomModel2.type;
+      _this._autoThrottle = true;
+      _this._noTarget = true;
+      _this._rangePropMode = ["percent", "percent"];
+      return _this;
+    }
+    DataZoomModel2.prototype.init = function(option, parentModel, ecModel) {
+      var inputRawOption = retrieveRawOption(option);
+      this.settledOption = inputRawOption;
+      this.mergeDefaultAndTheme(option, ecModel);
+      this._doInit(inputRawOption);
+    };
+    DataZoomModel2.prototype.mergeOption = function(newOption) {
+      var inputRawOption = retrieveRawOption(newOption);
+      util.merge(this.option, newOption, true);
+      util.merge(this.settledOption, inputRawOption, true);
+      this._doInit(inputRawOption);
+    };
+    DataZoomModel2.prototype._doInit = function(inputRawOption) {
+      var thisOption = this.option;
+      this._setDefaultThrottle(inputRawOption);
+      this._updateRangeUse(inputRawOption);
+      var settledOption = this.settledOption;
+      util.each([["start", "startValue"], ["end", "endValue"]], function(names, index) {
+        if (this._rangePropMode[index] === "value") {
+          thisOption[names[0]] = settledOption[names[0]] = null;
+        }
+      }, this);
+      this._resetTarget();
+    };
+    DataZoomModel2.prototype._resetTarget = function() {
+      var optionOrient = this.get("orient", true);
+      var targetAxisIndexMap = this._targetAxisInfoMap = util.createHashMap();
+      var hasAxisSpecified = this._fillSpecifiedTargetAxis(targetAxisIndexMap);
+      if (hasAxisSpecified) {
+        this._orient = optionOrient || this._makeAutoOrientByTargetAxis();
+      } else {
+        this._orient = optionOrient || "horizontal";
+        this._fillAutoTargetAxisByOrient(targetAxisIndexMap, this._orient);
+      }
+      this._noTarget = true;
+      targetAxisIndexMap.each(function(axisInfo) {
+        if (axisInfo.indexList.length) {
+          this._noTarget = false;
+        }
+      }, this);
+    };
+    DataZoomModel2.prototype._fillSpecifiedTargetAxis = function(targetAxisIndexMap) {
+      var hasAxisSpecified = false;
+      util.each(helper.DATA_ZOOM_AXIS_DIMENSIONS, function(axisDim) {
+        var refering = this.getReferringComponents(helper.getAxisMainType(axisDim), model.MULTIPLE_REFERRING);
+        if (!refering.specified) {
+          return;
+        }
+        hasAxisSpecified = true;
+        var axisInfo = new DataZoomAxisInfo();
+        util.each(refering.models, function(axisModel) {
+          axisInfo.add(axisModel.componentIndex);
+        });
+        targetAxisIndexMap.set(axisDim, axisInfo);
+      }, this);
+      return hasAxisSpecified;
+    };
+    DataZoomModel2.prototype._fillAutoTargetAxisByOrient = function(targetAxisIndexMap, orient) {
+      var ecModel = this.ecModel;
+      var needAuto = true;
+      if (needAuto) {
+        var axisDim = orient === "vertical" ? "y" : "x";
+        var axisModels = ecModel.findComponents({
+          mainType: axisDim + "Axis"
+        });
+        setParallelAxis(axisModels, axisDim);
+      }
+      if (needAuto) {
+        var axisModels = ecModel.findComponents({
+          mainType: "singleAxis",
+          filter: function(axisModel) {
+            return axisModel.get("orient", true) === orient;
+          }
+        });
+        setParallelAxis(axisModels, "single");
+      }
+      function setParallelAxis(axisModels2, axisDim2) {
+        var axisModel = axisModels2[0];
+        if (!axisModel) {
+          return;
+        }
+        var axisInfo = new DataZoomAxisInfo();
+        axisInfo.add(axisModel.componentIndex);
+        targetAxisIndexMap.set(axisDim2, axisInfo);
+        needAuto = false;
+        if (axisDim2 === "x" || axisDim2 === "y") {
+          var gridModel_1 = axisModel.getReferringComponents("grid", model.SINGLE_REFERRING).models[0];
+          gridModel_1 && util.each(axisModels2, function(axModel) {
+            if (axisModel.componentIndex !== axModel.componentIndex && gridModel_1 === axModel.getReferringComponents("grid", model.SINGLE_REFERRING).models[0]) {
+              axisInfo.add(axModel.componentIndex);
+            }
+          });
+        }
+      }
+      if (needAuto) {
+        util.each(helper.DATA_ZOOM_AXIS_DIMENSIONS, function(axisDim2) {
+          if (!needAuto) {
+            return;
+          }
+          var axisModels2 = ecModel.findComponents({
+            mainType: helper.getAxisMainType(axisDim2),
+            filter: function(axisModel) {
+              return axisModel.get("type", true) === "category";
+            }
+          });
+          if (axisModels2[0]) {
+            var axisInfo = new DataZoomAxisInfo();
+            axisInfo.add(axisModels2[0].componentIndex);
+            targetAxisIndexMap.set(axisDim2, axisInfo);
+            needAuto = false;
+          }
+        }, this);
+      }
+    };
+    DataZoomModel2.prototype._makeAutoOrientByTargetAxis = function() {
+      var dim;
+      this.eachTargetAxis(function(axisDim) {
+        !dim && (dim = axisDim);
+      }, this);
+      return dim === "y" ? "vertical" : "horizontal";
+    };
+    DataZoomModel2.prototype._setDefaultThrottle = function(inputRawOption) {
+      if (inputRawOption.hasOwnProperty("throttle")) {
+        this._autoThrottle = false;
+      }
+      if (this._autoThrottle) {
+        var globalOption = this.ecModel.option;
+        this.option.throttle = globalOption.animation && globalOption.animationDurationUpdate > 0 ? 100 : 20;
+      }
+    };
+    DataZoomModel2.prototype._updateRangeUse = function(inputRawOption) {
+      var rangePropMode = this._rangePropMode;
+      var rangeModeInOption = this.get("rangeMode");
+      util.each([["start", "startValue"], ["end", "endValue"]], function(names, index) {
+        var percentSpecified = inputRawOption[names[0]] != null;
+        var valueSpecified = inputRawOption[names[1]] != null;
+        if (percentSpecified && !valueSpecified) {
+          rangePropMode[index] = "percent";
+        } else if (!percentSpecified && valueSpecified) {
+          rangePropMode[index] = "value";
+        } else if (rangeModeInOption) {
+          rangePropMode[index] = rangeModeInOption[index];
+        } else if (percentSpecified) {
+          rangePropMode[index] = "percent";
+        }
+      });
+    };
+    DataZoomModel2.prototype.noTarget = function() {
+      return this._noTarget;
+    };
+    DataZoomModel2.prototype.getFirstTargetAxisModel = function() {
+      var firstAxisModel;
+      this.eachTargetAxis(function(axisDim, axisIndex) {
+        if (firstAxisModel == null) {
+          firstAxisModel = this.ecModel.getComponent(helper.getAxisMainType(axisDim), axisIndex);
+        }
+      }, this);
+      return firstAxisModel;
+    };
+    DataZoomModel2.prototype.eachTargetAxis = function(callback, context) {
+      this._targetAxisInfoMap.each(function(axisInfo, axisDim) {
+        util.each(axisInfo.indexList, function(axisIndex) {
+          callback.call(context, axisDim, axisIndex);
+        });
+      });
+    };
+    DataZoomModel2.prototype.getAxisProxy = function(axisDim, axisIndex) {
+      var axisModel = this.getAxisModel(axisDim, axisIndex);
+      if (axisModel) {
+        return axisModel.__dzAxisProxy;
+      }
+    };
+    DataZoomModel2.prototype.getAxisModel = function(axisDim, axisIndex) {
+      var axisInfo = this._targetAxisInfoMap.get(axisDim);
+      if (axisInfo && axisInfo.indexMap[axisIndex]) {
+        return this.ecModel.getComponent(helper.getAxisMainType(axisDim), axisIndex);
+      }
+    };
+    DataZoomModel2.prototype.setRawRange = function(opt) {
+      var thisOption = this.option;
+      var settledOption = this.settledOption;
+      util.each([["start", "startValue"], ["end", "endValue"]], function(names) {
+        if (opt[names[0]] != null || opt[names[1]] != null) {
+          thisOption[names[0]] = settledOption[names[0]] = opt[names[0]];
+          thisOption[names[1]] = settledOption[names[1]] = opt[names[1]];
+        }
+      }, this);
+      this._updateRangeUse(opt);
+    };
+    DataZoomModel2.prototype.setCalculatedRange = function(opt) {
+      var option = this.option;
+      util.each(["start", "startValue", "end", "endValue"], function(name) {
+        option[name] = opt[name];
+      });
+    };
+    DataZoomModel2.prototype.getPercentRange = function() {
+      var axisProxy = this.findRepresentativeAxisProxy();
+      if (axisProxy) {
+        return axisProxy.getDataPercentWindow();
+      }
+    };
+    DataZoomModel2.prototype.getValueRange = function(axisDim, axisIndex) {
+      if (axisDim == null && axisIndex == null) {
+        var axisProxy = this.findRepresentativeAxisProxy();
+        if (axisProxy) {
+          return axisProxy.getDataValueWindow();
+        }
+      } else {
+        return this.getAxisProxy(axisDim, axisIndex).getDataValueWindow();
+      }
+    };
+    DataZoomModel2.prototype.findRepresentativeAxisProxy = function(axisModel) {
+      if (axisModel) {
+        return axisModel.__dzAxisProxy;
+      }
+      var firstProxy;
+      var axisDimList = this._targetAxisInfoMap.keys();
+      for (var i = 0; i < axisDimList.length; i++) {
+        var axisDim = axisDimList[i];
+        var axisInfo = this._targetAxisInfoMap.get(axisDim);
+        for (var j = 0; j < axisInfo.indexList.length; j++) {
+          var proxy = this.getAxisProxy(axisDim, axisInfo.indexList[j]);
+          if (proxy.hostedBy(this)) {
+            return proxy;
+          }
+          if (!firstProxy) {
+            firstProxy = proxy;
+          }
+        }
+      }
+      return firstProxy;
+    };
+    DataZoomModel2.prototype.getRangePropMode = function() {
+      return this._rangePropMode.slice();
+    };
+    DataZoomModel2.prototype.getOrient = function() {
+      return this._orient;
+    };
+    DataZoomModel2.type = "dataZoom";
+    DataZoomModel2.dependencies = ["xAxis", "yAxis", "radiusAxis", "angleAxis", "singleAxis", "series", "toolbox"];
+    DataZoomModel2.defaultOption = {
+      // zlevel: 0,
+      z: 4,
+      filterMode: "filter",
+      start: 0,
+      end: 100
+    };
+    return DataZoomModel2;
+  }(Component.default)
+);
+function retrieveRawOption(option) {
+  var ret = {};
+  util.each(["start", "end", "startValue", "endValue", "throttle"], function(name) {
+    option.hasOwnProperty(name) && (ret[name] = option[name]);
+  });
+  return ret;
+}
+exports.default = DataZoomModel;

package/lib/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/component/dataZoom/DataZoomView.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const tslib_es6 = require("../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.js");
+const Component = require("../../view/Component.js");
+var DataZoomView = (
+  /** @class */
+  function(_super) {
+    tslib_es6.__extends(DataZoomView2, _super);
+    function DataZoomView2() {
+      var _this = _super !== null && _super.apply(this, arguments) || this;
+      _this.type = DataZoomView2.type;
+      return _this;
+    }
+    DataZoomView2.prototype.render = function(dataZoomModel, ecModel, api, payload) {
+      this.dataZoomModel = dataZoomModel;
+      this.ecModel = ecModel;
+      this.api = api;
+    };
+    DataZoomView2.type = "dataZoom";
+    return DataZoomView2;
+  }(Component.default)
+);
+exports.default = DataZoomView;

package/lib/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/component/dataZoom/InsideZoomModel.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const tslib_es6 = require("../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.js");
+const DataZoomModel = require("./DataZoomModel.js");
+const component = require("../../util/component.js");
+var InsideZoomModel = (
+  /** @class */
+  function(_super) {
+    tslib_es6.__extends(InsideZoomModel2, _super);
+    function InsideZoomModel2() {
+      var _this = _super !== null && _super.apply(this, arguments) || this;
+      _this.type = InsideZoomModel2.type;
+      return _this;
+    }
+    InsideZoomModel2.type = "dataZoom.inside";
+    InsideZoomModel2.defaultOption = component.inheritDefaultOption(DataZoomModel.default.defaultOption, {
+      disabled: false,
+      zoomLock: false,
+      zoomOnMouseWheel: true,
+      moveOnMouseMove: true,
+      moveOnMouseWheel: false,
+      preventDefaultMouseMove: true
+    });
+    return InsideZoomModel2;
+  }(DataZoomModel.default)
+);
+exports.default = InsideZoomModel;

package/lib/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/component/dataZoom/InsideZoomView.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const tslib_es6 = require("../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.js");
+const DataZoomView = require("./DataZoomView.js");
+const sliderMove = require("../helper/sliderMove.js");
+const roams = require("./roams.js");
+const util = require("../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.js");
+var InsideZoomView = (
+  /** @class */
+  function(_super) {
+    tslib_es6.__extends(InsideZoomView2, _super);
+    function InsideZoomView2() {
+      var _this = _super !== null && _super.apply(this, arguments) || this;
+      _this.type = "dataZoom.inside";
+      return _this;
+    }
+    InsideZoomView2.prototype.render = function(dataZoomModel, ecModel, api) {
+      _super.prototype.render.apply(this, arguments);
+      if (dataZoomModel.noTarget()) {
+        this._clear();
+        return;
+      }
+      this.range = dataZoomModel.getPercentRange();
+      roams.setViewInfoToCoordSysRecord(api, dataZoomModel, {
+        pan: util.bind(getRangeHandlers.pan, this),
+        zoom: util.bind(getRangeHandlers.zoom, this),
+        scrollMove: util.bind(getRangeHandlers.scrollMove, this)
+      });
+    };
+    InsideZoomView2.prototype.dispose = function() {
+      this._clear();
+      _super.prototype.dispose.apply(this, arguments);
+    };
+    InsideZoomView2.prototype._clear = function() {
+      roams.disposeCoordSysRecordIfNeeded(this.api, this.dataZoomModel);
+      this.range = null;
+    };
+    InsideZoomView2.type = "dataZoom.inside";
+    return InsideZoomView2;
+  }(DataZoomView.default)
+);
+var getRangeHandlers = {
+  zoom: function(coordSysInfo, coordSysMainType, controller, e) {
+    var lastRange = this.range;
+    var range = lastRange.slice();
+    var axisModel = coordSysInfo.axisModels[0];
+    if (!axisModel) {
+      return;
+    }
+    var directionInfo = getDirectionInfo[coordSysMainType](null, [e.originX, e.originY], axisModel, controller, coordSysInfo);
+    var percentPoint = (directionInfo.signal > 0 ? directionInfo.pixelStart + directionInfo.pixelLength - directionInfo.pixel : directionInfo.pixel - directionInfo.pixelStart) / directionInfo.pixelLength * (range[1] - range[0]) + range[0];
+    var scale = Math.max(1 / e.scale, 0);
+    range[0] = (range[0] - percentPoint) * scale + percentPoint;
+    range[1] = (range[1] - percentPoint) * scale + percentPoint;
+    var minMaxSpan = this.dataZoomModel.findRepresentativeAxisProxy().getMinMaxSpan();
+    sliderMove.default(0, range, [0, 100], 0, minMaxSpan.minSpan, minMaxSpan.maxSpan);
+    this.range = range;
+    if (lastRange[0] !== range[0] || lastRange[1] !== range[1]) {
+      return range;
+    }
+  },
+  pan: makeMover(function(range, axisModel, coordSysInfo, coordSysMainType, controller, e) {
+    var directionInfo = getDirectionInfo[coordSysMainType]([e.oldX, e.oldY], [e.newX, e.newY], axisModel, controller, coordSysInfo);
+    return directionInfo.signal * (range[1] - range[0]) * directionInfo.pixel / directionInfo.pixelLength;
+  }),
+  scrollMove: makeMover(function(range, axisModel, coordSysInfo, coordSysMainType, controller, e) {
+    var directionInfo = getDirectionInfo[coordSysMainType]([0, 0], [e.scrollDelta, e.scrollDelta], axisModel, controller, coordSysInfo);
+    return directionInfo.signal * (range[1] - range[0]) * e.scrollDelta;
+  })
+};
+function makeMover(getPercentDelta) {
+  return function(coordSysInfo, coordSysMainType, controller, e) {
+    var lastRange = this.range;
+    var range = lastRange.slice();
+    var axisModel = coordSysInfo.axisModels[0];
+    if (!axisModel) {
+      return;
+    }
+    var percentDelta = getPercentDelta(range, axisModel, coordSysInfo, coordSysMainType, controller, e);
+    sliderMove.default(percentDelta, range, [0, 100], "all");
+    this.range = range;
+    if (lastRange[0] !== range[0] || lastRange[1] !== range[1]) {
+      return range;
+    }
+  };
+}
+var getDirectionInfo = {
+  grid: function(oldPoint, newPoint, axisModel, controller, coordSysInfo) {
+    var axis = axisModel.axis;
+    var ret = {};
+    var rect = coordSysInfo.model.coordinateSystem.getRect();
+    oldPoint = oldPoint || [0, 0];
+    if (axis.dim === "x") {
+      ret.pixel = newPoint[0] - oldPoint[0];
+      ret.pixelLength = rect.width;
+      ret.pixelStart = rect.x;
+      ret.signal = axis.inverse ? 1 : -1;
+    } else {
+      ret.pixel = newPoint[1] - oldPoint[1];
+      ret.pixelLength = rect.height;
+      ret.pixelStart = rect.y;
+      ret.signal = axis.inverse ? -1 : 1;
+    }
+    return ret;
+  },
+  polar: function(oldPoint, newPoint, axisModel, controller, coordSysInfo) {
+    var axis = axisModel.axis;
+    var ret = {};
+    var polar = coordSysInfo.model.coordinateSystem;
+    var radiusExtent = polar.getRadiusAxis().getExtent();
+    var angleExtent = polar.getAngleAxis().getExtent();
+    oldPoint = oldPoint ? polar.pointToCoord(oldPoint) : [0, 0];
+    newPoint = polar.pointToCoord(newPoint);
+    if (axisModel.mainType === "radiusAxis") {
+      ret.pixel = newPoint[0] - oldPoint[0];
+      ret.pixelLength = radiusExtent[1] - radiusExtent[0];
+      ret.pixelStart = radiusExtent[0];
+      ret.signal = axis.inverse ? 1 : -1;
+    } else {
+      ret.pixel = newPoint[1] - oldPoint[1];
+      ret.pixelLength = angleExtent[1] - angleExtent[0];
+      ret.pixelStart = angleExtent[0];
+      ret.signal = axis.inverse ? -1 : 1;
+    }
+    return ret;
+  },
+  singleAxis: function(oldPoint, newPoint, axisModel, controller, coordSysInfo) {
+    var axis = axisModel.axis;
+    var rect = coordSysInfo.model.coordinateSystem.getRect();
+    var ret = {};
+    oldPoint = oldPoint || [0, 0];
+    if (axis.orient === "horizontal") {
+      ret.pixel = newPoint[0] - oldPoint[0];
+      ret.pixelLength = rect.width;
+      ret.pixelStart = rect.x;
+      ret.signal = axis.inverse ? 1 : -1;
+    } else {
+      ret.pixel = newPoint[1] - oldPoint[1];
+      ret.pixelLength = rect.height;
+      ret.pixelStart = rect.y;
+      ret.signal = axis.inverse ? -1 : 1;
+    }
+    return ret;
+  }
+};
+exports.default = InsideZoomView;

package/lib/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/component/dataZoom/SliderZoomModel.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const tslib_es6 = require("../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.js");
+const DataZoomModel = require("./DataZoomModel.js");
+const component = require("../../util/component.js");
+var SliderZoomModel = (
+  /** @class */
+  function(_super) {
+    tslib_es6.__extends(SliderZoomModel2, _super);
+    function SliderZoomModel2() {
+      var _this = _super !== null && _super.apply(this, arguments) || this;
+      _this.type = SliderZoomModel2.type;
+      return _this;
+    }
+    SliderZoomModel2.type = "dataZoom.slider";
+    SliderZoomModel2.layoutMode = "box";
+    SliderZoomModel2.defaultOption = component.inheritDefaultOption(DataZoomModel.default.defaultOption, {
+      show: true,
+      // 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: true,
+      showDataShadow: "auto",
+      realtime: true,
+      zoomLock: false,
+      textStyle: {
+        color: "#6E7079"
+      },
+      brushSelect: true,
+      brushStyle: {
+        color: "rgba(135,175,274,0.15)"
+      },
+      emphasis: {
+        handleLabel: {
+          show: true
+        },
+        handleStyle: {
+          borderColor: "#8FB0F7"
+        },
+        moveHandleStyle: {
+          color: "#8FB0F7"
+        }
+      }
+    });
+    return SliderZoomModel2;
+  }(DataZoomModel.default)
+);
+exports.default = SliderZoomModel;