@ecan-bi/datav 1.1.15 → 1.1.17

package/lib/node_modules/echarts/lib/core/echarts.js

@@ -0,0 +1,1783 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const tslib_es6 = require("../../node_modules/tslib/tslib.es6.js");
+const zrender = require("../../../zrender/lib/zrender.js");
+const util = require("../../../zrender/lib/core/util.js");
+const env = require("../../../zrender/lib/core/env.js");
+const timsort = require("../../../zrender/lib/core/timsort.js");
+const Eventful = require("../../../zrender/lib/core/Eventful.js");
+const Global = require("../model/Global.js");
+const ExtensionAPI = require("./ExtensionAPI.js");
+const CoordinateSystem = require("./CoordinateSystem.js");
+const OptionManager = require("../model/OptionManager.js");
+const backwardCompat = require("../preprocessor/backwardCompat.js");
+const dataStack = require("../processor/dataStack.js");
+const Series = require("../model/Series.js");
+const Component = require("../view/Component.js");
+const Chart = require("../view/Chart.js");
+const innerStore = require("../util/innerStore.js");
+const states = require("../util/states.js");
+const model = require("../util/model.js");
+const throttle = require("../util/throttle.js");
+const style = require("../visual/style.js");
+const _default = require("../loading/default.js");
+const Scheduler = require("./Scheduler.js");
+const light = require("../theme/light.js");
+const dark = require("../theme/dark.js");
+const clazz = require("../util/clazz.js");
+const ECEventProcessor = require("../util/ECEventProcessor.js");
+const symbol = require("../visual/symbol.js");
+const helper = require("../visual/helper.js");
+const log = require("../util/log.js");
+const dataSelectAction = require("../legacy/dataSelectAction.js");
+const transform = require("../data/helper/transform.js");
+const locale = require("./locale.js");
+const event = require("../util/event.js");
+const decal = require("../visual/decal.js");
+const lifecycle = require("./lifecycle.js");
+const platform = require("../../../zrender/lib/core/platform.js");
+const impl = require("./impl.js");
+const Rect = require("../../../zrender/lib/graphic/shape/Rect.js");
+const Image = require("../../../zrender/lib/graphic/Image.js");
+const basicTrasition = require("../animation/basicTrasition.js");
+const Path = require("../../../zrender/lib/graphic/Path.js");
+var hasWindow = typeof window !== "undefined";
+var TEST_FRAME_REMAIN_TIME = 1;
+var PRIORITY_PROCESSOR_SERIES_FILTER = 800;
+var PRIORITY_PROCESSOR_DATASTACK = 900;
+var PRIORITY_PROCESSOR_FILTER = 1e3;
+var PRIORITY_PROCESSOR_DEFAULT = 2e3;
+var PRIORITY_PROCESSOR_STATISTIC = 5e3;
+var PRIORITY_VISUAL_LAYOUT = 1e3;
+var PRIORITY_VISUAL_PROGRESSIVE_LAYOUT = 1100;
+var PRIORITY_VISUAL_GLOBAL = 2e3;
+var PRIORITY_VISUAL_CHART = 3e3;
+var PRIORITY_VISUAL_COMPONENT = 4e3;
+var PRIORITY_VISUAL_CHART_DATA_CUSTOM = 4500;
+var PRIORITY_VISUAL_POST_CHART_LAYOUT = 4600;
+var PRIORITY_VISUAL_BRUSH = 5e3;
+var PRIORITY_VISUAL_ARIA = 6e3;
+var PRIORITY_VISUAL_DECAL = 7e3;
+var PRIORITY = {
+  PROCESSOR: {
+    FILTER: PRIORITY_PROCESSOR_FILTER,
+    SERIES_FILTER: PRIORITY_PROCESSOR_SERIES_FILTER,
+    STATISTIC: PRIORITY_PROCESSOR_STATISTIC
+  },
+  VISUAL: {
+    LAYOUT: PRIORITY_VISUAL_LAYOUT,
+    PROGRESSIVE_LAYOUT: PRIORITY_VISUAL_PROGRESSIVE_LAYOUT,
+    GLOBAL: PRIORITY_VISUAL_GLOBAL,
+    CHART: PRIORITY_VISUAL_CHART,
+    POST_CHART_LAYOUT: PRIORITY_VISUAL_POST_CHART_LAYOUT,
+    COMPONENT: PRIORITY_VISUAL_COMPONENT,
+    BRUSH: PRIORITY_VISUAL_BRUSH,
+    CHART_ITEM: PRIORITY_VISUAL_CHART_DATA_CUSTOM,
+    ARIA: PRIORITY_VISUAL_ARIA,
+    DECAL: PRIORITY_VISUAL_DECAL
+  }
+};
+var IN_MAIN_PROCESS_KEY = "__flagInMainProcess";
+var PENDING_UPDATE = "__pendingUpdate";
+var STATUS_NEEDS_UPDATE_KEY = "__needsUpdateStatus";
+var ACTION_REG = /^[a-zA-Z0-9_]+$/;
+var CONNECT_STATUS_KEY = "__connectUpdateStatus";
+var CONNECT_STATUS_PENDING = 0;
+var CONNECT_STATUS_UPDATING = 1;
+var CONNECT_STATUS_UPDATED = 2;
+function createRegisterEventWithLowercaseECharts(method) {
+  return function() {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+      args[_i] = arguments[_i];
+    }
+    if (this.isDisposed()) {
+      disposedWarning(this.id);
+      return;
+    }
+    return toLowercaseNameAndCallEventful(this, method, args);
+  };
+}
+function createRegisterEventWithLowercaseMessageCenter(method) {
+  return function() {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+      args[_i] = arguments[_i];
+    }
+    return toLowercaseNameAndCallEventful(this, method, args);
+  };
+}
+function toLowercaseNameAndCallEventful(host, method, args) {
+  args[0] = args[0] && args[0].toLowerCase();
+  return Eventful.default.prototype[method].apply(host, args);
+}
+var MessageCenter = (
+  /** @class */
+  function(_super) {
+    tslib_es6.__extends(MessageCenter2, _super);
+    function MessageCenter2() {
+      return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return MessageCenter2;
+  }(Eventful.default)
+);
+var messageCenterProto = MessageCenter.prototype;
+messageCenterProto.on = createRegisterEventWithLowercaseMessageCenter("on");
+messageCenterProto.off = createRegisterEventWithLowercaseMessageCenter("off");
+var prepare;
+var prepareView;
+var updateDirectly;
+var updateMethods;
+var doConvertPixel;
+var updateStreamModes;
+var doDispatchAction;
+var flushPendingActions;
+var triggerUpdatedEvent;
+var bindRenderedEvent;
+var bindMouseEvent;
+var render;
+var renderComponents;
+var renderSeries;
+var createExtensionAPI;
+var enableConnect;
+var markStatusToUpdate;
+var applyChangedStates;
+var ECharts = (
+  /** @class */
+  function(_super) {
+    tslib_es6.__extends(ECharts2, _super);
+    function ECharts2(dom, theme, opts) {
+      var _this = _super.call(this, new ECEventProcessor.ECEventProcessor()) || this;
+      _this._chartsViews = [];
+      _this._chartsMap = {};
+      _this._componentsViews = [];
+      _this._componentsMap = {};
+      _this._pendingActions = [];
+      opts = opts || {};
+      if (util.isString(theme)) {
+        theme = themeStorage[theme];
+      }
+      _this._dom = dom;
+      var defaultRenderer = "canvas";
+      var defaultUseDirtyRect = false;
+      if (process.env.NODE_ENV !== "production") {
+        var root = (
+          /* eslint-disable-next-line */
+          hasWindow ? window : global
+        );
+        defaultRenderer = root.__ECHARTS__DEFAULT__RENDERER__ || defaultRenderer;
+        var devUseDirtyRect = root.__ECHARTS__DEFAULT__USE_DIRTY_RECT__;
+        defaultUseDirtyRect = devUseDirtyRect == null ? defaultUseDirtyRect : devUseDirtyRect;
+      }
+      var zr = _this._zr = zrender.init(dom, {
+        renderer: opts.renderer || defaultRenderer,
+        devicePixelRatio: opts.devicePixelRatio,
+        width: opts.width,
+        height: opts.height,
+        ssr: opts.ssr,
+        useDirtyRect: opts.useDirtyRect == null ? defaultUseDirtyRect : opts.useDirtyRect
+      });
+      _this._ssr = opts.ssr;
+      _this._throttledZrFlush = throttle.throttle(util.bind(zr.flush, zr), 17);
+      theme = util.clone(theme);
+      theme && backwardCompat.default(theme, true);
+      _this._theme = theme;
+      _this._locale = locale.createLocaleObject(opts.locale || locale.SYSTEM_LANG);
+      _this._coordSysMgr = new CoordinateSystem.default();
+      var api = _this._api = createExtensionAPI(_this);
+      function prioritySortFunc(a, b) {
+        return a.__prio - b.__prio;
+      }
+      timsort.default(visualFuncs, prioritySortFunc);
+      timsort.default(dataProcessorFuncs, prioritySortFunc);
+      _this._scheduler = new Scheduler.default(_this, api, dataProcessorFuncs, visualFuncs);
+      _this._messageCenter = new MessageCenter();
+      _this._initEvents();
+      _this.resize = util.bind(_this.resize, _this);
+      zr.animation.on("frame", _this._onframe, _this);
+      bindRenderedEvent(zr, _this);
+      bindMouseEvent(zr, _this);
+      util.setAsPrimitive(_this);
+      return _this;
+    }
+    ECharts2.prototype._onframe = function() {
+      if (this._disposed) {
+        return;
+      }
+      applyChangedStates(this);
+      var scheduler = this._scheduler;
+      if (this[PENDING_UPDATE]) {
+        var silent = this[PENDING_UPDATE].silent;
+        this[IN_MAIN_PROCESS_KEY] = true;
+        try {
+          prepare(this);
+          updateMethods.update.call(this, null, this[PENDING_UPDATE].updateParams);
+        } catch (e) {
+          this[IN_MAIN_PROCESS_KEY] = false;
+          this[PENDING_UPDATE] = null;
+          throw e;
+        }
+        this._zr.flush();
+        this[IN_MAIN_PROCESS_KEY] = false;
+        this[PENDING_UPDATE] = null;
+        flushPendingActions.call(this, silent);
+        triggerUpdatedEvent.call(this, silent);
+      } else if (scheduler.unfinished) {
+        var remainTime = TEST_FRAME_REMAIN_TIME;
+        var ecModel = this._model;
+        var api = this._api;
+        scheduler.unfinished = false;
+        do {
+          var startTime = +new Date();
+          scheduler.performSeriesTasks(ecModel);
+          scheduler.performDataProcessorTasks(ecModel);
+          updateStreamModes(this, ecModel);
+          scheduler.performVisualTasks(ecModel);
+          renderSeries(this, this._model, api, "remain", {});
+          remainTime -= +new Date() - startTime;
+        } while (remainTime > 0 && scheduler.unfinished);
+        if (!scheduler.unfinished) {
+          this._zr.flush();
+        }
+      }
+    };
+    ECharts2.prototype.getDom = function() {
+      return this._dom;
+    };
+    ECharts2.prototype.getId = function() {
+      return this.id;
+    };
+    ECharts2.prototype.getZr = function() {
+      return this._zr;
+    };
+    ECharts2.prototype.isSSR = function() {
+      return this._ssr;
+    };
+    ECharts2.prototype.setOption = function(option, notMerge, lazyUpdate) {
+      if (this[IN_MAIN_PROCESS_KEY]) {
+        if (process.env.NODE_ENV !== "production") {
+          log.error("`setOption` should not be called during main process.");
+        }
+        return;
+      }
+      if (this._disposed) {
+        disposedWarning(this.id);
+        return;
+      }
+      var silent;
+      var replaceMerge;
+      var transitionOpt;
+      if (util.isObject(notMerge)) {
+        lazyUpdate = notMerge.lazyUpdate;
+        silent = notMerge.silent;
+        replaceMerge = notMerge.replaceMerge;
+        transitionOpt = notMerge.transition;
+        notMerge = notMerge.notMerge;
+      }
+      this[IN_MAIN_PROCESS_KEY] = true;
+      if (!this._model || notMerge) {
+        var optionManager = new OptionManager.default(this._api);
+        var theme = this._theme;
+        var ecModel = this._model = new Global.default();
+        ecModel.scheduler = this._scheduler;
+        ecModel.ssr = this._ssr;
+        ecModel.init(null, null, null, theme, this._locale, optionManager);
+      }
+      this._model.setOption(option, {
+        replaceMerge
+      }, optionPreprocessorFuncs);
+      var updateParams = {
+        seriesTransition: transitionOpt,
+        optionChanged: true
+      };
+      if (lazyUpdate) {
+        this[PENDING_UPDATE] = {
+          silent,
+          updateParams
+        };
+        this[IN_MAIN_PROCESS_KEY] = false;
+        this.getZr().wakeUp();
+      } else {
+        try {
+          prepare(this);
+          updateMethods.update.call(this, null, updateParams);
+        } catch (e) {
+          this[PENDING_UPDATE] = null;
+          this[IN_MAIN_PROCESS_KEY] = false;
+          throw e;
+        }
+        if (!this._ssr) {
+          this._zr.flush();
+        }
+        this[PENDING_UPDATE] = null;
+        this[IN_MAIN_PROCESS_KEY] = false;
+        flushPendingActions.call(this, silent);
+        triggerUpdatedEvent.call(this, silent);
+      }
+    };
+    ECharts2.prototype.setTheme = function() {
+      log.deprecateLog("ECharts#setTheme() is DEPRECATED in ECharts 3.0");
+    };
+    ECharts2.prototype.getModel = function() {
+      return this._model;
+    };
+    ECharts2.prototype.getOption = function() {
+      return this._model && this._model.getOption();
+    };
+    ECharts2.prototype.getWidth = function() {
+      return this._zr.getWidth();
+    };
+    ECharts2.prototype.getHeight = function() {
+      return this._zr.getHeight();
+    };
+    ECharts2.prototype.getDevicePixelRatio = function() {
+      return this._zr.painter.dpr || hasWindow && window.devicePixelRatio || 1;
+    };
+    ECharts2.prototype.getRenderedCanvas = function(opts) {
+      if (process.env.NODE_ENV !== "production") {
+        log.deprecateReplaceLog("getRenderedCanvas", "renderToCanvas");
+      }
+      return this.renderToCanvas(opts);
+    };
+    ECharts2.prototype.renderToCanvas = function(opts) {
+      opts = opts || {};
+      var painter = this._zr.painter;
+      if (process.env.NODE_ENV !== "production") {
+        if (painter.type !== "canvas") {
+          throw new Error("renderToCanvas can only be used in the canvas renderer.");
+        }
+      }
+      return painter.getRenderedCanvas({
+        backgroundColor: opts.backgroundColor || this._model.get("backgroundColor"),
+        pixelRatio: opts.pixelRatio || this.getDevicePixelRatio()
+      });
+    };
+    ECharts2.prototype.renderToSVGString = function(opts) {
+      opts = opts || {};
+      var painter = this._zr.painter;
+      if (process.env.NODE_ENV !== "production") {
+        if (painter.type !== "svg") {
+          throw new Error("renderToSVGString can only be used in the svg renderer.");
+        }
+      }
+      return painter.renderToString({
+        useViewBox: opts.useViewBox
+      });
+    };
+    ECharts2.prototype.getSvgDataURL = function() {
+      if (!env.default.svgSupported) {
+        return;
+      }
+      var zr = this._zr;
+      var list = zr.storage.getDisplayList();
+      util.each(list, function(el) {
+        el.stopAnimation(null, true);
+      });
+      return zr.painter.toDataURL();
+    };
+    ECharts2.prototype.getDataURL = function(opts) {
+      if (this._disposed) {
+        disposedWarning(this.id);
+        return;
+      }
+      opts = opts || {};
+      var excludeComponents = opts.excludeComponents;
+      var ecModel = this._model;
+      var excludesComponentViews = [];
+      var self = this;
+      util.each(excludeComponents, function(componentType) {
+        ecModel.eachComponent({
+          mainType: componentType
+        }, function(component) {
+          var view = self._componentsMap[component.__viewId];
+          if (!view.group.ignore) {
+            excludesComponentViews.push(view);
+            view.group.ignore = true;
+          }
+        });
+      });
+      var url = this._zr.painter.getType() === "svg" ? this.getSvgDataURL() : this.renderToCanvas(opts).toDataURL("image/" + (opts && opts.type || "png"));
+      util.each(excludesComponentViews, function(view) {
+        view.group.ignore = false;
+      });
+      return url;
+    };
+    ECharts2.prototype.getConnectedDataURL = function(opts) {
+      if (this._disposed) {
+        disposedWarning(this.id);
+        return;
+      }
+      var isSvg = opts.type === "svg";
+      var groupId = this.group;
+      var mathMin = Math.min;
+      var mathMax = Math.max;
+      var MAX_NUMBER = Infinity;
+      if (connectedGroups[groupId]) {
+        var left_1 = MAX_NUMBER;
+        var top_1 = MAX_NUMBER;
+        var right_1 = -MAX_NUMBER;
+        var bottom_1 = -MAX_NUMBER;
+        var canvasList_1 = [];
+        var dpr_1 = opts && opts.pixelRatio || this.getDevicePixelRatio();
+        util.each(instances, function(chart, id) {
+          if (chart.group === groupId) {
+            var canvas = isSvg ? chart.getZr().painter.getSvgDom().innerHTML : chart.renderToCanvas(util.clone(opts));
+            var boundingRect = chart.getDom().getBoundingClientRect();
+            left_1 = mathMin(boundingRect.left, left_1);
+            top_1 = mathMin(boundingRect.top, top_1);
+            right_1 = mathMax(boundingRect.right, right_1);
+            bottom_1 = mathMax(boundingRect.bottom, bottom_1);
+            canvasList_1.push({
+              dom: canvas,
+              left: boundingRect.left,
+              top: boundingRect.top
+            });
+          }
+        });
+        left_1 *= dpr_1;
+        top_1 *= dpr_1;
+        right_1 *= dpr_1;
+        bottom_1 *= dpr_1;
+        var width = right_1 - left_1;
+        var height = bottom_1 - top_1;
+        var targetCanvas = platform.platformApi.createCanvas();
+        var zr_1 = zrender.init(targetCanvas, {
+          renderer: isSvg ? "svg" : "canvas"
+        });
+        zr_1.resize({
+          width,
+          height
+        });
+        if (isSvg) {
+          var content_1 = "";
+          util.each(canvasList_1, function(item) {
+            var x = item.left - left_1;
+            var y = item.top - top_1;
+            content_1 += '<g transform="translate(' + x + "," + y + ')">' + item.dom + "</g>";
+          });
+          zr_1.painter.getSvgRoot().innerHTML = content_1;
+          if (opts.connectedBackgroundColor) {
+            zr_1.painter.setBackgroundColor(opts.connectedBackgroundColor);
+          }
+          zr_1.refreshImmediately();
+          return zr_1.painter.toDataURL();
+        } else {
+          if (opts.connectedBackgroundColor) {
+            zr_1.add(new Rect.default({
+              shape: {
+                x: 0,
+                y: 0,
+                width,
+                height
+              },
+              style: {
+                fill: opts.connectedBackgroundColor
+              }
+            }));
+          }
+          util.each(canvasList_1, function(item) {
+            var img = new Image.default({
+              style: {
+                x: item.left * dpr_1 - left_1,
+                y: item.top * dpr_1 - top_1,
+                image: item.dom
+              }
+            });
+            zr_1.add(img);
+          });
+          zr_1.refreshImmediately();
+          return targetCanvas.toDataURL("image/" + (opts && opts.type || "png"));
+        }
+      } else {
+        return this.getDataURL(opts);
+      }
+    };
+    ECharts2.prototype.convertToPixel = function(finder, value) {
+      return doConvertPixel(this, "convertToPixel", finder, value);
+    };
+    ECharts2.prototype.convertFromPixel = function(finder, value) {
+      return doConvertPixel(this, "convertFromPixel", finder, value);
+    };
+    ECharts2.prototype.containPixel = function(finder, value) {
+      if (this._disposed) {
+        disposedWarning(this.id);
+        return;
+      }
+      var ecModel = this._model;
+      var result;
+      var findResult = model.parseFinder(ecModel, finder);
+      util.each(findResult, function(models, key) {
+        key.indexOf("Models") >= 0 && util.each(models, function(model2) {
+          var coordSys = model2.coordinateSystem;
+          if (coordSys && coordSys.containPoint) {
+            result = result || !!coordSys.containPoint(value);
+          } else if (key === "seriesModels") {
+            var view = this._chartsMap[model2.__viewId];
+            if (view && view.containPoint) {
+              result = result || view.containPoint(value, model2);
+            } else {
+              if (process.env.NODE_ENV !== "production") {
+                console.warn(key + ": " + (view ? "The found component do not support containPoint." : "No view mapping to the found component."));
+              }
+            }
+          } else {
+            if (process.env.NODE_ENV !== "production") {
+              console.warn(key + ": containPoint is not supported");
+            }
+          }
+        }, this);
+      }, this);
+      return !!result;
+    };
+    ECharts2.prototype.getVisual = function(finder, visualType) {
+      var ecModel = this._model;
+      var parsedFinder = model.parseFinder(ecModel, finder, {
+        defaultMainType: "series"
+      });
+      var seriesModel = parsedFinder.seriesModel;
+      if (process.env.NODE_ENV !== "production") {
+        if (!seriesModel) {
+          console.warn("There is no specified seires model");
+        }
+      }
+      var data = seriesModel.getData();
+      var dataIndexInside = parsedFinder.hasOwnProperty("dataIndexInside") ? parsedFinder.dataIndexInside : parsedFinder.hasOwnProperty("dataIndex") ? data.indexOfRawIndex(parsedFinder.dataIndex) : null;
+      return dataIndexInside != null ? helper.getItemVisualFromData(data, dataIndexInside, visualType) : helper.getVisualFromData(data, visualType);
+    };
+    ECharts2.prototype.getViewOfComponentModel = function(componentModel) {
+      return this._componentsMap[componentModel.__viewId];
+    };
+    ECharts2.prototype.getViewOfSeriesModel = function(seriesModel) {
+      return this._chartsMap[seriesModel.__viewId];
+    };
+    ECharts2.prototype._initEvents = function() {
+      var _this = this;
+      util.each(MOUSE_EVENT_NAMES, function(eveName) {
+        var handler = function(e) {
+          var ecModel = _this.getModel();
+          var el = e.target;
+          var params;
+          var isGlobalOut = eveName === "globalout";
+          if (isGlobalOut) {
+            params = {};
+          } else {
+            el && event.findEventDispatcher(el, function(parent) {
+              var ecData = innerStore.getECData(parent);
+              if (ecData && ecData.dataIndex != null) {
+                var dataModel = ecData.dataModel || ecModel.getSeriesByIndex(ecData.seriesIndex);
+                params = dataModel && dataModel.getDataParams(ecData.dataIndex, ecData.dataType) || {};
+                return true;
+              } else if (ecData.eventData) {
+                params = util.extend({}, ecData.eventData);
+                return true;
+              }
+            }, true);
+          }
+          if (params) {
+            var componentType = params.componentType;
+            var componentIndex = params.componentIndex;
+            if (componentType === "markLine" || componentType === "markPoint" || componentType === "markArea") {
+              componentType = "series";
+              componentIndex = params.seriesIndex;
+            }
+            var model2 = componentType && componentIndex != null && ecModel.getComponent(componentType, componentIndex);
+            var view = model2 && _this[model2.mainType === "series" ? "_chartsMap" : "_componentsMap"][model2.__viewId];
+            if (process.env.NODE_ENV !== "production") {
+              if (!isGlobalOut && !(model2 && view)) {
+                console.warn("model or view can not be found by params");
+              }
+            }
+            params.event = e;
+            params.type = eveName;
+            _this._$eventProcessor.eventInfo = {
+              targetEl: el,
+              packedEvent: params,
+              model: model2,
+              view
+            };
+            _this.trigger(eveName, params);
+          }
+        };
+        handler.zrEventfulCallAtLast = true;
+        _this._zr.on(eveName, handler, _this);
+      });
+      util.each(eventActionMap, function(actionType, eventType) {
+        _this._messageCenter.on(eventType, function(event2) {
+          this.trigger(eventType, event2);
+        }, _this);
+      });
+      util.each(["selectchanged"], function(eventType) {
+        _this._messageCenter.on(eventType, function(event2) {
+          this.trigger(eventType, event2);
+        }, _this);
+      });
+      dataSelectAction.handleLegacySelectEvents(this._messageCenter, this, this._api);
+    };
+    ECharts2.prototype.isDisposed = function() {
+      return this._disposed;
+    };
+    ECharts2.prototype.clear = function() {
+      if (this._disposed) {
+        disposedWarning(this.id);
+        return;
+      }
+      this.setOption({
+        series: []
+      }, true);
+    };
+    ECharts2.prototype.dispose = function() {
+      if (this._disposed) {
+        disposedWarning(this.id);
+        return;
+      }
+      this._disposed = true;
+      var dom = this.getDom();
+      if (dom) {
+        model.setAttribute(this.getDom(), DOM_ATTRIBUTE_KEY, "");
+      }
+      var chart = this;
+      var api = chart._api;
+      var ecModel = chart._model;
+      util.each(chart._componentsViews, function(component) {
+        component.dispose(ecModel, api);
+      });
+      util.each(chart._chartsViews, function(chart2) {
+        chart2.dispose(ecModel, api);
+      });
+      chart._zr.dispose();
+      chart._dom = chart._model = chart._chartsMap = chart._componentsMap = chart._chartsViews = chart._componentsViews = chart._scheduler = chart._api = chart._zr = chart._throttledZrFlush = chart._theme = chart._coordSysMgr = chart._messageCenter = null;
+      delete instances[chart.id];
+    };
+    ECharts2.prototype.resize = function(opts) {
+      if (this[IN_MAIN_PROCESS_KEY]) {
+        if (process.env.NODE_ENV !== "production") {
+          log.error("`resize` should not be called during main process.");
+        }
+        return;
+      }
+      if (this._disposed) {
+        disposedWarning(this.id);
+        return;
+      }
+      this._zr.resize(opts);
+      var ecModel = this._model;
+      this._loadingFX && this._loadingFX.resize();
+      if (!ecModel) {
+        return;
+      }
+      var needPrepare = ecModel.resetOption("media");
+      var silent = opts && opts.silent;
+      if (this[PENDING_UPDATE]) {
+        if (silent == null) {
+          silent = this[PENDING_UPDATE].silent;
+        }
+        needPrepare = true;
+        this[PENDING_UPDATE] = null;
+      }
+      this[IN_MAIN_PROCESS_KEY] = true;
+      try {
+        needPrepare && prepare(this);
+        updateMethods.update.call(this, {
+          type: "resize",
+          animation: util.extend({
+            // Disable animation
+            duration: 0
+          }, opts && opts.animation)
+        });
+      } catch (e) {
+        this[IN_MAIN_PROCESS_KEY] = false;
+        throw e;
+      }
+      this[IN_MAIN_PROCESS_KEY] = false;
+      flushPendingActions.call(this, silent);
+      triggerUpdatedEvent.call(this, silent);
+    };
+    ECharts2.prototype.showLoading = function(name, cfg) {
+      if (this._disposed) {
+        disposedWarning(this.id);
+        return;
+      }
+      if (util.isObject(name)) {
+        cfg = name;
+        name = "";
+      }
+      name = name || "default";
+      this.hideLoading();
+      if (!loadingEffects[name]) {
+        if (process.env.NODE_ENV !== "production") {
+          console.warn("Loading effects " + name + " not exists.");
+        }
+        return;
+      }
+      var el = loadingEffects[name](this._api, cfg);
+      var zr = this._zr;
+      this._loadingFX = el;
+      zr.add(el);
+    };
+    ECharts2.prototype.hideLoading = function() {
+      if (this._disposed) {
+        disposedWarning(this.id);
+        return;
+      }
+      this._loadingFX && this._zr.remove(this._loadingFX);
+      this._loadingFX = null;
+    };
+    ECharts2.prototype.makeActionFromEvent = function(eventObj) {
+      var payload = util.extend({}, eventObj);
+      payload.type = eventActionMap[eventObj.type];
+      return payload;
+    };
+    ECharts2.prototype.dispatchAction = function(payload, opt) {
+      if (this._disposed) {
+        disposedWarning(this.id);
+        return;
+      }
+      if (!util.isObject(opt)) {
+        opt = {
+          silent: !!opt
+        };
+      }
+      if (!actions[payload.type]) {
+        return;
+      }
+      if (!this._model) {
+        return;
+      }
+      if (this[IN_MAIN_PROCESS_KEY]) {
+        this._pendingActions.push(payload);
+        return;
+      }
+      var silent = opt.silent;
+      doDispatchAction.call(this, payload, silent);
+      var flush = opt.flush;
+      if (flush) {
+        this._zr.flush();
+      } else if (flush !== false && env.default.browser.weChat) {
+        this._throttledZrFlush();
+      }
+      flushPendingActions.call(this, silent);
+      triggerUpdatedEvent.call(this, silent);
+    };
+    ECharts2.prototype.updateLabelLayout = function() {
+      lifecycle.default.trigger("series:layoutlabels", this._model, this._api, {
+        // Not adding series labels.
+        // TODO
+        updatedSeries: []
+      });
+    };
+    ECharts2.prototype.appendData = function(params) {
+      if (this._disposed) {
+        disposedWarning(this.id);
+        return;
+      }
+      var seriesIndex = params.seriesIndex;
+      var ecModel = this.getModel();
+      var seriesModel = ecModel.getSeriesByIndex(seriesIndex);
+      if (process.env.NODE_ENV !== "production") {
+        util.assert(params.data && seriesModel);
+      }
+      seriesModel.appendData(params);
+      this._scheduler.unfinished = true;
+      this.getZr().wakeUp();
+    };
+    ECharts2.internalField = function() {
+      prepare = function(ecIns) {
+        var scheduler = ecIns._scheduler;
+        scheduler.restorePipelines(ecIns._model);
+        scheduler.prepareStageTasks();
+        prepareView(ecIns, true);
+        prepareView(ecIns, false);
+        scheduler.plan();
+      };
+      prepareView = function(ecIns, isComponent) {
+        var ecModel = ecIns._model;
+        var scheduler = ecIns._scheduler;
+        var viewList = isComponent ? ecIns._componentsViews : ecIns._chartsViews;
+        var viewMap = isComponent ? ecIns._componentsMap : ecIns._chartsMap;
+        var zr = ecIns._zr;
+        var api = ecIns._api;
+        for (var i = 0; i < viewList.length; i++) {
+          viewList[i].__alive = false;
+        }
+        isComponent ? ecModel.eachComponent(function(componentType, model2) {
+          componentType !== "series" && doPrepare(model2);
+        }) : ecModel.eachSeries(doPrepare);
+        function doPrepare(model2) {
+          var requireNewView = model2.__requireNewView;
+          model2.__requireNewView = false;
+          var viewId = "_ec_" + model2.id + "_" + model2.type;
+          var view2 = !requireNewView && viewMap[viewId];
+          if (!view2) {
+            var classType = clazz.parseClassType(model2.type);
+            var Clazz = isComponent ? Component.default.getClass(classType.main, classType.sub) : (
+              // FIXME:TS
+              // (ChartView as ChartViewConstructor).getClass('series', classType.sub)
+              // For backward compat, still support a chart type declared as only subType
+              // like "liquidfill", but recommend "series.liquidfill"
+              // But need a base class to make a type series.
+              Chart.default.getClass(classType.sub)
+            );
+            if (process.env.NODE_ENV !== "production") {
+              util.assert(Clazz, classType.sub + " does not exist.");
+            }
+            view2 = new Clazz();
+            view2.init(ecModel, api);
+            viewMap[viewId] = view2;
+            viewList.push(view2);
+            zr.add(view2.group);
+          }
+          model2.__viewId = view2.__id = viewId;
+          view2.__alive = true;
+          view2.__model = model2;
+          view2.group.__ecComponentInfo = {
+            mainType: model2.mainType,
+            index: model2.componentIndex
+          };
+          !isComponent && scheduler.prepareView(view2, model2, ecModel, api);
+        }
+        for (var i = 0; i < viewList.length; ) {
+          var view = viewList[i];
+          if (!view.__alive) {
+            !isComponent && view.renderTask.dispose();
+            zr.remove(view.group);
+            view.dispose(ecModel, api);
+            viewList.splice(i, 1);
+            if (viewMap[view.__id] === view) {
+              delete viewMap[view.__id];
+            }
+            view.__id = view.group.__ecComponentInfo = null;
+          } else {
+            i++;
+          }
+        }
+      };
+      updateDirectly = function(ecIns, method, payload, mainType, subType) {
+        var ecModel = ecIns._model;
+        ecModel.setUpdatePayload(payload);
+        if (!mainType) {
+          util.each([].concat(ecIns._componentsViews).concat(ecIns._chartsViews), callView);
+          return;
+        }
+        var query = {};
+        query[mainType + "Id"] = payload[mainType + "Id"];
+        query[mainType + "Index"] = payload[mainType + "Index"];
+        query[mainType + "Name"] = payload[mainType + "Name"];
+        var condition = {
+          mainType,
+          query
+        };
+        subType && (condition.subType = subType);
+        var excludeSeriesId = payload.excludeSeriesId;
+        var excludeSeriesIdMap;
+        if (excludeSeriesId != null) {
+          excludeSeriesIdMap = util.createHashMap();
+          util.each(model.normalizeToArray(excludeSeriesId), function(id) {
+            var modelId = model.convertOptionIdName(id, null);
+            if (modelId != null) {
+              excludeSeriesIdMap.set(modelId, true);
+            }
+          });
+        }
+        ecModel && ecModel.eachComponent(condition, function(model2) {
+          var isExcluded = excludeSeriesIdMap && excludeSeriesIdMap.get(model2.id) !== null;
+          if (isExcluded) {
+            return;
+          }
+          if (states.isHighDownPayload(payload)) {
+            if (model2 instanceof Series.default) {
+              if (payload.type === states.HIGHLIGHT_ACTION_TYPE && !payload.notBlur && !model2.get(["emphasis", "disabled"])) {
+                states.blurSeriesFromHighlightPayload(model2, payload, ecIns._api);
+              }
+            } else {
+              var _a = states.findComponentHighDownDispatchers(model2.mainType, model2.componentIndex, payload.name, ecIns._api), focusSelf = _a.focusSelf, dispatchers = _a.dispatchers;
+              if (payload.type === states.HIGHLIGHT_ACTION_TYPE && focusSelf && !payload.notBlur) {
+                states.blurComponent(model2.mainType, model2.componentIndex, ecIns._api);
+              }
+              if (dispatchers) {
+                util.each(dispatchers, function(dispatcher) {
+                  payload.type === states.HIGHLIGHT_ACTION_TYPE ? states.enterEmphasis(dispatcher) : states.leaveEmphasis(dispatcher);
+                });
+              }
+            }
+          } else if (states.isSelectChangePayload(payload)) {
+            if (model2 instanceof Series.default) {
+              states.toggleSelectionFromPayload(model2, payload, ecIns._api);
+              states.updateSeriesElementSelection(model2);
+              markStatusToUpdate(ecIns);
+            }
+          }
+        }, ecIns);
+        ecModel && ecModel.eachComponent(condition, function(model2) {
+          var isExcluded = excludeSeriesIdMap && excludeSeriesIdMap.get(model2.id) !== null;
+          if (isExcluded) {
+            return;
+          }
+          callView(ecIns[mainType === "series" ? "_chartsMap" : "_componentsMap"][model2.__viewId]);
+        }, ecIns);
+        function callView(view) {
+          view && view.__alive && view[method] && view[method](view.__model, ecModel, ecIns._api, payload);
+        }
+      };
+      updateMethods = {
+        prepareAndUpdate: function(payload) {
+          prepare(this);
+          updateMethods.update.call(this, payload, {
+            // Needs to mark option changed if newOption is given.
+            // It's from MagicType.
+            // TODO If use a separate flag optionChanged in payload?
+            optionChanged: payload.newOption != null
+          });
+        },
+        update: function(payload, updateParams) {
+          var ecModel = this._model;
+          var api = this._api;
+          var zr = this._zr;
+          var coordSysMgr = this._coordSysMgr;
+          var scheduler = this._scheduler;
+          if (!ecModel) {
+            return;
+          }
+          ecModel.setUpdatePayload(payload);
+          scheduler.restoreData(ecModel, payload);
+          scheduler.performSeriesTasks(ecModel);
+          coordSysMgr.create(ecModel, api);
+          scheduler.performDataProcessorTasks(ecModel, payload);
+          updateStreamModes(this, ecModel);
+          coordSysMgr.update(ecModel, api);
+          clearColorPalette(ecModel);
+          scheduler.performVisualTasks(ecModel, payload);
+          render(this, ecModel, api, payload, updateParams);
+          var backgroundColor = ecModel.get("backgroundColor") || "transparent";
+          var darkMode = ecModel.get("darkMode");
+          zr.setBackgroundColor(backgroundColor);
+          if (darkMode != null && darkMode !== "auto") {
+            zr.setDarkMode(darkMode);
+          }
+          lifecycle.default.trigger("afterupdate", ecModel, api);
+        },
+        updateTransform: function(payload) {
+          var _this = this;
+          var ecModel = this._model;
+          var api = this._api;
+          if (!ecModel) {
+            return;
+          }
+          ecModel.setUpdatePayload(payload);
+          var componentDirtyList = [];
+          ecModel.eachComponent(function(componentType, componentModel) {
+            if (componentType === "series") {
+              return;
+            }
+            var componentView = _this.getViewOfComponentModel(componentModel);
+            if (componentView && componentView.__alive) {
+              if (componentView.updateTransform) {
+                var result = componentView.updateTransform(componentModel, ecModel, api, payload);
+                result && result.update && componentDirtyList.push(componentView);
+              } else {
+                componentDirtyList.push(componentView);
+              }
+            }
+          });
+          var seriesDirtyMap = util.createHashMap();
+          ecModel.eachSeries(function(seriesModel) {
+            var chartView = _this._chartsMap[seriesModel.__viewId];
+            if (chartView.updateTransform) {
+              var result = chartView.updateTransform(seriesModel, ecModel, api, payload);
+              result && result.update && seriesDirtyMap.set(seriesModel.uid, 1);
+            } else {
+              seriesDirtyMap.set(seriesModel.uid, 1);
+            }
+          });
+          clearColorPalette(ecModel);
+          this._scheduler.performVisualTasks(ecModel, payload, {
+            setDirty: true,
+            dirtyMap: seriesDirtyMap
+          });
+          renderSeries(this, ecModel, api, payload, {}, seriesDirtyMap);
+          lifecycle.default.trigger("afterupdate", ecModel, api);
+        },
+        updateView: function(payload) {
+          var ecModel = this._model;
+          if (!ecModel) {
+            return;
+          }
+          ecModel.setUpdatePayload(payload);
+          Chart.default.markUpdateMethod(payload, "updateView");
+          clearColorPalette(ecModel);
+          this._scheduler.performVisualTasks(ecModel, payload, {
+            setDirty: true
+          });
+          render(this, ecModel, this._api, payload, {});
+          lifecycle.default.trigger("afterupdate", ecModel, this._api);
+        },
+        updateVisual: function(payload) {
+          var _this = this;
+          var ecModel = this._model;
+          if (!ecModel) {
+            return;
+          }
+          ecModel.setUpdatePayload(payload);
+          ecModel.eachSeries(function(seriesModel) {
+            seriesModel.getData().clearAllVisual();
+          });
+          Chart.default.markUpdateMethod(payload, "updateVisual");
+          clearColorPalette(ecModel);
+          this._scheduler.performVisualTasks(ecModel, payload, {
+            visualType: "visual",
+            setDirty: true
+          });
+          ecModel.eachComponent(function(componentType, componentModel) {
+            if (componentType !== "series") {
+              var componentView = _this.getViewOfComponentModel(componentModel);
+              componentView && componentView.__alive && componentView.updateVisual(componentModel, ecModel, _this._api, payload);
+            }
+          });
+          ecModel.eachSeries(function(seriesModel) {
+            var chartView = _this._chartsMap[seriesModel.__viewId];
+            chartView.updateVisual(seriesModel, ecModel, _this._api, payload);
+          });
+          lifecycle.default.trigger("afterupdate", ecModel, this._api);
+        },
+        updateLayout: function(payload) {
+          updateMethods.update.call(this, payload);
+        }
+      };
+      doConvertPixel = function(ecIns, methodName, finder, value) {
+        if (ecIns._disposed) {
+          disposedWarning(ecIns.id);
+          return;
+        }
+        var ecModel = ecIns._model;
+        var coordSysList = ecIns._coordSysMgr.getCoordinateSystems();
+        var result;
+        var parsedFinder = model.parseFinder(ecModel, finder);
+        for (var i = 0; i < coordSysList.length; i++) {
+          var coordSys = coordSysList[i];
+          if (coordSys[methodName] && (result = coordSys[methodName](ecModel, parsedFinder, value)) != null) {
+            return result;
+          }
+        }
+        if (process.env.NODE_ENV !== "production") {
+          console.warn("No coordinate system that supports " + methodName + " found by the given finder.");
+        }
+      };
+      updateStreamModes = function(ecIns, ecModel) {
+        var chartsMap = ecIns._chartsMap;
+        var scheduler = ecIns._scheduler;
+        ecModel.eachSeries(function(seriesModel) {
+          scheduler.updateStreamModes(seriesModel, chartsMap[seriesModel.__viewId]);
+        });
+      };
+      doDispatchAction = function(payload, silent) {
+        var _this = this;
+        var ecModel = this.getModel();
+        var payloadType = payload.type;
+        var escapeConnect = payload.escapeConnect;
+        var actionWrap = actions[payloadType];
+        var actionInfo = actionWrap.actionInfo;
+        var cptTypeTmp = (actionInfo.update || "update").split(":");
+        var updateMethod = cptTypeTmp.pop();
+        var cptType = cptTypeTmp[0] != null && clazz.parseClassType(cptTypeTmp[0]);
+        this[IN_MAIN_PROCESS_KEY] = true;
+        var payloads = [payload];
+        var batched = false;
+        if (payload.batch) {
+          batched = true;
+          payloads = util.map(payload.batch, function(item) {
+            item = util.defaults(util.extend({}, item), payload);
+            item.batch = null;
+            return item;
+          });
+        }
+        var eventObjBatch = [];
+        var eventObj;
+        var isSelectChange = states.isSelectChangePayload(payload);
+        var isHighDown = states.isHighDownPayload(payload);
+        if (isHighDown) {
+          states.allLeaveBlur(this._api);
+        }
+        util.each(payloads, function(batchItem) {
+          eventObj = actionWrap.action(batchItem, _this._model, _this._api);
+          eventObj = eventObj || util.extend({}, batchItem);
+          eventObj.type = actionInfo.event || eventObj.type;
+          eventObjBatch.push(eventObj);
+          if (isHighDown) {
+            var _a = model.preParseFinder(payload), queryOptionMap = _a.queryOptionMap, mainTypeSpecified = _a.mainTypeSpecified;
+            var componentMainType = mainTypeSpecified ? queryOptionMap.keys()[0] : "series";
+            updateDirectly(_this, updateMethod, batchItem, componentMainType);
+            markStatusToUpdate(_this);
+          } else if (isSelectChange) {
+            updateDirectly(_this, updateMethod, batchItem, "series");
+            markStatusToUpdate(_this);
+          } else if (cptType) {
+            updateDirectly(_this, updateMethod, batchItem, cptType.main, cptType.sub);
+          }
+        });
+        if (updateMethod !== "none" && !isHighDown && !isSelectChange && !cptType) {
+          try {
+            if (this[PENDING_UPDATE]) {
+              prepare(this);
+              updateMethods.update.call(this, payload);
+              this[PENDING_UPDATE] = null;
+            } else {
+              updateMethods[updateMethod].call(this, payload);
+            }
+          } catch (e) {
+            this[IN_MAIN_PROCESS_KEY] = false;
+            throw e;
+          }
+        }
+        if (batched) {
+          eventObj = {
+            type: actionInfo.event || payloadType,
+            escapeConnect,
+            batch: eventObjBatch
+          };
+        } else {
+          eventObj = eventObjBatch[0];
+        }
+        this[IN_MAIN_PROCESS_KEY] = false;
+        if (!silent) {
+          var messageCenter = this._messageCenter;
+          messageCenter.trigger(eventObj.type, eventObj);
+          if (isSelectChange) {
+            var newObj = {
+              type: "selectchanged",
+              escapeConnect,
+              selected: states.getAllSelectedIndices(ecModel),
+              isFromClick: payload.isFromClick || false,
+              fromAction: payload.type,
+              fromActionPayload: payload
+            };
+            messageCenter.trigger(newObj.type, newObj);
+          }
+        }
+      };
+      flushPendingActions = function(silent) {
+        var pendingActions = this._pendingActions;
+        while (pendingActions.length) {
+          var payload = pendingActions.shift();
+          doDispatchAction.call(this, payload, silent);
+        }
+      };
+      triggerUpdatedEvent = function(silent) {
+        !silent && this.trigger("updated");
+      };
+      bindRenderedEvent = function(zr, ecIns) {
+        zr.on("rendered", function(params) {
+          ecIns.trigger("rendered", params);
+          if (// Although zr is dirty if initial animation is not finished
+          // and this checking is called on frame, we also check
+          // animation finished for robustness.
+          zr.animation.isFinished() && !ecIns[PENDING_UPDATE] && !ecIns._scheduler.unfinished && !ecIns._pendingActions.length) {
+            ecIns.trigger("finished");
+          }
+        });
+      };
+      bindMouseEvent = function(zr, ecIns) {
+        zr.on("mouseover", function(e) {
+          var el = e.target;
+          var dispatcher = event.findEventDispatcher(el, states.isHighDownDispatcher);
+          if (dispatcher) {
+            states.handleGlobalMouseOverForHighDown(dispatcher, e, ecIns._api);
+            markStatusToUpdate(ecIns);
+          }
+        }).on("mouseout", function(e) {
+          var el = e.target;
+          var dispatcher = event.findEventDispatcher(el, states.isHighDownDispatcher);
+          if (dispatcher) {
+            states.handleGlobalMouseOutForHighDown(dispatcher, e, ecIns._api);
+            markStatusToUpdate(ecIns);
+          }
+        }).on("click", function(e) {
+          var el = e.target;
+          var dispatcher = event.findEventDispatcher(el, function(target) {
+            return innerStore.getECData(target).dataIndex != null;
+          }, true);
+          if (dispatcher) {
+            var actionType = dispatcher.selected ? "unselect" : "select";
+            var ecData = innerStore.getECData(dispatcher);
+            ecIns._api.dispatchAction({
+              type: actionType,
+              dataType: ecData.dataType,
+              dataIndexInside: ecData.dataIndex,
+              seriesIndex: ecData.seriesIndex,
+              isFromClick: true
+            });
+          }
+        });
+      };
+      function clearColorPalette(ecModel) {
+        ecModel.clearColorPalette();
+        ecModel.eachSeries(function(seriesModel) {
+          seriesModel.clearColorPalette();
+        });
+      }
+      function allocateZlevels(ecModel) {
+        var componentZLevels = [];
+        var seriesZLevels = [];
+        var hasSeperateZLevel = false;
+        ecModel.eachComponent(function(componentType, componentModel) {
+          var zlevel = componentModel.get("zlevel") || 0;
+          var z = componentModel.get("z") || 0;
+          var zlevelKey = componentModel.getZLevelKey();
+          hasSeperateZLevel = hasSeperateZLevel || !!zlevelKey;
+          (componentType === "series" ? seriesZLevels : componentZLevels).push({
+            zlevel,
+            z,
+            idx: componentModel.componentIndex,
+            type: componentType,
+            key: zlevelKey
+          });
+        });
+        if (hasSeperateZLevel) {
+          var zLevels = componentZLevels.concat(seriesZLevels);
+          var lastSeriesZLevel_1;
+          var lastSeriesKey_1;
+          timsort.default(zLevels, function(a, b) {
+            if (a.zlevel === b.zlevel) {
+              return a.z - b.z;
+            }
+            return a.zlevel - b.zlevel;
+          });
+          util.each(zLevels, function(item) {
+            var componentModel = ecModel.getComponent(item.type, item.idx);
+            var zlevel = item.zlevel;
+            var key = item.key;
+            if (lastSeriesZLevel_1 != null) {
+              zlevel = Math.max(lastSeriesZLevel_1, zlevel);
+            }
+            if (key) {
+              if (zlevel === lastSeriesZLevel_1 && key !== lastSeriesKey_1) {
+                zlevel++;
+              }
+              lastSeriesKey_1 = key;
+            } else if (lastSeriesKey_1) {
+              if (zlevel === lastSeriesZLevel_1) {
+                zlevel++;
+              }
+              lastSeriesKey_1 = "";
+            }
+            lastSeriesZLevel_1 = zlevel;
+            componentModel.setZLevel(zlevel);
+          });
+        }
+      }
+      render = function(ecIns, ecModel, api, payload, updateParams) {
+        allocateZlevels(ecModel);
+        renderComponents(ecIns, ecModel, api, payload, updateParams);
+        util.each(ecIns._chartsViews, function(chart) {
+          chart.__alive = false;
+        });
+        renderSeries(ecIns, ecModel, api, payload, updateParams);
+        util.each(ecIns._chartsViews, function(chart) {
+          if (!chart.__alive) {
+            chart.remove(ecModel, api);
+          }
+        });
+      };
+      renderComponents = function(ecIns, ecModel, api, payload, updateParams, dirtyList) {
+        util.each(dirtyList || ecIns._componentsViews, function(componentView) {
+          var componentModel = componentView.__model;
+          clearStates(componentModel, componentView);
+          componentView.render(componentModel, ecModel, api, payload);
+          updateZ(componentModel, componentView);
+          updateStates(componentModel, componentView);
+        });
+      };
+      renderSeries = function(ecIns, ecModel, api, payload, updateParams, dirtyMap) {
+        var scheduler = ecIns._scheduler;
+        updateParams = util.extend(updateParams || {}, {
+          updatedSeries: ecModel.getSeries()
+        });
+        lifecycle.default.trigger("series:beforeupdate", ecModel, api, updateParams);
+        var unfinished = false;
+        ecModel.eachSeries(function(seriesModel) {
+          var chartView = ecIns._chartsMap[seriesModel.__viewId];
+          chartView.__alive = true;
+          var renderTask = chartView.renderTask;
+          scheduler.updatePayload(renderTask, payload);
+          clearStates(seriesModel, chartView);
+          if (dirtyMap && dirtyMap.get(seriesModel.uid)) {
+            renderTask.dirty();
+          }
+          if (renderTask.perform(scheduler.getPerformArgs(renderTask))) {
+            unfinished = true;
+          }
+          chartView.group.silent = !!seriesModel.get("silent");
+          updateBlend(seriesModel, chartView);
+          states.updateSeriesElementSelection(seriesModel);
+        });
+        scheduler.unfinished = unfinished || scheduler.unfinished;
+        lifecycle.default.trigger("series:layoutlabels", ecModel, api, updateParams);
+        lifecycle.default.trigger("series:transition", ecModel, api, updateParams);
+        ecModel.eachSeries(function(seriesModel) {
+          var chartView = ecIns._chartsMap[seriesModel.__viewId];
+          updateZ(seriesModel, chartView);
+          updateStates(seriesModel, chartView);
+        });
+        updateHoverLayerStatus(ecIns, ecModel);
+        lifecycle.default.trigger("series:afterupdate", ecModel, api, updateParams);
+      };
+      markStatusToUpdate = function(ecIns) {
+        ecIns[STATUS_NEEDS_UPDATE_KEY] = true;
+        ecIns.getZr().wakeUp();
+      };
+      applyChangedStates = function(ecIns) {
+        if (!ecIns[STATUS_NEEDS_UPDATE_KEY]) {
+          return;
+        }
+        ecIns.getZr().storage.traverse(function(el) {
+          if (basicTrasition.isElementRemoved(el)) {
+            return;
+          }
+          applyElementStates(el);
+        });
+        ecIns[STATUS_NEEDS_UPDATE_KEY] = false;
+      };
+      function applyElementStates(el) {
+        var newStates = [];
+        var oldStates = el.currentStates;
+        for (var i = 0; i < oldStates.length; i++) {
+          var stateName = oldStates[i];
+          if (!(stateName === "emphasis" || stateName === "blur" || stateName === "select")) {
+            newStates.push(stateName);
+          }
+        }
+        if (el.selected && el.states.select) {
+          newStates.push("select");
+        }
+        if (el.hoverState === states.HOVER_STATE_EMPHASIS && el.states.emphasis) {
+          newStates.push("emphasis");
+        } else if (el.hoverState === states.HOVER_STATE_BLUR && el.states.blur) {
+          newStates.push("blur");
+        }
+        el.useStates(newStates);
+      }
+      function updateHoverLayerStatus(ecIns, ecModel) {
+        var zr = ecIns._zr;
+        var storage = zr.storage;
+        var elCount = 0;
+        storage.traverse(function(el) {
+          if (!el.isGroup) {
+            elCount++;
+          }
+        });
+        if (elCount > ecModel.get("hoverLayerThreshold") && !env.default.node && !env.default.worker) {
+          ecModel.eachSeries(function(seriesModel) {
+            if (seriesModel.preventUsingHoverLayer) {
+              return;
+            }
+            var chartView = ecIns._chartsMap[seriesModel.__viewId];
+            if (chartView.__alive) {
+              chartView.eachRendered(function(el) {
+                if (el.states.emphasis) {
+                  el.states.emphasis.hoverLayer = true;
+                }
+              });
+            }
+          });
+        }
+      }
+      function updateBlend(seriesModel, chartView) {
+        var blendMode = seriesModel.get("blendMode") || null;
+        chartView.eachRendered(function(el) {
+          if (!el.isGroup) {
+            el.style.blend = blendMode;
+          }
+        });
+      }
+      function updateZ(model2, view) {
+        if (model2.preventAutoZ) {
+          return;
+        }
+        var z = model2.get("z") || 0;
+        var zlevel = model2.get("zlevel") || 0;
+        view.eachRendered(function(el) {
+          doUpdateZ(el, z, zlevel, -Infinity);
+          return true;
+        });
+      }
+      function doUpdateZ(el, z, zlevel, maxZ2) {
+        var label = el.getTextContent();
+        var labelLine = el.getTextGuideLine();
+        var isGroup = el.isGroup;
+        if (isGroup) {
+          var children = el.childrenRef();
+          for (var i = 0; i < children.length; i++) {
+            maxZ2 = Math.max(doUpdateZ(children[i], z, zlevel, maxZ2), maxZ2);
+          }
+        } else {
+          el.z = z;
+          el.zlevel = zlevel;
+          maxZ2 = Math.max(el.z2, maxZ2);
+        }
+        if (label) {
+          label.z = z;
+          label.zlevel = zlevel;
+          isFinite(maxZ2) && (label.z2 = maxZ2 + 2);
+        }
+        if (labelLine) {
+          var textGuideLineConfig = el.textGuideLineConfig;
+          labelLine.z = z;
+          labelLine.zlevel = zlevel;
+          isFinite(maxZ2) && (labelLine.z2 = maxZ2 + (textGuideLineConfig && textGuideLineConfig.showAbove ? 1 : -1));
+        }
+        return maxZ2;
+      }
+      function clearStates(model2, view) {
+        view.eachRendered(function(el) {
+          if (basicTrasition.isElementRemoved(el)) {
+            return;
+          }
+          var textContent = el.getTextContent();
+          var textGuide = el.getTextGuideLine();
+          if (el.stateTransition) {
+            el.stateTransition = null;
+          }
+          if (textContent && textContent.stateTransition) {
+            textContent.stateTransition = null;
+          }
+          if (textGuide && textGuide.stateTransition) {
+            textGuide.stateTransition = null;
+          }
+          if (el.hasState()) {
+            el.prevStates = el.currentStates;
+            el.clearStates();
+          } else if (el.prevStates) {
+            el.prevStates = null;
+          }
+        });
+      }
+      function updateStates(model2, view) {
+        var stateAnimationModel = model2.getModel("stateAnimation");
+        var enableAnimation = model2.isAnimationEnabled();
+        var duration = stateAnimationModel.get("duration");
+        var stateTransition = duration > 0 ? {
+          duration,
+          delay: stateAnimationModel.get("delay"),
+          easing: stateAnimationModel.get("easing")
+          // additive: stateAnimationModel.get('additive')
+        } : null;
+        view.eachRendered(function(el) {
+          if (el.states && el.states.emphasis) {
+            if (basicTrasition.isElementRemoved(el)) {
+              return;
+            }
+            if (el instanceof Path.default) {
+              states.savePathStates(el);
+            }
+            if (el.__dirty) {
+              var prevStates = el.prevStates;
+              if (prevStates) {
+                el.useStates(prevStates);
+              }
+            }
+            if (enableAnimation) {
+              el.stateTransition = stateTransition;
+              var textContent = el.getTextContent();
+              var textGuide = el.getTextGuideLine();
+              if (textContent) {
+                textContent.stateTransition = stateTransition;
+              }
+              if (textGuide) {
+                textGuide.stateTransition = stateTransition;
+              }
+            }
+            if (el.__dirty) {
+              applyElementStates(el);
+            }
+          }
+        });
+      }
+      createExtensionAPI = function(ecIns) {
+        return new /** @class */
+        (function(_super2) {
+          tslib_es6.__extends(class_1, _super2);
+          function class_1() {
+            return _super2 !== null && _super2.apply(this, arguments) || this;
+          }
+          class_1.prototype.getCoordinateSystems = function() {
+            return ecIns._coordSysMgr.getCoordinateSystems();
+          };
+          class_1.prototype.getComponentByElement = function(el) {
+            while (el) {
+              var modelInfo = el.__ecComponentInfo;
+              if (modelInfo != null) {
+                return ecIns._model.getComponent(modelInfo.mainType, modelInfo.index);
+              }
+              el = el.parent;
+            }
+          };
+          class_1.prototype.enterEmphasis = function(el, highlightDigit) {
+            states.enterEmphasis(el, highlightDigit);
+            markStatusToUpdate(ecIns);
+          };
+          class_1.prototype.leaveEmphasis = function(el, highlightDigit) {
+            states.leaveEmphasis(el, highlightDigit);
+            markStatusToUpdate(ecIns);
+          };
+          class_1.prototype.enterBlur = function(el) {
+            states.enterBlur(el);
+            markStatusToUpdate(ecIns);
+          };
+          class_1.prototype.leaveBlur = function(el) {
+            states.leaveBlur(el);
+            markStatusToUpdate(ecIns);
+          };
+          class_1.prototype.enterSelect = function(el) {
+            states.enterSelect(el);
+            markStatusToUpdate(ecIns);
+          };
+          class_1.prototype.leaveSelect = function(el) {
+            states.leaveSelect(el);
+            markStatusToUpdate(ecIns);
+          };
+          class_1.prototype.getModel = function() {
+            return ecIns.getModel();
+          };
+          class_1.prototype.getViewOfComponentModel = function(componentModel) {
+            return ecIns.getViewOfComponentModel(componentModel);
+          };
+          class_1.prototype.getViewOfSeriesModel = function(seriesModel) {
+            return ecIns.getViewOfSeriesModel(seriesModel);
+          };
+          return class_1;
+        }(ExtensionAPI.default))(ecIns);
+      };
+      enableConnect = function(chart) {
+        function updateConnectedChartsStatus(charts, status) {
+          for (var i = 0; i < charts.length; i++) {
+            var otherChart = charts[i];
+            otherChart[CONNECT_STATUS_KEY] = status;
+          }
+        }
+        util.each(eventActionMap, function(actionType, eventType) {
+          chart._messageCenter.on(eventType, function(event2) {
+            if (connectedGroups[chart.group] && chart[CONNECT_STATUS_KEY] !== CONNECT_STATUS_PENDING) {
+              if (event2 && event2.escapeConnect) {
+                return;
+              }
+              var action_1 = chart.makeActionFromEvent(event2);
+              var otherCharts_1 = [];
+              util.each(instances, function(otherChart) {
+                if (otherChart !== chart && otherChart.group === chart.group) {
+                  otherCharts_1.push(otherChart);
+                }
+              });
+              updateConnectedChartsStatus(otherCharts_1, CONNECT_STATUS_PENDING);
+              util.each(otherCharts_1, function(otherChart) {
+                if (otherChart[CONNECT_STATUS_KEY] !== CONNECT_STATUS_UPDATING) {
+                  otherChart.dispatchAction(action_1);
+                }
+              });
+              updateConnectedChartsStatus(otherCharts_1, CONNECT_STATUS_UPDATED);
+            }
+          });
+        });
+      };
+    }();
+    return ECharts2;
+  }(Eventful.default)
+);
+var echartsProto = ECharts.prototype;
+echartsProto.on = createRegisterEventWithLowercaseECharts("on");
+echartsProto.off = createRegisterEventWithLowercaseECharts("off");
+echartsProto.one = function(eventName, cb, ctx) {
+  var self = this;
+  log.deprecateLog("ECharts#one is deprecated.");
+  function wrapped() {
+    var args2 = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+      args2[_i] = arguments[_i];
+    }
+    cb && cb.apply && cb.apply(this, args2);
+    self.off(eventName, wrapped);
+  }
+  this.on.call(this, eventName, wrapped, ctx);
+};
+var MOUSE_EVENT_NAMES = ["click", "dblclick", "mouseover", "mouseout", "mousemove", "mousedown", "mouseup", "globalout", "contextmenu"];
+function disposedWarning(id) {
+  if (process.env.NODE_ENV !== "production") {
+    console.warn("Instance " + id + " has been disposed");
+  }
+}
+var actions = {};
+var eventActionMap = {};
+var dataProcessorFuncs = [];
+var optionPreprocessorFuncs = [];
+var visualFuncs = [];
+var themeStorage = {};
+var loadingEffects = {};
+var instances = {};
+var connectedGroups = {};
+var idBase = +new Date() - 0;
+var DOM_ATTRIBUTE_KEY = "_echarts_instance_";
+function init(dom, theme, opts) {
+  var isClient = !(opts && opts.ssr);
+  if (isClient) {
+    if (process.env.NODE_ENV !== "production") {
+      if (!dom) {
+        throw new Error("Initialize failed: invalid dom.");
+      }
+    }
+    var existInstance = getInstanceByDom(dom);
+    if (existInstance) {
+      if (process.env.NODE_ENV !== "production") {
+        console.warn("There is a chart instance already initialized on the dom.");
+      }
+      return existInstance;
+    }
+    if (process.env.NODE_ENV !== "production") {
+      if (util.isDom(dom) && dom.nodeName.toUpperCase() !== "CANVAS" && (!dom.clientWidth && (!opts || opts.width == null) || !dom.clientHeight && (!opts || opts.height == null))) {
+        console.warn("Can't get DOM width or height. Please check dom.clientWidth and dom.clientHeight. They should not be 0.For example, you may need to call this in the callback of window.onload.");
+      }
+    }
+  }
+  var chart = new ECharts(dom, theme, opts);
+  chart.id = "ec_" + idBase++;
+  instances[chart.id] = chart;
+  isClient && model.setAttribute(dom, DOM_ATTRIBUTE_KEY, chart.id);
+  enableConnect(chart);
+  lifecycle.default.trigger("afterinit", chart);
+  return chart;
+}
+function getInstanceByDom(dom) {
+  return instances[model.getAttribute(dom, DOM_ATTRIBUTE_KEY)];
+}
+function registerTheme(name, theme) {
+  themeStorage[name] = theme;
+}
+function registerPreprocessor(preprocessorFunc) {
+  if (util.indexOf(optionPreprocessorFuncs, preprocessorFunc) < 0) {
+    optionPreprocessorFuncs.push(preprocessorFunc);
+  }
+}
+function registerProcessor(priority, processor) {
+  normalizeRegister(dataProcessorFuncs, priority, processor, PRIORITY_PROCESSOR_DEFAULT);
+}
+function registerPostInit(postInitFunc) {
+  registerUpdateLifecycle("afterinit", postInitFunc);
+}
+function registerPostUpdate(postUpdateFunc) {
+  registerUpdateLifecycle("afterupdate", postUpdateFunc);
+}
+function registerUpdateLifecycle(name, cb) {
+  lifecycle.default.on(name, cb);
+}
+function registerAction(actionInfo, eventName, action) {
+  if (util.isFunction(eventName)) {
+    action = eventName;
+    eventName = "";
+  }
+  var actionType = util.isObject(actionInfo) ? actionInfo.type : [actionInfo, actionInfo = {
+    event: eventName
+  }][0];
+  actionInfo.event = (actionInfo.event || actionType).toLowerCase();
+  eventName = actionInfo.event;
+  if (eventActionMap[eventName]) {
+    return;
+  }
+  util.assert(ACTION_REG.test(actionType) && ACTION_REG.test(eventName));
+  if (!actions[actionType]) {
+    actions[actionType] = {
+      action,
+      actionInfo
+    };
+  }
+  eventActionMap[eventName] = actionType;
+}
+function registerCoordinateSystem(type, coordSysCreator) {
+  CoordinateSystem.default.register(type, coordSysCreator);
+}
+function registerLayout(priority, layoutTask) {
+  normalizeRegister(visualFuncs, priority, layoutTask, PRIORITY_VISUAL_LAYOUT, "layout");
+}
+function registerVisual(priority, visualTask) {
+  normalizeRegister(visualFuncs, priority, visualTask, PRIORITY_VISUAL_CHART, "visual");
+}
+var registeredTasks = [];
+function normalizeRegister(targetList, priority, fn, defaultPriority, visualType) {
+  if (util.isFunction(priority) || util.isObject(priority)) {
+    fn = priority;
+    priority = defaultPriority;
+  }
+  if (process.env.NODE_ENV !== "production") {
+    if (isNaN(priority) || priority == null) {
+      throw new Error("Illegal priority");
+    }
+    util.each(targetList, function(wrap) {
+      util.assert(wrap.__raw !== fn);
+    });
+  }
+  if (util.indexOf(registeredTasks, fn) >= 0) {
+    return;
+  }
+  registeredTasks.push(fn);
+  var stageHandler = Scheduler.default.wrapStageHandler(fn, visualType);
+  stageHandler.__prio = priority;
+  stageHandler.__raw = fn;
+  targetList.push(stageHandler);
+}
+function registerLoading(name, loadingFx) {
+  loadingEffects[name] = loadingFx;
+}
+function registerMap(mapName, geoJson, specialAreas) {
+  var registerMap2 = impl.getImpl("registerMap");
+  registerMap2 && registerMap2(mapName, geoJson, specialAreas);
+}
+var registerTransform = transform.registerExternalTransform;
+registerVisual(PRIORITY_VISUAL_GLOBAL, style.seriesStyleTask);
+registerVisual(PRIORITY_VISUAL_CHART_DATA_CUSTOM, style.dataStyleTask);
+registerVisual(PRIORITY_VISUAL_CHART_DATA_CUSTOM, style.dataColorPaletteTask);
+registerVisual(PRIORITY_VISUAL_GLOBAL, symbol.seriesSymbolTask);
+registerVisual(PRIORITY_VISUAL_CHART_DATA_CUSTOM, symbol.dataSymbolTask);
+registerVisual(PRIORITY_VISUAL_DECAL, decal.default);
+registerPreprocessor(backwardCompat.default);
+registerProcessor(PRIORITY_PROCESSOR_DATASTACK, dataStack.default);
+registerLoading("default", _default.default);
+registerAction({
+  type: states.HIGHLIGHT_ACTION_TYPE,
+  event: states.HIGHLIGHT_ACTION_TYPE,
+  update: states.HIGHLIGHT_ACTION_TYPE
+}, util.noop);
+registerAction({
+  type: states.DOWNPLAY_ACTION_TYPE,
+  event: states.DOWNPLAY_ACTION_TYPE,
+  update: states.DOWNPLAY_ACTION_TYPE
+}, util.noop);
+registerAction({
+  type: states.SELECT_ACTION_TYPE,
+  event: states.SELECT_ACTION_TYPE,
+  update: states.SELECT_ACTION_TYPE
+}, util.noop);
+registerAction({
+  type: states.UNSELECT_ACTION_TYPE,
+  event: states.UNSELECT_ACTION_TYPE,
+  update: states.UNSELECT_ACTION_TYPE
+}, util.noop);
+registerAction({
+  type: states.TOGGLE_SELECT_ACTION_TYPE,
+  event: states.TOGGLE_SELECT_ACTION_TYPE,
+  update: states.TOGGLE_SELECT_ACTION_TYPE
+}, util.noop);
+registerTheme("light", light.default);
+registerTheme("dark", dark.default);
+exports.registerLocale = locale.registerLocale;
+exports.PRIORITY = PRIORITY;
+exports.getInstanceByDom = getInstanceByDom;
+exports.init = init;
+exports.registerAction = registerAction;
+exports.registerCoordinateSystem = registerCoordinateSystem;
+exports.registerLayout = registerLayout;
+exports.registerLoading = registerLoading;
+exports.registerMap = registerMap;
+exports.registerPostInit = registerPostInit;
+exports.registerPostUpdate = registerPostUpdate;
+exports.registerPreprocessor = registerPreprocessor;
+exports.registerProcessor = registerProcessor;
+exports.registerTheme = registerTheme;
+exports.registerTransform = registerTransform;
+exports.registerUpdateLifecycle = registerUpdateLifecycle;
+exports.registerVisual = registerVisual;
+//# sourceMappingURL=echarts.js.map