{"version":3,"sources":["webpack:///./node_modules/echarts/lib/core/locale.js","webpack:///./node_modules/echarts/lib/core/task.js","webpack:///./node_modules/echarts/lib/data/DataDimensionInfo.js","webpack:///./node_modules/echarts/lib/data/DataDiffer.js","webpack:///./node_modules/echarts/lib/core/ExtensionAPI.js","webpack:///./node_modules/echarts/lib/core/Scheduler.js","webpack:///./node_modules/echarts/lib/core/echarts.js"],"names":["LOCALE_ZH","LOCALE_EN","DEFAULT_LOCALE","localeStorage","localeModels","SYSTEM_LANG","domSupported","document","documentElement","lang","navigator","language","browserLanguage","toUpperCase","indexOf","registerLocale","locale","localeObj","createLocaleObject","getLocaleModel","getDefaultLocaleModel","createTask","define","Task","this","_reset","reset","_plan","plan","_count","count","_onDirty","onDirty","_dirty","prototype","perform","performArgs","planResult","upTask","_upstream","skip","context","data","outputData","__pipeline","currentTask","forceFirstProgress","lastModBy","normalizeModBy","_modBy","lastModDataCount","_modDataCount","modBy","modDataCount","val","_doReset","step","_dueEnd","_outputDueEnd","Infinity","_progress","start","_dueIndex","end","Math","min","progress","i","length","_doProgress","outputDueEnd","_settedOutputEnd","unfinished","dirty","iterator","_callingProgress","next","downstream","_downstream","pipe","downTask","dispose","_disposed","getUpstream","getDownstream","setOutputEnd","current","winCount","it","s","e","sStep","sCount","ceil","modNext","sequentialNext","dataIndex","result","DataDimensionInfo","opt","otherDims","dataIndexMapValueLength","valNumOrArrLengthMoreThan2","defaultKeyGetter","item","DataDiffer","oldArr","newArr","oldKeyGetter","newKeyGetter","diffMode","_old","_new","_oldKeyGetter","_newKeyGetter","_diffModeMultiple","add","func","_add","update","_update","updateManyToOne","_updateManyToOne","updateOneToMany","_updateOneToMany","remove","_remove","execute","_executeOneToOne","newDataIndexMap","oldDataKeyArr","Array","newDataKeyArr","_initIndexMap","oldKey","newIdxMapVal","newIdxMapValLen","newIdx","shift","_performRestAdd","_executeMultiple","oldDataIndexMap","oldIdxMapVal","oldIdxMapValLen","i_1","newKey","idxMapValLen","j","arr","map","keyArr","keyGetterName","cbModeMultiple","key","idxMapVal","push","availableMethods","ecInstance","methodName","Scheduler","api","dataProcessorHandlers","visualHandlers","_stageTaskMap","_dataProcessorHandlers","slice","_visualHandlers","_allHandlers","concat","restoreData","ecModel","payload","each","taskRecord","overallTask","getPerformArgs","task","isBlock","pipeline","_pipelineMap","get","id","pCtx","progressiveEnabled","progressiveRender","__idxInPipeline","blockIndex","getPipeline","pipelineId","updateStreamModes","seriesModel","view","uid","dataLen","getData","incrementalPrepareRender","threshold","large","pipelineContext","restorePipelines","scheduler","pipelineMap","eachSeries","progressive","getProgressive","set","head","tail","getProgressiveThreshold","preventIncremental","round","_pipe","dataTask","prepareStageTasks","stageTaskMap","getModel","handler","record","overallReset","_createSeriesStageTask","_createOverallStageTask","prepareView","model","renderTask","__block","performDataProcessorTasks","_performStageTasks","block","performVisualTasks","stageHandlers","needSetDirty","setDirty","dirtyMap","stageHandler","idx","visualType","stageHandlerRecord","seriesTaskMap","overallNeedDirty_1","agentStubMap","stub","updatePayload","performArgs_1","performRawSeries","isSeriesFiltered","performSeriesTasks","oldSeriesTaskMap","newSeriesTaskMap","seriesType","getTargetSeries","create","seriesTaskPlan","seriesTaskReset","seriesTaskCount","useClearVisual","isVisual","isLayout","createOnAllSeries","eachRawSeries","eachRawSeriesByType","overallTaskReset","oldAgentStubMap","newAgentStubMap","overallProgress","shouldOverallTaskDirty","createStub","stubReset","stubOnDirty","agent","getSeries","wrapStageHandler","detectSeriseType","stubProgress","clearAllVisual","resetDefines","v","makeSeriesTaskProgress","singleSeriesTaskProgress","resetDefineIdx","params","resetDefine","dataEach","legacyFunc","ecModelMock","apiMock","mockMethods","target","Clz","name_1","Global","eachSeriesByType","type","eachComponent","cond","mainType","subType","assert","isFunction","isObject","hasWindow","window","PRIORITY_PROCESSOR_DEFAULT","PRIORITY_VISUAL_LAYOUT","PRIORITY_VISUAL_CHART","PRIORITY","PROCESSOR","FILTER","SERIES_FILTER","STATISTIC","VISUAL","LAYOUT","PROGRESSIVE_LAYOUT","GLOBAL","CHART","POST_CHART_LAYOUT","COMPONENT","BRUSH","CHART_ITEM","ARIA","DECAL","ACTION_REG","CONNECT_STATUS_KEY","createRegisterEventWithLowercaseECharts","method","args","_i","arguments","isDisposed","toLowercaseNameAndCallEventful","disposedWarning","createRegisterEventWithLowercaseMessageCenter","host","toLowerCase","Eventful","apply","prepare","updateDirectly","updateMethods","doConvertPixel","doDispatchAction","flushPendingActions","triggerUpdatedEvent","bindRenderedEvent","bindMouseEvent","clearColorPalette","render","renderComponents","renderSeries","performPostUpdateFuncs","createExtensionAPI","enableConnect","setTransitionOpt","markStatusToUpdate","applyChangedStates","_super","MessageCenter","messageCenterProto","on","off","ECharts","dom","theme","opts","_this","call","ECEventProcessor","_chartsViews","_chartsMap","_componentsViews","_componentsMap","_pendingActions","themeStorage","_dom","zr","_zr","zrender","renderer","devicePixelRatio","width","height","useDirtyRect","_throttledZrFlush","throttle","flush","backwardCompat","_theme","_locale","_coordSysMgr","CoordinateSystem","_api","prioritySortFunc","a","b","__prio","timsort","visualFuncs","dataProcessorFuncs","_scheduler","_messageCenter","_labelManager","LabelManager","_initEvents","resize","animation","_onframe","silent","remainTime","_model","startTime","Date","getDom","getId","getZr","setOption","option","notMerge","lazyUpdate","replaceMerge","transitionOpt","transition","optionManager","OptionManager","init","optionPreprocessorFuncs","wakeUp","setTheme","console","error","getOption","getWidth","getHeight","getDevicePixelRatio","painter","dpr","getRenderedCanvas","env","canvasSupported","pixelRatio","backgroundColor","getSvgDataURL","svgSupported","list","storage","getDisplayList","el","stopAnimation","toDataURL","getDataURL","excludeComponents","excludesComponentViews","self","componentType","component","__viewId","group","ignore","url","getType","getConnectedDataURL","isSvg","groupId","mathMin","mathMax","max","connectedGroups","left_1","top_1","right_1","bottom_1","canvasList_1","dpr_1","instances","chart","canvas","getSvgDom","innerHTML","boundingRect","getBoundingClientRect","left","top","right","bottom","targetCanvas","zr_1","content_1","x","y","getSvgRoot","connectedBackgroundColor","setBackgroundColor","refreshImmediately","shape","style","fill","img","image","convertToPixel","finder","value","convertFromPixel","containPixel","findResult","models","coordSys","coordinateSystem","containPoint","getVisual","parsedFinder","defaultMainType","dataIndexInside","hasOwnProperty","indexOfRawIndex","getViewOfComponentModel","componentModel","getViewOfSeriesModel","MOUSE_EVENT_NAMES","eveName","parent","ecData","dataModel","getSeriesByIndex","seriesIndex","getDataParams","dataType","eventData","componentIndex","getComponent","event","_$eventProcessor","eventInfo","targetEl","packedEvent","trigger","zrEventfulCallAtLast","eventActionMap","actionType","eventType","clear","series","DOM_ATTRIBUTE_KEY","_loadingFX","optionChanged","resetOption","duration","showLoading","name","cfg","hideLoading","loadingEffects","makeActionFromEvent","eventObj","dispatchAction","actions","browser","weChat","updateLabelLayout","labelManager","updateLayoutConfig","layout","processLabelsOverall","appendData","internalField","applyElementStates","newStates","oldStates","currentStates","stateName","selected","states","select","hoverState","emphasis","blur","useStates","updateZ","preventAutoZ","_updateZ","z","zlevel","maxZ2","label","getTextContent","labelLine","getTextGuideLine","isGroup","children","childrenRef","z2","isFinite","textGuideLineConfig","showAbove","clearStates","traverse","graphic","textContent","textGuide","stateTransition","hasState","prevStates","updateStates","stateAnimationModel","enableAnimation","isAnimationEnabled","delay","easing","__dirty","ecIns","isComponent","viewList","viewMap","__alive","doPrepare","requireNewView","__requireNewView","viewId","classType","Component","getClass","main","sub","Chart","__id","__model","__ecComponentInfo","index","splice","setUpdatePayload","query","condition","excludeSeriesIdMap","excludeSeriesId","modelId","Series","notBlur","_a","focusSelf","dispatchers","dispatcher","callView","prepareAndUpdate","coordSysMgr","darkMode","setDarkMode","colorArr","color","updateTransform","componentDirtyList","componentView","seriesDirtyMap","chartView","updateView","markUpdateMethod","updateVisual","updateLayout","coordSysList","getCoordinateSystems","chartsMap","payloadType","escapeConnect","actionWrap","actionInfo","cptTypeTmp","split","updateMethod","pop","cptType","payloads","batched","batch","eventObjBatch","isSelectChange","isHighDown","batchItem","action","queryOptionMap","componentMainType","mainTypeSpecified","keys","messageCenter","newObj","isFromClick","fromAction","fromActionPayload","pendingActions","isFinished","dirtyList","clearLabels","__transientTransitionOpt","blendMode","blend","eachPendingDisplayable","displayable","updateBlend","addLabelsOfSeries","elCount","node","worker","preventUsingHoverLayer","hoverLayer","updateHoverLayerStatus","postUpdateFuncs","class_1","getComponentByElement","modelInfo","enterEmphasis","highlightDigit","leaveEmphasis","enterBlur","leaveBlur","enterSelect","leaveSelect","updateConnectedChartsStatus","charts","status","action_1","otherCharts_1","otherChart","transOpt","errMsg","fromOpt","from","toOpt","to","finderOpt","includeMainTypes","enableAll","enableNone","fromResult","toSeries","dimension","dividingMethod","echartsProto","one","eventName","cb","ctx","wrapped","args2","postInitFuncs","idBase","existInstance","getInstanceByDom","postInitFunc","registerTheme","registerPreprocessor","preprocessorFunc","registerProcessor","priority","processor","normalizeRegister","registerPostInit","registerPostUpdate","postUpdateFunc","registerAction","test","registerCoordinateSystem","coordSysCreator","register","registerLayout","layoutTask","registerVisual","visualTask","registeredTasks","targetList","fn","defaultPriority","__raw","registerLoading","loadingFx","registerMap","mapName","geoJson","specialAreas","geoSourceManager","registerTransform","decal","dataStack","light","dark"],"mappings":"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","file":"vendors~app~4939e289.js","sourcesContent":["\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\n\n/**\n * AUTO-GENERATED FILE. DO NOT MODIFY.\n */\n\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\nimport Model from '../model/Model';\nimport env from 'zrender/lib/core/env'; // default import ZH and EN lang\n\nimport langEN from '../i18n/langEN';\nimport langZH from '../i18n/langZH';\nimport { isString, clone, merge } from 'zrender/lib/core/util';\nvar LOCALE_ZH = 'ZH';\nvar LOCALE_EN = 'EN';\nvar DEFAULT_LOCALE = LOCALE_EN;\nvar localeStorage = {};\nvar localeModels = {};\nexport var SYSTEM_LANG = !env.domSupported ? DEFAULT_LOCALE : function () {\n  var langStr = (\n  /* eslint-disable-next-line */\n  document.documentElement.lang || navigator.language || navigator.browserLanguage).toUpperCase();\n  return langStr.indexOf(LOCALE_ZH) > -1 ? LOCALE_ZH : DEFAULT_LOCALE;\n}();\nexport function registerLocale(locale, localeObj) {\n  locale = locale.toUpperCase();\n  localeModels[locale] = new Model(localeObj);\n  localeStorage[locale] = localeObj;\n} // export function getLocale(locale: string) {\n//     return localeStorage[locale];\n// }\n\nexport function createLocaleObject(locale) {\n  if (isString(locale)) {\n    var localeObj = localeStorage[locale.toUpperCase()] || {};\n\n    if (locale === LOCALE_ZH || locale === LOCALE_EN) {\n      return clone(localeObj);\n    } else {\n      return merge(clone(localeObj), clone(localeStorage[DEFAULT_LOCALE]), false);\n    }\n  } else {\n    return merge(clone(locale), clone(localeStorage[DEFAULT_LOCALE]), false);\n  }\n}\nexport function getLocaleModel(lang) {\n  return localeModels[lang];\n}\nexport function getDefaultLocaleModel() {\n  return localeModels[DEFAULT_LOCALE];\n} // Default locale\n\nregisterLocale(LOCALE_EN, langEN);\nregisterLocale(LOCALE_ZH, langZH);","\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\n\n/**\n * AUTO-GENERATED FILE. DO NOT MODIFY.\n */\n\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\nimport { assert, isArray } from 'zrender/lib/core/util';\n;\n/**\n * @param {Object} define\n * @return See the return of `createTask`.\n */\n\nexport function createTask(define) {\n  return new Task(define);\n}\n\nvar Task =\n/** @class */\nfunction () {\n  function Task(define) {\n    define = define || {};\n    this._reset = define.reset;\n    this._plan = define.plan;\n    this._count = define.count;\n    this._onDirty = define.onDirty;\n    this._dirty = true;\n  }\n  /**\n   * @param step Specified step.\n   * @param skip Skip customer perform call.\n   * @param modBy Sampling window size.\n   * @param modDataCount Sampling count.\n   * @return whether unfinished.\n   */\n\n\n  Task.prototype.perform = function (performArgs) {\n    var upTask = this._upstream;\n    var skip = performArgs && performArgs.skip; // TODO some refactor.\n    // Pull data. Must pull data each time, because context.data\n    // may be updated by Series.setData.\n\n    if (this._dirty && upTask) {\n      var context = this.context;\n      context.data = context.outputData = upTask.context.outputData;\n    }\n\n    if (this.__pipeline) {\n      this.__pipeline.currentTask = this;\n    }\n\n    var planResult;\n\n    if (this._plan && !skip) {\n      planResult = this._plan(this.context);\n    } // Support sharding by mod, which changes the render sequence and makes the rendered graphic\n    // elements uniformed distributed when progress, especially when moving or zooming.\n\n\n    var lastModBy = normalizeModBy(this._modBy);\n    var lastModDataCount = this._modDataCount || 0;\n    var modBy = normalizeModBy(performArgs && performArgs.modBy);\n    var modDataCount = performArgs && performArgs.modDataCount || 0;\n\n    if (lastModBy !== modBy || lastModDataCount !== modDataCount) {\n      planResult = 'reset';\n    }\n\n    function normalizeModBy(val) {\n      !(val >= 1) && (val = 1); // jshint ignore:line\n\n      return val;\n    }\n\n    var forceFirstProgress;\n\n    if (this._dirty || planResult === 'reset') {\n      this._dirty = false;\n      forceFirstProgress = this._doReset(skip);\n    }\n\n    this._modBy = modBy;\n    this._modDataCount = modDataCount;\n    var step = performArgs && performArgs.step;\n\n    if (upTask) {\n      if (process.env.NODE_ENV !== 'production') {\n        assert(upTask._outputDueEnd != null);\n      }\n\n      this._dueEnd = upTask._outputDueEnd;\n    } // DataTask or overallTask\n    else {\n        if (process.env.NODE_ENV !== 'production') {\n          assert(!this._progress || this._count);\n        }\n\n        this._dueEnd = this._count ? this._count(this.context) : Infinity;\n      } // Note: Stubs, that its host overall task let it has progress, has progress.\n    // If no progress, pass index from upstream to downstream each time plan called.\n\n\n    if (this._progress) {\n      var start = this._dueIndex;\n      var end = Math.min(step != null ? this._dueIndex + step : Infinity, this._dueEnd);\n\n      if (!skip && (forceFirstProgress || start < end)) {\n        var progress = this._progress;\n\n        if (isArray(progress)) {\n          for (var i = 0; i < progress.length; i++) {\n            this._doProgress(progress[i], start, end, modBy, modDataCount);\n          }\n        } else {\n          this._doProgress(progress, start, end, modBy, modDataCount);\n        }\n      }\n\n      this._dueIndex = end; // If no `outputDueEnd`, assume that output data and\n      // input data is the same, so use `dueIndex` as `outputDueEnd`.\n\n      var outputDueEnd = this._settedOutputEnd != null ? this._settedOutputEnd : end;\n\n      if (process.env.NODE_ENV !== 'production') {\n        // ??? Can not rollback.\n        assert(outputDueEnd >= this._outputDueEnd);\n      }\n\n      this._outputDueEnd = outputDueEnd;\n    } else {\n      // (1) Some overall task has no progress.\n      // (2) Stubs, that its host overall task do not let it has progress, has no progress.\n      // This should always be performed so it can be passed to downstream.\n      this._dueIndex = this._outputDueEnd = this._settedOutputEnd != null ? this._settedOutputEnd : this._dueEnd;\n    }\n\n    return this.unfinished();\n  };\n\n  Task.prototype.dirty = function () {\n    this._dirty = true;\n    this._onDirty && this._onDirty(this.context);\n  };\n\n  Task.prototype._doProgress = function (progress, start, end, modBy, modDataCount) {\n    iterator.reset(start, end, modBy, modDataCount);\n    this._callingProgress = progress;\n\n    this._callingProgress({\n      start: start,\n      end: end,\n      count: end - start,\n      next: iterator.next\n    }, this.context);\n  };\n\n  Task.prototype._doReset = function (skip) {\n    this._dueIndex = this._outputDueEnd = this._dueEnd = 0;\n    this._settedOutputEnd = null;\n    var progress;\n    var forceFirstProgress;\n\n    if (!skip && this._reset) {\n      progress = this._reset(this.context);\n\n      if (progress && progress.progress) {\n        forceFirstProgress = progress.forceFirstProgress;\n        progress = progress.progress;\n      } // To simplify no progress checking, array must has item.\n\n\n      if (isArray(progress) && !progress.length) {\n        progress = null;\n      }\n    }\n\n    this._progress = progress;\n    this._modBy = this._modDataCount = null;\n    var downstream = this._downstream;\n    downstream && downstream.dirty();\n    return forceFirstProgress;\n  };\n\n  Task.prototype.unfinished = function () {\n    return this._progress && this._dueIndex < this._dueEnd;\n  };\n  /**\n   * @param downTask The downstream task.\n   * @return The downstream task.\n   */\n\n\n  Task.prototype.pipe = function (downTask) {\n    if (process.env.NODE_ENV !== 'production') {\n      assert(downTask && !downTask._disposed && downTask !== this);\n    } // If already downstream, do not dirty downTask.\n\n\n    if (this._downstream !== downTask || this._dirty) {\n      this._downstream = downTask;\n      downTask._upstream = this;\n      downTask.dirty();\n    }\n  };\n\n  Task.prototype.dispose = function () {\n    if (this._disposed) {\n      return;\n    }\n\n    this._upstream && (this._upstream._downstream = null);\n    this._downstream && (this._downstream._upstream = null);\n    this._dirty = false;\n    this._disposed = true;\n  };\n\n  Task.prototype.getUpstream = function () {\n    return this._upstream;\n  };\n\n  Task.prototype.getDownstream = function () {\n    return this._downstream;\n  };\n\n  Task.prototype.setOutputEnd = function (end) {\n    // This only happend in dataTask, dataZoom, map, currently.\n    // where dataZoom do not set end each time, but only set\n    // when reset. So we should record the setted end, in case\n    // that the stub of dataZoom perform again and earse the\n    // setted end by upstream.\n    this._outputDueEnd = this._settedOutputEnd = end;\n  };\n\n  return Task;\n}();\n\nexport { Task };\n\nvar iterator = function () {\n  var end;\n  var current;\n  var modBy;\n  var modDataCount;\n  var winCount;\n  var it = {\n    reset: function (s, e, sStep, sCount) {\n      current = s;\n      end = e;\n      modBy = sStep;\n      modDataCount = sCount;\n      winCount = Math.ceil(modDataCount / modBy);\n      it.next = modBy > 1 && modDataCount > 0 ? modNext : sequentialNext;\n    }\n  };\n  return it;\n\n  function sequentialNext() {\n    return current < end ? current++ : null;\n  }\n\n  function modNext() {\n    var dataIndex = current % winCount * modBy + Math.ceil(current / winCount);\n    var result = current >= end ? null : dataIndex < modDataCount ? dataIndex // If modDataCount is smaller than data.count() (consider `appendData` case),\n    // Use normal linear rendering mode.\n    : current;\n    current++;\n    return result;\n  }\n}(); ///////////////////////////////////////////////////////////\n// For stream debug (Should be commented out after used!)\n// @usage: printTask(this, 'begin');\n// @usage: printTask(this, null, {someExtraProp});\n// @usage: Use `__idxInPipeline` as conditional breakpiont.\n//\n// window.printTask = function (task: any, prefix: string, extra: { [key: string]: unknown }): void {\n//     window.ecTaskUID == null && (window.ecTaskUID = 0);\n//     task.uidDebug == null && (task.uidDebug = `task_${window.ecTaskUID++}`);\n//     task.agent && task.agent.uidDebug == null && (task.agent.uidDebug = `task_${window.ecTaskUID++}`);\n//     let props = [];\n//     if (task.__pipeline) {\n//         let val = `${task.__idxInPipeline}/${task.__pipeline.tail.__idxInPipeline} ${task.agent ? '(stub)' : ''}`;\n//         props.push({text: '__idxInPipeline/total', value: val});\n//     } else {\n//         let stubCount = 0;\n//         task.agentStubMap.each(() => stubCount++);\n//         props.push({text: 'idx', value: `overall (stubs: ${stubCount})`});\n//     }\n//     props.push({text: 'uid', value: task.uidDebug});\n//     if (task.__pipeline) {\n//         props.push({text: 'pipelineId', value: task.__pipeline.id});\n//         task.agent && props.push(\n//             {text: 'stubFor', value: task.agent.uidDebug}\n//         );\n//     }\n//     props.push(\n//         {text: 'dirty', value: task._dirty},\n//         {text: 'dueIndex', value: task._dueIndex},\n//         {text: 'dueEnd', value: task._dueEnd},\n//         {text: 'outputDueEnd', value: task._outputDueEnd}\n//     );\n//     if (extra) {\n//         Object.keys(extra).forEach(key => {\n//             props.push({text: key, value: extra[key]});\n//         });\n//     }\n//     let args = ['color: blue'];\n//     let msg = `%c[${prefix || 'T'}] %c` + props.map(item => (\n//         args.push('color: green', 'color: red'),\n//         `${item.text}: %c${item.value}`\n//     )).join('%c, ');\n//     console.log.apply(console, [msg].concat(args));\n//     // console.log(this);\n// };\n// window.printPipeline = function (task: any, prefix: string) {\n//     const pipeline = task.__pipeline;\n//     let currTask = pipeline.head;\n//     while (currTask) {\n//         window.printTask(currTask, prefix);\n//         currTask = currTask._downstream;\n//     }\n// };\n// window.showChain = function (chainHeadTask) {\n//     var chain = [];\n//     var task = chainHeadTask;\n//     while (task) {\n//         chain.push({\n//             task: task,\n//             up: task._upstream,\n//             down: task._downstream,\n//             idxInPipeline: task.__idxInPipeline\n//         });\n//         task = task._downstream;\n//     }\n//     return chain;\n// };\n// window.findTaskInChain = function (task, chainHeadTask) {\n//     let chain = window.showChain(chainHeadTask);\n//     let result = [];\n//     for (let i = 0; i < chain.length; i++) {\n//         let chainItem = chain[i];\n//         if (chainItem.task === task) {\n//             result.push(i);\n//         }\n//     }\n//     return result;\n// };\n// window.printChainAEachInChainB = function (chainHeadTaskA, chainHeadTaskB) {\n//     let chainA = window.showChain(chainHeadTaskA);\n//     for (let i = 0; i < chainA.length; i++) {\n//         console.log('chainAIdx:', i, 'inChainB:', window.findTaskInChain(chainA[i].task, chainHeadTaskB));\n//     }\n// };","\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\n\n/**\n * AUTO-GENERATED FILE. DO NOT MODIFY.\n */\n\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\nimport * as zrUtil from 'zrender/lib/core/util';\n\nvar DataDimensionInfo =\n/** @class */\nfunction () {\n  /**\n   * @param opt All of the fields will be shallow copied.\n   */\n  function DataDimensionInfo(opt) {\n    /**\n     * The format of `otherDims` is:\n     * ```js\n     * {\n     *     tooltip: number optional,\n     *     label: number optional,\n     *     itemName: number optional,\n     *     seriesName: number optional,\n     * }\n     * ```\n     *\n     * A `series.encode` can specified these fields:\n     * ```js\n     * encode: {\n     *     // \"3, 1, 5\" is the index of data dimension.\n     *     tooltip: [3, 1, 5],\n     *     label: [0, 3],\n     *     ...\n     * }\n     * ```\n     * `otherDims` is the parse result of the `series.encode` above, like:\n     * ```js\n     * // Suppose the index of this data dimension is `3`.\n     * this.otherDims = {\n     *     // `3` is at the index `0` of the `encode.tooltip`\n     *     tooltip: 0,\n     *     // `3` is at the index `1` of the `encode.tooltip`\n     *     label: 1\n     * };\n     * ```\n     *\n     * This prop should never be `null`/`undefined` after initialized.\n     */\n    this.otherDims = {};\n\n    if (opt != null) {\n      zrUtil.extend(this, opt);\n    }\n  }\n\n  return DataDimensionInfo;\n}();\n\n;\nexport default DataDimensionInfo;","\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\n\n/**\n * AUTO-GENERATED FILE. DO NOT MODIFY.\n */\n\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\nfunction dataIndexMapValueLength(valNumOrArrLengthMoreThan2) {\n  return valNumOrArrLengthMoreThan2 == null ? 0 : valNumOrArrLengthMoreThan2.length || 1;\n}\n\nfunction defaultKeyGetter(item) {\n  return item;\n}\n\nvar DataDiffer =\n/** @class */\nfunction () {\n  /**\n   * @param context Can be visited by this.context in callback.\n   */\n  function DataDiffer(oldArr, newArr, oldKeyGetter, newKeyGetter, context, // By default: 'oneToOne'.\n  diffMode) {\n    this._old = oldArr;\n    this._new = newArr;\n    this._oldKeyGetter = oldKeyGetter || defaultKeyGetter;\n    this._newKeyGetter = newKeyGetter || defaultKeyGetter; // Visible in callback via `this.context`;\n\n    this.context = context;\n    this._diffModeMultiple = diffMode === 'multiple';\n  }\n  /**\n   * Callback function when add a data\n   */\n\n\n  DataDiffer.prototype.add = function (func) {\n    this._add = func;\n    return this;\n  };\n  /**\n   * Callback function when update a data\n   */\n\n\n  DataDiffer.prototype.update = function (func) {\n    this._update = func;\n    return this;\n  };\n  /**\n   * Callback function when update a data and only work in `cbMode: 'byKey'`.\n   */\n\n\n  DataDiffer.prototype.updateManyToOne = function (func) {\n    this._updateManyToOne = func;\n    return this;\n  };\n  /**\n   * Callback function when update a data and only work in `cbMode: 'byKey'`.\n   */\n\n\n  DataDiffer.prototype.updateOneToMany = function (func) {\n    this._updateOneToMany = func;\n    return this;\n  };\n  /**\n   * Callback function when remove a data\n   */\n\n\n  DataDiffer.prototype.remove = function (func) {\n    this._remove = func;\n    return this;\n  };\n\n  DataDiffer.prototype.execute = function () {\n    this[this._diffModeMultiple ? '_executeMultiple' : '_executeOneToOne']();\n  };\n\n  DataDiffer.prototype._executeOneToOne = function () {\n    var oldArr = this._old;\n    var newArr = this._new;\n    var newDataIndexMap = {};\n    var oldDataKeyArr = new Array(oldArr.length);\n    var newDataKeyArr = new Array(newArr.length);\n\n    this._initIndexMap(oldArr, null, oldDataKeyArr, '_oldKeyGetter');\n\n    this._initIndexMap(newArr, newDataIndexMap, newDataKeyArr, '_newKeyGetter');\n\n    for (var i = 0; i < oldArr.length; i++) {\n      var oldKey = oldDataKeyArr[i];\n      var newIdxMapVal = newDataIndexMap[oldKey];\n      var newIdxMapValLen = dataIndexMapValueLength(newIdxMapVal); // idx can never be empty array here. see 'set null' logic below.\n\n      if (newIdxMapValLen > 1) {\n        // Consider there is duplicate key (for example, use dataItem.name as key).\n        // We should make sure every item in newArr and oldArr can be visited.\n        var newIdx = newIdxMapVal.shift();\n\n        if (newIdxMapVal.length === 1) {\n          newDataIndexMap[oldKey] = newIdxMapVal[0];\n        }\n\n        this._update && this._update(newIdx, i);\n      } else if (newIdxMapValLen === 1) {\n        newDataIndexMap[oldKey] = null;\n        this._update && this._update(newIdxMapVal, i);\n      } else {\n        this._remove && this._remove(i);\n      }\n    }\n\n    this._performRestAdd(newDataKeyArr, newDataIndexMap);\n  };\n  /**\n   * For example, consider the case:\n   * oldData: [o0, o1, o2, o3, o4, o5, o6, o7],\n   * newData: [n0, n1, n2, n3, n4, n5, n6, n7, n8],\n   * Where:\n   *     o0, o1, n0 has key 'a' (many to one)\n   *     o5, n4, n5, n6 has key 'b' (one to many)\n   *     o2, n1 has key 'c' (one to one)\n   *     n2, n3 has key 'd' (add)\n   *     o3, o4 has key 'e' (remove)\n   *     o6, o7, n7, n8 has key 'f' (many to many, treated as add and remove)\n   * Then:\n   *     (The order of the following directives are not ensured.)\n   *     this._updateManyToOne(n0, [o0, o1]);\n   *     this._updateOneToMany([n4, n5, n6], o5);\n   *     this._update(n1, o2);\n   *     this._remove(o3);\n   *     this._remove(o4);\n   *     this._remove(o6);\n   *     this._remove(o7);\n   *     this._add(n2);\n   *     this._add(n3);\n   *     this._add(n7);\n   *     this._add(n8);\n   */\n\n\n  DataDiffer.prototype._executeMultiple = function () {\n    var oldArr = this._old;\n    var newArr = this._new;\n    var oldDataIndexMap = {};\n    var newDataIndexMap = {};\n    var oldDataKeyArr = [];\n    var newDataKeyArr = [];\n\n    this._initIndexMap(oldArr, oldDataIndexMap, oldDataKeyArr, '_oldKeyGetter');\n\n    this._initIndexMap(newArr, newDataIndexMap, newDataKeyArr, '_newKeyGetter');\n\n    for (var i = 0; i < oldDataKeyArr.length; i++) {\n      var oldKey = oldDataKeyArr[i];\n      var oldIdxMapVal = oldDataIndexMap[oldKey];\n      var newIdxMapVal = newDataIndexMap[oldKey];\n      var oldIdxMapValLen = dataIndexMapValueLength(oldIdxMapVal);\n      var newIdxMapValLen = dataIndexMapValueLength(newIdxMapVal);\n\n      if (oldIdxMapValLen > 1 && newIdxMapValLen === 1) {\n        this._updateManyToOne && this._updateManyToOne(newIdxMapVal, oldIdxMapVal);\n        newDataIndexMap[oldKey] = null;\n      } else if (oldIdxMapValLen === 1 && newIdxMapValLen > 1) {\n        this._updateOneToMany && this._updateOneToMany(newIdxMapVal, oldIdxMapVal);\n        newDataIndexMap[oldKey] = null;\n      } else if (oldIdxMapValLen === 1 && newIdxMapValLen === 1) {\n        this._update && this._update(newIdxMapVal, oldIdxMapVal);\n        newDataIndexMap[oldKey] = null;\n      } else if (oldIdxMapValLen > 1) {\n        for (var i_1 = 0; i_1 < oldIdxMapValLen; i_1++) {\n          this._remove && this._remove(oldIdxMapVal[i_1]);\n        }\n      } else {\n        this._remove && this._remove(oldIdxMapVal);\n      }\n    }\n\n    this._performRestAdd(newDataKeyArr, newDataIndexMap);\n  };\n\n  DataDiffer.prototype._performRestAdd = function (newDataKeyArr, newDataIndexMap) {\n    for (var i = 0; i < newDataKeyArr.length; i++) {\n      var newKey = newDataKeyArr[i];\n      var newIdxMapVal = newDataIndexMap[newKey];\n      var idxMapValLen = dataIndexMapValueLength(newIdxMapVal);\n\n      if (idxMapValLen > 1) {\n        for (var j = 0; j < idxMapValLen; j++) {\n          this._add && this._add(newIdxMapVal[j]);\n        }\n      } else if (idxMapValLen === 1) {\n        this._add && this._add(newIdxMapVal);\n      } // Support both `newDataKeyArr` are duplication removed or not removed.\n\n\n      newDataIndexMap[newKey] = null;\n    }\n  };\n\n  DataDiffer.prototype._initIndexMap = function (arr, // Can be null.\n  map, // In 'byKey', the output `keyArr` is duplication removed.\n  // In 'byIndex', the output `keyArr` is not duplication removed and\n  //     its indices are accurately corresponding to `arr`.\n  keyArr, keyGetterName) {\n    var cbModeMultiple = this._diffModeMultiple;\n\n    for (var i = 0; i < arr.length; i++) {\n      // Add prefix to avoid conflict with Object.prototype.\n      var key = '_ec_' + this[keyGetterName](arr[i], i);\n\n      if (!cbModeMultiple) {\n        keyArr[i] = key;\n      }\n\n      if (!map) {\n        continue;\n      }\n\n      var idxMapVal = map[key];\n      var idxMapValLen = dataIndexMapValueLength(idxMapVal);\n\n      if (idxMapValLen === 0) {\n        // Simple optimize: in most cases, one index has one key,\n        // do not need array.\n        map[key] = i;\n\n        if (cbModeMultiple) {\n          keyArr.push(key);\n        }\n      } else if (idxMapValLen === 1) {\n        map[key] = [idxMapVal, i];\n      } else {\n        idxMapVal.push(i);\n      }\n    }\n  };\n\n  return DataDiffer;\n}();\n\nexport default DataDiffer;","\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\n\n/**\n * AUTO-GENERATED FILE. DO NOT MODIFY.\n */\n\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\nimport * as zrUtil from 'zrender/lib/core/util';\nvar availableMethods = ['getDom', 'getZr', 'getWidth', 'getHeight', 'getDevicePixelRatio', 'dispatchAction', 'isDisposed', 'on', 'off', 'getDataURL', 'getConnectedDataURL', // 'getModel',\n'getOption', // 'getViewOfComponentModel',\n// 'getViewOfSeriesModel',\n'getId', 'updateLabelLayout'];\n\nvar ExtensionAPI =\n/** @class */\nfunction () {\n  function ExtensionAPI(ecInstance) {\n    zrUtil.each(availableMethods, function (methodName) {\n      this[methodName] = zrUtil.bind(ecInstance[methodName], ecInstance);\n    }, this);\n  }\n\n  return ExtensionAPI;\n}();\n\nexport default ExtensionAPI;","\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\n\n/**\n * AUTO-GENERATED FILE. DO NOT MODIFY.\n */\n\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\nimport { each, map, isFunction, createHashMap, noop, assert } from 'zrender/lib/core/util';\nimport { createTask } from './task';\nimport { getUID } from '../util/component';\nimport GlobalModel from '../model/Global';\nimport ExtensionAPI from './ExtensionAPI';\nimport { normalizeToArray } from '../util/model';\n;\n\nvar Scheduler =\n/** @class */\nfunction () {\n  function Scheduler(ecInstance, api, dataProcessorHandlers, visualHandlers) {\n    // key: handlerUID\n    this._stageTaskMap = createHashMap();\n    this.ecInstance = ecInstance;\n    this.api = api; // Fix current processors in case that in some rear cases that\n    // processors might be registered after echarts instance created.\n    // Register processors incrementally for a echarts instance is\n    // not supported by this stream architecture.\n\n    dataProcessorHandlers = this._dataProcessorHandlers = dataProcessorHandlers.slice();\n    visualHandlers = this._visualHandlers = visualHandlers.slice();\n    this._allHandlers = dataProcessorHandlers.concat(visualHandlers);\n  }\n\n  Scheduler.prototype.restoreData = function (ecModel, payload) {\n    // TODO: Only restore needed series and components, but not all components.\n    // Currently `restoreData` of all of the series and component will be called.\n    // But some independent components like `title`, `legend`, `graphic`, `toolbox`,\n    // `tooltip`, `axisPointer`, etc, do not need series refresh when `setOption`,\n    // and some components like coordinate system, axes, dataZoom, visualMap only\n    // need their target series refresh.\n    // (1) If we are implementing this feature some day, we should consider these cases:\n    // if a data processor depends on a component (e.g., dataZoomProcessor depends\n    // on the settings of `dataZoom`), it should be re-performed if the component\n    // is modified by `setOption`.\n    // (2) If a processor depends on sevral series, speicified by its `getTargetSeries`,\n    // it should be re-performed when the result array of `getTargetSeries` changed.\n    // We use `dependencies` to cover these issues.\n    // (3) How to update target series when coordinate system related components modified.\n    // TODO: simply the dirty mechanism? Check whether only the case here can set tasks dirty,\n    // and this case all of the tasks will be set as dirty.\n    ecModel.restoreData(payload); // Theoretically an overall task not only depends on each of its target series, but also\n    // depends on all of the series.\n    // The overall task is not in pipeline, and `ecModel.restoreData` only set pipeline tasks\n    // dirty. If `getTargetSeries` of an overall task returns nothing, we should also ensure\n    // that the overall task is set as dirty and to be performed, otherwise it probably cause\n    // state chaos. So we have to set dirty of all of the overall tasks manually, otherwise it\n    // probably cause state chaos (consider `dataZoomProcessor`).\n\n    this._stageTaskMap.each(function (taskRecord) {\n      var overallTask = taskRecord.overallTask;\n      overallTask && overallTask.dirty();\n    });\n  }; // If seriesModel provided, incremental threshold is check by series data.\n\n\n  Scheduler.prototype.getPerformArgs = function (task, isBlock) {\n    // For overall task\n    if (!task.__pipeline) {\n      return;\n    }\n\n    var pipeline = this._pipelineMap.get(task.__pipeline.id);\n\n    var pCtx = pipeline.context;\n    var incremental = !isBlock && pipeline.progressiveEnabled && (!pCtx || pCtx.progressiveRender) && task.__idxInPipeline > pipeline.blockIndex;\n    var step = incremental ? pipeline.step : null;\n    var modDataCount = pCtx && pCtx.modDataCount;\n    var modBy = modDataCount != null ? Math.ceil(modDataCount / step) : null;\n    return {\n      step: step,\n      modBy: modBy,\n      modDataCount: modDataCount\n    };\n  };\n\n  Scheduler.prototype.getPipeline = function (pipelineId) {\n    return this._pipelineMap.get(pipelineId);\n  };\n  /**\n   * Current, progressive rendering starts from visual and layout.\n   * Always detect render mode in the same stage, avoiding that incorrect\n   * detection caused by data filtering.\n   * Caution:\n   * `updateStreamModes` use `seriesModel.getData()`.\n   */\n\n\n  Scheduler.prototype.updateStreamModes = function (seriesModel, view) {\n    var pipeline = this._pipelineMap.get(seriesModel.uid);\n\n    var data = seriesModel.getData();\n    var dataLen = data.count(); // `progressiveRender` means that can render progressively in each\n    // animation frame. Note that some types of series do not provide\n    // `view.incrementalPrepareRender` but support `chart.appendData`. We\n    // use the term `incremental` but not `progressive` to describe the\n    // case that `chart.appendData`.\n\n    var progressiveRender = pipeline.progressiveEnabled && view.incrementalPrepareRender && dataLen >= pipeline.threshold;\n    var large = seriesModel.get('large') && dataLen >= seriesModel.get('largeThreshold'); // TODO: modDataCount should not updated if `appendData`, otherwise cause whole repaint.\n    // see `test/candlestick-large3.html`\n\n    var modDataCount = seriesModel.get('progressiveChunkMode') === 'mod' ? dataLen : null;\n    seriesModel.pipelineContext = pipeline.context = {\n      progressiveRender: progressiveRender,\n      modDataCount: modDataCount,\n      large: large\n    };\n  };\n\n  Scheduler.prototype.restorePipelines = function (ecModel) {\n    var scheduler = this;\n    var pipelineMap = scheduler._pipelineMap = createHashMap();\n    ecModel.eachSeries(function (seriesModel) {\n      var progressive = seriesModel.getProgressive();\n      var pipelineId = seriesModel.uid;\n      pipelineMap.set(pipelineId, {\n        id: pipelineId,\n        head: null,\n        tail: null,\n        threshold: seriesModel.getProgressiveThreshold(),\n        progressiveEnabled: progressive && !(seriesModel.preventIncremental && seriesModel.preventIncremental()),\n        blockIndex: -1,\n        step: Math.round(progressive || 700),\n        count: 0\n      });\n\n      scheduler._pipe(seriesModel, seriesModel.dataTask);\n    });\n  };\n\n  Scheduler.prototype.prepareStageTasks = function () {\n    var stageTaskMap = this._stageTaskMap;\n    var ecModel = this.api.getModel();\n    var api = this.api;\n    each(this._allHandlers, function (handler) {\n      var record = stageTaskMap.get(handler.uid) || stageTaskMap.set(handler.uid, {});\n      var errMsg = '';\n\n      if (process.env.NODE_ENV !== 'production') {\n        // Currently do not need to support to sepecify them both.\n        errMsg = '\"reset\" and \"overallReset\" must not be both specified.';\n      }\n\n      assert(!(handler.reset && handler.overallReset), errMsg);\n      handler.reset && this._createSeriesStageTask(handler, record, ecModel, api);\n      handler.overallReset && this._createOverallStageTask(handler, record, ecModel, api);\n    }, this);\n  };\n\n  Scheduler.prototype.prepareView = function (view, model, ecModel, api) {\n    var renderTask = view.renderTask;\n    var context = renderTask.context;\n    context.model = model;\n    context.ecModel = ecModel;\n    context.api = api;\n    renderTask.__block = !view.incrementalPrepareRender;\n\n    this._pipe(model, renderTask);\n  };\n\n  Scheduler.prototype.performDataProcessorTasks = function (ecModel, payload) {\n    // If we do not use `block` here, it should be considered when to update modes.\n    this._performStageTasks(this._dataProcessorHandlers, ecModel, payload, {\n      block: true\n    });\n  };\n\n  Scheduler.prototype.performVisualTasks = function (ecModel, payload, opt) {\n    this._performStageTasks(this._visualHandlers, ecModel, payload, opt);\n  };\n\n  Scheduler.prototype._performStageTasks = function (stageHandlers, ecModel, payload, opt) {\n    opt = opt || {};\n    var unfinished = false;\n    var scheduler = this;\n    each(stageHandlers, function (stageHandler, idx) {\n      if (opt.visualType && opt.visualType !== stageHandler.visualType) {\n        return;\n      }\n\n      var stageHandlerRecord = scheduler._stageTaskMap.get(stageHandler.uid);\n\n      var seriesTaskMap = stageHandlerRecord.seriesTaskMap;\n      var overallTask = stageHandlerRecord.overallTask;\n\n      if (overallTask) {\n        var overallNeedDirty_1;\n        var agentStubMap = overallTask.agentStubMap;\n        agentStubMap.each(function (stub) {\n          if (needSetDirty(opt, stub)) {\n            stub.dirty();\n            overallNeedDirty_1 = true;\n          }\n        });\n        overallNeedDirty_1 && overallTask.dirty();\n        scheduler.updatePayload(overallTask, payload);\n        var performArgs_1 = scheduler.getPerformArgs(overallTask, opt.block); // Execute stubs firstly, which may set the overall task dirty,\n        // then execute the overall task. And stub will call seriesModel.setData,\n        // which ensures that in the overallTask seriesModel.getData() will not\n        // return incorrect data.\n\n        agentStubMap.each(function (stub) {\n          stub.perform(performArgs_1);\n        });\n\n        if (overallTask.perform(performArgs_1)) {\n          unfinished = true;\n        }\n      } else if (seriesTaskMap) {\n        seriesTaskMap.each(function (task, pipelineId) {\n          if (needSetDirty(opt, task)) {\n            task.dirty();\n          }\n\n          var performArgs = scheduler.getPerformArgs(task, opt.block); // FIXME\n          // if intending to decalare `performRawSeries` in handlers, only\n          // stream-independent (specifically, data item independent) operations can be\n          // performed. Because is a series is filtered, most of the tasks will not\n          // be performed. A stream-dependent operation probably cause wrong biz logic.\n          // Perhaps we should not provide a separate callback for this case instead\n          // of providing the config `performRawSeries`. The stream-dependent operaions\n          // and stream-independent operations should better not be mixed.\n\n          performArgs.skip = !stageHandler.performRawSeries && ecModel.isSeriesFiltered(task.context.model);\n          scheduler.updatePayload(task, payload);\n\n          if (task.perform(performArgs)) {\n            unfinished = true;\n          }\n        });\n      }\n    });\n\n    function needSetDirty(opt, task) {\n      return opt.setDirty && (!opt.dirtyMap || opt.dirtyMap.get(task.__pipeline.id));\n    }\n\n    this.unfinished = unfinished || this.unfinished;\n  };\n\n  Scheduler.prototype.performSeriesTasks = function (ecModel) {\n    var unfinished;\n    ecModel.eachSeries(function (seriesModel) {\n      // Progress to the end for dataInit and dataRestore.\n      unfinished = seriesModel.dataTask.perform() || unfinished;\n    });\n    this.unfinished = unfinished || this.unfinished;\n  };\n\n  Scheduler.prototype.plan = function () {\n    // Travel pipelines, check block.\n    this._pipelineMap.each(function (pipeline) {\n      var task = pipeline.tail;\n\n      do {\n        if (task.__block) {\n          pipeline.blockIndex = task.__idxInPipeline;\n          break;\n        }\n\n        task = task.getUpstream();\n      } while (task);\n    });\n  };\n\n  Scheduler.prototype.updatePayload = function (task, payload) {\n    payload !== 'remain' && (task.context.payload = payload);\n  };\n\n  Scheduler.prototype._createSeriesStageTask = function (stageHandler, stageHandlerRecord, ecModel, api) {\n    var scheduler = this;\n    var oldSeriesTaskMap = stageHandlerRecord.seriesTaskMap; // The count of stages are totally about only several dozen, so\n    // do not need to reuse the map.\n\n    var newSeriesTaskMap = stageHandlerRecord.seriesTaskMap = createHashMap();\n    var seriesType = stageHandler.seriesType;\n    var getTargetSeries = stageHandler.getTargetSeries; // If a stageHandler should cover all series, `createOnAllSeries` should be declared mandatorily,\n    // to avoid some typo or abuse. Otherwise if an extension do not specify a `seriesType`,\n    // it works but it may cause other irrelevant charts blocked.\n\n    if (stageHandler.createOnAllSeries) {\n      ecModel.eachRawSeries(create);\n    } else if (seriesType) {\n      ecModel.eachRawSeriesByType(seriesType, create);\n    } else if (getTargetSeries) {\n      getTargetSeries(ecModel, api).each(create);\n    }\n\n    function create(seriesModel) {\n      var pipelineId = seriesModel.uid; // Init tasks for each seriesModel only once.\n      // Reuse original task instance.\n\n      var task = newSeriesTaskMap.set(pipelineId, oldSeriesTaskMap && oldSeriesTaskMap.get(pipelineId) || createTask({\n        plan: seriesTaskPlan,\n        reset: seriesTaskReset,\n        count: seriesTaskCount\n      }));\n      task.context = {\n        model: seriesModel,\n        ecModel: ecModel,\n        api: api,\n        // PENDING: `useClearVisual` not used?\n        useClearVisual: stageHandler.isVisual && !stageHandler.isLayout,\n        plan: stageHandler.plan,\n        reset: stageHandler.reset,\n        scheduler: scheduler\n      };\n\n      scheduler._pipe(seriesModel, task);\n    }\n  };\n\n  Scheduler.prototype._createOverallStageTask = function (stageHandler, stageHandlerRecord, ecModel, api) {\n    var scheduler = this;\n    var overallTask = stageHandlerRecord.overallTask = stageHandlerRecord.overallTask // For overall task, the function only be called on reset stage.\n    || createTask({\n      reset: overallTaskReset\n    });\n    overallTask.context = {\n      ecModel: ecModel,\n      api: api,\n      overallReset: stageHandler.overallReset,\n      scheduler: scheduler\n    };\n    var oldAgentStubMap = overallTask.agentStubMap; // The count of stages are totally about only several dozen, so\n    // do not need to reuse the map.\n\n    var newAgentStubMap = overallTask.agentStubMap = createHashMap();\n    var seriesType = stageHandler.seriesType;\n    var getTargetSeries = stageHandler.getTargetSeries;\n    var overallProgress = true;\n    var shouldOverallTaskDirty = false; // FIXME:TS never used, so comment it\n    // let modifyOutputEnd = stageHandler.modifyOutputEnd;\n    // An overall task with seriesType detected or has `getTargetSeries`, we add\n    // stub in each pipelines, it will set the overall task dirty when the pipeline\n    // progress. Moreover, to avoid call the overall task each frame (too frequent),\n    // we set the pipeline block.\n\n    var errMsg = '';\n\n    if (process.env.NODE_ENV !== 'production') {\n      errMsg = '\"createOnAllSeries\" do not supported for \"overallReset\", ' + 'becuase it will block all streams.';\n    }\n\n    assert(!stageHandler.createOnAllSeries, errMsg);\n\n    if (seriesType) {\n      ecModel.eachRawSeriesByType(seriesType, createStub);\n    } else if (getTargetSeries) {\n      getTargetSeries(ecModel, api).each(createStub);\n    } // Otherwise, (usually it is legancy case), the overall task will only be\n    // executed when upstream dirty. Otherwise the progressive rendering of all\n    // pipelines will be disabled unexpectedly. But it still needs stubs to receive\n    // dirty info from upsteam.\n    else {\n        overallProgress = false;\n        each(ecModel.getSeries(), createStub);\n      }\n\n    function createStub(seriesModel) {\n      var pipelineId = seriesModel.uid;\n      var stub = newAgentStubMap.set(pipelineId, oldAgentStubMap && oldAgentStubMap.get(pipelineId) || ( // When the result of `getTargetSeries` changed, the overallTask\n      // should be set as dirty and re-performed.\n      shouldOverallTaskDirty = true, createTask({\n        reset: stubReset,\n        onDirty: stubOnDirty\n      })));\n      stub.context = {\n        model: seriesModel,\n        overallProgress: overallProgress // FIXME:TS never used, so comment it\n        // modifyOutputEnd: modifyOutputEnd\n\n      };\n      stub.agent = overallTask;\n      stub.__block = overallProgress;\n\n      scheduler._pipe(seriesModel, stub);\n    }\n\n    if (shouldOverallTaskDirty) {\n      overallTask.dirty();\n    }\n  };\n\n  Scheduler.prototype._pipe = function (seriesModel, task) {\n    var pipelineId = seriesModel.uid;\n\n    var pipeline = this._pipelineMap.get(pipelineId);\n\n    !pipeline.head && (pipeline.head = task);\n    pipeline.tail && pipeline.tail.pipe(task);\n    pipeline.tail = task;\n    task.__idxInPipeline = pipeline.count++;\n    task.__pipeline = pipeline;\n  };\n\n  Scheduler.wrapStageHandler = function (stageHandler, visualType) {\n    if (isFunction(stageHandler)) {\n      stageHandler = {\n        overallReset: stageHandler,\n        seriesType: detectSeriseType(stageHandler)\n      };\n    }\n\n    stageHandler.uid = getUID('stageHandler');\n    visualType && (stageHandler.visualType = visualType);\n    return stageHandler;\n  };\n\n  ;\n  return Scheduler;\n}();\n\nfunction overallTaskReset(context) {\n  context.overallReset(context.ecModel, context.api, context.payload);\n}\n\nfunction stubReset(context) {\n  return context.overallProgress && stubProgress;\n}\n\nfunction stubProgress() {\n  this.agent.dirty();\n  this.getDownstream().dirty();\n}\n\nfunction stubOnDirty() {\n  this.agent && this.agent.dirty();\n}\n\nfunction seriesTaskPlan(context) {\n  return context.plan ? context.plan(context.model, context.ecModel, context.api, context.payload) : null;\n}\n\nfunction seriesTaskReset(context) {\n  if (context.useClearVisual) {\n    context.data.clearAllVisual();\n  }\n\n  var resetDefines = context.resetDefines = normalizeToArray(context.reset(context.model, context.ecModel, context.api, context.payload));\n  return resetDefines.length > 1 ? map(resetDefines, function (v, idx) {\n    return makeSeriesTaskProgress(idx);\n  }) : singleSeriesTaskProgress;\n}\n\nvar singleSeriesTaskProgress = makeSeriesTaskProgress(0);\n\nfunction makeSeriesTaskProgress(resetDefineIdx) {\n  return function (params, context) {\n    var data = context.data;\n    var resetDefine = context.resetDefines[resetDefineIdx];\n\n    if (resetDefine && resetDefine.dataEach) {\n      for (var i = params.start; i < params.end; i++) {\n        resetDefine.dataEach(data, i);\n      }\n    } else if (resetDefine && resetDefine.progress) {\n      resetDefine.progress(params, data);\n    }\n  };\n}\n\nfunction seriesTaskCount(context) {\n  return context.data.count();\n}\n/**\n * Only some legacy stage handlers (usually in echarts extensions) are pure function.\n * To ensure that they can work normally, they should work in block mode, that is,\n * they should not be started util the previous tasks finished. So they cause the\n * progressive rendering disabled. We try to detect the series type, to narrow down\n * the block range to only the series type they concern, but not all series.\n */\n\n\nfunction detectSeriseType(legacyFunc) {\n  seriesType = null;\n\n  try {\n    // Assume there is no async when calling `eachSeriesByType`.\n    legacyFunc(ecModelMock, apiMock);\n  } catch (e) {}\n\n  return seriesType;\n}\n\nvar ecModelMock = {};\nvar apiMock = {};\nvar seriesType;\nmockMethods(ecModelMock, GlobalModel);\nmockMethods(apiMock, ExtensionAPI);\n\necModelMock.eachSeriesByType = ecModelMock.eachRawSeriesByType = function (type) {\n  seriesType = type;\n};\n\necModelMock.eachComponent = function (cond) {\n  if (cond.mainType === 'series' && cond.subType) {\n    seriesType = cond.subType;\n  }\n};\n\nfunction mockMethods(target, Clz) {\n  /* eslint-disable */\n  for (var name_1 in Clz.prototype) {\n    // Do not use hasOwnProperty\n    target[name_1] = noop;\n  }\n  /* eslint-enable */\n\n}\n\nexport default Scheduler;","\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\n\n/**\n * AUTO-GENERATED FILE. DO NOT MODIFY.\n */\n\nimport { __extends } from \"tslib\";\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\nimport * as zrender from 'zrender/lib/zrender';\nimport * as zrUtil from 'zrender/lib/core/util';\nimport * as colorTool from 'zrender/lib/tool/color';\nimport env from 'zrender/lib/core/env';\nimport timsort from 'zrender/lib/core/timsort';\nimport Eventful from 'zrender/lib/core/Eventful';\nimport GlobalModel from '../model/Global';\nimport ExtensionAPI from './ExtensionAPI';\nimport CoordinateSystemManager from './CoordinateSystem';\nimport OptionManager from '../model/OptionManager';\nimport backwardCompat from '../preprocessor/backwardCompat';\nimport dataStack from '../processor/dataStack';\nimport SeriesModel from '../model/Series';\nimport ComponentView from '../view/Component';\nimport ChartView from '../view/Chart';\nimport * as graphic from '../util/graphic';\nimport { getECData } from '../util/innerStore';\nimport { isHighDownDispatcher, HOVER_STATE_EMPHASIS, HOVER_STATE_BLUR, blurSeriesFromHighlightPayload, toggleSelectionFromPayload, updateSeriesElementSelection, getAllSelectedIndices, isSelectChangePayload, isHighDownPayload, HIGHLIGHT_ACTION_TYPE, DOWNPLAY_ACTION_TYPE, SELECT_ACTION_TYPE, UNSELECT_ACTION_TYPE, TOGGLE_SELECT_ACTION_TYPE, savePathStates, enterEmphasis, leaveEmphasis, leaveBlur, enterSelect, leaveSelect, enterBlur, allLeaveBlur, findComponentHighDownDispatchers, blurComponent, handleGlobalMouseOverForHighDown, handleGlboalMouseOutForHighDown } from '../util/states';\nimport * as modelUtil from '../util/model';\nimport { throttle } from '../util/throttle';\nimport { seriesStyleTask, dataStyleTask, dataColorPaletteTask } from '../visual/style';\nimport loadingDefault from '../loading/default';\nimport Scheduler from './Scheduler';\nimport lightTheme from '../theme/light';\nimport darkTheme from '../theme/dark';\nimport { parseClassType } from '../util/clazz';\nimport { ECEventProcessor } from '../util/ECEventProcessor';\nimport { seriesSymbolTask, dataSymbolTask } from '../visual/symbol';\nimport { getVisualFromData, getItemVisualFromData } from '../visual/helper';\nimport LabelManager from '../label/LabelManager';\nimport { deprecateLog, throwError } from '../util/log';\nimport { handleLegacySelectEvents } from '../legacy/dataSelectAction';\nimport { registerExternalTransform } from '../data/helper/transform';\nimport { createLocaleObject, SYSTEM_LANG } from './locale';\nimport { findEventDispatcher } from '../util/event';\nimport decal from '../visual/decal';\nimport geoSourceManager from '../coord/geo/geoSourceManager';\nvar assert = zrUtil.assert;\nvar each = zrUtil.each;\nvar isFunction = zrUtil.isFunction;\nvar isObject = zrUtil.isObject;\nvar indexOf = zrUtil.indexOf;\nvar hasWindow = typeof window !== 'undefined';\nexport var version = '5.1.1';\nexport var dependencies = {\n  zrender: '5.1.0'\n};\nvar TEST_FRAME_REMAIN_TIME = 1;\nvar PRIORITY_PROCESSOR_SERIES_FILTER = 800; // Some data processors depends on the stack result dimension (to calculate data extent).\n// So data stack stage should be in front of data processing stage.\n\nvar PRIORITY_PROCESSOR_DATASTACK = 900; // \"Data filter\" will block the stream, so it should be\n// put at the begining of data processing.\n\nvar PRIORITY_PROCESSOR_FILTER = 1000;\nvar PRIORITY_PROCESSOR_DEFAULT = 2000;\nvar PRIORITY_PROCESSOR_STATISTIC = 5000;\nvar PRIORITY_VISUAL_LAYOUT = 1000;\nvar PRIORITY_VISUAL_PROGRESSIVE_LAYOUT = 1100;\nvar PRIORITY_VISUAL_GLOBAL = 2000;\nvar PRIORITY_VISUAL_CHART = 3000;\nvar PRIORITY_VISUAL_COMPONENT = 4000; // Visual property in data. Greater than `PRIORITY_VISUAL_COMPONENT` to enable to\n// overwrite the viusal result of component (like `visualMap`)\n// using data item specific setting (like itemStyle.xxx on data item)\n\nvar PRIORITY_VISUAL_CHART_DATA_CUSTOM = 4500; // Greater than `PRIORITY_VISUAL_CHART_DATA_CUSTOM` to enable to layout based on\n// visual result like `symbolSize`.\n\nvar PRIORITY_VISUAL_POST_CHART_LAYOUT = 4600;\nvar PRIORITY_VISUAL_BRUSH = 5000;\nvar PRIORITY_VISUAL_ARIA = 6000;\nvar PRIORITY_VISUAL_DECAL = 7000;\nexport var PRIORITY = {\n  PROCESSOR: {\n    FILTER: PRIORITY_PROCESSOR_FILTER,\n    SERIES_FILTER: PRIORITY_PROCESSOR_SERIES_FILTER,\n    STATISTIC: PRIORITY_PROCESSOR_STATISTIC\n  },\n  VISUAL: {\n    LAYOUT: PRIORITY_VISUAL_LAYOUT,\n    PROGRESSIVE_LAYOUT: PRIORITY_VISUAL_PROGRESSIVE_LAYOUT,\n    GLOBAL: PRIORITY_VISUAL_GLOBAL,\n    CHART: PRIORITY_VISUAL_CHART,\n    POST_CHART_LAYOUT: PRIORITY_VISUAL_POST_CHART_LAYOUT,\n    COMPONENT: PRIORITY_VISUAL_COMPONENT,\n    BRUSH: PRIORITY_VISUAL_BRUSH,\n    CHART_ITEM: PRIORITY_VISUAL_CHART_DATA_CUSTOM,\n    ARIA: PRIORITY_VISUAL_ARIA,\n    DECAL: PRIORITY_VISUAL_DECAL\n  }\n}; // Main process have three entries: `setOption`, `dispatchAction` and `resize`,\n// where they must not be invoked nestedly, except the only case: invoke\n// dispatchAction with updateMethod \"none\" in main process.\n// This flag is used to carry out this rule.\n// All events will be triggered out side main process (i.e. when !this[IN_MAIN_PROCESS]).\n\nvar IN_MAIN_PROCESS_KEY = '__flagInMainProcess';\nvar OPTION_UPDATED_KEY = '__optionUpdated';\nvar STATUS_NEEDS_UPDATE_KEY = '__needsUpdateStatus';\nvar ACTION_REG = /^[a-zA-Z0-9_]+$/;\nvar CONNECT_STATUS_KEY = '__connectUpdateStatus';\nvar CONNECT_STATUS_PENDING = 0;\nvar CONNECT_STATUS_UPDATING = 1;\nvar CONNECT_STATUS_UPDATED = 2;\n;\n;\n;\n\nfunction createRegisterEventWithLowercaseECharts(method) {\n  return function () {\n    var args = [];\n\n    for (var _i = 0; _i < arguments.length; _i++) {\n      args[_i] = arguments[_i];\n    }\n\n    if (this.isDisposed()) {\n      disposedWarning(this.id);\n      return;\n    }\n\n    return toLowercaseNameAndCallEventful(this, method, args);\n  };\n}\n\nfunction createRegisterEventWithLowercaseMessageCenter(method) {\n  return function () {\n    var args = [];\n\n    for (var _i = 0; _i < arguments.length; _i++) {\n      args[_i] = arguments[_i];\n    }\n\n    return toLowercaseNameAndCallEventful(this, method, args);\n  };\n}\n\nfunction toLowercaseNameAndCallEventful(host, method, args) {\n  // `args[0]` is event name. Event name is all lowercase.\n  args[0] = args[0] && args[0].toLowerCase();\n  return Eventful.prototype[method].apply(host, args);\n}\n\nvar MessageCenter =\n/** @class */\nfunction (_super) {\n  __extends(MessageCenter, _super);\n\n  function MessageCenter() {\n    return _super !== null && _super.apply(this, arguments) || this;\n  }\n\n  return MessageCenter;\n}(Eventful);\n\nvar messageCenterProto = MessageCenter.prototype;\nmessageCenterProto.on = createRegisterEventWithLowercaseMessageCenter('on');\nmessageCenterProto.off = createRegisterEventWithLowercaseMessageCenter('off'); // ---------------------------------------\n// Internal method names for class ECharts\n// ---------------------------------------\n\nvar prepare;\nvar prepareView;\nvar updateDirectly;\nvar updateMethods;\nvar doConvertPixel;\nvar updateStreamModes;\nvar doDispatchAction;\nvar flushPendingActions;\nvar triggerUpdatedEvent;\nvar bindRenderedEvent;\nvar bindMouseEvent;\nvar clearColorPalette;\nvar render;\nvar renderComponents;\nvar renderSeries;\nvar performPostUpdateFuncs;\nvar createExtensionAPI;\nvar enableConnect;\nvar setTransitionOpt;\nvar markStatusToUpdate;\nvar applyChangedStates;\n\nvar ECharts =\n/** @class */\nfunction (_super) {\n  __extends(ECharts, _super);\n\n  function ECharts(dom, // Theme name or themeOption.\n  theme, opts) {\n    var _this = _super.call(this, new ECEventProcessor()) || this;\n\n    _this._chartsViews = [];\n    _this._chartsMap = {};\n    _this._componentsViews = [];\n    _this._componentsMap = {}; // Can't dispatch action during rendering procedure\n\n    _this._pendingActions = [];\n    opts = opts || {}; // Get theme by name\n\n    if (typeof theme === 'string') {\n      theme = themeStorage[theme];\n    }\n\n    _this._dom = dom;\n    var defaultRenderer = 'canvas';\n    var defaultUseDirtyRect = false;\n\n    if (process.env.NODE_ENV !== 'production') {\n      var root =\n      /* eslint-disable-next-line */\n      hasWindow ? window : global;\n      defaultRenderer = root.__ECHARTS__DEFAULT__RENDERER__ || defaultRenderer;\n      var devUseDirtyRect = root.__ECHARTS__DEFAULT__USE_DIRTY_RECT__;\n      defaultUseDirtyRect = devUseDirtyRect == null ? defaultUseDirtyRect : devUseDirtyRect;\n    }\n\n    var zr = _this._zr = zrender.init(dom, {\n      renderer: opts.renderer || defaultRenderer,\n      devicePixelRatio: opts.devicePixelRatio,\n      width: opts.width,\n      height: opts.height,\n      useDirtyRect: opts.useDirtyRect == null ? defaultUseDirtyRect : opts.useDirtyRect\n    }); // Expect 60 fps.\n\n    _this._throttledZrFlush = throttle(zrUtil.bind(zr.flush, zr), 17);\n    theme = zrUtil.clone(theme);\n    theme && backwardCompat(theme, true);\n    _this._theme = theme;\n    _this._locale = createLocaleObject(opts.locale || SYSTEM_LANG);\n    _this._coordSysMgr = new CoordinateSystemManager();\n    var api = _this._api = createExtensionAPI(_this); // Sort on demand\n\n    function prioritySortFunc(a, b) {\n      return a.__prio - b.__prio;\n    }\n\n    timsort(visualFuncs, prioritySortFunc);\n    timsort(dataProcessorFuncs, prioritySortFunc);\n    _this._scheduler = new Scheduler(_this, api, dataProcessorFuncs, visualFuncs);\n    _this._messageCenter = new MessageCenter();\n    _this._labelManager = new LabelManager(); // Init mouse events\n\n    _this._initEvents(); // In case some people write `window.onresize = chart.resize`\n\n\n    _this.resize = zrUtil.bind(_this.resize, _this);\n    zr.animation.on('frame', _this._onframe, _this);\n    bindRenderedEvent(zr, _this);\n    bindMouseEvent(zr, _this); // ECharts instance can be used as value.\n\n    zrUtil.setAsPrimitive(_this);\n    return _this;\n  }\n\n  ECharts.prototype._onframe = function () {\n    if (this._disposed) {\n      return;\n    }\n\n    applyChangedStates(this);\n    var scheduler = this._scheduler; // Lazy update\n\n    if (this[OPTION_UPDATED_KEY]) {\n      var silent = this[OPTION_UPDATED_KEY].silent;\n      this[IN_MAIN_PROCESS_KEY] = true;\n      prepare(this);\n      updateMethods.update.call(this); // At present, in each frame, zrender performs:\n      //   (1) animation step forward.\n      //   (2) trigger('frame') (where this `_onframe` is called)\n      //   (3) zrender flush (render).\n      // If we do nothing here, since we use `setToFinal: true`, the step (3) above\n      // will render the final state of the elements before the real animation started.\n\n      this._zr.flush();\n\n      this[IN_MAIN_PROCESS_KEY] = false;\n      this[OPTION_UPDATED_KEY] = false;\n      flushPendingActions.call(this, silent);\n      triggerUpdatedEvent.call(this, silent);\n    } // Avoid do both lazy update and progress in one frame.\n    else if (scheduler.unfinished) {\n        // Stream progress.\n        var remainTime = TEST_FRAME_REMAIN_TIME;\n        var ecModel = this._model;\n        var api = this._api;\n        scheduler.unfinished = false;\n\n        do {\n          var startTime = +new Date();\n          scheduler.performSeriesTasks(ecModel); // Currently dataProcessorFuncs do not check threshold.\n\n          scheduler.performDataProcessorTasks(ecModel);\n          updateStreamModes(this, ecModel); // Do not update coordinate system here. Because that coord system update in\n          // each frame is not a good user experience. So we follow the rule that\n          // the extent of the coordinate system is determin in the first frame (the\n          // frame is executed immedietely after task reset.\n          // this._coordSysMgr.update(ecModel, api);\n          // console.log('--- ec frame visual ---', remainTime);\n\n          scheduler.performVisualTasks(ecModel);\n          renderSeries(this, this._model, api, 'remain');\n          remainTime -= +new Date() - startTime;\n        } while (remainTime > 0 && scheduler.unfinished); // Call flush explicitly for trigger finished event.\n\n\n        if (!scheduler.unfinished) {\n          this._zr.flush();\n        } // Else, zr flushing be ensue within the same frame,\n        // because zr flushing is after onframe event.\n\n      }\n  };\n\n  ECharts.prototype.getDom = function () {\n    return this._dom;\n  };\n\n  ECharts.prototype.getId = function () {\n    return this.id;\n  };\n\n  ECharts.prototype.getZr = function () {\n    return this._zr;\n  };\n  /* eslint-disable-next-line */\n\n\n  ECharts.prototype.setOption = function (option, notMerge, lazyUpdate) {\n    if (process.env.NODE_ENV !== 'production') {\n      assert(!this[IN_MAIN_PROCESS_KEY], '`setOption` should not be called during main process.');\n    }\n\n    if (this._disposed) {\n      disposedWarning(this.id);\n      return;\n    }\n\n    var silent;\n    var replaceMerge;\n    var transitionOpt;\n\n    if (isObject(notMerge)) {\n      lazyUpdate = notMerge.lazyUpdate;\n      silent = notMerge.silent;\n      replaceMerge = notMerge.replaceMerge;\n      transitionOpt = notMerge.transition;\n      notMerge = notMerge.notMerge;\n    }\n\n    this[IN_MAIN_PROCESS_KEY] = true;\n\n    if (!this._model || notMerge) {\n      var optionManager = new OptionManager(this._api);\n      var theme = this._theme;\n      var ecModel = this._model = new GlobalModel();\n      ecModel.scheduler = this._scheduler;\n      ecModel.init(null, null, null, theme, this._locale, optionManager);\n    }\n\n    this._model.setOption(option, {\n      replaceMerge: replaceMerge\n    }, optionPreprocessorFuncs);\n\n    setTransitionOpt(this, transitionOpt);\n\n    if (lazyUpdate) {\n      this[OPTION_UPDATED_KEY] = {\n        silent: silent\n      };\n      this[IN_MAIN_PROCESS_KEY] = false; // `setOption(option, {lazyMode: true})` may be called when zrender has been slept.\n      // It should wake it up to make sure zrender start to render at the next frame.\n\n      this.getZr().wakeUp();\n    } else {\n      prepare(this);\n      updateMethods.update.call(this); // Ensure zr refresh sychronously, and then pixel in canvas can be\n      // fetched after `setOption`.\n\n      this._zr.flush();\n\n      this[OPTION_UPDATED_KEY] = false;\n      this[IN_MAIN_PROCESS_KEY] = false;\n      flushPendingActions.call(this, silent);\n      triggerUpdatedEvent.call(this, silent);\n    }\n  };\n  /**\n   * @DEPRECATED\n   */\n\n\n  ECharts.prototype.setTheme = function () {\n    console.error('ECharts#setTheme() is DEPRECATED in ECharts 3.0');\n  }; // We don't want developers to use getModel directly.\n\n\n  ECharts.prototype.getModel = function () {\n    return this._model;\n  };\n\n  ECharts.prototype.getOption = function () {\n    return this._model && this._model.getOption();\n  };\n\n  ECharts.prototype.getWidth = function () {\n    return this._zr.getWidth();\n  };\n\n  ECharts.prototype.getHeight = function () {\n    return this._zr.getHeight();\n  };\n\n  ECharts.prototype.getDevicePixelRatio = function () {\n    return this._zr.painter.dpr\n    /* eslint-disable-next-line */\n    || hasWindow && window.devicePixelRatio || 1;\n  };\n  /**\n   * Get canvas which has all thing rendered\n   */\n\n\n  ECharts.prototype.getRenderedCanvas = function (opts) {\n    if (!env.canvasSupported) {\n      return;\n    }\n\n    opts = zrUtil.extend({}, opts || {});\n    opts.pixelRatio = opts.pixelRatio || this.getDevicePixelRatio();\n    opts.backgroundColor = opts.backgroundColor || this._model.get('backgroundColor');\n    var zr = this._zr; // let list = zr.storage.getDisplayList();\n    // Stop animations\n    // Never works before in init animation, so remove it.\n    // zrUtil.each(list, function (el) {\n    //     el.stopAnimation(true);\n    // });\n\n    return zr.painter.getRenderedCanvas(opts);\n  };\n  /**\n   * Get svg data url\n   */\n\n\n  ECharts.prototype.getSvgDataURL = function () {\n    if (!env.svgSupported) {\n      return;\n    }\n\n    var zr = this._zr;\n    var list = zr.storage.getDisplayList(); // Stop animations\n\n    zrUtil.each(list, function (el) {\n      el.stopAnimation(null, true);\n    });\n    return zr.painter.toDataURL();\n  };\n\n  ECharts.prototype.getDataURL = function (opts) {\n    if (this._disposed) {\n      disposedWarning(this.id);\n      return;\n    }\n\n    opts = opts || {};\n    var excludeComponents = opts.excludeComponents;\n    var ecModel = this._model;\n    var excludesComponentViews = [];\n    var self = this;\n    each(excludeComponents, function (componentType) {\n      ecModel.eachComponent({\n        mainType: componentType\n      }, function (component) {\n        var view = self._componentsMap[component.__viewId];\n\n        if (!view.group.ignore) {\n          excludesComponentViews.push(view);\n          view.group.ignore = true;\n        }\n      });\n    });\n    var url = this._zr.painter.getType() === 'svg' ? this.getSvgDataURL() : this.getRenderedCanvas(opts).toDataURL('image/' + (opts && opts.type || 'png'));\n    each(excludesComponentViews, function (view) {\n      view.group.ignore = false;\n    });\n    return url;\n  };\n\n  ECharts.prototype.getConnectedDataURL = function (opts) {\n    if (this._disposed) {\n      disposedWarning(this.id);\n      return;\n    }\n\n    if (!env.canvasSupported) {\n      return;\n    }\n\n    var isSvg = opts.type === 'svg';\n    var groupId = this.group;\n    var mathMin = Math.min;\n    var mathMax = Math.max;\n    var MAX_NUMBER = Infinity;\n\n    if (connectedGroups[groupId]) {\n      var left_1 = MAX_NUMBER;\n      var top_1 = MAX_NUMBER;\n      var right_1 = -MAX_NUMBER;\n      var bottom_1 = -MAX_NUMBER;\n      var canvasList_1 = [];\n      var dpr_1 = opts && opts.pixelRatio || this.getDevicePixelRatio();\n      zrUtil.each(instances, function (chart, id) {\n        if (chart.group === groupId) {\n          var canvas = isSvg ? chart.getZr().painter.getSvgDom().innerHTML : chart.getRenderedCanvas(zrUtil.clone(opts));\n          var boundingRect = chart.getDom().getBoundingClientRect();\n          left_1 = mathMin(boundingRect.left, left_1);\n          top_1 = mathMin(boundingRect.top, top_1);\n          right_1 = mathMax(boundingRect.right, right_1);\n          bottom_1 = mathMax(boundingRect.bottom, bottom_1);\n          canvasList_1.push({\n            dom: canvas,\n            left: boundingRect.left,\n            top: boundingRect.top\n          });\n        }\n      });\n      left_1 *= dpr_1;\n      top_1 *= dpr_1;\n      right_1 *= dpr_1;\n      bottom_1 *= dpr_1;\n      var width = right_1 - left_1;\n      var height = bottom_1 - top_1;\n      var targetCanvas = zrUtil.createCanvas();\n      var zr_1 = zrender.init(targetCanvas, {\n        renderer: isSvg ? 'svg' : 'canvas'\n      });\n      zr_1.resize({\n        width: width,\n        height: height\n      });\n\n      if (isSvg) {\n        var content_1 = '';\n        each(canvasList_1, function (item) {\n          var x = item.left - left_1;\n          var y = item.top - top_1;\n          content_1 += '<g transform=\"translate(' + x + ',' + y + ')\">' + item.dom + '</g>';\n        });\n        zr_1.painter.getSvgRoot().innerHTML = content_1;\n\n        if (opts.connectedBackgroundColor) {\n          zr_1.painter.setBackgroundColor(opts.connectedBackgroundColor);\n        }\n\n        zr_1.refreshImmediately();\n        return zr_1.painter.toDataURL();\n      } else {\n        // Background between the charts\n        if (opts.connectedBackgroundColor) {\n          zr_1.add(new graphic.Rect({\n            shape: {\n              x: 0,\n              y: 0,\n              width: width,\n              height: height\n            },\n            style: {\n              fill: opts.connectedBackgroundColor\n            }\n          }));\n        }\n\n        each(canvasList_1, function (item) {\n          var img = new graphic.Image({\n            style: {\n              x: item.left * dpr_1 - left_1,\n              y: item.top * dpr_1 - top_1,\n              image: item.dom\n            }\n          });\n          zr_1.add(img);\n        });\n        zr_1.refreshImmediately();\n        return targetCanvas.toDataURL('image/' + (opts && opts.type || 'png'));\n      }\n    } else {\n      return this.getDataURL(opts);\n    }\n  };\n\n  ECharts.prototype.convertToPixel = function (finder, value) {\n    return doConvertPixel(this, 'convertToPixel', finder, value);\n  };\n\n  ECharts.prototype.convertFromPixel = function (finder, value) {\n    return doConvertPixel(this, 'convertFromPixel', finder, value);\n  };\n  /**\n   * Is the specified coordinate systems or components contain the given pixel point.\n   * @param {Array|number} value\n   * @return {boolean} result\n   */\n\n\n  ECharts.prototype.containPixel = function (finder, value) {\n    if (this._disposed) {\n      disposedWarning(this.id);\n      return;\n    }\n\n    var ecModel = this._model;\n    var result;\n    var findResult = modelUtil.parseFinder(ecModel, finder);\n    zrUtil.each(findResult, function (models, key) {\n      key.indexOf('Models') >= 0 && zrUtil.each(models, function (model) {\n        var coordSys = model.coordinateSystem;\n\n        if (coordSys && coordSys.containPoint) {\n          result = result || !!coordSys.containPoint(value);\n        } else if (key === 'seriesModels') {\n          var view = this._chartsMap[model.__viewId];\n\n          if (view && view.containPoint) {\n            result = result || view.containPoint(value, model);\n          } else {\n            if (process.env.NODE_ENV !== 'production') {\n              console.warn(key + ': ' + (view ? 'The found component do not support containPoint.' : 'No view mapping to the found component.'));\n            }\n          }\n        } else {\n          if (process.env.NODE_ENV !== 'production') {\n            console.warn(key + ': containPoint is not supported');\n          }\n        }\n      }, this);\n    }, this);\n    return !!result;\n  };\n  /**\n   * Get visual from series or data.\n   * @param finder\n   *        If string, e.g., 'series', means {seriesIndex: 0}.\n   *        If Object, could contain some of these properties below:\n   *        {\n   *            seriesIndex / seriesId / seriesName,\n   *            dataIndex / dataIndexInside\n   *        }\n   *        If dataIndex is not specified, series visual will be fetched,\n   *        but not data item visual.\n   *        If all of seriesIndex, seriesId, seriesName are not specified,\n   *        visual will be fetched from first series.\n   * @param visualType 'color', 'symbol', 'symbolSize'\n   */\n\n\n  ECharts.prototype.getVisual = function (finder, visualType) {\n    var ecModel = this._model;\n    var parsedFinder = modelUtil.parseFinder(ecModel, finder, {\n      defaultMainType: 'series'\n    });\n    var seriesModel = parsedFinder.seriesModel;\n\n    if (process.env.NODE_ENV !== 'production') {\n      if (!seriesModel) {\n        console.warn('There is no specified seires model');\n      }\n    }\n\n    var data = seriesModel.getData();\n    var dataIndexInside = parsedFinder.hasOwnProperty('dataIndexInside') ? parsedFinder.dataIndexInside : parsedFinder.hasOwnProperty('dataIndex') ? data.indexOfRawIndex(parsedFinder.dataIndex) : null;\n    return dataIndexInside != null ? getItemVisualFromData(data, dataIndexInside, visualType) : getVisualFromData(data, visualType);\n  };\n  /**\n   * Get view of corresponding component model\n   */\n\n\n  ECharts.prototype.getViewOfComponentModel = function (componentModel) {\n    return this._componentsMap[componentModel.__viewId];\n  };\n  /**\n   * Get view of corresponding series model\n   */\n\n\n  ECharts.prototype.getViewOfSeriesModel = function (seriesModel) {\n    return this._chartsMap[seriesModel.__viewId];\n  };\n\n  ECharts.prototype._initEvents = function () {\n    var _this = this;\n\n    each(MOUSE_EVENT_NAMES, function (eveName) {\n      var handler = function (e) {\n        var ecModel = _this.getModel();\n\n        var el = e.target;\n        var params;\n        var isGlobalOut = eveName === 'globalout'; // no e.target when 'globalout'.\n\n        if (isGlobalOut) {\n          params = {};\n        } else {\n          el && findEventDispatcher(el, function (parent) {\n            var ecData = getECData(parent);\n\n            if (ecData && ecData.dataIndex != null) {\n              var dataModel = ecData.dataModel || ecModel.getSeriesByIndex(ecData.seriesIndex);\n              params = dataModel && dataModel.getDataParams(ecData.dataIndex, ecData.dataType) || {};\n              return true;\n            } // If element has custom eventData of components\n            else if (ecData.eventData) {\n                params = zrUtil.extend({}, ecData.eventData);\n                return true;\n              }\n          }, true);\n        } // Contract: if params prepared in mouse event,\n        // these properties must be specified:\n        // {\n        //    componentType: string (component main type)\n        //    componentIndex: number\n        // }\n        // Otherwise event query can not work.\n\n\n        if (params) {\n          var componentType = params.componentType;\n          var componentIndex = params.componentIndex; // Special handling for historic reason: when trigger by\n          // markLine/markPoint/markArea, the componentType is\n          // 'markLine'/'markPoint'/'markArea', but we should better\n          // enable them to be queried by seriesIndex, since their\n          // option is set in each series.\n\n          if (componentType === 'markLine' || componentType === 'markPoint' || componentType === 'markArea') {\n            componentType = 'series';\n            componentIndex = params.seriesIndex;\n          }\n\n          var model = componentType && componentIndex != null && ecModel.getComponent(componentType, componentIndex);\n          var view = model && _this[model.mainType === 'series' ? '_chartsMap' : '_componentsMap'][model.__viewId];\n\n          if (process.env.NODE_ENV !== 'production') {\n            // `event.componentType` and `event[componentTpype + 'Index']` must not\n            // be missed, otherwise there is no way to distinguish source component.\n            // See `dataFormat.getDataParams`.\n            if (!isGlobalOut && !(model && view)) {\n              console.warn('model or view can not be found by params');\n            }\n          }\n\n          params.event = e;\n          params.type = eveName;\n          _this._$eventProcessor.eventInfo = {\n            targetEl: el,\n            packedEvent: params,\n            model: model,\n            view: view\n          };\n\n          _this.trigger(eveName, params);\n        }\n      }; // Consider that some component (like tooltip, brush, ...)\n      // register zr event handler, but user event handler might\n      // do anything, such as call `setOption` or `dispatchAction`,\n      // which probably update any of the content and probably\n      // cause problem if it is called previous other inner handlers.\n\n\n      handler.zrEventfulCallAtLast = true;\n\n      _this._zr.on(eveName, handler, _this);\n    });\n    each(eventActionMap, function (actionType, eventType) {\n      _this._messageCenter.on(eventType, function (event) {\n        this.trigger(eventType, event);\n      }, _this);\n    }); // Extra events\n    // TODO register?\n\n    each(['selectchanged'], function (eventType) {\n      _this._messageCenter.on(eventType, function (event) {\n        this.trigger(eventType, event);\n      }, _this);\n    });\n    handleLegacySelectEvents(this._messageCenter, this, this._api);\n  };\n\n  ECharts.prototype.isDisposed = function () {\n    return this._disposed;\n  };\n\n  ECharts.prototype.clear = function () {\n    if (this._disposed) {\n      disposedWarning(this.id);\n      return;\n    }\n\n    this.setOption({\n      series: []\n    }, true);\n  };\n\n  ECharts.prototype.dispose = function () {\n    if (this._disposed) {\n      disposedWarning(this.id);\n      return;\n    }\n\n    this._disposed = true;\n    modelUtil.setAttribute(this.getDom(), DOM_ATTRIBUTE_KEY, '');\n    var api = this._api;\n    var ecModel = this._model;\n    each(this._componentsViews, function (component) {\n      component.dispose(ecModel, api);\n    });\n    each(this._chartsViews, function (chart) {\n      chart.dispose(ecModel, api);\n    }); // Dispose after all views disposed\n\n    this._zr.dispose();\n\n    delete instances[this.id];\n  };\n  /**\n   * Resize the chart\n   */\n\n\n  ECharts.prototype.resize = function (opts) {\n    if (process.env.NODE_ENV !== 'production') {\n      assert(!this[IN_MAIN_PROCESS_KEY], '`resize` should not be called during main process.');\n    }\n\n    if (this._disposed) {\n      disposedWarning(this.id);\n      return;\n    }\n\n    this._zr.resize(opts);\n\n    var ecModel = this._model; // Resize loading effect\n\n    this._loadingFX && this._loadingFX.resize();\n\n    if (!ecModel) {\n      return;\n    }\n\n    var optionChanged = ecModel.resetOption('media');\n    var silent = opts && opts.silent;\n    this[IN_MAIN_PROCESS_KEY] = true;\n    optionChanged && prepare(this);\n    updateMethods.update.call(this, {\n      type: 'resize',\n      animation: zrUtil.extend({\n        // Disable animation\n        duration: 0\n      }, opts && opts.animation)\n    });\n    this[IN_MAIN_PROCESS_KEY] = false;\n    flushPendingActions.call(this, silent);\n    triggerUpdatedEvent.call(this, silent);\n  };\n\n  ECharts.prototype.showLoading = function (name, cfg) {\n    if (this._disposed) {\n      disposedWarning(this.id);\n      return;\n    }\n\n    if (isObject(name)) {\n      cfg = name;\n      name = '';\n    }\n\n    name = name || 'default';\n    this.hideLoading();\n\n    if (!loadingEffects[name]) {\n      if (process.env.NODE_ENV !== 'production') {\n        console.warn('Loading effects ' + name + ' not exists.');\n      }\n\n      return;\n    }\n\n    var el = loadingEffects[name](this._api, cfg);\n    var zr = this._zr;\n    this._loadingFX = el;\n    zr.add(el);\n  };\n  /**\n   * Hide loading effect\n   */\n\n\n  ECharts.prototype.hideLoading = function () {\n    if (this._disposed) {\n      disposedWarning(this.id);\n      return;\n    }\n\n    this._loadingFX && this._zr.remove(this._loadingFX);\n    this._loadingFX = null;\n  };\n\n  ECharts.prototype.makeActionFromEvent = function (eventObj) {\n    var payload = zrUtil.extend({}, eventObj);\n    payload.type = eventActionMap[eventObj.type];\n    return payload;\n  };\n  /**\n   * @param opt If pass boolean, means opt.silent\n   * @param opt.silent Default `false`. Whether trigger events.\n   * @param opt.flush Default `undefined`.\n   *        true: Flush immediately, and then pixel in canvas can be fetched\n   *            immediately. Caution: it might affect performance.\n   *        false: Not flush.\n   *        undefined: Auto decide whether perform flush.\n   */\n\n\n  ECharts.prototype.dispatchAction = function (payload, opt) {\n    if (this._disposed) {\n      disposedWarning(this.id);\n      return;\n    }\n\n    if (!isObject(opt)) {\n      opt = {\n        silent: !!opt\n      };\n    }\n\n    if (!actions[payload.type]) {\n      return;\n    } // Avoid dispatch action before setOption. Especially in `connect`.\n\n\n    if (!this._model) {\n      return;\n    } // May dispatchAction in rendering procedure\n\n\n    if (this[IN_MAIN_PROCESS_KEY]) {\n      this._pendingActions.push(payload);\n\n      return;\n    }\n\n    var silent = opt.silent;\n    doDispatchAction.call(this, payload, silent);\n    var flush = opt.flush;\n\n    if (flush) {\n      this._zr.flush();\n    } else if (flush !== false && env.browser.weChat) {\n      // In WeChat embeded browser, `requestAnimationFrame` and `setInterval`\n      // hang when sliding page (on touch event), which cause that zr does not\n      // refresh util user interaction finished, which is not expected.\n      // But `dispatchAction` may be called too frequently when pan on touch\n      // screen, which impacts performance if do not throttle them.\n      this._throttledZrFlush();\n    }\n\n    flushPendingActions.call(this, silent);\n    triggerUpdatedEvent.call(this, silent);\n  };\n\n  ECharts.prototype.updateLabelLayout = function () {\n    var labelManager = this._labelManager;\n    labelManager.updateLayoutConfig(this._api);\n    labelManager.layout(this._api);\n    labelManager.processLabelsOverall();\n  };\n\n  ECharts.prototype.appendData = function (params) {\n    if (this._disposed) {\n      disposedWarning(this.id);\n      return;\n    }\n\n    var seriesIndex = params.seriesIndex;\n    var ecModel = this.getModel();\n    var seriesModel = ecModel.getSeriesByIndex(seriesIndex);\n\n    if (process.env.NODE_ENV !== 'production') {\n      assert(params.data && seriesModel);\n    }\n\n    seriesModel.appendData(params); // Note: `appendData` does not support that update extent of coordinate\n    // system, util some scenario require that. In the expected usage of\n    // `appendData`, the initial extent of coordinate system should better\n    // be fixed by axis `min`/`max` setting or initial data, otherwise if\n    // the extent changed while `appendData`, the location of the painted\n    // graphic elements have to be changed, which make the usage of\n    // `appendData` meaningless.\n\n    this._scheduler.unfinished = true;\n    this.getZr().wakeUp();\n  }; // A work around for no `internal` modifier in ts yet but\n  // need to strictly hide private methods to JS users.\n\n\n  ECharts.internalField = function () {\n    prepare = function (ecIns) {\n      var scheduler = ecIns._scheduler;\n      scheduler.restorePipelines(ecIns._model);\n      scheduler.prepareStageTasks();\n      prepareView(ecIns, true);\n      prepareView(ecIns, false);\n      scheduler.plan();\n    };\n    /**\n     * Prepare view instances of charts and components\n     */\n\n\n    prepareView = function (ecIns, isComponent) {\n      var ecModel = ecIns._model;\n      var scheduler = ecIns._scheduler;\n      var viewList = isComponent ? ecIns._componentsViews : ecIns._chartsViews;\n      var viewMap = isComponent ? ecIns._componentsMap : ecIns._chartsMap;\n      var zr = ecIns._zr;\n      var api = ecIns._api;\n\n      for (var i = 0; i < viewList.length; i++) {\n        viewList[i].__alive = false;\n      }\n\n      isComponent ? ecModel.eachComponent(function (componentType, model) {\n        componentType !== 'series' && doPrepare(model);\n      }) : ecModel.eachSeries(doPrepare);\n\n      function doPrepare(model) {\n        // By defaut view will be reused if possible for the case that `setOption` with \"notMerge\"\n        // mode and need to enable transition animation. (Usually, when they have the same id, or\n        // especially no id but have the same type & name & index. See the `model.id` generation\n        // rule in `makeIdAndName` and `viewId` generation rule here).\n        // But in `replaceMerge` mode, this feature should be able to disabled when it is clear that\n        // the new model has nothing to do with the old model.\n        var requireNewView = model.__requireNewView; // This command should not work twice.\n\n        model.__requireNewView = false; // Consider: id same and type changed.\n\n        var viewId = '_ec_' + model.id + '_' + model.type;\n        var view = !requireNewView && viewMap[viewId];\n\n        if (!view) {\n          var classType = parseClassType(model.type);\n          var Clazz = isComponent ? ComponentView.getClass(classType.main, classType.sub) : // FIXME:TS\n          // (ChartView as ChartViewConstructor).getClass('series', classType.sub)\n          // For backward compat, still support a chart type declared as only subType\n          // like \"liquidfill\", but recommend \"series.liquidfill\"\n          // But need a base class to make a type series.\n          ChartView.getClass(classType.sub);\n\n          if (process.env.NODE_ENV !== 'production') {\n            assert(Clazz, classType.sub + ' does not exist.');\n          }\n\n          view = new Clazz();\n          view.init(ecModel, api);\n          viewMap[viewId] = view;\n          viewList.push(view);\n          zr.add(view.group);\n        }\n\n        model.__viewId = view.__id = viewId;\n        view.__alive = true;\n        view.__model = model;\n        view.group.__ecComponentInfo = {\n          mainType: model.mainType,\n          index: model.componentIndex\n        };\n        !isComponent && scheduler.prepareView(view, model, ecModel, api);\n      }\n\n      for (var i = 0; i < viewList.length;) {\n        var view = viewList[i];\n\n        if (!view.__alive) {\n          !isComponent && view.renderTask.dispose();\n          zr.remove(view.group);\n          view.dispose(ecModel, api);\n          viewList.splice(i, 1);\n\n          if (viewMap[view.__id] === view) {\n            delete viewMap[view.__id];\n          }\n\n          view.__id = view.group.__ecComponentInfo = null;\n        } else {\n          i++;\n        }\n      }\n    };\n\n    updateDirectly = function (ecIns, method, payload, mainType, subType) {\n      var ecModel = ecIns._model;\n      ecModel.setUpdatePayload(payload); // broadcast\n\n      if (!mainType) {\n        // FIXME\n        // Chart will not be update directly here, except set dirty.\n        // But there is no such scenario now.\n        each([].concat(ecIns._componentsViews).concat(ecIns._chartsViews), callView);\n        return;\n      }\n\n      var query = {};\n      query[mainType + 'Id'] = payload[mainType + 'Id'];\n      query[mainType + 'Index'] = payload[mainType + 'Index'];\n      query[mainType + 'Name'] = payload[mainType + 'Name'];\n      var condition = {\n        mainType: mainType,\n        query: query\n      };\n      subType && (condition.subType = subType); // subType may be '' by parseClassType;\n\n      var excludeSeriesId = payload.excludeSeriesId;\n      var excludeSeriesIdMap;\n\n      if (excludeSeriesId != null) {\n        excludeSeriesIdMap = zrUtil.createHashMap();\n        each(modelUtil.normalizeToArray(excludeSeriesId), function (id) {\n          var modelId = modelUtil.convertOptionIdName(id, null);\n\n          if (modelId != null) {\n            excludeSeriesIdMap.set(modelId, true);\n          }\n        });\n      }\n\n      if (isHighDownPayload(payload)) {\n        allLeaveBlur(ecIns._api);\n      } // If dispatchAction before setOption, do nothing.\n\n\n      ecModel && ecModel.eachComponent(condition, function (model) {\n        if (!excludeSeriesIdMap || excludeSeriesIdMap.get(model.id) == null) {\n          if (isHighDownPayload(payload)) {\n            if (model instanceof SeriesModel) {\n              if (payload.type === HIGHLIGHT_ACTION_TYPE && !payload.notBlur) {\n                blurSeriesFromHighlightPayload(model, payload, ecIns._api);\n              }\n            } else {\n              var _a = findComponentHighDownDispatchers(model.mainType, model.componentIndex, payload.name, ecIns._api),\n                  focusSelf = _a.focusSelf,\n                  dispatchers = _a.dispatchers;\n\n              if (payload.type === HIGHLIGHT_ACTION_TYPE && focusSelf && !payload.notBlur) {\n                blurComponent(model.mainType, model.componentIndex, ecIns._api);\n              } // PENDING:\n              // Whether to put this \"enter emphasis\" code in `ComponentView`,\n              // which will be the same as `ChartView` but might be not necessary\n              // and will be far from this logic.\n\n\n              if (dispatchers) {\n                each(dispatchers, function (dispatcher) {\n                  payload.type === HIGHLIGHT_ACTION_TYPE ? enterEmphasis(dispatcher) : leaveEmphasis(dispatcher);\n                });\n              }\n            }\n          } else if (isSelectChangePayload(payload)) {\n            // TODO geo\n            if (model instanceof SeriesModel) {\n              toggleSelectionFromPayload(model, payload, ecIns._api);\n              updateSeriesElementSelection(model);\n              markStatusToUpdate(ecIns);\n            }\n          }\n\n          callView(ecIns[mainType === 'series' ? '_chartsMap' : '_componentsMap'][model.__viewId]);\n        }\n      }, ecIns);\n\n      function callView(view) {\n        view && view.__alive && view[method] && view[method](view.__model, ecModel, ecIns._api, payload);\n      }\n    };\n\n    updateMethods = {\n      prepareAndUpdate: function (payload) {\n        prepare(this);\n        updateMethods.update.call(this, payload);\n      },\n      update: function (payload) {\n        // console.profile && console.profile('update');\n        var ecModel = this._model;\n        var api = this._api;\n        var zr = this._zr;\n        var coordSysMgr = this._coordSysMgr;\n        var scheduler = this._scheduler; // update before setOption\n\n        if (!ecModel) {\n          return;\n        }\n\n        ecModel.setUpdatePayload(payload);\n        scheduler.restoreData(ecModel, payload);\n        scheduler.performSeriesTasks(ecModel); // TODO\n        // Save total ecModel here for undo/redo (after restoring data and before processing data).\n        // Undo (restoration of total ecModel) can be carried out in 'action' or outside API call.\n        // Create new coordinate system each update\n        // In LineView may save the old coordinate system and use it to get the orignal point\n\n        coordSysMgr.create(ecModel, api);\n        scheduler.performDataProcessorTasks(ecModel, payload); // Current stream render is not supported in data process. So we can update\n        // stream modes after data processing, where the filtered data is used to\n        // deteming whether use progressive rendering.\n\n        updateStreamModes(this, ecModel); // We update stream modes before coordinate system updated, then the modes info\n        // can be fetched when coord sys updating (consider the barGrid extent fix). But\n        // the drawback is the full coord info can not be fetched. Fortunately this full\n        // coord is not requied in stream mode updater currently.\n\n        coordSysMgr.update(ecModel, api);\n        clearColorPalette(ecModel);\n        scheduler.performVisualTasks(ecModel, payload);\n        render(this, ecModel, api, payload); // Set background\n\n        var backgroundColor = ecModel.get('backgroundColor') || 'transparent';\n        var darkMode = ecModel.get('darkMode'); // In IE8\n\n        if (!env.canvasSupported) {\n          var colorArr = colorTool.parse(backgroundColor);\n          backgroundColor = colorTool.stringify(colorArr, 'rgb');\n\n          if (colorArr[3] === 0) {\n            backgroundColor = 'transparent';\n          }\n        } else {\n          zr.setBackgroundColor(backgroundColor); // Force set dark mode.\n\n          if (darkMode != null && darkMode !== 'auto') {\n            zr.setDarkMode(darkMode);\n          }\n        }\n\n        performPostUpdateFuncs(ecModel, api); // console.profile && console.profileEnd('update');\n      },\n      updateTransform: function (payload) {\n        var _this = this;\n\n        var ecModel = this._model;\n        var api = this._api; // update before setOption\n\n        if (!ecModel) {\n          return;\n        }\n\n        ecModel.setUpdatePayload(payload); // ChartView.markUpdateMethod(payload, 'updateTransform');\n\n        var componentDirtyList = [];\n        ecModel.eachComponent(function (componentType, componentModel) {\n          if (componentType === 'series') {\n            return;\n          }\n\n          var componentView = _this.getViewOfComponentModel(componentModel);\n\n          if (componentView && componentView.__alive) {\n            if (componentView.updateTransform) {\n              var result = componentView.updateTransform(componentModel, ecModel, api, payload);\n              result && result.update && componentDirtyList.push(componentView);\n            } else {\n              componentDirtyList.push(componentView);\n            }\n          }\n        });\n        var seriesDirtyMap = zrUtil.createHashMap();\n        ecModel.eachSeries(function (seriesModel) {\n          var chartView = _this._chartsMap[seriesModel.__viewId];\n\n          if (chartView.updateTransform) {\n            var result = chartView.updateTransform(seriesModel, ecModel, api, payload);\n            result && result.update && seriesDirtyMap.set(seriesModel.uid, 1);\n          } else {\n            seriesDirtyMap.set(seriesModel.uid, 1);\n          }\n        });\n        clearColorPalette(ecModel); // Keep pipe to the exist pipeline because it depends on the render task of the full pipeline.\n        // this._scheduler.performVisualTasks(ecModel, payload, 'layout', true);\n\n        this._scheduler.performVisualTasks(ecModel, payload, {\n          setDirty: true,\n          dirtyMap: seriesDirtyMap\n        }); // Currently, not call render of components. Geo render cost a lot.\n        // renderComponents(ecIns, ecModel, api, payload, componentDirtyList);\n\n\n        renderSeries(this, ecModel, api, payload, seriesDirtyMap);\n        performPostUpdateFuncs(ecModel, this._api);\n      },\n      updateView: function (payload) {\n        var ecModel = this._model; // update before setOption\n\n        if (!ecModel) {\n          return;\n        }\n\n        ecModel.setUpdatePayload(payload);\n        ChartView.markUpdateMethod(payload, 'updateView');\n        clearColorPalette(ecModel); // Keep pipe to the exist pipeline because it depends on the render task of the full pipeline.\n\n        this._scheduler.performVisualTasks(ecModel, payload, {\n          setDirty: true\n        });\n\n        render(this, this._model, this._api, payload);\n        performPostUpdateFuncs(ecModel, this._api);\n      },\n      updateVisual: function (payload) {\n        // updateMethods.update.call(this, payload);\n        var _this = this;\n\n        var ecModel = this._model; // update before setOption\n\n        if (!ecModel) {\n          return;\n        }\n\n        ecModel.setUpdatePayload(payload); // clear all visual\n\n        ecModel.eachSeries(function (seriesModel) {\n          seriesModel.getData().clearAllVisual();\n        }); // Perform visual\n\n        ChartView.markUpdateMethod(payload, 'updateVisual');\n        clearColorPalette(ecModel); // Keep pipe to the exist pipeline because it depends on the render task of the full pipeline.\n\n        this._scheduler.performVisualTasks(ecModel, payload, {\n          visualType: 'visual',\n          setDirty: true\n        });\n\n        ecModel.eachComponent(function (componentType, componentModel) {\n          if (componentType !== 'series') {\n            var componentView = _this.getViewOfComponentModel(componentModel);\n\n            componentView && componentView.__alive && componentView.updateVisual(componentModel, ecModel, _this._api, payload);\n          }\n        });\n        ecModel.eachSeries(function (seriesModel) {\n          var chartView = _this._chartsMap[seriesModel.__viewId];\n          chartView.updateVisual(seriesModel, ecModel, _this._api, payload);\n        });\n        performPostUpdateFuncs(ecModel, this._api);\n      },\n      updateLayout: function (payload) {\n        updateMethods.update.call(this, payload);\n      }\n    };\n\n    doConvertPixel = function (ecIns, methodName, finder, value) {\n      if (ecIns._disposed) {\n        disposedWarning(ecIns.id);\n        return;\n      }\n\n      var ecModel = ecIns._model;\n\n      var coordSysList = ecIns._coordSysMgr.getCoordinateSystems();\n\n      var result;\n      var parsedFinder = modelUtil.parseFinder(ecModel, finder);\n\n      for (var i = 0; i < coordSysList.length; i++) {\n        var coordSys = coordSysList[i];\n\n        if (coordSys[methodName] && (result = coordSys[methodName](ecModel, parsedFinder, value)) != null) {\n          return result;\n        }\n      }\n\n      if (process.env.NODE_ENV !== 'production') {\n        console.warn('No coordinate system that supports ' + methodName + ' found by the given finder.');\n      }\n    };\n\n    updateStreamModes = function (ecIns, ecModel) {\n      var chartsMap = ecIns._chartsMap;\n      var scheduler = ecIns._scheduler;\n      ecModel.eachSeries(function (seriesModel) {\n        scheduler.updateStreamModes(seriesModel, chartsMap[seriesModel.__viewId]);\n      });\n    };\n\n    doDispatchAction = function (payload, silent) {\n      var _this = this;\n\n      var ecModel = this.getModel();\n      var payloadType = payload.type;\n      var escapeConnect = payload.escapeConnect;\n      var actionWrap = actions[payloadType];\n      var actionInfo = actionWrap.actionInfo;\n      var cptTypeTmp = (actionInfo.update || 'update').split(':');\n      var updateMethod = cptTypeTmp.pop();\n      var cptType = cptTypeTmp[0] != null && parseClassType(cptTypeTmp[0]);\n      this[IN_MAIN_PROCESS_KEY] = true;\n      var payloads = [payload];\n      var batched = false; // Batch action\n\n      if (payload.batch) {\n        batched = true;\n        payloads = zrUtil.map(payload.batch, function (item) {\n          item = zrUtil.defaults(zrUtil.extend({}, item), payload);\n          item.batch = null;\n          return item;\n        });\n      }\n\n      var eventObjBatch = [];\n      var eventObj;\n      var isSelectChange = isSelectChangePayload(payload);\n      var isHighDown = isHighDownPayload(payload);\n      each(payloads, function (batchItem) {\n        // Action can specify the event by return it.\n        eventObj = actionWrap.action(batchItem, _this._model, _this._api); // Emit event outside\n\n        eventObj = eventObj || zrUtil.extend({}, batchItem); // Convert type to eventType\n\n        eventObj.type = actionInfo.event || eventObj.type;\n        eventObjBatch.push(eventObj); // light update does not perform data process, layout and visual.\n\n        if (isHighDown) {\n          var _a = modelUtil.preParseFinder(payload),\n              queryOptionMap = _a.queryOptionMap,\n              mainTypeSpecified = _a.mainTypeSpecified;\n\n          var componentMainType = mainTypeSpecified ? queryOptionMap.keys()[0] : 'series';\n          updateDirectly(_this, updateMethod, batchItem, componentMainType);\n          markStatusToUpdate(_this);\n        } else if (isSelectChange) {\n          // At present `dispatchAction({ type: 'select', ... })` is not supported on components.\n          // geo still use 'geoselect'.\n          updateDirectly(_this, updateMethod, batchItem, 'series');\n          markStatusToUpdate(_this);\n        } else if (cptType) {\n          updateDirectly(_this, updateMethod, batchItem, cptType.main, cptType.sub);\n        }\n      });\n\n      if (updateMethod !== 'none' && !isHighDown && !isSelectChange && !cptType) {\n        // Still dirty\n        if (this[OPTION_UPDATED_KEY]) {\n          prepare(this);\n          updateMethods.update.call(this, payload);\n          this[OPTION_UPDATED_KEY] = false;\n        } else {\n          updateMethods[updateMethod].call(this, payload);\n        }\n      } // Follow the rule of action batch\n\n\n      if (batched) {\n        eventObj = {\n          type: actionInfo.event || payloadType,\n          escapeConnect: escapeConnect,\n          batch: eventObjBatch\n        };\n      } else {\n        eventObj = eventObjBatch[0];\n      }\n\n      this[IN_MAIN_PROCESS_KEY] = false;\n\n      if (!silent) {\n        var messageCenter = this._messageCenter;\n        messageCenter.trigger(eventObj.type, eventObj); // Extra triggered 'selectchanged' event\n\n        if (isSelectChange) {\n          var newObj = {\n            type: 'selectchanged',\n            escapeConnect: escapeConnect,\n            selected: getAllSelectedIndices(ecModel),\n            isFromClick: payload.isFromClick || false,\n            fromAction: payload.type,\n            fromActionPayload: payload\n          };\n          messageCenter.trigger(newObj.type, newObj);\n        }\n      }\n    };\n\n    flushPendingActions = function (silent) {\n      var pendingActions = this._pendingActions;\n\n      while (pendingActions.length) {\n        var payload = pendingActions.shift();\n        doDispatchAction.call(this, payload, silent);\n      }\n    };\n\n    triggerUpdatedEvent = function (silent) {\n      !silent && this.trigger('updated');\n    };\n    /**\n     * Event `rendered` is triggered when zr\n     * rendered. It is useful for realtime\n     * snapshot (reflect animation).\n     *\n     * Event `finished` is triggered when:\n     * (1) zrender rendering finished.\n     * (2) initial animation finished.\n     * (3) progressive rendering finished.\n     * (4) no pending action.\n     * (5) no delayed setOption needs to be processed.\n     */\n\n\n    bindRenderedEvent = function (zr, ecIns) {\n      zr.on('rendered', function (params) {\n        ecIns.trigger('rendered', params); // The `finished` event should not be triggered repeatly,\n        // so it should only be triggered when rendering indeed happend\n        // in zrender. (Consider the case that dipatchAction is keep\n        // triggering when mouse move).\n\n        if ( // Although zr is dirty if initial animation is not finished\n        // and this checking is called on frame, we also check\n        // animation finished for robustness.\n        zr.animation.isFinished() && !ecIns[OPTION_UPDATED_KEY] && !ecIns._scheduler.unfinished && !ecIns._pendingActions.length) {\n          ecIns.trigger('finished');\n        }\n      });\n    };\n\n    bindMouseEvent = function (zr, ecIns) {\n      zr.on('mouseover', function (e) {\n        var el = e.target;\n        var dispatcher = findEventDispatcher(el, isHighDownDispatcher);\n\n        if (dispatcher) {\n          handleGlobalMouseOverForHighDown(dispatcher, e, ecIns._api);\n          markStatusToUpdate(ecIns);\n        }\n      }).on('mouseout', function (e) {\n        var el = e.target;\n        var dispatcher = findEventDispatcher(el, isHighDownDispatcher);\n\n        if (dispatcher) {\n          handleGlboalMouseOutForHighDown(dispatcher, e, ecIns._api);\n          markStatusToUpdate(ecIns);\n        }\n      }).on('click', function (e) {\n        var el = e.target;\n        var dispatcher = findEventDispatcher(el, function (target) {\n          return getECData(target).dataIndex != null;\n        }, true);\n\n        if (dispatcher) {\n          var actionType = dispatcher.selected ? 'unselect' : 'select';\n          var ecData = getECData(dispatcher);\n\n          ecIns._api.dispatchAction({\n            type: actionType,\n            dataType: ecData.dataType,\n            dataIndexInside: ecData.dataIndex,\n            seriesIndex: ecData.seriesIndex,\n            isFromClick: true\n          });\n        }\n      });\n    };\n\n    clearColorPalette = function (ecModel) {\n      ecModel.clearColorPalette();\n      ecModel.eachSeries(function (seriesModel) {\n        seriesModel.clearColorPalette();\n      });\n    };\n\n    render = function (ecIns, ecModel, api, payload) {\n      renderComponents(ecIns, ecModel, api, payload);\n      each(ecIns._chartsViews, function (chart) {\n        chart.__alive = false;\n      });\n      renderSeries(ecIns, ecModel, api, payload); // Remove groups of unrendered charts\n\n      each(ecIns._chartsViews, function (chart) {\n        if (!chart.__alive) {\n          chart.remove(ecModel, api);\n        }\n      });\n    };\n\n    renderComponents = function (ecIns, ecModel, api, payload, dirtyList) {\n      each(dirtyList || ecIns._componentsViews, function (componentView) {\n        var componentModel = componentView.__model;\n        clearStates(componentModel, componentView);\n        componentView.render(componentModel, ecModel, api, payload);\n        updateZ(componentModel, componentView);\n        updateStates(componentModel, componentView);\n      });\n    };\n    /**\n     * Render each chart and component\n     */\n\n\n    renderSeries = function (ecIns, ecModel, api, payload, dirtyMap) {\n      // Render all charts\n      var scheduler = ecIns._scheduler;\n      var labelManager = ecIns._labelManager;\n      labelManager.clearLabels();\n      var unfinished = false;\n      ecModel.eachSeries(function (seriesModel) {\n        var chartView = ecIns._chartsMap[seriesModel.__viewId];\n        chartView.__alive = true;\n        var renderTask = chartView.renderTask;\n        scheduler.updatePayload(renderTask, payload); // TODO states on marker.\n\n        clearStates(seriesModel, chartView);\n\n        if (dirtyMap && dirtyMap.get(seriesModel.uid)) {\n          renderTask.dirty();\n        }\n\n        if (renderTask.perform(scheduler.getPerformArgs(renderTask))) {\n          unfinished = true;\n        }\n\n        seriesModel.__transientTransitionOpt = null;\n        chartView.group.silent = !!seriesModel.get('silent'); // Should not call markRedraw on group, because it will disable zrender\n        // increamental render (alway render from the __startIndex each frame)\n        // chartView.group.markRedraw();\n\n        updateBlend(seriesModel, chartView);\n        updateSeriesElementSelection(seriesModel); // Add labels.\n\n        labelManager.addLabelsOfSeries(chartView);\n      });\n      scheduler.unfinished = unfinished || scheduler.unfinished;\n      labelManager.updateLayoutConfig(api);\n      labelManager.layout(api);\n      labelManager.processLabelsOverall();\n      ecModel.eachSeries(function (seriesModel) {\n        var chartView = ecIns._chartsMap[seriesModel.__viewId]; // Update Z after labels updated. Before applying states.\n\n        updateZ(seriesModel, chartView); // NOTE: Update states after label is updated.\n        // label should be in normal status when layouting.\n\n        updateStates(seriesModel, chartView);\n      }); // If use hover layer\n\n      updateHoverLayerStatus(ecIns, ecModel);\n    };\n\n    performPostUpdateFuncs = function (ecModel, api) {\n      each(postUpdateFuncs, function (func) {\n        func(ecModel, api);\n      });\n    };\n\n    markStatusToUpdate = function (ecIns) {\n      ecIns[STATUS_NEEDS_UPDATE_KEY] = true; // Wake up zrender if it's sleep. Let it update states in the next frame.\n\n      ecIns.getZr().wakeUp();\n    };\n\n    applyChangedStates = function (ecIns) {\n      if (!ecIns[STATUS_NEEDS_UPDATE_KEY]) {\n        return;\n      }\n\n      ecIns.getZr().storage.traverse(function (el) {\n        // Not applied on removed elements, it may still in fading.\n        if (graphic.isElementRemoved(el)) {\n          return;\n        }\n\n        applyElementStates(el);\n      });\n      ecIns[STATUS_NEEDS_UPDATE_KEY] = false;\n    };\n\n    function applyElementStates(el) {\n      var newStates = [];\n      var oldStates = el.currentStates; // Keep other states.\n\n      for (var i = 0; i < oldStates.length; i++) {\n        var stateName = oldStates[i];\n\n        if (!(stateName === 'emphasis' || stateName === 'blur' || stateName === 'select')) {\n          newStates.push(stateName);\n        }\n      } // Only use states when it's exists.\n\n\n      if (el.selected && el.states.select) {\n        newStates.push('select');\n      }\n\n      if (el.hoverState === HOVER_STATE_EMPHASIS && el.states.emphasis) {\n        newStates.push('emphasis');\n      } else if (el.hoverState === HOVER_STATE_BLUR && el.states.blur) {\n        newStates.push('blur');\n      }\n\n      el.useStates(newStates);\n    }\n\n    function updateHoverLayerStatus(ecIns, ecModel) {\n      var zr = ecIns._zr;\n      var storage = zr.storage;\n      var elCount = 0;\n      storage.traverse(function (el) {\n        if (!el.isGroup) {\n          elCount++;\n        }\n      });\n\n      if (elCount > ecModel.get('hoverLayerThreshold') && !env.node && !env.worker) {\n        ecModel.eachSeries(function (seriesModel) {\n          if (seriesModel.preventUsingHoverLayer) {\n            return;\n          }\n\n          var chartView = ecIns._chartsMap[seriesModel.__viewId];\n\n          if (chartView.__alive) {\n            chartView.group.traverse(function (el) {\n              if (el.states.emphasis) {\n                el.states.emphasis.hoverLayer = true;\n              }\n            });\n          }\n        });\n      }\n    }\n\n    ;\n    /**\n     * Update chart and blend.\n     */\n\n    function updateBlend(seriesModel, chartView) {\n      var blendMode = seriesModel.get('blendMode') || null;\n\n      if (process.env.NODE_ENV !== 'production') {\n        if (!env.canvasSupported && blendMode && blendMode !== 'source-over') {\n          console.warn('Only canvas support blendMode');\n        }\n      }\n\n      chartView.group.traverse(function (el) {\n        // FIXME marker and other components\n        if (!el.isGroup) {\n          // DONT mark the element dirty. In case element is incremental and don't wan't to rerender.\n          el.style.blend = blendMode;\n        }\n\n        if (el.eachPendingDisplayable) {\n          el.eachPendingDisplayable(function (displayable) {\n            displayable.style.blend = blendMode;\n          });\n        }\n      });\n    }\n\n    ;\n\n    function updateZ(model, view) {\n      if (model.preventAutoZ) {\n        return;\n      } // Set z and zlevel\n\n\n      _updateZ(view.group, model.get('z') || 0, model.get('zlevel') || 0, -Infinity);\n    }\n\n    ;\n\n    function _updateZ(el, z, zlevel, maxZ2) {\n      // Group may also have textContent\n      var label = el.getTextContent();\n      var labelLine = el.getTextGuideLine();\n      var isGroup = el.isGroup;\n\n      if (isGroup) {\n        // set z & zlevel of children elements of Group\n        // el.traverse((childEl: Element) => _updateZ(childEl, z, zlevel));\n        var children = el.childrenRef();\n\n        for (var i = 0; i < children.length; i++) {\n          maxZ2 = Math.max(_updateZ(children[i], z, zlevel, maxZ2), maxZ2);\n        }\n      } else {\n        // not Group\n        el.z = z;\n        el.zlevel = zlevel;\n        maxZ2 = Math.max(el.z2, maxZ2);\n      } // always set z and zlevel if label/labelLine exists\n\n\n      if (label) {\n        label.z = z;\n        label.zlevel = zlevel; // lift z2 of text content\n        // TODO if el.emphasis.z2 is spcefied, what about textContent.\n\n        isFinite(maxZ2) && (label.z2 = maxZ2 + 2);\n      }\n\n      if (labelLine) {\n        var textGuideLineConfig = el.textGuideLineConfig;\n        labelLine.z = z;\n        labelLine.zlevel = zlevel;\n        isFinite(maxZ2) && (labelLine.z2 = maxZ2 + (textGuideLineConfig && textGuideLineConfig.showAbove ? 1 : -1));\n      }\n\n      return maxZ2;\n    } // Clear states without animation.\n    // TODO States on component.\n\n\n    function clearStates(model, view) {\n      view.group.traverse(function (el) {\n        // Not applied on removed elements, it may still in fading.\n        if (graphic.isElementRemoved(el)) {\n          return;\n        }\n\n        var textContent = el.getTextContent();\n        var textGuide = el.getTextGuideLine();\n\n        if (el.stateTransition) {\n          el.stateTransition = null;\n        }\n\n        if (textContent && textContent.stateTransition) {\n          textContent.stateTransition = null;\n        }\n\n        if (textGuide && textGuide.stateTransition) {\n          textGuide.stateTransition = null;\n        } // TODO If el is incremental.\n\n\n        if (el.hasState()) {\n          el.prevStates = el.currentStates;\n          el.clearStates();\n        } else if (el.prevStates) {\n          el.prevStates = null;\n        }\n      });\n    }\n\n    function updateStates(model, view) {\n      var stateAnimationModel = model.getModel('stateAnimation');\n      var enableAnimation = model.isAnimationEnabled();\n      var duration = stateAnimationModel.get('duration');\n      var stateTransition = duration > 0 ? {\n        duration: duration,\n        delay: stateAnimationModel.get('delay'),\n        easing: stateAnimationModel.get('easing') // additive: stateAnimationModel.get('additive')\n\n      } : null;\n      view.group.traverse(function (el) {\n        if (el.states && el.states.emphasis) {\n          // Not applied on removed elements, it may still in fading.\n          if (graphic.isElementRemoved(el)) {\n            return;\n          }\n\n          if (el instanceof graphic.Path) {\n            savePathStates(el);\n          } // Only updated on changed element. In case element is incremental and don't wan't to rerender.\n          // TODO, a more proper way?\n\n\n          if (el.__dirty) {\n            var prevStates = el.prevStates; // Restore states without animation\n\n            if (prevStates) {\n              el.useStates(prevStates);\n            }\n          } // Update state transition and enable animation again.\n\n\n          if (enableAnimation) {\n            el.stateTransition = stateTransition;\n            var textContent = el.getTextContent();\n            var textGuide = el.getTextGuideLine(); // TODO Is it necessary to animate label?\n\n            if (textContent) {\n              textContent.stateTransition = stateTransition;\n            }\n\n            if (textGuide) {\n              textGuide.stateTransition = stateTransition;\n            }\n          } // The use higlighted and selected flag to toggle states.\n\n\n          if (el.__dirty) {\n            applyElementStates(el);\n          }\n        }\n      });\n    }\n\n    ;\n\n    createExtensionAPI = function (ecIns) {\n      return new (\n      /** @class */\n      function (_super) {\n        __extends(class_1, _super);\n\n        function class_1() {\n          return _super !== null && _super.apply(this, arguments) || this;\n        }\n\n        class_1.prototype.getCoordinateSystems = function () {\n          return ecIns._coordSysMgr.getCoordinateSystems();\n        };\n\n        class_1.prototype.getComponentByElement = function (el) {\n          while (el) {\n            var modelInfo = el.__ecComponentInfo;\n\n            if (modelInfo != null) {\n              return ecIns._model.getComponent(modelInfo.mainType, modelInfo.index);\n            }\n\n            el = el.parent;\n          }\n        };\n\n        class_1.prototype.enterEmphasis = function (el, highlightDigit) {\n          enterEmphasis(el, highlightDigit);\n          markStatusToUpdate(ecIns);\n        };\n\n        class_1.prototype.leaveEmphasis = function (el, highlightDigit) {\n          leaveEmphasis(el, highlightDigit);\n          markStatusToUpdate(ecIns);\n        };\n\n        class_1.prototype.enterBlur = function (el) {\n          enterBlur(el);\n          markStatusToUpdate(ecIns);\n        };\n\n        class_1.prototype.leaveBlur = function (el) {\n          leaveBlur(el);\n          markStatusToUpdate(ecIns);\n        };\n\n        class_1.prototype.enterSelect = function (el) {\n          enterSelect(el);\n          markStatusToUpdate(ecIns);\n        };\n\n        class_1.prototype.leaveSelect = function (el) {\n          leaveSelect(el);\n          markStatusToUpdate(ecIns);\n        };\n\n        class_1.prototype.getModel = function () {\n          return ecIns.getModel();\n        };\n\n        class_1.prototype.getViewOfComponentModel = function (componentModel) {\n          return ecIns.getViewOfComponentModel(componentModel);\n        };\n\n        class_1.prototype.getViewOfSeriesModel = function (seriesModel) {\n          return ecIns.getViewOfSeriesModel(seriesModel);\n        };\n\n        return class_1;\n      }(ExtensionAPI))(ecIns);\n    };\n\n    enableConnect = function (chart) {\n      function updateConnectedChartsStatus(charts, status) {\n        for (var i = 0; i < charts.length; i++) {\n          var otherChart = charts[i];\n          otherChart[CONNECT_STATUS_KEY] = status;\n        }\n      }\n\n      each(eventActionMap, function (actionType, eventType) {\n        chart._messageCenter.on(eventType, function (event) {\n          if (connectedGroups[chart.group] && chart[CONNECT_STATUS_KEY] !== CONNECT_STATUS_PENDING) {\n            if (event && event.escapeConnect) {\n              return;\n            }\n\n            var action_1 = chart.makeActionFromEvent(event);\n            var otherCharts_1 = [];\n            each(instances, function (otherChart) {\n              if (otherChart !== chart && otherChart.group === chart.group) {\n                otherCharts_1.push(otherChart);\n              }\n            });\n            updateConnectedChartsStatus(otherCharts_1, CONNECT_STATUS_PENDING);\n            each(otherCharts_1, function (otherChart) {\n              if (otherChart[CONNECT_STATUS_KEY] !== CONNECT_STATUS_UPDATING) {\n                otherChart.dispatchAction(action_1);\n              }\n            });\n            updateConnectedChartsStatus(otherCharts_1, CONNECT_STATUS_UPDATED);\n          }\n        });\n      });\n    };\n\n    setTransitionOpt = function (chart, transitionOpt) {\n      var ecModel = chart._model;\n      zrUtil.each(modelUtil.normalizeToArray(transitionOpt), function (transOpt) {\n        var errMsg;\n        var fromOpt = transOpt.from;\n        var toOpt = transOpt.to;\n\n        if (toOpt == null) {\n          if (process.env.NODE_ENV !== 'production') {\n            errMsg = '`transition.to` must be specified.';\n          }\n\n          throwError(errMsg);\n        }\n\n        var finderOpt = {\n          includeMainTypes: ['series'],\n          enableAll: false,\n          enableNone: false\n        };\n        var fromResult = fromOpt ? modelUtil.parseFinder(ecModel, fromOpt, finderOpt) : null;\n        var toResult = modelUtil.parseFinder(ecModel, toOpt, finderOpt);\n        var toSeries = toResult.seriesModel;\n\n        if (toSeries == null) {\n          errMsg = '';\n\n          if (process.env.NODE_ENV !== 'production') {\n            errMsg = '`transition` is only supported on series.';\n          }\n        }\n\n        if (fromResult && fromResult.seriesModel !== toSeries) {\n          errMsg = '';\n\n          if (process.env.NODE_ENV !== 'production') {\n            errMsg = '`transition.from` and `transition.to` must be specified to the same series.';\n          }\n        }\n\n        if (errMsg != null) {\n          throwError(errMsg);\n        } // Just a temp solution: mount them on series.\n\n\n        toSeries.__transientTransitionOpt = {\n          from: fromOpt ? fromOpt.dimension : null,\n          to: toOpt.dimension,\n          dividingMethod: transOpt.dividingMethod\n        };\n      });\n    };\n  }();\n\n  return ECharts;\n}(Eventful);\n\nvar echartsProto = ECharts.prototype;\nechartsProto.on = createRegisterEventWithLowercaseECharts('on');\nechartsProto.off = createRegisterEventWithLowercaseECharts('off');\n/**\n * @deprecated\n */\n// @ts-ignore\n\nechartsProto.one = function (eventName, cb, ctx) {\n  var self = this;\n  deprecateLog('ECharts#one is deprecated.');\n\n  function wrapped() {\n    var args2 = [];\n\n    for (var _i = 0; _i < arguments.length; _i++) {\n      args2[_i] = arguments[_i];\n    }\n\n    cb && cb.apply && cb.apply(this, args2); // @ts-ignore\n\n    self.off(eventName, wrapped);\n  }\n\n  ; // @ts-ignore\n\n  this.on.call(this, eventName, wrapped, ctx);\n}; // /**\n//  * Encode visual infomation from data after data processing\n//  *\n//  * @param {module:echarts/model/Global} ecModel\n//  * @param {object} layout\n//  * @param {boolean} [layoutFilter] `true`: only layout,\n//  *                                 `false`: only not layout,\n//  *                                 `null`/`undefined`: all.\n//  * @param {string} taskBaseTag\n//  * @private\n//  */\n// function startVisualEncoding(ecIns, ecModel, api, payload, layoutFilter) {\n//     each(visualFuncs, function (visual, index) {\n//         let isLayout = visual.isLayout;\n//         if (layoutFilter == null\n//             || (layoutFilter === false && !isLayout)\n//             || (layoutFilter === true && isLayout)\n//         ) {\n//             visual.func(ecModel, api, payload);\n//         }\n//     });\n// }\n\n\nvar MOUSE_EVENT_NAMES = ['click', 'dblclick', 'mouseover', 'mouseout', 'mousemove', 'mousedown', 'mouseup', 'globalout', 'contextmenu'];\n\nfunction disposedWarning(id) {\n  if (process.env.NODE_ENV !== 'production') {\n    console.warn('Instance ' + id + ' has been disposed');\n  }\n}\n\nvar actions = {};\n/**\n * Map eventType to actionType\n */\n\nvar eventActionMap = {};\nvar dataProcessorFuncs = [];\nvar optionPreprocessorFuncs = [];\nvar postInitFuncs = [];\nvar postUpdateFuncs = [];\nvar visualFuncs = [];\nvar themeStorage = {};\nvar loadingEffects = {};\nvar instances = {};\nvar connectedGroups = {};\nvar idBase = +new Date() - 0;\nvar groupIdBase = +new Date() - 0;\nvar DOM_ATTRIBUTE_KEY = '_echarts_instance_';\n/**\n * @param opts.devicePixelRatio Use window.devicePixelRatio by default\n * @param opts.renderer Can choose 'canvas' or 'svg' to render the chart.\n * @param opts.width Use clientWidth of the input `dom` by default.\n *        Can be 'auto' (the same as null/undefined)\n * @param opts.height Use clientHeight of the input `dom` by default.\n *        Can be 'auto' (the same as null/undefined)\n */\n\nexport function init(dom, theme, opts) {\n  if (process.env.NODE_ENV !== 'production') {\n    if (!dom) {\n      throw new Error('Initialize failed: invalid dom.');\n    }\n  }\n\n  var existInstance = getInstanceByDom(dom);\n\n  if (existInstance) {\n    if (process.env.NODE_ENV !== 'production') {\n      console.warn('There is a chart instance already initialized on the dom.');\n    }\n\n    return existInstance;\n  }\n\n  if (process.env.NODE_ENV !== 'production') {\n    if (zrUtil.isDom(dom) && dom.nodeName.toUpperCase() !== 'CANVAS' && (!dom.clientWidth && (!opts || opts.width == null) || !dom.clientHeight && (!opts || opts.height == null))) {\n      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.');\n    }\n  }\n\n  var chart = new ECharts(dom, theme, opts);\n  chart.id = 'ec_' + idBase++;\n  instances[chart.id] = chart;\n  modelUtil.setAttribute(dom, DOM_ATTRIBUTE_KEY, chart.id);\n  enableConnect(chart);\n  each(postInitFuncs, function (postInitFunc) {\n    postInitFunc(chart);\n  });\n  return chart;\n}\n/**\n * @usage\n * (A)\n * ```js\n * let chart1 = echarts.init(dom1);\n * let chart2 = echarts.init(dom2);\n * chart1.group = 'xxx';\n * chart2.group = 'xxx';\n * echarts.connect('xxx');\n * ```\n * (B)\n * ```js\n * let chart1 = echarts.init(dom1);\n * let chart2 = echarts.init(dom2);\n * echarts.connect('xxx', [chart1, chart2]);\n * ```\n */\n\nexport function connect(groupId) {\n  // Is array of charts\n  if (zrUtil.isArray(groupId)) {\n    var charts = groupId;\n    groupId = null; // If any chart has group\n\n    each(charts, function (chart) {\n      if (chart.group != null) {\n        groupId = chart.group;\n      }\n    });\n    groupId = groupId || 'g_' + groupIdBase++;\n    each(charts, function (chart) {\n      chart.group = groupId;\n    });\n  }\n\n  connectedGroups[groupId] = true;\n  return groupId;\n}\n/**\n * @deprecated\n */\n\nexport function disConnect(groupId) {\n  connectedGroups[groupId] = false;\n}\n/**\n * Alias and backword compat\n */\n\nexport var disconnect = disConnect;\n/**\n * Dispose a chart instance\n */\n\nexport function dispose(chart) {\n  if (typeof chart === 'string') {\n    chart = instances[chart];\n  } else if (!(chart instanceof ECharts)) {\n    // Try to treat as dom\n    chart = getInstanceByDom(chart);\n  }\n\n  if (chart instanceof ECharts && !chart.isDisposed()) {\n    chart.dispose();\n  }\n}\nexport function getInstanceByDom(dom) {\n  return instances[modelUtil.getAttribute(dom, DOM_ATTRIBUTE_KEY)];\n}\nexport function getInstanceById(key) {\n  return instances[key];\n}\n/**\n * Register theme\n */\n\nexport function registerTheme(name, theme) {\n  themeStorage[name] = theme;\n}\n/**\n * Register option preprocessor\n */\n\nexport function registerPreprocessor(preprocessorFunc) {\n  if (indexOf(optionPreprocessorFuncs, preprocessorFunc) < 0) {\n    optionPreprocessorFuncs.push(preprocessorFunc);\n  }\n}\nexport function registerProcessor(priority, processor) {\n  normalizeRegister(dataProcessorFuncs, priority, processor, PRIORITY_PROCESSOR_DEFAULT);\n}\n/**\n * Register postIniter\n * @param {Function} postInitFunc\n */\n\nexport function registerPostInit(postInitFunc) {\n  if (indexOf(postInitFuncs, postInitFunc) < 0) {\n    postInitFunc && postInitFuncs.push(postInitFunc);\n  }\n}\n/**\n * Register postUpdater\n * @param {Function} postUpdateFunc\n */\n\nexport function registerPostUpdate(postUpdateFunc) {\n  if (indexOf(postUpdateFuncs, postUpdateFunc) < 0) {\n    postUpdateFunc && postUpdateFuncs.push(postUpdateFunc);\n  }\n}\nexport function registerAction(actionInfo, eventName, action) {\n  if (typeof eventName === 'function') {\n    action = eventName;\n    eventName = '';\n  }\n\n  var actionType = isObject(actionInfo) ? actionInfo.type : [actionInfo, actionInfo = {\n    event: eventName\n  }][0]; // Event name is all lowercase\n\n  actionInfo.event = (actionInfo.event || actionType).toLowerCase();\n  eventName = actionInfo.event;\n\n  if (eventActionMap[eventName]) {\n    // Already registered.\n    return;\n  } // Validate action type and event name.\n\n\n  assert(ACTION_REG.test(actionType) && ACTION_REG.test(eventName));\n\n  if (!actions[actionType]) {\n    actions[actionType] = {\n      action: action,\n      actionInfo: actionInfo\n    };\n  }\n\n  eventActionMap[eventName] = actionType;\n}\nexport function registerCoordinateSystem(type, coordSysCreator) {\n  CoordinateSystemManager.register(type, coordSysCreator);\n}\n/**\n * Get dimensions of specified coordinate system.\n * @param {string} type\n * @return {Array.<string|Object>}\n */\n\nexport function getCoordinateSystemDimensions(type) {\n  var coordSysCreator = CoordinateSystemManager.get(type);\n\n  if (coordSysCreator) {\n    return coordSysCreator.getDimensionsInfo ? coordSysCreator.getDimensionsInfo() : coordSysCreator.dimensions.slice();\n  }\n}\nexport { registerLocale } from './locale';\n\nfunction registerLayout(priority, layoutTask) {\n  normalizeRegister(visualFuncs, priority, layoutTask, PRIORITY_VISUAL_LAYOUT, 'layout');\n}\n\nfunction registerVisual(priority, visualTask) {\n  normalizeRegister(visualFuncs, priority, visualTask, PRIORITY_VISUAL_CHART, 'visual');\n}\n\nexport { registerLayout, registerVisual };\nvar registeredTasks = [];\n\nfunction normalizeRegister(targetList, priority, fn, defaultPriority, visualType) {\n  if (isFunction(priority) || isObject(priority)) {\n    fn = priority;\n    priority = defaultPriority;\n  }\n\n  if (process.env.NODE_ENV !== 'production') {\n    if (isNaN(priority) || priority == null) {\n      throw new Error('Illegal priority');\n    } // Check duplicate\n\n\n    each(targetList, function (wrap) {\n      assert(wrap.__raw !== fn);\n    });\n  } // Already registered\n\n\n  if (indexOf(registeredTasks, fn) >= 0) {\n    return;\n  }\n\n  registeredTasks.push(fn);\n  var stageHandler = Scheduler.wrapStageHandler(fn, visualType);\n  stageHandler.__prio = priority;\n  stageHandler.__raw = fn;\n  targetList.push(stageHandler);\n}\n\nexport function registerLoading(name, loadingFx) {\n  loadingEffects[name] = loadingFx;\n}\n/**\n * ZRender need a canvas context to do measureText.\n * But in node environment canvas may be created by node-canvas.\n * So we need to specify how to create a canvas instead of using document.createElement('canvas')\n *\n * Be careful of using it in the browser.\n *\n * @example\n *     let Canvas = require('canvas');\n *     let echarts = require('echarts');\n *     echarts.setCanvasCreator(function () {\n *         // Small size is enough.\n *         return new Canvas(32, 32);\n *     });\n */\n\nexport function setCanvasCreator(creator) {\n  zrUtil.$override('createCanvas', creator);\n}\n/**\n * The parameters and usage: see `geoSourceManager.registerMap`.\n * Compatible with previous `echarts.registerMap`.\n */\n\nexport function registerMap(mapName, geoJson, specialAreas) {\n  geoSourceManager.registerMap(mapName, geoJson, specialAreas);\n}\nexport function getMap(mapName) {\n  return geoSourceManager.getMapForUser(mapName);\n}\nexport var registerTransform = registerExternalTransform;\n/**\n * Globa dispatchAction to a specified chart instance.\n */\n// export function dispatchAction(payload: { chartId: string } & Payload, opt?: Parameters<ECharts['dispatchAction']>[1]) {\n//     if (!payload || !payload.chartId) {\n//         // Must have chartId to find chart\n//         return;\n//     }\n//     const chart = instances[payload.chartId];\n//     if (chart) {\n//         chart.dispatchAction(payload, opt);\n//     }\n// }\n// Buitlin global visual\n\nregisterVisual(PRIORITY_VISUAL_GLOBAL, seriesStyleTask);\nregisterVisual(PRIORITY_VISUAL_CHART_DATA_CUSTOM, dataStyleTask);\nregisterVisual(PRIORITY_VISUAL_CHART_DATA_CUSTOM, dataColorPaletteTask);\nregisterVisual(PRIORITY_VISUAL_GLOBAL, seriesSymbolTask);\nregisterVisual(PRIORITY_VISUAL_CHART_DATA_CUSTOM, dataSymbolTask);\nregisterVisual(PRIORITY_VISUAL_DECAL, decal);\nregisterPreprocessor(backwardCompat);\nregisterProcessor(PRIORITY_PROCESSOR_DATASTACK, dataStack);\nregisterLoading('default', loadingDefault); // Default actions\n\nregisterAction({\n  type: HIGHLIGHT_ACTION_TYPE,\n  event: HIGHLIGHT_ACTION_TYPE,\n  update: HIGHLIGHT_ACTION_TYPE\n}, zrUtil.noop);\nregisterAction({\n  type: DOWNPLAY_ACTION_TYPE,\n  event: DOWNPLAY_ACTION_TYPE,\n  update: DOWNPLAY_ACTION_TYPE\n}, zrUtil.noop);\nregisterAction({\n  type: SELECT_ACTION_TYPE,\n  event: SELECT_ACTION_TYPE,\n  update: SELECT_ACTION_TYPE\n}, zrUtil.noop);\nregisterAction({\n  type: UNSELECT_ACTION_TYPE,\n  event: UNSELECT_ACTION_TYPE,\n  update: UNSELECT_ACTION_TYPE\n}, zrUtil.noop);\nregisterAction({\n  type: TOGGLE_SELECT_ACTION_TYPE,\n  event: TOGGLE_SELECT_ACTION_TYPE,\n  update: TOGGLE_SELECT_ACTION_TYPE\n}, zrUtil.noop); // Default theme\n\nregisterTheme('light', lightTheme);\nregisterTheme('dark', darkTheme); // For backward compatibility, where the namespace `dataTool` will\n// be mounted on `echarts` is the extension `dataTool` is imported.\n\nexport var dataTool = {};"],"sourceRoot":""}